[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 1382, Mon Mar 22 22:36:25 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.11 2004-03-22 22:36:23 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    //, { "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  , { 0, 0 } }  #endif
134    //, { "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 145  Line 286 
286    int tst;    int tst;
287    CPU *cpu;    CPU *cpu;
288    int i;    int i;
289    short iDst0[8*8], iDst[8*8], fDst[8*8];          DECLARE_ALIGNED_MATRIX(iDst0, 8, 8, short, 16);
290            DECLARE_ALIGNED_MATRIX(iDst,  8, 8, short, 16);
291            DECLARE_ALIGNED_MATRIX(fDst,  8, 8, short, 16);
292    double overhead;    double overhead;
293    
294    printf( "\n ===== test fdct/idct =====\n" );    printf( "\n ===== test fdct/idct =====\n" );
# Line 161  Line 304 
304    
305    for(cpu = cpu_list; cpu->name!=0; ++cpu)    for(cpu = cpu_list; cpu->name!=0; ++cpu)
306    {    {
307      double t;                  double t, PSNR, MSE;
     int iCrc, fCrc;  
308    
309      if (!init_cpu(cpu))      if (!init_cpu(cpu))
310        continue;        continue;
# Line 178  Line 320 
320      }      }
321      emms();      emms();
322      t = (gettime_usec() - t - overhead) / nb_tests;      t = (gettime_usec() - t - overhead) / nb_tests;
323      iCrc=0; fCrc=0;                  MSE = 0.;
324      for(i=0; i<8*8; ++i) {      for(i=0; i<8*8; ++i) {
325        iCrc += ABS(iDst[i] - iDst0[i]);                          double delta = 1.0*(iDst[i] - iDst0[i]);
326        fCrc += fDst[i]^i;                          MSE += delta*delta;
327      }      }
328      printf( "%s -  %.3f usec       iCrc=%d  fCrc=%d\n",                  PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
329        cpu->name, t, iCrc, fCrc );                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
330        // the norm tolerates ~1 bit of diff per coeff                                  cpu->name, t, PSNR, MSE,
331      if (ABS(iCrc)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
332    }    }
333  }  }
334    
# Line 200  Line 342 
342    int tst;    int tst;
343    CPU *cpu;    CPU *cpu;
344    int i;    int i;
345    uint8_t Cur[16*16], Ref1[16*16], Ref2[16*16];          DECLARE_ALIGNED_MATRIX(Cur,  16, 16, uint8_t, 16);
346            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
347            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
348    
349    printf( "\n ======  test SAD ======\n" );    printf( "\n ======  test SAD ======\n" );
350    for(i=0; i<16*16;++i) {    for(i=0; i<16*16;++i) {
# Line 221  Line 365 
365      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
366      emms();      emms();
367      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
368      printf( "%s - sad8    %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad8    %.3f usec       sad=%d %s\n",
369      if (s!=3776) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
370                               (s!=3776)?"| ERROR": "" );
371    
372      t = gettime_usec();      t = gettime_usec();
373      emms();      emms();
374      for(tst=0; tst<nb_tests; ++tst) s = sad16(Cur, Ref1, 16, -1);      for(tst=0; tst<nb_tests; ++tst) s = sad16(Cur, Ref1, 16, -1);
375      emms();      emms();
376      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
377      printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad16   %.3f usec       sad=%d %s\n",
378      if (s!=27214) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
379                               (s!=27214)?"| ERROR": "" );
380    
381      t = gettime_usec();      t = gettime_usec();
382      emms();      emms();
383      for(tst=0; tst<nb_tests; ++tst) s = sad16bi(Cur, Ref1, Ref2, 16);      for(tst=0; tst<nb_tests; ++tst) s = sad16bi(Cur, Ref1, Ref2, 16);
384      emms();      emms();
385      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
386      printf( "%s - sad16bi %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - sad16bi %.3f usec       sad=%d %s\n",
387      if (s!=26274) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
388                                    (s!=26274)?"| ERROR": "" );
389    
390      t = gettime_usec();      t = gettime_usec();
391      emms();      emms();
392      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
393      emms();      emms();
394      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
395      printf( "%s - dev16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - dev16   %.3f usec       sad=%d %s\n",
396      if (s!=3344) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
397                                    (s!=3344)?"| ERROR": "" );
398    
399      printf( " --- \n" );      printf( " --- \n" );
400    }    }
# Line 264  Line 412 
412  #define LEAVE \  #define LEAVE \
413      emms();                             \      emms();                             \
414      t = (gettime_usec() - t) / nb_tests;  \      t = (gettime_usec() - t) / nb_tests;  \
415      iCrc = 0;                           \          iCrc = calc_crc((uint8_t*)Dst, sizeof(Dst), CRC32_INITIAL)
     for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }  
416    
417  #define TEST_MB(FUNC, R)                \  #define TEST_MB(FUNC, R)                \
418      ENTER                               \      ENTER                               \
# Line 283  Line 430 
430    const int nb_tests = 2000*speed_ref;    const int nb_tests = 2000*speed_ref;
431    CPU *cpu;    CPU *cpu;
432    const uint8_t Src0[16*9] = {    const uint8_t Src0[16*9] = {
433          // try to have every possible combinaison of rounding...                  /* try to have every possible combinaison of rounding... */
434        0, 0, 1, 0, 2, 0, 3, 0, 4             ,0,0,0, 0,0,0,0                  0, 0, 1, 0, 2, 0, 3, 0, 4             ,0,0,0, 0,0,0,0,
435      , 0, 1, 1, 1, 2, 1, 3, 1, 3             ,0,0,0, 0,0,0,0                  0, 1, 1, 1, 2, 1, 3, 1, 3             ,0,0,0, 0,0,0,0,
436      , 0, 2, 1, 2, 2, 2, 3, 2, 2             ,0,0,0, 0,0,0,0                  0, 2, 1, 2, 2, 2, 3, 2, 2             ,0,0,0, 0,0,0,0,
437      , 0, 3, 1, 3, 2, 3, 3, 3, 1             ,0,0,0, 0,0,0,0                  0, 3, 1, 3, 2, 3, 3, 3, 1             ,0,0,0, 0,0,0,0,
438      , 1, 3, 0, 2, 1, 0, 2, 3, 4             ,0,0,0, 0,0,0,0                  1, 3, 0, 2, 1, 0, 2, 3, 4             ,0,0,0, 0,0,0,0,
439      , 2, 2, 1, 2, 0, 1, 3, 5, 3             ,0,0,0, 0,0,0,0                  2, 2, 1, 2, 0, 1, 3, 5, 3             ,0,0,0, 0,0,0,0,
440      , 3, 1, 2, 3, 1, 2, 2, 6, 2             ,0,0,0, 0,0,0,0                  3, 1, 2, 3, 1, 2, 2, 6, 2             ,0,0,0, 0,0,0,0,
441      , 1, 0, 1, 3, 0, 3, 1, 6, 1             ,0,0,0, 0,0,0,0                  1, 0, 1, 3, 0, 3, 1, 6, 1             ,0,0,0, 0,0,0,0,
442      , 4, 3, 2, 1, 2, 3, 4, 0, 3             ,0,0,0, 0,0,0,0                  4, 3, 2, 1, 2, 3, 4, 0, 3             ,0,0,0, 0,0,0,0
443    };    };
444    uint8_t Dst[16*8] = {0};    uint8_t Dst[16*8] = {0};
445    
# Line 307  Line 454 
454        continue;        continue;
455    
456      TEST_MB(interpolate8x8_halfpel_h, 0);      TEST_MB(interpolate8x8_halfpel_h, 0);
457      printf( "%s - interp- h-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp- h-round0 %.3f usec       crc32=0x%08x %s\n",
458      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
459                               (iCrc!=0x115381ba)?"| ERROR": "" );
460    
461      TEST_MB(interpolate8x8_halfpel_h, 1);      TEST_MB(interpolate8x8_halfpel_h, 1);
462      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
463      if (iCrc!=8100) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
464                               (iCrc!=0x2b1f528f)?"| ERROR": "" );
465    
466    
467      TEST_MB(interpolate8x8_halfpel_v, 0);      TEST_MB(interpolate8x8_halfpel_v, 0);
468      printf( "%s - interp- v-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp- v-round0 %.3f usec       crc32=0x%08x %s\n",
469      if (iCrc!=8108) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
470                               (iCrc!=0x423cdcc7)?"| ERROR": "" );
471    
472      TEST_MB(interpolate8x8_halfpel_v, 1);      TEST_MB(interpolate8x8_halfpel_v, 1);
473      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
474      if (iCrc!=8105) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
475                               (iCrc!=0x42202efe)?"| ERROR": "" );
476    
477    
478      TEST_MB(interpolate8x8_halfpel_hv, 0);      TEST_MB(interpolate8x8_halfpel_hv, 0);
479      printf( "%s - interp-hv-round0 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interp-hv-round0 %.3f usec       crc32=0x%08x %s\n",
480      if (iCrc!=8112) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
481                               (iCrc!=0xd198d387)?"| ERROR": "" );
482    
483      TEST_MB(interpolate8x8_halfpel_hv, 1);      TEST_MB(interpolate8x8_halfpel_hv, 1);
484      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
485      if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
486                               (iCrc!=0x9ecfd921)?"| ERROR": "" );
487    
488    
489                    /* this is a new function, as of 06.06.2002 */
490    #if 0
491                    TEST_MB2(interpolate8x8_avrg);
492                    printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
493                               cpu->name, t, iCrc,
494                               (iCrc!=8107)?"| ERROR": "" );
495    #endif
496    
497      printf( " --- \n" );      printf( " --- \n" );
498    }    }
# Line 365  Line 527 
527      }                                         \      }                                         \
528      emms();                                   \      emms();                                   \
529      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
530      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]^i; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
531    
532  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
533      TEST_TRANSFER_BEGIN(DST);                 \      TEST_TRANSFER_BEGIN(DST);                 \
# Line 391  Line 553 
553      }                                         \      }                                         \
554      emms();                                   \      emms();                                   \
555      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
556      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
557    
558  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
559      TEST_TRANSFER2_BEGIN(DST,SRC);            \      TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 413  Line 575 
575    
576    printf( "\n ===  test transfer ===\n" );    printf( "\n ===  test transfer ===\n" );
577    
578    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
579    {    {
580      double t, overhead;      double t, overhead;
581      int tst, s;      int tst, s;
# Line 422  Line 584 
584        continue;        continue;
585    
586      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
587      printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
588      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
589                               (s!=0x115814bb)?"| ERROR": "");
590    
591      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
592      printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
593      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
594                                    (s!=0xee7ccbb4)?"| ERROR": "");
595    
596      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
597      printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
598      if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
599                               (s!=0xd37b3295)?"| ERROR": "");
600    
601      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
602      printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
603      if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
604                               (s!=0xdd817bf4)?"| ERROR": "" );
605    
606      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
607      printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
608      if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
609      s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }                          s1 = calc_crc((uint8_t*)Dst16, sizeof(Dst16), CRC32_INITIAL);
610      printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, sizeof(Src8), CRC32_INITIAL);
611      if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
612                                       cpu->name, t, s1, s2,
613                                       (s1!=0xa1e07163)?"| ERROR1": "",
614                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
615                    }
616    
617      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
618      printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
619      if (s!=20384) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
620                               (s!=0x99b6c4c7)?"| ERROR": "" );
621    
622      printf( " --- \n" );      printf( " --- \n" );
623    }    }
# Line 458  Line 629 
629    
630  #define TEST_QUANT(FUNC, DST, SRC)            \  #define TEST_QUANT(FUNC, DST, SRC)            \
631      t = gettime_usec();                       \      t = gettime_usec();                       \
632    for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
633      for(i=0; i<8*8; ++i) Quant[i] = qm;       \
634      set_inter_matrix( mpeg_quant_matrices, Quant );                \
635      emms();                                   \      emms();                                   \
636      for(q=1; q<=max_Q; ++q) {                 \
637      for(tst=0; tst<nb_tests; ++tst)           \      for(tst=0; tst<nb_tests; ++tst)           \
638        for(s=0, q=1; q<=max_Q; ++q) {          \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
639          (FUNC)((DST), (SRC), q);              \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
         for(i=0; i<64; ++i) s+=(DST)[i]^i;    \  
640        }                                       \        }                                       \
641      emms();                                   \      emms();                                   \
642      t = (gettime_usec()-t-overhead)/nb_tests;  }                                           \
643    t = (gettime_usec()-t-overhead)/nb_tests/qm
644    
645  #define TEST_QUANT2(FUNC, DST, SRC, MULT)     \  #define TEST_QUANT2(FUNC, DST, SRC)             \
646      t = gettime_usec();                       \      t = gettime_usec();                       \
647    for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
648      for(i=0; i<8*8; ++i) Quant[i] = qm;       \
649      set_intra_matrix( mpeg_quant_matrices, Quant );                \
650      emms();                                   \      emms();                                   \
651      for(q=1; q<=max_Q; ++q) {                 \
652      for(tst=0; tst<nb_tests; ++tst)           \      for(tst=0; tst<nb_tests; ++tst)           \
653        for(s=0, q=1; q<=max_Q; ++q) {          \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
654          (FUNC)((DST), (SRC), q, MULT);        \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
         for(i=0; i<64; ++i) s+=(DST)[i]^i;    \  
655        }                                       \        }                                       \
656      emms();                                   \      emms();                                   \
657      t = (gettime_usec()-t-overhead)/nb_tests;  }                                           \
658    t = (gettime_usec()-t-overhead)/nb_tests/qm
659    
660  void test_quant()  void test_quant()
661  {  {
662    const int nb_tests = 150*speed_ref;          const int nb_tests = 1*speed_ref;
663    const int max_Q = 31;    const int max_Q = 31;
664    int i;          DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
665    
666            int i, qm;
667    CPU *cpu;    CPU *cpu;
668    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
669            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
670            uint8_t Quant[8*8];
671    
672    printf( "\n =====  test quant =====\n" );    printf( "\n =====  test quant =====\n" );
673    
674    /* we deliberately enfringe the norm's specified range [-127,127], */
675    /* to test the robustness of the iquant module */
676    for(i=0; i<64; ++i) {    for(i=0; i<64; ++i) {
677      Src[i] = i-32;                  Src[i] = 1 + (i-32) * (i&6);
678      Dst[i] = 0;      Dst[i] = 0;
679    }    }
680    
681            for(cpu = cpu_list; cpu->name!=0; ++cpu)
   for(cpu = cpu_short_list; cpu->name!=0; ++cpu)  
682    {    {
683      double t, overhead;      double t, overhead;
684      int tst, s, q;                  int tst, q;
685                    uint32_t s;
686    
687      if (!init_cpu(cpu))      if (!init_cpu(cpu))
688        continue;        continue;
689    
     set_inter_matrix( get_default_inter_matrix() );  
     set_intra_matrix( get_default_intra_matrix() );  
690      overhead = -gettime_usec();      overhead = -gettime_usec();
691      for(tst=0; tst<nb_tests; ++tst)                  for(s=0,qm=1; qm<=255; ++qm) {
692        for(s=0, q=1; q<=max_Q; ++q)                          for(i=0; i<8*8; ++i) Quant[i] = qm;
693          for(i=0; i<64; ++i) s+=Dst[i]^i;                          set_inter_matrix(mpeg_quant_matrices, Quant );
694                            for(q=1; q<=max_Q; ++q)
695                                    for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
696                    }
697      overhead += gettime_usec();      overhead += gettime_usec();
698    
699      TEST_QUANT2(quant4_intra, Dst, Src, 7);                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
700      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",
701      if (s!=55827) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
702                               (s!=0xfd6a21a4)? "| ERROR": "");
703      TEST_QUANT(quant4_inter, Dst, Src);  
704      printf( "%s -   quant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
705      if (s!=58201) printf( "*** CRC ERROR! ***\n" );                  printf("%s -   quant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
706                               cpu->name, t, s,
707                               (s!=0xf6de7757)?"| ERROR": "");
708      TEST_QUANT2(dequant4_intra, Dst, Src, 7);  
709      printf( "%s - dequant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
710      if (s!=193340) printf( "*** CRC ERROR! ***\n" );                  printf("%s - dequant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
711                               cpu->name, t, s,
712      TEST_QUANT(dequant4_inter, Dst, Src);                             (s!=0x2def7bc7)?"| ERROR": "");
713      printf( "%s - dequant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );  
714      if (s!=116483) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
715                    printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
716      TEST_QUANT2(quant_intra, Dst, Src, 7);                             cpu->name, t, s,
717      printf( "%s -    quant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                             (s!=0xd878c722)?"| ERROR": "");
718      if (s!=56885) printf( "*** CRC ERROR! ***\n" );  
719                    TEST_QUANT2(quant_h263_intra, Dst, Src);
720      TEST_QUANT(quant_inter, Dst, Src);                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
721      printf( "%s -    quant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                             cpu->name, t, s,
722      if (s!=58056) printf( "*** CRC ERROR! ***\n" );                             (s!=0x2eba9d43)?"| ERROR": "");
723    
724      TEST_QUANT2(dequant_intra, Dst, Src, 7);                  TEST_QUANT(quant_h263_inter, Dst, Src);
725      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",
726      if (s!=-7936) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
727                               (s!=0xbd315a7e)?"| ERROR": "");
728      TEST_QUANT(dequant_inter, Dst, Src);  
729      printf( "%s -  dequant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
730  //    { 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",
731      if (s!=-33217) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
732                               (s!=0x9841212a)?"| ERROR": "");
733    
734                    TEST_QUANT(dequant_h263_inter, Dst, Src);
735                    printf("%s - dequant_h263_inter %.3f usec       crc32=0x%08x %s\n",
736                               cpu->name, t, s,
737                               (s!=0xe7df8fba)?"| ERROR": "");
738    
739      printf( " --- \n" );      printf( " --- \n" );
740    }    }
# Line 566  Line 758 
758    const int nb_tests = 10000*speed_ref;    const int nb_tests = 10000*speed_ref;
759    int i;    int i;
760    CPU *cpu;    CPU *cpu;
761    int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
762            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
763            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
764            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
765    
766    printf( "\n =====  test cbp =====\n" );    printf( "\n =====  test cbp =====\n" );
767    
768    for(i=0; i<6*64; ++i) {    for(i=0; i<6*64; ++i) {
769      Src1[i] = (i*i*3/8192)&(i/64)&1;  // 'random'                  Src1[i] = (i*i*3/8192)&(i/64)&1;  /* 'random' */
770      Src2[i] = (i<3*64);               // half-full                  Src2[i] = (i<3*64);               /* half-full */
771      Src3[i] = ((i+32)>3*64);      Src3[i] = ((i+32)>3*64);
772      Src4[i] = (i==(3*64+2) || i==(5*64+9));      Src4[i] = (i==(3*64+2) || i==(5*64+9));
773    }    }
774    
775    for(cpu = cpu_short_list2; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
776    {    {
777      double t;      double t;
778      int tst, cbp;      int tst, cbp;
# Line 586  Line 781 
781        continue;        continue;
782    
783      TEST_CBP(calc_cbp, Src1);      TEST_CBP(calc_cbp, Src1);
784      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",
785      if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
786      TEST_CBP(calc_cbp, Src2);      TEST_CBP(calc_cbp, Src2);
787      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",
788      if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
789      TEST_CBP(calc_cbp, Src3);      TEST_CBP(calc_cbp, Src3);
790      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",
791      if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
792      TEST_CBP(calc_cbp, Src4);      TEST_CBP(calc_cbp, Src4);
793      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",
794      if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
795      printf( " --- \n" );      printf( " --- \n" );
796    }    }
797  }  }
798    
799  /*********************************************************************  /*********************************************************************
800     * fdct/idct IEEE1180 compliance
801     *********************************************************************/
802    
803    typedef struct {
804            long Errors[64];
805            long Sqr_Errors[64];
806            long Max_Errors[64];
807            long Nb;
808    } STATS_8x8;
809    
810    void init_stats(STATS_8x8 *S)
811    {
812            int i;
813            for(i=0; i<64; ++i) {
814                    S->Errors[i]     = 0;
815                    S->Sqr_Errors[i] = 0;
816                    S->Max_Errors[i] = 0;
817            }
818            S->Nb = 0;
819    }
820    
821    void store_stats(STATS_8x8 *S, short Blk[64], short Ref[64])
822    {
823            int i;
824            for(i=0; i<64; ++i)
825            {
826                    short Err = Blk[i] - Ref[i];
827                    S->Errors[i] += Err;
828                    S->Sqr_Errors[i] += Err * Err;
829                    if (Err<0) Err = -Err;
830                    if (S->Max_Errors[i]<Err)
831                            S->Max_Errors[i] = Err;
832            }
833            S->Nb++;
834    }
835    
836    void print_stats(STATS_8x8 *S)
837    {
838            int i;
839            double Norm;
840    
841            assert(S->Nb>0);
842            Norm = 1. / (double)S->Nb;
843            printf("\n== Max absolute values of errors ==\n");
844            for(i=0; i<64; i++) {
845                    printf("  %4ld", S->Max_Errors[i]);
846                    if ((i&7)==7) printf("\n");
847            }
848    
849            printf("\n== Mean square errors ==\n");
850            for(i=0; i<64; i++)
851            {
852                    double Err = Norm * (double)S->Sqr_Errors[i];
853                    printf(" %.3f", Err);
854                    if ((i&7)==7) printf("\n");
855            }
856    
857            printf("\n== Mean errors ==\n");
858            for(i=0; i<64; i++)
859            {
860                    double Err = Norm * (double)S->Errors[i];
861                    printf(" %.3f", Err);
862                    if ((i&7)==7) printf("\n");
863            }
864            printf("\n");
865    }
866    
867    static const char *CHECK(double v, double l) {
868            if (fabs(v)<=l) return "ok";
869            else return "FAIL!";
870    }
871    
872    void report_stats(STATS_8x8 *S, const double *Limits)
873    {
874            int i;
875            double Norm, PE, PMSE, OMSE, PME, OME;
876    
877            assert(S->Nb>0);
878            Norm = 1. / (double)S->Nb;
879            PE = 0.;
880            for(i=0; i<64; i++) {
881                    if (PE<S->Max_Errors[i])
882                            PE = S->Max_Errors[i];
883            }
884    
885            PMSE = 0.;
886            OMSE = 0.;
887            for(i=0; i<64; i++)
888            {
889                    double Err = Norm * (double)S->Sqr_Errors[i];
890                    OMSE += Err;
891                    if (PMSE < Err) PMSE = Err;
892            }
893            OMSE /= 64.;
894    
895            PME = 0.;
896            OME = 0.;
897            for(i=0; i<64; i++)
898            {
899                    double Err = Norm * (double)S->Errors[i];
900                    OME += Err;
901                    Err = fabs(Err);
902                    if (PME < Err) PME = Err;
903            }
904            OME /= 64.;
905    
906            printf( "Peak error:   %4.4f\n", PE );
907            printf( "Peak MSE:     %4.4f\n", PMSE );
908            printf( "Overall MSE:  %4.4f\n", OMSE );
909            printf( "Peak ME:      %4.4f\n", PME );
910            printf( "Overall ME:   %4.4f\n", OME );
911    
912            if (Limits!=0)
913            {
914                    printf( "[PE<=%.4f %s]  ", Limits[0], CHECK(PE,   Limits[0]) );
915                    printf( "\n" );
916                    printf( "[PMSE<=%.4f %s]", Limits[1], CHECK(PMSE, Limits[1]) );
917                    printf( "[OMSE<=%.4f %s]", Limits[2], CHECK(OMSE, Limits[2]) );
918                    printf( "\n" );
919                    printf( "[PME<=%.4f %s] ", Limits[3], CHECK(PME , Limits[3]) );
920                    printf( "[OME<=%.4f %s] ", Limits[4], CHECK(OME , Limits[4]) );
921                    printf( "\n" );
922            }
923    }
924    
925    ///* ////////////////////////////////////////////////////// */
926    /* Pseudo-random generator specified by IEEE 1180 */
927    
928    static long ieee_seed = 1;
929    static void ieee_reseed(long s) {
930            ieee_seed = s;
931    }
932    static long ieee_rand(int Min, int Max)
933    {
934            static double z = (double) 0x7fffffff;
935    
936            long i,j;
937            double x;
938    
939            ieee_seed = (ieee_seed * 1103515245) + 12345;
940            i = ieee_seed & 0x7ffffffe;
941            x = ((double) i) / z;
942            x *= (Max-Min+1);
943            j = (long)x;
944            j = j + Min;
945            assert(j>=Min && j<=Max);
946            return (short)j;
947    }
948    
949    #define CLAMP(x, M)   (x) = ((x)<-(M)) ? (-(M)) : ((x)>=(M) ? ((M)-1) : (x))
950    
951    static double Cos[8][8];
952    static void init_ref_dct()
953    {
954            int i, j;
955            for(i=0; i<8; i++)
956            {
957                    double scale = (i == 0) ? sqrt(0.125) : 0.5;
958                    for (j=0; j<8; j++)
959                            Cos[i][j] = scale*cos( (M_PI/8.0)*i*(j + 0.5) );
960            }
961    }
962    
963    void ref_idct(short *M)
964    {
965            int i, j, k;
966            double Tmp[8][8];
967    
968            for(i=0; i<8; i++) {
969                    for(j=0; j<8; j++)
970                    {
971                            double Sum = 0.0;
972                            for (k=0; k<8; k++) Sum += Cos[k][j]*M[8*i+k];
973                            Tmp[i][j] = Sum;
974                    }
975            }
976            for(i=0; i<8; i++) {
977                    for(j=0; j<8; j++) {
978                            double Sum = 0.0;
979                            for (k=0; k<8; k++) Sum += Cos[k][i]*Tmp[k][j];
980                            M[8*i+j] = (short)floor(Sum + .5);
981                    }
982            }
983    }
984    
985    void ref_fdct(short *M)
986    {
987            int i, j, k;
988            double Tmp[8][8];
989    
990            for(i=0; i<8; i++) {
991                    for(j=0; j<8; j++)
992                    {
993                            double Sum = 0.0;
994                            for (k=0; k<8; k++) Sum += Cos[j][k]*M[8*i+k];
995                            Tmp[i][j] = Sum;
996                    }
997            }
998            for(i=0; i<8; i++) {
999                    for(j=0; j<8; j++) {
1000                            double Sum = 0.0;
1001                            for (k=0; k<8; k++) Sum += Cos[i][k]*Tmp[k][j];
1002                            M[8*i+j] = (short)floor(Sum + 0.5);
1003                    }
1004            }
1005    }
1006    
1007    void test_IEEE1180_compliance(int Min, int Max, int Sign)
1008    {
1009            static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };
1010            int Loops = 10000;
1011            int i, m, n;
1012            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1013            DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1014            DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1015            DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
1016            DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
1017    
1018            STATS_8x8 FStats; /* forward dct stats */
1019            STATS_8x8 IStats; /* inverse dct stats */
1020    
1021            CPU *cpu;
1022    
1023            init_ref_dct();
1024    
1025            for(cpu = cpu_list; cpu->name!=0; ++cpu)
1026            {
1027                    if (!init_cpu(cpu))
1028                            continue;
1029    
1030                    printf( "\n===== IEEE test for %s ==== (Min=%d Max=%d Sign=%d Loops=%d)\n",
1031                                    cpu->name, Min, Max, Sign, Loops);
1032    
1033                    init_stats(&IStats);
1034                    init_stats(&FStats);
1035    
1036                    ieee_reseed(1);
1037                    for(n=0; n<Loops; ++n)
1038                    {
1039                            for(i=0; i<64; ++i)
1040                                    Blk0[i] = (short)ieee_rand(Min,Max) * Sign;
1041    
1042                            /* hmm, I'm not quite sure this is exactly */
1043                            /* the tests described in the norm. check... */
1044    
1045                            memcpy(Ref_FDCT, Blk0, 64*sizeof(short));
1046                            ref_fdct(Ref_FDCT);
1047                            for(i=0; i<64; i++) CLAMP( Ref_FDCT[i], 2048 );
1048    
1049                            memcpy(Blk, Blk0, 64*sizeof(short));
1050                            emms(); fdct(Blk); emms();
1051                            for(i=0; i<64; i++) CLAMP( Blk[i], 2048 );
1052    
1053                            store_stats(&FStats, Blk, Ref_FDCT);
1054    
1055    
1056                            memcpy(Ref_IDCT, Ref_FDCT, 64*sizeof(short));
1057                            ref_idct(Ref_IDCT);
1058                            for (i=0; i<64; i++) CLAMP( Ref_IDCT[i], 256 );
1059    
1060                            memcpy(iBlk, Ref_FDCT, 64*sizeof(short));
1061                            emms(); idct(iBlk); emms();
1062                            for(i=0; i<64; i++) CLAMP( iBlk[i], 256 );
1063    
1064                            store_stats(&IStats, iBlk, Ref_IDCT);
1065                    }
1066    
1067    
1068                    printf( "\n  -- FDCT report --\n" );
1069    //    print_stats(&FStats);
1070                    report_stats(&FStats, 0); /* so far I know, IEEE1180 says nothing for fdct */
1071    
1072                    for(i=0; i<64; i++) Blk[i] = 0;
1073                    emms(); fdct(Blk); emms();
1074                    for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
1075                    printf( "FDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1076    
1077                    printf( "\n  -- IDCT report --\n" );
1078    //    print_stats(&IStats);
1079                    report_stats(&IStats, ILimits);
1080    
1081    
1082                    for(i=0; i<64; i++) Blk[i] = 0;
1083                    emms(); idct(Blk); emms();
1084                    for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
1085                    printf( "IDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1086            }
1087    }
1088    
1089    
1090    void test_dct_saturation(int Min, int Max)
1091    {
1092    /* test behaviour on input range fringe */
1093    
1094            int i, n, p;
1095            CPU *cpu;
1096    //  const short IDCT_MAX =  2047;  /* 12bits input */
1097    //  const short IDCT_MIN = -2048;
1098    //  const short IDCT_OUT =   256;  /* 9bits ouput */
1099            const int Partitions = 4;
1100            const int Loops = 10000 / Partitions;
1101    
1102            init_ref_dct();
1103    
1104            for(cpu = cpu_list; cpu->name!=0; ++cpu)
1105            {
1106                    short Blk0[64], Blk[64];
1107                    STATS_8x8 Stats;
1108    
1109                    if (!init_cpu(cpu))
1110                            continue;
1111    
1112                    printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",
1113                                    cpu->name, Min, Max );
1114    
1115                    /* FDCT tests // */
1116    
1117                    init_stats(&Stats);
1118    
1119                    /* test each computation channels separately */
1120                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;
1121                    ref_fdct(Blk0);
1122                    emms(); fdct(Blk); emms();
1123                    store_stats(&Stats, Blk, Blk0);
1124    
1125                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Min : 0;
1126                    ref_fdct(Blk0);
1127                    emms(); fdct(Blk); emms();
1128                    store_stats(&Stats, Blk, Blk0);
1129    
1130                    /* randomly saturated inputs */
1131                    for(p=0; p<Partitions; ++p)
1132                    {
1133                            for(n=0; n<Loops; ++n)
1134                            {
1135                                    for(i=0; i<64; ++i)
1136                                            Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? Max : Min;
1137                                    ref_fdct(Blk0);
1138                                    emms(); fdct(Blk); emms();
1139                                    store_stats(&Stats, Blk, Blk0);
1140                            }
1141                    }
1142                    printf( "\n  -- FDCT saturation report --\n" );
1143                    report_stats(&Stats, 0);
1144    
1145    
1146                    /* IDCT tests // */
1147    #if 0
1148                    /* no finished yet */
1149    
1150                    init_stats(&Stats);
1151    
1152    /* test each computation channel separately */
1153                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 0;
1154                    ref_idct(Blk0);
1155                    emms(); idct(Blk); emms();
1156                    for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1157                    store_stats(&Stats, Blk, Blk0);
1158    
1159                    for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MIN : 0;
1160                    ref_idct(Blk0);
1161                    emms(); idct(Blk); emms();
1162                    for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1163                    store_stats(&Stats, Blk, Blk0);
1164    
1165                    /* randomly saturated inputs */
1166                    for(p=0; p<Partitions; ++p)
1167                    {
1168                            for(n=0; n<Loops; ++n)
1169                            {
1170                                    for(i=0; i<64; ++i)
1171                                            Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? IDCT_MAX : IDCT_MIN;
1172                                    ref_idct(Blk0);
1173                                    emms(); idct(Blk); emms();
1174                                    for(i=0; i<64; i++) { CLAMP(Blk0[i],IDCT_OUT); CLAMP(Blk[i],IDCT_OUT); }
1175                                    store_stats(&Stats, Blk, Blk0);
1176                            }
1177                    }
1178    
1179                    printf( "\n  -- IDCT saturation report --\n" );
1180                    print_stats(&Stats);
1181                    report_stats(&Stats, 0);
1182    #endif
1183            }
1184    }
1185    
1186    /*********************************************************************
1187   * measure raw decoding speed   * measure raw decoding speed
1188   *********************************************************************/   *********************************************************************/
1189    
# Line 610  Line 1192 
1192    FILE *f = 0;    FILE *f = 0;
1193    void *dechandle = 0;    void *dechandle = 0;
1194    int xerr;    int xerr;
1195          XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
1196          XVID_DEC_PARAM xparam;          xvid_dec_create_t xparam;
1197          XVID_DEC_FRAME xframe;          xvid_dec_frame_t xframe;
1198          double t = 0.;          double t = 0.;
1199          int nb = 0;          int nb = 0;
1200    uint8_t *buf = 0;    uint8_t *buf = 0;
# Line 620  Line 1202 
1202    int buf_size, pos;    int buf_size, pos;
1203    uint32_t chksum = 0;    uint32_t chksum = 0;
1204    
1205          xinit.cpu_flags = 0;          memset(&xinit, 0, sizeof(xinit));
1206          xvid_init(NULL, 0, &xinit, NULL);          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;
1207          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          xinit.version = XVID_VERSION;
1208            xvid_global(NULL, 0, &xinit, NULL);
1209    
1210            memset(&xparam, 0, sizeof(xparam));
1211          xparam.width = width;          xparam.width = width;
1212          xparam.height = height;          xparam.height = height;
1213            xparam.version = XVID_VERSION;
1214          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1215          if (xerr!=XVID_ERR_OK) {          if (xerr==XVID_ERR_FAIL) {
1216            printf("can't init decoder (err=%d)\n", xerr);            printf("can't init decoder (err=%d)\n", xerr);
1217            return;            return;
1218          }          }
# Line 649  Line 1233 
1233    }    }
1234    else printf( "Input size: %d\n", buf_size);    else printf( "Input size: %d\n", buf_size);
1235    
1236    buf = malloc(buf_size); // should be enuf'          buf = malloc(buf_size); /* should be enuf' */
1237    rgb_out = calloc(4, width*height);  // <-room for _RGB24          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */
1238    if (buf==0 || rgb_out==0) {    if (buf==0 || rgb_out==0) {
1239      printf( "malloc failed!\n" );      printf( "malloc failed!\n" );
1240      goto End;      goto End;
# Line 665  Line 1249 
1249    pos = 0;    pos = 0;
1250    t = -gettime_usec();    t = -gettime_usec();
1251    while(1) {    while(1) {
1252                    memset(&xframe, 0, sizeof(xframe));
1253                    xframe.version = XVID_VERSION;
1254      xframe.bitstream = buf + pos;      xframe.bitstream = buf + pos;
1255      xframe.length = buf_size - pos;      xframe.length = buf_size - pos;
1256      xframe.image = rgb_out;                  xframe.output.plane[0] = rgb_out;
1257      xframe.stride = width;                  xframe.output.stride[0] = width;
1258      xframe.colorspace = XVID_CSP_RGB24;                  xframe.output.csp = XVID_CSP_BGR;
1259      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1260      nb++;      nb++;
1261      pos += xframe.length;      pos += xframe.length;
# Line 680  Line 1266 
1266      }      }
1267      if (pos==buf_size)      if (pos==buf_size)
1268        break;        break;
1269      if (xerr!=XVID_ERR_OK) {                  if (xerr==XVID_ERR_FAIL) {
1270            printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);            printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1271            break;            break;
1272          }          }
# Line 696  Line 1282 
1282    if (buf!=0) free(buf);    if (buf!=0) free(buf);
1283    if (dechandle!=0) {    if (dechandle!=0) {
1284      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1285      if (xerr!=XVID_ERR_OK)                  if (xerr==XVID_ERR_FAIL)
1286              printf("destroy-decoder failed (err=%d)!\n", xerr);              printf("destroy-decoder failed (err=%d)!\n", xerr);
1287    }    }
1288    if (f!=0) fclose(f);    if (f!=0) fclose(f);
# Line 709  Line 1295 
1295  void test_bugs1()  void test_bugs1()
1296  {  {
1297    CPU *cpu;    CPU *cpu;
1298            uint16_t mpeg_quant_matrices[64*8];
1299    
1300    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1301    
1302    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1303    {    {
1304      int i;      int i;
1305      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 721  Line 1308 
1308        continue;        continue;
1309    
1310      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1311      set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1312      dequant4_intra(Dst, Src, 32, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1313      printf( "dequant4_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1314      printf( "  Out[]= " );      printf( "  Out[]= " );
1315      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1316      printf( "\n" );      printf( "\n" );
# Line 731  Line 1318 
1318    
1319    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );
1320    
1321    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1322    {    {
1323      int i;      int i;
1324      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 740  Line 1327 
1327        continue;        continue;
1328    
1329      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1330      set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1331      dequant4_inter(Dst, Src, 32);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1332      printf( "dequant4_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1333      printf( "  Out[]= " );      printf( "  Out[]= " );
1334      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1335      printf( "\n" );      printf( "\n" );
# Line 752  Line 1339 
1339  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1340  {  {
1341    CPU *cpu;    CPU *cpu;
1342    short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1343            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1344    
1345    printf( "\n =====  fdct/idct saturation diffs =====\n" );          printf( "\n =====  fdct/idct precision diffs =====\n" );
1346    
1347    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1348    {    {
1349      int i;      int i;
1350    
# Line 780  Line 1368 
1368    }    }
1369  }  }
1370    
1371    void test_quant_bug()
1372    {
1373            const int max_Q = 31;
1374            int i, n, qm, q;
1375            CPU *cpu;
1376            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1377            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1378            uint8_t Quant[8*8];
1379            CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1380            uint16_t Crcs_Inter[2][32];
1381            uint16_t Crcs_Intra[2][32];
1382            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1383    
1384            printf( "\n =====  test MPEG4-quantize bug =====\n" );
1385    
1386            for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;
1387    
1388    #if 1
1389            for(qm=1; qm<=255; ++qm)
1390            {
1391                    for(i=0; i<8*8; ++i) Quant[i] = qm;
1392                    set_inter_matrix( mpeg_quant_matrices, Quant );
1393    
1394                    for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1395                    {
1396                            uint16_t s;
1397    
1398                            if (!init_cpu(cpu))
1399                                    continue;
1400    
1401                            for(q=1; q<=max_Q; ++q) {
1402                                    emms();
1403                                    quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1404                                    emms();
1405                                    for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1406                                    Crcs_Inter[n][q] = s;
1407                            }
1408                    }
1409    
1410                    for(q=1; q<=max_Q; ++q)
1411                            for(i=0; i<n-1; ++i)
1412                                    if (Crcs_Inter[i][q]!=Crcs_Inter[i+1][q])
1413                                            printf( "Discrepancy Inter: qm=%d, q=%d  -> %d/%d !\n",
1414                                                            qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1415            }
1416    #endif
1417    
1418    #if 1
1419            for(qm=1; qm<=255; ++qm)
1420            {
1421                    for(i=0; i<8*8; ++i) Quant[i] = qm;
1422                    set_intra_matrix( mpeg_quant_matrices, Quant );
1423    
1424                    for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1425                    {
1426                            uint16_t s;
1427    
1428                            if (!init_cpu(cpu))
1429                                    continue;
1430    
1431                            for(q=1; q<=max_Q; ++q) {
1432                                    emms();
1433                                    quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1434                                    emms();
1435                                    for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1436                                    Crcs_Intra[n][q] = s;
1437                            }
1438                    }
1439    
1440                    for(q=1; q<=max_Q; ++q)
1441                            for(i=0; i<n-1; ++i)
1442                                    if (Crcs_Intra[i][q]!=Crcs_Intra[i+1][q])
1443                                            printf( "Discrepancy Intra: qm=%d, q=%d  -> %d/%d!\n",
1444                                                            qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1445            }
1446    #endif
1447    }
1448    
1449  /*********************************************************************  /*********************************************************************
1450   * main   * main
# Line 796  Line 1461 
1461    if (what==0 || what==5) test_quant();    if (what==0 || what==5) test_quant();
1462    if (what==0 || what==6) test_cbp();    if (what==0 || what==6) test_cbp();
1463    
1464    if (what==8) {          if (what==7) {
1465                    test_IEEE1180_compliance(-256, 255, 1);
1466                    test_IEEE1180_compliance(-256, 255,-1);
1467                    test_IEEE1180_compliance(  -5,   5, 1);
1468                    test_IEEE1180_compliance(  -5,   5,-1);
1469                    test_IEEE1180_compliance(-300, 300, 1);
1470                    test_IEEE1180_compliance(-300, 300,-1);
1471            }
1472            if (what==8) test_dct_saturation(-256, 255);
1473    
1474            if (what==9) {
1475      int width, height;      int width, height;
1476      if (argc<5) {      if (argc<5) {
1477        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 1483 
1483    }    }
1484    
1485    if (what==-1) {    if (what==-1) {
     test_bugs1();  
1486      test_dct_precision_diffs();      test_dct_precision_diffs();
1487                    test_bugs1();
1488    }    }
1489            if (what==-2)
1490                    test_quant_bug();
1491    
1492            if (what >= 0 && what <= 6) {
1493                    printf("\n\n"
1494                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1495                               "    a C function is used instead. So don't panic if some functions\n"
1496                               "    may appear to be slow.\n");
1497            }
1498    
1499    #ifdef ARCH_IS_IA32
1500            if (what == 0 || what == 5) {
1501                    printf("\n"
1502                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1503                               "    for 1 or 2 coefficients a block. This is mainly caused by the fact the unit\n"
1504                               "    test goes far behind the usual limits of real encoding. Please do not report\n"
1505                               "    this error to the developers.\n");
1506            }
1507    #endif
1508    
1509    return 0;    return 0;
1510  }  }
1511    
1512  /*********************************************************************  /*********************************************************************
1513   * 'Reference' output (except for timing) on a PIII 1.13Ghz/linux   * 'Reference' output (except for timing) on an Athlon XP 2200+
1514   *********************************************************************/   *********************************************************************/
1515  /*  
1516    /* as of 2002-01-07, there's a problem with MMX mpeg4-quantization */
1517    /* as of 2003-11-30, the problem is still here */
1518    
1519    /*********************************************************************
1520    
1521    
1522   ===== test fdct/idct =====   ===== test fdct/idct =====
1523  PLAINC -  2.631 usec       iCrc=3  fCrc=-85  PLAINC -  2.867 usec       PSNR=13.291  MSE=3.000
1524  MMX    -  0.596 usec       iCrc=3  fCrc=-67  MMX    -  -0.211 usec       PSNR=9.611  MSE=7.000
1525  MMXEXT -  0.608 usec       iCrc=3  fCrc=-67  MMXEXT -  -0.256 usec       PSNR=9.611  MSE=7.000
1526  SSE2   -  0.605 usec       iCrc=3  fCrc=-67  3DNOW  -  2.855 usec       PSNR=13.291  MSE=3.000
1527  3DNOW  - skipped...  3DNOWE -  1.429 usec       PSNR=13.291  MSE=3.000
 3DNOWE - skipped...  
1528    
1529   ===  test block motion ===   ===  test block motion ===
1530  PLAINC - interp- h-round0 1.031 usec       iCrc=8107  PLAINC - interp- h-round0 0.538 usec       crc32=0x115381ba
1531  PLAINC -           round1 1.022 usec       iCrc=8100  PLAINC -           round1 0.527 usec       crc32=0x2b1f528f
1532  PLAINC - interp- v-round0 1.002 usec       iCrc=8108  PLAINC - interp- v-round0 0.554 usec       crc32=0x423cdcc7
1533  PLAINC -           round1 1.011 usec       iCrc=8105  PLAINC -           round1 0.551 usec       crc32=0x42202efe
1534  PLAINC - interp-hv-round0 1.623 usec       iCrc=8112  PLAINC - interp-hv-round0 1.041 usec       crc32=0xd198d387
1535  PLAINC -           round1 1.621 usec       iCrc=8103  PLAINC -           round1 1.038 usec       crc32=0x9ecfd921
1536  PLAINC - interpolate8x8_c 0.229 usec       iCrc=8107   ---
1537   ---  MMX    - interp- h-round0 0.051 usec       crc32=0x115381ba
1538  MMX    - interp- h-round0 0.105 usec       iCrc=8107  MMX    -           round1 0.053 usec       crc32=0x2b1f528f
1539  MMX    -           round1 0.105 usec       iCrc=8100  MMX    - interp- v-round0 0.048 usec       crc32=0x423cdcc7
1540  MMX    - interp- v-round0 0.106 usec       iCrc=8108  MMX    -           round1 0.048 usec       crc32=0x42202efe
1541  MMX    -           round1 0.107 usec       iCrc=8105  MMX    - interp-hv-round0 0.074 usec       crc32=0xd198d387
1542  MMX    - interp-hv-round0 0.145 usec       iCrc=8112  MMX    -           round1 0.073 usec       crc32=0x9ecfd921
1543  MMX    -           round1 0.145 usec       iCrc=8103   ---
1544  MMX    - interpolate8x8_c 0.229 usec       iCrc=8107  MMXEXT - interp- h-round0 0.020 usec       crc32=0x115381ba
1545   ---  MMXEXT -           round1 0.025 usec       crc32=0x2b1f528f
1546  MMXEXT - interp- h-round0 0.027 usec       iCrc=8107  MMXEXT - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1547  MMXEXT -           round1 0.041 usec       iCrc=8100  MMXEXT -           round1 0.024 usec       crc32=0x42202efe
1548  MMXEXT - interp- v-round0 0.027 usec       iCrc=8108  MMXEXT - interp-hv-round0 0.037 usec       crc32=0xd198d387
1549  MMXEXT -           round1 0.040 usec       iCrc=8105  MMXEXT -           round1 0.037 usec       crc32=0x9ecfd921
1550  MMXEXT - interp-hv-round0 0.070 usec       iCrc=8112   ---
1551  MMXEXT -           round1 0.066 usec       iCrc=8103  3DNOW  - interp- h-round0 0.020 usec       crc32=0x115381ba
1552  MMXEXT - interpolate8x8_c 0.027 usec       iCrc=8107  3DNOW  -           round1 0.029 usec       crc32=0x2b1f528f
1553   ---  3DNOW  - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1554  SSE2   - interp- h-round0 0.106 usec       iCrc=8107  3DNOW  -           round1 0.024 usec       crc32=0x42202efe
1555  SSE2   -           round1 0.105 usec       iCrc=8100  3DNOW  - interp-hv-round0 0.038 usec       crc32=0xd198d387
1556  SSE2   - interp- v-round0 0.106 usec       iCrc=8108  3DNOW  -           round1 0.039 usec       crc32=0x9ecfd921
1557  SSE2   -           round1 0.106 usec       iCrc=8105   ---
1558  SSE2   - interp-hv-round0 0.145 usec       iCrc=8112  3DNOWE - interp- h-round0 0.020 usec       crc32=0x115381ba
1559  SSE2   -           round1 0.145 usec       iCrc=8103  3DNOWE -           round1 0.024 usec       crc32=0x2b1f528f
1560  SSE2   - interpolate8x8_c 0.237 usec       iCrc=8107  3DNOWE - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1561    3DNOWE -           round1 0.021 usec       crc32=0x42202efe
1562    3DNOWE - interp-hv-round0 0.037 usec       crc32=0xd198d387
1563    3DNOWE -           round1 0.036 usec       crc32=0x9ecfd921
1564   ---   ---
 3DNOW  - skipped...  
 3DNOWE - skipped...  
1565    
1566   ======  test SAD ======   ======  test SAD ======
1567  PLAINC - sad8    0.296 usec       sad=3776  PLAINC - sad8    0.505 usec       sad=3776
1568  PLAINC - sad16   1.599 usec       sad=27214  PLAINC - sad16   1.941 usec       sad=27214
1569  PLAINC - sad16bi 2.350 usec       sad=26274  PLAINC - sad16bi 4.925 usec       sad=26274
1570  PLAINC - dev16   1.610 usec       sad=3344  PLAINC - dev16   4.254 usec       sad=3344
1571   ---   ---
1572  MMX    - sad8    0.057 usec       sad=3776  MMX    - sad8    0.036 usec       sad=3776
1573  MMX    - sad16   0.178 usec       sad=27214  MMX    - sad16   0.107 usec       sad=27214
1574  MMX    - sad16bi 2.381 usec       sad=26274  MMX    - sad16bi 0.259 usec       sad=26274
1575  MMX    - dev16   0.312 usec       sad=3344  MMX    - dev16   0.187 usec       sad=3344
1576   ---   ---
1577  MMXEXT - sad8    0.036 usec       sad=3776  MMXEXT - sad8    0.016 usec       sad=3776
1578  MMXEXT - sad16   0.106 usec       sad=27214  MMXEXT - sad16   0.050 usec       sad=27214
1579  MMXEXT - sad16bi 0.182 usec       sad=26274  MMXEXT - sad16bi 0.060 usec       sad=26274
1580  MMXEXT - dev16   0.193 usec       sad=3344  MMXEXT - dev16   0.086 usec       sad=3344
1581   ---   ---
1582  SSE2   - sad8    0.057 usec       sad=3776  3DNOW  - sad8    0.506 usec       sad=3776
1583  SSE2   - sad16   0.178 usec       sad=27214  3DNOW  - sad16   1.954 usec       sad=27214
1584  SSE2   - sad16bi 2.427 usec       sad=26274  3DNOW  - sad16bi 0.119 usec       sad=26274
1585  SSE2   - dev16   0.313 usec       sad=3344  3DNOW  - dev16   4.252 usec       sad=3344
1586     ---
1587    3DNOWE - sad8    0.017 usec       sad=3776
1588    3DNOWE - sad16   0.038 usec       sad=27214
1589    3DNOWE - sad16bi 0.052 usec       sad=26274
1590    3DNOWE - dev16   0.067 usec       sad=3344
1591   ---   ---
 3DNOW  - skipped...  
 3DNOWE - skipped...  
1592    
1593   ===  test transfer ===   ===  test transfer ===
1594  PLAINC - 8to16     0.124 usec       crc=28288  PLAINC - 8to16     0.603 usec       crc32=0x115814bb
1595  PLAINC - 16to8     0.753 usec       crc=28288  PLAINC - 16to8     1.077 usec       crc32=0xee7ccbb4
1596  PLAINC - 8to8      0.041 usec       crc=20352  PLAINC - 8to8      0.679 usec       crc32=0xd37b3295
1597  PLAINC - 16to8add  0.916 usec       crc=25536  PLAINC - 16to8add  1.341 usec       crc32=0xdd817bf4
1598  PLAINC - 8to16sub  0.812 usec       crc1=28064 crc2=16256  PLAINC - 8to16sub  1.566 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1599  PLAINC - 8to16sub2 0.954 usec       crc=20384  PLAINC - 8to16sub2 2.206 usec       crc32=0x99b6c4c7
1600   ---   ---
1601  MMX    - 8to16     0.037 usec       crc=28288  MMX    - 8to16     -0.025 usec       crc32=0x115814bb
1602  MMX    - 16to8     0.016 usec       crc=28288  MMX    - 16to8     -0.049 usec       crc32=0xee7ccbb4
1603  MMX    - 8to8      0.018 usec       crc=20352  MMX    - 8to8      0.014 usec       crc32=0xd37b3295
1604  MMX    - 16to8add  0.044 usec       crc=25536  MMX    - 16to8add  0.011 usec       crc32=0xdd817bf4
1605  MMX    - 8to16sub  0.065 usec       crc1=28064 crc2=16256  MMX    - 8to16sub  0.108 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1606  MMX    - 8to16sub2 0.110 usec       crc=20384  MMX    - 8to16sub2 0.164 usec       crc32=0x99b6c4c7
1607   ---   ---
1608  MMXEXT - 8to16     0.032 usec       crc=28288  MMXEXT - 8to16     -0.054 usec       crc32=0x115814bb
1609  MMXEXT - 16to8     0.023 usec       crc=28288  MMXEXT - 16to8     0.010 usec       crc32=0xee7ccbb4
1610  MMXEXT - 8to8      0.018 usec       crc=20352  MMXEXT - 8to8      0.015 usec       crc32=0xd37b3295
1611  MMXEXT - 16to8add  0.041 usec       crc=25536  MMXEXT - 16to8add  0.008 usec       crc32=0xdd817bf4
1612  MMXEXT - 8to16sub  0.065 usec       crc1=28064 crc2=16256  MMXEXT - 8to16sub  0.263 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1613  MMXEXT - 8to16sub2 0.069 usec       crc=20384  MMXEXT - 8to16sub2 0.178 usec       crc32=0x99b6c4c7
1614     ---
1615    3DNOW  - 8to16     0.666 usec       crc32=0x115814bb
1616    3DNOW  - 16to8     1.078 usec       crc32=0xee7ccbb4
1617    3DNOW  - 8to8      0.665 usec       crc32=0xd37b3295
1618    3DNOW  - 16to8add  1.365 usec       crc32=0xdd817bf4
1619    3DNOW  - 8to16sub  1.356 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1620    3DNOW  - 8to16sub2 2.098 usec       crc32=0x99b6c4c7
1621     ---
1622    3DNOWE - 8to16     -0.024 usec       crc32=0x115814bb
1623    3DNOWE - 16to8     0.010 usec       crc32=0xee7ccbb4
1624    3DNOWE - 8to8      0.014 usec       crc32=0xd37b3295
1625    3DNOWE - 16to8add  0.016 usec       crc32=0xdd817bf4
1626    3DNOWE - 8to16sub  -0.000 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1627    3DNOWE - 8to16sub2 -0.031 usec       crc32=0x99b6c4c7
1628   ---   ---
1629    
1630   =====  test quant =====   =====  test quant =====
1631  PLAINC -   quant4_intra 78.889 usec       crc=55827  PLAINC -   quant_mpeg_intra 98.631 usec       crc32=0xfd6a21a4
1632  PLAINC -   quant4_inter 71.957 usec       crc=58201  PLAINC -   quant_mpeg_inter 104.876 usec       crc32=0xf6de7757
1633  PLAINC - dequant4_intra 34.968 usec       crc=193340  PLAINC - dequant_mpeg_intra 50.285 usec       crc32=0x2def7bc7
1634  PLAINC - dequant4_inter 40.792 usec       crc=116483  PLAINC - dequant_mpeg_inter 58.316 usec       crc32=0xd878c722
1635  PLAINC -    quant_intra 30.845 usec       crc=56885  PLAINC -   quant_h263_intra 33.803 usec       crc32=0x2eba9d43
1636  PLAINC -    quant_inter 34.842 usec       crc=58056  PLAINC -   quant_h263_inter 45.411 usec       crc32=0xbd315a7e
1637  PLAINC -  dequant_intra 33.211 usec       crc=-7936  PLAINC - dequant_h263_intra 39.302 usec       crc32=0x9841212a
1638  PLAINC -  dequant_inter 45.486 usec       crc=-33217  PLAINC - dequant_h263_inter 44.124 usec       crc32=0xe7df8fba
1639   ---   ---
1640  MMX    -   quant4_intra 9.030 usec       crc=55827  MMX    -   quant_mpeg_intra 4.273 usec       crc32=0xdacabdb6 | ERROR
1641  MMX    -   quant4_inter 8.234 usec       crc=58201  MMX    -   quant_mpeg_inter 3.576 usec       crc32=0x72883ab6 | ERROR
1642  MMX    - dequant4_intra 18.330 usec       crc=193340  MMX    - dequant_mpeg_intra 3.793 usec       crc32=0x2def7bc7
1643  MMX    - dequant4_inter 19.181 usec       crc=116483  MMX    - dequant_mpeg_inter 4.808 usec       crc32=0xd878c722
1644  MMX    -    quant_intra 7.124 usec       crc=56885  MMX    -   quant_h263_intra 2.881 usec       crc32=0x2eba9d43
1645  MMX    -    quant_inter 6.861 usec       crc=58056  MMX    -   quant_h263_inter 2.550 usec       crc32=0xbd315a7e
1646  MMX    -  dequant_intra 9.048 usec       crc=-7936  MMX    - dequant_h263_intra 2.974 usec       crc32=0x9841212a
1647  MMX    -  dequant_inter 8.203 usec       crc=-33217  MMX    - dequant_h263_inter 2.906 usec       crc32=0xe7df8fba
1648   ---   ---
1649  MMXEXT -   quant4_intra 9.045 usec       crc=55827  MMXEXT -   quant_mpeg_intra 4.221 usec       crc32=0xfd6a21a4
1650  MMXEXT -   quant4_inter 8.232 usec       crc=58201  MMXEXT -   quant_mpeg_inter 4.339 usec       crc32=0xf6de7757
1651  MMXEXT - dequant4_intra 18.250 usec       crc=193340  MMXEXT - dequant_mpeg_intra 3.802 usec       crc32=0x2def7bc7
1652  MMXEXT - dequant4_inter 19.256 usec       crc=116483  MMXEXT - dequant_mpeg_inter 4.821 usec       crc32=0xd878c722
1653  MMXEXT -    quant_intra 7.121 usec       crc=56885  MMXEXT -   quant_h263_intra 2.884 usec       crc32=0x2eba9d43
1654  MMXEXT -    quant_inter 6.855 usec       crc=58056  MMXEXT -   quant_h263_inter 2.554 usec       crc32=0xbd315a7e
1655  MMXEXT -  dequant_intra 9.034 usec       crc=-7936  MMXEXT - dequant_h263_intra 2.728 usec       crc32=0x9841212a
1656  MMXEXT -  dequant_inter 8.202 usec       crc=-33217  MMXEXT - dequant_h263_inter 2.611 usec       crc32=0xe7df8fba
1657     ---
1658    3DNOW  -   quant_mpeg_intra 98.512 usec       crc32=0xfd6a21a4
1659    3DNOW  -   quant_mpeg_inter 104.873 usec       crc32=0xf6de7757
1660    3DNOW  - dequant_mpeg_intra 50.219 usec       crc32=0x2def7bc7
1661    3DNOW  - dequant_mpeg_inter 58.254 usec       crc32=0xd878c722
1662    3DNOW  -   quant_h263_intra 33.778 usec       crc32=0x2eba9d43
1663    3DNOW  -   quant_h263_inter 41.998 usec       crc32=0xbd315a7e
1664    3DNOW  - dequant_h263_intra 39.344 usec       crc32=0x9841212a
1665    3DNOW  - dequant_h263_inter 43.607 usec       crc32=0xe7df8fba
1666     ---
1667    3DNOWE -   quant_mpeg_intra 98.490 usec       crc32=0xfd6a21a4
1668    3DNOWE -   quant_mpeg_inter 104.889 usec       crc32=0xf6de7757
1669    3DNOWE - dequant_mpeg_intra 3.277 usec       crc32=0x2def7bc7
1670    3DNOWE - dequant_mpeg_inter 4.485 usec       crc32=0xd878c722
1671    3DNOWE -   quant_h263_intra 1.882 usec       crc32=0x2eba9d43
1672    3DNOWE -   quant_h263_inter 2.246 usec       crc32=0xbd315a7e
1673    3DNOWE - dequant_h263_intra 3.457 usec       crc32=0x9841212a
1674    3DNOWE - dequant_h263_inter 3.275 usec       crc32=0xe7df8fba
1675   ---   ---
1676    
1677   =====  test cbp =====   =====  test cbp =====
1678  PLAINC -   calc_cbp#1 0.545 usec       cbp=0x15  PLAINC -   calc_cbp#1 0.168 usec       cbp=0x15
1679  PLAINC -   calc_cbp#2 0.540 usec       cbp=0x38  PLAINC -   calc_cbp#2 0.168 usec       cbp=0x38
1680  PLAINC -   calc_cbp#3 0.477 usec       cbp=0xf  PLAINC -   calc_cbp#3 0.157 usec       cbp=0x0f
1681  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  
1682   ---   ---
1683  */  MMX    -   calc_cbp#1 0.070 usec       cbp=0x15
1684    MMX    -   calc_cbp#2 0.062 usec       cbp=0x38
1685    MMX    -   calc_cbp#3 0.062 usec       cbp=0x0f
1686    MMX    -   calc_cbp#4 0.061 usec       cbp=0x05
1687     ---
1688    MMXEXT -   calc_cbp#1 0.062 usec       cbp=0x15
1689    MMXEXT -   calc_cbp#2 0.061 usec       cbp=0x38
1690    MMXEXT -   calc_cbp#3 0.061 usec       cbp=0x0f
1691    MMXEXT -   calc_cbp#4 0.061 usec       cbp=0x05
1692     ---
1693    3DNOW  -   calc_cbp#1 0.168 usec       cbp=0x15
1694    3DNOW  -   calc_cbp#2 0.168 usec       cbp=0x38
1695    3DNOW  -   calc_cbp#3 0.157 usec       cbp=0x0f
1696    3DNOW  -   calc_cbp#4 0.238 usec       cbp=0x05
1697     ---
1698    3DNOWE -   calc_cbp#1 0.049 usec       cbp=0x15
1699    3DNOWE -   calc_cbp#2 0.049 usec       cbp=0x38
1700    3DNOWE -   calc_cbp#3 0.049 usec       cbp=0x0f
1701    3DNOWE -   calc_cbp#4 0.049 usec       cbp=0x05
1702     ---
1703    
1704    
1705    NB: If a function isn't optimised for a specific set of intructions,
1706        a C function is used instead. So don't panic if some functions
1707        may appear to be slow.
1708    
1709    NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)
1710        for 1 or 2 coefficients a block. This is mainly caused by the fact the unit
1711        test goes far behind the usual limits of real encoding. Please do not report
1712        this error to the developers
1713    
1714    *********************************************************************/
Legend:
Removed from v.225  
changed lines
  Added in v.1382
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4