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