[cvs] / xvidcore / examples / xvid_bench.c Repository:
ViewVC logotype

Diff of /xvidcore/examples/xvid_bench.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.9.2.8, Wed Nov 19 21:27:25 2003 UTC revision 1.22, Wed Jun 15 06:07:28 2005 UTC
# Line 26  Line 26 
26  /*****************************************************************************  /*****************************************************************************
27   *   *
28   *  'Reference' output is at the end of file.   *  'Reference' output is at the end of file.
  *  Don't take the checksums and crc too seriouly, they aren't  
  *  bullet-proof (should plug some .md5 here)...  
29   *   *
30   *   compiles with something like:   *   compiles with something like:
31   *   gcc -o xvid_bench xvid_bench.c  -I../src/ -lxvidcore -lm   *   gcc -o xvid_bench xvid_bench.c  -I../src/ -lxvidcore -lm
# Line 67  Line 65 
65  #define M_PI            3.14159265358979323846  #define M_PI            3.14159265358979323846
66  #endif  #endif
67    
68  const int speed_ref = 100;  /* on slow machines, decrease this value */  int speed_ref = 100;  /* on slow machines, decrease this value */
69    int verbose = 0;
70    unsigned int cpu_mask;
71    
72  /*********************************************************************  /*********************************************************************
73   * misc   * misc
# Line 83  Line 83 
83  #else  #else
84          clock_t clk;          clock_t clk;
85          clk = clock();          clk = clock();
86          return clk * 1000000 / CLOCKS_PER_SEC;          return clk * 1000. / CLOCKS_PER_SEC;  /* clock() returns time in Milliseconds */
87  #endif  #endif
88  }  }
89    
# Line 112  Line 112 
112          unsigned int cpu;          unsigned int cpu;
113  } CPU;  } CPU;
114    
115  CPU cpu_list[] =  CPU cpu_list[] = {
116  { { "PLAINC", 0 }          { "PLAINC ", 0 },
117  #ifdef ARCH_IS_IA32  #ifdef ARCH_IS_IA32
118    , { "MMX   ", XVID_CPU_MMX }          { "MMX    ", XVID_CPU_MMX },
119    , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }          { "MMXEXT ", XVID_CPU_MMXEXT | XVID_CPU_MMX },
120    , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }          { "SSE2   ", XVID_CPU_SSE2 | XVID_CPU_MMX },
121    , { "3DNOW ", XVID_CPU_3DNOW }          { "3DNOW  ", XVID_CPU_3DNOW },
122    , { "3DNOWE", XVID_CPU_3DNOWEXT }          { "3DNOWE ", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT },
123  #endif  #endif
124  //, { "IA64  ", XVID_CPU_IA64 }  #ifdef ARCH_IS_PPC
125  //, { "TSC   ", XVID_CPU_TSC }          { "ALTIVEC", XVID_CPU_ALTIVEC },
   , { 0, 0 } };  
   
 CPU  cpu_short_list[] =  
 { { "PLAINC", 0 }  
 #ifdef ARCH_IS_IA32  
   , { "MMX   ", XVID_CPU_MMX }  
 //, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }  
126  #endif  #endif
127  //, { "IA64  ", XVID_CPU_IA64 }  #ifdef ARCH_IS_X86_64
128    , { 0, 0 } };          { "X86_64 ", XVID_CPU_ASM},
129    #endif
130  CPU cpu_short_list2[] =  #ifdef ARCH_IS_IA64
131  { { "PLAINC", 0 }  //      { "IA64   ", XVID_CPU_IA64 },
 #ifdef ARCH_IS_IA32  
   , { "MMX   ", XVID_CPU_MMX }  
   , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  
132  #endif  #endif
133    , { 0, 0 } };  //      { "TSC    ", XVID_CPU_TSC },
134            { 0, 0 }
135    };
136    
137    
138  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
# Line 171  Line 163 
163          return 1;          return 1;
164  }  }
165    
166    #define CRC32_REMAINDER 0xCBF43926
167    #define CRC32_INITIAL 0xffffffff
168    
169    #define DO1(c, crc) ((crc) = crc32tab[((unsigned int)((crc)>>24) ^ (*c++)) & 0xff] ^ ((crc) << 8))
170    #define DO2(c, crc)  DO1(c, crc); DO1(c, crc);
171    #define DO4(c, crc)  DO2(c, crc); DO2(c, crc);
172    #define DO8(c, crc)  DO4(c, crc); DO4(c, crc);
173    
174    /******************************************************************************
175    * Precomputed AAL5 CRC32 lookup table
176    ******************************************************************************/
177    
178    static unsigned long crc32tab[256] = {
179    
180            0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
181            0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
182            0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
183            0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
184            0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
185            0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
186            0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
187            0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
188            0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
189            0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
190            0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
191            0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
192            0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
193            0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
194            0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
195            0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
196            0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
197            0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
198            0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
199            0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
200            0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
201            0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
202            0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
203            0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
204            0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
205            0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
206            0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
207            0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
208            0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
209            0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
210            0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
211            0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
212            0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
213            0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
214            0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
215            0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
216            0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
217            0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
218            0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
219            0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
220            0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
221            0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
222            0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
223            0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
224            0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
225            0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
226            0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
227            0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
228            0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
229            0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
230            0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
231            0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
232            0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
233            0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
234            0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
235            0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
236            0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
237            0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
238            0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
239            0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
240            0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
241            0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
242            0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
243            0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
244    
245    };
246    
247    uint32_t
248    calc_crc(uint8_t *mem, int len, uint32_t crc)
249    {
250            while( len >= 8) {
251                    DO8(mem, crc);
252                    len -= 8;
253            }
254    
255            while( len ) {
256                    DO1(mem, crc);
257                    len--;
258            }
259    
260            return crc;
261    }
262    
263    void byte_swap(uint8_t *mem, int len, int element_size) {
264    #ifdef ARCH_IS_BIG_ENDIAN
265            int i;
266    
267            if(element_size == 1) {
268                    /* No need to swap */
269            } else if(element_size == 2) {
270                    uint8_t temp[2];
271    
272                    for(i=0; i < (len/2); i++ ) {
273                            temp[0] = mem[0];
274                            temp[1] = mem[1];
275                            mem[0] = temp[1];
276                            mem[1] = temp[0];
277    
278                            mem += 2;
279                    }
280            } else if(element_size == 4) {
281                    uint8_t temp[4];
282    
283                    for(i=0; i < (len/4); i++ ) {
284                            temp[0] = mem[0];
285                            temp[1] = mem[1];
286                            temp[2] = mem[2];
287                            temp[3] = mem[3];
288                            mem[0] = temp[3];
289                            mem[1] = temp[2];
290                            mem[2] = temp[1];
291                            mem[3] = temp[0];
292    
293                            mem += 4;
294                    }
295            } else {
296                    printf("ERROR: byte_swap unsupported element_size(%u)\n", element_size);
297            }
298    #endif
299    }
300    
301  /*********************************************************************  /*********************************************************************
302   * test DCT   * test DCT
303   *********************************************************************/   *********************************************************************/
# Line 223  Line 350 
350                          MSE += delta*delta;                          MSE += delta*delta;
351                  }                  }
352                  PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );                  PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
353                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f\n",                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
354                                  cpu->name, t, PSNR, MSE );                                  cpu->name, t, PSNR, MSE,
355                  if (ABS(MSE)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
356          }          }
357  }  }
358    
# Line 239  Line 366 
366          int tst;          int tst;
367          CPU *cpu;          CPU *cpu;
368          int i;          int i;
369          uint8_t Cur[16*16], Ref1[16*16], Ref2[16*16];          DECLARE_ALIGNED_MATRIX(Cur,  16, 16, uint8_t, 16);
370            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
371            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
372    
373          printf( "\n ======  test SAD ======\n" );          printf( "\n ======  test SAD ======\n" );
374          for(i=0; i<16*16;++i) {          for(i=0; i<16*16;++i) {
# Line 260  Line 389 
389                  for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);                  for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
390                  emms();                  emms();
391                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
392                  printf( "%s - sad8    %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad8    %.3f usec       sad=%d %s\n",
393                  if (s!=3776) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
394                               (s!=3776)?"| ERROR": "" );
395    
396                  t = gettime_usec();                  t = gettime_usec();
397                  emms();                  emms();
398                  for(tst=0; tst<nb_tests; ++tst) s = sad16(Cur, Ref1, 16, -1);                  for(tst=0; tst<nb_tests; ++tst) s = sad16(Cur, Ref1, 16, -1);
399                  emms();                  emms();
400                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
401                  printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad16   %.3f usec       sad=%d %s\n",
402                  if (s!=27214) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
403                               (s!=27214)?"| ERROR": "" );
404    
405                  t = gettime_usec();                  t = gettime_usec();
406                  emms();                  emms();
407                  for(tst=0; tst<nb_tests; ++tst) s = sad16bi(Cur, Ref1, Ref2, 16);                  for(tst=0; tst<nb_tests; ++tst) s = sad16bi(Cur, Ref1, Ref2, 16);
408                  emms();                  emms();
409                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
410                  printf( "%s - sad16bi %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - sad16bi %.3f usec       sad=%d %s\n",
411                  if (s!=26274) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
412                                    (s!=26274)?"| ERROR": "" );
413    
414                  t = gettime_usec();                  t = gettime_usec();
415                  emms();                  emms();
416                  for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);                  for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
417                  emms();                  emms();
418                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
419                  printf( "%s - dev16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - dev16   %.3f usec       sad=%d %s\n",
420                  if (s!=3344) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
421                                    (s!=3344)?"| ERROR": "" );
422    
423                  printf( " --- \n" );                  printf( " --- \n" );
424          }          }
# Line 303  Line 436 
436  #define LEAVE \  #define LEAVE \
437  emms();                             \  emms();                             \
438  t = (gettime_usec() - t) / nb_tests;  \  t = (gettime_usec() - t) / nb_tests;  \
439  iCrc = 0;                           \          iCrc = calc_crc((uint8_t*)Dst, sizeof(Dst), CRC32_INITIAL)
 for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }  
440    
441  #define TEST_MB(FUNC, R)                \  #define TEST_MB(FUNC, R)                \
442  ENTER                               \  ENTER                               \
# Line 323  Line 455 
455          CPU *cpu;          CPU *cpu;
456          const uint8_t Src0[16*9] = {          const uint8_t Src0[16*9] = {
457                  /* try to have every possible combinaison of rounding... */                  /* try to have every possible combinaison of rounding... */
458                  0, 0, 1, 0, 2, 0, 3, 0, 4             ,0,0,0, 0,0,0,0                  0, 0, 1, 0, 2, 0, 3, 0, 4             ,0,0,0, 0,0,0,0,
459                  , 0, 1, 1, 1, 2, 1, 3, 1, 3             ,0,0,0, 0,0,0,0                  0, 1, 1, 1, 2, 1, 3, 1, 3             ,0,0,0, 0,0,0,0,
460                  , 0, 2, 1, 2, 2, 2, 3, 2, 2             ,0,0,0, 0,0,0,0                  0, 2, 1, 2, 2, 2, 3, 2, 2             ,0,0,0, 0,0,0,0,
461                  , 0, 3, 1, 3, 2, 3, 3, 3, 1             ,0,0,0, 0,0,0,0                  0, 3, 1, 3, 2, 3, 3, 3, 1             ,0,0,0, 0,0,0,0,
462                  , 1, 3, 0, 2, 1, 0, 2, 3, 4             ,0,0,0, 0,0,0,0                  1, 3, 0, 2, 1, 0, 2, 3, 4             ,0,0,0, 0,0,0,0,
463                  , 2, 2, 1, 2, 0, 1, 3, 5, 3             ,0,0,0, 0,0,0,0                  2, 2, 1, 2, 0, 1, 3, 5, 3             ,0,0,0, 0,0,0,0,
464                  , 3, 1, 2, 3, 1, 2, 2, 6, 2             ,0,0,0, 0,0,0,0                  3, 1, 2, 3, 1, 2, 2, 6, 2             ,0,0,0, 0,0,0,0,
465                  , 1, 0, 1, 3, 0, 3, 1, 6, 1             ,0,0,0, 0,0,0,0                  1, 0, 1, 3, 0, 3, 1, 6, 1             ,0,0,0, 0,0,0,0,
466                  , 4, 3, 2, 1, 2, 3, 4, 0, 3             ,0,0,0, 0,0,0,0                  4, 3, 2, 1, 2, 3, 4, 0, 3             ,0,0,0, 0,0,0,0
467          };          };
468          uint8_t Dst[16*8] = {0};          uint8_t Dst[16*8] = {0};
469    
# Line 346  Line 478 
478                          continue;                          continue;
479    
480                  TEST_MB(interpolate8x8_halfpel_h, 0);                  TEST_MB(interpolate8x8_halfpel_h, 0);
481                  printf( "%s - interp- h-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp- h-round0 %.3f usec       crc32=0x%08x %s\n",
482                  if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
483                               (iCrc!=0x115381ba)?"| ERROR": "" );
484    
485                  TEST_MB(interpolate8x8_halfpel_h, 1);                  TEST_MB(interpolate8x8_halfpel_h, 1);
486                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
487                  if (iCrc!=8100) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
488                               (iCrc!=0x2b1f528f)?"| ERROR": "" );
489    
490    
491                  TEST_MB(interpolate8x8_halfpel_v, 0);                  TEST_MB(interpolate8x8_halfpel_v, 0);
492                  printf( "%s - interp- v-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp- v-round0 %.3f usec       crc32=0x%08x %s\n",
493                  if (iCrc!=8108) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
494                               (iCrc!=0x423cdcc7)?"| ERROR": "" );
495    
496                  TEST_MB(interpolate8x8_halfpel_v, 1);                  TEST_MB(interpolate8x8_halfpel_v, 1);
497                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
498                  if (iCrc!=8105) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
499                               (iCrc!=0x42202efe)?"| ERROR": "" );
500    
501    
502                  TEST_MB(interpolate8x8_halfpel_hv, 0);                  TEST_MB(interpolate8x8_halfpel_hv, 0);
503                  printf( "%s - interp-hv-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp-hv-round0 %.3f usec       crc32=0x%08x %s\n",
504                  if (iCrc!=8112) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
505                               (iCrc!=0xd198d387)?"| ERROR": "" );
506    
507                  TEST_MB(interpolate8x8_halfpel_hv, 1);                  TEST_MB(interpolate8x8_halfpel_hv, 1);
508                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
509                  if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
510                               (iCrc!=0x9ecfd921)?"| ERROR": "" );
511    
512    
513                  /* this is a new function, as of 06.06.2002 */                  /* this is a new function, as of 06.06.2002 */
514  #if 0  #if 0
515                  TEST_MB2(interpolate8x8_avrg);                  TEST_MB2(interpolate8x8_avrg);
516                  printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
517                  if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
518                               (iCrc!=8107)?"| ERROR": "" );
519  #endif  #endif
520    
521                  printf( " --- \n" );                  printf( " --- \n" );
# Line 412  Line 551 
551  }                                         \  }                                         \
552  emms();                                   \  emms();                                   \
553  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
554  s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]^i; }  byte_swap((uint8_t*)(DST), 8*32*sizeof((DST)[0]), sizeof((DST)[0]));  \
555    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
556    
557  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
558  TEST_TRANSFER_BEGIN(DST);                 \  TEST_TRANSFER_BEGIN(DST);                 \
# Line 438  Line 578 
578  }                                         \  }                                         \
579  emms();                                   \  emms();                                   \
580  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
581  s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]; }  byte_swap((uint8_t*)(DST), 8*32*sizeof((DST)[0]), sizeof((DST)[0]));  \
582    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
583    
584  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
585  TEST_TRANSFER2_BEGIN(DST,SRC);            \  TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 455  Line 596 
596          const int nb_tests = 4000*speed_ref;          const int nb_tests = 4000*speed_ref;
597          int i;          int i;
598          CPU *cpu;          CPU *cpu;
599          uint8_t  Src8[8*32], Dst8[8*32], Ref1[8*32], Ref2[8*32];  //      uint8_t  Src8[8*32], Dst8[8*32], Ref1[8*32], Ref2[8*32];
600          int16_t Src16[8*32], Dst16[8*32];  //      int16_t Src16[8*32], Dst16[8*32];
601      DECLARE_ALIGNED_MATRIX(Src8, 8, 32, uint8_t, CACHE_LINE);
602      DECLARE_ALIGNED_MATRIX(Dst8, 8, 32, uint8_t, CACHE_LINE);
603      DECLARE_ALIGNED_MATRIX(Ref1, 8, 32, uint8_t, CACHE_LINE);
604      DECLARE_ALIGNED_MATRIX(Ref2, 8, 32, uint8_t, CACHE_LINE);
605      DECLARE_ALIGNED_MATRIX(Src16, 8, 32, uint16_t, CACHE_LINE);
606      DECLARE_ALIGNED_MATRIX(Dst16, 8, 32, uint16_t, CACHE_LINE);
607    
608          printf( "\n ===  test transfer ===\n" );          printf( "\n ===  test transfer ===\n" );
609    
# Line 469  Line 616 
616                          continue;                          continue;
617    
618                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
619                  printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
620                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
621                               (s!=0x115814bb)?"| ERROR": "");
622    
623                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
624                  printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
625                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
626                                    (s!=0xee7ccbb4)?"| ERROR": "");
627    
628                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
629                  printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
630                  if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
631                               (s!=0xd37b3295)?"| ERROR": "");
632    
633                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
634                  printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
635                  if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
636                               (s!=0xdd817bf4)?"| ERROR": "" );
637    
638                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
639                  printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
640                  if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
641                  s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }                          s1 = calc_crc((uint8_t*)Dst16, 8*32*sizeof(Dst16[0]), CRC32_INITIAL);
642                  printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, 8*32*sizeof(Src8[0]), CRC32_INITIAL);
643                  if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
644                                       cpu->name, t, s1, s2,
645                                       (s1!=0xa1e07163)?"| ERROR1": "",
646                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
647                    }
648    
649                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
650                  printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
651                  if (s!=22368) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
652                               (s!=0x99b6c4c7)?"| ERROR": "" );
653    
654                  printf( " --- \n" );                  printf( " --- \n" );
655          }          }
# Line 505  Line 661 
661    
662  #define TEST_QUANT(FUNC, DST, SRC)              \  #define TEST_QUANT(FUNC, DST, SRC)              \
663  t = gettime_usec();                         \  t = gettime_usec();                         \
664  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
665    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
666    set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
667    emms();                                   \    emms();                                   \
668    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
669          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
670            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
671          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
672            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
673    }                                         \    }                                         \
674    emms();                                   \    emms();                                   \
675  }                                           \  }                                           \
676  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
 s = (s&0xffff)^(s>>16)  
677    
678  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
679  t = gettime_usec();                         \  t = gettime_usec();                         \
680  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
681    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
682    set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
683    emms();                                   \    emms();                                   \
684    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
685          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
686            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
687          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
688            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
689    }                                         \    }                                         \
690    emms();                                   \    emms();                                   \
691  }                                           \  }                                           \
692  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
693  s = (s&0xffff)^(s>>16)  
694    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
695    { int i,q,s;\
696            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
697      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
698      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
699      for(q=1;q<=max_Q;q++)          \
700        for(s=-RANGE;s<RANGE;s++) { \
701          for(i=0;i<64;i++) Src[i]=s; \
702          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
703          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
704          for(i=0;i<64;i++)     \
705            if(Dst[i]!=Dst2[i]) printf("ERROR : " #NEWFUNC " i%d quant:%d input:%d C_result:%d ASM_result:%d\n",i,q,s,Dst[i],Dst2[i]);  \
706        }      \
707    }
708    
709    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
710    { int i,q,s;  \
711            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
712      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
713      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
714      for(q=1;q<=max_Q;q++)  \
715        for(s=-RANGE;s<RANGE;s++) {   \
716          for(i=0;i<64;i++) Src[i]=s; \
717          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
718          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
719          emms();           \
720          for(i=0;i<64;i++) \
721            if(Dst[i]!=Dst2[i]) printf("ERROR : " #NEWFUNC " i%d quant:%d input:%d C_result:%d ASM_result:%d\n",i,q,s,Dst[i],Dst2[i]); \
722        } \
723    }
724    
725  void test_quant()  void test_quant()
726  {  {
727          const int nb_tests = 1*speed_ref;          const int nb_tests = 1*speed_ref;
728          const int max_Q = 31;          const int max_Q = 31;
729            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
730    
731          int i, qm;          int i, qm;
732          CPU *cpu;          CPU *cpu;
733          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
734            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
735            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
736          uint8_t Quant[8*8];          uint8_t Quant[8*8];
737    
738          printf( "\n =====  test quant =====\n" );          printf( "\n =====  test quant =====\n" );
# Line 562  Line 753 
753                  if (!init_cpu(cpu))                  if (!init_cpu(cpu))
754                  continue;                  continue;
755    
756                    // exhaustive tests to compare against the (ref) C-version
757                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
758                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
759                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
760                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
761    
762                  overhead = -gettime_usec();                  overhead = -gettime_usec();
763                  for(s=0,qm=1; qm<=255; ++qm) {                  for(s=0,qm=1; qm<=255; ++qm) {
764                          for(i=0; i<8*8; ++i) Quant[i] = qm;                          for(i=0; i<8*8; ++i) Quant[i] = qm;
765                          set_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
766                          for(q=1; q<=max_Q; ++q)                          for(q=1; q<=max_Q; ++q)
767                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
768                  }                  }
769                  overhead += gettime_usec();                  overhead += gettime_usec();
770    
 #if 1  
771                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
772                  printf( "%s -   quant_mpeg_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s -   quant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
773                  if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
774                               (s!=0xfd6a21a4)? "| ERROR": "");
775    
776                  TEST_QUANT(quant_mpeg_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
777                  printf( "%s -   quant_mpeg_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s -   quant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
778                  if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
779  #endif                             (s!=0xf6de7757)?"| ERROR": "");
780  #if 1  
781                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
782                  printf( "%s - dequant_mpeg_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - dequant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
783                  if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
784                               (s!=0x2def7bc7)?"| ERROR": "");
785    
786                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
787                  printf( "%s - dequant_mpeg_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
788                  if (s!=63847) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
789  #endif                             (s!=0xd878c722)?"| ERROR": "");
790  #if 1  
791                  TEST_QUANT2(quant_h263_intra, Dst, Src);                  TEST_QUANT2(quant_h263_intra, Dst, Src);
792                  printf( "%s -   quant_h263_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
793                  if (s!=25662) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
794                               (s!=0x2eba9d43)?"| ERROR": "");
795    
796                  TEST_QUANT(quant_h263_inter, Dst, Src);                  TEST_QUANT(quant_h263_inter, Dst, Src);
797                  printf( "%s -   quant_h263_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s -   quant_h263_inter %.3f usec       crc32=0x%08x %s\n",
798                  if (s!=23972) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
799  #endif                             (s!=0xbd315a7e)?"| ERROR": "");
800  #if 1  
801                  TEST_QUANT2(dequant_h263_intra, Dst, Src);                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
802                  printf( "%s - dequant_h263_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - dequant_h263_intra %.3f usec       crc32=0x%08x %s\n",
803                  if (s!=49900) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
804                               (s!=0x9841212a)?"| ERROR": "");
805    
806                  TEST_QUANT(dequant_h263_inter, Dst, Src);                  TEST_QUANT(dequant_h263_inter, Dst, Src);
807                  printf( "%s - dequant_h263_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - dequant_h263_inter %.3f usec       crc32=0x%08x %s\n",
808                  if (s!=48899) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
809  #endif                             (s!=0xe7df8fba)?"| ERROR": "");
810    
811                    printf( " --- \n" );
812            }
813    }
814    
815    /*********************************************************************
816     * test distortion operators
817     *********************************************************************/
818    
819    static void ieee_reseed(long s);
820    static long ieee_rand(int Min, int Max);
821    
822    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
823      do { \
824        t = gettime_usec(); \
825        tst = nb_tests; \
826        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
827        emms(); \
828        t = (gettime_usec() - t)/(double)nb_tests;  \
829      } while(0)
830    
831    
832    void test_sse()
833    {
834            const int nb_tests = 100000*speed_ref;
835            int i;
836            CPU *cpu;
837            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
838            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
839            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
840            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
841    
842            printf( "\n =====  test sse =====\n" );
843    
844            ieee_reseed(1);
845            for(i=0; i<64; ++i) {
846                    Src1[i] = ieee_rand(-2048, 2047);
847                    Src2[i] = ieee_rand(-2048, 2047);
848                    Src3[i] = ieee_rand(-2048, 2047);
849                    Src4[i] = ieee_rand(-2048, 2047);
850            }
851    
852            for(cpu = cpu_list; cpu->name!=0; ++cpu)
853            {
854                    double t;
855                    int tst, sse;
856    
857                    if (!init_cpu(cpu))
858                            continue;
859    
860                    /* 16 bit element blocks */
861                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
862                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
863                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
864                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
865                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
866                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
867                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
868                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
869                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
870                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
871                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
872                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
873                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
874                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
875                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
876                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
877                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
878                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
879    
880                    /* 8 bit element blocks */
881                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
882                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
883                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
884                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
885                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
886                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
887                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
888                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
889                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
890                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
891                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
892                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
893                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
894                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
895                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
896                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
897                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
898                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
899    
900                  printf( " --- \n" );                  printf( " --- \n" );
901          }          }
902  }  }
# Line 629  Line 919 
919          const int nb_tests = 10000*speed_ref;          const int nb_tests = 10000*speed_ref;
920          int i;          int i;
921          CPU *cpu;          CPU *cpu;
922          int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
923            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
924            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
925            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
926    
927          printf( "\n =====  test cbp =====\n" );          printf( "\n =====  test cbp =====\n" );
928    
# Line 649  Line 942 
942                          continue;                          continue;
943    
944                  TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1);
945                  printf( "%s -   calc_cbp#1 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#1 %.3f usec       cbp=0x%02x %s\n",
946                  if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
947                  TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2);
948                  printf( "%s -   calc_cbp#2 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#2 %.3f usec       cbp=0x%02x %s\n",
949                  if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
950                  TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3);
951                  printf( "%s -   calc_cbp#3 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#3 %.3f usec       cbp=0x%02x %s\n",
952                  if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
953                  TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4);
954                  printf( "%s -   calc_cbp#4 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
955                  if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
956                  printf( " --- \n" );                  printf( " --- \n" );
957          }          }
958  }  }
# Line 1055  Line 1348 
1348   * measure raw decoding speed   * measure raw decoding speed
1349   *********************************************************************/   *********************************************************************/
1350    
1351  void test_dec(const char *name, int width, int height, int with_chksum)  void test_dec(const char *name, int width, int height, int ref_chksum)
1352  {  {
1353          FILE *f = 0;          FILE *f = 0;
1354          void *dechandle = 0;          void *dechandle = 0;
# Line 1066  Line 1359 
1359          double t = 0.;          double t = 0.;
1360          int nb = 0;          int nb = 0;
1361          uint8_t *buf = 0;          uint8_t *buf = 0;
1362          uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1363          int buf_size, pos;          int buf_size, pos;
1364          uint32_t chksum = 0;          uint32_t chksum = 0;
1365            int bps = (width+31) & ~31;
1366    
1367          memset(&xinit, 0, sizeof(xinit));          memset(&xinit, 0, sizeof(xinit));
1368          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = cpu_mask;
1369          xinit.version = XVID_VERSION;          xinit.version = XVID_VERSION;
1370          xvid_global(NULL, 0, &xinit, NULL);          xvid_global(NULL, 0, &xinit, NULL);
1371    
# Line 1081  Line 1375 
1375          xparam.version = XVID_VERSION;          xparam.version = XVID_VERSION;
1376          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1377          if (xerr==XVID_ERR_FAIL) {          if (xerr==XVID_ERR_FAIL) {
1378                  printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1379                  return;                  return;
1380          }          }
1381          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1089  Line 1383 
1383    
1384          f = fopen(name, "rb");          f = fopen(name, "rb");
1385          if (f==0) {          if (f==0) {
1386                  printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1387                  return;                  return;
1388          }          }
1389          fseek(f, 0, SEEK_END);          fseek(f, 0, SEEK_END);
1390          buf_size = ftell(f);          buf_size = ftell(f);
1391          fseek(f, 0, SEEK_SET);          fseek(f, 0, SEEK_SET);
1392          if (buf_size<=0) {          if (buf_size<=0) {
1393                  printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1394                  goto End;                  goto End;
1395          }          }
         else printf( "Input size: %d\n", buf_size);  
1396    
1397          buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1398          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1399          if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1400                  printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1401                  goto End;                  goto End;
1402          }          }
1403    
1404          if (fread(buf, buf_size, 1, f)!=1) {          if (fread(buf, buf_size, 1, f)!=1) {
1405                  printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1406                  goto End;                  goto End;
1407          }          }
1408    
# Line 1117  Line 1410 
1410          pos = 0;          pos = 0;
1411          t = -gettime_usec();          t = -gettime_usec();
1412          while(1) {          while(1) {
1413              int y;
1414    
1415                  memset(&xframe, 0, sizeof(xframe));                  memset(&xframe, 0, sizeof(xframe));
1416                  xframe.version = XVID_VERSION;                  xframe.version = XVID_VERSION;
1417                  xframe.bitstream = buf + pos;                  xframe.bitstream = buf + pos;
1418                  xframe.length = buf_size - pos;                  xframe.length = buf_size - pos;
1419                  xframe.output.plane[0] = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1420                  xframe.output.stride[0] = width;                  xframe.output.plane[1] = xframe.output.plane[0] + bps*height;
1421                  xframe.output.csp = XVID_CSP_BGR;                  xframe.output.plane[2] = xframe.output.plane[1] + bps/2;
1422                    xframe.output.stride[0] = bps;
1423                    xframe.output.stride[1] = bps;
1424                    xframe.output.stride[2] = bps;
1425                    xframe.output.csp = XVID_CSP_I420;
1426                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1427                    if (xerr<0) {
1428                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1429                            break;
1430                    }
1431                    else if (xerr==0)
1432                      break;
1433        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1434    
1435                    pos += xerr;
1436                  nb++;                  nb++;
1437                  pos += xframe.length;  
1438                  if (with_chksum) {      for(y=0; y<height/2; ++y) {
1439                          int k = width*height;                    chksum = calc_crc(xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1440                          uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc(xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1441                          while(k-->0) chksum += *ptr++;                          chksum = calc_crc(xframe.output.plane[1] + y*bps, width/2, chksum);
1442                            chksum = calc_crc(xframe.output.plane[2] + y*bps, width/2, chksum);
1443                  }                  }
1444                  if (pos==buf_size)                  if (pos==buf_size)
1445                          break;                          break;
                 if (xerr==XVID_ERR_FAIL) {  
                         printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
                         break;  
                 }  
1446          }          }
1447          t += gettime_usec();          t += gettime_usec();
1448            if (ref_chksum==0) {
1449          if (t>0.)          if (t>0.)
1450                  printf( "%d frames decoded in %.3f s -> %.1f FPS\n", nb, t*1.e-6f, (float)(nb*1.e6f/t) );                    printf( "%d frames decoded in %.3f s -> %.1f FPS   Checksum:0x%.8x\n", nb, t*1.e-6f, (float)(nb*1.e6f/t), chksum );
1451          if (with_chksum)    }
1452                  printf("checksum: 0x%.8x\n", chksum);    else {
1453                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1454                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1455      }
1456    
1457   End:   End:
1458          if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1459          if (buf!=0) free(buf);          if (buf!=0) free(buf);
1460          if (dechandle!=0) {          if (dechandle!=0) {
1461                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1462                  if (xerr==XVID_ERR_FAIL)                  if (xerr==XVID_ERR_FAIL)
1463                          printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1464          }          }
1465          if (f!=0) fclose(f);          if (f!=0) fclose(f);
1466  }  }
# Line 1163  Line 1472 
1472  void test_bugs1()  void test_bugs1()
1473  {  {
1474          CPU *cpu;          CPU *cpu;
1475            uint16_t mpeg_quant_matrices[64*8];
1476    
1477          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1478    
# Line 1175  Line 1485 
1485                          continue;                          continue;
1486    
1487                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1488                  set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1489                  dequant_mpeg_intra(Dst, Src, 31, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1490                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1491                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1492                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1194  Line 1504 
1504                          continue;                          continue;
1505    
1506                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1507                  set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1508                  dequant_mpeg_inter(Dst, Src, 31);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1509                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1510                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1511                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1206  Line 1516 
1516  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1517  {  {
1518          CPU *cpu;          CPU *cpu;
1519          short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1520            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1521    
1522          printf( "\n =====  fdct/idct precision diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1523    
# Line 1239  Line 1550 
1550          const int max_Q = 31;          const int max_Q = 31;
1551          int i, n, qm, q;          int i, n, qm, q;
1552          CPU *cpu;          CPU *cpu;
1553          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1554            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1555          uint8_t Quant[8*8];          uint8_t Quant[8*8];
1556          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1557          uint16_t Crcs_Inter[2][32];          uint16_t Crcs_Inter[2][32];
1558          uint16_t Crcs_Intra[2][32];          uint16_t Crcs_Intra[2][32];
1559            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1560    
1561          printf( "\n =====  test MPEG4-quantize bug =====\n" );          printf( "\n =====  test MPEG4-quantize bug =====\n" );
1562    
1563          for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;          for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;
# Line 1252  Line 1566 
1566          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1567          {          {
1568                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1569                  set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1570    
1571                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1572                  {                  {
# Line 1263  Line 1577 
1577    
1578                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1579                                  emms();                                  emms();
1580                                  quant_mpeg_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1581                                  emms();                                  emms();
1582                                  for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;                                  for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1583                                  Crcs_Inter[n][q] = s;                                  Crcs_Inter[n][q] = s;
# Line 1282  Line 1596 
1596          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1597          {          {
1598                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1599                  set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1600    
1601                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1602                  {                  {
# Line 1293  Line 1607 
1607    
1608                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1609                                  emms();                                  emms();
1610                                  quant_mpeg_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1611                                  emms();                                  emms();
1612                                  for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;                                  for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1613                                  Crcs_Intra[n][q] = s;                                  Crcs_Intra[n][q] = s;
# Line 1308  Line 1622 
1622          }          }
1623  #endif  #endif
1624  }  }
1625    /*********************************************************************/
1626    
1627    static uint32_t __inline log2bin_v1(uint32_t value)
1628    {
1629      int n = 0;
1630      while (value) {
1631        value >>= 1;
1632        n++;
1633      }
1634      return n;
1635    }
1636    
1637    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1638    
1639    static uint32_t __inline log2bin_v2(uint32_t value)
1640    {
1641      int n = 0;
1642      if (value & 0xffff0000) {
1643        value >>= 16;
1644        n += 16;
1645      }
1646      if (value & 0xff00) {
1647        value >>= 8;
1648        n += 8;
1649      }
1650      if (value & 0xf0) {
1651        value >>= 4;
1652        n += 4;
1653      }
1654     return n + log2_tab_16[value];
1655    }
1656    
1657    void test_log2bin()
1658    {
1659            const int nb_tests = 3000*speed_ref;
1660      int n, crc1=0, crc2=0;
1661      uint32_t s, s0;
1662      double t1, t2;
1663    
1664      t1 = gettime_usec();
1665      s0 = (int)(t1*31.241);
1666      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1667        crc1 += log2bin_v1(s);
1668      t1 = (gettime_usec()-t1) / nb_tests;
1669    
1670      t2 = gettime_usec();
1671      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1672        crc2 += log2bin_v2(s);
1673      t2 = (gettime_usec() - t2) / nb_tests;
1674    
1675      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1676      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1677      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1678    }
1679    
1680    /*********************************************************************/
1681    
1682    static void __inline old_gcd(int *num, int *den)
1683    {
1684     int i = *num;
1685      while (i > 1) {
1686        if (*num % i == 0 && *den % i == 0) {
1687          *num /= i;
1688          *den /= i;
1689          i = *num;
1690          continue;
1691        }
1692        i--;
1693      }
1694    }
1695    
1696    static uint32_t gcd(int num, int den)
1697    {
1698      int tmp;
1699      while( (tmp=num%den) ) { num = den; den = tmp; }
1700      return den;
1701    }
1702    static void __inline new_gcd(int *num, int *den)
1703    {
1704      const int div = gcd(*num, *den);
1705      if (num) {
1706        *num /= div;
1707        *den /= div;
1708      }
1709    }
1710    
1711    void test_gcd()
1712    {
1713            const int nb_tests = 10*speed_ref;
1714      int i;
1715      uint32_t crc1=0, crc2=0;
1716      uint32_t n0, n, d0, d;
1717      double t1, t2;
1718    
1719      t1 = gettime_usec();
1720      n0 = 0xfffff & (int)(t1*31.241);
1721      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1722      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1723        old_gcd(&n, &d);
1724        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1725        n = d;
1726        d = (d*12363+31) & 0xffff;
1727        d |= !d;
1728      }
1729      t1 = (gettime_usec()-t1) / nb_tests;
1730    
1731      t2 = gettime_usec();
1732      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1733        new_gcd(&n, &d);
1734        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1735        n = d;
1736        d = (d*12363+31) & 0xffff;
1737        d |= !d;
1738      }
1739      t2 = (gettime_usec() - t2) / nb_tests;
1740    
1741      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1742      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1743      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1744    }
1745    
1746  /*********************************************************************  /*********************************************************************
1747   * main   * main
1748   *********************************************************************/   *********************************************************************/
1749    
1750  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
1751  {  {
1752          int what = 0;    printf( "missing argument after option '%s'\n", opt);
1753          if (argc>1) what = atoi(argv[1]);    exit(-1);
1754    }
1755    
1756    int main(int argc, const char *argv[])
1757    {
1758            int c, what = 0;
1759            int width, height;
1760            uint32_t chksum = 0;
1761      const char * test_bitstream = 0;
1762    
1763            cpu_mask = 0;  // default => will use autodectect
1764            for(c=1; c<argc; ++c)
1765            {
1766              if (!strcmp(argv[c], "-v")) verbose++;
1767              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
1768              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
1769              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1770              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1771              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
1772              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
1773              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
1774              else if (!strcmp(argv[c], "-spd")) {
1775          if (++c==argc) arg_missing( argv[argc-1] );
1776          speed_ref = atoi(argv[c]);
1777        }
1778              else if (argv[c][0]!='-') {
1779                what = atoi(argv[c]);
1780                if (what==9) {
1781                  if (c+4>argc) {
1782                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
1783                    exit(-1);
1784            }
1785            test_bitstream = argv[++c];
1786                  width  = atoi(argv[++c]);
1787                  height = atoi(argv[++c]);
1788                  if (c+1<argc && argv[c+1][0]!='-') {
1789                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
1790                      printf( "can't read checksum value.\n" );
1791                      exit(-1);
1792              }
1793              else c++;
1794            }
1795    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
1796          }
1797        }
1798        else {
1799          printf( "unrecognized option '%s'\n", argv[c]);
1800          exit(-1);
1801        }
1802      }
1803    
1804    
1805          if (what==0 || what==1) test_dct();          if (what==0 || what==1) test_dct();
1806          if (what==0 || what==2) test_mb();          if (what==0 || what==2) test_mb();
1807          if (what==0 || what==3) test_sad();          if (what==0 || what==3) test_sad();
1808          if (what==0 || what==4) test_transfer();          if (what==0 || what==4) test_transfer();
1809          if (what==0 || what==5) test_quant();          if (what==0 || what==5) test_quant();
1810          if (what==0 || what==6) test_cbp();          if (what==0 || what==6) test_cbp();
1811            if (what==0 || what==10) test_sse();
1812            if (what==0 || what==11) test_log2bin();
1813            if (what==0 || what==12) test_gcd();
1814    
1815    
1816          if (what==7) {          if (what==7) {
1817                  test_IEEE1180_compliance(-256, 255, 1);                  test_IEEE1180_compliance(-256, 255, 1);
# Line 1334  Line 1823 
1823          }          }
1824          if (what==8) test_dct_saturation(-256, 255);          if (what==8) test_dct_saturation(-256, 255);
1825    
1826          if (what==9) {          if (test_bitstream)
1827                  int width, height;            test_dec(test_bitstream, width, height, chksum);
                 if (argc<5) {  
                         printf("usage: %s %d [bitstream] [width] [height]\n", argv[0], what);  
                         return 1;  
                 }  
                 width = atoi(argv[3]);  
                 height = atoi(argv[4]);  
                 test_dec(argv[2], width, height, (argc>5));  
         }  
   
1828          if (what==-1) {          if (what==-1) {
1829                  test_dct_precision_diffs();                  test_dct_precision_diffs();
1830                  test_bugs1();                  test_bugs1();
# Line 1352  Line 1832 
1832          if (what==-2)          if (what==-2)
1833                  test_quant_bug();                  test_quant_bug();
1834    
1835          return 0;          if ((what >= 0 && what <= 6) || what == 10) {
1836                    printf("\n\n"
1837                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1838                               "    a C function is used instead. So don't panic if some functions\n"
1839                               "    may appear to be slow.\n");
1840  }  }
1841    
1842  /*********************************************************************  #ifdef ARCH_IS_IA32
1843   * 'Reference' output (except for timing) on an Athlon XP 2200+          if (what == 0 || what == 5) {
1844   *********************************************************************/                  printf("\n"
1845                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1846  /* as of 07/01/2002, there's a problem with MMX mpeg4-quantization */                             "    for 1 or 2 coefficients a block. This is mainly caused by the fact the unit\n"
1847  /*                             "    test goes far behind the usual limits of real encoding. Please do not report\n"
1848                               "    this error to the developers.\n");
1849            }
1850    #endif
1851    
1852   ===== test fdct/idct =====          return 0;
1853  PLAINC -  1.446 usec       PSNR=13.291  MSE=3.000  }
 MMX    -  -0.260 usec       PSNR=9.611  MSE=7.000  
 MMXEXT -  -0.293 usec       PSNR=9.611  MSE=7.000  
 3DNOW  -  1.535 usec       PSNR=13.291  MSE=3.000  
 3DNOWE -  0.376 usec       PSNR=13.291  MSE=3.000  
   
  ===  test block motion ===  
 PLAINC - interp- h-round0 0.126 usec       iCrc=8107  
 PLAINC -           round1 0.136 usec       iCrc=8100  
 PLAINC - interp- v-round0 0.121 usec       iCrc=8108  
 PLAINC -           round1 0.127 usec       iCrc=8105  
 PLAINC - interp-hv-round0 0.192 usec       iCrc=8112  
 PLAINC -           round1 0.213 usec       iCrc=8103  
  ---  
 MMX    - interp- h-round0 0.048 usec       iCrc=8107  
 MMX    -           round1 0.048 usec       iCrc=8100  
 MMX    - interp- v-round0 0.046 usec       iCrc=8108  
 MMX    -           round1 0.047 usec       iCrc=8105  
 MMX    - interp-hv-round0 0.074 usec       iCrc=8112  
 MMX    -           round1 0.074 usec       iCrc=8103  
  ---  
 MMXEXT - interp- h-round0 0.019 usec       iCrc=8107  
 MMXEXT -           round1 0.025 usec       iCrc=8100  
 MMXEXT - interp- v-round0 0.015 usec       iCrc=8108  
 MMXEXT -           round1 0.024 usec       iCrc=8105  
 MMXEXT - interp-hv-round0 0.039 usec       iCrc=8112  
 MMXEXT -           round1 0.037 usec       iCrc=8103  
  ---  
 3DNOW  - interp- h-round0 0.019 usec       iCrc=8107  
 3DNOW  -           round1 0.023 usec       iCrc=8100  
 3DNOW  - interp- v-round0 0.015 usec       iCrc=8108  
 3DNOW  -           round1 0.024 usec       iCrc=8105  
 3DNOW  - interp-hv-round0 0.037 usec       iCrc=8112  
 3DNOW  -           round1 0.038 usec       iCrc=8103  
  ---  
 3DNOWE - interp- h-round0 0.022 usec       iCrc=8107  
 3DNOWE -           round1 0.023 usec       iCrc=8100  
 3DNOWE - interp- v-round0 0.016 usec       iCrc=8108  
 3DNOWE -           round1 0.021 usec       iCrc=8105  
 3DNOWE - interp-hv-round0 0.036 usec       iCrc=8112  
 3DNOWE -           round1 0.036 usec       iCrc=8103  
  ---  
   
  ======  test SAD ======  
 PLAINC - sad8    0.165 usec       sad=3776  
 PLAINC - sad16   0.587 usec       sad=27214  
 PLAINC - sad16bi 1.290 usec       sad=26274  
 PLAINC - dev16   1.535 usec       sad=3344  
  ---  
 MMX    - sad8    0.036 usec       sad=3776  
 MMX    - sad16   0.113 usec       sad=27214  
 MMX    - sad16bi 0.250 usec       sad=26274  
 MMX    - dev16   0.187 usec       sad=3344  
  ---  
 MMXEXT - sad8    0.015 usec       sad=3776  
 MMXEXT - sad16   0.046 usec       sad=27214  
 MMXEXT - sad16bi 0.059 usec       sad=26274  
 MMXEXT - dev16   0.088 usec       sad=3344  
  ---  
 3DNOW  - sad8    0.165 usec       sad=3776  
 3DNOW  - sad16   0.589 usec       sad=27214  
 3DNOW  - sad16bi 0.119 usec       sad=26274  
 3DNOW  - dev16   1.541 usec       sad=3344  
  ---  
 3DNOWE - sad8    0.018 usec       sad=3776  
 3DNOWE - sad16   0.039 usec       sad=27214  
 3DNOWE - sad16bi 0.051 usec       sad=26274  
 3DNOWE - dev16   0.070 usec       sad=3344  
  ---  
   
  ===  test transfer ===  
 PLAINC - 8to16     0.207 usec       crc=28288  
 PLAINC - 16to8     0.357 usec       crc=28288  
 PLAINC - 8to8      0.154 usec       crc=20352  
 PLAINC - 16to8add  0.391 usec       crc=25536  
 PLAINC - 8to16sub  0.562 usec       crc1=28064 crc2=16256  
 PLAINC - 8to16sub2 0.519 usec       crc=22368  
  ---  
 MMX    - 8to16     0.048 usec       crc=28288  
 MMX    - 16to8     0.205 usec       crc=28288  
 MMX    - 8to8      -0.158 usec       crc=20352  
 MMX    - 16to8add  0.015 usec       crc=25536  
 MMX    - 8to16sub  0.203 usec       crc1=28064 crc2=16256  
 MMX    - 8to16sub2 0.087 usec       crc=22368  
  ---  
 MMXEXT - 8to16     0.013 usec       crc=28288  
 MMXEXT - 16to8     0.011 usec       crc=28288  
 MMXEXT - 8to8      -0.023 usec       crc=20352  
 MMXEXT - 16to8add  0.023 usec       crc=25536  
 MMXEXT - 8to16sub  0.072 usec       crc1=28064 crc2=16256  
 MMXEXT - 8to16sub2 0.093 usec       crc=22368  
  ---  
 3DNOW  - 8to16     0.192 usec       crc=28288  
 3DNOW  - 16to8     0.367 usec       crc=28288  
 3DNOW  - 8to8      0.132 usec       crc=20352  
 3DNOW  - 16to8add  0.440 usec       crc=25536  
 3DNOW  - 8to16sub  0.557 usec       crc1=28064 crc2=16256  
 3DNOW  - 8to16sub2 0.691 usec       crc=22368  
  ---  
 3DNOWE - 8to16     0.004 usec       crc=28288  
 3DNOWE - 16to8     0.019 usec       crc=28288  
 3DNOWE - 8to8      -0.294 usec       crc=20352  
 3DNOWE - 16to8add  0.028 usec       crc=25536  
 3DNOWE - 8to16sub  0.065 usec       crc1=28064 crc2=16256  
 3DNOWE - 8to16sub2 0.027 usec       crc=22368  
  ---  
   
  =====  test quant =====  
 PLAINC -   quant_mpeg_intra 67.757 usec       crc=29809  
 PLAINC -   quant_mpeg_inter 68.482 usec       crc=12574  
 PLAINC - dequant_mpeg_intra 20.764 usec       crc=24052  
 PLAINC - dequant_mpeg_inter 24.413 usec       crc=63847  
 PLAINC -   quant_h263_intra 16.446 usec       crc=25662  
 PLAINC -   quant_h263_inter 14.499 usec       crc=23972  
 PLAINC - dequant_h263_intra 16.419 usec       crc=49900  
 PLAINC - dequant_h263_inter 18.679 usec       crc=48899  
  ---  
 MMX    -   quant_mpeg_intra 8.299 usec       crc=3459  
 *** CRC ERROR! ***  
 MMX    -   quant_mpeg_inter 7.078 usec       crc=13247  
 *** CRC ERROR! ***  
 MMX    - dequant_mpeg_intra 3.455 usec       crc=24052  
 MMX    - dequant_mpeg_inter 4.483 usec       crc=63847  
 MMX    -   quant_h263_intra 2.597 usec       crc=25662  
 MMX    -   quant_h263_inter 2.151 usec       crc=23972  
 MMX    - dequant_h263_intra 2.684 usec       crc=49900  
 MMX    - dequant_h263_inter 2.647 usec       crc=48899  
  ---  
 MMXEXT -   quant_mpeg_intra 3.878 usec       crc=29809  
 MMXEXT -   quant_mpeg_inter 4.112 usec       crc=12574  
 MMXEXT - dequant_mpeg_intra 3.452 usec       crc=24052  
 MMXEXT - dequant_mpeg_inter 4.473 usec       crc=63847  
 MMXEXT -   quant_h263_intra 2.608 usec       crc=25662  
 MMXEXT -   quant_h263_inter 2.145 usec       crc=23972  
 MMXEXT - dequant_h263_intra 2.478 usec       crc=49900  
 MMXEXT - dequant_h263_inter 2.450 usec       crc=48899  
  ---  
 3DNOW  -   quant_mpeg_intra 66.051 usec       crc=29809  
 3DNOW  -   quant_mpeg_inter 73.494 usec       crc=12574  
 3DNOW  - dequant_mpeg_intra 20.374 usec       crc=24052  
 3DNOW  - dequant_mpeg_inter 23.645 usec       crc=63847  
 3DNOW  -   quant_h263_intra 16.292 usec       crc=25662  
 3DNOW  -   quant_h263_inter 14.322 usec       crc=23972  
 3DNOW  - dequant_h263_intra 16.613 usec       crc=49900  
 3DNOW  - dequant_h263_inter 18.382 usec       crc=48899  
  ---  
 3DNOWE -   quant_mpeg_intra 66.140 usec       crc=29809  
 3DNOWE -   quant_mpeg_inter 68.454 usec       crc=12574  
 3DNOWE - dequant_mpeg_intra 2.881 usec       crc=24052  
 3DNOWE - dequant_mpeg_inter 4.155 usec       crc=63847  
 3DNOWE -   quant_h263_intra 1.451 usec       crc=25662  
 3DNOWE -   quant_h263_inter 1.849 usec       crc=23972  
 3DNOWE - dequant_h263_intra 2.101 usec       crc=49900  
 3DNOWE - dequant_h263_inter 2.109 usec       crc=48899  
  ---  
   
  =====  test cbp =====  
 PLAINC -   calc_cbp#1 0.090 usec       cbp=0x15  
 PLAINC -   calc_cbp#2 0.086 usec       cbp=0x38  
 PLAINC -   calc_cbp#3 0.087 usec       cbp=0xf  
 PLAINC -   calc_cbp#4 0.114 usec       cbp=0x5  
  ---  
 MMX    -   calc_cbp#1 0.061 usec       cbp=0x15  
 MMX    -   calc_cbp#2 0.063 usec       cbp=0x38  
 MMX    -   calc_cbp#3 0.061 usec       cbp=0xf  
 MMX    -   calc_cbp#4 0.060 usec       cbp=0x5  
  ---  
 MMXEXT -   calc_cbp#1 0.062 usec       cbp=0x15  
 MMXEXT -   calc_cbp#2 0.060 usec       cbp=0x38  
 MMXEXT -   calc_cbp#3 0.062 usec       cbp=0xf  
 MMXEXT -   calc_cbp#4 0.061 usec       cbp=0x5  
  ---  
 3DNOW  -   calc_cbp#1 0.089 usec       cbp=0x15  
 3DNOW  -   calc_cbp#2 0.087 usec       cbp=0x38  
 3DNOW  -   calc_cbp#3 0.087 usec       cbp=0xf  
 3DNOW  -   calc_cbp#4 0.116 usec       cbp=0x5  
  ---  
 3DNOWE -   calc_cbp#1 0.050 usec       cbp=0x15  
 3DNOWE -   calc_cbp#2 0.051 usec       cbp=0x38  
 3DNOWE -   calc_cbp#3 0.050 usec       cbp=0xf  
 3DNOWE -   calc_cbp#4 0.049 usec       cbp=0x5  
  ---  
1854    
1855  */  /*********************************************************************/
Legend:
Removed from v.1.9.2.8  
changed lines
  Added in v.1.22
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4