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