[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 898, Wed Feb 26 19:05:20 2003 UTC revision 1586, Wed Jan 5 23:02:15 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.15 2005-01-05 23:02:15 edgomez Exp $
23   *   *
24   *************************************************************************/   ****************************************************************************/
25    
26  /************************************************************************  /*****************************************************************************
27   *   *
28   *  'Reference' output is at the end of file.   *  'Reference' output is at the end of file.
  *  Don't take the checksums and crc too seriouly, they aren't  
  *  bullet-proof (should plug some .md5 here)...  
  *  
  *   compiles best at xvidcore/src-dir with something like  
  *  
  *   gcc -DARCH_IS_IA32 -DARCH_IS_32BIT -o xvid_bench xvid_bench.c  \  
  *        ../build/generic/libxvidcore.a -lm  
  *  
  *      History:  
29   *   *
30   *      06.06.2002  initial coding      -Skal-   *   compiles with something like:
31   *      27.02.2003  minor changes (compile, sad16v) <gruel@web.de>   *   gcc -o xvid_bench xvid_bench.c  -I../src/ -lxvidcore -lm
32   *   *
33   *************************************************************************/   ****************************************************************************/
34    
35  #include <stdio.h>  #include <stdio.h>
36  #include <stdlib.h>  #include <stdlib.h>
37  #include <string.h>    // for memset  #include <string.h>    /* for memset */
38  #include <assert.h>  #include <assert.h>
39    
40  #ifndef WIN32  #ifndef WIN32
41  #include <sys/time.h>   // for gettimeofday  #include <sys/time.h>   /* for gettimeofday */
42  #else  #else
43  #include <time.h>  #include <time.h>
44  #endif  #endif
# Line 56  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"
# Line 70  Line 65 
65  #define M_PI            3.14159265358979323846  #define M_PI            3.14159265358979323846
66  #endif  #endif
67    
68  const int speed_ref = 100;  // on slow machines, decrease this value  const int speed_ref = 100;  /* on slow machines, decrease this value */
69    
70  /*********************************************************************  /*********************************************************************
71   * misc   * misc
# Line 117  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  , { "IA64  ", XVID_CPU_IA64 }  #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  , { "IA64  ", XVID_CPU_IA64 }  #endif
138  , { 0, 0 } }  //, { "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 168  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 206  Line 330 
330        MSE += delta*delta;        MSE += delta*delta;
331      }      }
332      PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );      PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
333      printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f\n",                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
334        cpu->name, t, PSNR, MSE );                                  cpu->name, t, PSNR, MSE,
335      if (ABS(MSE)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
336    }    }
337  }  }
338    
# Line 219  Line 343 
343  void test_sad()  void test_sad()
344  {  {
345    const int nb_tests = 2000*speed_ref;    const int nb_tests = 2000*speed_ref;
346    int tst,dummy[4];          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 243  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": "" );
     t = gettime_usec();  
     emms();  
     for(tst=0; tst<nb_tests; ++tst) s = sad16(Cur, Ref1, 16, 65535);  
     emms();  
     t = (gettime_usec() - t) / nb_tests;  
     printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );  
     if (s!=27214) printf( "*** CRC ERROR! ***\n" );  
375    
376      t = gettime_usec();      t = gettime_usec();
377      emms();      emms();
378      for(tst=0; tst<nb_tests; ++tst) s = sad16v(Cur, Ref1, 16, dummy);                  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 - sad16v  %.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 294  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 313  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 337  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                  /* this is a new function, as of 06.06.2002 */
494  #if 0  #if 0
495      TEST_MB2(interpolate8x8_avrg);      TEST_MB2(interpolate8x8_avrg);
496      printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
497      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
498                               (iCrc!=8107)?"| ERROR": "" );
499  #endif  #endif
500    
501      printf( " --- \n" );      printf( " --- \n" );
# Line 403  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 429  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 451  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 460  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  #if 1                                     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  //    for(i=0; i<64; ++i) printf( "[%d]", Dst16[i]);                             (s!=0x99b6c4c7)?"| ERROR": "" );
625  //    printf("\n");  
 #endif  
626      printf( " --- \n" );      printf( " --- \n" );
627    }    }
628  }  }
# Line 498  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=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
637        for(i=0; i<8*8; ++i) Quant[i] = qm;       \        for(i=0; i<8*8; ++i) Quant[i] = qm;       \
638        set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
639        emms();                                   \        emms();                                   \
640        for(q=1; q<=max_Q; ++q) {                 \        for(q=1; q<=max_Q; ++q) {                 \
641          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
642            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
643          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
644        }                                         \        }                                         \
645        emms();                                   \        emms();                                   \
646      }                                           \      }                                           \
647      t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
     s = (s&0xffff)^(s>>16)  
648    
649  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
650      t = gettime_usec();                         \      t = gettime_usec();                         \
651      for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
652        for(i=0; i<8*8; ++i) Quant[i] = qm;       \        for(i=0; i<8*8; ++i) Quant[i] = qm;       \
653        set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
654        emms();                                   \        emms();                                   \
655        for(q=1; q<=max_Q; ++q) {                 \        for(q=1; q<=max_Q; ++q) {                 \
656          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
657            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
658          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
659      }                                         \
660      emms();                                   \
661    }                                           \
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();                                   \        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      t = (gettime_usec()-t-overhead)/nb_tests/qm;\  }
     s = (s&0xffff)^(s>>16)  
694    
695  void test_quant()  void test_quant()
696  {  {
697    const int nb_tests = 1*speed_ref;    const int nb_tests = 1*speed_ref;
698    const int max_Q = 31;    const int max_Q = 31;
699            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
700    
701    int i, qm;    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];    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],  /* we deliberately enfringe the norm's specified range [-127,127], */
711      // to test the robustness of the iquant module  /* to test the robustness of the iquant module */
712    for(i=0; i<64; ++i) {    for(i=0; i<64; ++i) {
713      Src[i] = 1 + (i-32) * (i&6);      Src[i] = 1 + (i-32) * (i&6);
714      Dst[i] = 0;      Dst[i] = 0;
715    }    }
716    
717    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
718    {    {
719      double t, overhead;      double t, overhead;
720      int tst, q;      int tst, q;
# Line 555  Line 723 
723      if (!init_cpu(cpu))      if (!init_cpu(cpu))
724        continue;        continue;
725    
726                    // exhaustive tests to compare against the (ref) C-version
727                    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(s=0,qm=1; qm<=255; ++qm) {      for(s=0,qm=1; qm<=255; ++qm) {
734        for(i=0; i<8*8; ++i) Quant[i] = qm;        for(i=0; i<8*8; ++i) Quant[i] = qm;
735        set_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
736        for(q=1; q<=max_Q; ++q)        for(q=1; q<=max_Q; ++q)
737          for(i=0; i<64; ++i) s+=Dst[i]^i^qm;          for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
738      }      }
739      overhead += gettime_usec();      overhead += gettime_usec();
740    
741  #if 1                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
742      TEST_QUANT2(quant4_intra, Dst, Src);                  printf("%s -   quant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
743      printf( "%s -   quant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                             cpu->name, t, s,
744      if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             (s!=0xfd6a21a4)? "| ERROR": "");
745    
746      TEST_QUANT(quant4_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
747      printf( "%s -   quant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s -   quant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
748      if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
749  #endif                             (s!=0xf6de7757)?"| ERROR": "");
750  #if 1  
751      TEST_QUANT2(dequant4_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
752      printf( "%s - dequant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - dequant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
753      if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
754                               (s!=0x2def7bc7)?"| ERROR": "");
755      TEST_QUANT(dequant4_inter, Dst, Src);  
756      printf( "%s - dequant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
757      if (s!=63847) printf( "*** CRC ERROR! ***\n" );                  printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
758  #endif                             cpu->name, t, s,
759  #if 1                             (s!=0xd878c722)?"| ERROR": "");
760      TEST_QUANT2(quant_intra, Dst, Src);  
761      printf( "%s -    quant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(quant_h263_intra, Dst, Src);
762      if (s!=25662) printf( "*** CRC ERROR! ***\n" );                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
763                               cpu->name, t, s,
764      TEST_QUANT(quant_inter, Dst, Src);                             (s!=0x2eba9d43)?"| ERROR": "");
765      printf( "%s -    quant_inter %.3f usec       crc=%d\n", cpu->name, t, s );  
766      if (s!=23972) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT(quant_h263_inter, Dst, Src);
767  #endif                  printf("%s -   quant_h263_inter %.3f usec       crc32=0x%08x %s\n",
768  #if 1                             cpu->name, t, s,
769      TEST_QUANT2(dequant_intra, Dst, Src);                             (s!=0xbd315a7e)?"| ERROR": "");
770      printf( "%s -  dequant_intra %.3f usec       crc=%d\n", cpu->name, t, s );  
771      if (s!=49900) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
772                    printf("%s - dequant_h263_intra %.3f usec       crc32=0x%08x %s\n",
773      TEST_QUANT(dequant_inter, Dst, Src);                             cpu->name, t, s,
774      printf( "%s -  dequant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                             (s!=0x9841212a)?"| ERROR": "");
775      if (s!=48899) printf( "*** CRC ERROR! ***\n" );  
776  #endif                  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    }    }
872  }  }
# Line 622  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 642  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  }  }
# Line 783  Line 1053 
1053    }    }
1054  }  }
1055    
1056  //////////////////////////////////////////////////////////  ///* ////////////////////////////////////////////////////// */
1057  /* Pseudo-random generator specified by IEEE 1180 */  /* Pseudo-random generator specified by IEEE 1180 */
1058    
1059  static long ieee_seed = 1;  static long ieee_seed = 1;
# Line 870  Line 1140 
1140    static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };    static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };
1141    int Loops = 10000;    int Loops = 10000;
1142    int i, m, n;    int i, m, n;
1143    short Blk0[64];     // reference          DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1144    short Blk[64], iBlk[64];          DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1145    short Ref_FDCT[64];          DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1146    short Ref_IDCT[64];          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          STATS_8x8 FStats; /* forward dct stats */
1150    STATS_8x8 IStats; // inverse dct stats          STATS_8x8 IStats; /* inverse dct stats */
1151    
1152    CPU *cpu;    CPU *cpu;
1153    
# Line 899  Line 1170 
1170        for(i=0; i<64; ++i)        for(i=0; i<64; ++i)
1171          Blk0[i] = (short)ieee_rand(Min,Max) * Sign;          Blk0[i] = (short)ieee_rand(Min,Max) * Sign;
1172    
1173          // hmm, I'm not quite sure this is exactly                          /* hmm, I'm not quite sure this is exactly */
1174          // the tests described in the norm. check...                          /* the tests described in the norm. check... */
1175    
1176        memcpy(Ref_FDCT, Blk0, 64*sizeof(short));        memcpy(Ref_FDCT, Blk0, 64*sizeof(short));
1177        ref_fdct(Ref_FDCT);        ref_fdct(Ref_FDCT);
# Line 927  Line 1198 
1198    
1199      printf( "\n  -- FDCT report --\n" );      printf( "\n  -- FDCT report --\n" );
1200  //    print_stats(&FStats);  //    print_stats(&FStats);
1201      report_stats(&FStats, 0); // so far I know, IEEE1180 says nothing for fdct                  report_stats(&FStats, 0); /* so far I know, IEEE1180 says nothing for fdct */
1202    
1203      for(i=0; i<64; i++) Blk[i] = 0;      for(i=0; i<64; i++) Blk[i] = 0;
1204      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
# Line 949  Line 1220 
1220    
1221  void test_dct_saturation(int Min, int Max)  void test_dct_saturation(int Min, int Max)
1222  {  {
1223      // test behaviour on input range fringe  /* test behaviour on input range fringe */
1224    
1225    int i, n, p;    int i, n, p;
1226    CPU *cpu;    CPU *cpu;
1227  //  const short IDCT_MAX =  2047;  // 12bits input  //  const short IDCT_MAX =  2047;  /* 12bits input */
1228  //  const short IDCT_MIN = -2048;  //  const short IDCT_MIN = -2048;
1229  //  const short IDCT_OUT =   256;  // 9bits ouput  //  const short IDCT_OUT =   256;  /* 9bits ouput */
1230    const int Partitions = 4;    const int Partitions = 4;
1231    const int Loops = 10000 / Partitions;    const int Loops = 10000 / Partitions;
1232    
# Line 972  Line 1243 
1243      printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",      printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",
1244        cpu->name, Min, Max );        cpu->name, Min, Max );
1245    
1246                // FDCT tests //                  /* FDCT tests // */
1247    
1248      init_stats(&Stats);      init_stats(&Stats);
1249    
1250        // test each computation channels separately                  /* test each computation channels separately */
1251      for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;      for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;
1252      ref_fdct(Blk0);      ref_fdct(Blk0);
1253      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
# Line 987  Line 1258 
1258      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
1259      store_stats(&Stats, Blk, Blk0);      store_stats(&Stats, Blk, Blk0);
1260    
1261        // randomly saturated inputs                  /* randomly saturated inputs */
1262      for(p=0; p<Partitions; ++p)      for(p=0; p<Partitions; ++p)
1263      {      {
1264        for(n=0; n<Loops; ++n)        for(n=0; n<Loops; ++n)
# Line 1003  Line 1274 
1274      report_stats(&Stats, 0);      report_stats(&Stats, 0);
1275    
1276    
1277                // IDCT tests //                  /* IDCT tests // */
1278  #if 0  #if 0
1279        // no finished yet                  /* no finished yet */
1280    
1281      init_stats(&Stats);      init_stats(&Stats);
1282    
1283      // test each computation channel separately  /* test each computation channel separately */
1284      for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 0;      for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 0;
1285      ref_idct(Blk0);      ref_idct(Blk0);
1286      emms(); idct(Blk); emms();      emms(); idct(Blk); emms();
# Line 1022  Line 1293 
1293      for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }      for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1294      store_stats(&Stats, Blk, Blk0);      store_stats(&Stats, Blk, Blk0);
1295    
1296        // randomly saturated inputs                  /* randomly saturated inputs */
1297      for(p=0; p<Partitions; ++p)      for(p=0; p<Partitions; ++p)
1298      {      {
1299        for(n=0; n<Loops; ++n)        for(n=0; n<Loops; ++n)
# Line 1052  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 1062  Line 1333 
1333    int buf_size, pos;    int buf_size, pos;
1334    uint32_t chksum = 0;    uint32_t chksum = 0;
1335    
1336            memset(&xinit, 0, sizeof(xinit));
1337          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;
1338          xvid_init(NULL, 0, &xinit, NULL);          xinit.version = XVID_VERSION;
1339          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          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 1091  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 1107  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 1122  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 1138  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 1151  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 1163  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, 31, 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 1173  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 1182  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, 31);                  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 1194  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 precision 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 1227  Line 1504 
1504    const int max_Q = 31;    const int max_Q = 31;
1505    int i, n, qm, q;    int i, n, qm, q;
1506    CPU *cpu;    CPU *cpu;
1507    int16_t  Src[8*8], Dst[8*8];          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];    uint8_t Quant[8*8];
1510    CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };    CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1511    uint16_t Crcs_Inter[2][32];    uint16_t Crcs_Inter[2][32];
1512    uint16_t Crcs_Intra[2][32];    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" );    printf( "\n =====  test MPEG4-quantize bug =====\n" );
1516    
1517    for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;    for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;
# Line 1240  Line 1520 
1520    for(qm=1; qm<=255; ++qm)    for(qm=1; qm<=255; ++qm)
1521    {    {
1522      for(i=0; i<8*8; ++i) Quant[i] = qm;      for(i=0; i<8*8; ++i) Quant[i] = qm;
1523      set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1524    
1525      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1526      {      {
# Line 1251  Line 1531 
1531    
1532        for(q=1; q<=max_Q; ++q) {        for(q=1; q<=max_Q; ++q) {
1533          emms();          emms();
1534          quant4_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1535          emms();          emms();
1536          for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;          for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1537          Crcs_Inter[n][q] = s;          Crcs_Inter[n][q] = s;
# Line 1270  Line 1550 
1550    for(qm=1; qm<=255; ++qm)    for(qm=1; qm<=255; ++qm)
1551    {    {
1552      for(i=0; i<8*8; ++i) Quant[i] = qm;      for(i=0; i<8*8; ++i) Quant[i] = qm;
1553      set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1554    
1555      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1556      {      {
# Line 1281  Line 1561 
1561    
1562        for(q=1; q<=max_Q; ++q) {        for(q=1; q<=max_Q; ++q) {
1563          emms();          emms();
1564          quant4_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1565          emms();          emms();
1566          for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;          for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1567          Crcs_Intra[n][q] = s;          Crcs_Intra[n][q] = s;
# Line 1311  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) {    if (what==7) {
1597      test_IEEE1180_compliance(-256, 255, 1);      test_IEEE1180_compliance(-256, 255, 1);
 #if 0  
1598      test_IEEE1180_compliance(-256, 255,-1);      test_IEEE1180_compliance(-256, 255,-1);
1599      test_IEEE1180_compliance(  -5,   5, 1);      test_IEEE1180_compliance(  -5,   5, 1);
1600      test_IEEE1180_compliance(  -5,   5,-1);      test_IEEE1180_compliance(  -5,   5,-1);
1601      test_IEEE1180_compliance(-300, 300, 1);      test_IEEE1180_compliance(-300, 300, 1);
1602      test_IEEE1180_compliance(-300, 300,-1);      test_IEEE1180_compliance(-300, 300,-1);
 #endif  
1603    }    }
1604    if (what==8) test_dct_saturation(-256, 255);    if (what==8) test_dct_saturation(-256, 255);
1605    
# Line 1342  Line 1621 
1621    if (what==-2)    if (what==-2)
1622      test_quant_bug();      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 07/01/2002, there's a problem with mpeg4-quantization */  /* 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 -  3.312 usec       PSNR=13.291  MSE=3.000  PLAINC -  2.867 usec       PSNR=13.291  MSE=3.000
1656  MMX    -  0.591 usec       PSNR=13.291  MSE=3.000  MMX    -  -0.211 usec       PSNR=9.611  MSE=7.000
1657  MMXEXT -  0.577 usec       PSNR=13.291  MSE=3.000  MMXEXT -  -0.256 usec       PSNR=9.611  MSE=7.000
1658  SSE2   -  0.588 usec       PSNR=13.291  MSE=3.000  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 0.911 usec       iCrc=8107  PLAINC - interp- h-round0 0.538 usec       crc32=0x115381ba
1663  PLAINC -           round1 0.863 usec       iCrc=8100  PLAINC -           round1 0.527 usec       crc32=0x2b1f528f
1664  PLAINC - interp- v-round0 0.860 usec       iCrc=8108  PLAINC - interp- v-round0 0.554 usec       crc32=0x423cdcc7
1665  PLAINC -           round1 0.857 usec       iCrc=8105  PLAINC -           round1 0.551 usec       crc32=0x42202efe
1666  PLAINC - interp-hv-round0 2.103 usec       iCrc=8112  PLAINC - interp-hv-round0 1.041 usec       crc32=0xd198d387
1667  PLAINC -           round1 2.050 usec       iCrc=8103  PLAINC -           round1 1.038 usec       crc32=0x9ecfd921
1668   ---   ---
1669  MMX    - interp- h-round0 0.105 usec       iCrc=8107  MMX    - interp- h-round0 0.051 usec       crc32=0x115381ba
1670  MMX    -           round1 0.106 usec       iCrc=8100  MMX    -           round1 0.053 usec       crc32=0x2b1f528f
1671  MMX    - interp- v-round0 0.106 usec       iCrc=8108  MMX    - interp- v-round0 0.048 usec       crc32=0x423cdcc7
1672  MMX    -           round1 0.106 usec       iCrc=8105  MMX    -           round1 0.048 usec       crc32=0x42202efe
1673  MMX    - interp-hv-round0 0.145 usec       iCrc=8112  MMX    - interp-hv-round0 0.074 usec       crc32=0xd198d387
1674  MMX    -           round1 0.145 usec       iCrc=8103  MMX    -           round1 0.073 usec       crc32=0x9ecfd921
1675   ---   ---
1676  MMXEXT - interp- h-round0 0.028 usec       iCrc=8107  MMXEXT - interp- h-round0 0.020 usec       crc32=0x115381ba
1677  MMXEXT -           round1 0.041 usec       iCrc=8100  MMXEXT -           round1 0.025 usec       crc32=0x2b1f528f
1678  MMXEXT - interp- v-round0 0.027 usec       iCrc=8108  MMXEXT - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1679  MMXEXT -           round1 0.041 usec       iCrc=8105  MMXEXT -           round1 0.024 usec       crc32=0x42202efe
1680  MMXEXT - interp-hv-round0 0.066 usec       iCrc=8112  MMXEXT - interp-hv-round0 0.037 usec       crc32=0xd198d387
1681  MMXEXT -           round1 0.065 usec       iCrc=8103  MMXEXT -           round1 0.037 usec       crc32=0x9ecfd921
1682   ---   ---
1683  SSE2   - interp- h-round0 0.109 usec       iCrc=8107  3DNOW  - interp- h-round0 0.020 usec       crc32=0x115381ba
1684  SSE2   -           round1 0.105 usec       iCrc=8100  3DNOW  -           round1 0.029 usec       crc32=0x2b1f528f
1685  SSE2   - interp- v-round0 0.106 usec       iCrc=8108  3DNOW  - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1686  SSE2   -           round1 0.109 usec       iCrc=8105  3DNOW  -           round1 0.024 usec       crc32=0x42202efe
1687  SSE2   - interp-hv-round0 0.145 usec       iCrc=8112  3DNOW  - interp-hv-round0 0.038 usec       crc32=0xd198d387
1688  SSE2   -           round1 0.145 usec       iCrc=8103  3DNOW  -           round1 0.039 usec       crc32=0x9ecfd921
1689     ---
1690    3DNOWE - interp- h-round0 0.020 usec       crc32=0x115381ba
1691    3DNOWE -           round1 0.024 usec       crc32=0x2b1f528f
1692    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.251 usec       sad=3776  PLAINC - sad8    0.505 usec       sad=3776
1700  PLAINC - sad16   1.601 usec       sad=27214  PLAINC - sad16   1.941 usec       sad=27214
1701  PLAINC - sad16bi 2.371 usec       sad=26274  PLAINC - sad16bi 4.925 usec       sad=26274
1702  PLAINC - dev16   1.564 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.182 usec       sad=27214  MMX    - sad16   0.107 usec       sad=27214
1706  MMX    - sad16bi 2.462 usec       sad=26274  MMX    - sad16bi 0.259 usec       sad=26274
1707  MMX    - dev16   0.311 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.109 usec       sad=27214  MMXEXT - sad16   0.050 usec       sad=27214
1711  MMXEXT - sad16bi 0.143 usec       sad=26274  MMXEXT - sad16bi 0.060 usec       sad=26274
1712  MMXEXT - dev16   0.192 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.179 usec       sad=27214  3DNOW  - sad16   1.954 usec       sad=27214
1716  SSE2   - sad16bi 2.456 usec       sad=26274  3DNOW  - sad16bi 0.119 usec       sad=26274
1717  SSE2   - dev16   0.321 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.151 usec       crc=28288  PLAINC - 8to16     0.603 usec       crc32=0x115814bb
1727  PLAINC - 16to8     1.113 usec       crc=28288  PLAINC - 16to8     1.077 usec       crc32=0xee7ccbb4
1728  PLAINC - 8to8      0.043 usec       crc=20352  PLAINC - 8to8      0.679 usec       crc32=0xd37b3295
1729  PLAINC - 16to8add  1.069 usec       crc=25536  PLAINC - 16to8add  1.341 usec       crc32=0xdd817bf4
1730  PLAINC - 8to16sub  0.631 usec       crc1=28064 crc2=16256  PLAINC - 8to16sub  1.566 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1731  PLAINC - 8to16sub2 0.597 usec       crc=20384  PLAINC - 8to16sub2 2.206 usec       crc32=0x99b6c4c7
1732   ---   ---
1733  MMX    - 8to16     0.032 usec       crc=28288  MMX    - 8to16     -0.025 usec       crc32=0x115814bb
1734  MMX    - 16to8     0.024 usec       crc=28288  MMX    - 16to8     -0.049 usec       crc32=0xee7ccbb4
1735  MMX    - 8to8      0.020 usec       crc=20352  MMX    - 8to8      0.014 usec       crc32=0xd37b3295
1736  MMX    - 16to8add  0.043 usec       crc=25536  MMX    - 16to8add  0.011 usec       crc32=0xdd817bf4
1737  MMX    - 8to16sub  0.066 usec       crc1=28064 crc2=16256  MMX    - 8to16sub  0.108 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1738  MMX    - 8to16sub2 0.111 usec       crc=20384  MMX    - 8to16sub2 0.164 usec       crc32=0x99b6c4c7
1739     ---
1740    MMXEXT - 8to16     -0.054 usec       crc32=0x115814bb
1741    MMXEXT - 16to8     0.010 usec       crc32=0xee7ccbb4
1742    MMXEXT - 8to8      0.015 usec       crc32=0xd37b3295
1743    MMXEXT - 16to8add  0.008 usec       crc32=0xdd817bf4
1744    MMXEXT - 8to16sub  0.263 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1745    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 74.248 usec       crc=29809  PLAINC -   quant_mpeg_intra 98.631 usec       crc32=0xfd6a21a4
1764  PLAINC -   quant4_inter 70.850 usec       crc=12574  PLAINC -   quant_mpeg_inter 104.876 usec       crc32=0xf6de7757
1765  PLAINC - dequant4_intra 40.628 usec       crc=24052  PLAINC - dequant_mpeg_intra 50.285 usec       crc32=0x2def7bc7
1766  PLAINC - dequant4_inter 45.691 usec       crc=63847  PLAINC - dequant_mpeg_inter 58.316 usec       crc32=0xd878c722
1767  PLAINC -    quant_intra 43.357 usec       crc=25662  PLAINC -   quant_h263_intra 33.803 usec       crc32=0x2eba9d43
1768  PLAINC -    quant_inter 33.410 usec       crc=23972  PLAINC -   quant_h263_inter 45.411 usec       crc32=0xbd315a7e
1769  PLAINC -  dequant_intra 36.384 usec       crc=49900  PLAINC - dequant_h263_intra 39.302 usec       crc32=0x9841212a
1770  PLAINC -  dequant_inter 48.930 usec       crc=48899  PLAINC - dequant_h263_inter 44.124 usec       crc32=0xe7df8fba
1771   ---   ---
1772  MMX    -   quant4_intra 7.445 usec       crc=3459  MMX    -   quant_mpeg_intra 4.273 usec       crc32=0xdacabdb6 | ERROR
1773  *** CRC ERROR! ***  MMX    -   quant_mpeg_inter 3.576 usec       crc32=0x72883ab6 | ERROR
1774  MMX    -   quant4_inter 5.384 usec       crc=51072  MMX    - dequant_mpeg_intra 3.793 usec       crc32=0x2def7bc7
1775  *** CRC ERROR! ***  MMX    - dequant_mpeg_inter 4.808 usec       crc32=0xd878c722
1776  MMX    - dequant4_intra 5.515 usec       crc=24052  MMX    -   quant_h263_intra 2.881 usec       crc32=0x2eba9d43
1777  MMX    - dequant4_inter 7.745 usec       crc=63847  MMX    -   quant_h263_inter 2.550 usec       crc32=0xbd315a7e
1778  MMX    -    quant_intra 4.661 usec       crc=25662  MMX    - dequant_h263_intra 2.974 usec       crc32=0x9841212a
1779  MMX    -    quant_inter 4.406 usec       crc=23972  MMX    - dequant_h263_inter 2.906 usec       crc32=0xe7df8fba
1780  MMX    -  dequant_intra 4.928 usec       crc=49900   ---
1781  MMX    -  dequant_inter 4.532 usec       crc=48899  MMXEXT -   quant_mpeg_intra 4.221 usec       crc32=0xfd6a21a4
1782    MMXEXT -   quant_mpeg_inter 4.339 usec       crc32=0xf6de7757
1783    MMXEXT - dequant_mpeg_intra 3.802 usec       crc32=0x2def7bc7
1784    MMXEXT - dequant_mpeg_inter 4.821 usec       crc32=0xd878c722
1785    MMXEXT -   quant_h263_intra 2.884 usec       crc32=0x2eba9d43
1786    MMXEXT -   quant_h263_inter 2.554 usec       crc32=0xbd315a7e
1787    MMXEXT - dequant_h263_intra 2.728 usec       crc32=0x9841212a
1788    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.371 usec       cbp=0x15  PLAINC -   calc_cbp#1 0.168 usec       cbp=0x15
1811  PLAINC -   calc_cbp#2 0.432 usec       cbp=0x38  PLAINC -   calc_cbp#2 0.168 usec       cbp=0x38
1812  PLAINC -   calc_cbp#3 0.339 usec       cbp=0xf  PLAINC -   calc_cbp#3 0.157 usec       cbp=0x0f
1813  PLAINC -   calc_cbp#4 0.506 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.134 usec       cbp=0x38  MMX    -   calc_cbp#2 0.062 usec       cbp=0x38
1817  MMX    -   calc_cbp#3 0.138 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.136 usec       cbp=0x15  MMXEXT -   calc_cbp#1 0.062 usec       cbp=0x15
1821  SSE2   -   calc_cbp#2 0.133 usec       cbp=0x38  MMXEXT -   calc_cbp#2 0.061 usec       cbp=0x38
1822  SSE2   -   calc_cbp#3 0.133 usec       cbp=0xf  MMXEXT -   calc_cbp#3 0.061 usec       cbp=0x0f
1823  SSE2   -   calc_cbp#4 0.141 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.898  
changed lines
  Added in v.1586
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4