[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.35, Thu Dec 21 23:27:35 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 60  Line 58 
58  #include "utils/timer.h"  #include "utils/timer.h"
59  #include "quant/quant_matrix.c"  #include "quant/quant_matrix.c"
60  #include "bitstream/cbp.h"  #include "bitstream/cbp.h"
61    #include "bitstream/bitstream.h"
62    
63  #include <math.h>  #include <math.h>
64    
# Line 67  Line 66 
66  #define M_PI            3.14159265358979323846  #define M_PI            3.14159265358979323846
67  #endif  #endif
68    
69  const int speed_ref = 100;  /* on slow machines, decrease this value */  int speed_ref = 100;  /* on slow machines, decrease this value */
70    int verbose = 0;
71    unsigned int cpu_mask;
72    
73  /*********************************************************************  /*********************************************************************
74   * misc   * misc
# Line 83  Line 84 
84  #else  #else
85          clock_t clk;          clock_t clk;
86          clk = clock();          clk = clock();
87          return clk * 1000000 / CLOCKS_PER_SEC;          return clk * 1000. / CLOCKS_PER_SEC;  /* clock() returns time in Milliseconds */
88  #endif  #endif
89  }  }
90    
# Line 112  Line 113 
113          unsigned int cpu;          unsigned int cpu;
114  } CPU;  } CPU;
115    
116  CPU cpu_list[] =  CPU cpu_list[] = {
117  { { "PLAINC", 0 }          { "PLAINC ", 0 },
118  #ifdef ARCH_IS_IA32  #ifdef ARCH_IS_IA32
119    , { "MMX   ", XVID_CPU_MMX }          { "MMX    ", XVID_CPU_MMX },
120    , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }          { "MMXEXT ", XVID_CPU_MMXEXT | XVID_CPU_MMX },
121    , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }          { "SSE2   ", XVID_CPU_SSE2 | XVID_CPU_MMX },
122    , { "3DNOW ", XVID_CPU_3DNOW }          { "3DNOW  ", XVID_CPU_3DNOW },
123    , { "3DNOWE", XVID_CPU_3DNOWEXT }          { "3DNOWE ", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT },
124  #endif  #endif
125  //, { "IA64  ", XVID_CPU_IA64 }  #ifdef ARCH_IS_PPC
126  //, { "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 }  
127  #endif  #endif
128  //, { "IA64  ", XVID_CPU_IA64 }  #ifdef ARCH_IS_X86_64
129    , { 0, 0 } };          { "X86_64 ", XVID_CPU_ASM},
130    #endif
131  CPU cpu_short_list2[] =  #ifdef ARCH_IS_IA64
132  { { "PLAINC", 0 }  //      { "IA64   ", XVID_CPU_IA64 },
 #ifdef ARCH_IS_IA32  
   , { "MMX   ", XVID_CPU_MMX }  
   , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  
133  #endif  #endif
134    , { 0, 0 } };  //      { "TSC    ", XVID_CPU_TSC },
135            { 0, 0 }
136    };
137    
138    
139  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
# Line 171  Line 164 
164          return 1;          return 1;
165  }  }
166    
167    #define CRC32_REMAINDER 0xCBF43926
168    #define CRC32_INITIAL 0xffffffff
169    
170    #define DO1(c, crc) ((crc) = crc32tab[((unsigned int)((crc)>>24) ^ (*c++)) & 0xff] ^ ((crc) << 8))
171    #define DO2(c, crc)  DO1(c, crc); DO1(c, crc);
172    #define DO4(c, crc)  DO2(c, crc); DO2(c, crc);
173    #define DO8(c, crc)  DO4(c, crc); DO4(c, crc);
174    
175    /******************************************************************************
176    * Precomputed AAL5 CRC32 lookup table
177    ******************************************************************************/
178    
179    static unsigned long crc32tab[256] = {
180    
181            0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
182            0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
183            0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
184            0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
185            0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
186            0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
187            0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
188            0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
189            0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
190            0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
191            0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
192            0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
193            0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
194            0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
195            0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
196            0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
197            0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
198            0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
199            0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
200            0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
201            0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
202            0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
203            0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
204            0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
205            0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
206            0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
207            0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
208            0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
209            0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
210            0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
211            0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
212            0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
213            0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
214            0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
215            0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
216            0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
217            0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
218            0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
219            0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
220            0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
221            0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
222            0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
223            0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
224            0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
225            0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
226            0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
227            0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
228            0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
229            0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
230            0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
231            0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
232            0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
233            0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
234            0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
235            0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
236            0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
237            0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
238            0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
239            0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
240            0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
241            0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
242            0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
243            0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
244            0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
245    
246    };
247    
248    uint32_t
249    calc_crc(uint8_t *mem, int len, uint32_t crc)
250    {
251            while( len >= 8) {
252                    DO8(mem, crc);
253                    len -= 8;
254            }
255    
256            while( len ) {
257                    DO1(mem, crc);
258                    len--;
259            }
260    
261            return crc;
262    }
263    
264    void byte_swap(uint8_t *mem, int len, int element_size) {
265    #ifdef ARCH_IS_BIG_ENDIAN
266            int i;
267    
268            if(element_size == 1) {
269                    /* No need to swap */
270            } else if(element_size == 2) {
271                    uint8_t temp[2];
272    
273                    for(i=0; i < (len/2); i++ ) {
274                            temp[0] = mem[0];
275                            temp[1] = mem[1];
276                            mem[0] = temp[1];
277                            mem[1] = temp[0];
278    
279                            mem += 2;
280                    }
281            } else if(element_size == 4) {
282                    uint8_t temp[4];
283    
284                    for(i=0; i < (len/4); i++ ) {
285                            temp[0] = mem[0];
286                            temp[1] = mem[1];
287                            temp[2] = mem[2];
288                            temp[3] = mem[3];
289                            mem[0] = temp[3];
290                            mem[1] = temp[2];
291                            mem[2] = temp[1];
292                            mem[3] = temp[0];
293    
294                            mem += 4;
295                    }
296            } else {
297                    printf("ERROR: byte_swap unsupported element_size(%u)\n", element_size);
298            }
299    #endif
300    }
301    
302  /*********************************************************************  /*********************************************************************
303   * test DCT   * test DCT
304   *********************************************************************/   *********************************************************************/
# Line 223  Line 351 
351                          MSE += delta*delta;                          MSE += delta*delta;
352                  }                  }
353                  PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );                  PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
354                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f\n",                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
355                                  cpu->name, t, PSNR, MSE );                                  cpu->name, t, PSNR, MSE,
356                  if (ABS(MSE)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
357          }          }
358  }  }
359    
# Line 239  Line 367 
367          int tst;          int tst;
368          CPU *cpu;          CPU *cpu;
369          int i;          int i;
370          uint8_t Cur[16*16], Ref1[16*16], Ref2[16*16];          DECLARE_ALIGNED_MATRIX(Cur,  16, 16, uint8_t, 16);
371            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
372            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
373    
374          printf( "\n ======  test SAD ======\n" );          printf( "\n ======  test SAD ======\n" );
375          for(i=0; i<16*16;++i) {          for(i=0; i<16*16;++i) {
# Line 260  Line 390 
390                  for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);                  for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
391                  emms();                  emms();
392                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
393                  printf( "%s - sad8    %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad8    %.3f usec       sad=%d %s\n",
394                  if (s!=3776) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
395                               (s!=3776)?"| ERROR": "" );
396    
397                  t = gettime_usec();                  t = gettime_usec();
398                  emms();                  emms();
399                  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);
400                  emms();                  emms();
401                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
402                  printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad16   %.3f usec       sad=%d %s\n",
403                  if (s!=27214) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
404                               (s!=27214)?"| ERROR": "" );
405    
406                  t = gettime_usec();                  t = gettime_usec();
407                  emms();                  emms();
408                  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);
409                  emms();                  emms();
410                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
411                  printf( "%s - sad16bi %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - sad16bi %.3f usec       sad=%d %s\n",
412                  if (s!=26274) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
413                                    (s!=26274)?"| ERROR": "" );
414    
415                  t = gettime_usec();                  t = gettime_usec();
416                  emms();                  emms();
417                  for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);                  for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
418                  emms();                  emms();
419                  t = (gettime_usec() - t) / nb_tests;                  t = (gettime_usec() - t) / nb_tests;
420                  printf( "%s - dev16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - dev16   %.3f usec       sad=%d %s\n",
421                  if (s!=3344) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
422                                    (s!=3344)?"| ERROR": "" );
423    
424                  printf( " --- \n" );                  printf( " --- \n" );
425          }          }
# Line 303  Line 437 
437  #define LEAVE \  #define LEAVE \
438  emms();                             \  emms();                             \
439  t = (gettime_usec() - t) / nb_tests;  \  t = (gettime_usec() - t) / nb_tests;  \
440  iCrc = 0;                           \          iCrc = calc_crc((uint8_t*)Dst, sizeof(Dst), CRC32_INITIAL)
 for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }  
441    
442  #define TEST_MB(FUNC, R)                \  #define TEST_MB(FUNC, R)                \
443  ENTER                               \  ENTER                               \
# Line 323  Line 456 
456          CPU *cpu;          CPU *cpu;
457          const uint8_t Src0[16*9] = {          const uint8_t Src0[16*9] = {
458                  /* try to have every possible combinaison of rounding... */                  /* try to have every possible combinaison of rounding... */
459                  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,
460                  , 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,
461                  , 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,
462                  , 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,
463                  , 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,
464                  , 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,
465                  , 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,
466                  , 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,
467                  , 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
468          };          };
469          uint8_t Dst[16*8] = {0};          uint8_t Dst[16*8] = {0};
470    
# Line 346  Line 479 
479                          continue;                          continue;
480    
481                  TEST_MB(interpolate8x8_halfpel_h, 0);                  TEST_MB(interpolate8x8_halfpel_h, 0);
482                  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",
483                  if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
484                               (iCrc!=0x115381ba)?"| ERROR": "" );
485    
486                  TEST_MB(interpolate8x8_halfpel_h, 1);                  TEST_MB(interpolate8x8_halfpel_h, 1);
487                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
488                  if (iCrc!=8100) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
489                               (iCrc!=0x2b1f528f)?"| ERROR": "" );
490    
491    
492                  TEST_MB(interpolate8x8_halfpel_v, 0);                  TEST_MB(interpolate8x8_halfpel_v, 0);
493                  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",
494                  if (iCrc!=8108) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
495                               (iCrc!=0x423cdcc7)?"| ERROR": "" );
496    
497                  TEST_MB(interpolate8x8_halfpel_v, 1);                  TEST_MB(interpolate8x8_halfpel_v, 1);
498                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
499                  if (iCrc!=8105) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
500                               (iCrc!=0x42202efe)?"| ERROR": "" );
501    
502    
503                  TEST_MB(interpolate8x8_halfpel_hv, 0);                  TEST_MB(interpolate8x8_halfpel_hv, 0);
504                  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",
505                  if (iCrc!=8112) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
506                               (iCrc!=0xd198d387)?"| ERROR": "" );
507    
508                  TEST_MB(interpolate8x8_halfpel_hv, 1);                  TEST_MB(interpolate8x8_halfpel_hv, 1);
509                  printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
510                  if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
511                               (iCrc!=0x9ecfd921)?"| ERROR": "" );
512    
513    
514                  /* this is a new function, as of 06.06.2002 */                  /* this is a new function, as of 06.06.2002 */
515  #if 0  #if 0
516                  TEST_MB2(interpolate8x8_avrg);                  TEST_MB2(interpolate8x8_avrg);
517                  printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
518                  if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
519                               (iCrc!=8107)?"| ERROR": "" );
520  #endif  #endif
521    
522        /* New functions for field prediction by CK 1.10.2005 */
523    #pragma NEW8X4
524                    TEST_MB(interpolate8x4_halfpel_h, 0);
525                    printf("%s - interpfield-h -round0 %.3f usec       crc32=0x%08x %s\n",
526                               cpu->name, t, iCrc,
527                               (iCrc!=0x9538d6df)?"| ERROR": "" );
528    
529                    TEST_MB(interpolate8x4_halfpel_h, 1);
530                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
531                               cpu->name, t, iCrc,
532                               (iCrc!=0xde5f1db4)?"| ERROR": "" );
533    
534    
535                    TEST_MB(interpolate8x4_halfpel_v, 0);
536                    printf("%s - interpfield- v-round0 %.3f usec       crc32=0x%08x %s\n",
537                               cpu->name, t, iCrc,
538                               (iCrc!=0xea5a69ef)?"| ERROR": "" );
539    
540                    TEST_MB(interpolate8x4_halfpel_v, 1);
541                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
542                               cpu->name, t, iCrc,
543                               (iCrc!=0x4f10ec0f)?"| ERROR": "" );
544    
545    
546                    TEST_MB(interpolate8x4_halfpel_hv, 0);
547                    printf("%s - interpfield-hv-round0 %.3f usec       crc32=0x%08x %s\n",
548                               cpu->name, t, iCrc,
549                               (iCrc!=0xf97ee367)?"| ERROR": "" );
550    
551                    TEST_MB(interpolate8x4_halfpel_hv, 1);
552                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
553                               cpu->name, t, iCrc,
554                               (iCrc!=0xb6a9f581)?"| ERROR": "" );
555    /* End of 8x4 functions */
556    
557                  printf( " --- \n" );                  printf( " --- \n" );
558          }          }
559  }  }
560    
561    #undef ENTER
562    #undef LEAVE
563    #undef TEST_MB
564    #undef TEST_MB2
565    
566  /*********************************************************************  /*********************************************************************
567   * test transfer   * test transfer
568   *********************************************************************/   *********************************************************************/
# Line 412  Line 592 
592  }                                         \  }                                         \
593  emms();                                   \  emms();                                   \
594  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
595  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]));  \
596    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
597    
598  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
599  TEST_TRANSFER_BEGIN(DST);                 \  TEST_TRANSFER_BEGIN(DST);                 \
# Line 438  Line 619 
619  }                                         \  }                                         \
620  emms();                                   \  emms();                                   \
621  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
622  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]));  \
623    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
624    
625  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
626  TEST_TRANSFER2_BEGIN(DST,SRC);            \  TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 455  Line 637 
637          const int nb_tests = 4000*speed_ref;          const int nb_tests = 4000*speed_ref;
638          int i;          int i;
639          CPU *cpu;          CPU *cpu;
640          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];
641          int16_t Src16[8*32], Dst16[8*32];  //      int16_t Src16[8*32], Dst16[8*32];
642      DECLARE_ALIGNED_MATRIX(Src8, 8, 32, uint8_t, CACHE_LINE);
643      DECLARE_ALIGNED_MATRIX(Dst8, 8, 32, uint8_t, CACHE_LINE);
644      DECLARE_ALIGNED_MATRIX(Ref1, 8, 32, uint8_t, CACHE_LINE);
645      DECLARE_ALIGNED_MATRIX(Ref2, 8, 32, uint8_t, CACHE_LINE);
646      DECLARE_ALIGNED_MATRIX(Src16, 8, 32, uint16_t, CACHE_LINE);
647      DECLARE_ALIGNED_MATRIX(Dst16, 8, 32, uint16_t, CACHE_LINE);
648    
649          printf( "\n ===  test transfer ===\n" );          printf( "\n ===  test transfer ===\n" );
650    
# Line 469  Line 657 
657                          continue;                          continue;
658    
659                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);                  TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
660                  printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
661                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
662                               (s!=0x115814bb)?"| ERROR": "");
663    
664                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
665                  printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
666                  if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
667                                    (s!=0xee7ccbb4)?"| ERROR": "");
668    
669        /* New functions for field prediction by CK 1.10.2005 */
670    #pragma NEW8X4
671                    TEST_TRANSFER(transfer8x4_copy, Dst8, Src8);
672                    printf("%s - 8to4      %.3f usec       crc32=0x%08x %s\n",
673                               cpu->name, t, s,
674                               (s!=0xbb9c3db5)?"| ERROR": "");
675    /* End of new functions */
676    
677                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);                  TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
678                  printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
679                  if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
680                               (s!=0xd37b3295)?"| ERROR": "");
681    
682                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);                  TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
683                  printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
684                  if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
685                               (s!=0xdd817bf4)?"| ERROR": "" );
686    
687                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
688                  printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
689                  if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
690                  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);
691                  printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, 8*32*sizeof(Src8[0]), CRC32_INITIAL);
692                  if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
693                                       cpu->name, t, s1, s2,
694                                       (s1!=0xa1e07163)?"| ERROR1": "",
695                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
696                    }
697    
698                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);                  TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
699                  printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
700                  if (s!=22368) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
701                               (s!=0x99b6c4c7)?"| ERROR": "" );
702    
703                  printf( " --- \n" );                  printf( " --- \n" );
704          }          }
# Line 505  Line 710 
710    
711  #define TEST_QUANT(FUNC, DST, SRC)              \  #define TEST_QUANT(FUNC, DST, SRC)              \
712  t = gettime_usec();                         \  t = gettime_usec();                         \
713  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
714    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
715    set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
716    emms();                                   \    emms();                                   \
717    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
718          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
719            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
720          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
721            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
722    }                                         \    }                                         \
723    emms();                                   \    emms();                                   \
724  }                                           \  }                                           \
725  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
 s = (s&0xffff)^(s>>16)  
726    
727  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
728  t = gettime_usec();                         \  t = gettime_usec();                         \
729  for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
730    for(i=0; i<8*8; ++i) Quant[i] = qm;       \    for(i=0; i<8*8; ++i) Quant[i] = qm;       \
731    set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
732    emms();                                   \    emms();                                   \
733    for(q=1; q<=max_Q; ++q) {                 \    for(q=1; q<=max_Q; ++q) {                 \
734          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
735            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
736          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
737            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
738    }                                         \    }                                         \
739    emms();                                   \    emms();                                   \
740  }                                           \  }                                           \
741  t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
742  s = (s&0xffff)^(s>>16)  
743    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
744    { int i,q,s;\
745            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
746      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
747      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
748      for(q=1;q<=max_Q;q++)          \
749        for(s=-RANGE;s<RANGE;s++) { \
750          for(i=0;i<64;i++) Src[i]=s; \
751          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
752          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
753          for(i=0;i<64;i++)     \
754            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]);  \
755        }      \
756    }
757    
758    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
759    { int i,q,s;  \
760            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
761      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
762      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
763      for(q=1;q<=max_Q;q++)  \
764        for(s=-RANGE;s<RANGE;s++) {   \
765          for(i=0;i<64;i++) Src[i]=s; \
766          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
767          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
768          emms();           \
769          for(i=0;i<64;i++) \
770            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]); \
771        } \
772    }
773    
774  void test_quant()  void test_quant()
775  {  {
776          const int nb_tests = 1*speed_ref;          const int nb_tests = 1*speed_ref;
777          const int max_Q = 31;          const int max_Q = 31;
778            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
779    
780          int i, qm;          int i, qm;
781          CPU *cpu;          CPU *cpu;
782          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
783            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
784            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
785          uint8_t Quant[8*8];          uint8_t Quant[8*8];
786    
787          printf( "\n =====  test quant =====\n" );          printf( "\n =====  test quant =====\n" );
# Line 562  Line 802 
802                  if (!init_cpu(cpu))                  if (!init_cpu(cpu))
803                  continue;                  continue;
804    
805                    // exhaustive tests to compare against the (ref) C-version
806                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
807                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
808                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
809                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
810    
811                  overhead = -gettime_usec();                  overhead = -gettime_usec();
812                  for(s=0,qm=1; qm<=255; ++qm) {                  for(s=0,qm=1; qm<=255; ++qm) {
813                          for(i=0; i<8*8; ++i) Quant[i] = qm;                          for(i=0; i<8*8; ++i) Quant[i] = qm;
814                          set_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
815                          for(q=1; q<=max_Q; ++q)                          for(q=1; q<=max_Q; ++q)
816                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;                                  for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
817                  }                  }
818                  overhead += gettime_usec();                  overhead += gettime_usec();
819    
 #if 1  
820                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
821                  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",
822                  if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
823                               (s!=0xfd6a21a4)? "| ERROR": "");
824    
825                  TEST_QUANT(quant_mpeg_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
826                  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",
827                  if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
828  #endif                             (s!=0xf6de7757)?"| ERROR": "");
829  #if 1  
830                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
831                  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",
832                  if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
833                               (s!=0x2def7bc7)?"| ERROR": "");
834    
835                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
836                  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",
837                  if (s!=63847) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
838  #endif                             (s!=0xd878c722)?"| ERROR": "");
839  #if 1  
840                  TEST_QUANT2(quant_h263_intra, Dst, Src);                  TEST_QUANT2(quant_h263_intra, Dst, Src);
841                  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",
842                  if (s!=25662) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
843                               (s!=0x2eba9d43)?"| ERROR": "");
844    
845                  TEST_QUANT(quant_h263_inter, Dst, Src);                  TEST_QUANT(quant_h263_inter, Dst, Src);
846                  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",
847                  if (s!=23972) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
848  #endif                             (s!=0xbd315a7e)?"| ERROR": "");
849  #if 1  
850                  TEST_QUANT2(dequant_h263_intra, Dst, Src);                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
851                  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",
852                  if (s!=49900) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
853                               (s!=0x9841212a)?"| ERROR": "");
854    
855                  TEST_QUANT(dequant_h263_inter, Dst, Src);                  TEST_QUANT(dequant_h263_inter, Dst, Src);
856                  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",
857                  if (s!=48899) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
858  #endif                             (s!=0xe7df8fba)?"| ERROR": "");
859    
860                    printf( " --- \n" );
861            }
862    }
863    
864    /*********************************************************************
865     * test distortion operators
866     *********************************************************************/
867    
868    static void ieee_reseed(long s);
869    static long ieee_rand(int Min, int Max);
870    
871    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
872      do { \
873        t = gettime_usec(); \
874        tst = nb_tests; \
875        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
876        emms(); \
877        t = (gettime_usec() - t)/(double)nb_tests;  \
878      } while(0)
879    
880    
881    void test_sse()
882    {
883            const int nb_tests = 100000*speed_ref;
884            int i;
885            CPU *cpu;
886            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
887            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
888            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
889            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
890    
891            printf( "\n =====  test sse =====\n" );
892    
893            ieee_reseed(1);
894            for(i=0; i<64; ++i) {
895                    Src1[i] = ieee_rand(-2048, 2047);
896                    Src2[i] = ieee_rand(-2048, 2047);
897                    Src3[i] = ieee_rand(-2048, 2047);
898                    Src4[i] = ieee_rand(-2048, 2047);
899            }
900    
901            for(cpu = cpu_list; cpu->name!=0; ++cpu)
902            {
903                    double t;
904                    int tst, sse;
905    
906                    if (!init_cpu(cpu))
907                            continue;
908    
909                    /* 16 bit element blocks */
910                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
911                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
912                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
913                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
914                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
915                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
916                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
917                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
918                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
919                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
920                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
921                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
922                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
923                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
924                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
925                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
926                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
927                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
928    
929                    /* 8 bit element blocks */
930                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
931                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
932                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
933                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
934                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
935                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
936                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
937                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
938                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
939                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
940                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
941                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
942                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
943                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
944                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
945                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
946                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
947                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
948    
949                  printf( " --- \n" );                  printf( " --- \n" );
950          }          }
951  }  }
# Line 615  Line 954 
954   * test non-zero AC counting   * test non-zero AC counting
955   *********************************************************************/   *********************************************************************/
956    
957  #define TEST_CBP(FUNC, SRC)                   \  #define TEST_CBP(FUNC, SRC, NB)           \
958  t = gettime_usec();                       \  t = gettime_usec();                       \
959  emms();                                   \  emms();                                   \
960  for(tst=0; tst<nb_tests; ++tst) {         \  for(tst=0; tst<NB; ++tst) {         \
961    cbp = (FUNC)((SRC));                    \    cbp = (FUNC)((SRC));                    \
962  }                                         \  }                                         \
963  emms();                                   \  emms();                                   \
# Line 627  Line 966 
966  void test_cbp()  void test_cbp()
967  {  {
968          const int nb_tests = 10000*speed_ref;          const int nb_tests = 10000*speed_ref;
969          int i;          int i, n, m;
970          CPU *cpu;          CPU *cpu;
971          int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
972            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
973            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
974            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
975      DECLARE_ALIGNED_MATRIX(Src5, 6, 64, int16_t, 16);
976    
977          printf( "\n =====  test cbp =====\n" );          printf( "\n =====  test cbp =====\n" );
978    
# Line 638  Line 981 
981                  Src2[i] = (i<3*64);               /* half-full */                  Src2[i] = (i<3*64);               /* half-full */
982                  Src3[i] = ((i+32)>3*64);                  Src3[i] = ((i+32)>3*64);
983                  Src4[i] = (i==(3*64+2) || i==(5*64+9));                  Src4[i] = (i==(3*64+2) || i==(5*64+9));
984        Src5[i] = ieee_rand(0,1) ? -1 : 1;  /* +/- test */
985          }          }
986    
987          for(cpu = cpu_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
# Line 648  Line 992 
992                  if (!init_cpu(cpu))                  if (!init_cpu(cpu))
993                          continue;                          continue;
994    
995                  TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1, nb_tests);
996                  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",
997                  if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
998                  TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2, nb_tests);
999                  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",
1000                  if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
1001                  TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3, nb_tests);
1002                  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",
1003                  if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
1004                  TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4, nb_tests);
1005                  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",
1006                  if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
1007                    TEST_CBP(calc_cbp, Src5, nb_tests);
1008                    printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
1009                               cpu->name, t, cbp, (cbp!=0x3f)?"| ERROR": "" );
1010                  printf( " --- \n" );                  printf( " --- \n" );
1011          }          }
1012    
1013            for(cpu = cpu_list; cpu->name!=0; ++cpu)  /* bench suggested by Carlo (carlo dot bramix at libero dot it) */
1014            {
1015                    double t;
1016                    int tst, cbp, err;
1017    
1018                    if (!init_cpu(cpu))
1019                            continue;
1020    
1021        err = 0;
1022        for(n=0; n<6; ++n)
1023        {
1024          for(m=0; m<64; ++m)
1025          {
1026            for(i=0; i<6*64; ++i)
1027              Src1[i] = (i== (m + n*64));
1028    
1029            TEST_CBP(calc_cbp, Src1, 1);
1030            if (cbp!= (((m!=0)<<(5-n))))
1031            {
1032              printf( "%s -   calc_cbp#5: ERROR at pos %d / %d!\n", cpu->name, n, m);
1033              err = 1;
1034              break;
1035            }
1036          }
1037        }
1038        if (!err)
1039          printf( " %s -    calc_cbp#5 : OK\n", cpu->name );
1040    
1041            }
1042  }  }
1043    
1044  /*********************************************************************  /*********************************************************************
# Line 1055  Line 1432 
1432   * measure raw decoding speed   * measure raw decoding speed
1433   *********************************************************************/   *********************************************************************/
1434    
1435  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)
1436  {  {
1437          FILE *f = 0;          FILE *f = 0;
1438          void *dechandle = 0;          void *dechandle = 0;
# Line 1066  Line 1443 
1443          double t = 0.;          double t = 0.;
1444          int nb = 0;          int nb = 0;
1445          uint8_t *buf = 0;          uint8_t *buf = 0;
1446          uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1447          int buf_size, pos;          int buf_size, pos;
1448          uint32_t chksum = 0;          uint32_t chksum = 0;
1449            int bps = (width+31) & ~31;
1450    
1451          memset(&xinit, 0, sizeof(xinit));          memset(&xinit, 0, sizeof(xinit));
1452          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = cpu_mask;
1453          xinit.version = XVID_VERSION;          xinit.version = XVID_VERSION;
1454          xvid_global(NULL, 0, &xinit, NULL);          xvid_global(NULL, 0, &xinit, NULL);
1455    
# Line 1081  Line 1459 
1459          xparam.version = XVID_VERSION;          xparam.version = XVID_VERSION;
1460          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1461          if (xerr==XVID_ERR_FAIL) {          if (xerr==XVID_ERR_FAIL) {
1462                  printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1463                  return;                  return;
1464          }          }
1465          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1089  Line 1467 
1467    
1468          f = fopen(name, "rb");          f = fopen(name, "rb");
1469          if (f==0) {          if (f==0) {
1470                  printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1471                  return;                  return;
1472          }          }
1473          fseek(f, 0, SEEK_END);          fseek(f, 0, SEEK_END);
1474          buf_size = ftell(f);          buf_size = ftell(f);
1475          fseek(f, 0, SEEK_SET);          fseek(f, 0, SEEK_SET);
1476          if (buf_size<=0) {          if (buf_size<=0) {
1477                  printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1478                  goto End;                  goto End;
1479          }          }
         else printf( "Input size: %d\n", buf_size);  
1480    
1481          buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1482          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1483          if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1484                  printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1485                  goto End;                  goto End;
1486          }          }
1487    
1488          if (fread(buf, buf_size, 1, f)!=1) {          if (fread(buf, buf_size, 1, f)!=1) {
1489                  printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1490                  goto End;                  goto End;
1491          }          }
1492    
# Line 1117  Line 1494 
1494          pos = 0;          pos = 0;
1495          t = -gettime_usec();          t = -gettime_usec();
1496          while(1) {          while(1) {
1497              int y;
1498    
1499                  memset(&xframe, 0, sizeof(xframe));                  memset(&xframe, 0, sizeof(xframe));
1500                  xframe.version = XVID_VERSION;                  xframe.version = XVID_VERSION;
1501                  xframe.bitstream = buf + pos;                  xframe.bitstream = buf + pos;
1502                  xframe.length = buf_size - pos;                  xframe.length = buf_size - pos;
1503                  xframe.output.plane[0] = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1504                  xframe.output.stride[0] = width;                  xframe.output.plane[1] = (uint8_t*)xframe.output.plane[0] + bps*height;
1505                  xframe.output.csp = XVID_CSP_BGR;                  xframe.output.plane[2] = (uint8_t*)xframe.output.plane[1] + bps/2;
1506                    xframe.output.stride[0] = bps;
1507                    xframe.output.stride[1] = bps;
1508                    xframe.output.stride[2] = bps;
1509                    xframe.output.csp = XVID_CSP_I420;
1510                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1511                    if (xerr<0) {
1512                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1513                            break;
1514                    }
1515                    else if (xerr==0)
1516                      break;
1517        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1518    
1519                    pos += xerr;
1520                  nb++;                  nb++;
1521                  pos += xframe.length;  
1522                  if (with_chksum) {      for(y=0; y<height/2; ++y) {
1523                          int k = width*height;                    chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1524                          uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1525                          while(k-->0) chksum += *ptr++;                          chksum = calc_crc((uint8_t*)xframe.output.plane[1] + y*bps, width/2, chksum);
1526                            chksum = calc_crc((uint8_t*)xframe.output.plane[2] + y*bps, width/2, chksum);
1527                  }                  }
1528                  if (pos==buf_size)                  if (pos==buf_size)
1529                          break;                          break;
                 if (xerr==XVID_ERR_FAIL) {  
                         printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
                         break;  
                 }  
1530          }          }
1531          t += gettime_usec();          t += gettime_usec();
1532            if (ref_chksum==0) {
1533          if (t>0.)          if (t>0.)
1534                  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 );
1535          if (with_chksum)    }
1536                  printf("checksum: 0x%.8x\n", chksum);    else {
1537                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1538                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1539      }
1540    
1541   End:   End:
1542          if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1543          if (buf!=0) free(buf);          if (buf!=0) free(buf);
1544          if (dechandle!=0) {          if (dechandle!=0) {
1545                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1546                  if (xerr==XVID_ERR_FAIL)                  if (xerr==XVID_ERR_FAIL)
1547                          printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1548          }          }
1549          if (f!=0) fclose(f);          if (f!=0) fclose(f);
1550  }  }
# Line 1163  Line 1556 
1556  void test_bugs1()  void test_bugs1()
1557  {  {
1558          CPU *cpu;          CPU *cpu;
1559            uint16_t mpeg_quant_matrices[64*8];
1560    
1561          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );          printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1562    
# Line 1175  Line 1569 
1569                          continue;                          continue;
1570    
1571                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1572                  set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1573                  dequant_mpeg_intra(Dst, Src, 31, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1574                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1575                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1576                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1194  Line 1588 
1588                          continue;                          continue;
1589    
1590                  for(i=0; i<64; ++i) Src[i] = i-32;                  for(i=0; i<64; ++i) Src[i] = i-32;
1591                  set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1592                  dequant_mpeg_inter(Dst, Src, 31);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1593                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1594                  printf( "  Out[]= " );                  printf( "  Out[]= " );
1595                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);                  for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
# Line 1206  Line 1600 
1600  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1601  {  {
1602          CPU *cpu;          CPU *cpu;
1603          short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1604            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1605    
1606          printf( "\n =====  fdct/idct precision diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1607    
# Line 1239  Line 1634 
1634          const int max_Q = 31;          const int max_Q = 31;
1635          int i, n, qm, q;          int i, n, qm, q;
1636          CPU *cpu;          CPU *cpu;
1637          int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1638            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1639          uint8_t Quant[8*8];          uint8_t Quant[8*8];
1640          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };          CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1641          uint16_t Crcs_Inter[2][32];          uint16_t Crcs_Inter[2][32];
1642          uint16_t Crcs_Intra[2][32];          uint16_t Crcs_Intra[2][32];
1643            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1644    
1645          printf( "\n =====  test MPEG4-quantize bug =====\n" );          printf( "\n =====  test MPEG4-quantize bug =====\n" );
1646    
1647          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 1650 
1650          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1651          {          {
1652                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1653                  set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1654    
1655                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1656                  {                  {
# Line 1263  Line 1661 
1661    
1662                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1663                                  emms();                                  emms();
1664                                  quant_mpeg_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1665                                  emms();                                  emms();
1666                                  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;
1667                                  Crcs_Inter[n][q] = s;                                  Crcs_Inter[n][q] = s;
# Line 1282  Line 1680 
1680          for(qm=1; qm<=255; ++qm)          for(qm=1; qm<=255; ++qm)
1681          {          {
1682                  for(i=0; i<8*8; ++i) Quant[i] = qm;                  for(i=0; i<8*8; ++i) Quant[i] = qm;
1683                  set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1684    
1685                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)                  for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1686                  {                  {
# Line 1293  Line 1691 
1691    
1692                          for(q=1; q<=max_Q; ++q) {                          for(q=1; q<=max_Q; ++q) {
1693                                  emms();                                  emms();
1694                                  quant_mpeg_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1695                                  emms();                                  emms();
1696                                  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;
1697                                  Crcs_Intra[n][q] = s;                                  Crcs_Intra[n][q] = s;
# Line 1310  Line 1708 
1708  }  }
1709    
1710  /*********************************************************************  /*********************************************************************
1711     * test some YUV func
1712     *********************************************************************/
1713    
1714    #define ENTER \
1715    for(i=0; i<(int)sizeof(Dst0); ++i) Dst0[0][i] = 0;   \
1716    t = gettime_usec();                   \
1717    emms();
1718    
1719    #define LEAVE \
1720    emms();                             \
1721    t = (gettime_usec() - t) / nb_tests;  \
1722            iCrc = calc_crc((uint8_t*)Dst0, sizeof(Dst0), CRC32_INITIAL)
1723    
1724    #define TEST_YUYV(FUNC, S)                \
1725    ENTER                               \
1726    for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst0[0], S*WIDTH, Src0[0], Src0[1], Src0[2], WIDTH, WIDTH/2, WIDTH, HEIGHT, 0); \
1727    LEAVE
1728    
1729    #define WIDTH 128
1730    #define HEIGHT 32
1731    void test_yuv()
1732    {
1733            const int nb_tests = 200*speed_ref;
1734            CPU *cpu;
1735            uint8_t Src0[3][WIDTH*HEIGHT];
1736            uint8_t Dst0[4][WIDTH*HEIGHT];
1737            int i, j;
1738            double t;
1739            int tst, iCrc;
1740    
1741            colorspace_init();
1742            ieee_reseed(1);
1743            for(i=0; i<(int)sizeof(Src0); ++i) Src0[0][i] = ieee_rand(0,255);
1744            for(i=0; i<(int)sizeof(Dst0); ++i) Dst0[0][i] = 0x5a;
1745    
1746            printf( "\n ===  test YUV ===\n" );
1747    
1748            init_cpu(&cpu_list[0]);
1749            TEST_YUYV(yv12_to_yuyv_c, 4);
1750            printf(" yv12_to_yuyv_c %.3f usec       crc32=0x%08x %s\n",
1751                       t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1752            TEST_YUYV(yv12_to_uyvy_c, 4);
1753            printf(" yv12_to_uyvy_c %.3f usec       crc32=0x%08x %s\n",
1754                       t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1755    
1756    #ifdef ARCH_IS_IA32
1757            init_cpu(&cpu_list[1]);
1758            TEST_YUYV(yv12_to_yuyv_mmx, 4);
1759            printf(" yv12_to_yuyv_mmx %.3f usec       crc32=0x%08x %s\n",
1760                    t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1761    
1762            TEST_YUYV(yv12_to_uyvy_mmx, 4);
1763            printf(" yv12_to_uyvy_mmx %.3f usec       crc32=0x%08x %s\n",
1764                    t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1765    #endif
1766    
1767    #ifdef ARCH_IS_PPC
1768            init_cpu(&cpu_list[1]);
1769            TEST_YUYV(yv12_to_yuyv_altivec_c, 4);
1770            printf(" yv12_to_yuyv_altivec_c %.3f usec       crc32=0x%08x %s\n",
1771                    t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1772    
1773            TEST_YUYV(yv12_to_uyvy_altivec_c, 4);
1774            printf(" yv12_to_uyvy_altivec_c %.3f usec       crc32=0x%08x %s\n",
1775                    t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1776    #endif
1777            printf( " --- \n" );
1778    }
1779    
1780    #define TEST_YV2(FUNC, WITH_UV, WITH_FLIP)        \
1781    ENTER                               \
1782    for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst0[0], Dst0[1], Dst0[2], WIDTH, WIDTH, \
1783            Src0[0], (WITH_UV) ? Src0[1] : 0, (WITH_UV) ? Src0[2] : 0,  WIDTH, WIDTH, \
1784            WIDTH-2, HEIGHT-2, WITH_FLIP); \
1785    LEAVE
1786    
1787    #define PRINT_NxN(DATA,W,H,STR)   {   \
1788            int i,j; \
1789            for(j=0; j<(H); ++j) { \
1790                    for(i=0; i<(W); ++i) printf( "0x%.2x ", (DATA)[i+j*(STR)] );\
1791                    printf("\n"); \
1792            } \
1793            printf("---\n"); \
1794    }
1795    
1796    static const int yv12_CRCs[2][2] = {
1797            {0x5cab7cf0,0xdab46541}
1798    ,       {0xe8bae865,0x1faf77b7}
1799    };
1800    
1801    void test_yuv2()
1802    {
1803            const int nb_tests = 800*speed_ref;
1804            CPU *cpu;
1805            uint8_t Src0[3][WIDTH*HEIGHT];
1806            uint8_t Dst0[3][WIDTH*HEIGHT];
1807            int with_uv, with_flip;
1808            int i, j;
1809            double t;
1810            int tst, iCrc;
1811    
1812            colorspace_init();
1813            ieee_reseed(1);
1814            for(i=0; i<(int)sizeof(Src0); ++i) Src0[0][i] = ieee_rand(0,255);
1815    
1816            printf( "\n ===  test YV2 ===\n" );
1817            for(with_flip=0; with_flip<=1; ++with_flip) {
1818                    for(with_uv=0; with_uv<=1; ++with_uv) {
1819                            init_cpu(&cpu_list[0]);
1820                            TEST_YV2(yv12_to_yv12_c, with_uv, with_flip);
1821                            printf(" yv12_to_yv12_c   %.3f usec      \tcrc32=0x%08x %s\n",
1822                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1823                            /* if (!with_uv) PRINT_NxN(Dst0[1], WIDTH/2, HEIGHT/2, WIDTH ); */
1824    
1825    #ifdef ARCH_IS_IA32
1826                            init_cpu(&cpu_list[1]);
1827                            TEST_YV2(yv12_to_yv12_mmx, with_uv, with_flip);
1828                            printf(" yv12_to_yv12_mmx %.3f usec     \tcrc32=0x%08x %s\n",
1829                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1830                            /* if (!with_uv) PRINT_NxN(Dst0[1], WIDTH/2, HEIGHT/2, WIDTH ); */
1831    
1832                            TEST_YV2(yv12_to_yv12_xmm, with_uv, with_flip);
1833                            printf(" yv12_to_yv12_xmm %.3f usec     \tcrc32=0x%08x %s\n",
1834                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1835    #endif
1836                    }
1837    
1838                    printf( " --- \n" );
1839            }
1840            printf( " ===== \n" );
1841    }
1842    
1843    #undef WIDTH
1844    #undef HEIGHT
1845    #undef ENTER
1846    #undef LEAVE
1847    
1848    /*********************************************************************/
1849    
1850    static uint32_t __inline log2bin_v1(uint32_t value)
1851    {
1852      int n = 0;
1853      while (value) {
1854        value >>= 1;
1855        n++;
1856      }
1857      return n;
1858    }
1859    
1860    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1861    
1862    static uint32_t __inline log2bin_v2(uint32_t value)
1863    {
1864      int n = 0;
1865      if (value & 0xffff0000) {
1866        value >>= 16;
1867        n += 16;
1868      }
1869      if (value & 0xff00) {
1870        value >>= 8;
1871        n += 8;
1872      }
1873      if (value & 0xf0) {
1874        value >>= 4;
1875        n += 4;
1876      }
1877     return n + log2_tab_16[value];
1878    }
1879    
1880    void test_log2bin()
1881    {
1882            const int nb_tests = 3000*speed_ref;
1883      int n, crc1=0, crc2=0;
1884      uint32_t s, s0;
1885      double t1, t2;
1886    
1887      t1 = gettime_usec();
1888      s0 = (int)(t1*31.241);
1889      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1890        crc1 += log2bin_v1(s);
1891      t1 = (gettime_usec()-t1) / nb_tests;
1892    
1893      t2 = gettime_usec();
1894      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1895        crc2 += log2bin_v2(s);
1896      t2 = (gettime_usec() - t2) / nb_tests;
1897    
1898      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1899      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1900      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1901    }
1902    
1903    /*********************************************************************/
1904    
1905    static void __inline old_gcd(int *num, int *den)
1906    {
1907     int i = *num;
1908      while (i > 1) {
1909        if (*num % i == 0 && *den % i == 0) {
1910          *num /= i;
1911          *den /= i;
1912          i = *num;
1913          continue;
1914        }
1915        i--;
1916      }
1917    }
1918    
1919    static uint32_t gcd(int num, int den)
1920    {
1921      int tmp;
1922      while( (tmp=num%den) ) { num = den; den = tmp; }
1923      return den;
1924    }
1925    static void __inline new_gcd(int *num, int *den)
1926    {
1927      const int div = gcd(*num, *den);
1928      if (num) {
1929        *num /= div;
1930        *den /= div;
1931      }
1932    }
1933    
1934    void test_gcd()
1935    {
1936      const int nb_tests = 10*speed_ref;
1937      int i;
1938      uint32_t crc1=0, crc2=0;
1939      uint32_t n0, n, d0, d;
1940      double t1, t2;
1941    
1942      t1 = gettime_usec();
1943      n0 = 0xfffff & (int)(t1*31.241);
1944      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1945      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1946        old_gcd(&n, &d);
1947        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1948        n = d;
1949        d = (d*12363+31) & 0xffff;
1950        d |= !d;
1951      }
1952      t1 = (gettime_usec()-t1) / nb_tests;
1953    
1954      t2 = gettime_usec();
1955      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1956        new_gcd(&n, &d);
1957        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1958        n = d;
1959        d = (d*12363+31) & 0xffff;
1960        d |= !d;
1961      }
1962      t2 = (gettime_usec() - t2) / nb_tests;
1963    
1964      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1965      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1966      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1967    }
1968    
1969    /*********************************************************************
1970     * test compiler
1971     *********************************************************************/
1972    
1973    void test_compiler() {
1974      int nb_err = 0;
1975      int32_t v;
1976      if (sizeof(uint16_t)<2) {
1977        printf( "ERROR: sizeof(uint16_t)<2 !!\n" );
1978        nb_err++;
1979      }
1980      if (sizeof(int16_t)<2) {
1981        printf( "ERROR: sizeof(int16_t)<2 !!\n" );
1982        nb_err++;
1983      }
1984      if (sizeof(uint8_t)!=1) {
1985        printf( "ERROR: sizeof(uint8_t)!=1 !!\n" );
1986        nb_err++;
1987      }
1988      if (sizeof(int8_t)!=1) {
1989        printf( "ERROR: sizeof(int8_t)!=1 !!\n" );
1990        nb_err++;
1991      }
1992      if (sizeof(uint32_t)<4) {
1993        printf( "ERROR: sizeof(uint32_t)<4 !!\n" );
1994        nb_err++;
1995      }
1996      if (sizeof(int32_t)<4) {
1997        printf( "ERROR: sizeof(int32_t)<4 !!\n" );
1998        nb_err++;
1999      }
2000             /* yes, i know, this test is silly. But better be safe than sorry. :) */
2001      for(v=1000; v>=0; v--) {
2002        if ( (v>>2) != v/4)
2003          nb_err++;
2004      }
2005      for(v=-1000; v!=-1; v++) {
2006        if ( (v>>2) != (v/4)-!!(v%4))
2007          nb_err++;
2008      }
2009      if (nb_err!=0) {
2010        printf( "ERROR! please post your platform/compiler specs to xvid-devel@xvid.org !\n" );
2011      }
2012    }
2013    
2014    /*********************************************************************
2015     * test SSIM functions
2016     *********************************************************************/
2017    
2018    typedef int (*lumfunc)(uint8_t* ptr, int stride);
2019    typedef void (*csfunc)(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2020    
2021    extern int lum_8x8_c(uint8_t* ptr, int stride);
2022    extern int lum_8x8_mmx(uint8_t* ptr, int stride);
2023    extern int lum_2x8_c(uint8_t* ptr, int stride);
2024    extern void consim_c(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2025    extern void consim_mmx(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2026    extern void consim_sse2(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2027    
2028    void test_SSIM()
2029    {
2030            const int nb_tests = 3000*speed_ref;
2031            int tst;
2032            CPU *cpu;
2033            int i;
2034            int devs[3];
2035            long lumo, lumc;
2036            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
2037            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
2038            lumfunc lum8x8;
2039            lumfunc lum2x8;
2040            csfunc  csim;
2041    
2042            ieee_reseed(1);
2043            printf( "\n ======  test SSIM ======\n" );
2044            for(i=0; i<16*16;++i) {
2045                    long v1, v2;
2046                    v1 = ieee_rand(-256, 511);
2047                    v2 = ieee_rand(-256, 511);
2048                    Ref1[i] = (v1<0) ? 0 : (v1>255) ? 255 : v1;
2049                    Ref2[i] = (v2<0) ? 0 : (v2>255) ? 255 : v2;
2050            }
2051            lumc = ieee_rand(0, 255);
2052            lumo = ieee_rand(0, 255);
2053    
2054            for(cpu = cpu_list; cpu->name!=0; ++cpu)
2055            {
2056                    double t;
2057                    int m;
2058                    if (!init_cpu(cpu))
2059                            continue;
2060                    lum8x8 = lum_8x8_c;
2061                    lum2x8 = lum_2x8_c;
2062                    csim   = consim_c;
2063    #ifdef ARCH_IS_IA32
2064                    if (cpu->cpu & XVID_CPU_MMX){
2065                            lum8x8 = lum_8x8_mmx;
2066                            csim = consim_mmx;
2067                    }
2068                    if (cpu->cpu & XVID_CPU_MMX){
2069                            csim = consim_sse2;
2070                    }
2071    #endif
2072                    t = gettime_usec();
2073                    emms();
2074                    for(tst=0; tst<nb_tests; ++tst) m = lum8x8(Ref1, 16);
2075                    emms();
2076                    t = (gettime_usec() - t) / nb_tests;
2077                    printf("%s - ssim-lum8x8    %.3f usec       m=%d %s\n",
2078                               cpu->name, t, m,
2079                               (m!=8230)?"| ERROR": "" );
2080    
2081                    t = gettime_usec();
2082                    emms();
2083                    for(tst=0; tst<nb_tests; ++tst) m = lum2x8(Ref1+8, 16);
2084                    emms();
2085                    t = (gettime_usec() - t) / nb_tests;
2086                    printf("%s - ssim-lum2x8    %.3f usec       m=%d %s\n",
2087                               cpu->name, t, m,
2088                               (m!=681)?"| ERROR": "" );
2089    
2090                    t = gettime_usec();
2091                    emms();
2092                    for(tst=0; tst<nb_tests; ++tst) csim(Ref1, Ref2, 16, lumo, lumc, devs+0, devs+1, devs+2);
2093                    emms();
2094                    t = (gettime_usec() - t) / nb_tests;
2095                    printf("%s - ssim-consim    %.3f usec       devs=[0x%x 0x%x 0x%x] %s\n",
2096                               cpu->name, t, devs[0], devs[1], devs[2],
2097                               (devs[0]!=0x1bdf0f || devs[1]!=0x137258 ||  devs[2]!=0xcdb13)?"| ERROR": "" );
2098                    printf( " --- \n" );
2099            }
2100    }
2101    
2102    /*********************************************************************
2103     * test bitstream functions
2104     *********************************************************************/
2105    
2106    #define BIT_BUF_SIZE 2000
2107    
2108    static void test_bits()
2109    {
2110      const int nb_tests = 50*speed_ref;
2111      int tst;
2112      uint32_t Crc;
2113      uint8_t Buf[BIT_BUF_SIZE];
2114      uint32_t Extracted[BIT_BUF_SIZE*8]; /* worst case: bits read 1 by 1 */
2115      int Lens[BIT_BUF_SIZE*8];
2116      double t1;
2117    
2118    
2119      printf( "\n ===  test bitstream ===\n" );
2120      ieee_reseed(1);
2121      Crc = 0;
2122    
2123      t1 = gettime_usec();
2124      for(tst=0; tst<nb_tests; ++tst) {
2125            Bitstream bs;
2126            int m, m2, l, l2;
2127    
2128            for(l=0; l<BIT_BUF_SIZE; ++l)
2129                    Buf[l] = (uint8_t)ieee_rand(0,255);
2130    
2131            l = BIT_BUF_SIZE - ieee_rand(1,BIT_BUF_SIZE/10);
2132            BitstreamInit(&bs, (void*)(Buf+BIT_BUF_SIZE-l), l);
2133    
2134    
2135            BitstreamReset(&bs);
2136            for(l2=l*8, m=0; l2>0; m++) {
2137                    const int b = ieee_rand(1,32);
2138                    Lens[m] = b;
2139                    l2 -= b;
2140                    if (l2<0) break;
2141                    Extracted[m] = BitstreamShowBits(&bs, b);
2142                    BitstreamSkip(&bs, b);
2143    //              printf( "<= %d: %d 0x%x\n", m, b, Extracted[m]);
2144            }
2145    
2146            BitstreamReset(&bs);
2147            for(m2=0; m2<m; ++m2) {
2148                    const int b = Lens[m2];
2149                    const uint32_t v = BitstreamGetBits(&bs, b);
2150                    Crc |= (v!=Extracted[m2]);
2151    //              printf( "=> %d: %d 0x%x %c\n", m2, b, v, " *"[Crc]);
2152            }
2153      }
2154      t1 = (gettime_usec() - t1) / nb_tests;
2155      printf(" test_bits   %.3f usec   %s\n", t1, (Crc!=0)?"| ERROR": "" );
2156    }
2157    
2158    /*********************************************************************
2159   * main   * main
2160   *********************************************************************/   *********************************************************************/
2161    
2162  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
2163  {  {
2164          int what = 0;    printf( "missing argument after option '%s'\n", opt);
2165          if (argc>1) what = atoi(argv[1]);    exit(-1);
2166    }
2167    
2168    int main(int argc, const char *argv[])
2169    {
2170            int c, what = 0;
2171            int width, height;
2172            uint32_t chksum = 0;
2173            const char * test_bitstream = 0;
2174    
2175            cpu_mask = 0;  // default => will use autodectect
2176            for(c=1; c<argc; ++c)
2177            {
2178              if (!strcmp(argv[c], "-v")) verbose++;
2179              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
2180              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
2181              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
2182              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
2183              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
2184              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
2185              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
2186              else if (!strcmp(argv[c], "-spd")) {
2187          if (++c==argc) arg_missing( argv[argc-1] );
2188          speed_ref = atoi(argv[c]);
2189        }
2190              else if (argv[c][0]!='-') {
2191                what = atoi(argv[c]);
2192                if (what==9) {
2193                  if (c+4>argc) {
2194                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
2195                    exit(-1);
2196            }
2197            test_bitstream = argv[++c];
2198                  width  = atoi(argv[++c]);
2199                  height = atoi(argv[++c]);
2200                  if (c+1<argc && argv[c+1][0]!='-') {
2201                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
2202                      printf( "can't read checksum value.\n" );
2203                      exit(-1);
2204              }
2205              else c++;
2206            }
2207    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
2208          }
2209        }
2210        else {
2211          printf( "unrecognized option '%s'\n", argv[c]);
2212          exit(-1);
2213        }
2214      }
2215    
2216    
2217          if (what==0 || what==1) test_dct();          if (what==0 || what==1) test_dct();
2218          if (what==0 || what==2) test_mb();          if (what==0 || what==2) test_mb();
2219          if (what==0 || what==3) test_sad();          if (what==0 || what==3) test_sad();
2220          if (what==0 || what==4) test_transfer();          if (what==0 || what==4) test_transfer();
2221          if (what==0 || what==5) test_quant();          if (what==0 || what==5) test_quant();
2222          if (what==0 || what==6) test_cbp();          if (what==0 || what==6) test_cbp();
2223            if (what==0 || what==10) test_sse();
2224            if (what==0 || what==11) test_log2bin();
2225            if (what==0 || what==12) test_gcd();
2226            if (what==0 || what==13) test_compiler();
2227            if (what==0 || what==14) test_yuv();
2228            if (what==0 || what==15) test_SSIM();
2229            if (what==0 || what==16) test_yuv2();
2230            if (what==0 || what==17) test_bits();
2231    
2232          if (what==7) {          if (what==7) {
2233                  test_IEEE1180_compliance(-256, 255, 1);                  test_IEEE1180_compliance(-256, 255, 1);
# Line 1334  Line 2239 
2239          }          }
2240          if (what==8) test_dct_saturation(-256, 255);          if (what==8) test_dct_saturation(-256, 255);
2241    
2242          if (what==9) {          if (test_bitstream)
2243                  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));  
         }  
   
2244          if (what==-1) {          if (what==-1) {
2245                  test_dct_precision_diffs();                  test_dct_precision_diffs();
2246                  test_bugs1();                  test_bugs1();
# Line 1352  Line 2248 
2248          if (what==-2)          if (what==-2)
2249                  test_quant_bug();                  test_quant_bug();
2250    
2251          return 0;          if ((what >= 0 && what <= 6) || what == 10) {
2252                    printf("\n\n"
2253                               "NB: If a function isn't optimised for a specific set of intructions,\n"
2254                               "    a C function is used instead. So don't panic if some functions\n"
2255                               "    may appear to be slow.\n");
2256  }  }
2257    
2258  /*********************************************************************  #ifdef ARCH_IS_IA32
2259   * 'Reference' output (except for timing) on an Athlon XP 2200+          if (what == 0 || what == 5) {
2260   *********************************************************************/                  printf("\n"
2261                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
2262  /* 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"
2263  /*                             "    test goes far behind the usual limits of real encoding. Please do not report\n"
2264                               "    this error to the developers.\n");
2265            }
2266    #endif
2267    
2268   ===== test fdct/idct =====          return 0;
2269  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  
  ---  
2270    
2271  */  /*********************************************************************/
Legend:
Removed from v.1.9.2.8  
changed lines
  Added in v.1.35
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4