[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 1620, Tue Jun 14 13:58:21 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.21 2005-06-14 13:58:21 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), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
531    
532  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
533      TEST_TRANSFER_BEGIN(DST);                 \      TEST_TRANSFER_BEGIN(DST);                 \
# Line 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), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
557    
558  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
559      TEST_TRANSFER2_BEGIN(DST,SRC);            \      TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 408  Line 570 
570    const int nb_tests = 4000*speed_ref;    const int nb_tests = 4000*speed_ref;
571    int i;    int i;
572    CPU *cpu;    CPU *cpu;
573    uint8_t  Src8[8*32], Dst8[8*32], Ref1[8*32], Ref2[8*32];  //      uint8_t  Src8[8*32], Dst8[8*32], Ref1[8*32], Ref2[8*32];
574    int16_t Src16[8*32], Dst16[8*32];  //      int16_t Src16[8*32], Dst16[8*32];
575      DECLARE_ALIGNED_MATRIX(Src8, 8, 32, uint8_t, CACHE_LINE);
576      DECLARE_ALIGNED_MATRIX(Dst8, 8, 32, uint8_t, CACHE_LINE);
577      DECLARE_ALIGNED_MATRIX(Ref1, 8, 32, uint8_t, CACHE_LINE);
578      DECLARE_ALIGNED_MATRIX(Ref2, 8, 32, uint8_t, CACHE_LINE);
579      DECLARE_ALIGNED_MATRIX(Src16, 8, 32, uint16_t, CACHE_LINE);
580      DECLARE_ALIGNED_MATRIX(Dst16, 8, 32, uint16_t, CACHE_LINE);
581    
582    printf( "\n ===  test transfer ===\n" );    printf( "\n ===  test transfer ===\n" );
583    
584    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
585    {    {
586      double t, overhead;      double t, overhead;
587      int tst, s;      int tst, s;
# Line 422  Line 590 
590        continue;        continue;
591    
592      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
593      printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
594      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
595                               (s!=0x115814bb)?"| ERROR": "");
596    
597      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
598      printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
599      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
600                                    (s!=0xee7ccbb4)?"| ERROR": "");
601    
602      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
603      printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
604      if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
605                               (s!=0xd37b3295)?"| ERROR": "");
606    
607      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
608      printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
609      if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
610                               (s!=0xdd817bf4)?"| ERROR": "" );
611    
612      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
613      printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
614      if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
615      s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }                          s1 = calc_crc((uint8_t*)Dst16, 8*32*sizeof(Dst16[0]), CRC32_INITIAL);
616      printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, 8*32*sizeof(Src8[0]), CRC32_INITIAL);
617      if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
618                                       cpu->name, t, s1, s2,
619                                       (s1!=0xa1e07163)?"| ERROR1": "",
620                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
621                    }
622    
623      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
624      printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
625      if (s!=20384) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
626                               (s!=0x99b6c4c7)?"| ERROR": "" );
627    
628      printf( " --- \n" );      printf( " --- \n" );
629    }    }
# Line 458  Line 635 
635    
636  #define TEST_QUANT(FUNC, DST, SRC)            \  #define TEST_QUANT(FUNC, DST, SRC)            \
637      t = gettime_usec();                       \      t = gettime_usec();                       \
638    for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
639      for(i=0; i<8*8; ++i) Quant[i] = qm;       \
640      set_inter_matrix( mpeg_quant_matrices, Quant );                \
641      emms();                                   \      emms();                                   \
642      for(q=1; q<=max_Q; ++q) {                 \
643      for(tst=0; tst<nb_tests; ++tst)           \      for(tst=0; tst<nb_tests; ++tst)           \
644        for(s=0, q=1; q<=max_Q; ++q) {          \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
645          (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;    \  
646        }                                       \        }                                       \
647      emms();                                   \      emms();                                   \
648      t = (gettime_usec()-t-overhead)/nb_tests;  }                                           \
649    t = (gettime_usec()-t-overhead)/nb_tests/qm
650    
651  #define TEST_QUANT2(FUNC, DST, SRC, MULT)     \  #define TEST_QUANT2(FUNC, DST, SRC)             \
652      t = gettime_usec();                       \      t = gettime_usec();                       \
653    for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
654      for(i=0; i<8*8; ++i) Quant[i] = qm;       \
655      set_intra_matrix( mpeg_quant_matrices, Quant );                \
656      emms();                                   \      emms();                                   \
657      for(q=1; q<=max_Q; ++q) {                 \
658      for(tst=0; tst<nb_tests; ++tst)           \      for(tst=0; tst<nb_tests; ++tst)           \
659        for(s=0, q=1; q<=max_Q; ++q) {          \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
660          (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;    \  
661        }                                       \        }                                       \
662      emms();                                   \      emms();                                   \
663      t = (gettime_usec()-t-overhead)/nb_tests;  }                                           \
664    t = (gettime_usec()-t-overhead)/nb_tests/qm
665    
666    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
667    { int i,q,s;\
668            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
669      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
670      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
671      for(q=1;q<=max_Q;q++)          \
672        for(s=-RANGE;s<RANGE;s++) { \
673          for(i=0;i<64;i++) Src[i]=s; \
674          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
675          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
676          for(i=0;i<64;i++)     \
677            if(Dst[i]!=Dst2[i]) printf("ERROR : " #NEWFUNC " i%d quant:%d input:%d C_result:%d ASM_result:%d\n",i,q,s,Dst[i],Dst2[i]);  \
678        }      \
679    }
680    
681    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
682    { int i,q,s;  \
683            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
684      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
685      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
686      for(q=1;q<=max_Q;q++)  \
687        for(s=-RANGE;s<RANGE;s++) {   \
688          for(i=0;i<64;i++) Src[i]=s; \
689          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
690          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
691          emms();           \
692          for(i=0;i<64;i++) \
693            if(Dst[i]!=Dst2[i]) printf("ERROR : " #NEWFUNC " i%d quant:%d input:%d C_result:%d ASM_result:%d\n",i,q,s,Dst[i],Dst2[i]); \
694        } \
695    }
696    
697  void test_quant()  void test_quant()
698  {  {
699    const int nb_tests = 150*speed_ref;          const int nb_tests = 1*speed_ref;
700    const int max_Q = 31;    const int max_Q = 31;
701    int i;          DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
702    
703            int i, qm;
704    CPU *cpu;    CPU *cpu;
705    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
706            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
707            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
708            uint8_t Quant[8*8];
709    
710    printf( "\n =====  test quant =====\n" );    printf( "\n =====  test quant =====\n" );
711    
712    /* we deliberately enfringe the norm's specified range [-127,127], */
713    /* to test the robustness of the iquant module */
714    for(i=0; i<64; ++i) {    for(i=0; i<64; ++i) {
715      Src[i] = i-32;                  Src[i] = 1 + (i-32) * (i&6);
716      Dst[i] = 0;      Dst[i] = 0;
717    }    }
718    
719            for(cpu = cpu_list; cpu->name!=0; ++cpu)
   for(cpu = cpu_short_list; cpu->name!=0; ++cpu)  
720    {    {
721      double t, overhead;      double t, overhead;
722      int tst, s, q;                  int tst, q;
723                    uint32_t s;
724    
725      if (!init_cpu(cpu))      if (!init_cpu(cpu))
726        continue;        continue;
727    
728      set_inter_matrix( get_default_inter_matrix() );                  // exhaustive tests to compare against the (ref) C-version
729      set_intra_matrix( get_default_intra_matrix() );                  TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
730                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
731                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
732                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
733    
734      overhead = -gettime_usec();      overhead = -gettime_usec();
735      for(tst=0; tst<nb_tests; ++tst)                  for(s=0,qm=1; qm<=255; ++qm) {
736        for(s=0, q=1; q<=max_Q; ++q)                          for(i=0; i<8*8; ++i) Quant[i] = qm;
737          for(i=0; i<64; ++i) s+=Dst[i]^i;                          set_inter_matrix(mpeg_quant_matrices, Quant );
738                            for(q=1; q<=max_Q; ++q)
739                                    for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
740                    }
741      overhead += gettime_usec();      overhead += gettime_usec();
742    
743      TEST_QUANT2(quant4_intra, Dst, Src, 7);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
744      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",
745      if (s!=55827) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
746                               (s!=0xfd6a21a4)? "| ERROR": "");
747      TEST_QUANT(quant4_inter, Dst, Src);  
748      printf( "%s -   quant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
749      if (s!=58201) printf( "*** CRC ERROR! ***\n" );                  printf("%s -   quant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
750                               cpu->name, t, s,
751                               (s!=0xf6de7757)?"| ERROR": "");
752      TEST_QUANT2(dequant4_intra, Dst, Src, 7);  
753      printf( "%s - dequant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
754      if (s!=193340) printf( "*** CRC ERROR! ***\n" );                  printf("%s - dequant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
755                               cpu->name, t, s,
756      TEST_QUANT(dequant4_inter, Dst, Src);                             (s!=0x2def7bc7)?"| ERROR": "");
757      printf( "%s - dequant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );  
758      if (s!=116483) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
759                    printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
760      TEST_QUANT2(quant_intra, Dst, Src, 7);                             cpu->name, t, s,
761      printf( "%s -    quant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                             (s!=0xd878c722)?"| ERROR": "");
762      if (s!=56885) printf( "*** CRC ERROR! ***\n" );  
763                    TEST_QUANT2(quant_h263_intra, Dst, Src);
764      TEST_QUANT(quant_inter, Dst, Src);                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
765      printf( "%s -    quant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                             cpu->name, t, s,
766      if (s!=58056) printf( "*** CRC ERROR! ***\n" );                             (s!=0x2eba9d43)?"| ERROR": "");
767    
768      TEST_QUANT2(dequant_intra, Dst, Src, 7);                  TEST_QUANT(quant_h263_inter, Dst, Src);
769      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",
770      if (s!=-7936) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
771                               (s!=0xbd315a7e)?"| ERROR": "");
772      TEST_QUANT(dequant_inter, Dst, Src);  
773      printf( "%s -  dequant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
774  //    { 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",
775      if (s!=-33217) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
776                               (s!=0x9841212a)?"| ERROR": "");
777    
778                    TEST_QUANT(dequant_h263_inter, Dst, Src);
779                    printf("%s - dequant_h263_inter %.3f usec       crc32=0x%08x %s\n",
780                               cpu->name, t, s,
781                               (s!=0xe7df8fba)?"| ERROR": "");
782    
783                    printf( " --- \n" );
784            }
785    }
786    
787    /*********************************************************************
788     * test distortion operators
789     *********************************************************************/
790    
791    static void ieee_reseed(long s);
792    static long ieee_rand(int Min, int Max);
793    
794    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
795      do { \
796        t = gettime_usec(); \
797        tst = nb_tests; \
798        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
799        emms(); \
800        t = (gettime_usec() - t)/(double)nb_tests;  \
801      } while(0)
802    
803    
804    void test_sse()
805    {
806            const int nb_tests = 100000*speed_ref;
807            int i;
808            CPU *cpu;
809            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
810            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
811            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
812            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
813    
814            printf( "\n =====  test sse =====\n" );
815    
816            ieee_reseed(1);
817            for(i=0; i<64; ++i) {
818                    Src1[i] = ieee_rand(-2048, 2047);
819                    Src2[i] = ieee_rand(-2048, 2047);
820                    Src3[i] = ieee_rand(-2048, 2047);
821                    Src4[i] = ieee_rand(-2048, 2047);
822            }
823    
824            for(cpu = cpu_list; cpu->name!=0; ++cpu)
825            {
826                    double t;
827                    int tst, sse;
828    
829                    if (!init_cpu(cpu))
830                            continue;
831    
832                    /* 16 bit element blocks */
833                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
834                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
835                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
836                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
837                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
838                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
839                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
840                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
841                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
842                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
843                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
844                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
845                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
846                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
847                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
848                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
849                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
850                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
851    
852                    /* 8 bit element blocks */
853                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
854                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
855                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
856                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
857                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
858                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
859                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
860                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
861                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
862                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
863                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
864                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
865                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
866                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
867                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
868                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
869                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
870                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
871    
872      printf( " --- \n" );      printf( " --- \n" );
873    }    }
# Line 566  Line 891 
891    const int nb_tests = 10000*speed_ref;    const int nb_tests = 10000*speed_ref;
892    int i;    int i;
893    CPU *cpu;    CPU *cpu;
894    int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
895            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
896            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
897            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
898    
899    printf( "\n =====  test cbp =====\n" );    printf( "\n =====  test cbp =====\n" );
900    
901    for(i=0; i<6*64; ++i) {    for(i=0; i<6*64; ++i) {
902      Src1[i] = (i*i*3/8192)&(i/64)&1;  // 'random'                  Src1[i] = (i*i*3/8192)&(i/64)&1;  /* 'random' */
903      Src2[i] = (i<3*64);               // half-full                  Src2[i] = (i<3*64);               /* half-full */
904      Src3[i] = ((i+32)>3*64);      Src3[i] = ((i+32)>3*64);
905      Src4[i] = (i==(3*64+2) || i==(5*64+9));      Src4[i] = (i==(3*64+2) || i==(5*64+9));
906    }    }
907    
908    for(cpu = cpu_short_list2; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
909    {    {
910      double t;      double t;
911      int tst, cbp;      int tst, cbp;
# Line 586  Line 914 
914        continue;        continue;
915    
916      TEST_CBP(calc_cbp, Src1);      TEST_CBP(calc_cbp, Src1);
917      printf( "%s -   calc_cbp#1 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#1 %.3f usec       cbp=0x%02x %s\n",
918      if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
919      TEST_CBP(calc_cbp, Src2);      TEST_CBP(calc_cbp, Src2);
920      printf( "%s -   calc_cbp#2 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#2 %.3f usec       cbp=0x%02x %s\n",
921      if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
922      TEST_CBP(calc_cbp, Src3);      TEST_CBP(calc_cbp, Src3);
923      printf( "%s -   calc_cbp#3 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#3 %.3f usec       cbp=0x%02x %s\n",
924      if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
925      TEST_CBP(calc_cbp, Src4);      TEST_CBP(calc_cbp, Src4);
926      printf( "%s -   calc_cbp#4 %.3f usec       cbp=0x%x\n", cpu->name, t, cbp );                  printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
927      if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
928      printf( " --- \n" );      printf( " --- \n" );
929    }    }
930  }  }
931    
932  /*********************************************************************  /*********************************************************************
933     * fdct/idct IEEE1180 compliance
934     *********************************************************************/
935    
936    typedef struct {
937            long Errors[64];
938            long Sqr_Errors[64];
939            long Max_Errors[64];
940            long Nb;
941    } STATS_8x8;
942    
943    void init_stats(STATS_8x8 *S)
944    {
945            int i;
946            for(i=0; i<64; ++i) {
947                    S->Errors[i]     = 0;
948                    S->Sqr_Errors[i] = 0;
949                    S->Max_Errors[i] = 0;
950            }
951            S->Nb = 0;
952    }
953    
954    void store_stats(STATS_8x8 *S, short Blk[64], short Ref[64])
955    {
956            int i;
957            for(i=0; i<64; ++i)
958            {
959                    short Err = Blk[i] - Ref[i];
960                    S->Errors[i] += Err;
961                    S->Sqr_Errors[i] += Err * Err;
962                    if (Err<0) Err = -Err;
963                    if (S->Max_Errors[i]<Err)
964                            S->Max_Errors[i] = Err;
965            }
966            S->Nb++;
967    }
968    
969    void print_stats(STATS_8x8 *S)
970    {
971            int i;
972            double Norm;
973    
974            assert(S->Nb>0);
975            Norm = 1. / (double)S->Nb;
976            printf("\n== Max absolute values of errors ==\n");
977            for(i=0; i<64; i++) {
978                    printf("  %4ld", S->Max_Errors[i]);
979                    if ((i&7)==7) printf("\n");
980            }
981    
982            printf("\n== Mean square errors ==\n");
983            for(i=0; i<64; i++)
984            {
985                    double Err = Norm * (double)S->Sqr_Errors[i];
986                    printf(" %.3f", Err);
987                    if ((i&7)==7) printf("\n");
988            }
989    
990            printf("\n== Mean errors ==\n");
991            for(i=0; i<64; i++)
992            {
993                    double Err = Norm * (double)S->Errors[i];
994                    printf(" %.3f", Err);
995                    if ((i&7)==7) printf("\n");
996            }
997            printf("\n");
998    }
999    
1000    static const char *CHECK(double v, double l) {
1001            if (fabs(v)<=l) return "ok";
1002            else return "FAIL!";
1003    }
1004    
1005    void report_stats(STATS_8x8 *S, const double *Limits)
1006    {
1007            int i;
1008            double Norm, PE, PMSE, OMSE, PME, OME;
1009    
1010            assert(S->Nb>0);
1011            Norm = 1. / (double)S->Nb;
1012            PE = 0.;
1013            for(i=0; i<64; i++) {
1014                    if (PE<S->Max_Errors[i])
1015                            PE = S->Max_Errors[i];
1016            }
1017    
1018            PMSE = 0.;
1019            OMSE = 0.;
1020            for(i=0; i<64; i++)
1021            {
1022                    double Err = Norm * (double)S->Sqr_Errors[i];
1023                    OMSE += Err;
1024                    if (PMSE < Err) PMSE = Err;
1025            }
1026            OMSE /= 64.;
1027    
1028            PME = 0.;
1029            OME = 0.;
1030            for(i=0; i<64; i++)
1031            {
1032                    double Err = Norm * (double)S->Errors[i];
1033                    OME += Err;
1034                    Err = fabs(Err);
1035                    if (PME < Err) PME = Err;
1036            }
1037            OME /= 64.;
1038    
1039            printf( "Peak error:   %4.4f\n", PE );
1040            printf( "Peak MSE:     %4.4f\n", PMSE );
1041            printf( "Overall MSE:  %4.4f\n", OMSE );
1042            printf( "Peak ME:      %4.4f\n", PME );
1043            printf( "Overall ME:   %4.4f\n", OME );
1044    
1045            if (Limits!=0)
1046            {
1047                    printf( "[PE<=%.4f %s]  ", Limits[0], CHECK(PE,   Limits[0]) );
1048                    printf( "\n" );
1049                    printf( "[PMSE<=%.4f %s]", Limits[1], CHECK(PMSE, Limits[1]) );
1050                    printf( "[OMSE<=%.4f %s]", Limits[2], CHECK(OMSE, Limits[2]) );
1051                    printf( "\n" );
1052                    printf( "[PME<=%.4f %s] ", Limits[3], CHECK(PME , Limits[3]) );
1053                    printf( "[OME<=%.4f %s] ", Limits[4], CHECK(OME , Limits[4]) );
1054                    printf( "\n" );
1055            }
1056    }
1057    
1058    ///* ////////////////////////////////////////////////////// */
1059    /* Pseudo-random generator specified by IEEE 1180 */
1060    
1061    static long ieee_seed = 1;
1062    static void ieee_reseed(long s) {
1063            ieee_seed = s;
1064    }
1065    static long ieee_rand(int Min, int Max)
1066    {
1067            static double z = (double) 0x7fffffff;
1068    
1069            long i,j;
1070            double x;
1071    
1072            ieee_seed = (ieee_seed * 1103515245) + 12345;
1073            i = ieee_seed & 0x7ffffffe;
1074            x = ((double) i) / z;
1075            x *= (Max-Min+1);
1076            j = (long)x;
1077            j = j + Min;
1078            assert(j>=Min && j<=Max);
1079            return (short)j;
1080    }
1081    
1082    #define CLAMP(x, M)   (x) = ((x)<-(M)) ? (-(M)) : ((x)>=(M) ? ((M)-1) : (x))
1083    
1084    static double Cos[8][8];
1085    static void init_ref_dct()
1086    {
1087            int i, j;
1088            for(i=0; i<8; i++)
1089            {
1090                    double scale = (i == 0) ? sqrt(0.125) : 0.5;
1091                    for (j=0; j<8; j++)
1092                            Cos[i][j] = scale*cos( (M_PI/8.0)*i*(j + 0.5) );
1093            }
1094    }
1095    
1096    void ref_idct(short *M)
1097    {
1098            int i, j, k;
1099            double Tmp[8][8];
1100    
1101            for(i=0; i<8; i++) {
1102                    for(j=0; j<8; j++)
1103                    {
1104                            double Sum = 0.0;
1105                            for (k=0; k<8; k++) Sum += Cos[k][j]*M[8*i+k];
1106                            Tmp[i][j] = Sum;
1107                    }
1108            }
1109            for(i=0; i<8; i++) {
1110                    for(j=0; j<8; j++) {
1111                            double Sum = 0.0;
1112                            for (k=0; k<8; k++) Sum += Cos[k][i]*Tmp[k][j];
1113                            M[8*i+j] = (short)floor(Sum + .5);
1114                    }
1115            }
1116    }
1117    
1118    void ref_fdct(short *M)
1119    {
1120            int i, j, k;
1121            double Tmp[8][8];
1122    
1123            for(i=0; i<8; i++) {
1124                    for(j=0; j<8; j++)
1125                    {
1126                            double Sum = 0.0;
1127                            for (k=0; k<8; k++) Sum += Cos[j][k]*M[8*i+k];
1128                            Tmp[i][j] = Sum;
1129                    }
1130            }
1131            for(i=0; i<8; i++) {
1132                    for(j=0; j<8; j++) {
1133                            double Sum = 0.0;
1134                            for (k=0; k<8; k++) Sum += Cos[i][k]*Tmp[k][j];
1135                            M[8*i+j] = (short)floor(Sum + 0.5);
1136                    }
1137            }
1138    }
1139    
1140    void test_IEEE1180_compliance(int Min, int Max, int Sign)
1141    {
1142            static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };
1143            int Loops = 10000;
1144            int i, m, n;
1145            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1146            DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1147            DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1148            DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
1149            DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
1150    
1151            STATS_8x8 FStats; /* forward dct stats */
1152            STATS_8x8 IStats; /* inverse dct stats */
1153    
1154            CPU *cpu;
1155    
1156            init_ref_dct();
1157    
1158            for(cpu = cpu_list; cpu->name!=0; ++cpu)
1159            {
1160                    if (!init_cpu(cpu))
1161                            continue;
1162    
1163                    printf( "\n===== IEEE test for %s ==== (Min=%d Max=%d Sign=%d Loops=%d)\n",
1164                                    cpu->name, Min, Max, Sign, Loops);
1165    
1166                    init_stats(&IStats);
1167                    init_stats(&FStats);
1168    
1169                    ieee_reseed(1);
1170                    for(n=0; n<Loops; ++n)
1171                    {
1172                            for(i=0; i<64; ++i)
1173                                    Blk0[i] = (short)ieee_rand(Min,Max) * Sign;
1174    
1175                            /* hmm, I'm not quite sure this is exactly */
1176                            /* the tests described in the norm. check... */
1177    
1178                            memcpy(Ref_FDCT, Blk0, 64*sizeof(short));
1179                            ref_fdct(Ref_FDCT);
1180                            for(i=0; i<64; i++) CLAMP( Ref_FDCT[i], 2048 );
1181    
1182                            memcpy(Blk, Blk0, 64*sizeof(short));
1183                            emms(); fdct(Blk); emms();
1184                            for(i=0; i<64; i++) CLAMP( Blk[i], 2048 );
1185    
1186                            store_stats(&FStats, Blk, Ref_FDCT);
1187    
1188    
1189                            memcpy(Ref_IDCT, Ref_FDCT, 64*sizeof(short));
1190                            ref_idct(Ref_IDCT);
1191                            for (i=0; i<64; i++) CLAMP( Ref_IDCT[i], 256 );
1192    
1193                            memcpy(iBlk, Ref_FDCT, 64*sizeof(short));
1194                            emms(); idct(iBlk); emms();
1195                            for(i=0; i<64; i++) CLAMP( iBlk[i], 256 );
1196    
1197                            store_stats(&IStats, iBlk, Ref_IDCT);
1198                    }
1199    
1200    
1201                    printf( "\n  -- FDCT report --\n" );
1202    //    print_stats(&FStats);
1203                    report_stats(&FStats, 0); /* so far I know, IEEE1180 says nothing for fdct */
1204    
1205                    for(i=0; i<64; i++) Blk[i] = 0;
1206                    emms(); fdct(Blk); emms();
1207                    for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
1208                    printf( "FDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1209    
1210                    printf( "\n  -- IDCT report --\n" );
1211    //    print_stats(&IStats);
1212                    report_stats(&IStats, ILimits);
1213    
1214    
1215                    for(i=0; i<64; i++) Blk[i] = 0;
1216                    emms(); idct(Blk); emms();
1217                    for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
1218                    printf( "IDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1219            }
1220    }
1221    
1222    
1223    void test_dct_saturation(int Min, int Max)
1224    {
1225    /* test behaviour on input range fringe */
1226    
1227            int i, n, p;
1228            CPU *cpu;
1229    //  const short IDCT_MAX =  2047;  /* 12bits input */
1230    //  const short IDCT_MIN = -2048;
1231    //  const short IDCT_OUT =   256;  /* 9bits ouput */
1232            const int Partitions = 4;
1233            const int Loops = 10000 / Partitions;
1234    
1235            init_ref_dct();
1236    
1237            for(cpu = cpu_list; cpu->name!=0; ++cpu)
1238            {
1239                    short Blk0[64], Blk[64];
1240                    STATS_8x8 Stats;
1241    
1242                    if (!init_cpu(cpu))
1243                            continue;
1244    
1245                    printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",
1246                                    cpu->name, Min, Max );
1247    
1248                    /* FDCT tests // */
1249    
1250                    init_stats(&Stats);
1251    
1252                    /* test each computation channels separately */
1253                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;
1254                    ref_fdct(Blk0);
1255                    emms(); fdct(Blk); emms();
1256                    store_stats(&Stats, Blk, Blk0);
1257    
1258                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Min : 0;
1259                    ref_fdct(Blk0);
1260                    emms(); fdct(Blk); emms();
1261                    store_stats(&Stats, Blk, Blk0);
1262    
1263                    /* randomly saturated inputs */
1264                    for(p=0; p<Partitions; ++p)
1265                    {
1266                            for(n=0; n<Loops; ++n)
1267                            {
1268                                    for(i=0; i<64; ++i)
1269                                            Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? Max : Min;
1270                                    ref_fdct(Blk0);
1271                                    emms(); fdct(Blk); emms();
1272                                    store_stats(&Stats, Blk, Blk0);
1273                            }
1274                    }
1275                    printf( "\n  -- FDCT saturation report --\n" );
1276                    report_stats(&Stats, 0);
1277    
1278    
1279                    /* IDCT tests // */
1280    #if 0
1281                    /* no finished yet */
1282    
1283                    init_stats(&Stats);
1284    
1285    /* test each computation channel separately */
1286                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 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                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MIN : 0;
1293                    ref_idct(Blk0);
1294                    emms(); idct(Blk); emms();
1295                    for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1296                    store_stats(&Stats, Blk, Blk0);
1297    
1298                    /* randomly saturated inputs */
1299                    for(p=0; p<Partitions; ++p)
1300                    {
1301                            for(n=0; n<Loops; ++n)
1302                            {
1303                                    for(i=0; i<64; ++i)
1304                                            Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? IDCT_MAX : IDCT_MIN;
1305                                    ref_idct(Blk0);
1306                                    emms(); idct(Blk); emms();
1307                                    for(i=0; i<64; i++) { CLAMP(Blk0[i],IDCT_OUT); CLAMP(Blk[i],IDCT_OUT); }
1308                                    store_stats(&Stats, Blk, Blk0);
1309                            }
1310                    }
1311    
1312                    printf( "\n  -- IDCT saturation report --\n" );
1313                    print_stats(&Stats);
1314                    report_stats(&Stats, 0);
1315    #endif
1316            }
1317    }
1318    
1319    /*********************************************************************
1320   * measure raw decoding speed   * measure raw decoding speed
1321   *********************************************************************/   *********************************************************************/
1322    
1323  void test_dec(const char *name, int width, int height, int with_chksum)  void test_dec(const char *name, int width, int height, int ref_chksum)
1324  {  {
1325    FILE *f = 0;    FILE *f = 0;
1326    void *dechandle = 0;    void *dechandle = 0;
1327    int xerr;    int xerr;
1328          XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
1329          XVID_DEC_PARAM xparam;          xvid_dec_create_t xparam;
1330          XVID_DEC_FRAME xframe;          xvid_dec_frame_t xframe;
1331          double t = 0.;          double t = 0.;
1332          int nb = 0;          int nb = 0;
1333    uint8_t *buf = 0;    uint8_t *buf = 0;
1334    uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1335    int buf_size, pos;    int buf_size, pos;
1336    uint32_t chksum = 0;    uint32_t chksum = 0;
1337            int bps = (width+31) & ~31;
1338    
1339          xinit.cpu_flags = 0;          memset(&xinit, 0, sizeof(xinit));
1340          xvid_init(NULL, 0, &xinit, NULL);          xinit.cpu_flags = cpu_mask;
1341          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          xinit.version = XVID_VERSION;
1342            xvid_global(NULL, 0, &xinit, NULL);
1343    
1344            memset(&xparam, 0, sizeof(xparam));
1345          xparam.width = width;          xparam.width = width;
1346          xparam.height = height;          xparam.height = height;
1347            xparam.version = XVID_VERSION;
1348          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1349          if (xerr!=XVID_ERR_OK) {          if (xerr==XVID_ERR_FAIL) {
1350            printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1351            return;            return;
1352          }          }
1353          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 637  Line 1355 
1355    
1356          f = fopen(name, "rb");          f = fopen(name, "rb");
1357    if (f==0) {    if (f==0) {
1358      printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1359      return;      return;
1360    }    }
1361    fseek(f, 0, SEEK_END);    fseek(f, 0, SEEK_END);
1362    buf_size = ftell(f);    buf_size = ftell(f);
1363    fseek(f, 0, SEEK_SET);    fseek(f, 0, SEEK_SET);
1364    if (buf_size<=0) {    if (buf_size<=0) {
1365      printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1366      goto End;      goto End;
1367    }    }
   else printf( "Input size: %d\n", buf_size);  
1368    
1369    buf = malloc(buf_size); // should be enuf'          buf = malloc(buf_size);
1370    rgb_out = calloc(4, width*height);  // <-room for _RGB24          yuv_out = calloc(1, bps*height*3/2 + 15);
1371    if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1372      printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1373      goto End;      goto End;
1374    }    }
1375    
1376    if (fread(buf, buf_size, 1, f)!=1) {    if (fread(buf, buf_size, 1, f)!=1) {
1377      printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1378      goto End;      goto End;
1379    }    }
1380    
# Line 665  Line 1382 
1382    pos = 0;    pos = 0;
1383    t = -gettime_usec();    t = -gettime_usec();
1384    while(1) {    while(1) {
1385              int y;
1386    
1387                    memset(&xframe, 0, sizeof(xframe));
1388                    xframe.version = XVID_VERSION;
1389      xframe.bitstream = buf + pos;      xframe.bitstream = buf + pos;
1390      xframe.length = buf_size - pos;      xframe.length = buf_size - pos;
1391      xframe.image = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1392      xframe.stride = width;                  xframe.output.plane[1] = xframe.output.plane[0] + bps*height;
1393      xframe.colorspace = XVID_CSP_RGB24;                  xframe.output.plane[2] = xframe.output.plane[1] + bps/2;
1394                    xframe.output.stride[0] = bps;
1395                    xframe.output.stride[1] = bps;
1396                    xframe.output.stride[2] = bps;
1397                    xframe.output.csp = XVID_CSP_I420;
1398      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1399                    if (xerr<0) {
1400                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1401                            break;
1402                    }
1403                    else if (xerr==0)
1404                      break;
1405        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1406    
1407                    pos += xerr;
1408      nb++;      nb++;
1409      pos += xframe.length;  
1410      if (with_chksum) {      for(y=0; y<height/2; ++y) {
1411        int k = width*height;                    chksum = calc_crc(xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1412        uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc(xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1413        while(k-->0) chksum += *ptr++;                          chksum = calc_crc(xframe.output.plane[1] + y*bps, width/2, chksum);
1414                            chksum = calc_crc(xframe.output.plane[2] + y*bps, width/2, chksum);
1415      }      }
1416      if (pos==buf_size)      if (pos==buf_size)
1417        break;        break;
     if (xerr!=XVID_ERR_OK) {  
           printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
           break;  
         }  
1418    }    }
1419    t += gettime_usec();    t += gettime_usec();
1420            if (ref_chksum==0) {
1421    if (t>0.)    if (t>0.)
1422      printf( "%d frames decoded in %.3f s -> %.1f FPS\n", nb, t*1.e-6f, (float)(nb*1.e6f/t) );                    printf( "%d frames decoded in %.3f s -> %.1f FPS   Checksum:0x%.8x\n", nb, t*1.e-6f, (float)(nb*1.e6f/t), chksum );
1423    if (with_chksum)    }
1424      printf("checksum: 0x%.8x\n", chksum);    else {
1425                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1426                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1427      }
1428    
1429  End:  End:
1430    if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1431    if (buf!=0) free(buf);    if (buf!=0) free(buf);
1432    if (dechandle!=0) {    if (dechandle!=0) {
1433      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1434      if (xerr!=XVID_ERR_OK)                  if (xerr==XVID_ERR_FAIL)
1435              printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1436    }    }
1437    if (f!=0) fclose(f);    if (f!=0) fclose(f);
1438  }  }
# Line 709  Line 1444 
1444  void test_bugs1()  void test_bugs1()
1445  {  {
1446    CPU *cpu;    CPU *cpu;
1447            uint16_t mpeg_quant_matrices[64*8];
1448    
1449    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1450    
1451    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1452    {    {
1453      int i;      int i;
1454      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 721  Line 1457 
1457        continue;        continue;
1458    
1459      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1460      set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1461      dequant4_intra(Dst, Src, 32, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1462      printf( "dequant4_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1463      printf( "  Out[]= " );      printf( "  Out[]= " );
1464      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1465      printf( "\n" );      printf( "\n" );
# Line 731  Line 1467 
1467    
1468    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );
1469    
1470    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1471    {    {
1472      int i;      int i;
1473      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 740  Line 1476 
1476        continue;        continue;
1477    
1478      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1479      set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1480      dequant4_inter(Dst, Src, 32);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1481      printf( "dequant4_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1482      printf( "  Out[]= " );      printf( "  Out[]= " );
1483      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1484      printf( "\n" );      printf( "\n" );
# Line 752  Line 1488 
1488  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1489  {  {
1490    CPU *cpu;    CPU *cpu;
1491    short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1492            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1493    
1494    printf( "\n =====  fdct/idct saturation diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1495    
1496    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1497    {    {
1498      int i;      int i;
1499    
# Line 780  Line 1517 
1517    }    }
1518  }  }
1519    
1520    void test_quant_bug()
1521    {
1522            const int max_Q = 31;
1523            int i, n, qm, q;
1524            CPU *cpu;
1525            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1526            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1527            uint8_t Quant[8*8];
1528            CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1529            uint16_t Crcs_Inter[2][32];
1530            uint16_t Crcs_Intra[2][32];
1531            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1532    
1533            printf( "\n =====  test MPEG4-quantize bug =====\n" );
1534    
1535            for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;
1536    
1537    #if 1
1538            for(qm=1; qm<=255; ++qm)
1539            {
1540                    for(i=0; i<8*8; ++i) Quant[i] = qm;
1541                    set_inter_matrix( mpeg_quant_matrices, Quant );
1542    
1543                    for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1544                    {
1545                            uint16_t s;
1546    
1547                            if (!init_cpu(cpu))
1548                                    continue;
1549    
1550                            for(q=1; q<=max_Q; ++q) {
1551                                    emms();
1552                                    quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1553                                    emms();
1554                                    for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1555                                    Crcs_Inter[n][q] = s;
1556                            }
1557                    }
1558    
1559                    for(q=1; q<=max_Q; ++q)
1560                            for(i=0; i<n-1; ++i)
1561                                    if (Crcs_Inter[i][q]!=Crcs_Inter[i+1][q])
1562                                            printf( "Discrepancy Inter: qm=%d, q=%d  -> %d/%d !\n",
1563                                                            qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1564            }
1565    #endif
1566    
1567    #if 1
1568            for(qm=1; qm<=255; ++qm)
1569            {
1570                    for(i=0; i<8*8; ++i) Quant[i] = qm;
1571                    set_intra_matrix( mpeg_quant_matrices, Quant );
1572    
1573                    for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1574                    {
1575                            uint16_t s;
1576    
1577                            if (!init_cpu(cpu))
1578                                    continue;
1579    
1580                            for(q=1; q<=max_Q; ++q) {
1581                                    emms();
1582                                    quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1583                                    emms();
1584                                    for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1585                                    Crcs_Intra[n][q] = s;
1586                            }
1587                    }
1588    
1589                    for(q=1; q<=max_Q; ++q)
1590                            for(i=0; i<n-1; ++i)
1591                                    if (Crcs_Intra[i][q]!=Crcs_Intra[i+1][q])
1592                                            printf( "Discrepancy Intra: qm=%d, q=%d  -> %d/%d!\n",
1593                                                            qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1594            }
1595    #endif
1596    }
1597    /*********************************************************************/
1598    
1599    static uint32_t __inline log2bin_v1(uint32_t value)
1600    {
1601      int n = 0;
1602      while (value) {
1603        value >>= 1;
1604        n++;
1605      }
1606      return n;
1607    }
1608    
1609    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1610    
1611    static uint32_t __inline log2bin_v2(uint32_t value)
1612    {
1613      int n = 0;
1614      if (value & 0xffff0000) {
1615        value >>= 16;
1616        n += 16;
1617      }
1618      if (value & 0xff00) {
1619        value >>= 8;
1620        n += 8;
1621      }
1622      if (value & 0xf0) {
1623        value >>= 4;
1624        n += 4;
1625      }
1626     return n + log2_tab_16[value];
1627    }
1628    
1629    void test_log2bin()
1630    {
1631            const int nb_tests = 3000*speed_ref;
1632      int n, crc1=0, crc2=0;
1633      uint32_t s, s0;
1634      double t1, t2;
1635    
1636      t1 = gettime_usec();
1637      s0 = (int)(t1*31.241);
1638      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1639        crc1 += log2bin_v1(s);
1640      t1 = (gettime_usec()-t1) / nb_tests;
1641    
1642      t2 = gettime_usec();
1643      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1644        crc2 += log2bin_v2(s);
1645      t2 = (gettime_usec() - t2) / nb_tests;
1646    
1647      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1648      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1649      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1650    }
1651    
1652    /*********************************************************************/
1653    
1654    static void __inline old_gcd(int *num, int *den)
1655    {
1656     int i = *num;
1657      while (i > 1) {
1658        if (*num % i == 0 && *den % i == 0) {
1659          *num /= i;
1660          *den /= i;
1661          i = *num;
1662          continue;
1663        }
1664        i--;
1665      }
1666    }
1667    
1668    static uint32_t gcd(int num, int den)
1669    {
1670      int tmp;
1671      while( (tmp=num%den) ) { num = den; den = tmp; }
1672      return den;
1673    }
1674    static void __inline new_gcd(int *num, int *den)
1675    {
1676      const int div = gcd(*num, *den);
1677      if (num) {
1678        *num /= div;
1679        *den /= div;
1680      }
1681    }
1682    
1683    void test_gcd()
1684    {
1685            const int nb_tests = 10*speed_ref;
1686      int i;
1687      uint32_t crc1=0, crc2=0;
1688      uint32_t n0, n, d0, d;
1689      double t1, t2;
1690    
1691      t1 = gettime_usec();
1692      n0 = 0xfffff & (int)(t1*31.241);
1693      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1694      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1695        old_gcd(&n, &d);
1696        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1697        n = d;
1698        d = (d*12363+31) & 0xffff;
1699        d |= !d;
1700      }
1701      t1 = (gettime_usec()-t1) / nb_tests;
1702    
1703      t2 = gettime_usec();
1704      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1705        new_gcd(&n, &d);
1706        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1707        n = d;
1708        d = (d*12363+31) & 0xffff;
1709        d |= !d;
1710      }
1711      t2 = (gettime_usec() - t2) / nb_tests;
1712    
1713      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1714      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1715      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1716    }
1717    
1718  /*********************************************************************  /*********************************************************************
1719   * main   * main
1720   *********************************************************************/   *********************************************************************/
1721    
1722  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
1723    {
1724      printf( "missing argument after option '%s'\n", opt);
1725      exit(-1);
1726    }
1727    
1728    int main(int argc, const char *argv[])
1729  {  {
1730    int what = 0;          int c, what = 0;
1731    if (argc>1) what = atoi(argv[1]);          int width, height;
1732            uint32_t chksum = 0;
1733      const char * test_bitstream = 0;
1734    
1735            cpu_mask = 0;  // default => will use autodectect
1736            for(c=1; c<argc; ++c)
1737            {
1738              if (!strcmp(argv[c], "-v")) verbose++;
1739              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
1740              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
1741              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1742              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1743              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
1744              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
1745              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
1746              else if (!strcmp(argv[c], "-spd")) {
1747          if (++c==argc) arg_missing( argv[argc-1] );
1748          speed_ref = atoi(argv[c]);
1749        }
1750              else if (argv[c][0]!='-') {
1751                what = atoi(argv[c]);
1752                if (what==9) {
1753                  if (c+4>argc) {
1754                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
1755                    exit(-1);
1756            }
1757            test_bitstream = argv[++c];
1758                  width  = atoi(argv[++c]);
1759                  height = atoi(argv[++c]);
1760                  if (c+1<argc && argv[c+1][0]!='-') {
1761                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
1762                      printf( "can't read checksum value.\n" );
1763                      exit(-1);
1764              }
1765              else c++;
1766            }
1767    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
1768          }
1769        }
1770        else {
1771          printf( "unrecognized option '%s'\n", argv[c]);
1772          exit(-1);
1773        }
1774      }
1775    
1776    
1777    if (what==0 || what==1) test_dct();    if (what==0 || what==1) test_dct();
1778    if (what==0 || what==2) test_mb();    if (what==0 || what==2) test_mb();
1779    if (what==0 || what==3) test_sad();    if (what==0 || what==3) test_sad();
1780    if (what==0 || what==4) test_transfer();    if (what==0 || what==4) test_transfer();
1781    if (what==0 || what==5) test_quant();    if (what==0 || what==5) test_quant();
1782    if (what==0 || what==6) test_cbp();    if (what==0 || what==6) test_cbp();
1783            if (what==0 || what==10) test_sse();
1784    if (what==8) {          if (what==0 || what==11) test_log2bin();
1785      int width, height;          if (what==0 || what==12) test_gcd();
1786      if (argc<5) {  
1787        printf("usage: %s %d [bitstream] [width] [height]\n", argv[0], what);  
1788        return 1;          if (what==7) {
1789      }                  test_IEEE1180_compliance(-256, 255, 1);
1790      width = atoi(argv[3]);                  test_IEEE1180_compliance(-256, 255,-1);
1791      height = atoi(argv[4]);                  test_IEEE1180_compliance(  -5,   5, 1);
1792      test_dec(argv[2], width, height, (argc>5));                  test_IEEE1180_compliance(  -5,   5,-1);
1793                    test_IEEE1180_compliance(-300, 300, 1);
1794                    test_IEEE1180_compliance(-300, 300,-1);
1795    }    }
1796            if (what==8) test_dct_saturation(-256, 255);
1797    
1798            if (test_bitstream)
1799              test_dec(test_bitstream, width, height, chksum);
1800    if (what==-1) {    if (what==-1) {
     test_bugs1();  
1801      test_dct_precision_diffs();      test_dct_precision_diffs();
1802                    test_bugs1();
1803    }    }
1804    return 0;          if (what==-2)
1805                    test_quant_bug();
1806    
1807            if ((what >= 0 && what <= 6) || what == 10) {
1808                    printf("\n\n"
1809                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1810                               "    a C function is used instead. So don't panic if some functions\n"
1811                               "    may appear to be slow.\n");
1812            }
1813    
1814    #ifdef ARCH_IS_IA32
1815            if (what == 0 || what == 5) {
1816                    printf("\n"
1817                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1818                               "    for 1 or 2 coefficients a block. This is mainly caused by the fact the unit\n"
1819                               "    test goes far behind the usual limits of real encoding. Please do not report\n"
1820                               "    this error to the developers.\n");
1821  }  }
1822    #endif
1823    
1824  /*********************************************************************          return 0;
1825   * 'Reference' output (except for timing) on a PIII 1.13Ghz/linux  }
  *********************************************************************/  
 /*  
1826    
1827   ===== test fdct/idct =====  /*********************************************************************/
 PLAINC -  2.631 usec       iCrc=3  fCrc=-85  
 MMX    -  0.596 usec       iCrc=3  fCrc=-67  
 MMXEXT -  0.608 usec       iCrc=3  fCrc=-67  
 SSE2   -  0.605 usec       iCrc=3  fCrc=-67  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
  ===  test block motion ===  
 PLAINC - interp- h-round0 1.031 usec       iCrc=8107  
 PLAINC -           round1 1.022 usec       iCrc=8100  
 PLAINC - interp- v-round0 1.002 usec       iCrc=8108  
 PLAINC -           round1 1.011 usec       iCrc=8105  
 PLAINC - interp-hv-round0 1.623 usec       iCrc=8112  
 PLAINC -           round1 1.621 usec       iCrc=8103  
 PLAINC - interpolate8x8_c 0.229 usec       iCrc=8107  
  ---  
 MMX    - interp- h-round0 0.105 usec       iCrc=8107  
 MMX    -           round1 0.105 usec       iCrc=8100  
 MMX    - interp- v-round0 0.106 usec       iCrc=8108  
 MMX    -           round1 0.107 usec       iCrc=8105  
 MMX    - interp-hv-round0 0.145 usec       iCrc=8112  
 MMX    -           round1 0.145 usec       iCrc=8103  
 MMX    - interpolate8x8_c 0.229 usec       iCrc=8107  
  ---  
 MMXEXT - interp- h-round0 0.027 usec       iCrc=8107  
 MMXEXT -           round1 0.041 usec       iCrc=8100  
 MMXEXT - interp- v-round0 0.027 usec       iCrc=8108  
 MMXEXT -           round1 0.040 usec       iCrc=8105  
 MMXEXT - interp-hv-round0 0.070 usec       iCrc=8112  
 MMXEXT -           round1 0.066 usec       iCrc=8103  
 MMXEXT - interpolate8x8_c 0.027 usec       iCrc=8107  
  ---  
 SSE2   - interp- h-round0 0.106 usec       iCrc=8107  
 SSE2   -           round1 0.105 usec       iCrc=8100  
 SSE2   - interp- v-round0 0.106 usec       iCrc=8108  
 SSE2   -           round1 0.106 usec       iCrc=8105  
 SSE2   - interp-hv-round0 0.145 usec       iCrc=8112  
 SSE2   -           round1 0.145 usec       iCrc=8103  
 SSE2   - interpolate8x8_c 0.237 usec       iCrc=8107  
  ---  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
  ======  test SAD ======  
 PLAINC - sad8    0.296 usec       sad=3776  
 PLAINC - sad16   1.599 usec       sad=27214  
 PLAINC - sad16bi 2.350 usec       sad=26274  
 PLAINC - dev16   1.610 usec       sad=3344  
  ---  
 MMX    - sad8    0.057 usec       sad=3776  
 MMX    - sad16   0.178 usec       sad=27214  
 MMX    - sad16bi 2.381 usec       sad=26274  
 MMX    - dev16   0.312 usec       sad=3344  
  ---  
 MMXEXT - sad8    0.036 usec       sad=3776  
 MMXEXT - sad16   0.106 usec       sad=27214  
 MMXEXT - sad16bi 0.182 usec       sad=26274  
 MMXEXT - dev16   0.193 usec       sad=3344  
  ---  
 SSE2   - sad8    0.057 usec       sad=3776  
 SSE2   - sad16   0.178 usec       sad=27214  
 SSE2   - sad16bi 2.427 usec       sad=26274  
 SSE2   - dev16   0.313 usec       sad=3344  
  ---  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
  ===  test transfer ===  
 PLAINC - 8to16     0.124 usec       crc=28288  
 PLAINC - 16to8     0.753 usec       crc=28288  
 PLAINC - 8to8      0.041 usec       crc=20352  
 PLAINC - 16to8add  0.916 usec       crc=25536  
 PLAINC - 8to16sub  0.812 usec       crc1=28064 crc2=16256  
 PLAINC - 8to16sub2 0.954 usec       crc=20384  
  ---  
 MMX    - 8to16     0.037 usec       crc=28288  
 MMX    - 16to8     0.016 usec       crc=28288  
 MMX    - 8to8      0.018 usec       crc=20352  
 MMX    - 16to8add  0.044 usec       crc=25536  
 MMX    - 8to16sub  0.065 usec       crc1=28064 crc2=16256  
 MMX    - 8to16sub2 0.110 usec       crc=20384  
  ---  
 MMXEXT - 8to16     0.032 usec       crc=28288  
 MMXEXT - 16to8     0.023 usec       crc=28288  
 MMXEXT - 8to8      0.018 usec       crc=20352  
 MMXEXT - 16to8add  0.041 usec       crc=25536  
 MMXEXT - 8to16sub  0.065 usec       crc1=28064 crc2=16256  
 MMXEXT - 8to16sub2 0.069 usec       crc=20384  
  ---  
   
  =====  test quant =====  
 PLAINC -   quant4_intra 78.889 usec       crc=55827  
 PLAINC -   quant4_inter 71.957 usec       crc=58201  
 PLAINC - dequant4_intra 34.968 usec       crc=193340  
 PLAINC - dequant4_inter 40.792 usec       crc=116483  
 PLAINC -    quant_intra 30.845 usec       crc=56885  
 PLAINC -    quant_inter 34.842 usec       crc=58056  
 PLAINC -  dequant_intra 33.211 usec       crc=-7936  
 PLAINC -  dequant_inter 45.486 usec       crc=-33217  
  ---  
 MMX    -   quant4_intra 9.030 usec       crc=55827  
 MMX    -   quant4_inter 8.234 usec       crc=58201  
 MMX    - dequant4_intra 18.330 usec       crc=193340  
 MMX    - dequant4_inter 19.181 usec       crc=116483  
 MMX    -    quant_intra 7.124 usec       crc=56885  
 MMX    -    quant_inter 6.861 usec       crc=58056  
 MMX    -  dequant_intra 9.048 usec       crc=-7936  
 MMX    -  dequant_inter 8.203 usec       crc=-33217  
  ---  
 MMXEXT -   quant4_intra 9.045 usec       crc=55827  
 MMXEXT -   quant4_inter 8.232 usec       crc=58201  
 MMXEXT - dequant4_intra 18.250 usec       crc=193340  
 MMXEXT - dequant4_inter 19.256 usec       crc=116483  
 MMXEXT -    quant_intra 7.121 usec       crc=56885  
 MMXEXT -    quant_inter 6.855 usec       crc=58056  
 MMXEXT -  dequant_intra 9.034 usec       crc=-7936  
 MMXEXT -  dequant_inter 8.202 usec       crc=-33217  
  ---  
   
  =====  test cbp =====  
 PLAINC -   calc_cbp#1 0.545 usec       cbp=0x15  
 PLAINC -   calc_cbp#2 0.540 usec       cbp=0x38  
 PLAINC -   calc_cbp#3 0.477 usec       cbp=0xf  
 PLAINC -   calc_cbp#4 0.739 usec       cbp=0x5  
  ---  
 MMX    -   calc_cbp#1 0.136 usec       cbp=0x15  
 MMX    -   calc_cbp#2 0.131 usec       cbp=0x38  
 MMX    -   calc_cbp#3 0.132 usec       cbp=0xf  
 MMX    -   calc_cbp#4 0.135 usec       cbp=0x5  
  ---  
 SSE2   -   calc_cbp#1 0.135 usec       cbp=0x15  
 SSE2   -   calc_cbp#2 0.131 usec       cbp=0x38  
 SSE2   -   calc_cbp#3 0.134 usec       cbp=0xf  
 SSE2   -   calc_cbp#4 0.136 usec       cbp=0x5  
  ---  
 */  
Legend:
Removed from v.225  
changed lines
  Added in v.1620
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4