[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.33, Mon Oct 30 11:21:42 2006 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        /* New functions for field prediction by CK 1.10.2005 */
522    #pragma NEW8X4
523                    TEST_MB(interpolate8x4_halfpel_h, 0);
524                    printf("%s - interpfield-h -round0 %.3f usec       crc32=0x%08x %s\n",
525                               cpu->name, t, iCrc,
526                               (iCrc!=0x9538d6df)?"| ERROR": "" );
527    
528                    TEST_MB(interpolate8x4_halfpel_h, 1);
529                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
530                               cpu->name, t, iCrc,
531                               (iCrc!=0xde5f1db4)?"| ERROR": "" );
532    
533    
534                    TEST_MB(interpolate8x4_halfpel_v, 0);
535                    printf("%s - interpfield- v-round0 %.3f usec       crc32=0x%08x %s\n",
536                               cpu->name, t, iCrc,
537                               (iCrc!=0xea5a69ef)?"| ERROR": "" );
538    
539                    TEST_MB(interpolate8x4_halfpel_v, 1);
540                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
541                               cpu->name, t, iCrc,
542                               (iCrc!=0x4f10ec0f)?"| ERROR": "" );
543    
544    
545                    TEST_MB(interpolate8x4_halfpel_hv, 0);
546                    printf("%s - interpfield-hv-round0 %.3f usec       crc32=0x%08x %s\n",
547                               cpu->name, t, iCrc,
548                               (iCrc!=0xf97ee367)?"| ERROR": "" );
549    
550                    TEST_MB(interpolate8x4_halfpel_hv, 1);
551                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
552                               cpu->name, t, iCrc,
553                               (iCrc!=0xb6a9f581)?"| ERROR": "" );
554    /* End of 8x4 functions */
555    
556                  printf( " --- \n" );                  printf( " --- \n" );
557          }          }
558  }  }
559    
560    #undef ENTER
561    #undef LEAVE
562    #undef TEST_MB
563    #undef TEST_MB2
564    
565  /*********************************************************************  /*********************************************************************
566   * test transfer   * test transfer
567   *********************************************************************/   *********************************************************************/
# Line 412  Line 591 
591  }                                         \  }                                         \
592  emms();                                   \  emms();                                   \
593  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
594  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]));  \
595    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
596    
597  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
598  TEST_TRANSFER_BEGIN(DST);                 \  TEST_TRANSFER_BEGIN(DST);                 \
# Line 438  Line 618 
618  }                                         \  }                                         \
619  emms();                                   \  emms();                                   \
620  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
621  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]));  \
622    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
623    
624  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
625  TEST_TRANSFER2_BEGIN(DST,SRC);            \  TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 455  Line 636 
636          const int nb_tests = 4000*speed_ref;          const int nb_tests = 4000*speed_ref;
637          int i;          int i;
638          CPU *cpu;          CPU *cpu;
639          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];
640          int16_t Src16[8*32], Dst16[8*32];  //      int16_t Src16[8*32], Dst16[8*32];
641      DECLARE_ALIGNED_MATRIX(Src8, 8, 32, uint8_t, CACHE_LINE);
642      DECLARE_ALIGNED_MATRIX(Dst8, 8, 32, uint8_t, CACHE_LINE);
643      DECLARE_ALIGNED_MATRIX(Ref1, 8, 32, uint8_t, CACHE_LINE);
644      DECLARE_ALIGNED_MATRIX(Ref2, 8, 32, uint8_t, CACHE_LINE);
645      DECLARE_ALIGNED_MATRIX(Src16, 8, 32, uint16_t, CACHE_LINE);
646      DECLARE_ALIGNED_MATRIX(Dst16, 8, 32, uint16_t, CACHE_LINE);
647    
648          printf( "\n ===  test transfer ===\n" );          printf( "\n ===  test transfer ===\n" );
649    
# Line 469  Line 656 
656                          continue;                          continue;
657    
658                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
659                  printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
660                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
661                               (s!=0x115814bb)?"| ERROR": "");
662    
663                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
664                  printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
665                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
666                                    (s!=0xee7ccbb4)?"| ERROR": "");
667    
668        /* New functions for field prediction by CK 1.10.2005 */
669    #pragma NEW8X4
670                    TEST_TRANSFER(transfer8x4_copy, Dst8, Src8);
671                    printf("%s - 8to4      %.3f usec       crc32=0x%08x %s\n",
672                               cpu->name, t, s,
673                               (s!=0xbb9c3db5)?"| ERROR": "");
674    /* End of new functions */
675    
676                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
677                  printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
678                  if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
679                               (s!=0xd37b3295)?"| ERROR": "");
680    
681                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
682                  printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
683                  if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
684                               (s!=0xdd817bf4)?"| ERROR": "" );
685    
686                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
687                  printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
688                  if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
689                  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);
690                  printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, 8*32*sizeof(Src8[0]), CRC32_INITIAL);
691                  if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
692                                       cpu->name, t, s1, s2,
693                                       (s1!=0xa1e07163)?"| ERROR1": "",
694                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
695                    }
696    
697                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
698                  printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
699                  if (s!=22368) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
700                               (s!=0x99b6c4c7)?"| ERROR": "" );
701    
702                  printf( " --- \n" );                  printf( " --- \n" );
703          }          }
# Line 505  Line 709 
709    
710  #define TEST_QUANT(FUNC, DST, SRC)              \  #define TEST_QUANT(FUNC, DST, SRC)              \
711  t = gettime_usec();                         \  t = gettime_usec();                         \
712  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
713    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
714    set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
715    emms();                                   \    emms();                                   \
716    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
717          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
718            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
719          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
720            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
721    }                                         \    }                                         \
722    emms();                                   \    emms();                                   \
723  }                                           \  }                                           \
724  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
 s = (s&0xffff)^(s>>16)  
725    
726  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
727  t = gettime_usec();                         \  t = gettime_usec();                         \
728  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
729    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
730    set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
731    emms();                                   \    emms();                                   \
732    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
733          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
734            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
735          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
736            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
737      }                                         \
738      emms();                                   \
739    }                                           \
740    t = (gettime_usec()-t-overhead)/nb_tests/qm
741    
742    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
743    { int i,q,s;\
744            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
745      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
746      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
747      for(q=1;q<=max_Q;q++)          \
748        for(s=-RANGE;s<RANGE;s++) { \
749          for(i=0;i<64;i++) Src[i]=s; \
750          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
751          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
752          for(i=0;i<64;i++)     \
753            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]);  \
754    }                                         \    }                                         \
755    }
756    
757    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
758    { int i,q,s;  \
759            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
760      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
761      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
762      for(q=1;q<=max_Q;q++)  \
763        for(s=-RANGE;s<RANGE;s++) {   \
764          for(i=0;i<64;i++) Src[i]=s; \
765          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
766          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
767    emms();                                   \    emms();                                   \
768          for(i=0;i<64;i++) \
769            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]); \
770  }                                           \  }                                           \
771  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  }
 s = (s&0xffff)^(s>>16)  
772    
773  void test_quant()  void test_quant()
774  {  {
775          const int nb_tests = 1*speed_ref;          const int nb_tests = 1*speed_ref;
776          const int max_Q = 31;          const int max_Q = 31;
777            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
778    
779          int i, qm;          int i, qm;
780          CPU *cpu;          CPU *cpu;
781          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
782            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
783            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
784          uint8_t Quant[8*8];          uint8_t Quant[8*8];
785    
786          printf( "\n =====  test quant =====\n" );          printf( "\n =====  test quant =====\n" );
# Line 562  Line 801 
801                  if (!init_cpu(cpu))                  if (!init_cpu(cpu))
802                  continue;                  continue;
803    
804                    // exhaustive tests to compare against the (ref) C-version
805                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
806                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
807                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
808                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
809    
810                  overhead = -gettime_usec();                  overhead = -gettime_usec();
811                  for(s=0,qm=1; qm<=255; ++qm) {                  for(s=0,qm=1; qm<=255; ++qm) {
812                          for(i=0; i<8*8; ++i) Quant[i] = qm;                          for(i=0; i<8*8; ++i) Quant[i] = qm;
813                          set_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
814                          for(q=1; q<=max_Q; ++q)                          for(q=1; q<=max_Q; ++q)
815                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
816                  }                  }
817                  overhead += gettime_usec();                  overhead += gettime_usec();
818    
 #if 1  
819                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
820                  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",
821                  if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
822                               (s!=0xfd6a21a4)? "| ERROR": "");
823    
824                  TEST_QUANT(quant_mpeg_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
825                  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",
826                  if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
827  #endif                             (s!=0xf6de7757)?"| ERROR": "");
828  #if 1  
829                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
830                  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",
831                  if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
832                               (s!=0x2def7bc7)?"| ERROR": "");
833    
834                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
835                  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",
836                  if (s!=63847) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
837  #endif                             (s!=0xd878c722)?"| ERROR": "");
838  #if 1  
839                  TEST_QUANT2(quant_h263_intra, Dst, Src);                  TEST_QUANT2(quant_h263_intra, Dst, Src);
840                  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",
841                  if (s!=25662) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
842                               (s!=0x2eba9d43)?"| ERROR": "");
843    
844                  TEST_QUANT(quant_h263_inter, Dst, Src);                  TEST_QUANT(quant_h263_inter, Dst, Src);
845                  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",
846                  if (s!=23972) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
847  #endif                             (s!=0xbd315a7e)?"| ERROR": "");
848  #if 1  
849                  TEST_QUANT2(dequant_h263_intra, Dst, Src);                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
850                  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",
851                  if (s!=49900) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
852                               (s!=0x9841212a)?"| ERROR": "");
853    
854                  TEST_QUANT(dequant_h263_inter, Dst, Src);                  TEST_QUANT(dequant_h263_inter, Dst, Src);
855                  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",
856                  if (s!=48899) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
857  #endif                             (s!=0xe7df8fba)?"| ERROR": "");
858    
859                    printf( " --- \n" );
860            }
861    }
862    
863    /*********************************************************************
864     * test distortion operators
865     *********************************************************************/
866    
867    static void ieee_reseed(long s);
868    static long ieee_rand(int Min, int Max);
869    
870    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
871      do { \
872        t = gettime_usec(); \
873        tst = nb_tests; \
874        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
875        emms(); \
876        t = (gettime_usec() - t)/(double)nb_tests;  \
877      } while(0)
878    
879    
880    void test_sse()
881    {
882            const int nb_tests = 100000*speed_ref;
883            int i;
884            CPU *cpu;
885            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
886            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
887            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
888            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
889    
890            printf( "\n =====  test sse =====\n" );
891    
892            ieee_reseed(1);
893            for(i=0; i<64; ++i) {
894                    Src1[i] = ieee_rand(-2048, 2047);
895                    Src2[i] = ieee_rand(-2048, 2047);
896                    Src3[i] = ieee_rand(-2048, 2047);
897                    Src4[i] = ieee_rand(-2048, 2047);
898            }
899    
900            for(cpu = cpu_list; cpu->name!=0; ++cpu)
901            {
902                    double t;
903                    int tst, sse;
904    
905                    if (!init_cpu(cpu))
906                            continue;
907    
908                    /* 16 bit element blocks */
909                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
910                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
911                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
912                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
913                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
914                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
915                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
916                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
917                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
918                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
919                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
920                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
921                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
922                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
923                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
924                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
925                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
926                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
927    
928                    /* 8 bit element blocks */
929                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
930                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
931                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
932                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
933                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
934                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
935                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
936                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
937                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
938                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
939                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
940                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
941                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
942                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
943                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
944                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
945                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
946                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
947    
948                  printf( " --- \n" );                  printf( " --- \n" );
949          }          }
950  }  }
# Line 615  Line 953 
953   * test non-zero AC counting   * test non-zero AC counting
954   *********************************************************************/   *********************************************************************/
955    
956  #define TEST_CBP(FUNC, SRC)                   \  #define TEST_CBP(FUNC, SRC, NB)           \
957  t = gettime_usec();                       \  t = gettime_usec();                       \
958  emms();                                   \  emms();                                   \
959  for(tst=0; tst<nb_tests; ++tst) {         \  for(tst=0; tst<NB; ++tst) {         \
960    cbp = (FUNC)((SRC));                    \    cbp = (FUNC)((SRC));                    \
961  }                                         \  }                                         \
962  emms();                                   \  emms();                                   \
# Line 627  Line 965 
965  void test_cbp()  void test_cbp()
966  {  {
967          const int nb_tests = 10000*speed_ref;          const int nb_tests = 10000*speed_ref;
968          int i;          int i, n, m;
969          CPU *cpu;          CPU *cpu;
970          int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
971            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
972            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
973            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
974      DECLARE_ALIGNED_MATRIX(Src5, 6, 64, int16_t, 16);
975    
976          printf( "\n =====  test cbp =====\n" );          printf( "\n =====  test cbp =====\n" );
977    
# Line 638  Line 980 
980                  Src2[i] = (i<3*64);               /* half-full */                  Src2[i] = (i<3*64);               /* half-full */
981                  Src3[i] = ((i+32)>3*64);                  Src3[i] = ((i+32)>3*64);
982                  Src4[i] = (i==(3*64+2) || i==(5*64+9));                  Src4[i] = (i==(3*64+2) || i==(5*64+9));
983        Src5[i] = ieee_rand(0,1) ? -1 : 1;  /* +/- test */
984          }          }
985    
986          for(cpu = cpu_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
# Line 648  Line 991 
991                  if (!init_cpu(cpu))                  if (!init_cpu(cpu))
992                          continue;                          continue;
993    
994                  TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1, nb_tests);
995                  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",
996                  if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
997                  TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2, nb_tests);
998                  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",
999                  if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
1000                  TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3, nb_tests);
1001                  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",
1002                  if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
1003                  TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4, nb_tests);
1004                  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",
1005                  if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
1006                    TEST_CBP(calc_cbp, Src5, nb_tests);
1007                    printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
1008                               cpu->name, t, cbp, (cbp!=0x3f)?"| ERROR": "" );
1009                  printf( " --- \n" );                  printf( " --- \n" );
1010          }          }
1011    
1012            for(cpu = cpu_list; cpu->name!=0; ++cpu)  /* bench suggested by Carlo (carlo dot bramix at libero dot it) */
1013            {
1014                    double t;
1015                    int tst, cbp, err;
1016    
1017                    if (!init_cpu(cpu))
1018                            continue;
1019    
1020        err = 0;
1021        for(n=0; n<6; ++n)
1022        {
1023          for(m=0; m<64; ++m)
1024          {
1025            for(i=0; i<6*64; ++i)
1026              Src1[i] = (i== (m + n*64));
1027    
1028            TEST_CBP(calc_cbp, Src1, 1);
1029            if (cbp!= (((m!=0)<<(5-n))))
1030            {
1031              printf( "%s -   calc_cbp#5: ERROR at pos %d / %d!\n", cpu->name, n, m);
1032              err = 1;
1033              break;
1034            }
1035          }
1036        }
1037        if (!err)
1038          printf( " %s -    calc_cbp#5 : OK\n", cpu->name );
1039    
1040            }
1041  }  }
1042    
1043  /*********************************************************************  /*********************************************************************
# Line 1055  Line 1431 
1431   * measure raw decoding speed   * measure raw decoding speed
1432   *********************************************************************/   *********************************************************************/
1433    
1434  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)
1435  {  {
1436          FILE *f = 0;          FILE *f = 0;
1437          void *dechandle = 0;          void *dechandle = 0;
# Line 1066  Line 1442 
1442          double t = 0.;          double t = 0.;
1443          int nb = 0;          int nb = 0;
1444          uint8_t *buf = 0;          uint8_t *buf = 0;
1445          uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1446          int buf_size, pos;          int buf_size, pos;
1447          uint32_t chksum = 0;          uint32_t chksum = 0;
1448            int bps = (width+31) & ~31;
1449    
1450          memset(&xinit, 0, sizeof(xinit));          memset(&xinit, 0, sizeof(xinit));
1451          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = cpu_mask;
1452          xinit.version = XVID_VERSION;          xinit.version = XVID_VERSION;
1453          xvid_global(NULL, 0, &xinit, NULL);          xvid_global(NULL, 0, &xinit, NULL);
1454    
# Line 1081  Line 1458 
1458          xparam.version = XVID_VERSION;          xparam.version = XVID_VERSION;
1459          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1460          if (xerr==XVID_ERR_FAIL) {          if (xerr==XVID_ERR_FAIL) {
1461                  printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1462                  return;                  return;
1463          }          }
1464          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1089  Line 1466 
1466    
1467          f = fopen(name, "rb");          f = fopen(name, "rb");
1468          if (f==0) {          if (f==0) {
1469                  printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1470                  return;                  return;
1471          }          }
1472          fseek(f, 0, SEEK_END);          fseek(f, 0, SEEK_END);
1473          buf_size = ftell(f);          buf_size = ftell(f);
1474          fseek(f, 0, SEEK_SET);          fseek(f, 0, SEEK_SET);
1475          if (buf_size<=0) {          if (buf_size<=0) {
1476                  printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1477                  goto End;                  goto End;
1478          }          }
         else printf( "Input size: %d\n", buf_size);  
1479    
1480          buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1481          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1482          if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1483                  printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1484                  goto End;                  goto End;
1485          }          }
1486    
1487          if (fread(buf, buf_size, 1, f)!=1) {          if (fread(buf, buf_size, 1, f)!=1) {
1488                  printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1489                  goto End;                  goto End;
1490          }          }
1491    
# Line 1117  Line 1493 
1493          pos = 0;          pos = 0;
1494          t = -gettime_usec();          t = -gettime_usec();
1495          while(1) {          while(1) {
1496              int y;
1497    
1498                  memset(&xframe, 0, sizeof(xframe));                  memset(&xframe, 0, sizeof(xframe));
1499                  xframe.version = XVID_VERSION;                  xframe.version = XVID_VERSION;
1500                  xframe.bitstream = buf + pos;                  xframe.bitstream = buf + pos;
1501                  xframe.length = buf_size - pos;                  xframe.length = buf_size - pos;
1502                  xframe.output.plane[0] = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1503                  xframe.output.stride[0] = width;                  xframe.output.plane[1] = (uint8_t*)xframe.output.plane[0] + bps*height;
1504                  xframe.output.csp = XVID_CSP_BGR;                  xframe.output.plane[2] = (uint8_t*)xframe.output.plane[1] + bps/2;
1505                    xframe.output.stride[0] = bps;
1506                    xframe.output.stride[1] = bps;
1507                    xframe.output.stride[2] = bps;
1508                    xframe.output.csp = XVID_CSP_I420;
1509                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1510                    if (xerr<0) {
1511                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1512                            break;
1513                    }
1514                    else if (xerr==0)
1515                      break;
1516        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1517    
1518                    pos += xerr;
1519                  nb++;                  nb++;
1520                  pos += xframe.length;  
1521                  if (with_chksum) {      for(y=0; y<height/2; ++y) {
1522                          int k = width*height;                    chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1523                          uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1524                          while(k-->0) chksum += *ptr++;                          chksum = calc_crc((uint8_t*)xframe.output.plane[1] + y*bps, width/2, chksum);
1525                            chksum = calc_crc((uint8_t*)xframe.output.plane[2] + y*bps, width/2, chksum);
1526                  }                  }
1527                  if (pos==buf_size)                  if (pos==buf_size)
1528                          break;                          break;
                 if (xerr==XVID_ERR_FAIL) {  
                         printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
                         break;  
                 }  
1529          }          }
1530          t += gettime_usec();          t += gettime_usec();
1531            if (ref_chksum==0) {
1532          if (t>0.)          if (t>0.)
1533                  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 );
1534          if (with_chksum)    }
1535                  printf("checksum: 0x%.8x\n", chksum);    else {
1536                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1537                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1538      }
1539    
1540   End:   End:
1541          if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1542          if (buf!=0) free(buf);          if (buf!=0) free(buf);
1543          if (dechandle!=0) {          if (dechandle!=0) {
1544                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1545                  if (xerr==XVID_ERR_FAIL)                  if (xerr==XVID_ERR_FAIL)
1546                          printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1547          }          }
1548          if (f!=0) fclose(f);          if (f!=0) fclose(f);
1549  }  }
# Line 1163  Line 1555 
1555  void test_bugs1()  void test_bugs1()
1556  {  {
1557          CPU *cpu;          CPU *cpu;
1558            uint16_t mpeg_quant_matrices[64*8];
1559    
1560          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1561    
# Line 1175  Line 1568 
1568                          continue;                          continue;
1569    
1570                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1571                  set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1572                  dequant_mpeg_intra(Dst, Src, 31, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1573                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1574                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1575                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1194  Line 1587 
1587                          continue;                          continue;
1588    
1589                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1590                  set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1591                  dequant_mpeg_inter(Dst, Src, 31);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1592                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1593                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1594                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1206  Line 1599 
1599  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1600  {  {
1601          CPU *cpu;          CPU *cpu;
1602          short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1603            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1604    
1605          printf( "\n =====  fdct/idct precision diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1606    
# Line 1239  Line 1633 
1633          const int max_Q = 31;          const int max_Q = 31;
1634          int i, n, qm, q;          int i, n, qm, q;
1635          CPU *cpu;          CPU *cpu;
1636          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1637            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1638          uint8_t Quant[8*8];          uint8_t Quant[8*8];
1639          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1640          uint16_t Crcs_Inter[2][32];          uint16_t Crcs_Inter[2][32];
1641          uint16_t Crcs_Intra[2][32];          uint16_t Crcs_Intra[2][32];
1642            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1643    
1644          printf( "\n =====  test MPEG4-quantize bug =====\n" );          printf( "\n =====  test MPEG4-quantize bug =====\n" );
1645    
1646          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 1649 
1649          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1650          {          {
1651                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1652                  set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1653    
1654                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1655                  {                  {
# Line 1263  Line 1660 
1660    
1661                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1662                                  emms();                                  emms();
1663                                  quant_mpeg_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1664                                  emms();                                  emms();
1665                                  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;
1666                                  Crcs_Inter[n][q] = s;                                  Crcs_Inter[n][q] = s;
# Line 1282  Line 1679 
1679          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1680          {          {
1681                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1682                  set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1683    
1684                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1685                  {                  {
# Line 1293  Line 1690 
1690    
1691                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1692                                  emms();                                  emms();
1693                                  quant_mpeg_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1694                                  emms();                                  emms();
1695                                  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;
1696                                  Crcs_Intra[n][q] = s;                                  Crcs_Intra[n][q] = s;
# Line 1310  Line 1707 
1707  }  }
1708    
1709  /*********************************************************************  /*********************************************************************
1710     * test some YUV func
1711     *********************************************************************/
1712    
1713    #define ENTER \
1714    for(i=0; i<(int)sizeof(Dst0); ++i) Dst0[0][i] = 0;   \
1715    t = gettime_usec();                   \
1716    emms();
1717    
1718    #define LEAVE \
1719    emms();                             \
1720    t = (gettime_usec() - t) / nb_tests;  \
1721            iCrc = calc_crc((uint8_t*)Dst0, sizeof(Dst0), CRC32_INITIAL)
1722    
1723    #define TEST_YUYV(FUNC, S)                \
1724    ENTER                               \
1725    for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst0[0], S*WIDTH, Src0[0], Src0[1], Src0[2], WIDTH, WIDTH/2, WIDTH, HEIGHT, 0); \
1726    LEAVE
1727    
1728    #define WIDTH 128
1729    #define HEIGHT 32
1730    void test_yuv()
1731    {
1732            const int nb_tests = 200*speed_ref;
1733            CPU *cpu;
1734            uint8_t Src0[3][WIDTH*HEIGHT];
1735            uint8_t Dst0[4][WIDTH*HEIGHT];
1736            int i, j;
1737            double t;
1738            int tst, iCrc;
1739    
1740            colorspace_init();
1741            ieee_reseed(1);
1742            for(i=0; i<(int)sizeof(Src0); ++i) Src0[0][i] = ieee_rand(0,255);
1743            for(i=0; i<(int)sizeof(Dst0); ++i) Dst0[0][i] = 0x5a;
1744    
1745            printf( "\n ===  test YUV ===\n" );
1746    
1747            init_cpu(&cpu_list[0]);
1748            TEST_YUYV(yv12_to_yuyv_c, 4);
1749            printf(" yv12_to_yuyv_c %.3f usec       crc32=0x%08x %s\n",
1750                       t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1751            TEST_YUYV(yv12_to_uyvy_c, 4);
1752            printf(" yv12_to_uyvy_c %.3f usec       crc32=0x%08x %s\n",
1753                       t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1754    
1755    #ifdef ARCH_IS_IA32
1756            init_cpu(&cpu_list[1]);
1757            TEST_YUYV(yv12_to_yuyv_mmx, 4);
1758            printf(" yv12_to_yuyv_mmx %.3f usec       crc32=0x%08x %s\n",
1759                    t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1760    
1761            TEST_YUYV(yv12_to_uyvy_mmx, 4);
1762            printf(" yv12_to_uyvy_mmx %.3f usec       crc32=0x%08x %s\n",
1763                    t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1764    #endif
1765    
1766    #ifdef ARCH_IS_PPC
1767            init_cpu(&cpu_list[1]);
1768            TEST_YUYV(yv12_to_yuyv_altivec_c, 4);
1769            printf(" yv12_to_yuyv_altivec_c %.3f usec       crc32=0x%08x %s\n",
1770                    t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1771    
1772            TEST_YUYV(yv12_to_uyvy_altivec_c, 4);
1773            printf(" yv12_to_uyvy_altivec_c %.3f usec       crc32=0x%08x %s\n",
1774                    t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1775    #endif
1776            printf( " --- \n" );
1777    }
1778    
1779    #define TEST_YV2(FUNC, WITH_UV, WITH_FLIP)        \
1780    ENTER                               \
1781    for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst0[0], Dst0[1], Dst0[2], WIDTH, WIDTH, \
1782            Src0[0], (WITH_UV) ? Src0[1] : 0, (WITH_UV) ? Src0[2] : 0,  WIDTH, WIDTH, \
1783            WIDTH-2, HEIGHT-2, WITH_FLIP); \
1784    LEAVE
1785    
1786    #define PRINT_NxN(DATA,W,H,STR)   {   \
1787            int i,j; \
1788            for(j=0; j<(H); ++j) { \
1789                    for(i=0; i<(W); ++i) printf( "0x%.2x ", (DATA)[i+j*(STR)] );\
1790                    printf("\n"); \
1791            } \
1792            printf("---\n"); \
1793    }
1794    
1795    static const int yv12_CRCs[2][2] = {
1796            {0x5cab7cf0,0xdab46541}
1797    ,       {0xe8bae865,0x1faf77b7}
1798    };
1799    
1800    void test_yuv2()
1801    {
1802            const int nb_tests = 800*speed_ref;
1803            CPU *cpu;
1804            uint8_t Src0[3][WIDTH*HEIGHT];
1805            uint8_t Dst0[3][WIDTH*HEIGHT];
1806            int with_uv, with_flip;
1807            int i, j;
1808            double t;
1809            int tst, iCrc;
1810    
1811            colorspace_init();
1812            ieee_reseed(1);
1813            for(i=0; i<(int)sizeof(Src0); ++i) Src0[0][i] = ieee_rand(0,255);
1814    
1815            printf( "\n ===  test YV2 ===\n" );
1816            for(with_flip=0; with_flip<=1; ++with_flip) {
1817                    for(with_uv=0; with_uv<=1; ++with_uv) {
1818                            init_cpu(&cpu_list[0]);
1819                            TEST_YV2(yv12_to_yv12_c, with_uv, with_flip);
1820                            printf(" yv12_to_yv12_c   %.3f usec      \tcrc32=0x%08x %s\n",
1821                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1822                            /* if (!with_uv) PRINT_NxN(Dst0[1], WIDTH/2, HEIGHT/2, WIDTH ); */
1823    
1824    #ifdef ARCH_IS_IA32
1825                            init_cpu(&cpu_list[1]);
1826                            TEST_YV2(yv12_to_yv12_mmx, with_uv, with_flip);
1827                            printf(" yv12_to_yv12_mmx %.3f usec     \tcrc32=0x%08x %s\n",
1828                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1829                            /* if (!with_uv) PRINT_NxN(Dst0[1], WIDTH/2, HEIGHT/2, WIDTH ); */
1830    
1831                            TEST_YV2(yv12_to_yv12_xmm, with_uv, with_flip);
1832                            printf(" yv12_to_yv12_xmm %.3f usec     \tcrc32=0x%08x %s\n",
1833                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1834    #endif
1835                    }
1836    
1837                    printf( " --- \n" );
1838            }
1839            printf( " ===== \n" );
1840    }
1841    
1842    #undef WIDTH
1843    #undef HEIGHT
1844    #undef ENTER
1845    #undef LEAVE
1846    
1847    /*********************************************************************/
1848    
1849    static uint32_t __inline log2bin_v1(uint32_t value)
1850    {
1851      int n = 0;
1852      while (value) {
1853        value >>= 1;
1854        n++;
1855      }
1856      return n;
1857    }
1858    
1859    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1860    
1861    static uint32_t __inline log2bin_v2(uint32_t value)
1862    {
1863      int n = 0;
1864      if (value & 0xffff0000) {
1865        value >>= 16;
1866        n += 16;
1867      }
1868      if (value & 0xff00) {
1869        value >>= 8;
1870        n += 8;
1871      }
1872      if (value & 0xf0) {
1873        value >>= 4;
1874        n += 4;
1875      }
1876     return n + log2_tab_16[value];
1877    }
1878    
1879    void test_log2bin()
1880    {
1881            const int nb_tests = 3000*speed_ref;
1882      int n, crc1=0, crc2=0;
1883      uint32_t s, s0;
1884      double t1, t2;
1885    
1886      t1 = gettime_usec();
1887      s0 = (int)(t1*31.241);
1888      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1889        crc1 += log2bin_v1(s);
1890      t1 = (gettime_usec()-t1) / nb_tests;
1891    
1892      t2 = gettime_usec();
1893      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1894        crc2 += log2bin_v2(s);
1895      t2 = (gettime_usec() - t2) / nb_tests;
1896    
1897      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1898      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1899      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1900    }
1901    
1902    /*********************************************************************/
1903    
1904    static void __inline old_gcd(int *num, int *den)
1905    {
1906     int i = *num;
1907      while (i > 1) {
1908        if (*num % i == 0 && *den % i == 0) {
1909          *num /= i;
1910          *den /= i;
1911          i = *num;
1912          continue;
1913        }
1914        i--;
1915      }
1916    }
1917    
1918    static uint32_t gcd(int num, int den)
1919    {
1920      int tmp;
1921      while( (tmp=num%den) ) { num = den; den = tmp; }
1922      return den;
1923    }
1924    static void __inline new_gcd(int *num, int *den)
1925    {
1926      const int div = gcd(*num, *den);
1927      if (num) {
1928        *num /= div;
1929        *den /= div;
1930      }
1931    }
1932    
1933    void test_gcd()
1934    {
1935            const int nb_tests = 10*speed_ref;
1936      int i;
1937      uint32_t crc1=0, crc2=0;
1938      uint32_t n0, n, d0, d;
1939      double t1, t2;
1940    
1941      t1 = gettime_usec();
1942      n0 = 0xfffff & (int)(t1*31.241);
1943      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1944      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1945        old_gcd(&n, &d);
1946        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1947        n = d;
1948        d = (d*12363+31) & 0xffff;
1949        d |= !d;
1950      }
1951      t1 = (gettime_usec()-t1) / nb_tests;
1952    
1953      t2 = gettime_usec();
1954      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1955        new_gcd(&n, &d);
1956        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1957        n = d;
1958        d = (d*12363+31) & 0xffff;
1959        d |= !d;
1960      }
1961      t2 = (gettime_usec() - t2) / nb_tests;
1962    
1963      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1964      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1965      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1966    }
1967    
1968    /*********************************************************************
1969     * test compiler
1970     *********************************************************************/
1971    
1972    void test_compiler() {
1973      int nb_err = 0;
1974      int32_t v;
1975      if (sizeof(uint16_t)<2) {
1976        printf( "ERROR: sizeof(uint16_t)<2 !!\n" );
1977        nb_err++;
1978      }
1979      if (sizeof(int16_t)<2) {
1980        printf( "ERROR: sizeof(int16_t)<2 !!\n" );
1981        nb_err++;
1982      }
1983      if (sizeof(uint8_t)!=1) {
1984        printf( "ERROR: sizeof(uint8_t)!=1 !!\n" );
1985        nb_err++;
1986      }
1987      if (sizeof(int8_t)!=1) {
1988        printf( "ERROR: sizeof(int8_t)!=1 !!\n" );
1989        nb_err++;
1990      }
1991      if (sizeof(uint32_t)<4) {
1992        printf( "ERROR: sizeof(uint32_t)<4 !!\n" );
1993        nb_err++;
1994      }
1995      if (sizeof(int32_t)<4) {
1996        printf( "ERROR: sizeof(int32_t)<4 !!\n" );
1997        nb_err++;
1998      }
1999             /* yes, i know, this test is silly. But better be safe than sorry. :) */
2000      for(v=1000; v>=0; v--) {
2001        if ( (v>>2) != v/4)
2002          nb_err++;
2003      }
2004      for(v=-1000; v!=-1; v++) {
2005        if ( (v>>2) != (v/4)-!!(v%4))
2006          nb_err++;
2007      }
2008      if (nb_err!=0) {
2009        printf( "ERROR! please post your platform/compiler specs to xvid-devel@xvid.org !\n" );
2010      }
2011    }
2012    /*********************************************************************
2013     * test SSIM functions
2014     *********************************************************************/
2015    
2016    typedef int (*lumfunc)(uint8_t* ptr, int stride);
2017    typedef void (*csfunc)(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2018    
2019    extern int lum_8x8_c(uint8_t* ptr, int stride);
2020    extern int lum_8x8_mmx(uint8_t* ptr, int stride);
2021    extern int lum_2x8_c(uint8_t* ptr, int stride);
2022    extern void consim_c(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2023    extern void consim_mmx(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2024    extern void consim_sse2(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2025    
2026    void test_SSIM()
2027    {
2028            const int nb_tests = 3000*speed_ref;
2029            int tst;
2030            CPU *cpu;
2031            int i;
2032            int devs[3];
2033            long lumo, lumc;
2034            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
2035            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
2036            lumfunc lum8x8;
2037            lumfunc lum2x8;
2038            csfunc  csim;
2039    
2040            ieee_reseed(1);
2041            printf( "\n ======  test SSIM ======\n" );
2042            for(i=0; i<16*16;++i) {
2043                    long v1, v2;
2044                    v1 = ieee_rand(-256, 511);
2045                    v2 = ieee_rand(-256, 511);
2046                    Ref1[i] = (v1<0) ? 0 : (v1>255) ? 255 : v1;
2047                    Ref2[i] = (v2<0) ? 0 : (v2>255) ? 255 : v2;
2048            }
2049            lumc = ieee_rand(0, 255);
2050            lumo = ieee_rand(0, 255);
2051    
2052            for(cpu = cpu_list; cpu->name!=0; ++cpu)
2053            {
2054                    double t;
2055                    int m;
2056                    if (!init_cpu(cpu))
2057                            continue;
2058                    lum8x8 = lum_8x8_c;
2059                    lum2x8 = lum_2x8_c;
2060                    csim   = consim_c;
2061                    if (cpu->cpu & XVID_CPU_MMX){
2062                            lum8x8 = lum_8x8_mmx;
2063                            csim = consim_mmx;
2064                    }
2065                    if (cpu->cpu & XVID_CPU_MMX){
2066                            csim = consim_sse2;
2067                    }
2068    
2069                    t = gettime_usec();
2070                    emms();
2071                    for(tst=0; tst<nb_tests; ++tst) m = lum8x8(Ref1, 16);
2072                    emms();
2073                    t = (gettime_usec() - t) / nb_tests;
2074                    printf("%s - ssim-lum8x8    %.3f usec       m=%d %s\n",
2075                               cpu->name, t, m,
2076                               (m!=8230)?"| ERROR": "" );
2077    
2078                    t = gettime_usec();
2079                    emms();
2080                    for(tst=0; tst<nb_tests; ++tst) m = lum2x8(Ref1+8, 16);
2081                    emms();
2082                    t = (gettime_usec() - t) / nb_tests;
2083                    printf("%s - ssim-lum2x8    %.3f usec       m=%d %s\n",
2084                               cpu->name, t, m,
2085                               (m!=681)?"| ERROR": "" );
2086    
2087                    t = gettime_usec();
2088                    emms();
2089                    for(tst=0; tst<nb_tests; ++tst) csim(Ref1, Ref2, 16, lumo, lumc, devs+0, devs+1, devs+2);
2090                    emms();
2091                    t = (gettime_usec() - t) / nb_tests;
2092                    printf("%s - ssim-consim    %.3f usec       devs=[0x%x 0x%x 0x%x] %s\n",
2093                               cpu->name, t, devs[0], devs[1], devs[2],
2094                               (devs[0]!=0x1bdf0f || devs[1]!=0x137258 ||  devs[2]!=0xcdb13)?"| ERROR": "" );
2095                    printf( " --- \n" );
2096            }
2097    }
2098    
2099    /*********************************************************************
2100   * main   * main
2101   *********************************************************************/   *********************************************************************/
2102    
2103  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
2104  {  {
2105          int what = 0;    printf( "missing argument after option '%s'\n", opt);
2106          if (argc>1) what = atoi(argv[1]);    exit(-1);
2107    }
2108    
2109    int main(int argc, const char *argv[])
2110    {
2111            int c, what = 0;
2112            int width, height;
2113            uint32_t chksum = 0;
2114      const char * test_bitstream = 0;
2115    
2116            cpu_mask = 0;  // default => will use autodectect
2117            for(c=1; c<argc; ++c)
2118            {
2119              if (!strcmp(argv[c], "-v")) verbose++;
2120              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
2121              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
2122              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
2123              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
2124              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
2125              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
2126              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
2127              else if (!strcmp(argv[c], "-spd")) {
2128          if (++c==argc) arg_missing( argv[argc-1] );
2129          speed_ref = atoi(argv[c]);
2130        }
2131              else if (argv[c][0]!='-') {
2132                what = atoi(argv[c]);
2133                if (what==9) {
2134                  if (c+4>argc) {
2135                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
2136                    exit(-1);
2137            }
2138            test_bitstream = argv[++c];
2139                  width  = atoi(argv[++c]);
2140                  height = atoi(argv[++c]);
2141                  if (c+1<argc && argv[c+1][0]!='-') {
2142                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
2143                      printf( "can't read checksum value.\n" );
2144                      exit(-1);
2145              }
2146              else c++;
2147            }
2148    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
2149          }
2150        }
2151        else {
2152          printf( "unrecognized option '%s'\n", argv[c]);
2153          exit(-1);
2154        }
2155      }
2156    
2157    
2158          if (what==0 || what==1) test_dct();          if (what==0 || what==1) test_dct();
2159          if (what==0 || what==2) test_mb();          if (what==0 || what==2) test_mb();
2160          if (what==0 || what==3) test_sad();          if (what==0 || what==3) test_sad();
2161          if (what==0 || what==4) test_transfer();          if (what==0 || what==4) test_transfer();
2162          if (what==0 || what==5) test_quant();          if (what==0 || what==5) test_quant();
2163          if (what==0 || what==6) test_cbp();          if (what==0 || what==6) test_cbp();
2164            if (what==0 || what==10) test_sse();
2165            if (what==0 || what==11) test_log2bin();
2166            if (what==0 || what==12) test_gcd();
2167            if (what==0 || what==13) test_compiler();
2168            if (what==0 || what==14) test_yuv();
2169            if (what==0 || what==15) test_SSIM();
2170            if (what==0 || what==16) test_yuv2();
2171    
2172    
2173          if (what==7) {          if (what==7) {
2174                  test_IEEE1180_compliance(-256, 255, 1);                  test_IEEE1180_compliance(-256, 255, 1);
# Line 1334  Line 2180 
2180          }          }
2181          if (what==8) test_dct_saturation(-256, 255);          if (what==8) test_dct_saturation(-256, 255);
2182    
2183          if (what==9) {          if (test_bitstream)
2184                  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));  
         }  
   
2185          if (what==-1) {          if (what==-1) {
2186                  test_dct_precision_diffs();                  test_dct_precision_diffs();
2187                  test_bugs1();                  test_bugs1();
# Line 1352  Line 2189 
2189          if (what==-2)          if (what==-2)
2190                  test_quant_bug();                  test_quant_bug();
2191    
2192          return 0;          if ((what >= 0 && what <= 6) || what == 10) {
2193                    printf("\n\n"
2194                               "NB: If a function isn't optimised for a specific set of intructions,\n"
2195                               "    a C function is used instead. So don't panic if some functions\n"
2196                               "    may appear to be slow.\n");
2197  }  }
2198    
2199  /*********************************************************************  #ifdef ARCH_IS_IA32
2200   * 'Reference' output (except for timing) on an Athlon XP 2200+          if (what == 0 || what == 5) {
2201   *********************************************************************/                  printf("\n"
2202                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
2203  /* 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"
2204  /*                             "    test goes far behind the usual limits of real encoding. Please do not report\n"
2205                               "    this error to the developers.\n");
2206            }
2207    #endif
2208    
2209   ===== test fdct/idct =====          return 0;
2210  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  
  ---  
2211    
2212  */  /*********************************************************************/
Legend:
Removed from v.1.9.2.8  
changed lines
  Added in v.1.33
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4