[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.5, Thu Oct 9 18:50:22 2003 UTC revision 1.21, Tue Jun 14 13:58:21 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 145  Line 151 
151    
152  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
153  {  {
154          int xerr, cpu_type;          xvid_gbl_info_t xinfo;
         xvid_gbl_init_t xinit;  
155    
156            /* Get the available CPU flags */
157            memset(&xinfo, 0, sizeof(xinfo));
158            xinfo.version = XVID_VERSION;
159            xvid_global(NULL, XVID_GBL_INFO, &xinfo, NULL);
160    
161            /* Are we trying to test a subset of the host CPU features */
162            if ((xinfo.cpu_flags & cpu->cpu) == cpu->cpu) {
163                    int xerr;
164                    xvid_gbl_init_t xinit;
165          memset(&xinit, 0, sizeof(xinit));          memset(&xinit, 0, sizeof(xinit));
166          xinit.cpu_flags = cpu->cpu | XVID_CPU_FORCE;          xinit.cpu_flags = cpu->cpu | XVID_CPU_FORCE;
167          xinit.version = XVID_VERSION;          xinit.version = XVID_VERSION;
168          xerr = xvid_global(NULL, 0, &xinit, NULL);                  xerr = xvid_global(NULL, XVID_GBL_INIT, &xinit, NULL);
169          if (cpu->cpu>0 && xerr==XVID_ERR_FAIL) {                  if (xerr==XVID_ERR_FAIL) {
170                  printf( "%s - skipped...\n", cpu->name );                          /* libxvidcore failed to init */
171                  return 0;                  return 0;
172          }          }
173            } else {
174                    /* The host CPU doesn't support some required feature for this test */
175                    return(0);
176            }
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 171  Line 286 
286          int tst;          int tst;
287          CPU *cpu;          CPU *cpu;
288          int i;          int i;
289          short iDst0[8*8], iDst[8*8], fDst[8*8];          DECLARE_ALIGNED_MATRIX(iDst0, 8, 8, short, 16);
290            DECLARE_ALIGNED_MATRIX(iDst,  8, 8, short, 16);
291            DECLARE_ALIGNED_MATRIX(fDst,  8, 8, short, 16);
292          double overhead;          double overhead;
293    
294          printf( "\n ===== test fdct/idct =====\n" );          printf( "\n ===== test fdct/idct =====\n" );
# Line 209  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 225  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 246  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 289  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 309  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 332  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 398  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), 8*32*sizeof((DST)[0]), 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 424  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), 8*32*sizeof((DST)[0]), 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 441  Line 570 
570          const int nb_tests = 4000*speed_ref;          const int nb_tests = 4000*speed_ref;
571          int i;          int i;
572          CPU *cpu;          CPU *cpu;
573          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];
574          int16_t Src16[8*32], Dst16[8*32];  //      int16_t Src16[8*32], Dst16[8*32];
575      DECLARE_ALIGNED_MATRIX(Src8, 8, 32, uint8_t, CACHE_LINE);
576      DECLARE_ALIGNED_MATRIX(Dst8, 8, 32, uint8_t, CACHE_LINE);
577      DECLARE_ALIGNED_MATRIX(Ref1, 8, 32, uint8_t, CACHE_LINE);
578      DECLARE_ALIGNED_MATRIX(Ref2, 8, 32, uint8_t, CACHE_LINE);
579      DECLARE_ALIGNED_MATRIX(Src16, 8, 32, uint16_t, CACHE_LINE);
580      DECLARE_ALIGNED_MATRIX(Dst16, 8, 32, uint16_t, CACHE_LINE);
581    
582          printf( "\n ===  test transfer ===\n" );          printf( "\n ===  test transfer ===\n" );
583    
# Line 455  Line 590 
590                          continue;                          continue;
591    
592                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
593                  printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
594                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
595                               (s!=0x115814bb)?"| ERROR": "");
596    
597                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
598                  printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
599                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
600                                    (s!=0xee7ccbb4)?"| ERROR": "");
601    
602                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
603                  printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
604                  if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
605                               (s!=0xd37b3295)?"| ERROR": "");
606    
607                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
608                  printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
609                  if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
610                               (s!=0xdd817bf4)?"| ERROR": "" );
611    
612                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
613                  printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
614                  if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
615                  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);
616                  printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, 8*32*sizeof(Src8[0]), CRC32_INITIAL);
617                  if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
618  #if 1                                     cpu->name, t, s1, s2,
619                                       (s1!=0xa1e07163)?"| ERROR1": "",
620                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
621                    }
622    
623                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
624                  printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
625                  if (s!=20384) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
626  //    for(i=0; i<64; ++i) printf( "[%d]", Dst16[i]);                             (s!=0x99b6c4c7)?"| ERROR": "" );
627  //    printf("\n");  
 #endif  
628                  printf( " --- \n" );                  printf( " --- \n" );
629          }          }
630  }  }
# Line 493  Line 635 
635    
636  #define TEST_QUANT(FUNC, DST, SRC)              \  #define TEST_QUANT(FUNC, DST, SRC)              \
637  t = gettime_usec();                         \  t = gettime_usec();                         \
638  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
639    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
640    set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
641    emms();                                   \    emms();                                   \
642    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
643          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
644            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
645          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
646    }                                         \    }                                         \
647    emms();                                   \    emms();                                   \
648  }                                           \  }                                           \
649  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
 s = (s&0xffff)^(s>>16)  
650    
651  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
652  t = gettime_usec();                         \  t = gettime_usec();                         \
653  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
654    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
655    set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
656    emms();                                   \    emms();                                   \
657    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
658          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
659            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
660          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
661    }                                         \    }                                         \
662    emms();                                   \    emms();                                   \
663  }                                           \  }                                           \
664  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
665  s = (s&0xffff)^(s>>16)  
666    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
667    { int i,q,s;\
668            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
669      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
670      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
671      for(q=1;q<=max_Q;q++)          \
672        for(s=-RANGE;s<RANGE;s++) { \
673          for(i=0;i<64;i++) Src[i]=s; \
674          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
675          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
676          for(i=0;i<64;i++)     \
677            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]);  \
678        }      \
679    }
680    
681    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
682    { int i,q,s;  \
683            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
684      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
685      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
686      for(q=1;q<=max_Q;q++)  \
687        for(s=-RANGE;s<RANGE;s++) {   \
688          for(i=0;i<64;i++) Src[i]=s; \
689          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
690          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
691          emms();           \
692          for(i=0;i<64;i++) \
693            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]); \
694        } \
695    }
696    
697  void test_quant()  void test_quant()
698  {  {
699          const int nb_tests = 1*speed_ref;          const int nb_tests = 1*speed_ref;
700          const int max_Q = 31;          const int max_Q = 31;
701            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
702    
703          int i, qm;          int i, qm;
704          CPU *cpu;          CPU *cpu;
705          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
706            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
707            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
708          uint8_t Quant[8*8];          uint8_t Quant[8*8];
709    
710          printf( "\n =====  test quant =====\n" );          printf( "\n =====  test quant =====\n" );
# Line 550  Line 725 
725                  if (!init_cpu(cpu))                  if (!init_cpu(cpu))
726                  continue;                  continue;
727    
728                    // exhaustive tests to compare against the (ref) C-version
729                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
730                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
731                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
732                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
733    
734                  overhead = -gettime_usec();                  overhead = -gettime_usec();
735                  for(s=0,qm=1; qm<=255; ++qm) {                  for(s=0,qm=1; qm<=255; ++qm) {
736                          for(i=0; i<8*8; ++i) Quant[i] = qm;                          for(i=0; i<8*8; ++i) Quant[i] = qm;
737                          set_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
738                          for(q=1; q<=max_Q; ++q)                          for(q=1; q<=max_Q; ++q)
739                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
740                  }                  }
741                  overhead += gettime_usec();                  overhead += gettime_usec();
742    
 #if 1  
743                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
744                  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",
745                  if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
746                               (s!=0xfd6a21a4)? "| ERROR": "");
747    
748                  TEST_QUANT(quant_mpeg_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
749                  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",
750                  if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
751  #endif                             (s!=0xf6de7757)?"| ERROR": "");
752  #if 1  
753                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
754                  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",
755                  if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
756                               (s!=0x2def7bc7)?"| ERROR": "");
757    
758                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
759                  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",
760                  if (s!=63847) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
761  #endif                             (s!=0xd878c722)?"| ERROR": "");
762  #if 1  
763                  TEST_QUANT2(quant_h263_intra, Dst, Src);                  TEST_QUANT2(quant_h263_intra, Dst, Src);
764                  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",
765                  if (s!=25662) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
766                               (s!=0x2eba9d43)?"| ERROR": "");
767    
768                  TEST_QUANT(quant_h263_inter, Dst, Src);                  TEST_QUANT(quant_h263_inter, Dst, Src);
769                  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",
770                  if (s!=23972) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
771  #endif                             (s!=0xbd315a7e)?"| ERROR": "");
772  #if 1  
773                  TEST_QUANT2(dequant_h263_intra, Dst, Src);                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
774                  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",
775                  if (s!=49900) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
776                               (s!=0x9841212a)?"| ERROR": "");
777    
778                  TEST_QUANT(dequant_h263_inter, Dst, Src);                  TEST_QUANT(dequant_h263_inter, Dst, Src);
779                  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",
780                  if (s!=48899) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
781  #endif                             (s!=0xe7df8fba)?"| ERROR": "");
782    
783                    printf( " --- \n" );
784            }
785    }
786    
787    /*********************************************************************
788     * test distortion operators
789     *********************************************************************/
790    
791    static void ieee_reseed(long s);
792    static long ieee_rand(int Min, int Max);
793    
794    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
795      do { \
796        t = gettime_usec(); \
797        tst = nb_tests; \
798        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
799        emms(); \
800        t = (gettime_usec() - t)/(double)nb_tests;  \
801      } while(0)
802    
803    
804    void test_sse()
805    {
806            const int nb_tests = 100000*speed_ref;
807            int i;
808            CPU *cpu;
809            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
810            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
811            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
812            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
813    
814            printf( "\n =====  test sse =====\n" );
815    
816            ieee_reseed(1);
817            for(i=0; i<64; ++i) {
818                    Src1[i] = ieee_rand(-2048, 2047);
819                    Src2[i] = ieee_rand(-2048, 2047);
820                    Src3[i] = ieee_rand(-2048, 2047);
821                    Src4[i] = ieee_rand(-2048, 2047);
822            }
823    
824            for(cpu = cpu_list; cpu->name!=0; ++cpu)
825            {
826                    double t;
827                    int tst, sse;
828    
829                    if (!init_cpu(cpu))
830                            continue;
831    
832                    /* 16 bit element blocks */
833                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
834                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
835                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
836                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
837                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
838                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
839                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
840                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
841                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
842                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
843                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
844                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
845                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
846                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
847                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
848                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
849                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
850                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
851    
852                    /* 8 bit element blocks */
853                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
854                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
855                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
856                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
857                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
858                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
859                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
860                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
861                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
862                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
863                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
864                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
865                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
866                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
867                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
868                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
869                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
870                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
871    
872                  printf( " --- \n" );                  printf( " --- \n" );
873          }          }
874  }  }
# Line 617  Line 891 
891          const int nb_tests = 10000*speed_ref;          const int nb_tests = 10000*speed_ref;
892          int i;          int i;
893          CPU *cpu;          CPU *cpu;
894          int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
895            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
896            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
897            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
898    
899          printf( "\n =====  test cbp =====\n" );          printf( "\n =====  test cbp =====\n" );
900    
# Line 637  Line 914 
914                          continue;                          continue;
915    
916                  TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1);
917                  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",
918                  if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
919                  TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2);
920                  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",
921                  if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
922                  TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3);
923                  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",
924                  if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
925                  TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4);
926                  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",
927                  if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
928                  printf( " --- \n" );                  printf( " --- \n" );
929          }          }
930  }  }
# Line 865  Line 1142 
1142          static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };          static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };
1143          int Loops = 10000;          int Loops = 10000;
1144          int i, m, n;          int i, m, n;
1145          short Blk0[64];     /* reference */          DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1146          short Blk[64], iBlk[64];          DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1147          short Ref_FDCT[64];          DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1148          short Ref_IDCT[64];          DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
1149            DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
1150    
1151          STATS_8x8 FStats; /* forward dct stats */          STATS_8x8 FStats; /* forward dct stats */
1152          STATS_8x8 IStats; /* inverse dct stats */          STATS_8x8 IStats; /* inverse dct stats */
# Line 1042  Line 1320 
1320   * measure raw decoding speed   * measure raw decoding speed
1321   *********************************************************************/   *********************************************************************/
1322    
1323  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)
1324  {  {
1325          FILE *f = 0;          FILE *f = 0;
1326          void *dechandle = 0;          void *dechandle = 0;
# Line 1053  Line 1331 
1331          double t = 0.;          double t = 0.;
1332          int nb = 0;          int nb = 0;
1333          uint8_t *buf = 0;          uint8_t *buf = 0;
1334          uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1335          int buf_size, pos;          int buf_size, pos;
1336          uint32_t chksum = 0;          uint32_t chksum = 0;
1337            int bps = (width+31) & ~31;
1338    
1339          memset(&xinit, 0, sizeof(xinit));          memset(&xinit, 0, sizeof(xinit));
1340          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = cpu_mask;
1341          xinit.version = XVID_VERSION;          xinit.version = XVID_VERSION;
1342          xvid_global(NULL, 0, &xinit, NULL);          xvid_global(NULL, 0, &xinit, NULL);
1343    
# Line 1068  Line 1347 
1347          xparam.version = XVID_VERSION;          xparam.version = XVID_VERSION;
1348          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1349          if (xerr==XVID_ERR_FAIL) {          if (xerr==XVID_ERR_FAIL) {
1350                  printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1351                  return;                  return;
1352          }          }
1353          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1076  Line 1355 
1355    
1356          f = fopen(name, "rb");          f = fopen(name, "rb");
1357          if (f==0) {          if (f==0) {
1358                  printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1359                  return;                  return;
1360          }          }
1361          fseek(f, 0, SEEK_END);          fseek(f, 0, SEEK_END);
1362          buf_size = ftell(f);          buf_size = ftell(f);
1363          fseek(f, 0, SEEK_SET);          fseek(f, 0, SEEK_SET);
1364          if (buf_size<=0) {          if (buf_size<=0) {
1365                  printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1366                  goto End;                  goto End;
1367          }          }
         else printf( "Input size: %d\n", buf_size);  
1368    
1369          buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1370          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1371          if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1372                  printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1373                  goto End;                  goto End;
1374          }          }
1375    
1376          if (fread(buf, buf_size, 1, f)!=1) {          if (fread(buf, buf_size, 1, f)!=1) {
1377                  printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1378                  goto End;                  goto End;
1379          }          }
1380    
# Line 1104  Line 1382 
1382          pos = 0;          pos = 0;
1383          t = -gettime_usec();          t = -gettime_usec();
1384          while(1) {          while(1) {
1385              int y;
1386    
1387                  memset(&xframe, 0, sizeof(xframe));                  memset(&xframe, 0, sizeof(xframe));
1388                  xframe.version = XVID_VERSION;                  xframe.version = XVID_VERSION;
1389                  xframe.bitstream = buf + pos;                  xframe.bitstream = buf + pos;
1390                  xframe.length = buf_size - pos;                  xframe.length = buf_size - pos;
1391                  xframe.output.plane[0] = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1392                  xframe.output.stride[0] = width;                  xframe.output.plane[1] = xframe.output.plane[0] + bps*height;
1393                  xframe.output.csp = XVID_CSP_BGR;                  xframe.output.plane[2] = xframe.output.plane[1] + bps/2;
1394                    xframe.output.stride[0] = bps;
1395                    xframe.output.stride[1] = bps;
1396                    xframe.output.stride[2] = bps;
1397                    xframe.output.csp = XVID_CSP_I420;
1398                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1399                    if (xerr<0) {
1400                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1401                            break;
1402                    }
1403                    else if (xerr==0)
1404                      break;
1405        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1406    
1407                    pos += xerr;
1408                  nb++;                  nb++;
1409                  pos += xframe.length;  
1410                  if (with_chksum) {      for(y=0; y<height/2; ++y) {
1411                          int k = width*height;                    chksum = calc_crc(xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1412                          uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc(xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1413                          while(k-->0) chksum += *ptr++;                          chksum = calc_crc(xframe.output.plane[1] + y*bps, width/2, chksum);
1414                            chksum = calc_crc(xframe.output.plane[2] + y*bps, width/2, chksum);
1415                  }                  }
1416                  if (pos==buf_size)                  if (pos==buf_size)
1417                          break;                          break;
                 if (xerr==XVID_ERR_FAIL) {  
                         printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
                         break;  
                 }  
1418          }          }
1419          t += gettime_usec();          t += gettime_usec();
1420            if (ref_chksum==0) {
1421          if (t>0.)          if (t>0.)
1422                  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 );
1423          if (with_chksum)    }
1424                  printf("checksum: 0x%.8x\n", chksum);    else {
1425                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1426                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1427      }
1428    
1429   End:   End:
1430          if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1431          if (buf!=0) free(buf);          if (buf!=0) free(buf);
1432          if (dechandle!=0) {          if (dechandle!=0) {
1433                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1434                  if (xerr==XVID_ERR_FAIL)                  if (xerr==XVID_ERR_FAIL)
1435                          printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1436          }          }
1437          if (f!=0) fclose(f);          if (f!=0) fclose(f);
1438  }  }
# Line 1150  Line 1444 
1444  void test_bugs1()  void test_bugs1()
1445  {  {
1446          CPU *cpu;          CPU *cpu;
1447            uint16_t mpeg_quant_matrices[64*8];
1448    
1449          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1450    
# Line 1162  Line 1457 
1457                          continue;                          continue;
1458    
1459                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1460                  set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1461                  dequant_mpeg_intra(Dst, Src, 31, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1462                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1463                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1464                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1181  Line 1476 
1476                          continue;                          continue;
1477    
1478                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1479                  set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1480                  dequant_mpeg_inter(Dst, Src, 31);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1481                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1482                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1483                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1193  Line 1488 
1488  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1489  {  {
1490          CPU *cpu;          CPU *cpu;
1491          short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1492            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1493    
1494          printf( "\n =====  fdct/idct precision diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1495    
# Line 1226  Line 1522 
1522          const int max_Q = 31;          const int max_Q = 31;
1523          int i, n, qm, q;          int i, n, qm, q;
1524          CPU *cpu;          CPU *cpu;
1525          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1526            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1527          uint8_t Quant[8*8];          uint8_t Quant[8*8];
1528          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1529          uint16_t Crcs_Inter[2][32];          uint16_t Crcs_Inter[2][32];
1530          uint16_t Crcs_Intra[2][32];          uint16_t Crcs_Intra[2][32];
1531            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1532    
1533          printf( "\n =====  test MPEG4-quantize bug =====\n" );          printf( "\n =====  test MPEG4-quantize bug =====\n" );
1534    
1535          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 1239  Line 1538 
1538          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1539          {          {
1540                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1541                  set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1542    
1543                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1544                  {                  {
# Line 1250  Line 1549 
1549    
1550                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1551                                  emms();                                  emms();
1552                                  quant_mpeg_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1553                                  emms();                                  emms();
1554                                  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;
1555                                  Crcs_Inter[n][q] = s;                                  Crcs_Inter[n][q] = s;
# Line 1269  Line 1568 
1568          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1569          {          {
1570                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1571                  set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1572    
1573                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1574                  {                  {
# Line 1280  Line 1579 
1579    
1580                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1581                                  emms();                                  emms();
1582                                  quant_mpeg_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1583                                  emms();                                  emms();
1584                                  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;
1585                                  Crcs_Intra[n][q] = s;                                  Crcs_Intra[n][q] = s;
# Line 1295  Line 1594 
1594          }          }
1595  #endif  #endif
1596  }  }
1597    /*********************************************************************/
1598    
1599    static uint32_t __inline log2bin_v1(uint32_t value)
1600    {
1601      int n = 0;
1602      while (value) {
1603        value >>= 1;
1604        n++;
1605      }
1606      return n;
1607    }
1608    
1609    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1610    
1611    static uint32_t __inline log2bin_v2(uint32_t value)
1612    {
1613      int n = 0;
1614      if (value & 0xffff0000) {
1615        value >>= 16;
1616        n += 16;
1617      }
1618      if (value & 0xff00) {
1619        value >>= 8;
1620        n += 8;
1621      }
1622      if (value & 0xf0) {
1623        value >>= 4;
1624        n += 4;
1625      }
1626     return n + log2_tab_16[value];
1627    }
1628    
1629    void test_log2bin()
1630    {
1631            const int nb_tests = 3000*speed_ref;
1632      int n, crc1=0, crc2=0;
1633      uint32_t s, s0;
1634      double t1, t2;
1635    
1636      t1 = gettime_usec();
1637      s0 = (int)(t1*31.241);
1638      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1639        crc1 += log2bin_v1(s);
1640      t1 = (gettime_usec()-t1) / nb_tests;
1641    
1642      t2 = gettime_usec();
1643      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1644        crc2 += log2bin_v2(s);
1645      t2 = (gettime_usec() - t2) / nb_tests;
1646    
1647      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1648      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1649      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1650    }
1651    
1652    /*********************************************************************/
1653    
1654    static void __inline old_gcd(int *num, int *den)
1655    {
1656     int i = *num;
1657      while (i > 1) {
1658        if (*num % i == 0 && *den % i == 0) {
1659          *num /= i;
1660          *den /= i;
1661          i = *num;
1662          continue;
1663        }
1664        i--;
1665      }
1666    }
1667    
1668    static uint32_t gcd(int num, int den)
1669    {
1670      int tmp;
1671      while( (tmp=num%den) ) { num = den; den = tmp; }
1672      return den;
1673    }
1674    static void __inline new_gcd(int *num, int *den)
1675    {
1676      const int div = gcd(*num, *den);
1677      if (num) {
1678        *num /= div;
1679        *den /= div;
1680      }
1681    }
1682    
1683    void test_gcd()
1684    {
1685            const int nb_tests = 10*speed_ref;
1686      int i;
1687      uint32_t crc1=0, crc2=0;
1688      uint32_t n0, n, d0, d;
1689      double t1, t2;
1690    
1691      t1 = gettime_usec();
1692      n0 = 0xfffff & (int)(t1*31.241);
1693      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1694      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1695        old_gcd(&n, &d);
1696        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1697        n = d;
1698        d = (d*12363+31) & 0xffff;
1699        d |= !d;
1700      }
1701      t1 = (gettime_usec()-t1) / nb_tests;
1702    
1703      t2 = gettime_usec();
1704      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1705        new_gcd(&n, &d);
1706        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1707        n = d;
1708        d = (d*12363+31) & 0xffff;
1709        d |= !d;
1710      }
1711      t2 = (gettime_usec() - t2) / nb_tests;
1712    
1713      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1714      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1715      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1716    }
1717    
1718  /*********************************************************************  /*********************************************************************
1719   * main   * main
1720   *********************************************************************/   *********************************************************************/
1721    
1722  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
1723    {
1724      printf( "missing argument after option '%s'\n", opt);
1725      exit(-1);
1726    }
1727    
1728    int main(int argc, const char *argv[])
1729  {  {
1730          int what = 0;          int c, what = 0;
1731          if (argc>1) what = atoi(argv[1]);          int width, height;
1732            uint32_t chksum = 0;
1733      const char * test_bitstream = 0;
1734    
1735            cpu_mask = 0;  // default => will use autodectect
1736            for(c=1; c<argc; ++c)
1737            {
1738              if (!strcmp(argv[c], "-v")) verbose++;
1739              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
1740              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
1741              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1742              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1743              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
1744              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
1745              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
1746              else if (!strcmp(argv[c], "-spd")) {
1747          if (++c==argc) arg_missing( argv[argc-1] );
1748          speed_ref = atoi(argv[c]);
1749        }
1750              else if (argv[c][0]!='-') {
1751                what = atoi(argv[c]);
1752                if (what==9) {
1753                  if (c+4>argc) {
1754                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
1755                    exit(-1);
1756            }
1757            test_bitstream = argv[++c];
1758                  width  = atoi(argv[++c]);
1759                  height = atoi(argv[++c]);
1760                  if (c+1<argc && argv[c+1][0]!='-') {
1761                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
1762                      printf( "can't read checksum value.\n" );
1763                      exit(-1);
1764              }
1765              else c++;
1766            }
1767    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
1768          }
1769        }
1770        else {
1771          printf( "unrecognized option '%s'\n", argv[c]);
1772          exit(-1);
1773        }
1774      }
1775    
1776    
1777          if (what==0 || what==1) test_dct();          if (what==0 || what==1) test_dct();
1778          if (what==0 || what==2) test_mb();          if (what==0 || what==2) test_mb();
1779          if (what==0 || what==3) test_sad();          if (what==0 || what==3) test_sad();
1780          if (what==0 || what==4) test_transfer();          if (what==0 || what==4) test_transfer();
1781          if (what==0 || what==5) test_quant();          if (what==0 || what==5) test_quant();
1782          if (what==0 || what==6) test_cbp();          if (what==0 || what==6) test_cbp();
1783            if (what==0 || what==10) test_sse();
1784            if (what==0 || what==11) test_log2bin();
1785            if (what==0 || what==12) test_gcd();
1786    
1787    
1788          if (what==7) {          if (what==7) {
1789                  test_IEEE1180_compliance(-256, 255, 1);                  test_IEEE1180_compliance(-256, 255, 1);
 #if 0  
1790                  test_IEEE1180_compliance(-256, 255,-1);                  test_IEEE1180_compliance(-256, 255,-1);
1791                  test_IEEE1180_compliance(  -5,   5, 1);                  test_IEEE1180_compliance(  -5,   5, 1);
1792                  test_IEEE1180_compliance(  -5,   5,-1);                  test_IEEE1180_compliance(  -5,   5,-1);
1793                  test_IEEE1180_compliance(-300, 300, 1);                  test_IEEE1180_compliance(-300, 300, 1);
1794                  test_IEEE1180_compliance(-300, 300,-1);                  test_IEEE1180_compliance(-300, 300,-1);
 #endif  
1795          }          }
1796          if (what==8) test_dct_saturation(-256, 255);          if (what==8) test_dct_saturation(-256, 255);
1797    
1798          if (what==9) {          if (test_bitstream)
1799                  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));  
         }  
   
1800          if (what==-1) {          if (what==-1) {
1801                  test_dct_precision_diffs();                  test_dct_precision_diffs();
1802                  test_bugs1();                  test_bugs1();
# Line 1341  Line 1804 
1804          if (what==-2)          if (what==-2)
1805                  test_quant_bug();                  test_quant_bug();
1806    
1807          return 0;          if ((what >= 0 && what <= 6) || what == 10) {
1808                    printf("\n\n"
1809                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1810                               "    a C function is used instead. So don't panic if some functions\n"
1811                               "    may appear to be slow.\n");
1812  }  }
1813    
1814  /*********************************************************************  #ifdef ARCH_IS_IA32
1815   * 'Reference' output (except for timing) on a PIII 1.13Ghz/linux          if (what == 0 || what == 5) {
1816   *********************************************************************/                  printf("\n"
1817                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1818  /* as of 07/01/2002, there's a problem with mpeg4-quantization */                             "    for 1 or 2 coefficients a block. This is mainly caused by the fact the unit\n"
1819  /*                             "    test goes far behind the usual limits of real encoding. Please do not report\n"
1820                               "    this error to the developers.\n");
1821            }
1822    #endif
1823    
1824  ===== test fdct/idct =====          return 0;
1825  PLAINC -  3.312 usec       PSNR=13.291  MSE=3.000  }
 MMX    -  0.591 usec       PSNR=13.291  MSE=3.000  
 MMXEXT -  0.577 usec       PSNR=13.291  MSE=3.000  
 SSE2   -  0.588 usec       PSNR=13.291  MSE=3.000  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
 ===  test block motion ===  
 PLAINC - interp- h-round0 0.911 usec       iCrc=8107  
 PLAINC -           round1 0.863 usec       iCrc=8100  
 PLAINC - interp- v-round0 0.860 usec       iCrc=8108  
 PLAINC -           round1 0.857 usec       iCrc=8105  
 PLAINC - interp-hv-round0 2.103 usec       iCrc=8112  
 PLAINC -           round1 2.050 usec       iCrc=8103  
 ---  
 MMX    - interp- h-round0 0.105 usec       iCrc=8107  
 MMX    -           round1 0.106 usec       iCrc=8100  
 MMX    - interp- v-round0 0.106 usec       iCrc=8108  
 MMX    -           round1 0.106 usec       iCrc=8105  
 MMX    - interp-hv-round0 0.145 usec       iCrc=8112  
 MMX    -           round1 0.145 usec       iCrc=8103  
 ---  
 MMXEXT - interp- h-round0 0.028 usec       iCrc=8107  
 MMXEXT -           round1 0.041 usec       iCrc=8100  
 MMXEXT - interp- v-round0 0.027 usec       iCrc=8108  
 MMXEXT -           round1 0.041 usec       iCrc=8105  
 MMXEXT - interp-hv-round0 0.066 usec       iCrc=8112  
 MMXEXT -           round1 0.065 usec       iCrc=8103  
 ---  
 SSE2   - interp- h-round0 0.109 usec       iCrc=8107  
 SSE2   -           round1 0.105 usec       iCrc=8100  
 SSE2   - interp- v-round0 0.106 usec       iCrc=8108  
 SSE2   -           round1 0.109 usec       iCrc=8105  
 SSE2   - interp-hv-round0 0.145 usec       iCrc=8112  
 SSE2   -           round1 0.145 usec       iCrc=8103  
 ---  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
 ======  test SAD ======  
 PLAINC - sad8    0.251 usec       sad=3776  
 PLAINC - sad16   1.601 usec       sad=27214  
 PLAINC - sad16bi 2.371 usec       sad=26274  
 PLAINC - dev16   1.564 usec       sad=3344  
 ---  
 MMX    - sad8    0.057 usec       sad=3776  
 MMX    - sad16   0.182 usec       sad=27214  
 MMX    - sad16bi 2.462 usec       sad=26274  
 MMX    - dev16   0.311 usec       sad=3344  
 ---  
 MMXEXT - sad8    0.036 usec       sad=3776  
 MMXEXT - sad16   0.109 usec       sad=27214  
 MMXEXT - sad16bi 0.143 usec       sad=26274  
 MMXEXT - dev16   0.192 usec       sad=3344  
 ---  
 SSE2   - sad8    0.057 usec       sad=3776  
 SSE2   - sad16   0.179 usec       sad=27214  
 SSE2   - sad16bi 2.456 usec       sad=26274  
 SSE2   - dev16   0.321 usec       sad=3344  
 ---  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
 ===  test transfer ===  
 PLAINC - 8to16     0.151 usec       crc=28288  
 PLAINC - 16to8     1.113 usec       crc=28288  
 PLAINC - 8to8      0.043 usec       crc=20352  
 PLAINC - 16to8add  1.069 usec       crc=25536  
 PLAINC - 8to16sub  0.631 usec       crc1=28064 crc2=16256  
 PLAINC - 8to16sub2 0.597 usec       crc=20384  
 ---  
 MMX    - 8to16     0.032 usec       crc=28288  
 MMX    - 16to8     0.024 usec       crc=28288  
 MMX    - 8to8      0.020 usec       crc=20352  
 MMX    - 16to8add  0.043 usec       crc=25536  
 MMX    - 8to16sub  0.066 usec       crc1=28064 crc2=16256  
 MMX    - 8to16sub2 0.111 usec       crc=20384  
 ---  
   
 =====  test quant =====  
 PLAINC -   quant4_intra 74.248 usec       crc=29809  
 PLAINC -   quant4_inter 70.850 usec       crc=12574  
 PLAINC - dequant4_intra 40.628 usec       crc=24052  
 PLAINC - dequant4_inter 45.691 usec       crc=63847  
 PLAINC -    quant_intra 43.357 usec       crc=25662  
 PLAINC -    quant_inter 33.410 usec       crc=23972  
 PLAINC -  dequant_intra 36.384 usec       crc=49900  
 PLAINC -  dequant_inter 48.930 usec       crc=48899  
 ---  
 MMX    -   quant4_intra 7.445 usec       crc=3459  
 *** CRC ERROR! ***  
 MMX    -   quant4_inter 5.384 usec       crc=51072  
 *** CRC ERROR! ***  
 MMX    - dequant4_intra 5.515 usec       crc=24052  
 MMX    - dequant4_inter 7.745 usec       crc=63847  
 MMX    -    quant_intra 4.661 usec       crc=25662  
 MMX    -    quant_inter 4.406 usec       crc=23972  
 MMX    -  dequant_intra 4.928 usec       crc=49900  
 MMX    -  dequant_inter 4.532 usec       crc=48899  
 ---  
   
 =====  test cbp =====  
 PLAINC -   calc_cbp#1 0.371 usec       cbp=0x15  
 PLAINC -   calc_cbp#2 0.432 usec       cbp=0x38  
 PLAINC -   calc_cbp#3 0.339 usec       cbp=0xf  
 PLAINC -   calc_cbp#4 0.506 usec       cbp=0x5  
 ---  
 MMX    -   calc_cbp#1 0.136 usec       cbp=0x15  
 MMX    -   calc_cbp#2 0.134 usec       cbp=0x38  
 MMX    -   calc_cbp#3 0.138 usec       cbp=0xf  
 MMX    -   calc_cbp#4 0.135 usec       cbp=0x5  
 ---  
 SSE2   -   calc_cbp#1 0.136 usec       cbp=0x15  
 SSE2   -   calc_cbp#2 0.133 usec       cbp=0x38  
 SSE2   -   calc_cbp#3 0.133 usec       cbp=0xf  
 SSE2   -   calc_cbp#4 0.141 usec       cbp=0x5  
 ---  
1826    
1827  */  /*********************************************************************/
Legend:
Removed from v.1.9.2.5  
changed lines
  Added in v.1.21
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4