[svn] / trunk / xvidcore / examples / xvid_bench.c Repository:
ViewVC logotype

Diff of /trunk/xvidcore/examples/xvid_bench.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 225, Wed Jun 19 14:27:08 2002 UTC revision 1616, Tue May 17 21:03:32 2005 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC - Unit tests and benches   *  XVID MPEG-4 VIDEO CODEC
4     *  - Unit tests and benches -
5     *
6     *  Copyright(C) 2002 Pascal Massimino <skal@planet-d.net>
7   *   *
8   *      This program is free software; you can redistribute it and/or modify   *      This program is free software; you can redistribute it and/or modify
9   *      it under the terms of the GNU General Public License as published by   *      it under the terms of the GNU General Public License as published by
# Line 14  Line 17 
17   *   *
18   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
19   *      along with this program; if not, write to the Free Software   *      along with this program; if not, write to the Free Software
20   *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21     *
22     * $Id: xvid_bench.c,v 1.18 2005-05-17 21:03:32 Skal Exp $
23   *   *
24   *************************************************************************/   ****************************************************************************/
25    
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...  
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
32   *   *
33   *      History:   ****************************************************************************/
  *  
  *      06.06.2002  initial coding      -Skal-  
  *  
  *************************************************************************/  
34    
35  #include <stdio.h>  #include <stdio.h>
36  #include <stdlib.h>  #include <stdlib.h>
37  #include <sys/time.h>  // for gettimeofday  #include <string.h>    /* for memset */
 #include <string.h>    // for memset  
38  #include <assert.h>  #include <assert.h>
39    
40    #ifndef WIN32
41    #include <sys/time.h>   /* for gettimeofday */
42    #else
43    #include <time.h>
44    #endif
45    
46    
47  #include "xvid.h"  #include "xvid.h"
48    
49  // inner guts  // inner guts
# Line 47  Line 52 
52  #include "image/colorspace.h"  #include "image/colorspace.h"
53  #include "image/interpolate8x8.h"  #include "image/interpolate8x8.h"
54  #include "utils/mem_transfer.h"  #include "utils/mem_transfer.h"
55  #include "quant/quant_h263.h"  #include "quant/quant.h"
 #include "quant/quant_mpeg4.h"  
56  #include "motion/sad.h"  #include "motion/sad.h"
57  #include "utils/emms.h"  #include "utils/emms.h"
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    
62  const int speed_ref = 100;  // on slow machines, decrease this value  #include <math.h>
63    
64    #ifndef M_PI
65    #define M_PI            3.14159265358979323846
66    #endif
67    
68    int speed_ref = 100;  /* on slow machines, decrease this value */
69    int verbose = 0;
70    unsigned int cpu_mask;
71    
72  /*********************************************************************  /*********************************************************************
73   * misc   * misc
# Line 64  Line 76 
76   /* returns time in micro-s*/   /* returns time in micro-s*/
77  double gettime_usec()  double gettime_usec()
78  {  {
79    #ifndef WIN32
80    struct timeval  tv;    struct timeval  tv;
81    gettimeofday(&tv, 0);    gettimeofday(&tv, 0);
82    return tv.tv_sec*1.0e6f + tv.tv_usec;          return tv.tv_sec*1.0e6 + tv.tv_usec;
83    #else
84            clock_t clk;
85            clk = clock();
86            return clk * 1000. / CLOCKS_PER_SEC;  /* clock() returns time in Milliseconds */
87    #endif
88  }  }
89    
90   /* returns squared deviates (mean(v*v)-mean(v)^2) of a 8x8 block */   /* returns squared deviates (mean(v*v)-mean(v)^2) of a 8x8 block */
# Line 96  Line 114 
114    
115  CPU cpu_list[] =  CPU cpu_list[] =
116  { { "PLAINC", 0 }  { { "PLAINC", 0 }
117    #ifdef ARCH_IS_IA32
118  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
119  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }
120  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }
121  , { "3DNOW ", XVID_CPU_3DNOW }  , { "3DNOW ", XVID_CPU_3DNOW }
122  , { "3DNOWE", XVID_CPU_3DNOWEXT }    , { "3DNOWE", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT }
123    #endif
124    #ifdef ARCH_IS_PPC
125      , { "ALTIVEC", XVID_CPU_ALTIVEC }
126    #endif
127    #ifdef ARCH_IS_X86_64
128      , { "X86_64", XVID_CPU_ASM}
129    #endif
130    //, { "IA64  ", XVID_CPU_IA64 }
131  //, { "TSC   ", XVID_CPU_TSC }  //, { "TSC   ", XVID_CPU_TSC }
132  , { 0, 0 } }    , { 0, 0 } };
133    
134  , cpu_short_list[] =  CPU  cpu_short_list[] =
135  { { "PLAINC", 0 }  { { "PLAINC", 0 }
136    #ifdef ARCH_IS_IA32
137  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
138  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }  //, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }
139  , { 0, 0 } }  #endif
140    //, { "IA64  ", XVID_CPU_IA64 }
141      , { 0, 0 } };
142    
143  , cpu_short_list2[] =  CPU cpu_short_list2[] =
144  { { "PLAINC", 0 }  { { "PLAINC", 0 }
145    #ifdef ARCH_IS_IA32
146  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
147  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }
148    #endif
149  , { 0, 0 } };  , { 0, 0 } };
150    
151    
152  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
153  {  {
154    int xerr, cpu_type;          xvid_gbl_info_t xinfo;
155    XVID_INIT_PARAM xinit;  
156            /* Get the available CPU flags */
157            memset(&xinfo, 0, sizeof(xinfo));
158            xinfo.version = XVID_VERSION;
159            xvid_global(NULL, XVID_GBL_INFO, &xinfo, NULL);
160    
161    cpu_type = check_cpu_features() & cpu->cpu;          /* Are we trying to test a subset of the host CPU features */
162    xinit.cpu_flags = cpu_type | XVID_CPU_FORCE;          if ((xinfo.cpu_flags & cpu->cpu) == cpu->cpu) {
163    //    xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;                  int xerr;
164    xerr = xvid_init(NULL, 0, &xinit, NULL);                  xvid_gbl_init_t xinit;
165    if (cpu->cpu>0 && (cpu_type==0 || xerr!=XVID_ERR_OK)) {                  memset(&xinit, 0, sizeof(xinit));
166      printf( "%s - skipped...\n", cpu->name );                  xinit.cpu_flags = cpu->cpu | XVID_CPU_FORCE;
167                    xinit.version = XVID_VERSION;
168                    xerr = xvid_global(NULL, XVID_GBL_INIT, &xinit, NULL);
169                    if (xerr==XVID_ERR_FAIL) {
170                            /* libxvidcore failed to init */
171      return 0;      return 0;
172    }    }
173            } else {
174                    /* The host CPU doesn't support some required feature for this test */
175                    return(0);
176            }
177    return 1;    return 1;
178  }  }
179    
180    #define CRC32_REMAINDER 0xCBF43926
181    #define CRC32_INITIAL 0xffffffff
182    
183    #define DO1(c, crc) ((crc) = crc32tab[((unsigned int)((crc)>>24) ^ (*c++)) & 0xff] ^ ((crc) << 8))
184    #define DO2(c, crc)  DO1(c, crc); DO1(c, crc);
185    #define DO4(c, crc)  DO2(c, crc); DO2(c, crc);
186    #define DO8(c, crc)  DO4(c, crc); DO4(c, crc);
187    
188    /******************************************************************************
189    * Precomputed AAL5 CRC32 lookup table
190    ******************************************************************************/
191    
192    static unsigned long crc32tab[256] = {
193    
194            0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
195            0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
196            0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
197            0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
198            0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
199            0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
200            0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
201            0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
202            0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
203            0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
204            0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
205            0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
206            0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
207            0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
208            0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
209            0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
210            0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
211            0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
212            0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
213            0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
214            0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
215            0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
216            0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
217            0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
218            0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
219            0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
220            0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
221            0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
222            0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
223            0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
224            0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
225            0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
226            0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
227            0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
228            0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
229            0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
230            0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
231            0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
232            0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
233            0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
234            0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
235            0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
236            0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
237            0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
238            0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
239            0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
240            0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
241            0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
242            0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
243            0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
244            0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
245            0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
246            0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
247            0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
248            0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
249            0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
250            0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
251            0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
252            0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
253            0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
254            0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
255            0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
256            0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
257            0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
258    
259    };
260    
261    uint32_t
262    calc_crc(uint8_t *mem, int len, uint32_t crc)
263    {
264            while( len >= 8) {
265                    DO8(mem, crc);
266                    len -= 8;
267            }
268    
269            while( len ) {
270                    DO1(mem, crc);
271                    len--;
272            }
273    
274            return crc;
275    }
276    
277  /*********************************************************************  /*********************************************************************
278   * test DCT   * test DCT
279   *********************************************************************/   *********************************************************************/
# Line 145  Line 286 
286    int tst;    int tst;
287    CPU *cpu;    CPU *cpu;
288    int i;    int i;
289    short iDst0[8*8], iDst[8*8], fDst[8*8];          DECLARE_ALIGNED_MATRIX(iDst0, 8, 8, short, 16);
290            DECLARE_ALIGNED_MATRIX(iDst,  8, 8, short, 16);
291            DECLARE_ALIGNED_MATRIX(fDst,  8, 8, short, 16);
292    double overhead;    double overhead;
293    
294    printf( "\n ===== test fdct/idct =====\n" );    printf( "\n ===== test fdct/idct =====\n" );
# Line 161  Line 304 
304    
305    for(cpu = cpu_list; cpu->name!=0; ++cpu)    for(cpu = cpu_list; cpu->name!=0; ++cpu)
306    {    {
307      double t;                  double t, PSNR, MSE;
     int iCrc, fCrc;  
308    
309      if (!init_cpu(cpu))      if (!init_cpu(cpu))
310        continue;        continue;
# Line 178  Line 320 
320      }      }
321      emms();      emms();
322      t = (gettime_usec() - t - overhead) / nb_tests;      t = (gettime_usec() - t - overhead) / nb_tests;
323      iCrc=0; fCrc=0;                  MSE = 0.;
324      for(i=0; i<8*8; ++i) {      for(i=0; i<8*8; ++i) {
325        iCrc += ABS(iDst[i] - iDst0[i]);                          double delta = 1.0*(iDst[i] - iDst0[i]);
326        fCrc += fDst[i]^i;                          MSE += delta*delta;
327      }      }
328      printf( "%s -  %.3f usec       iCrc=%d  fCrc=%d\n",                  PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
329        cpu->name, t, iCrc, fCrc );                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
330        // the norm tolerates ~1 bit of diff per coeff                                  cpu->name, t, PSNR, MSE,
331      if (ABS(iCrc)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
332    }    }
333  }  }
334    
# Line 200  Line 342 
342    int tst;    int tst;
343    CPU *cpu;    CPU *cpu;
344    int i;    int i;
345    uint8_t Cur[16*16], Ref1[16*16], Ref2[16*16];          DECLARE_ALIGNED_MATRIX(Cur,  16, 16, uint8_t, 16);
346            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
347            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
348    
349    printf( "\n ======  test SAD ======\n" );    printf( "\n ======  test SAD ======\n" );
350    for(i=0; i<16*16;++i) {    for(i=0; i<16*16;++i) {
# Line 221  Line 365 
365      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
366      emms();      emms();
367      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
368      printf( "%s - sad8    %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad8    %.3f usec       sad=%d %s\n",
369      if (s!=3776) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
370                               (s!=3776)?"| ERROR": "" );
371    
372      t = gettime_usec();      t = gettime_usec();
373      emms();      emms();
374      for(tst=0; tst<nb_tests; ++tst) s = sad16(Cur, Ref1, 16, -1);      for(tst=0; tst<nb_tests; ++tst) s = sad16(Cur, Ref1, 16, -1);
375      emms();      emms();
376      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
377      printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad16   %.3f usec       sad=%d %s\n",
378      if (s!=27214) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
379                               (s!=27214)?"| ERROR": "" );
380    
381      t = gettime_usec();      t = gettime_usec();
382      emms();      emms();
383      for(tst=0; tst<nb_tests; ++tst) s = sad16bi(Cur, Ref1, Ref2, 16);      for(tst=0; tst<nb_tests; ++tst) s = sad16bi(Cur, Ref1, Ref2, 16);
384      emms();      emms();
385      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
386      printf( "%s - sad16bi %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - sad16bi %.3f usec       sad=%d %s\n",
387      if (s!=26274) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
388                                    (s!=26274)?"| ERROR": "" );
389    
390      t = gettime_usec();      t = gettime_usec();
391      emms();      emms();
392      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
393      emms();      emms();
394      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
395      printf( "%s - dev16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - dev16   %.3f usec       sad=%d %s\n",
396      if (s!=3344) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
397                                    (s!=3344)?"| ERROR": "" );
398    
399      printf( " --- \n" );      printf( " --- \n" );
400    }    }
# Line 264  Line 412 
412  #define LEAVE \  #define LEAVE \
413      emms();                             \      emms();                             \
414      t = (gettime_usec() - t) / nb_tests;  \      t = (gettime_usec() - t) / nb_tests;  \
415      iCrc = 0;                           \          iCrc = calc_crc((uint8_t*)Dst, sizeof(Dst), CRC32_INITIAL)
     for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }  
416    
417  #define TEST_MB(FUNC, R)                \  #define TEST_MB(FUNC, R)                \
418      ENTER                               \      ENTER                               \
# Line 283  Line 430 
430    const int nb_tests = 2000*speed_ref;    const int nb_tests = 2000*speed_ref;
431    CPU *cpu;    CPU *cpu;
432    const uint8_t Src0[16*9] = {    const uint8_t Src0[16*9] = {
433          // try to have every possible combinaison of rounding...                  /* try to have every possible combinaison of rounding... */
434        0, 0, 1, 0, 2, 0, 3, 0, 4             ,0,0,0, 0,0,0,0                  0, 0, 1, 0, 2, 0, 3, 0, 4             ,0,0,0, 0,0,0,0,
435      , 0, 1, 1, 1, 2, 1, 3, 1, 3             ,0,0,0, 0,0,0,0                  0, 1, 1, 1, 2, 1, 3, 1, 3             ,0,0,0, 0,0,0,0,
436      , 0, 2, 1, 2, 2, 2, 3, 2, 2             ,0,0,0, 0,0,0,0                  0, 2, 1, 2, 2, 2, 3, 2, 2             ,0,0,0, 0,0,0,0,
437      , 0, 3, 1, 3, 2, 3, 3, 3, 1             ,0,0,0, 0,0,0,0                  0, 3, 1, 3, 2, 3, 3, 3, 1             ,0,0,0, 0,0,0,0,
438      , 1, 3, 0, 2, 1, 0, 2, 3, 4             ,0,0,0, 0,0,0,0                  1, 3, 0, 2, 1, 0, 2, 3, 4             ,0,0,0, 0,0,0,0,
439      , 2, 2, 1, 2, 0, 1, 3, 5, 3             ,0,0,0, 0,0,0,0                  2, 2, 1, 2, 0, 1, 3, 5, 3             ,0,0,0, 0,0,0,0,
440      , 3, 1, 2, 3, 1, 2, 2, 6, 2             ,0,0,0, 0,0,0,0                  3, 1, 2, 3, 1, 2, 2, 6, 2             ,0,0,0, 0,0,0,0,
441      , 1, 0, 1, 3, 0, 3, 1, 6, 1             ,0,0,0, 0,0,0,0                  1, 0, 1, 3, 0, 3, 1, 6, 1             ,0,0,0, 0,0,0,0,
442      , 4, 3, 2, 1, 2, 3, 4, 0, 3             ,0,0,0, 0,0,0,0                  4, 3, 2, 1, 2, 3, 4, 0, 3             ,0,0,0, 0,0,0,0
443    };    };
444    uint8_t Dst[16*8] = {0};    uint8_t Dst[16*8] = {0};
445    
# Line 307  Line 454 
454        continue;        continue;
455    
456      TEST_MB(interpolate8x8_halfpel_h, 0);      TEST_MB(interpolate8x8_halfpel_h, 0);
457      printf( "%s - interp- h-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp- h-round0 %.3f usec       crc32=0x%08x %s\n",
458      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
459                               (iCrc!=0x115381ba)?"| ERROR": "" );
460    
461      TEST_MB(interpolate8x8_halfpel_h, 1);      TEST_MB(interpolate8x8_halfpel_h, 1);
462      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
463      if (iCrc!=8100) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
464                               (iCrc!=0x2b1f528f)?"| ERROR": "" );
465    
466    
467      TEST_MB(interpolate8x8_halfpel_v, 0);      TEST_MB(interpolate8x8_halfpel_v, 0);
468      printf( "%s - interp- v-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp- v-round0 %.3f usec       crc32=0x%08x %s\n",
469      if (iCrc!=8108) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
470                               (iCrc!=0x423cdcc7)?"| ERROR": "" );
471    
472      TEST_MB(interpolate8x8_halfpel_v, 1);      TEST_MB(interpolate8x8_halfpel_v, 1);
473      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
474      if (iCrc!=8105) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
475                               (iCrc!=0x42202efe)?"| ERROR": "" );
476    
477    
478      TEST_MB(interpolate8x8_halfpel_hv, 0);      TEST_MB(interpolate8x8_halfpel_hv, 0);
479      printf( "%s - interp-hv-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp-hv-round0 %.3f usec       crc32=0x%08x %s\n",
480      if (iCrc!=8112) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
481                               (iCrc!=0xd198d387)?"| ERROR": "" );
482    
483      TEST_MB(interpolate8x8_halfpel_hv, 1);      TEST_MB(interpolate8x8_halfpel_hv, 1);
484      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
485      if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
486                               (iCrc!=0x9ecfd921)?"| ERROR": "" );
487    
488    
489                    /* this is a new function, as of 06.06.2002 */
490    #if 0
491                    TEST_MB2(interpolate8x8_avrg);
492                    printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
493                               cpu->name, t, iCrc,
494                               (iCrc!=8107)?"| ERROR": "" );
495    #endif
496    
497      printf( " --- \n" );      printf( " --- \n" );
498    }    }
# Line 365  Line 527 
527      }                                         \      }                                         \
528      emms();                                   \      emms();                                   \
529      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
530      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]^i; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
531    
532  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
533      TEST_TRANSFER_BEGIN(DST);                 \      TEST_TRANSFER_BEGIN(DST);                 \
# Line 391  Line 553 
553      }                                         \      }                                         \
554      emms();                                   \      emms();                                   \
555      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
556      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
557    
558  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
559      TEST_TRANSFER2_BEGIN(DST,SRC);            \      TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 413  Line 575 
575    
576    printf( "\n ===  test transfer ===\n" );    printf( "\n ===  test transfer ===\n" );
577    
578    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
579    {    {
580      double t, overhead;      double t, overhead;
581      int tst, s;      int tst, s;
# Line 422  Line 584 
584        continue;        continue;
585    
586      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
587      printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
588      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
589                               (s!=0x115814bb)?"| ERROR": "");
590    
591      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
592      printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
593      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
594                                    (s!=0xee7ccbb4)?"| ERROR": "");
595    
596      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
597      printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
598      if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
599                               (s!=0xd37b3295)?"| ERROR": "");
600    
601      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
602      printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
603      if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
604                               (s!=0xdd817bf4)?"| ERROR": "" );
605    
606      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
607      printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
608      if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
609      s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }                          s1 = calc_crc((uint8_t*)Dst16, sizeof(Dst16), CRC32_INITIAL);
610      printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, sizeof(Src8), CRC32_INITIAL);
611      if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
612                                       cpu->name, t, s1, s2,
613                                       (s1!=0xa1e07163)?"| ERROR1": "",
614                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
615                    }
616    
617      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
618      printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
619      if (s!=20384) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
620                               (s!=0x99b6c4c7)?"| ERROR": "" );
621    
622      printf( " --- \n" );      printf( " --- \n" );
623    }    }
# Line 458  Line 629 
629    
630  #define TEST_QUANT(FUNC, DST, SRC)            \  #define TEST_QUANT(FUNC, DST, SRC)            \
631      t = gettime_usec();                       \      t = gettime_usec();                       \
632    for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
633      for(i=0; i<8*8; ++i) Quant[i] = qm;       \
634      set_inter_matrix( mpeg_quant_matrices, Quant );                \
635      emms();                                   \      emms();                                   \
636      for(q=1; q<=max_Q; ++q) {                 \
637      for(tst=0; tst<nb_tests; ++tst)           \      for(tst=0; tst<nb_tests; ++tst)           \
638        for(s=0, q=1; q<=max_Q; ++q) {          \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
639          (FUNC)((DST), (SRC), q);              \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
         for(i=0; i<64; ++i) s+=(DST)[i]^i;    \  
640        }                                       \        }                                       \
641      emms();                                   \      emms();                                   \
642      t = (gettime_usec()-t-overhead)/nb_tests;  }                                           \
643    t = (gettime_usec()-t-overhead)/nb_tests/qm
644    
645  #define TEST_QUANT2(FUNC, DST, SRC, MULT)     \  #define TEST_QUANT2(FUNC, DST, SRC)             \
646      t = gettime_usec();                       \      t = gettime_usec();                       \
647    for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
648      for(i=0; i<8*8; ++i) Quant[i] = qm;       \
649      set_intra_matrix( mpeg_quant_matrices, Quant );                \
650      emms();                                   \      emms();                                   \
651      for(q=1; q<=max_Q; ++q) {                 \
652      for(tst=0; tst<nb_tests; ++tst)           \      for(tst=0; tst<nb_tests; ++tst)           \
653        for(s=0, q=1; q<=max_Q; ++q) {          \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
654          (FUNC)((DST), (SRC), q, MULT);        \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
         for(i=0; i<64; ++i) s+=(DST)[i]^i;    \  
655        }                                       \        }                                       \
656      emms();                                   \      emms();                                   \
657      t = (gettime_usec()-t-overhead)/nb_tests;  }                                           \
658    t = (gettime_usec()-t-overhead)/nb_tests/qm
659    
660    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
661    { int i,q,s;\
662            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
663      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
664      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
665      for(q=1;q<=max_Q;q++)          \
666        for(s=-RANGE;s<RANGE;s++) { \
667          for(i=0;i<64;i++) Src[i]=s; \
668          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
669          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
670          for(i=0;i<64;i++)     \
671            if(Dst[i]!=Dst2[i]) printf("ERROR : " #NEWFUNC " i%d quant:%d input:%d C_result:%d ASM_result:%d\n",i,q,s,Dst[i],Dst2[i]);  \
672        }      \
673    }
674    
675    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
676    { int i,q,s;  \
677            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
678      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
679      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
680      for(q=1;q<=max_Q;q++)  \
681        for(s=-RANGE;s<RANGE;s++) {   \
682          for(i=0;i<64;i++) Src[i]=s; \
683          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
684          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
685          emms();           \
686          for(i=0;i<64;i++) \
687            if(Dst[i]!=Dst2[i]) printf("ERROR : " #NEWFUNC " i%d quant:%d input:%d C_result:%d ASM_result:%d\n",i,q,s,Dst[i],Dst2[i]); \
688        } \
689    }
690    
691  void test_quant()  void test_quant()
692  {  {
693    const int nb_tests = 150*speed_ref;          const int nb_tests = 1*speed_ref;
694    const int max_Q = 31;    const int max_Q = 31;
695    int i;          DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
696    
697            int i, qm;
698    CPU *cpu;    CPU *cpu;
699    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
700            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
701            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
702            uint8_t Quant[8*8];
703    
704    printf( "\n =====  test quant =====\n" );    printf( "\n =====  test quant =====\n" );
705    
706    /* we deliberately enfringe the norm's specified range [-127,127], */
707    /* to test the robustness of the iquant module */
708    for(i=0; i<64; ++i) {    for(i=0; i<64; ++i) {
709      Src[i] = i-32;                  Src[i] = 1 + (i-32) * (i&6);
710      Dst[i] = 0;      Dst[i] = 0;
711    }    }
712    
713            for(cpu = cpu_list; cpu->name!=0; ++cpu)
   for(cpu = cpu_short_list; cpu->name!=0; ++cpu)  
714    {    {
715      double t, overhead;      double t, overhead;
716      int tst, s, q;                  int tst, q;
717                    uint32_t s;
718    
719      if (!init_cpu(cpu))      if (!init_cpu(cpu))
720        continue;        continue;
721    
722      set_inter_matrix( get_default_inter_matrix() );                  // exhaustive tests to compare against the (ref) C-version
723      set_intra_matrix( get_default_intra_matrix() );                  TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
724                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
725                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
726                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
727    
728      overhead = -gettime_usec();      overhead = -gettime_usec();
729      for(tst=0; tst<nb_tests; ++tst)                  for(s=0,qm=1; qm<=255; ++qm) {
730        for(s=0, q=1; q<=max_Q; ++q)                          for(i=0; i<8*8; ++i) Quant[i] = qm;
731          for(i=0; i<64; ++i) s+=Dst[i]^i;                          set_inter_matrix(mpeg_quant_matrices, Quant );
732                            for(q=1; q<=max_Q; ++q)
733                                    for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
734                    }
735      overhead += gettime_usec();      overhead += gettime_usec();
736    
737      TEST_QUANT2(quant4_intra, Dst, Src, 7);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
738      printf( "%s -   quant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s -   quant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
739      if (s!=55827) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
740                               (s!=0xfd6a21a4)? "| ERROR": "");
741      TEST_QUANT(quant4_inter, Dst, Src);  
742      printf( "%s -   quant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
743      if (s!=58201) printf( "*** CRC ERROR! ***\n" );                  printf("%s -   quant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
744                               cpu->name, t, s,
745                               (s!=0xf6de7757)?"| ERROR": "");
746      TEST_QUANT2(dequant4_intra, Dst, Src, 7);  
747      printf( "%s - dequant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
748      if (s!=193340) printf( "*** CRC ERROR! ***\n" );                  printf("%s - dequant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
749                               cpu->name, t, s,
750      TEST_QUANT(dequant4_inter, Dst, Src);                             (s!=0x2def7bc7)?"| ERROR": "");
751      printf( "%s - dequant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );  
752      if (s!=116483) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
753                    printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
754      TEST_QUANT2(quant_intra, Dst, Src, 7);                             cpu->name, t, s,
755      printf( "%s -    quant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                             (s!=0xd878c722)?"| ERROR": "");
756      if (s!=56885) printf( "*** CRC ERROR! ***\n" );  
757                    TEST_QUANT2(quant_h263_intra, Dst, Src);
758      TEST_QUANT(quant_inter, Dst, Src);                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
759      printf( "%s -    quant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                             cpu->name, t, s,
760      if (s!=58056) printf( "*** CRC ERROR! ***\n" );                             (s!=0x2eba9d43)?"| ERROR": "");
761    
762      TEST_QUANT2(dequant_intra, Dst, Src, 7);                  TEST_QUANT(quant_h263_inter, Dst, Src);
763      printf( "%s -  dequant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s -   quant_h263_inter %.3f usec       crc32=0x%08x %s\n",
764      if (s!=-7936) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
765                               (s!=0xbd315a7e)?"| ERROR": "");
766      TEST_QUANT(dequant_inter, Dst, Src);  
767      printf( "%s -  dequant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
768  //    { int k,l; for(k=0; k<8; ++k) { for(l=0; l<8; ++l) printf( "[%.4d]", Dst[k*8+l]); printf("\n"); } }                  printf("%s - dequant_h263_intra %.3f usec       crc32=0x%08x %s\n",
769      if (s!=-33217) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
770                               (s!=0x9841212a)?"| ERROR": "");
771    
772                    TEST_QUANT(dequant_h263_inter, Dst, Src);
773                    printf("%s - dequant_h263_inter %.3f usec       crc32=0x%08x %s\n",
774                               cpu->name, t, s,
775                               (s!=0xe7df8fba)?"| ERROR": "");
776    
777                    printf( " --- \n" );
778            }
779    }
780    
781    /*********************************************************************
782     * test distortion operators
783     *********************************************************************/
784    
785    static void ieee_reseed(long s);
786    static long ieee_rand(int Min, int Max);
787    
788    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
789      do { \
790        t = gettime_usec(); \
791        tst = nb_tests; \
792        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
793        emms(); \
794        t = (gettime_usec() - t)/(double)nb_tests;  \
795      } while(0)
796    
797    
798    void test_sse()
799    {
800            const int nb_tests = 100000*speed_ref;
801            int i;
802            CPU *cpu;
803            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
804            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
805            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
806            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
807    
808            printf( "\n =====  test sse =====\n" );
809    
810            ieee_reseed(1);
811            for(i=0; i<64; ++i) {
812                    Src1[i] = ieee_rand(-2048, 2047);
813                    Src2[i] = ieee_rand(-2048, 2047);
814                    Src3[i] = ieee_rand(-2048, 2047);
815                    Src4[i] = ieee_rand(-2048, 2047);
816            }
817    
818            for(cpu = cpu_list; cpu->name!=0; ++cpu)
819            {
820                    double t;
821                    int tst, sse;
822    
823                    if (!init_cpu(cpu))
824                            continue;
825    
826                    /* 16 bit element blocks */
827                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
828                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
829                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
830                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
831                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
832                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
833                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
834                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
835                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
836                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
837                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
838                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
839                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
840                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
841                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
842                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
843                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
844                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
845    
846                    /* 8 bit element blocks */
847                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
848                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
849                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
850                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
851                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
852                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
853                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
854                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
855                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
856                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
857                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
858                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
859                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
860                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
861                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
862                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
863                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
864                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
865    
866      printf( " --- \n" );      printf( " --- \n" );
867    }    }
# Line 566  Line 885 
885    const int nb_tests = 10000*speed_ref;    const int nb_tests = 10000*speed_ref;
886    int i;    int i;
887    CPU *cpu;    CPU *cpu;
888    int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
889            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
890            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
891            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
892    
893    printf( "\n =====  test cbp =====\n" );    printf( "\n =====  test cbp =====\n" );
894    
895    for(i=0; i<6*64; ++i) {    for(i=0; i<6*64; ++i) {
896      Src1[i] = (i*i*3/8192)&(i/64)&1;  // 'random'                  Src1[i] = (i*i*3/8192)&(i/64)&1;  /* 'random' */
897      Src2[i] = (i<3*64);               // half-full                  Src2[i] = (i<3*64);               /* half-full */
898      Src3[i] = ((i+32)>3*64);      Src3[i] = ((i+32)>3*64);
899      Src4[i] = (i==(3*64+2) || i==(5*64+9));      Src4[i] = (i==(3*64+2) || i==(5*64+9));
900    }    }
901    
902    for(cpu = cpu_short_list2; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
903    {    {
904      double t;      double t;
905      int tst, cbp;      int tst, cbp;
# Line 586  Line 908 
908        continue;        continue;
909    
910      TEST_CBP(calc_cbp, Src1);      TEST_CBP(calc_cbp, Src1);
911      printf( "%s -   calc_cbp#1 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#1 %.3f usec       cbp=0x%02x %s\n",
912      if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
913      TEST_CBP(calc_cbp, Src2);      TEST_CBP(calc_cbp, Src2);
914      printf( "%s -   calc_cbp#2 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#2 %.3f usec       cbp=0x%02x %s\n",
915      if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
916      TEST_CBP(calc_cbp, Src3);      TEST_CBP(calc_cbp, Src3);
917      printf( "%s -   calc_cbp#3 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#3 %.3f usec       cbp=0x%02x %s\n",
918      if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
919      TEST_CBP(calc_cbp, Src4);      TEST_CBP(calc_cbp, Src4);
920      printf( "%s -   calc_cbp#4 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
921      if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
922      printf( " --- \n" );      printf( " --- \n" );
923    }    }
924  }  }
925    
926  /*********************************************************************  /*********************************************************************
927     * fdct/idct IEEE1180 compliance
928     *********************************************************************/
929    
930    typedef struct {
931            long Errors[64];
932            long Sqr_Errors[64];
933            long Max_Errors[64];
934            long Nb;
935    } STATS_8x8;
936    
937    void init_stats(STATS_8x8 *S)
938    {
939            int i;
940            for(i=0; i<64; ++i) {
941                    S->Errors[i]     = 0;
942                    S->Sqr_Errors[i] = 0;
943                    S->Max_Errors[i] = 0;
944            }
945            S->Nb = 0;
946    }
947    
948    void store_stats(STATS_8x8 *S, short Blk[64], short Ref[64])
949    {
950            int i;
951            for(i=0; i<64; ++i)
952            {
953                    short Err = Blk[i] - Ref[i];
954                    S->Errors[i] += Err;
955                    S->Sqr_Errors[i] += Err * Err;
956                    if (Err<0) Err = -Err;
957                    if (S->Max_Errors[i]<Err)
958                            S->Max_Errors[i] = Err;
959            }
960            S->Nb++;
961    }
962    
963    void print_stats(STATS_8x8 *S)
964    {
965            int i;
966            double Norm;
967    
968            assert(S->Nb>0);
969            Norm = 1. / (double)S->Nb;
970            printf("\n== Max absolute values of errors ==\n");
971            for(i=0; i<64; i++) {
972                    printf("  %4ld", S->Max_Errors[i]);
973                    if ((i&7)==7) printf("\n");
974            }
975    
976            printf("\n== Mean square errors ==\n");
977            for(i=0; i<64; i++)
978            {
979                    double Err = Norm * (double)S->Sqr_Errors[i];
980                    printf(" %.3f", Err);
981                    if ((i&7)==7) printf("\n");
982            }
983    
984            printf("\n== Mean errors ==\n");
985            for(i=0; i<64; i++)
986            {
987                    double Err = Norm * (double)S->Errors[i];
988                    printf(" %.3f", Err);
989                    if ((i&7)==7) printf("\n");
990            }
991            printf("\n");
992    }
993    
994    static const char *CHECK(double v, double l) {
995            if (fabs(v)<=l) return "ok";
996            else return "FAIL!";
997    }
998    
999    void report_stats(STATS_8x8 *S, const double *Limits)
1000    {
1001            int i;
1002            double Norm, PE, PMSE, OMSE, PME, OME;
1003    
1004            assert(S->Nb>0);
1005            Norm = 1. / (double)S->Nb;
1006            PE = 0.;
1007            for(i=0; i<64; i++) {
1008                    if (PE<S->Max_Errors[i])
1009                            PE = S->Max_Errors[i];
1010            }
1011    
1012            PMSE = 0.;
1013            OMSE = 0.;
1014            for(i=0; i<64; i++)
1015            {
1016                    double Err = Norm * (double)S->Sqr_Errors[i];
1017                    OMSE += Err;
1018                    if (PMSE < Err) PMSE = Err;
1019            }
1020            OMSE /= 64.;
1021    
1022            PME = 0.;
1023            OME = 0.;
1024            for(i=0; i<64; i++)
1025            {
1026                    double Err = Norm * (double)S->Errors[i];
1027                    OME += Err;
1028                    Err = fabs(Err);
1029                    if (PME < Err) PME = Err;
1030            }
1031            OME /= 64.;
1032    
1033            printf( "Peak error:   %4.4f\n", PE );
1034            printf( "Peak MSE:     %4.4f\n", PMSE );
1035            printf( "Overall MSE:  %4.4f\n", OMSE );
1036            printf( "Peak ME:      %4.4f\n", PME );
1037            printf( "Overall ME:   %4.4f\n", OME );
1038    
1039            if (Limits!=0)
1040            {
1041                    printf( "[PE<=%.4f %s]  ", Limits[0], CHECK(PE,   Limits[0]) );
1042                    printf( "\n" );
1043                    printf( "[PMSE<=%.4f %s]", Limits[1], CHECK(PMSE, Limits[1]) );
1044                    printf( "[OMSE<=%.4f %s]", Limits[2], CHECK(OMSE, Limits[2]) );
1045                    printf( "\n" );
1046                    printf( "[PME<=%.4f %s] ", Limits[3], CHECK(PME , Limits[3]) );
1047                    printf( "[OME<=%.4f %s] ", Limits[4], CHECK(OME , Limits[4]) );
1048                    printf( "\n" );
1049            }
1050    }
1051    
1052    ///* ////////////////////////////////////////////////////// */
1053    /* Pseudo-random generator specified by IEEE 1180 */
1054    
1055    static long ieee_seed = 1;
1056    static void ieee_reseed(long s) {
1057            ieee_seed = s;
1058    }
1059    static long ieee_rand(int Min, int Max)
1060    {
1061            static double z = (double) 0x7fffffff;
1062    
1063            long i,j;
1064            double x;
1065    
1066            ieee_seed = (ieee_seed * 1103515245) + 12345;
1067            i = ieee_seed & 0x7ffffffe;
1068            x = ((double) i) / z;
1069            x *= (Max-Min+1);
1070            j = (long)x;
1071            j = j + Min;
1072            assert(j>=Min && j<=Max);
1073            return (short)j;
1074    }
1075    
1076    #define CLAMP(x, M)   (x) = ((x)<-(M)) ? (-(M)) : ((x)>=(M) ? ((M)-1) : (x))
1077    
1078    static double Cos[8][8];
1079    static void init_ref_dct()
1080    {
1081            int i, j;
1082            for(i=0; i<8; i++)
1083            {
1084                    double scale = (i == 0) ? sqrt(0.125) : 0.5;
1085                    for (j=0; j<8; j++)
1086                            Cos[i][j] = scale*cos( (M_PI/8.0)*i*(j + 0.5) );
1087            }
1088    }
1089    
1090    void ref_idct(short *M)
1091    {
1092            int i, j, k;
1093            double Tmp[8][8];
1094    
1095            for(i=0; i<8; i++) {
1096                    for(j=0; j<8; j++)
1097                    {
1098                            double Sum = 0.0;
1099                            for (k=0; k<8; k++) Sum += Cos[k][j]*M[8*i+k];
1100                            Tmp[i][j] = Sum;
1101                    }
1102            }
1103            for(i=0; i<8; i++) {
1104                    for(j=0; j<8; j++) {
1105                            double Sum = 0.0;
1106                            for (k=0; k<8; k++) Sum += Cos[k][i]*Tmp[k][j];
1107                            M[8*i+j] = (short)floor(Sum + .5);
1108                    }
1109            }
1110    }
1111    
1112    void ref_fdct(short *M)
1113    {
1114            int i, j, k;
1115            double Tmp[8][8];
1116    
1117            for(i=0; i<8; i++) {
1118                    for(j=0; j<8; j++)
1119                    {
1120                            double Sum = 0.0;
1121                            for (k=0; k<8; k++) Sum += Cos[j][k]*M[8*i+k];
1122                            Tmp[i][j] = Sum;
1123                    }
1124            }
1125            for(i=0; i<8; i++) {
1126                    for(j=0; j<8; j++) {
1127                            double Sum = 0.0;
1128                            for (k=0; k<8; k++) Sum += Cos[i][k]*Tmp[k][j];
1129                            M[8*i+j] = (short)floor(Sum + 0.5);
1130                    }
1131            }
1132    }
1133    
1134    void test_IEEE1180_compliance(int Min, int Max, int Sign)
1135    {
1136            static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };
1137            int Loops = 10000;
1138            int i, m, n;
1139            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1140            DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1141            DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1142            DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
1143            DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
1144    
1145            STATS_8x8 FStats; /* forward dct stats */
1146            STATS_8x8 IStats; /* inverse dct stats */
1147    
1148            CPU *cpu;
1149    
1150            init_ref_dct();
1151    
1152            for(cpu = cpu_list; cpu->name!=0; ++cpu)
1153            {
1154                    if (!init_cpu(cpu))
1155                            continue;
1156    
1157                    printf( "\n===== IEEE test for %s ==== (Min=%d Max=%d Sign=%d Loops=%d)\n",
1158                                    cpu->name, Min, Max, Sign, Loops);
1159    
1160                    init_stats(&IStats);
1161                    init_stats(&FStats);
1162    
1163                    ieee_reseed(1);
1164                    for(n=0; n<Loops; ++n)
1165                    {
1166                            for(i=0; i<64; ++i)
1167                                    Blk0[i] = (short)ieee_rand(Min,Max) * Sign;
1168    
1169                            /* hmm, I'm not quite sure this is exactly */
1170                            /* the tests described in the norm. check... */
1171    
1172                            memcpy(Ref_FDCT, Blk0, 64*sizeof(short));
1173                            ref_fdct(Ref_FDCT);
1174                            for(i=0; i<64; i++) CLAMP( Ref_FDCT[i], 2048 );
1175    
1176                            memcpy(Blk, Blk0, 64*sizeof(short));
1177                            emms(); fdct(Blk); emms();
1178                            for(i=0; i<64; i++) CLAMP( Blk[i], 2048 );
1179    
1180                            store_stats(&FStats, Blk, Ref_FDCT);
1181    
1182    
1183                            memcpy(Ref_IDCT, Ref_FDCT, 64*sizeof(short));
1184                            ref_idct(Ref_IDCT);
1185                            for (i=0; i<64; i++) CLAMP( Ref_IDCT[i], 256 );
1186    
1187                            memcpy(iBlk, Ref_FDCT, 64*sizeof(short));
1188                            emms(); idct(iBlk); emms();
1189                            for(i=0; i<64; i++) CLAMP( iBlk[i], 256 );
1190    
1191                            store_stats(&IStats, iBlk, Ref_IDCT);
1192                    }
1193    
1194    
1195                    printf( "\n  -- FDCT report --\n" );
1196    //    print_stats(&FStats);
1197                    report_stats(&FStats, 0); /* so far I know, IEEE1180 says nothing for fdct */
1198    
1199                    for(i=0; i<64; i++) Blk[i] = 0;
1200                    emms(); fdct(Blk); emms();
1201                    for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
1202                    printf( "FDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1203    
1204                    printf( "\n  -- IDCT report --\n" );
1205    //    print_stats(&IStats);
1206                    report_stats(&IStats, ILimits);
1207    
1208    
1209                    for(i=0; i<64; i++) Blk[i] = 0;
1210                    emms(); idct(Blk); emms();
1211                    for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
1212                    printf( "IDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1213            }
1214    }
1215    
1216    
1217    void test_dct_saturation(int Min, int Max)
1218    {
1219    /* test behaviour on input range fringe */
1220    
1221            int i, n, p;
1222            CPU *cpu;
1223    //  const short IDCT_MAX =  2047;  /* 12bits input */
1224    //  const short IDCT_MIN = -2048;
1225    //  const short IDCT_OUT =   256;  /* 9bits ouput */
1226            const int Partitions = 4;
1227            const int Loops = 10000 / Partitions;
1228    
1229            init_ref_dct();
1230    
1231            for(cpu = cpu_list; cpu->name!=0; ++cpu)
1232            {
1233                    short Blk0[64], Blk[64];
1234                    STATS_8x8 Stats;
1235    
1236                    if (!init_cpu(cpu))
1237                            continue;
1238    
1239                    printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",
1240                                    cpu->name, Min, Max );
1241    
1242                    /* FDCT tests // */
1243    
1244                    init_stats(&Stats);
1245    
1246                    /* test each computation channels separately */
1247                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;
1248                    ref_fdct(Blk0);
1249                    emms(); fdct(Blk); emms();
1250                    store_stats(&Stats, Blk, Blk0);
1251    
1252                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Min : 0;
1253                    ref_fdct(Blk0);
1254                    emms(); fdct(Blk); emms();
1255                    store_stats(&Stats, Blk, Blk0);
1256    
1257                    /* randomly saturated inputs */
1258                    for(p=0; p<Partitions; ++p)
1259                    {
1260                            for(n=0; n<Loops; ++n)
1261                            {
1262                                    for(i=0; i<64; ++i)
1263                                            Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? Max : Min;
1264                                    ref_fdct(Blk0);
1265                                    emms(); fdct(Blk); emms();
1266                                    store_stats(&Stats, Blk, Blk0);
1267                            }
1268                    }
1269                    printf( "\n  -- FDCT saturation report --\n" );
1270                    report_stats(&Stats, 0);
1271    
1272    
1273                    /* IDCT tests // */
1274    #if 0
1275                    /* no finished yet */
1276    
1277                    init_stats(&Stats);
1278    
1279    /* test each computation channel separately */
1280                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 0;
1281                    ref_idct(Blk0);
1282                    emms(); idct(Blk); emms();
1283                    for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1284                    store_stats(&Stats, Blk, Blk0);
1285    
1286                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MIN : 0;
1287                    ref_idct(Blk0);
1288                    emms(); idct(Blk); emms();
1289                    for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1290                    store_stats(&Stats, Blk, Blk0);
1291    
1292                    /* randomly saturated inputs */
1293                    for(p=0; p<Partitions; ++p)
1294                    {
1295                            for(n=0; n<Loops; ++n)
1296                            {
1297                                    for(i=0; i<64; ++i)
1298                                            Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? IDCT_MAX : IDCT_MIN;
1299                                    ref_idct(Blk0);
1300                                    emms(); idct(Blk); emms();
1301                                    for(i=0; i<64; i++) { CLAMP(Blk0[i],IDCT_OUT); CLAMP(Blk[i],IDCT_OUT); }
1302                                    store_stats(&Stats, Blk, Blk0);
1303                            }
1304                    }
1305    
1306                    printf( "\n  -- IDCT saturation report --\n" );
1307                    print_stats(&Stats);
1308                    report_stats(&Stats, 0);
1309    #endif
1310            }
1311    }
1312    
1313    /*********************************************************************
1314   * measure raw decoding speed   * measure raw decoding speed
1315   *********************************************************************/   *********************************************************************/
1316    
1317  void test_dec(const char *name, int width, int height, int with_chksum)  void test_dec(const char *name, int width, int height, int ref_chksum)
1318  {  {
1319    FILE *f = 0;    FILE *f = 0;
1320    void *dechandle = 0;    void *dechandle = 0;
1321    int xerr;    int xerr;
1322          XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
1323          XVID_DEC_PARAM xparam;          xvid_dec_create_t xparam;
1324          XVID_DEC_FRAME xframe;          xvid_dec_frame_t xframe;
1325          double t = 0.;          double t = 0.;
1326          int nb = 0;          int nb = 0;
1327    uint8_t *buf = 0;    uint8_t *buf = 0;
1328    uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1329    int buf_size, pos;    int buf_size, pos;
1330    uint32_t chksum = 0;    uint32_t chksum = 0;
1331            int bps = (width+31) & ~31;
1332    
1333          xinit.cpu_flags = 0;          memset(&xinit, 0, sizeof(xinit));
1334          xvid_init(NULL, 0, &xinit, NULL);          xinit.cpu_flags = cpu_mask;
1335          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          xinit.version = XVID_VERSION;
1336            xvid_global(NULL, 0, &xinit, NULL);
1337    
1338            memset(&xparam, 0, sizeof(xparam));
1339          xparam.width = width;          xparam.width = width;
1340          xparam.height = height;          xparam.height = height;
1341            xparam.version = XVID_VERSION;
1342          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1343          if (xerr!=XVID_ERR_OK) {          if (xerr==XVID_ERR_FAIL) {
1344            printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1345            return;            return;
1346          }          }
1347          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 637  Line 1349 
1349    
1350          f = fopen(name, "rb");          f = fopen(name, "rb");
1351    if (f==0) {    if (f==0) {
1352      printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1353      return;      return;
1354    }    }
1355    fseek(f, 0, SEEK_END);    fseek(f, 0, SEEK_END);
1356    buf_size = ftell(f);    buf_size = ftell(f);
1357    fseek(f, 0, SEEK_SET);    fseek(f, 0, SEEK_SET);
1358    if (buf_size<=0) {    if (buf_size<=0) {
1359      printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1360      goto End;      goto End;
1361    }    }
   else printf( "Input size: %d\n", buf_size);  
1362    
1363    buf = malloc(buf_size); // should be enuf'          buf = malloc(buf_size);
1364    rgb_out = calloc(4, width*height);  // <-room for _RGB24          yuv_out = calloc(1, bps*height*3/2 + 15);
1365    if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1366      printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1367      goto End;      goto End;
1368    }    }
1369    
1370    if (fread(buf, buf_size, 1, f)!=1) {    if (fread(buf, buf_size, 1, f)!=1) {
1371      printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1372      goto End;      goto End;
1373    }    }
1374    
# Line 665  Line 1376 
1376    pos = 0;    pos = 0;
1377    t = -gettime_usec();    t = -gettime_usec();
1378    while(1) {    while(1) {
1379              int y;
1380    
1381                    memset(&xframe, 0, sizeof(xframe));
1382                    xframe.version = XVID_VERSION;
1383      xframe.bitstream = buf + pos;      xframe.bitstream = buf + pos;
1384      xframe.length = buf_size - pos;      xframe.length = buf_size - pos;
1385      xframe.image = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1386      xframe.stride = width;                  xframe.output.plane[1] = xframe.output.plane[0] + bps*height;
1387      xframe.colorspace = XVID_CSP_RGB24;                  xframe.output.plane[2] = xframe.output.plane[1] + bps/2;
1388                    xframe.output.stride[0] = bps;
1389                    xframe.output.stride[1] = bps;
1390                    xframe.output.stride[2] = bps;
1391                    xframe.output.csp = XVID_CSP_I420;
1392      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1393                    if (xerr<0) {
1394                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1395                            break;
1396                    }
1397                    else if (xerr==0)
1398                      break;
1399        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1400    
1401                    pos += xerr;
1402      nb++;      nb++;
1403      pos += xframe.length;  
1404      if (with_chksum) {      for(y=0; y<height/2; ++y) {
1405        int k = width*height;                    chksum = calc_crc(xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1406        uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc(xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1407        while(k-->0) chksum += *ptr++;                          chksum = calc_crc(xframe.output.plane[1] + y*bps, width/2, chksum);
1408                            chksum = calc_crc(xframe.output.plane[2] + y*bps, width/2, chksum);
1409      }      }
1410      if (pos==buf_size)      if (pos==buf_size)
1411        break;        break;
     if (xerr!=XVID_ERR_OK) {  
           printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
           break;  
         }  
1412    }    }
1413    t += gettime_usec();    t += gettime_usec();
1414            if (ref_chksum==0) {
1415    if (t>0.)    if (t>0.)
1416      printf( "%d frames decoded in %.3f s -> %.1f FPS\n", nb, t*1.e-6f, (float)(nb*1.e6f/t) );                    printf( "%d frames decoded in %.3f s -> %.1f FPS   Checksum:0x%.8x\n", nb, t*1.e-6f, (float)(nb*1.e6f/t), chksum );
1417    if (with_chksum)    }
1418      printf("checksum: 0x%.8x\n", chksum);    else {
1419                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1420                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1421      }
1422    
1423  End:  End:
1424    if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1425    if (buf!=0) free(buf);    if (buf!=0) free(buf);
1426    if (dechandle!=0) {    if (dechandle!=0) {
1427      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1428      if (xerr!=XVID_ERR_OK)                  if (xerr==XVID_ERR_FAIL)
1429              printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1430    }    }
1431    if (f!=0) fclose(f);    if (f!=0) fclose(f);
1432  }  }
# Line 709  Line 1438 
1438  void test_bugs1()  void test_bugs1()
1439  {  {
1440    CPU *cpu;    CPU *cpu;
1441            uint16_t mpeg_quant_matrices[64*8];
1442    
1443    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1444    
1445    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1446    {    {
1447      int i;      int i;
1448      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 721  Line 1451 
1451        continue;        continue;
1452    
1453      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1454      set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1455      dequant4_intra(Dst, Src, 32, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1456      printf( "dequant4_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1457      printf( "  Out[]= " );      printf( "  Out[]= " );
1458      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1459      printf( "\n" );      printf( "\n" );
# Line 731  Line 1461 
1461    
1462    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );
1463    
1464    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1465    {    {
1466      int i;      int i;
1467      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 740  Line 1470 
1470        continue;        continue;
1471    
1472      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1473      set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1474      dequant4_inter(Dst, Src, 32);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1475      printf( "dequant4_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1476      printf( "  Out[]= " );      printf( "  Out[]= " );
1477      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1478      printf( "\n" );      printf( "\n" );
# Line 752  Line 1482 
1482  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1483  {  {
1484    CPU *cpu;    CPU *cpu;
1485    short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1486            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1487    
1488    printf( "\n =====  fdct/idct saturation diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1489    
1490    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1491    {    {
1492      int i;      int i;
1493    
# Line 780  Line 1511 
1511    }    }
1512  }  }
1513    
1514    void test_quant_bug()
1515    {
1516            const int max_Q = 31;
1517            int i, n, qm, q;
1518            CPU *cpu;
1519            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1520            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1521            uint8_t Quant[8*8];
1522            CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1523            uint16_t Crcs_Inter[2][32];
1524            uint16_t Crcs_Intra[2][32];
1525            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1526    
1527            printf( "\n =====  test MPEG4-quantize bug =====\n" );
1528    
1529            for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;
1530    
1531    #if 1
1532            for(qm=1; qm<=255; ++qm)
1533            {
1534                    for(i=0; i<8*8; ++i) Quant[i] = qm;
1535                    set_inter_matrix( mpeg_quant_matrices, Quant );
1536    
1537                    for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1538                    {
1539                            uint16_t s;
1540    
1541                            if (!init_cpu(cpu))
1542                                    continue;
1543    
1544                            for(q=1; q<=max_Q; ++q) {
1545                                    emms();
1546                                    quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1547                                    emms();
1548                                    for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1549                                    Crcs_Inter[n][q] = s;
1550                            }
1551                    }
1552    
1553                    for(q=1; q<=max_Q; ++q)
1554                            for(i=0; i<n-1; ++i)
1555                                    if (Crcs_Inter[i][q]!=Crcs_Inter[i+1][q])
1556                                            printf( "Discrepancy Inter: qm=%d, q=%d  -> %d/%d !\n",
1557                                                            qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1558            }
1559    #endif
1560    
1561    #if 1
1562            for(qm=1; qm<=255; ++qm)
1563            {
1564                    for(i=0; i<8*8; ++i) Quant[i] = qm;
1565                    set_intra_matrix( mpeg_quant_matrices, Quant );
1566    
1567                    for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1568                    {
1569                            uint16_t s;
1570    
1571                            if (!init_cpu(cpu))
1572                                    continue;
1573    
1574                            for(q=1; q<=max_Q; ++q) {
1575                                    emms();
1576                                    quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1577                                    emms();
1578                                    for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1579                                    Crcs_Intra[n][q] = s;
1580                            }
1581                    }
1582    
1583                    for(q=1; q<=max_Q; ++q)
1584                            for(i=0; i<n-1; ++i)
1585                                    if (Crcs_Intra[i][q]!=Crcs_Intra[i+1][q])
1586                                            printf( "Discrepancy Intra: qm=%d, q=%d  -> %d/%d!\n",
1587                                                            qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1588            }
1589    #endif
1590    }
1591    /*********************************************************************/
1592    
1593    static uint32_t __inline log2bin_v1(uint32_t value)
1594    {
1595      int n = 0;
1596      while (value) {
1597        value >>= 1;
1598        n++;
1599      }
1600      return n;
1601    }
1602    
1603    static const uint8_t log2_tab_16[256] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1604    
1605    static uint32_t __inline log2bin_v2(uint32_t value)
1606    {
1607      int n = 0;
1608      if (value & 0xffff0000) {
1609        value >>= 16;
1610        n += 16;
1611      }
1612      if (value & 0xff00) {
1613        value >>= 8;
1614        n += 8;
1615      }
1616      if (value & 0xf0) {
1617        value >>= 4;
1618        n += 4;
1619      }
1620     return n + log2_tab_16[value];
1621    }
1622    
1623    void test_log2bin()
1624    {
1625            const int nb_tests = 3000*speed_ref;
1626      int n, crc1=0, crc2=0;
1627      uint32_t s, s0;
1628      double t1, t2;
1629    
1630      t1 = gettime_usec();
1631      s0 = (int)(t1*31.241);
1632      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1633        crc1 += log2bin_v1(s);
1634      t1 = (gettime_usec()-t1) / nb_tests;
1635    
1636      t2 = gettime_usec();
1637      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1638        crc2 += log2bin_v2(s);
1639      t2 = (gettime_usec() - t2) / nb_tests;
1640      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1641      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1642      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1643    }
1644    
1645  /*********************************************************************  /*********************************************************************
1646   * main   * main
1647   *********************************************************************/   *********************************************************************/
1648    
1649  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
1650    {
1651      printf( "missing argument after option '%s'\n", opt);
1652      exit(-1);
1653    }
1654    
1655    int main(int argc, const char *argv[])
1656  {  {
1657    int what = 0;          int c, what = 0;
1658    if (argc>1) what = atoi(argv[1]);          int width, height;
1659            uint32_t chksum = 0;
1660      const char * test_bitstream = 0;
1661    
1662            cpu_mask = 0;  // default => will use autodectect
1663            for(c=1; c<argc; ++c)
1664            {
1665              if (!strcmp(argv[c], "-v")) verbose++;
1666              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
1667              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
1668              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1669              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMX | XVID_CPU_FORCE;
1670              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
1671              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
1672              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
1673              else if (!strcmp(argv[c], "-spd")) {
1674          if (++c==argc) arg_missing( argv[argc-1] );
1675          speed_ref = atoi(argv[c]);
1676        }
1677              else if (argv[c][0]!='-') {
1678                what = atoi(argv[c]);
1679                if (what==9) {
1680                  if (c+4>argc) {
1681                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
1682                    exit(-1);
1683            }
1684            test_bitstream = argv[++c];
1685                  width  = atoi(argv[++c]);
1686                  height = atoi(argv[++c]);
1687                  if (c+1<argc && argv[c+1][0]!='-') {
1688                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
1689                      printf( "can't read checksum value.\n" );
1690                      exit(-1);
1691              }
1692              else c++;
1693            }
1694    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
1695          }
1696        }
1697        else {
1698          printf( "unrecognized option '%s'\n", argv[c]);
1699          exit(-1);
1700        }
1701      }
1702    
1703    
1704    if (what==0 || what==1) test_dct();    if (what==0 || what==1) test_dct();
1705    if (what==0 || what==2) test_mb();    if (what==0 || what==2) test_mb();
1706    if (what==0 || what==3) test_sad();    if (what==0 || what==3) test_sad();
1707    if (what==0 || what==4) test_transfer();    if (what==0 || what==4) test_transfer();
1708    if (what==0 || what==5) test_quant();    if (what==0 || what==5) test_quant();
1709    if (what==0 || what==6) test_cbp();    if (what==0 || what==6) test_cbp();
1710            if (what==0 || what==10) test_sse();
1711            if (what==0 || what==11) test_log2bin();
1712    
1713    if (what==8) {  
1714      int width, height;          if (what==7) {
1715      if (argc<5) {                  test_IEEE1180_compliance(-256, 255, 1);
1716        printf("usage: %s %d [bitstream] [width] [height]\n", argv[0], what);                  test_IEEE1180_compliance(-256, 255,-1);
1717        return 1;                  test_IEEE1180_compliance(  -5,   5, 1);
1718      }                  test_IEEE1180_compliance(  -5,   5,-1);
1719      width = atoi(argv[3]);                  test_IEEE1180_compliance(-300, 300, 1);
1720      height = atoi(argv[4]);                  test_IEEE1180_compliance(-300, 300,-1);
     test_dec(argv[2], width, height, (argc>5));  
1721    }    }
1722            if (what==8) test_dct_saturation(-256, 255);
1723    
1724            if (test_bitstream)
1725              test_dec(test_bitstream, width, height, chksum);
1726    if (what==-1) {    if (what==-1) {
     test_bugs1();  
1727      test_dct_precision_diffs();      test_dct_precision_diffs();
1728                    test_bugs1();
1729    }    }
1730            if (what==-2)
1731                    test_quant_bug();
1732    
1733            if ((what >= 0 && what <= 6) || what == 10) {
1734                    printf("\n\n"
1735                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1736                               "    a C function is used instead. So don't panic if some functions\n"
1737                               "    may appear to be slow.\n");
1738            }
1739    
1740    #ifdef ARCH_IS_IA32
1741            if (what == 0 || what == 5) {
1742                    printf("\n"
1743                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1744                               "    for 1 or 2 coefficients a block. This is mainly caused by the fact the unit\n"
1745                               "    test goes far behind the usual limits of real encoding. Please do not report\n"
1746                               "    this error to the developers.\n");
1747            }
1748    #endif
1749    
1750    return 0;    return 0;
1751  }  }
1752    
1753  /*********************************************************************  /*********************************************************************
1754   * 'Reference' output (except for timing) on a PIII 1.13Ghz/linux   * 'Reference' output (except for timing) on an Athlon XP 2200+
1755   *********************************************************************/   *********************************************************************/
1756  /*  
1757    /* as of 2002-01-07, there's a problem with MMX mpeg4-quantization */
1758    /* as of 2003-11-30, the problem is still here */
1759    
1760    /*********************************************************************
1761    
1762    
1763   ===== test fdct/idct =====   ===== test fdct/idct =====
1764  PLAINC -  2.631 usec       iCrc=3  fCrc=-85  PLAINC -  2.867 usec       PSNR=13.291  MSE=3.000
1765  MMX    -  0.596 usec       iCrc=3  fCrc=-67  MMX    -  -0.211 usec       PSNR=9.611  MSE=7.000
1766  MMXEXT -  0.608 usec       iCrc=3  fCrc=-67  MMXEXT -  -0.256 usec       PSNR=9.611  MSE=7.000
1767  SSE2   -  0.605 usec       iCrc=3  fCrc=-67  3DNOW  -  2.855 usec       PSNR=13.291  MSE=3.000
1768  3DNOW  - skipped...  3DNOWE -  1.429 usec       PSNR=13.291  MSE=3.000
 3DNOWE - skipped...  
1769    
1770   ===  test block motion ===   ===  test block motion ===
1771  PLAINC - interp- h-round0 1.031 usec       iCrc=8107  PLAINC - interp- h-round0 0.538 usec       crc32=0x115381ba
1772  PLAINC -           round1 1.022 usec       iCrc=8100  PLAINC -           round1 0.527 usec       crc32=0x2b1f528f
1773  PLAINC - interp- v-round0 1.002 usec       iCrc=8108  PLAINC - interp- v-round0 0.554 usec       crc32=0x423cdcc7
1774  PLAINC -           round1 1.011 usec       iCrc=8105  PLAINC -           round1 0.551 usec       crc32=0x42202efe
1775  PLAINC - interp-hv-round0 1.623 usec       iCrc=8112  PLAINC - interp-hv-round0 1.041 usec       crc32=0xd198d387
1776  PLAINC -           round1 1.621 usec       iCrc=8103  PLAINC -           round1 1.038 usec       crc32=0x9ecfd921
1777  PLAINC - interpolate8x8_c 0.229 usec       iCrc=8107   ---
1778   ---  MMX    - interp- h-round0 0.051 usec       crc32=0x115381ba
1779  MMX    - interp- h-round0 0.105 usec       iCrc=8107  MMX    -           round1 0.053 usec       crc32=0x2b1f528f
1780  MMX    -           round1 0.105 usec       iCrc=8100  MMX    - interp- v-round0 0.048 usec       crc32=0x423cdcc7
1781  MMX    - interp- v-round0 0.106 usec       iCrc=8108  MMX    -           round1 0.048 usec       crc32=0x42202efe
1782  MMX    -           round1 0.107 usec       iCrc=8105  MMX    - interp-hv-round0 0.074 usec       crc32=0xd198d387
1783  MMX    - interp-hv-round0 0.145 usec       iCrc=8112  MMX    -           round1 0.073 usec       crc32=0x9ecfd921
1784  MMX    -           round1 0.145 usec       iCrc=8103   ---
1785  MMX    - interpolate8x8_c 0.229 usec       iCrc=8107  MMXEXT - interp- h-round0 0.020 usec       crc32=0x115381ba
1786   ---  MMXEXT -           round1 0.025 usec       crc32=0x2b1f528f
1787  MMXEXT - interp- h-round0 0.027 usec       iCrc=8107  MMXEXT - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1788  MMXEXT -           round1 0.041 usec       iCrc=8100  MMXEXT -           round1 0.024 usec       crc32=0x42202efe
1789  MMXEXT - interp- v-round0 0.027 usec       iCrc=8108  MMXEXT - interp-hv-round0 0.037 usec       crc32=0xd198d387
1790  MMXEXT -           round1 0.040 usec       iCrc=8105  MMXEXT -           round1 0.037 usec       crc32=0x9ecfd921
1791  MMXEXT - interp-hv-round0 0.070 usec       iCrc=8112   ---
1792  MMXEXT -           round1 0.066 usec       iCrc=8103  3DNOW  - interp- h-round0 0.020 usec       crc32=0x115381ba
1793  MMXEXT - interpolate8x8_c 0.027 usec       iCrc=8107  3DNOW  -           round1 0.029 usec       crc32=0x2b1f528f
1794   ---  3DNOW  - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1795  SSE2   - interp- h-round0 0.106 usec       iCrc=8107  3DNOW  -           round1 0.024 usec       crc32=0x42202efe
1796  SSE2   -           round1 0.105 usec       iCrc=8100  3DNOW  - interp-hv-round0 0.038 usec       crc32=0xd198d387
1797  SSE2   - interp- v-round0 0.106 usec       iCrc=8108  3DNOW  -           round1 0.039 usec       crc32=0x9ecfd921
1798  SSE2   -           round1 0.106 usec       iCrc=8105   ---
1799  SSE2   - interp-hv-round0 0.145 usec       iCrc=8112  3DNOWE - interp- h-round0 0.020 usec       crc32=0x115381ba
1800  SSE2   -           round1 0.145 usec       iCrc=8103  3DNOWE -           round1 0.024 usec       crc32=0x2b1f528f
1801  SSE2   - interpolate8x8_c 0.237 usec       iCrc=8107  3DNOWE - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1802    3DNOWE -           round1 0.021 usec       crc32=0x42202efe
1803    3DNOWE - interp-hv-round0 0.037 usec       crc32=0xd198d387
1804    3DNOWE -           round1 0.036 usec       crc32=0x9ecfd921
1805   ---   ---
 3DNOW  - skipped...  
 3DNOWE - skipped...  
1806    
1807   ======  test SAD ======   ======  test SAD ======
1808  PLAINC - sad8    0.296 usec       sad=3776  PLAINC - sad8    0.505 usec       sad=3776
1809  PLAINC - sad16   1.599 usec       sad=27214  PLAINC - sad16   1.941 usec       sad=27214
1810  PLAINC - sad16bi 2.350 usec       sad=26274  PLAINC - sad16bi 4.925 usec       sad=26274
1811  PLAINC - dev16   1.610 usec       sad=3344  PLAINC - dev16   4.254 usec       sad=3344
1812   ---   ---
1813  MMX    - sad8    0.057 usec       sad=3776  MMX    - sad8    0.036 usec       sad=3776
1814  MMX    - sad16   0.178 usec       sad=27214  MMX    - sad16   0.107 usec       sad=27214
1815  MMX    - sad16bi 2.381 usec       sad=26274  MMX    - sad16bi 0.259 usec       sad=26274
1816  MMX    - dev16   0.312 usec       sad=3344  MMX    - dev16   0.187 usec       sad=3344
1817   ---   ---
1818  MMXEXT - sad8    0.036 usec       sad=3776  MMXEXT - sad8    0.016 usec       sad=3776
1819  MMXEXT - sad16   0.106 usec       sad=27214  MMXEXT - sad16   0.050 usec       sad=27214
1820  MMXEXT - sad16bi 0.182 usec       sad=26274  MMXEXT - sad16bi 0.060 usec       sad=26274
1821  MMXEXT - dev16   0.193 usec       sad=3344  MMXEXT - dev16   0.086 usec       sad=3344
1822   ---   ---
1823  SSE2   - sad8    0.057 usec       sad=3776  3DNOW  - sad8    0.506 usec       sad=3776
1824  SSE2   - sad16   0.178 usec       sad=27214  3DNOW  - sad16   1.954 usec       sad=27214
1825  SSE2   - sad16bi 2.427 usec       sad=26274  3DNOW  - sad16bi 0.119 usec       sad=26274
1826  SSE2   - dev16   0.313 usec       sad=3344  3DNOW  - dev16   4.252 usec       sad=3344
1827     ---
1828    3DNOWE - sad8    0.017 usec       sad=3776
1829    3DNOWE - sad16   0.038 usec       sad=27214
1830    3DNOWE - sad16bi 0.052 usec       sad=26274
1831    3DNOWE - dev16   0.067 usec       sad=3344
1832   ---   ---
 3DNOW  - skipped...  
 3DNOWE - skipped...  
1833    
1834   ===  test transfer ===   ===  test transfer ===
1835  PLAINC - 8to16     0.124 usec       crc=28288  PLAINC - 8to16     0.603 usec       crc32=0x115814bb
1836  PLAINC - 16to8     0.753 usec       crc=28288  PLAINC - 16to8     1.077 usec       crc32=0xee7ccbb4
1837  PLAINC - 8to8      0.041 usec       crc=20352  PLAINC - 8to8      0.679 usec       crc32=0xd37b3295
1838  PLAINC - 16to8add  0.916 usec       crc=25536  PLAINC - 16to8add  1.341 usec       crc32=0xdd817bf4
1839  PLAINC - 8to16sub  0.812 usec       crc1=28064 crc2=16256  PLAINC - 8to16sub  1.566 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1840  PLAINC - 8to16sub2 0.954 usec       crc=20384  PLAINC - 8to16sub2 2.206 usec       crc32=0x99b6c4c7
1841   ---   ---
1842  MMX    - 8to16     0.037 usec       crc=28288  MMX    - 8to16     -0.025 usec       crc32=0x115814bb
1843  MMX    - 16to8     0.016 usec       crc=28288  MMX    - 16to8     -0.049 usec       crc32=0xee7ccbb4
1844  MMX    - 8to8      0.018 usec       crc=20352  MMX    - 8to8      0.014 usec       crc32=0xd37b3295
1845  MMX    - 16to8add  0.044 usec       crc=25536  MMX    - 16to8add  0.011 usec       crc32=0xdd817bf4
1846  MMX    - 8to16sub  0.065 usec       crc1=28064 crc2=16256  MMX    - 8to16sub  0.108 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1847  MMX    - 8to16sub2 0.110 usec       crc=20384  MMX    - 8to16sub2 0.164 usec       crc32=0x99b6c4c7
1848   ---   ---
1849  MMXEXT - 8to16     0.032 usec       crc=28288  MMXEXT - 8to16     -0.054 usec       crc32=0x115814bb
1850  MMXEXT - 16to8     0.023 usec       crc=28288  MMXEXT - 16to8     0.010 usec       crc32=0xee7ccbb4
1851  MMXEXT - 8to8      0.018 usec       crc=20352  MMXEXT - 8to8      0.015 usec       crc32=0xd37b3295
1852  MMXEXT - 16to8add  0.041 usec       crc=25536  MMXEXT - 16to8add  0.008 usec       crc32=0xdd817bf4
1853  MMXEXT - 8to16sub  0.065 usec       crc1=28064 crc2=16256  MMXEXT - 8to16sub  0.263 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1854  MMXEXT - 8to16sub2 0.069 usec       crc=20384  MMXEXT - 8to16sub2 0.178 usec       crc32=0x99b6c4c7
1855     ---
1856    3DNOW  - 8to16     0.666 usec       crc32=0x115814bb
1857    3DNOW  - 16to8     1.078 usec       crc32=0xee7ccbb4
1858    3DNOW  - 8to8      0.665 usec       crc32=0xd37b3295
1859    3DNOW  - 16to8add  1.365 usec       crc32=0xdd817bf4
1860    3DNOW  - 8to16sub  1.356 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1861    3DNOW  - 8to16sub2 2.098 usec       crc32=0x99b6c4c7
1862     ---
1863    3DNOWE - 8to16     -0.024 usec       crc32=0x115814bb
1864    3DNOWE - 16to8     0.010 usec       crc32=0xee7ccbb4
1865    3DNOWE - 8to8      0.014 usec       crc32=0xd37b3295
1866    3DNOWE - 16to8add  0.016 usec       crc32=0xdd817bf4
1867    3DNOWE - 8to16sub  -0.000 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1868    3DNOWE - 8to16sub2 -0.031 usec       crc32=0x99b6c4c7
1869   ---   ---
1870    
1871   =====  test quant =====   =====  test quant =====
1872  PLAINC -   quant4_intra 78.889 usec       crc=55827  PLAINC -   quant_mpeg_intra 98.631 usec       crc32=0xfd6a21a4
1873  PLAINC -   quant4_inter 71.957 usec       crc=58201  PLAINC -   quant_mpeg_inter 104.876 usec       crc32=0xf6de7757
1874  PLAINC - dequant4_intra 34.968 usec       crc=193340  PLAINC - dequant_mpeg_intra 50.285 usec       crc32=0x2def7bc7
1875  PLAINC - dequant4_inter 40.792 usec       crc=116483  PLAINC - dequant_mpeg_inter 58.316 usec       crc32=0xd878c722
1876  PLAINC -    quant_intra 30.845 usec       crc=56885  PLAINC -   quant_h263_intra 33.803 usec       crc32=0x2eba9d43
1877  PLAINC -    quant_inter 34.842 usec       crc=58056  PLAINC -   quant_h263_inter 45.411 usec       crc32=0xbd315a7e
1878  PLAINC -  dequant_intra 33.211 usec       crc=-7936  PLAINC - dequant_h263_intra 39.302 usec       crc32=0x9841212a
1879  PLAINC -  dequant_inter 45.486 usec       crc=-33217  PLAINC - dequant_h263_inter 44.124 usec       crc32=0xe7df8fba
1880   ---   ---
1881  MMX    -   quant4_intra 9.030 usec       crc=55827  MMX    -   quant_mpeg_intra 4.273 usec       crc32=0xdacabdb6 | ERROR
1882  MMX    -   quant4_inter 8.234 usec       crc=58201  MMX    -   quant_mpeg_inter 3.576 usec       crc32=0x72883ab6 | ERROR
1883  MMX    - dequant4_intra 18.330 usec       crc=193340  MMX    - dequant_mpeg_intra 3.793 usec       crc32=0x2def7bc7
1884  MMX    - dequant4_inter 19.181 usec       crc=116483  MMX    - dequant_mpeg_inter 4.808 usec       crc32=0xd878c722
1885  MMX    -    quant_intra 7.124 usec       crc=56885  MMX    -   quant_h263_intra 2.881 usec       crc32=0x2eba9d43
1886  MMX    -    quant_inter 6.861 usec       crc=58056  MMX    -   quant_h263_inter 2.550 usec       crc32=0xbd315a7e
1887  MMX    -  dequant_intra 9.048 usec       crc=-7936  MMX    - dequant_h263_intra 2.974 usec       crc32=0x9841212a
1888  MMX    -  dequant_inter 8.203 usec       crc=-33217  MMX    - dequant_h263_inter 2.906 usec       crc32=0xe7df8fba
1889   ---   ---
1890  MMXEXT -   quant4_intra 9.045 usec       crc=55827  MMXEXT -   quant_mpeg_intra 4.221 usec       crc32=0xfd6a21a4
1891  MMXEXT -   quant4_inter 8.232 usec       crc=58201  MMXEXT -   quant_mpeg_inter 4.339 usec       crc32=0xf6de7757
1892  MMXEXT - dequant4_intra 18.250 usec       crc=193340  MMXEXT - dequant_mpeg_intra 3.802 usec       crc32=0x2def7bc7
1893  MMXEXT - dequant4_inter 19.256 usec       crc=116483  MMXEXT - dequant_mpeg_inter 4.821 usec       crc32=0xd878c722
1894  MMXEXT -    quant_intra 7.121 usec       crc=56885  MMXEXT -   quant_h263_intra 2.884 usec       crc32=0x2eba9d43
1895  MMXEXT -    quant_inter 6.855 usec       crc=58056  MMXEXT -   quant_h263_inter 2.554 usec       crc32=0xbd315a7e
1896  MMXEXT -  dequant_intra 9.034 usec       crc=-7936  MMXEXT - dequant_h263_intra 2.728 usec       crc32=0x9841212a
1897  MMXEXT -  dequant_inter 8.202 usec       crc=-33217  MMXEXT - dequant_h263_inter 2.611 usec       crc32=0xe7df8fba
1898     ---
1899    3DNOW  -   quant_mpeg_intra 98.512 usec       crc32=0xfd6a21a4
1900    3DNOW  -   quant_mpeg_inter 104.873 usec       crc32=0xf6de7757
1901    3DNOW  - dequant_mpeg_intra 50.219 usec       crc32=0x2def7bc7
1902    3DNOW  - dequant_mpeg_inter 58.254 usec       crc32=0xd878c722
1903    3DNOW  -   quant_h263_intra 33.778 usec       crc32=0x2eba9d43
1904    3DNOW  -   quant_h263_inter 41.998 usec       crc32=0xbd315a7e
1905    3DNOW  - dequant_h263_intra 39.344 usec       crc32=0x9841212a
1906    3DNOW  - dequant_h263_inter 43.607 usec       crc32=0xe7df8fba
1907     ---
1908    3DNOWE -   quant_mpeg_intra 98.490 usec       crc32=0xfd6a21a4
1909    3DNOWE -   quant_mpeg_inter 104.889 usec       crc32=0xf6de7757
1910    3DNOWE - dequant_mpeg_intra 3.277 usec       crc32=0x2def7bc7
1911    3DNOWE - dequant_mpeg_inter 4.485 usec       crc32=0xd878c722
1912    3DNOWE -   quant_h263_intra 1.882 usec       crc32=0x2eba9d43
1913    3DNOWE -   quant_h263_inter 2.246 usec       crc32=0xbd315a7e
1914    3DNOWE - dequant_h263_intra 3.457 usec       crc32=0x9841212a
1915    3DNOWE - dequant_h263_inter 3.275 usec       crc32=0xe7df8fba
1916   ---   ---
1917    
1918   =====  test cbp =====   =====  test cbp =====
1919  PLAINC -   calc_cbp#1 0.545 usec       cbp=0x15  PLAINC -   calc_cbp#1 0.168 usec       cbp=0x15
1920  PLAINC -   calc_cbp#2 0.540 usec       cbp=0x38  PLAINC -   calc_cbp#2 0.168 usec       cbp=0x38
1921  PLAINC -   calc_cbp#3 0.477 usec       cbp=0xf  PLAINC -   calc_cbp#3 0.157 usec       cbp=0x0f
1922  PLAINC -   calc_cbp#4 0.739 usec       cbp=0x5  PLAINC -   calc_cbp#4 0.235 usec       cbp=0x05
1923   ---   ---
1924  MMX    -   calc_cbp#1 0.136 usec       cbp=0x15  MMX    -   calc_cbp#1 0.070 usec       cbp=0x15
1925  MMX    -   calc_cbp#2 0.131 usec       cbp=0x38  MMX    -   calc_cbp#2 0.062 usec       cbp=0x38
1926  MMX    -   calc_cbp#3 0.132 usec       cbp=0xf  MMX    -   calc_cbp#3 0.062 usec       cbp=0x0f
1927  MMX    -   calc_cbp#4 0.135 usec       cbp=0x5  MMX    -   calc_cbp#4 0.061 usec       cbp=0x05
1928   ---   ---
1929  SSE2   -   calc_cbp#1 0.135 usec       cbp=0x15  MMXEXT -   calc_cbp#1 0.062 usec       cbp=0x15
1930  SSE2   -   calc_cbp#2 0.131 usec       cbp=0x38  MMXEXT -   calc_cbp#2 0.061 usec       cbp=0x38
1931  SSE2   -   calc_cbp#3 0.134 usec       cbp=0xf  MMXEXT -   calc_cbp#3 0.061 usec       cbp=0x0f
1932  SSE2   -   calc_cbp#4 0.136 usec       cbp=0x5  MMXEXT -   calc_cbp#4 0.061 usec       cbp=0x05
1933     ---
1934    3DNOW  -   calc_cbp#1 0.168 usec       cbp=0x15
1935    3DNOW  -   calc_cbp#2 0.168 usec       cbp=0x38
1936    3DNOW  -   calc_cbp#3 0.157 usec       cbp=0x0f
1937    3DNOW  -   calc_cbp#4 0.238 usec       cbp=0x05
1938   ---   ---
1939  */  3DNOWE -   calc_cbp#1 0.049 usec       cbp=0x15
1940    3DNOWE -   calc_cbp#2 0.049 usec       cbp=0x38
1941    3DNOWE -   calc_cbp#3 0.049 usec       cbp=0x0f
1942    3DNOWE -   calc_cbp#4 0.049 usec       cbp=0x05
1943     ---
1944    
1945    
1946    NB: If a function isn't optimised for a specific set of intructions,
1947        a C function is used instead. So don't panic if some functions
1948        may appear to be slow.
1949    
1950    NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)
1951        for 1 or 2 coefficients a block. This is mainly caused by the fact the unit
1952        test goes far behind the usual limits of real encoding. Please do not report
1953        this error to the developers
1954    
1955    *********************************************************************/
Legend:
Removed from v.225  
changed lines
  Added in v.1616
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4