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