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