[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.20, Mon May 23 12:06:02 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 119  Line 119 
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
124    #ifdef ARCH_IS_PPC
125      , { "ALTIVEC", XVID_CPU_ALTIVEC }
126    #endif
127    #ifdef ARCH_IS_X86_64
128      , { "X86_64", XVID_CPU_ASM}
129  #endif  #endif
130  //, { "IA64  ", XVID_CPU_IA64 }  //, { "IA64  ", XVID_CPU_IA64 }
131  //, { "TSC   ", XVID_CPU_TSC }  //, { "TSC   ", XVID_CPU_TSC }
# Line 171  Line 177 
177          return 1;          return 1;
178  }  }
179    
180    #define CRC32_REMAINDER 0xCBF43926
181    #define CRC32_INITIAL 0xffffffff
182    
183    #define DO1(c, crc) ((crc) = crc32tab[((unsigned int)((crc)>>24) ^ (*c++)) & 0xff] ^ ((crc) << 8))
184    #define DO2(c, crc)  DO1(c, crc); DO1(c, crc);
185    #define DO4(c, crc)  DO2(c, crc); DO2(c, crc);
186    #define DO8(c, crc)  DO4(c, crc); DO4(c, crc);
187    
188    /******************************************************************************
189    * Precomputed AAL5 CRC32 lookup table
190    ******************************************************************************/
191    
192    static unsigned long crc32tab[256] = {
193    
194            0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
195            0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
196            0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
197            0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
198            0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
199            0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
200            0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
201            0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
202            0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
203            0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
204            0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
205            0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
206            0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
207            0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
208            0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
209            0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
210            0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
211            0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
212            0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
213            0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
214            0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
215            0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
216            0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
217            0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
218            0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
219            0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
220            0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
221            0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
222            0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
223            0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
224            0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
225            0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
226            0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
227            0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
228            0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
229            0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
230            0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
231            0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
232            0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
233            0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
234            0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
235            0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
236            0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
237            0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
238            0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
239            0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
240            0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
241            0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
242            0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
243            0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
244            0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
245            0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
246            0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
247            0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
248            0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
249            0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
250            0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
251            0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
252            0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
253            0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
254            0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
255            0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
256            0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
257            0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
258    
259    };
260    
261    uint32_t
262    calc_crc(uint8_t *mem, int len, uint32_t crc)
263    {
264            while( len >= 8) {
265                    DO8(mem, crc);
266                    len -= 8;
267            }
268    
269            while( len ) {
270                    DO1(mem, crc);
271                    len--;
272            }
273    
274            return crc;
275    }
276    
277  /*********************************************************************  /*********************************************************************
278   * test DCT   * test DCT
279   *********************************************************************/   *********************************************************************/
# Line 223  Line 326 
326                          MSE += delta*delta;                          MSE += delta*delta;
327                  }                  }
328                  PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );                  PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
329                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f\n",                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
330                                  cpu->name, t, PSNR, MSE );                                  cpu->name, t, PSNR, MSE,
331                  if (ABS(MSE)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
332          }          }
333  }  }
334    
# Line 239  Line 342 
342          int tst;          int tst;
343          CPU *cpu;          CPU *cpu;
344          int i;          int i;
345          uint8_t Cur[16*16], Ref1[16*16], Ref2[16*16];          DECLARE_ALIGNED_MATRIX(Cur,  16, 16, uint8_t, 16);
346            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
347            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
348    
349          printf( "\n ======  test SAD ======\n" );          printf( "\n ======  test SAD ======\n" );
350          for(i=0; i<16*16;++i) {          for(i=0; i<16*16;++i) {
# Line 260  Line 365 
365                  for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);                  for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
366                  emms();                  emms();
367                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
368                  printf( "%s - sad8    %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad8    %.3f usec       sad=%d %s\n",
369                  if (s!=3776) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
370                               (s!=3776)?"| ERROR": "" );
371    
372                  t = gettime_usec();                  t = gettime_usec();
373                  emms();                  emms();
374                  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);
375                  emms();                  emms();
376                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
377                  printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad16   %.3f usec       sad=%d %s\n",
378                  if (s!=27214) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
379                               (s!=27214)?"| ERROR": "" );
380    
381                  t = gettime_usec();                  t = gettime_usec();
382                  emms();                  emms();
383                  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);
384                  emms();                  emms();
385                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
386                  printf( "%s - sad16bi %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - sad16bi %.3f usec       sad=%d %s\n",
387                  if (s!=26274) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
388                                    (s!=26274)?"| ERROR": "" );
389    
390                  t = gettime_usec();                  t = gettime_usec();
391                  emms();                  emms();
392                  for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);                  for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
393                  emms();                  emms();
394                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
395                  printf( "%s - dev16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - dev16   %.3f usec       sad=%d %s\n",
396                  if (s!=3344) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
397                                    (s!=3344)?"| ERROR": "" );
398    
399                  printf( " --- \n" );                  printf( " --- \n" );
400          }          }
# Line 303  Line 412 
412  #define LEAVE \  #define LEAVE \
413  emms();                             \  emms();                             \
414  t = (gettime_usec() - t) / nb_tests;  \  t = (gettime_usec() - t) / nb_tests;  \
415  iCrc = 0;                           \          iCrc = calc_crc((uint8_t*)Dst, sizeof(Dst), CRC32_INITIAL)
 for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }  
416    
417  #define TEST_MB(FUNC, R)                \  #define TEST_MB(FUNC, R)                \
418  ENTER                               \  ENTER                               \
# Line 323  Line 431 
431          CPU *cpu;          CPU *cpu;
432          const uint8_t Src0[16*9] = {          const uint8_t Src0[16*9] = {
433                  /* try to have every possible combinaison of rounding... */                  /* try to have every possible combinaison of rounding... */
434                  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,
435                  , 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,
436                  , 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,
437                  , 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,
438                  , 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,
439                  , 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,
440                  , 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,
441                  , 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,
442                  , 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
443          };          };
444          uint8_t Dst[16*8] = {0};          uint8_t Dst[16*8] = {0};
445    
# Line 346  Line 454 
454                          continue;                          continue;
455    
456                  TEST_MB(interpolate8x8_halfpel_h, 0);                  TEST_MB(interpolate8x8_halfpel_h, 0);
457                  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",
458                  if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
459                               (iCrc!=0x115381ba)?"| ERROR": "" );
460    
461                  TEST_MB(interpolate8x8_halfpel_h, 1);                  TEST_MB(interpolate8x8_halfpel_h, 1);
462                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
463                  if (iCrc!=8100) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
464                               (iCrc!=0x2b1f528f)?"| ERROR": "" );
465    
466    
467                  TEST_MB(interpolate8x8_halfpel_v, 0);                  TEST_MB(interpolate8x8_halfpel_v, 0);
468                  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",
469                  if (iCrc!=8108) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
470                               (iCrc!=0x423cdcc7)?"| ERROR": "" );
471    
472                  TEST_MB(interpolate8x8_halfpel_v, 1);                  TEST_MB(interpolate8x8_halfpel_v, 1);
473                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
474                  if (iCrc!=8105) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
475                               (iCrc!=0x42202efe)?"| ERROR": "" );
476    
477    
478                  TEST_MB(interpolate8x8_halfpel_hv, 0);                  TEST_MB(interpolate8x8_halfpel_hv, 0);
479                  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",
480                  if (iCrc!=8112) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
481                               (iCrc!=0xd198d387)?"| ERROR": "" );
482    
483                  TEST_MB(interpolate8x8_halfpel_hv, 1);                  TEST_MB(interpolate8x8_halfpel_hv, 1);
484                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
485                  if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
486                               (iCrc!=0x9ecfd921)?"| ERROR": "" );
487    
488    
489                  /* this is a new function, as of 06.06.2002 */                  /* this is a new function, as of 06.06.2002 */
490  #if 0  #if 0
491                  TEST_MB2(interpolate8x8_avrg);                  TEST_MB2(interpolate8x8_avrg);
492                  printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
493                  if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
494                               (iCrc!=8107)?"| ERROR": "" );
495  #endif  #endif
496    
497                  printf( " --- \n" );                  printf( " --- \n" );
# Line 412  Line 527 
527  }                                         \  }                                         \
528  emms();                                   \  emms();                                   \
529  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
530  s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]^i; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
531    
532  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
533  TEST_TRANSFER_BEGIN(DST);                 \  TEST_TRANSFER_BEGIN(DST);                 \
# Line 438  Line 553 
553  }                                         \  }                                         \
554  emms();                                   \  emms();                                   \
555  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
556  s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
557    
558  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
559  TEST_TRANSFER2_BEGIN(DST,SRC);            \  TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 469  Line 584 
584                          continue;                          continue;
585    
586                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
587                  printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
588                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
589                               (s!=0x115814bb)?"| ERROR": "");
590    
591                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
592                  printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
593                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
594                                    (s!=0xee7ccbb4)?"| ERROR": "");
595    
596                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
597                  printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
598                  if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
599                               (s!=0xd37b3295)?"| ERROR": "");
600    
601                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
602                  printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
603                  if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
604                               (s!=0xdd817bf4)?"| ERROR": "" );
605    
606                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
607                  printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
608                  if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
609                  s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }                          s1 = calc_crc((uint8_t*)Dst16, sizeof(Dst16), CRC32_INITIAL);
610                  printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, sizeof(Src8), CRC32_INITIAL);
611                  if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
612                                       cpu->name, t, s1, s2,
613                                       (s1!=0xa1e07163)?"| ERROR1": "",
614                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
615                    }
616    
617                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
618                  printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
619                  if (s!=22368) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
620                               (s!=0x99b6c4c7)?"| ERROR": "" );
621    
622                  printf( " --- \n" );                  printf( " --- \n" );
623          }          }
# Line 505  Line 629 
629    
630  #define TEST_QUANT(FUNC, DST, SRC)              \  #define TEST_QUANT(FUNC, DST, SRC)              \
631  t = gettime_usec();                         \  t = gettime_usec();                         \
632  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
633    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
634    set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
635    emms();                                   \    emms();                                   \
636    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
637          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
638            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
639          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
640    }                                         \    }                                         \
641    emms();                                   \    emms();                                   \
642  }                                           \  }                                           \
643  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
 s = (s&0xffff)^(s>>16)  
644    
645  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
646  t = gettime_usec();                         \  t = gettime_usec();                         \
647  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
648    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
649    set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
650    emms();                                   \    emms();                                   \
651    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
652          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
653            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
654          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
655      }                                         \
656      emms();                                   \
657    }                                           \
658    t = (gettime_usec()-t-overhead)/nb_tests/qm
659    
660    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
661    { int i,q,s;\
662            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
663      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
664      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
665      for(q=1;q<=max_Q;q++)          \
666        for(s=-RANGE;s<RANGE;s++) { \
667          for(i=0;i<64;i++) Src[i]=s; \
668          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
669          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
670          for(i=0;i<64;i++)     \
671            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]);  \
672    }                                         \    }                                         \
673    }
674    
675    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
676    { int i,q,s;  \
677            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
678      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
679      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
680      for(q=1;q<=max_Q;q++)  \
681        for(s=-RANGE;s<RANGE;s++) {   \
682          for(i=0;i<64;i++) Src[i]=s; \
683          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
684          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
685    emms();                                   \    emms();                                   \
686          for(i=0;i<64;i++) \
687            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]); \
688  }                                           \  }                                           \
689  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  }
 s = (s&0xffff)^(s>>16)  
690    
691  void test_quant()  void test_quant()
692  {  {
693          const int nb_tests = 1*speed_ref;          const int nb_tests = 1*speed_ref;
694          const int max_Q = 31;          const int max_Q = 31;
695            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
696    
697          int i, qm;          int i, qm;
698          CPU *cpu;          CPU *cpu;
699          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
700            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
701            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
702          uint8_t Quant[8*8];          uint8_t Quant[8*8];
703    
704          printf( "\n =====  test quant =====\n" );          printf( "\n =====  test quant =====\n" );
# Line 562  Line 719 
719                  if (!init_cpu(cpu))                  if (!init_cpu(cpu))
720                  continue;                  continue;
721    
722                    // exhaustive tests to compare against the (ref) C-version
723                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
724                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
725                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
726                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
727    
728                  overhead = -gettime_usec();                  overhead = -gettime_usec();
729                  for(s=0,qm=1; qm<=255; ++qm) {                  for(s=0,qm=1; qm<=255; ++qm) {
730                          for(i=0; i<8*8; ++i) Quant[i] = qm;                          for(i=0; i<8*8; ++i) Quant[i] = qm;
731                          set_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
732                          for(q=1; q<=max_Q; ++q)                          for(q=1; q<=max_Q; ++q)
733                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
734                  }                  }
735                  overhead += gettime_usec();                  overhead += gettime_usec();
736    
 #if 1  
737                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
738                  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",
739                  if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
740                               (s!=0xfd6a21a4)? "| ERROR": "");
741    
742                  TEST_QUANT(quant_mpeg_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
743                  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",
744                  if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
745  #endif                             (s!=0xf6de7757)?"| ERROR": "");
746  #if 1  
747                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
748                  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",
749                  if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
750                               (s!=0x2def7bc7)?"| ERROR": "");
751    
752                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
753                  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",
754                  if (s!=63847) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
755  #endif                             (s!=0xd878c722)?"| ERROR": "");
756  #if 1  
757                  TEST_QUANT2(quant_h263_intra, Dst, Src);                  TEST_QUANT2(quant_h263_intra, Dst, Src);
758                  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",
759                  if (s!=25662) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
760                               (s!=0x2eba9d43)?"| ERROR": "");
761    
762                  TEST_QUANT(quant_h263_inter, Dst, Src);                  TEST_QUANT(quant_h263_inter, Dst, Src);
763                  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",
764                  if (s!=23972) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
765  #endif                             (s!=0xbd315a7e)?"| ERROR": "");
766  #if 1  
767                  TEST_QUANT2(dequant_h263_intra, Dst, Src);                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
768                  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",
769                  if (s!=49900) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
770                               (s!=0x9841212a)?"| ERROR": "");
771    
772                  TEST_QUANT(dequant_h263_inter, Dst, Src);                  TEST_QUANT(dequant_h263_inter, Dst, Src);
773                  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",
774                  if (s!=48899) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
775  #endif                             (s!=0xe7df8fba)?"| ERROR": "");
776    
777                    printf( " --- \n" );
778            }
779    }
780    
781    /*********************************************************************
782     * test distortion operators
783     *********************************************************************/
784    
785    static void ieee_reseed(long s);
786    static long ieee_rand(int Min, int Max);
787    
788    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
789      do { \
790        t = gettime_usec(); \
791        tst = nb_tests; \
792        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
793        emms(); \
794        t = (gettime_usec() - t)/(double)nb_tests;  \
795      } while(0)
796    
797    
798    void test_sse()
799    {
800            const int nb_tests = 100000*speed_ref;
801            int i;
802            CPU *cpu;
803            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
804            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
805            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
806            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
807    
808            printf( "\n =====  test sse =====\n" );
809    
810            ieee_reseed(1);
811            for(i=0; i<64; ++i) {
812                    Src1[i] = ieee_rand(-2048, 2047);
813                    Src2[i] = ieee_rand(-2048, 2047);
814                    Src3[i] = ieee_rand(-2048, 2047);
815                    Src4[i] = ieee_rand(-2048, 2047);
816            }
817    
818            for(cpu = cpu_list; cpu->name!=0; ++cpu)
819            {
820                    double t;
821                    int tst, sse;
822    
823                    if (!init_cpu(cpu))
824                            continue;
825    
826                    /* 16 bit element blocks */
827                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
828                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
829                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
830                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
831                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
832                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
833                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
834                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
835                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
836                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
837                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
838                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
839                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
840                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
841                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
842                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
843                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
844                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
845    
846                    /* 8 bit element blocks */
847                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
848                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
849                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
850                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
851                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
852                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
853                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
854                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
855                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
856                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
857                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
858                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
859                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
860                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
861                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
862                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
863                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
864                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
865    
866                  printf( " --- \n" );                  printf( " --- \n" );
867          }          }
868  }  }
# Line 629  Line 885 
885          const int nb_tests = 10000*speed_ref;          const int nb_tests = 10000*speed_ref;
886          int i;          int i;
887          CPU *cpu;          CPU *cpu;
888          int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
889            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
890            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
891            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
892    
893          printf( "\n =====  test cbp =====\n" );          printf( "\n =====  test cbp =====\n" );
894    
# Line 649  Line 908 
908                          continue;                          continue;
909    
910                  TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1);
911                  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",
912                  if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
913                  TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2);
914                  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",
915                  if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
916                  TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3);
917                  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",
918                  if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
919                  TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4);
920                  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",
921                  if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
922                  printf( " --- \n" );                  printf( " --- \n" );
923          }          }
924  }  }
# Line 1055  Line 1314 
1314   * measure raw decoding speed   * measure raw decoding speed
1315   *********************************************************************/   *********************************************************************/
1316    
1317  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)
1318  {  {
1319          FILE *f = 0;          FILE *f = 0;
1320          void *dechandle = 0;          void *dechandle = 0;
# Line 1066  Line 1325 
1325          double t = 0.;          double t = 0.;
1326          int nb = 0;          int nb = 0;
1327          uint8_t *buf = 0;          uint8_t *buf = 0;
1328          uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1329          int buf_size, pos;          int buf_size, pos;
1330          uint32_t chksum = 0;          uint32_t chksum = 0;
1331            int bps = (width+31) & ~31;
1332    
1333          memset(&xinit, 0, sizeof(xinit));          memset(&xinit, 0, sizeof(xinit));
1334          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = cpu_mask;
1335          xinit.version = XVID_VERSION;          xinit.version = XVID_VERSION;
1336          xvid_global(NULL, 0, &xinit, NULL);          xvid_global(NULL, 0, &xinit, NULL);
1337    
# Line 1081  Line 1341 
1341          xparam.version = XVID_VERSION;          xparam.version = XVID_VERSION;
1342          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1343          if (xerr==XVID_ERR_FAIL) {          if (xerr==XVID_ERR_FAIL) {
1344                  printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1345                  return;                  return;
1346          }          }
1347          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1089  Line 1349 
1349    
1350          f = fopen(name, "rb");          f = fopen(name, "rb");
1351          if (f==0) {          if (f==0) {
1352                  printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1353                  return;                  return;
1354          }          }
1355          fseek(f, 0, SEEK_END);          fseek(f, 0, SEEK_END);
1356          buf_size = ftell(f);          buf_size = ftell(f);
1357          fseek(f, 0, SEEK_SET);          fseek(f, 0, SEEK_SET);
1358          if (buf_size<=0) {          if (buf_size<=0) {
1359                  printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1360                  goto End;                  goto End;
1361          }          }
         else printf( "Input size: %d\n", buf_size);  
1362    
1363          buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1364          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1365          if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1366                  printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1367                  goto End;                  goto End;
1368          }          }
1369    
1370          if (fread(buf, buf_size, 1, f)!=1) {          if (fread(buf, buf_size, 1, f)!=1) {
1371                  printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1372                  goto End;                  goto End;
1373          }          }
1374    
# Line 1117  Line 1376 
1376          pos = 0;          pos = 0;
1377          t = -gettime_usec();          t = -gettime_usec();
1378          while(1) {          while(1) {
1379              int y;
1380    
1381                  memset(&xframe, 0, sizeof(xframe));                  memset(&xframe, 0, sizeof(xframe));
1382                  xframe.version = XVID_VERSION;                  xframe.version = XVID_VERSION;
1383                  xframe.bitstream = buf + pos;                  xframe.bitstream = buf + pos;
1384                  xframe.length = buf_size - pos;                  xframe.length = buf_size - pos;
1385                  xframe.output.plane[0] = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1386                  xframe.output.stride[0] = width;                  xframe.output.plane[1] = xframe.output.plane[0] + bps*height;
1387                  xframe.output.csp = XVID_CSP_BGR;                  xframe.output.plane[2] = xframe.output.plane[1] + bps/2;
1388                    xframe.output.stride[0] = bps;
1389                    xframe.output.stride[1] = bps;
1390                    xframe.output.stride[2] = bps;
1391                    xframe.output.csp = XVID_CSP_I420;
1392                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1393                    if (xerr<0) {
1394                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1395                            break;
1396                    }
1397                    else if (xerr==0)
1398                      break;
1399        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1400    
1401                    pos += xerr;
1402                  nb++;                  nb++;
1403                  pos += xframe.length;  
1404                  if (with_chksum) {      for(y=0; y<height/2; ++y) {
1405                          int k = width*height;                    chksum = calc_crc(xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1406                          uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc(xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1407                          while(k-->0) chksum += *ptr++;                          chksum = calc_crc(xframe.output.plane[1] + y*bps, width/2, chksum);
1408                            chksum = calc_crc(xframe.output.plane[2] + y*bps, width/2, chksum);
1409                  }                  }
1410                  if (pos==buf_size)                  if (pos==buf_size)
1411                          break;                          break;
                 if (xerr==XVID_ERR_FAIL) {  
                         printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
                         break;  
                 }  
1412          }          }
1413          t += gettime_usec();          t += gettime_usec();
1414            if (ref_chksum==0) {
1415          if (t>0.)          if (t>0.)
1416                  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 );
1417          if (with_chksum)    }
1418                  printf("checksum: 0x%.8x\n", chksum);    else {
1419                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1420                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1421      }
1422    
1423   End:   End:
1424          if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1425          if (buf!=0) free(buf);          if (buf!=0) free(buf);
1426          if (dechandle!=0) {          if (dechandle!=0) {
1427                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1428                  if (xerr==XVID_ERR_FAIL)                  if (xerr==XVID_ERR_FAIL)
1429                          printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1430          }          }
1431          if (f!=0) fclose(f);          if (f!=0) fclose(f);
1432  }  }
# Line 1163  Line 1438 
1438  void test_bugs1()  void test_bugs1()
1439  {  {
1440          CPU *cpu;          CPU *cpu;
1441            uint16_t mpeg_quant_matrices[64*8];
1442    
1443          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1444    
# Line 1175  Line 1451 
1451                          continue;                          continue;
1452    
1453                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1454                  set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1455                  dequant_mpeg_intra(Dst, Src, 31, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1456                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1457                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1458                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1194  Line 1470 
1470                          continue;                          continue;
1471    
1472                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1473                  set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1474                  dequant_mpeg_inter(Dst, Src, 31);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1475                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1476                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1477                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1206  Line 1482 
1482  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1483  {  {
1484          CPU *cpu;          CPU *cpu;
1485          short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1486            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1487    
1488          printf( "\n =====  fdct/idct precision diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1489    
# Line 1239  Line 1516 
1516          const int max_Q = 31;          const int max_Q = 31;
1517          int i, n, qm, q;          int i, n, qm, q;
1518          CPU *cpu;          CPU *cpu;
1519          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1520            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1521          uint8_t Quant[8*8];          uint8_t Quant[8*8];
1522          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1523          uint16_t Crcs_Inter[2][32];          uint16_t Crcs_Inter[2][32];
1524          uint16_t Crcs_Intra[2][32];          uint16_t Crcs_Intra[2][32];
1525            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1526    
1527          printf( "\n =====  test MPEG4-quantize bug =====\n" );          printf( "\n =====  test MPEG4-quantize bug =====\n" );
1528    
1529          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 1532 
1532          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1533          {          {
1534                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1535                  set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1536    
1537                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1538                  {                  {
# Line 1263  Line 1543 
1543    
1544                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1545                                  emms();                                  emms();
1546                                  quant_mpeg_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1547                                  emms();                                  emms();
1548                                  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;
1549                                  Crcs_Inter[n][q] = s;                                  Crcs_Inter[n][q] = s;
# Line 1282  Line 1562 
1562          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1563          {          {
1564                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1565                  set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1566    
1567                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1568                  {                  {
# Line 1293  Line 1573 
1573    
1574                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1575                                  emms();                                  emms();
1576                                  quant_mpeg_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1577                                  emms();                                  emms();
1578                                  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;
1579                                  Crcs_Intra[n][q] = s;                                  Crcs_Intra[n][q] = s;
# Line 1308  Line 1588 
1588          }          }
1589  #endif  #endif
1590  }  }
1591    /*********************************************************************/
1592    
1593    static uint32_t __inline log2bin_v1(uint32_t value)
1594    {
1595      int n = 0;
1596      while (value) {
1597        value >>= 1;
1598        n++;
1599      }
1600      return n;
1601    }
1602    
1603    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1604    
1605    static uint32_t __inline log2bin_v2(uint32_t value)
1606    {
1607      int n = 0;
1608      if (value & 0xffff0000) {
1609        value >>= 16;
1610        n += 16;
1611      }
1612      if (value & 0xff00) {
1613        value >>= 8;
1614        n += 8;
1615      }
1616      if (value & 0xf0) {
1617        value >>= 4;
1618        n += 4;
1619      }
1620     return n + log2_tab_16[value];
1621    }
1622    
1623    void test_log2bin()
1624    {
1625            const int nb_tests = 3000*speed_ref;
1626      int n, crc1=0, crc2=0;
1627      uint32_t s, s0;
1628      double t1, t2;
1629    
1630      t1 = gettime_usec();
1631      s0 = (int)(t1*31.241);
1632      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1633        crc1 += log2bin_v1(s);
1634      t1 = (gettime_usec()-t1) / nb_tests;
1635    
1636      t2 = gettime_usec();
1637      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1638        crc2 += log2bin_v2(s);
1639      t2 = (gettime_usec() - t2) / nb_tests;
1640    
1641      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1642      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1643      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1644    }
1645    
1646    /*********************************************************************/
1647    
1648    static void __inline old_gcd(int *num, int *den)
1649    {
1650     int i = *num;
1651      while (i > 1) {
1652        if (*num % i == 0 && *den % i == 0) {
1653          *num /= i;
1654          *den /= i;
1655          i = *num;
1656          continue;
1657        }
1658        i--;
1659      }
1660    }
1661    
1662    static uint32_t gcd(int num, int den)
1663    {
1664      int tmp;
1665      while( (tmp=num%den) ) { num = den; den = tmp; }
1666      return den;
1667    }
1668    static void __inline new_gcd(int *num, int *den)
1669    {
1670      const int div = gcd(*num, *den);
1671      if (num) {
1672        *num /= div;
1673        *den /= div;
1674      }
1675    }
1676    
1677    void test_gcd()
1678    {
1679            const int nb_tests = 10*speed_ref;
1680      int i;
1681      uint32_t crc1=0, crc2=0;
1682      uint32_t n0, n, d0, d;
1683      double t1, t2;
1684    
1685      t1 = gettime_usec();
1686      n0 = 0xfffff & (int)(t1*31.241);
1687      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1688      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1689        old_gcd(&n, &d);
1690        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1691        n = d;
1692        d = (d*12363+31) & 0xffff;
1693        d |= !d;
1694      }
1695      t1 = (gettime_usec()-t1) / nb_tests;
1696    
1697      t2 = gettime_usec();
1698      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1699        new_gcd(&n, &d);
1700        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1701        n = d;
1702        d = (d*12363+31) & 0xffff;
1703        d |= !d;
1704      }
1705      t2 = (gettime_usec() - t2) / nb_tests;
1706    
1707      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1708      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1709      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1710    }
1711    
1712  /*********************************************************************  /*********************************************************************
1713   * main   * main
1714   *********************************************************************/   *********************************************************************/
1715    
1716  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
1717    {
1718      printf( "missing argument after option '%s'\n", opt);
1719      exit(-1);
1720    }
1721    
1722    int main(int argc, const char *argv[])
1723  {  {
1724          int what = 0;          int c, what = 0;
1725          if (argc>1) what = atoi(argv[1]);          int width, height;
1726            uint32_t chksum = 0;
1727      const char * test_bitstream = 0;
1728    
1729            cpu_mask = 0;  // default => will use autodectect
1730            for(c=1; c<argc; ++c)
1731            {
1732              if (!strcmp(argv[c], "-v")) verbose++;
1733              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
1734              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
1735              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1736              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1737              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
1738              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
1739              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
1740              else if (!strcmp(argv[c], "-spd")) {
1741          if (++c==argc) arg_missing( argv[argc-1] );
1742          speed_ref = atoi(argv[c]);
1743        }
1744              else if (argv[c][0]!='-') {
1745                what = atoi(argv[c]);
1746                if (what==9) {
1747                  if (c+4>argc) {
1748                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
1749                    exit(-1);
1750            }
1751            test_bitstream = argv[++c];
1752                  width  = atoi(argv[++c]);
1753                  height = atoi(argv[++c]);
1754                  if (c+1<argc && argv[c+1][0]!='-') {
1755                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
1756                      printf( "can't read checksum value.\n" );
1757                      exit(-1);
1758              }
1759              else c++;
1760            }
1761    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
1762          }
1763        }
1764        else {
1765          printf( "unrecognized option '%s'\n", argv[c]);
1766          exit(-1);
1767        }
1768      }
1769    
1770    
1771          if (what==0 || what==1) test_dct();          if (what==0 || what==1) test_dct();
1772          if (what==0 || what==2) test_mb();          if (what==0 || what==2) test_mb();
1773          if (what==0 || what==3) test_sad();          if (what==0 || what==3) test_sad();
1774          if (what==0 || what==4) test_transfer();          if (what==0 || what==4) test_transfer();
1775          if (what==0 || what==5) test_quant();          if (what==0 || what==5) test_quant();
1776          if (what==0 || what==6) test_cbp();          if (what==0 || what==6) test_cbp();
1777            if (what==0 || what==10) test_sse();
1778            if (what==0 || what==11) test_log2bin();
1779            if (what==0 || what==12) test_gcd();
1780    
1781    
1782          if (what==7) {          if (what==7) {
1783                  test_IEEE1180_compliance(-256, 255, 1);                  test_IEEE1180_compliance(-256, 255, 1);
# Line 1334  Line 1789 
1789          }          }
1790          if (what==8) test_dct_saturation(-256, 255);          if (what==8) test_dct_saturation(-256, 255);
1791    
1792          if (what==9) {          if (test_bitstream)
1793                  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));  
         }  
   
1794          if (what==-1) {          if (what==-1) {
1795                  test_dct_precision_diffs();                  test_dct_precision_diffs();
1796                  test_bugs1();                  test_bugs1();
# Line 1352  Line 1798 
1798          if (what==-2)          if (what==-2)
1799                  test_quant_bug();                  test_quant_bug();
1800    
1801          return 0;          if ((what >= 0 && what <= 6) || what == 10) {
1802                    printf("\n\n"
1803                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1804                               "    a C function is used instead. So don't panic if some functions\n"
1805                               "    may appear to be slow.\n");
1806  }  }
1807    
1808  /*********************************************************************  #ifdef ARCH_IS_IA32
1809   * 'Reference' output (except for timing) on an Athlon XP 2200+          if (what == 0 || what == 5) {
1810   *********************************************************************/                  printf("\n"
1811                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1812  /* 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"
1813  /*                             "    test goes far behind the usual limits of real encoding. Please do not report\n"
1814                               "    this error to the developers.\n");
1815            }
1816    #endif
1817    
1818   ===== test fdct/idct =====          return 0;
1819  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  
  ---  
1820    
1821  */  /*********************************************************************/
Legend:
Removed from v.1.9.2.8  
changed lines
  Added in v.1.20
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4