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

Diff of /xvidcore/examples/xvid_bench.c

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

revision 1.2, Fri Jul 5 14:54:15 2002 UTC revision 1.9.2.11, Tue Mar 30 21:38:19 2004 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$
23   *   *
24   *************************************************************************/   ****************************************************************************/
25    
26  /************************************************************************  /*****************************************************************************
27   *   *
28   *  'Reference' output is at the end of file.   *  'Reference' output is at the end of file.
29   *  Don't take the checksums and crc too seriouly, they aren't   *  Don't take the checksums and crc too seriouly, they aren't
30   *  bullet-proof...   *  bullet-proof (should plug some .md5 here)...
31   *   *
32   *   compiles with something like:   *   compiles with something like:
33   *   gcc -o xvid_bench xvid_bench.c  -I../src/ -lxvidcore -lm   *   gcc -o xvid_bench xvid_bench.c  -I../src/ -lxvidcore -lm
34   *   *
35   *      History:   ****************************************************************************/
  *  
  *      06.06.2002  initial coding      -Skal-  
  *  
  *************************************************************************/  
36    
37  #include <stdio.h>  #include <stdio.h>
38  #include <stdlib.h>  #include <stdlib.h>
39  #include <sys/time.h>  // for gettimeofday  #include <string.h>    /* for memset */
 #include <string.h>    // for memset  
40  #include <assert.h>  #include <assert.h>
41    
42    #ifndef WIN32
43    #include <sys/time.h>   /* for gettimeofday */
44    #else
45    #include <time.h>
46    #endif
47    
48    
49  #include "xvid.h"  #include "xvid.h"
50    
51  // inner guts  // inner guts
# Line 47  Line 54 
54  #include "image/colorspace.h"  #include "image/colorspace.h"
55  #include "image/interpolate8x8.h"  #include "image/interpolate8x8.h"
56  #include "utils/mem_transfer.h"  #include "utils/mem_transfer.h"
57  #include "quant/quant_h263.h"  #include "quant/quant.h"
 #include "quant/quant_mpeg4.h"  
58  #include "motion/sad.h"  #include "motion/sad.h"
59  #include "utils/emms.h"  #include "utils/emms.h"
60  #include "utils/timer.h"  #include "utils/timer.h"
61  #include "quant/quant_matrix.c"  #include "quant/quant_matrix.c"
62  #include "bitstream/cbp.h"  #include "bitstream/cbp.h"
63    
64  const int speed_ref = 100;  // on slow machines, decrease this value  #include <math.h>
65    
66    #ifndef M_PI
67    #define M_PI            3.14159265358979323846
68    #endif
69    
70    const int speed_ref = 100;  /* on slow machines, decrease this value */
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.0e6 + tv.tv_usec;    return tv.tv_sec*1.0e6 + tv.tv_usec;
83    #else
84            clock_t clk;
85            clk = clock();
86            return clk * 1000000 / CLOCKS_PER_SEC;
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    //, { "IA64  ", XVID_CPU_IA64 }
125  //, { "TSC   ", XVID_CPU_TSC }  //, { "TSC   ", XVID_CPU_TSC }
126  , { 0, 0 } }    , { 0, 0 } };
127    
128  , cpu_short_list[] =  CPU  cpu_short_list[] =
129  { { "PLAINC", 0 }  { { "PLAINC", 0 }
130    #ifdef ARCH_IS_IA32
131  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
132  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }  //, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }
133  , { "IA64  ", XVID_CPU_IA64 }  #endif
134  , { 0, 0 } }  //, { "IA64  ", XVID_CPU_IA64 }
135      , { 0, 0 } };
136    
137  , cpu_short_list2[] =  CPU cpu_short_list2[] =
138  { { "PLAINC", 0 }  { { "PLAINC", 0 }
139    #ifdef ARCH_IS_IA32
140  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
141  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }
142    #endif
143  , { 0, 0 } };  , { 0, 0 } };
144    
145    
146  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
147  {  {
148    int xerr, cpu_type;          xvid_gbl_info_t xinfo;
   XVID_INIT_PARAM xinit;  
149    
150    cpu_type = check_cpu_features() & cpu->cpu;          /* Get the available CPU flags */
151    xinit.cpu_flags = cpu_type | XVID_CPU_FORCE;          memset(&xinfo, 0, sizeof(xinfo));
152    //    xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinfo.version = XVID_VERSION;
153    xerr = xvid_init(NULL, 0, &xinit, NULL);          xvid_global(NULL, XVID_GBL_INFO, &xinfo, NULL);
154    if (cpu->cpu>0 && (cpu_type==0 || xerr!=XVID_ERR_OK)) {  
155      printf( "%s - skipped...\n", cpu->name );          /* Are we trying to test a subset of the host CPU features */
156            if ((xinfo.cpu_flags & cpu->cpu) == cpu->cpu) {
157                    int xerr;
158                    xvid_gbl_init_t xinit;
159                    memset(&xinit, 0, sizeof(xinit));
160                    xinit.cpu_flags = cpu->cpu | XVID_CPU_FORCE;
161                    xinit.version = XVID_VERSION;
162                    xerr = xvid_global(NULL, XVID_GBL_INIT, &xinit, NULL);
163                    if (xerr==XVID_ERR_FAIL) {
164                            /* libxvidcore failed to init */
165      return 0;      return 0;
166    }    }
167            } else {
168                    /* The host CPU doesn't support some required feature for this test */
169                    return(0);
170            }
171    return 1;    return 1;
172  }  }
173    
174    #define CRC32_REMAINDER 0xCBF43926
175    #define CRC32_INITIAL 0xffffffff
176    
177    #define DO1(c, crc) ((crc) = crc32tab[((unsigned int)((crc)>>24) ^ (*c++)) & 0xff] ^ ((crc) << 8))
178    #define DO2(c, crc)  DO1(c, crc); DO1(c, crc);
179    #define DO4(c, crc)  DO2(c, crc); DO2(c, crc);
180    #define DO8(c, crc)  DO4(c, crc); DO4(c, crc);
181    
182    /******************************************************************************
183    * Precomputed AAL5 CRC32 lookup table
184    ******************************************************************************/
185    
186    static unsigned long crc32tab[256] = {
187    
188            0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
189            0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
190            0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
191            0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
192            0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
193            0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
194            0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
195            0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
196            0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
197            0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
198            0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
199            0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
200            0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
201            0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
202            0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
203            0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
204            0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
205            0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
206            0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
207            0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
208            0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
209            0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
210            0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
211            0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
212            0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
213            0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
214            0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
215            0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
216            0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
217            0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
218            0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
219            0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
220            0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
221            0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
222            0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
223            0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
224            0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
225            0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
226            0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
227            0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
228            0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
229            0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
230            0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
231            0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
232            0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
233            0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
234            0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
235            0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
236            0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
237            0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
238            0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
239            0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
240            0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
241            0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
242            0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
243            0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
244            0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
245            0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
246            0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
247            0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
248            0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
249            0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
250            0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
251            0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
252    
253    };
254    
255    uint32_t
256    calc_crc(uint8_t *mem, int len, uint32_t initial)
257    {
258    
259            register unsigned int crc;
260    
261            crc = initial;
262    
263            while( len >= 8) {
264                    DO8(mem, crc);
265                    len -= 8;
266            }
267    
268            while( len ) {
269                    DO1(mem, crc);
270                    len--;
271            }
272    
273            return(crc);
274    
275    }
276    
277  /*********************************************************************  /*********************************************************************
278   * test DCT   * test DCT
279   *********************************************************************/   *********************************************************************/
# Line 147  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 163  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 180  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 202  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 223  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 266  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 285  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 309  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 367  Line 527 
527      }                                         \      }                                         \
528      emms();                                   \      emms();                                   \
529      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
530      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]^i; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
531    
532  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
533      TEST_TRANSFER_BEGIN(DST);                 \      TEST_TRANSFER_BEGIN(DST);                 \
# Line 393  Line 553 
553      }                                         \      }                                         \
554      emms();                                   \      emms();                                   \
555      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
556      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
557    
558  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
559      TEST_TRANSFER2_BEGIN(DST,SRC);            \      TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 415  Line 575 
575    
576    printf( "\n ===  test transfer ===\n" );    printf( "\n ===  test transfer ===\n" );
577    
578    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
579    {    {
580      double t, overhead;      double t, overhead;
581      int tst, s;      int tst, s;
# Line 424  Line 584 
584        continue;        continue;
585    
586      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
587      printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
588      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
589                               (s!=0x115814bb)?"| ERROR": "");
590    
591      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
592      printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
593      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
594                                    (s!=0xee7ccbb4)?"| ERROR": "");
595    
596      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
597      printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
598      if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
599                               (s!=0xd37b3295)?"| ERROR": "");
600    
601      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
602      printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
603      if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
604                               (s!=0xdd817bf4)?"| ERROR": "" );
605    
606      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
607      printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
608      if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
609      s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }                          s1 = calc_crc((uint8_t*)Dst16, sizeof(Dst16), CRC32_INITIAL);
610      printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, sizeof(Src8), CRC32_INITIAL);
611      if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
612                                       cpu->name, t, s1, s2,
613                                       (s1!=0xa1e07163)?"| ERROR1": "",
614                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
615                    }
616    
617      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
618      printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
619      if (s!=20384) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
620                               (s!=0x99b6c4c7)?"| ERROR": "" );
621    
622      printf( " --- \n" );      printf( " --- \n" );
623    }    }
# Line 460  Line 629 
629    
630  #define TEST_QUANT(FUNC, DST, SRC)            \  #define TEST_QUANT(FUNC, DST, SRC)            \
631      t = gettime_usec();                       \      t = gettime_usec();                       \
632    for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
633      for(i=0; i<8*8; ++i) Quant[i] = qm;       \
634      set_inter_matrix( mpeg_quant_matrices, Quant );                \
635      emms();                                   \      emms();                                   \
636      for(q=1; q<=max_Q; ++q) {                 \
637      for(tst=0; tst<nb_tests; ++tst)           \      for(tst=0; tst<nb_tests; ++tst)           \
638        for(s=0, q=1; q<=max_Q; ++q) {          \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
639          (FUNC)((DST), (SRC), q);              \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
         for(i=0; i<64; ++i) s+=(DST)[i]^i;    \  
640        }                                       \        }                                       \
641      emms();                                   \      emms();                                   \
642      t = (gettime_usec()-t-overhead)/nb_tests;  }                                           \
643    t = (gettime_usec()-t-overhead)/nb_tests/qm
644    
645  #define TEST_QUANT2(FUNC, DST, SRC, MULT)     \  #define TEST_QUANT2(FUNC, DST, SRC)             \
646      t = gettime_usec();                       \      t = gettime_usec();                       \
647    for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
648      for(i=0; i<8*8; ++i) Quant[i] = qm;       \
649      set_intra_matrix( mpeg_quant_matrices, Quant );                \
650      emms();                                   \      emms();                                   \
651      for(q=1; q<=max_Q; ++q) {                 \
652      for(tst=0; tst<nb_tests; ++tst)           \      for(tst=0; tst<nb_tests; ++tst)           \
653        for(s=0, q=1; q<=max_Q; ++q) {          \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
654          (FUNC)((DST), (SRC), q, MULT);        \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
         for(i=0; i<64; ++i) s+=(DST)[i]^i;    \  
655        }                                       \        }                                       \
656      emms();                                   \      emms();                                   \
657      t = (gettime_usec()-t-overhead)/nb_tests;  }                                           \
658    t = (gettime_usec()-t-overhead)/nb_tests/qm
659    
660    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
661    { int i,q,s;\
662            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
663      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
664      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
665      for(q=1;q<=max_Q;q++)          \
666        for(s=-RANGE;s<RANGE;s++) { \
667          for(i=0;i<64;i++) Src[i]=s; \
668          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
669          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
670          for(i=0;i<64;i++)     \
671            if(Dst[i]!=Dst2[i]) printf("ERROR : " #NEWFUNC " i%d quant:%d input:%d C_result:%d ASM_result:%d\n",i,q,s,Dst[i],Dst2[i]);  \
672        }      \
673    }
674    
675    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
676    { int i,q,s;  \
677            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
678      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
679      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
680      for(q=1;q<=max_Q;q++)  \
681        for(s=-RANGE;s<RANGE;s++) {   \
682          for(i=0;i<64;i++) Src[i]=s; \
683          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
684          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
685          emms();           \
686          for(i=0;i<64;i++) \
687            if(Dst[i]!=Dst2[i]) printf("ERROR : " #NEWFUNC " i%d quant:%d input:%d C_result:%d ASM_result:%d\n",i,q,s,Dst[i],Dst2[i]); \
688        } \
689    }
690    
691  void test_quant()  void test_quant()
692  {  {
693    const int nb_tests = 150*speed_ref;          const int nb_tests = 1*speed_ref;
694    const int max_Q = 31;    const int max_Q = 31;
695    int i;          DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
696    
697            int i, qm;
698    CPU *cpu;    CPU *cpu;
699    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
700            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
701      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
702            uint8_t Quant[8*8];
703    
704    
705    
706    printf( "\n =====  test quant =====\n" );    printf( "\n =====  test quant =====\n" );
707    
708    /* we deliberately enfringe the norm's specified range [-127,127], */
709    /* to test the robustness of the iquant module */
710    for(i=0; i<64; ++i) {    for(i=0; i<64; ++i) {
711      Src[i] = i-32;                  Src[i] = 1 + (i-32) * (i&6);
712      Dst[i] = 0;      Dst[i] = 0;
713    }    }
714    
715            for(cpu = cpu_list; cpu->name!=0; ++cpu)
   for(cpu = cpu_short_list; cpu->name!=0; ++cpu)  
716    {    {
717      double t, overhead;      double t, overhead;
718      int tst, s, q;                  int tst, q;
719                    uint32_t s;
720    
721      if (!init_cpu(cpu))      if (!init_cpu(cpu))
722        continue;        continue;
723    
724      set_inter_matrix( get_default_inter_matrix() );        // exhaustive tests to compare against the (ref) C-version
725      set_intra_matrix( get_default_intra_matrix() );      TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
726        TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
727        TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
728        TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
729    
730      overhead = -gettime_usec();      overhead = -gettime_usec();
731      for(tst=0; tst<nb_tests; ++tst)                  for(s=0,qm=1; qm<=255; ++qm) {
732        for(s=0, q=1; q<=max_Q; ++q)                          for(i=0; i<8*8; ++i) Quant[i] = qm;
733          for(i=0; i<64; ++i) s+=Dst[i]^i;                          set_inter_matrix(mpeg_quant_matrices, Quant );
734                            for(q=1; q<=max_Q; ++q)
735                                    for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
736                    }
737      overhead += gettime_usec();      overhead += gettime_usec();
738    
739      TEST_QUANT2(quant4_intra, Dst, Src, 7);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
740      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",
741      if (s!=55827) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
742                               (s!=0xfd6a21a4)? "| ERROR": "");
743      TEST_QUANT(quant4_inter, Dst, Src);  
744      printf( "%s -   quant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
745      if (s!=58201) printf( "*** CRC ERROR! ***\n" );                  printf("%s -   quant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
746                               cpu->name, t, s,
747                               (s!=0xf6de7757)?"| ERROR": "");
748      TEST_QUANT2(dequant4_intra, Dst, Src, 7);  
749      printf( "%s - dequant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
750      if (s!=193340) printf( "*** CRC ERROR! ***\n" );                  printf("%s - dequant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
751                               cpu->name, t, s,
752      TEST_QUANT(dequant4_inter, Dst, Src);                             (s!=0x2def7bc7)?"| ERROR": "");
753      printf( "%s - dequant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );  
754      if (s!=116483) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
755                    printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
756      TEST_QUANT2(quant_intra, Dst, Src, 7);                             cpu->name, t, s,
757      printf( "%s -    quant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                             (s!=0xd878c722)?"| ERROR": "");
758      if (s!=56885) printf( "*** CRC ERROR! ***\n" );  
759                    TEST_QUANT2(quant_h263_intra, Dst, Src);
760      TEST_QUANT(quant_inter, Dst, Src);                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
761      printf( "%s -    quant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                             cpu->name, t, s,
762      if (s!=58056) printf( "*** CRC ERROR! ***\n" );                             (s!=0x2eba9d43)?"| ERROR": "");
763    
764      TEST_QUANT2(dequant_intra, Dst, Src, 7);                  TEST_QUANT(quant_h263_inter, Dst, Src);
765      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",
766      if (s!=-7936) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
767                               (s!=0xbd315a7e)?"| ERROR": "");
768      TEST_QUANT(dequant_inter, Dst, Src);  
769      printf( "%s -  dequant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
770  //    { 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",
771      if (s!=-33217) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
772                               (s!=0x9841212a)?"| ERROR": "");
773    
774                    TEST_QUANT(dequant_h263_inter, Dst, Src);
775                    printf("%s - dequant_h263_inter %.3f usec       crc32=0x%08x %s\n",
776                               cpu->name, t, s,
777                               (s!=0xe7df8fba)?"| ERROR": "");
778    
779      printf( " --- \n" );      printf( " --- \n" );
780    }    }
# Line 568  Line 798 
798    const int nb_tests = 10000*speed_ref;    const int nb_tests = 10000*speed_ref;
799    int i;    int i;
800    CPU *cpu;    CPU *cpu;
801    int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
802            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
803            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
804            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
805    
806    printf( "\n =====  test cbp =====\n" );    printf( "\n =====  test cbp =====\n" );
807    
808    for(i=0; i<6*64; ++i) {    for(i=0; i<6*64; ++i) {
809      Src1[i] = (i*i*3/8192)&(i/64)&1;  // 'random'                  Src1[i] = (i*i*3/8192)&(i/64)&1;  /* 'random' */
810      Src2[i] = (i<3*64);               // half-full                  Src2[i] = (i<3*64);               /* half-full */
811      Src3[i] = ((i+32)>3*64);      Src3[i] = ((i+32)>3*64);
812      Src4[i] = (i==(3*64+2) || i==(5*64+9));      Src4[i] = (i==(3*64+2) || i==(5*64+9));
813    }    }
814    
815    for(cpu = cpu_short_list2; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
816    {    {
817      double t;      double t;
818      int tst, cbp;      int tst, cbp;
# Line 588  Line 821 
821        continue;        continue;
822    
823      TEST_CBP(calc_cbp, Src1);      TEST_CBP(calc_cbp, Src1);
824      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\n",
825      if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
826      TEST_CBP(calc_cbp, Src2);      TEST_CBP(calc_cbp, Src2);
827      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\n",
828      if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
829      TEST_CBP(calc_cbp, Src3);      TEST_CBP(calc_cbp, Src3);
830      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\n",
831      if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
832      TEST_CBP(calc_cbp, Src4);      TEST_CBP(calc_cbp, Src4);
833      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\n",
834      if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
835      printf( " --- \n" );      printf( " --- \n" );
836    }    }
837  }  }
838    
839  /*********************************************************************  /*********************************************************************
840     * fdct/idct IEEE1180 compliance
841     *********************************************************************/
842    
843    typedef struct {
844            long Errors[64];
845            long Sqr_Errors[64];
846            long Max_Errors[64];
847            long Nb;
848    } STATS_8x8;
849    
850    void init_stats(STATS_8x8 *S)
851    {
852            int i;
853            for(i=0; i<64; ++i) {
854                    S->Errors[i]     = 0;
855                    S->Sqr_Errors[i] = 0;
856                    S->Max_Errors[i] = 0;
857            }
858            S->Nb = 0;
859    }
860    
861    void store_stats(STATS_8x8 *S, short Blk[64], short Ref[64])
862    {
863            int i;
864            for(i=0; i<64; ++i)
865            {
866                    short Err = Blk[i] - Ref[i];
867                    S->Errors[i] += Err;
868                    S->Sqr_Errors[i] += Err * Err;
869                    if (Err<0) Err = -Err;
870                    if (S->Max_Errors[i]<Err)
871                            S->Max_Errors[i] = Err;
872            }
873            S->Nb++;
874    }
875    
876    void print_stats(STATS_8x8 *S)
877    {
878            int i;
879            double Norm;
880    
881            assert(S->Nb>0);
882            Norm = 1. / (double)S->Nb;
883            printf("\n== Max absolute values of errors ==\n");
884            for(i=0; i<64; i++) {
885                    printf("  %4ld", S->Max_Errors[i]);
886                    if ((i&7)==7) printf("\n");
887            }
888    
889            printf("\n== Mean square errors ==\n");
890            for(i=0; i<64; i++)
891            {
892                    double Err = Norm * (double)S->Sqr_Errors[i];
893                    printf(" %.3f", Err);
894                    if ((i&7)==7) printf("\n");
895            }
896    
897            printf("\n== Mean errors ==\n");
898            for(i=0; i<64; i++)
899            {
900                    double Err = Norm * (double)S->Errors[i];
901                    printf(" %.3f", Err);
902                    if ((i&7)==7) printf("\n");
903            }
904            printf("\n");
905    }
906    
907    static const char *CHECK(double v, double l) {
908            if (fabs(v)<=l) return "ok";
909            else return "FAIL!";
910    }
911    
912    void report_stats(STATS_8x8 *S, const double *Limits)
913    {
914            int i;
915            double Norm, PE, PMSE, OMSE, PME, OME;
916    
917            assert(S->Nb>0);
918            Norm = 1. / (double)S->Nb;
919            PE = 0.;
920            for(i=0; i<64; i++) {
921                    if (PE<S->Max_Errors[i])
922                            PE = S->Max_Errors[i];
923            }
924    
925            PMSE = 0.;
926            OMSE = 0.;
927            for(i=0; i<64; i++)
928            {
929                    double Err = Norm * (double)S->Sqr_Errors[i];
930                    OMSE += Err;
931                    if (PMSE < Err) PMSE = Err;
932            }
933            OMSE /= 64.;
934    
935            PME = 0.;
936            OME = 0.;
937            for(i=0; i<64; i++)
938            {
939                    double Err = Norm * (double)S->Errors[i];
940                    OME += Err;
941                    Err = fabs(Err);
942                    if (PME < Err) PME = Err;
943            }
944            OME /= 64.;
945    
946            printf( "Peak error:   %4.4f\n", PE );
947            printf( "Peak MSE:     %4.4f\n", PMSE );
948            printf( "Overall MSE:  %4.4f\n", OMSE );
949            printf( "Peak ME:      %4.4f\n", PME );
950            printf( "Overall ME:   %4.4f\n", OME );
951    
952            if (Limits!=0)
953            {
954                    printf( "[PE<=%.4f %s]  ", Limits[0], CHECK(PE,   Limits[0]) );
955                    printf( "\n" );
956                    printf( "[PMSE<=%.4f %s]", Limits[1], CHECK(PMSE, Limits[1]) );
957                    printf( "[OMSE<=%.4f %s]", Limits[2], CHECK(OMSE, Limits[2]) );
958                    printf( "\n" );
959                    printf( "[PME<=%.4f %s] ", Limits[3], CHECK(PME , Limits[3]) );
960                    printf( "[OME<=%.4f %s] ", Limits[4], CHECK(OME , Limits[4]) );
961                    printf( "\n" );
962            }
963    }
964    
965    ///* ////////////////////////////////////////////////////// */
966    /* Pseudo-random generator specified by IEEE 1180 */
967    
968    static long ieee_seed = 1;
969    static void ieee_reseed(long s) {
970            ieee_seed = s;
971    }
972    static long ieee_rand(int Min, int Max)
973    {
974            static double z = (double) 0x7fffffff;
975    
976            long i,j;
977            double x;
978    
979            ieee_seed = (ieee_seed * 1103515245) + 12345;
980            i = ieee_seed & 0x7ffffffe;
981            x = ((double) i) / z;
982            x *= (Max-Min+1);
983            j = (long)x;
984            j = j + Min;
985            assert(j>=Min && j<=Max);
986            return (short)j;
987    }
988    
989    #define CLAMP(x, M)   (x) = ((x)<-(M)) ? (-(M)) : ((x)>=(M) ? ((M)-1) : (x))
990    
991    static double Cos[8][8];
992    static void init_ref_dct()
993    {
994            int i, j;
995            for(i=0; i<8; i++)
996            {
997                    double scale = (i == 0) ? sqrt(0.125) : 0.5;
998                    for (j=0; j<8; j++)
999                            Cos[i][j] = scale*cos( (M_PI/8.0)*i*(j + 0.5) );
1000            }
1001    }
1002    
1003    void ref_idct(short *M)
1004    {
1005            int i, j, k;
1006            double Tmp[8][8];
1007    
1008            for(i=0; i<8; i++) {
1009                    for(j=0; j<8; j++)
1010                    {
1011                            double Sum = 0.0;
1012                            for (k=0; k<8; k++) Sum += Cos[k][j]*M[8*i+k];
1013                            Tmp[i][j] = Sum;
1014                    }
1015            }
1016            for(i=0; i<8; i++) {
1017                    for(j=0; j<8; j++) {
1018                            double Sum = 0.0;
1019                            for (k=0; k<8; k++) Sum += Cos[k][i]*Tmp[k][j];
1020                            M[8*i+j] = (short)floor(Sum + .5);
1021                    }
1022            }
1023    }
1024    
1025    void ref_fdct(short *M)
1026    {
1027            int i, j, k;
1028            double Tmp[8][8];
1029    
1030            for(i=0; i<8; i++) {
1031                    for(j=0; j<8; j++)
1032                    {
1033                            double Sum = 0.0;
1034                            for (k=0; k<8; k++) Sum += Cos[j][k]*M[8*i+k];
1035                            Tmp[i][j] = Sum;
1036                    }
1037            }
1038            for(i=0; i<8; i++) {
1039                    for(j=0; j<8; j++) {
1040                            double Sum = 0.0;
1041                            for (k=0; k<8; k++) Sum += Cos[i][k]*Tmp[k][j];
1042                            M[8*i+j] = (short)floor(Sum + 0.5);
1043                    }
1044            }
1045    }
1046    
1047    void test_IEEE1180_compliance(int Min, int Max, int Sign)
1048    {
1049            static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };
1050            int Loops = 10000;
1051            int i, m, n;
1052            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1053            DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1054            DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1055            DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
1056            DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
1057    
1058            STATS_8x8 FStats; /* forward dct stats */
1059            STATS_8x8 IStats; /* inverse dct stats */
1060    
1061            CPU *cpu;
1062    
1063            init_ref_dct();
1064    
1065            for(cpu = cpu_list; cpu->name!=0; ++cpu)
1066            {
1067                    if (!init_cpu(cpu))
1068                            continue;
1069    
1070                    printf( "\n===== IEEE test for %s ==== (Min=%d Max=%d Sign=%d Loops=%d)\n",
1071                                    cpu->name, Min, Max, Sign, Loops);
1072    
1073                    init_stats(&IStats);
1074                    init_stats(&FStats);
1075    
1076                    ieee_reseed(1);
1077                    for(n=0; n<Loops; ++n)
1078                    {
1079                            for(i=0; i<64; ++i)
1080                                    Blk0[i] = (short)ieee_rand(Min,Max) * Sign;
1081    
1082                            /* hmm, I'm not quite sure this is exactly */
1083                            /* the tests described in the norm. check... */
1084    
1085                            memcpy(Ref_FDCT, Blk0, 64*sizeof(short));
1086                            ref_fdct(Ref_FDCT);
1087                            for(i=0; i<64; i++) CLAMP( Ref_FDCT[i], 2048 );
1088    
1089                            memcpy(Blk, Blk0, 64*sizeof(short));
1090                            emms(); fdct(Blk); emms();
1091                            for(i=0; i<64; i++) CLAMP( Blk[i], 2048 );
1092    
1093                            store_stats(&FStats, Blk, Ref_FDCT);
1094    
1095    
1096                            memcpy(Ref_IDCT, Ref_FDCT, 64*sizeof(short));
1097                            ref_idct(Ref_IDCT);
1098                            for (i=0; i<64; i++) CLAMP( Ref_IDCT[i], 256 );
1099    
1100                            memcpy(iBlk, Ref_FDCT, 64*sizeof(short));
1101                            emms(); idct(iBlk); emms();
1102                            for(i=0; i<64; i++) CLAMP( iBlk[i], 256 );
1103    
1104                            store_stats(&IStats, iBlk, Ref_IDCT);
1105                    }
1106    
1107    
1108                    printf( "\n  -- FDCT report --\n" );
1109    //    print_stats(&FStats);
1110                    report_stats(&FStats, 0); /* so far I know, IEEE1180 says nothing for fdct */
1111    
1112                    for(i=0; i<64; i++) Blk[i] = 0;
1113                    emms(); fdct(Blk); emms();
1114                    for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
1115                    printf( "FDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1116    
1117                    printf( "\n  -- IDCT report --\n" );
1118    //    print_stats(&IStats);
1119                    report_stats(&IStats, ILimits);
1120    
1121    
1122                    for(i=0; i<64; i++) Blk[i] = 0;
1123                    emms(); idct(Blk); emms();
1124                    for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
1125                    printf( "IDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1126            }
1127    }
1128    
1129    
1130    void test_dct_saturation(int Min, int Max)
1131    {
1132    /* test behaviour on input range fringe */
1133    
1134            int i, n, p;
1135            CPU *cpu;
1136    //  const short IDCT_MAX =  2047;  /* 12bits input */
1137    //  const short IDCT_MIN = -2048;
1138    //  const short IDCT_OUT =   256;  /* 9bits ouput */
1139            const int Partitions = 4;
1140            const int Loops = 10000 / Partitions;
1141    
1142            init_ref_dct();
1143    
1144            for(cpu = cpu_list; cpu->name!=0; ++cpu)
1145            {
1146                    short Blk0[64], Blk[64];
1147                    STATS_8x8 Stats;
1148    
1149                    if (!init_cpu(cpu))
1150                            continue;
1151    
1152                    printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",
1153                                    cpu->name, Min, Max );
1154    
1155                    /* FDCT tests // */
1156    
1157                    init_stats(&Stats);
1158    
1159                    /* test each computation channels separately */
1160                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;
1161                    ref_fdct(Blk0);
1162                    emms(); fdct(Blk); emms();
1163                    store_stats(&Stats, Blk, Blk0);
1164    
1165                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Min : 0;
1166                    ref_fdct(Blk0);
1167                    emms(); fdct(Blk); emms();
1168                    store_stats(&Stats, Blk, Blk0);
1169    
1170                    /* randomly saturated inputs */
1171                    for(p=0; p<Partitions; ++p)
1172                    {
1173                            for(n=0; n<Loops; ++n)
1174                            {
1175                                    for(i=0; i<64; ++i)
1176                                            Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? Max : Min;
1177                                    ref_fdct(Blk0);
1178                                    emms(); fdct(Blk); emms();
1179                                    store_stats(&Stats, Blk, Blk0);
1180                            }
1181                    }
1182                    printf( "\n  -- FDCT saturation report --\n" );
1183                    report_stats(&Stats, 0);
1184    
1185    
1186                    /* IDCT tests // */
1187    #if 0
1188                    /* no finished yet */
1189    
1190                    init_stats(&Stats);
1191    
1192    /* test each computation channel separately */
1193                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 0;
1194                    ref_idct(Blk0);
1195                    emms(); idct(Blk); emms();
1196                    for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1197                    store_stats(&Stats, Blk, Blk0);
1198    
1199                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MIN : 0;
1200                    ref_idct(Blk0);
1201                    emms(); idct(Blk); emms();
1202                    for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1203                    store_stats(&Stats, Blk, Blk0);
1204    
1205                    /* randomly saturated inputs */
1206                    for(p=0; p<Partitions; ++p)
1207                    {
1208                            for(n=0; n<Loops; ++n)
1209                            {
1210                                    for(i=0; i<64; ++i)
1211                                            Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? IDCT_MAX : IDCT_MIN;
1212                                    ref_idct(Blk0);
1213                                    emms(); idct(Blk); emms();
1214                                    for(i=0; i<64; i++) { CLAMP(Blk0[i],IDCT_OUT); CLAMP(Blk[i],IDCT_OUT); }
1215                                    store_stats(&Stats, Blk, Blk0);
1216                            }
1217                    }
1218    
1219                    printf( "\n  -- IDCT saturation report --\n" );
1220                    print_stats(&Stats);
1221                    report_stats(&Stats, 0);
1222    #endif
1223            }
1224    }
1225    
1226    /*********************************************************************
1227   * measure raw decoding speed   * measure raw decoding speed
1228   *********************************************************************/   *********************************************************************/
1229    
# Line 612  Line 1232 
1232    FILE *f = 0;    FILE *f = 0;
1233    void *dechandle = 0;    void *dechandle = 0;
1234    int xerr;    int xerr;
1235          XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
1236          XVID_DEC_PARAM xparam;          xvid_dec_create_t xparam;
1237          XVID_DEC_FRAME xframe;          xvid_dec_frame_t xframe;
1238          double t = 0.;          double t = 0.;
1239          int nb = 0;          int nb = 0;
1240    uint8_t *buf = 0;    uint8_t *buf = 0;
# Line 622  Line 1242 
1242    int buf_size, pos;    int buf_size, pos;
1243    uint32_t chksum = 0;    uint32_t chksum = 0;
1244    
1245          xinit.cpu_flags = 0;          memset(&xinit, 0, sizeof(xinit));
1246          xvid_init(NULL, 0, &xinit, NULL);          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;
1247          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          xinit.version = XVID_VERSION;
1248            xvid_global(NULL, 0, &xinit, NULL);
1249    
1250            memset(&xparam, 0, sizeof(xparam));
1251          xparam.width = width;          xparam.width = width;
1252          xparam.height = height;          xparam.height = height;
1253            xparam.version = XVID_VERSION;
1254          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1255          if (xerr!=XVID_ERR_OK) {          if (xerr==XVID_ERR_FAIL) {
1256            printf("can't init decoder (err=%d)\n", xerr);            printf("can't init decoder (err=%d)\n", xerr);
1257            return;            return;
1258          }          }
# Line 651  Line 1273 
1273    }    }
1274    else printf( "Input size: %d\n", buf_size);    else printf( "Input size: %d\n", buf_size);
1275    
1276    buf = malloc(buf_size); // should be enuf'          buf = malloc(buf_size); /* should be enuf' */
1277    rgb_out = calloc(4, width*height);  // <-room for _RGB24          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */
1278    if (buf==0 || rgb_out==0) {    if (buf==0 || rgb_out==0) {
1279      printf( "malloc failed!\n" );      printf( "malloc failed!\n" );
1280      goto End;      goto End;
# Line 667  Line 1289 
1289    pos = 0;    pos = 0;
1290    t = -gettime_usec();    t = -gettime_usec();
1291    while(1) {    while(1) {
1292                    memset(&xframe, 0, sizeof(xframe));
1293                    xframe.version = XVID_VERSION;
1294      xframe.bitstream = buf + pos;      xframe.bitstream = buf + pos;
1295      xframe.length = buf_size - pos;      xframe.length = buf_size - pos;
1296      xframe.image = rgb_out;                  xframe.output.plane[0] = rgb_out;
1297      xframe.stride = width;                  xframe.output.stride[0] = width;
1298      xframe.colorspace = XVID_CSP_RGB24;                  xframe.output.csp = XVID_CSP_BGR;
1299      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1300      nb++;      nb++;
1301      pos += xframe.length;      pos += xframe.length;
# Line 682  Line 1306 
1306      }      }
1307      if (pos==buf_size)      if (pos==buf_size)
1308        break;        break;
1309      if (xerr!=XVID_ERR_OK) {                  if (xerr==XVID_ERR_FAIL) {
1310            printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);            printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1311            break;            break;
1312          }          }
# Line 698  Line 1322 
1322    if (buf!=0) free(buf);    if (buf!=0) free(buf);
1323    if (dechandle!=0) {    if (dechandle!=0) {
1324      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1325      if (xerr!=XVID_ERR_OK)                  if (xerr==XVID_ERR_FAIL)
1326              printf("destroy-decoder failed (err=%d)!\n", xerr);              printf("destroy-decoder failed (err=%d)!\n", xerr);
1327    }    }
1328    if (f!=0) fclose(f);    if (f!=0) fclose(f);
# Line 711  Line 1335 
1335  void test_bugs1()  void test_bugs1()
1336  {  {
1337    CPU *cpu;    CPU *cpu;
1338            uint16_t mpeg_quant_matrices[64*8];
1339    
1340    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1341    
1342    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1343    {    {
1344      int i;      int i;
1345      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 723  Line 1348 
1348        continue;        continue;
1349    
1350      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1351      set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1352      dequant4_intra(Dst, Src, 32, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1353      printf( "dequant4_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1354      printf( "  Out[]= " );      printf( "  Out[]= " );
1355      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1356      printf( "\n" );      printf( "\n" );
# Line 733  Line 1358 
1358    
1359    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );
1360    
1361    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1362    {    {
1363      int i;      int i;
1364      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 742  Line 1367 
1367        continue;        continue;
1368    
1369      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1370      set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1371      dequant4_inter(Dst, Src, 32);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1372      printf( "dequant4_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1373      printf( "  Out[]= " );      printf( "  Out[]= " );
1374      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1375      printf( "\n" );      printf( "\n" );
# Line 754  Line 1379 
1379  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1380  {  {
1381    CPU *cpu;    CPU *cpu;
1382    short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1383            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1384    
1385    printf( "\n =====  fdct/idct saturation diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1386    
1387    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1388    {    {
1389      int i;      int i;
1390    
# Line 782  Line 1408 
1408    }    }
1409  }  }
1410    
1411    void test_quant_bug()
1412    {
1413            const int max_Q = 31;
1414            int i, n, qm, q;
1415            CPU *cpu;
1416            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1417            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1418            uint8_t Quant[8*8];
1419            CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1420            uint16_t Crcs_Inter[2][32];
1421            uint16_t Crcs_Intra[2][32];
1422            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1423    
1424            printf( "\n =====  test MPEG4-quantize bug =====\n" );
1425    
1426            for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;
1427    
1428    #if 1
1429            for(qm=1; qm<=255; ++qm)
1430            {
1431                    for(i=0; i<8*8; ++i) Quant[i] = qm;
1432                    set_inter_matrix( mpeg_quant_matrices, Quant );
1433    
1434                    for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1435                    {
1436                            uint16_t s;
1437    
1438                            if (!init_cpu(cpu))
1439                                    continue;
1440    
1441                            for(q=1; q<=max_Q; ++q) {
1442                                    emms();
1443                                    quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1444                                    emms();
1445                                    for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1446                                    Crcs_Inter[n][q] = s;
1447                            }
1448                    }
1449    
1450                    for(q=1; q<=max_Q; ++q)
1451                            for(i=0; i<n-1; ++i)
1452                                    if (Crcs_Inter[i][q]!=Crcs_Inter[i+1][q])
1453                                            printf( "Discrepancy Inter: qm=%d, q=%d  -> %d/%d !\n",
1454                                                            qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1455            }
1456    #endif
1457    
1458    #if 1
1459            for(qm=1; qm<=255; ++qm)
1460            {
1461                    for(i=0; i<8*8; ++i) Quant[i] = qm;
1462                    set_intra_matrix( mpeg_quant_matrices, Quant );
1463    
1464                    for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1465                    {
1466                            uint16_t s;
1467    
1468                            if (!init_cpu(cpu))
1469                                    continue;
1470    
1471                            for(q=1; q<=max_Q; ++q) {
1472                                    emms();
1473                                    quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1474                                    emms();
1475                                    for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1476                                    Crcs_Intra[n][q] = s;
1477                            }
1478                    }
1479    
1480                    for(q=1; q<=max_Q; ++q)
1481                            for(i=0; i<n-1; ++i)
1482                                    if (Crcs_Intra[i][q]!=Crcs_Intra[i+1][q])
1483                                            printf( "Discrepancy Intra: qm=%d, q=%d  -> %d/%d!\n",
1484                                                            qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1485            }
1486    #endif
1487    }
1488    
1489  /*********************************************************************  /*********************************************************************
1490   * main   * main
# Line 798  Line 1501 
1501    if (what==0 || what==5) test_quant();    if (what==0 || what==5) test_quant();
1502    if (what==0 || what==6) test_cbp();    if (what==0 || what==6) test_cbp();
1503    
1504    if (what==8) {          if (what==7) {
1505                    test_IEEE1180_compliance(-256, 255, 1);
1506                    test_IEEE1180_compliance(-256, 255,-1);
1507                    test_IEEE1180_compliance(  -5,   5, 1);
1508                    test_IEEE1180_compliance(  -5,   5,-1);
1509                    test_IEEE1180_compliance(-300, 300, 1);
1510                    test_IEEE1180_compliance(-300, 300,-1);
1511            }
1512            if (what==8) test_dct_saturation(-256, 255);
1513    
1514            if (what==9) {
1515      int width, height;      int width, height;
1516      if (argc<5) {      if (argc<5) {
1517        printf("usage: %s %d [bitstream] [width] [height]\n", argv[0], what);        printf("usage: %s %d [bitstream] [width] [height]\n", argv[0], what);
# Line 810  Line 1523 
1523    }    }
1524    
1525    if (what==-1) {    if (what==-1) {
     test_bugs1();  
1526      test_dct_precision_diffs();      test_dct_precision_diffs();
1527                    test_bugs1();
1528    }    }
1529            if (what==-2)
1530                    test_quant_bug();
1531    
1532            if (what >= 0 && what <= 6) {
1533                    printf("\n\n"
1534                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1535                               "    a C function is used instead. So don't panic if some functions\n"
1536                               "    may appear to be slow.\n");
1537            }
1538    
1539    #ifdef ARCH_IS_IA32
1540            if (what == 0 || what == 5) {
1541                    printf("\n"
1542                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1543                               "    for 1 or 2 coefficients a block. This is mainly caused by the fact the unit\n"
1544                               "    test goes far behind the usual limits of real encoding. Please do not report\n"
1545                               "    this error to the developers.\n");
1546            }
1547    #endif
1548    
1549    return 0;    return 0;
1550  }  }
1551    
1552  /*********************************************************************  /*********************************************************************
1553   * 'Reference' output (except for timing) on a PIII 1.13Ghz/linux   * 'Reference' output (except for timing) on an Athlon XP 2200+
1554   *********************************************************************/   *********************************************************************/
1555  /*  
1556    /* as of 2002-01-07, there's a problem with MMX mpeg4-quantization */
1557    /* as of 2003-11-30, the problem is still here */
1558    
1559    /*********************************************************************
1560    
1561    
1562   ===== test fdct/idct =====   ===== test fdct/idct =====
1563  PLAINC -  2.631 usec       iCrc=3  fCrc=-85  PLAINC -  2.867 usec       PSNR=13.291  MSE=3.000
1564  MMX    -  0.596 usec       iCrc=3  fCrc=-67  MMX    -  -0.211 usec       PSNR=9.611  MSE=7.000
1565  MMXEXT -  0.608 usec       iCrc=3  fCrc=-67  MMXEXT -  -0.256 usec       PSNR=9.611  MSE=7.000
1566  SSE2   -  0.605 usec       iCrc=3  fCrc=-67  3DNOW  -  2.855 usec       PSNR=13.291  MSE=3.000
1567  3DNOW  - skipped...  3DNOWE -  1.429 usec       PSNR=13.291  MSE=3.000
 3DNOWE - skipped...  
1568    
1569   ===  test block motion ===   ===  test block motion ===
1570  PLAINC - interp- h-round0 1.031 usec       iCrc=8107  PLAINC - interp- h-round0 0.538 usec       crc32=0x115381ba
1571  PLAINC -           round1 1.022 usec       iCrc=8100  PLAINC -           round1 0.527 usec       crc32=0x2b1f528f
1572  PLAINC - interp- v-round0 1.002 usec       iCrc=8108  PLAINC - interp- v-round0 0.554 usec       crc32=0x423cdcc7
1573  PLAINC -           round1 1.011 usec       iCrc=8105  PLAINC -           round1 0.551 usec       crc32=0x42202efe
1574  PLAINC - interp-hv-round0 1.623 usec       iCrc=8112  PLAINC - interp-hv-round0 1.041 usec       crc32=0xd198d387
1575  PLAINC -           round1 1.621 usec       iCrc=8103  PLAINC -           round1 1.038 usec       crc32=0x9ecfd921
1576  PLAINC - interpolate8x8_c 0.229 usec       iCrc=8107   ---
1577   ---  MMX    - interp- h-round0 0.051 usec       crc32=0x115381ba
1578  MMX    - interp- h-round0 0.105 usec       iCrc=8107  MMX    -           round1 0.053 usec       crc32=0x2b1f528f
1579  MMX    -           round1 0.105 usec       iCrc=8100  MMX    - interp- v-round0 0.048 usec       crc32=0x423cdcc7
1580  MMX    - interp- v-round0 0.106 usec       iCrc=8108  MMX    -           round1 0.048 usec       crc32=0x42202efe
1581  MMX    -           round1 0.107 usec       iCrc=8105  MMX    - interp-hv-round0 0.074 usec       crc32=0xd198d387
1582  MMX    - interp-hv-round0 0.145 usec       iCrc=8112  MMX    -           round1 0.073 usec       crc32=0x9ecfd921
1583  MMX    -           round1 0.145 usec       iCrc=8103   ---
1584  MMX    - interpolate8x8_c 0.229 usec       iCrc=8107  MMXEXT - interp- h-round0 0.020 usec       crc32=0x115381ba
1585   ---  MMXEXT -           round1 0.025 usec       crc32=0x2b1f528f
1586  MMXEXT - interp- h-round0 0.027 usec       iCrc=8107  MMXEXT - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1587  MMXEXT -           round1 0.041 usec       iCrc=8100  MMXEXT -           round1 0.024 usec       crc32=0x42202efe
1588  MMXEXT - interp- v-round0 0.027 usec       iCrc=8108  MMXEXT - interp-hv-round0 0.037 usec       crc32=0xd198d387
1589  MMXEXT -           round1 0.040 usec       iCrc=8105  MMXEXT -           round1 0.037 usec       crc32=0x9ecfd921
1590  MMXEXT - interp-hv-round0 0.070 usec       iCrc=8112   ---
1591  MMXEXT -           round1 0.066 usec       iCrc=8103  3DNOW  - interp- h-round0 0.020 usec       crc32=0x115381ba
1592  MMXEXT - interpolate8x8_c 0.027 usec       iCrc=8107  3DNOW  -           round1 0.029 usec       crc32=0x2b1f528f
1593   ---  3DNOW  - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1594  SSE2   - interp- h-round0 0.106 usec       iCrc=8107  3DNOW  -           round1 0.024 usec       crc32=0x42202efe
1595  SSE2   -           round1 0.105 usec       iCrc=8100  3DNOW  - interp-hv-round0 0.038 usec       crc32=0xd198d387
1596  SSE2   - interp- v-round0 0.106 usec       iCrc=8108  3DNOW  -           round1 0.039 usec       crc32=0x9ecfd921
1597  SSE2   -           round1 0.106 usec       iCrc=8105   ---
1598  SSE2   - interp-hv-round0 0.145 usec       iCrc=8112  3DNOWE - interp- h-round0 0.020 usec       crc32=0x115381ba
1599  SSE2   -           round1 0.145 usec       iCrc=8103  3DNOWE -           round1 0.024 usec       crc32=0x2b1f528f
1600  SSE2   - interpolate8x8_c 0.237 usec       iCrc=8107  3DNOWE - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1601    3DNOWE -           round1 0.021 usec       crc32=0x42202efe
1602    3DNOWE - interp-hv-round0 0.037 usec       crc32=0xd198d387
1603    3DNOWE -           round1 0.036 usec       crc32=0x9ecfd921
1604   ---   ---
 3DNOW  - skipped...  
 3DNOWE - skipped...  
1605    
1606   ======  test SAD ======   ======  test SAD ======
1607  PLAINC - sad8    0.296 usec       sad=3776  PLAINC - sad8    0.505 usec       sad=3776
1608  PLAINC - sad16   1.599 usec       sad=27214  PLAINC - sad16   1.941 usec       sad=27214
1609  PLAINC - sad16bi 2.350 usec       sad=26274  PLAINC - sad16bi 4.925 usec       sad=26274
1610  PLAINC - dev16   1.610 usec       sad=3344  PLAINC - dev16   4.254 usec       sad=3344
1611   ---   ---
1612  MMX    - sad8    0.057 usec       sad=3776  MMX    - sad8    0.036 usec       sad=3776
1613  MMX    - sad16   0.178 usec       sad=27214  MMX    - sad16   0.107 usec       sad=27214
1614  MMX    - sad16bi 2.381 usec       sad=26274  MMX    - sad16bi 0.259 usec       sad=26274
1615  MMX    - dev16   0.312 usec       sad=3344  MMX    - dev16   0.187 usec       sad=3344
1616   ---   ---
1617  MMXEXT - sad8    0.036 usec       sad=3776  MMXEXT - sad8    0.016 usec       sad=3776
1618  MMXEXT - sad16   0.106 usec       sad=27214  MMXEXT - sad16   0.050 usec       sad=27214
1619  MMXEXT - sad16bi 0.182 usec       sad=26274  MMXEXT - sad16bi 0.060 usec       sad=26274
1620  MMXEXT - dev16   0.193 usec       sad=3344  MMXEXT - dev16   0.086 usec       sad=3344
1621   ---   ---
1622  SSE2   - sad8    0.057 usec       sad=3776  3DNOW  - sad8    0.506 usec       sad=3776
1623  SSE2   - sad16   0.178 usec       sad=27214  3DNOW  - sad16   1.954 usec       sad=27214
1624  SSE2   - sad16bi 2.427 usec       sad=26274  3DNOW  - sad16bi 0.119 usec       sad=26274
1625  SSE2   - dev16   0.313 usec       sad=3344  3DNOW  - dev16   4.252 usec       sad=3344
1626     ---
1627    3DNOWE - sad8    0.017 usec       sad=3776
1628    3DNOWE - sad16   0.038 usec       sad=27214
1629    3DNOWE - sad16bi 0.052 usec       sad=26274
1630    3DNOWE - dev16   0.067 usec       sad=3344
1631   ---   ---
 3DNOW  - skipped...  
 3DNOWE - skipped...  
1632    
1633   ===  test transfer ===   ===  test transfer ===
1634  PLAINC - 8to16     0.124 usec       crc=28288  PLAINC - 8to16     0.603 usec       crc32=0x115814bb
1635  PLAINC - 16to8     0.753 usec       crc=28288  PLAINC - 16to8     1.077 usec       crc32=0xee7ccbb4
1636  PLAINC - 8to8      0.041 usec       crc=20352  PLAINC - 8to8      0.679 usec       crc32=0xd37b3295
1637  PLAINC - 16to8add  0.916 usec       crc=25536  PLAINC - 16to8add  1.341 usec       crc32=0xdd817bf4
1638  PLAINC - 8to16sub  0.812 usec       crc1=28064 crc2=16256  PLAINC - 8to16sub  1.566 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1639  PLAINC - 8to16sub2 0.954 usec       crc=20384  PLAINC - 8to16sub2 2.206 usec       crc32=0x99b6c4c7
1640   ---   ---
1641  MMX    - 8to16     0.037 usec       crc=28288  MMX    - 8to16     -0.025 usec       crc32=0x115814bb
1642  MMX    - 16to8     0.016 usec       crc=28288  MMX    - 16to8     -0.049 usec       crc32=0xee7ccbb4
1643  MMX    - 8to8      0.018 usec       crc=20352  MMX    - 8to8      0.014 usec       crc32=0xd37b3295
1644  MMX    - 16to8add  0.044 usec       crc=25536  MMX    - 16to8add  0.011 usec       crc32=0xdd817bf4
1645  MMX    - 8to16sub  0.065 usec       crc1=28064 crc2=16256  MMX    - 8to16sub  0.108 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1646  MMX    - 8to16sub2 0.110 usec       crc=20384  MMX    - 8to16sub2 0.164 usec       crc32=0x99b6c4c7
1647   ---   ---
1648  MMXEXT - 8to16     0.032 usec       crc=28288  MMXEXT - 8to16     -0.054 usec       crc32=0x115814bb
1649  MMXEXT - 16to8     0.023 usec       crc=28288  MMXEXT - 16to8     0.010 usec       crc32=0xee7ccbb4
1650  MMXEXT - 8to8      0.018 usec       crc=20352  MMXEXT - 8to8      0.015 usec       crc32=0xd37b3295
1651  MMXEXT - 16to8add  0.041 usec       crc=25536  MMXEXT - 16to8add  0.008 usec       crc32=0xdd817bf4
1652  MMXEXT - 8to16sub  0.065 usec       crc1=28064 crc2=16256  MMXEXT - 8to16sub  0.263 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1653  MMXEXT - 8to16sub2 0.069 usec       crc=20384  MMXEXT - 8to16sub2 0.178 usec       crc32=0x99b6c4c7
1654     ---
1655    3DNOW  - 8to16     0.666 usec       crc32=0x115814bb
1656    3DNOW  - 16to8     1.078 usec       crc32=0xee7ccbb4
1657    3DNOW  - 8to8      0.665 usec       crc32=0xd37b3295
1658    3DNOW  - 16to8add  1.365 usec       crc32=0xdd817bf4
1659    3DNOW  - 8to16sub  1.356 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1660    3DNOW  - 8to16sub2 2.098 usec       crc32=0x99b6c4c7
1661     ---
1662    3DNOWE - 8to16     -0.024 usec       crc32=0x115814bb
1663    3DNOWE - 16to8     0.010 usec       crc32=0xee7ccbb4
1664    3DNOWE - 8to8      0.014 usec       crc32=0xd37b3295
1665    3DNOWE - 16to8add  0.016 usec       crc32=0xdd817bf4
1666    3DNOWE - 8to16sub  -0.000 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1667    3DNOWE - 8to16sub2 -0.031 usec       crc32=0x99b6c4c7
1668   ---   ---
1669    
1670   =====  test quant =====   =====  test quant =====
1671  PLAINC -   quant4_intra 78.889 usec       crc=55827  PLAINC -   quant_mpeg_intra 98.631 usec       crc32=0xfd6a21a4
1672  PLAINC -   quant4_inter 71.957 usec       crc=58201  PLAINC -   quant_mpeg_inter 104.876 usec       crc32=0xf6de7757
1673  PLAINC - dequant4_intra 34.968 usec       crc=193340  PLAINC - dequant_mpeg_intra 50.285 usec       crc32=0x2def7bc7
1674  PLAINC - dequant4_inter 40.792 usec       crc=116483  PLAINC - dequant_mpeg_inter 58.316 usec       crc32=0xd878c722
1675  PLAINC -    quant_intra 30.845 usec       crc=56885  PLAINC -   quant_h263_intra 33.803 usec       crc32=0x2eba9d43
1676  PLAINC -    quant_inter 34.842 usec       crc=58056  PLAINC -   quant_h263_inter 45.411 usec       crc32=0xbd315a7e
1677  PLAINC -  dequant_intra 33.211 usec       crc=-7936  PLAINC - dequant_h263_intra 39.302 usec       crc32=0x9841212a
1678  PLAINC -  dequant_inter 45.486 usec       crc=-33217  PLAINC - dequant_h263_inter 44.124 usec       crc32=0xe7df8fba
1679   ---   ---
1680  MMX    -   quant4_intra 9.030 usec       crc=55827  MMX    -   quant_mpeg_intra 4.273 usec       crc32=0xdacabdb6 | ERROR
1681  MMX    -   quant4_inter 8.234 usec       crc=58201  MMX    -   quant_mpeg_inter 3.576 usec       crc32=0x72883ab6 | ERROR
1682  MMX    - dequant4_intra 18.330 usec       crc=193340  MMX    - dequant_mpeg_intra 3.793 usec       crc32=0x2def7bc7
1683  MMX    - dequant4_inter 19.181 usec       crc=116483  MMX    - dequant_mpeg_inter 4.808 usec       crc32=0xd878c722
1684  MMX    -    quant_intra 7.124 usec       crc=56885  MMX    -   quant_h263_intra 2.881 usec       crc32=0x2eba9d43
1685  MMX    -    quant_inter 6.861 usec       crc=58056  MMX    -   quant_h263_inter 2.550 usec       crc32=0xbd315a7e
1686  MMX    -  dequant_intra 9.048 usec       crc=-7936  MMX    - dequant_h263_intra 2.974 usec       crc32=0x9841212a
1687  MMX    -  dequant_inter 8.203 usec       crc=-33217  MMX    - dequant_h263_inter 2.906 usec       crc32=0xe7df8fba
1688   ---   ---
1689  MMXEXT -   quant4_intra 9.045 usec       crc=55827  MMXEXT -   quant_mpeg_intra 4.221 usec       crc32=0xfd6a21a4
1690  MMXEXT -   quant4_inter 8.232 usec       crc=58201  MMXEXT -   quant_mpeg_inter 4.339 usec       crc32=0xf6de7757
1691  MMXEXT - dequant4_intra 18.250 usec       crc=193340  MMXEXT - dequant_mpeg_intra 3.802 usec       crc32=0x2def7bc7
1692  MMXEXT - dequant4_inter 19.256 usec       crc=116483  MMXEXT - dequant_mpeg_inter 4.821 usec       crc32=0xd878c722
1693  MMXEXT -    quant_intra 7.121 usec       crc=56885  MMXEXT -   quant_h263_intra 2.884 usec       crc32=0x2eba9d43
1694  MMXEXT -    quant_inter 6.855 usec       crc=58056  MMXEXT -   quant_h263_inter 2.554 usec       crc32=0xbd315a7e
1695  MMXEXT -  dequant_intra 9.034 usec       crc=-7936  MMXEXT - dequant_h263_intra 2.728 usec       crc32=0x9841212a
1696  MMXEXT -  dequant_inter 8.202 usec       crc=-33217  MMXEXT - dequant_h263_inter 2.611 usec       crc32=0xe7df8fba
1697     ---
1698    3DNOW  -   quant_mpeg_intra 98.512 usec       crc32=0xfd6a21a4
1699    3DNOW  -   quant_mpeg_inter 104.873 usec       crc32=0xf6de7757
1700    3DNOW  - dequant_mpeg_intra 50.219 usec       crc32=0x2def7bc7
1701    3DNOW  - dequant_mpeg_inter 58.254 usec       crc32=0xd878c722
1702    3DNOW  -   quant_h263_intra 33.778 usec       crc32=0x2eba9d43
1703    3DNOW  -   quant_h263_inter 41.998 usec       crc32=0xbd315a7e
1704    3DNOW  - dequant_h263_intra 39.344 usec       crc32=0x9841212a
1705    3DNOW  - dequant_h263_inter 43.607 usec       crc32=0xe7df8fba
1706     ---
1707    3DNOWE -   quant_mpeg_intra 98.490 usec       crc32=0xfd6a21a4
1708    3DNOWE -   quant_mpeg_inter 104.889 usec       crc32=0xf6de7757
1709    3DNOWE - dequant_mpeg_intra 3.277 usec       crc32=0x2def7bc7
1710    3DNOWE - dequant_mpeg_inter 4.485 usec       crc32=0xd878c722
1711    3DNOWE -   quant_h263_intra 1.882 usec       crc32=0x2eba9d43
1712    3DNOWE -   quant_h263_inter 2.246 usec       crc32=0xbd315a7e
1713    3DNOWE - dequant_h263_intra 3.457 usec       crc32=0x9841212a
1714    3DNOWE - dequant_h263_inter 3.275 usec       crc32=0xe7df8fba
1715   ---   ---
1716    
1717   =====  test cbp =====   =====  test cbp =====
1718  PLAINC -   calc_cbp#1 0.545 usec       cbp=0x15  PLAINC -   calc_cbp#1 0.168 usec       cbp=0x15
1719  PLAINC -   calc_cbp#2 0.540 usec       cbp=0x38  PLAINC -   calc_cbp#2 0.168 usec       cbp=0x38
1720  PLAINC -   calc_cbp#3 0.477 usec       cbp=0xf  PLAINC -   calc_cbp#3 0.157 usec       cbp=0x0f
1721  PLAINC -   calc_cbp#4 0.739 usec       cbp=0x5  PLAINC -   calc_cbp#4 0.235 usec       cbp=0x05
  ---  
 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  
1722   ---   ---
1723  */  MMX    -   calc_cbp#1 0.070 usec       cbp=0x15
1724    MMX    -   calc_cbp#2 0.062 usec       cbp=0x38
1725    MMX    -   calc_cbp#3 0.062 usec       cbp=0x0f
1726    MMX    -   calc_cbp#4 0.061 usec       cbp=0x05
1727     ---
1728    MMXEXT -   calc_cbp#1 0.062 usec       cbp=0x15
1729    MMXEXT -   calc_cbp#2 0.061 usec       cbp=0x38
1730    MMXEXT -   calc_cbp#3 0.061 usec       cbp=0x0f
1731    MMXEXT -   calc_cbp#4 0.061 usec       cbp=0x05
1732     ---
1733    3DNOW  -   calc_cbp#1 0.168 usec       cbp=0x15
1734    3DNOW  -   calc_cbp#2 0.168 usec       cbp=0x38
1735    3DNOW  -   calc_cbp#3 0.157 usec       cbp=0x0f
1736    3DNOW  -   calc_cbp#4 0.238 usec       cbp=0x05
1737     ---
1738    3DNOWE -   calc_cbp#1 0.049 usec       cbp=0x15
1739    3DNOWE -   calc_cbp#2 0.049 usec       cbp=0x38
1740    3DNOWE -   calc_cbp#3 0.049 usec       cbp=0x0f
1741    3DNOWE -   calc_cbp#4 0.049 usec       cbp=0x05
1742     ---
1743    
1744    
1745    NB: If a function isn't optimised for a specific set of intructions,
1746        a C function is used instead. So don't panic if some functions
1747        may appear to be slow.
1748    
1749    NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)
1750        for 1 or 2 coefficients a block. This is mainly caused by the fact the unit
1751        test goes far behind the usual limits of real encoding. Please do not report
1752        this error to the developers
1753    
1754    *********************************************************************/
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.9.2.11
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4