[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 824, Sun Feb 9 19:32:52 2003 UTC revision 1641, Fri Sep 23 12:53:35 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.25 2005-09-23 12:53:35 suxen_drol 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)...  
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>
 #ifdef  WIN32  
 #include <time.h>  /* for clock */  
 #else  
 #include <sys/time.h>  /* for gettimeofday */  
 #endif  
37  #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
50  #include "dct/idct.h"  #include "dct/idct.h"
51  #include "dct/fdct.h"  #include "dct/fdct.h"
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 60  Line 60 
60  #include "bitstream/cbp.h"  #include "bitstream/cbp.h"
61    
62  #include <math.h>  #include <math.h>
63    
64  #ifndef M_PI  #ifndef M_PI
65  #  define M_PI     3.14159265359  #define M_PI            3.14159265358979323846
 #  define M_PI_2   1.5707963268  
66  #endif  #endif
67  const int speed_ref = 100;  /* on slow machines, decrease this value */  
68    int speed_ref = 100;  /* on slow machines, decrease this value */
69    int verbose = 0;
70    unsigned int cpu_mask;
71    
72  /*********************************************************************  /*********************************************************************
73   * misc   * misc
# Line 73  Line 76 
76   /* returns time in micro-s*/   /* returns time in micro-s*/
77  double gettime_usec()  double gettime_usec()
78  {  {
79  #ifdef  WIN32  #ifndef WIN32
   return clock()*1000;  
 #else  
80    struct timeval  tv;    struct timeval  tv;
81    gettimeofday(&tv, 0);    gettimeofday(&tv, 0);
82    return tv.tv_sec*1.0e6 + tv.tv_usec;    return tv.tv_sec*1.0e6 + tv.tv_usec;
83    #else
84            clock_t clk;
85            clk = clock();
86            return clk * 1000. / CLOCKS_PER_SEC;  /* clock() returns time in Milliseconds */
87  #endif  #endif
88  }  }
89    
# Line 107  Line 112 
112    unsigned int cpu;    unsigned int cpu;
113  } CPU;  } CPU;
114    
115  CPU cpu_list[] =  CPU cpu_list[] = {
116  { { "PLAINC", 0 }          { "PLAINC ", 0 },
117  , { "MMX   ", XVID_CPU_MMX }  #ifdef ARCH_IS_IA32
118  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }          { "MMX    ", XVID_CPU_MMX },
119  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }          { "MMXEXT ", XVID_CPU_MMXEXT | XVID_CPU_MMX },
120  , { "3DNOW ", XVID_CPU_3DNOW }          { "SSE2   ", XVID_CPU_SSE2 | XVID_CPU_MMX },
121  , { "3DNOWE", XVID_CPU_3DNOWEXT }          { "3DNOW  ", XVID_CPU_3DNOW },
122  , { "IA64  ", XVID_CPU_IA64 }          { "3DNOWE ", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT },
123  /*, { "TSC   ", XVID_CPU_TSC } */  #endif
124  , { 0, 0 } }  #ifdef ARCH_IS_PPC
125            { "ALTIVEC", XVID_CPU_ALTIVEC },
126  , cpu_short_list[] =  #endif
127  { { "PLAINC", 0 }  #ifdef ARCH_IS_X86_64
128  , { "MMX   ", XVID_CPU_MMX }          { "X86_64 ", XVID_CPU_ASM},
129  /*, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX } */  #endif
130  , { "IA64  ", XVID_CPU_IA64 }  #ifdef ARCH_IS_IA64
131  , { 0, 0 } }  //      { "IA64   ", XVID_CPU_IA64 },
132    #endif
133  , cpu_short_list2[] =  //      { "TSC    ", XVID_CPU_TSC },
134  { { "PLAINC", 0 }          { 0, 0 }
135  , { "MMX   ", XVID_CPU_MMX }  };
 , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  
 , { 0, 0 } };  
136    
137    
138  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
139  {  {
140    int xerr, cpu_type;          xvid_gbl_info_t xinfo;
141    XVID_INIT_PARAM xinit;  
142            /* Get the available CPU flags */
143            memset(&xinfo, 0, sizeof(xinfo));
144            xinfo.version = XVID_VERSION;
145            xvid_global(NULL, XVID_GBL_INFO, &xinfo, NULL);
146    
147    cpu_type = check_cpu_features() & cpu->cpu;          /* Are we trying to test a subset of the host CPU features */
148    xinit.cpu_flags = cpu_type | XVID_CPU_FORCE;          if ((xinfo.cpu_flags & cpu->cpu) == cpu->cpu) {
149    /*    xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE; */                  int xerr;
150    xerr = xvid_init(NULL, 0, &xinit, NULL);                  xvid_gbl_init_t xinit;
151    if (cpu->cpu>0 && (cpu_type==0 || xerr!=XVID_ERR_OK)) {                  memset(&xinit, 0, sizeof(xinit));
152      printf( "%s - skipped...\n", cpu->name );                  xinit.cpu_flags = cpu->cpu | XVID_CPU_FORCE;
153                    xinit.version = XVID_VERSION;
154                    xerr = xvid_global(NULL, XVID_GBL_INIT, &xinit, NULL);
155                    if (xerr==XVID_ERR_FAIL) {
156                            /* libxvidcore failed to init */
157      return 0;      return 0;
158    }    }
159            } else {
160                    /* The host CPU doesn't support some required feature for this test */
161                    return(0);
162            }
163    return 1;    return 1;
164  }  }
165    
166    #define CRC32_REMAINDER 0xCBF43926
167    #define CRC32_INITIAL 0xffffffff
168    
169    #define DO1(c, crc) ((crc) = crc32tab[((unsigned int)((crc)>>24) ^ (*c++)) & 0xff] ^ ((crc) << 8))
170    #define DO2(c, crc)  DO1(c, crc); DO1(c, crc);
171    #define DO4(c, crc)  DO2(c, crc); DO2(c, crc);
172    #define DO8(c, crc)  DO4(c, crc); DO4(c, crc);
173    
174    /******************************************************************************
175    * Precomputed AAL5 CRC32 lookup table
176    ******************************************************************************/
177    
178    static unsigned long crc32tab[256] = {
179    
180            0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
181            0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
182            0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
183            0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
184            0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
185            0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
186            0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
187            0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
188            0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
189            0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
190            0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
191            0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
192            0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
193            0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
194            0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
195            0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
196            0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
197            0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
198            0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
199            0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
200            0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
201            0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
202            0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
203            0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
204            0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
205            0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
206            0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
207            0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
208            0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
209            0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
210            0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
211            0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
212            0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
213            0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
214            0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
215            0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
216            0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
217            0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
218            0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
219            0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
220            0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
221            0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
222            0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
223            0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
224            0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
225            0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
226            0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
227            0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
228            0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
229            0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
230            0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
231            0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
232            0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
233            0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
234            0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
235            0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
236            0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
237            0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
238            0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
239            0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
240            0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
241            0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
242            0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
243            0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
244    
245    };
246    
247    uint32_t
248    calc_crc(uint8_t *mem, int len, uint32_t crc)
249    {
250            while( len >= 8) {
251                    DO8(mem, crc);
252                    len -= 8;
253            }
254    
255            while( len ) {
256                    DO1(mem, crc);
257                    len--;
258            }
259    
260            return crc;
261    }
262    
263    void byte_swap(uint8_t *mem, int len, int element_size) {
264    #ifdef ARCH_IS_BIG_ENDIAN
265            int i;
266    
267            if(element_size == 1) {
268                    /* No need to swap */
269            } else if(element_size == 2) {
270                    uint8_t temp[2];
271    
272                    for(i=0; i < (len/2); i++ ) {
273                            temp[0] = mem[0];
274                            temp[1] = mem[1];
275                            mem[0] = temp[1];
276                            mem[1] = temp[0];
277    
278                            mem += 2;
279                    }
280            } else if(element_size == 4) {
281                    uint8_t temp[4];
282    
283                    for(i=0; i < (len/4); i++ ) {
284                            temp[0] = mem[0];
285                            temp[1] = mem[1];
286                            temp[2] = mem[2];
287                            temp[3] = mem[3];
288                            mem[0] = temp[3];
289                            mem[1] = temp[2];
290                            mem[2] = temp[1];
291                            mem[3] = temp[0];
292    
293                            mem += 4;
294                    }
295            } else {
296                    printf("ERROR: byte_swap unsupported element_size(%u)\n", element_size);
297            }
298    #endif
299    }
300    
301  /*********************************************************************  /*********************************************************************
302   * test DCT   * test DCT
303   *********************************************************************/   *********************************************************************/
# Line 160  Line 310 
310    int tst;    int tst;
311    CPU *cpu;    CPU *cpu;
312    int i;    int i;
313    short iDst0[8*8], iDst[8*8], fDst[8*8];          DECLARE_ALIGNED_MATRIX(iDst0, 8, 8, short, 16);
314            DECLARE_ALIGNED_MATRIX(iDst,  8, 8, short, 16);
315            DECLARE_ALIGNED_MATRIX(fDst,  8, 8, short, 16);
316    double overhead;    double overhead;
317    
318    printf( "\n ===== test fdct/idct =====\n" );    printf( "\n ===== test fdct/idct =====\n" );
# Line 198  Line 350 
350        MSE += delta*delta;        MSE += delta*delta;
351      }      }
352      PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );      PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
353      printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f\n",                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
354        cpu->name, t, PSNR, MSE );                                  cpu->name, t, PSNR, MSE,
355      if (ABS(MSE)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
356    }    }
357  }  }
358    
# Line 214  Line 366 
366    int tst;    int tst;
367    CPU *cpu;    CPU *cpu;
368    int i;    int i;
369    uint8_t Cur[16*16], Ref1[16*16], Ref2[16*16];          DECLARE_ALIGNED_MATRIX(Cur,  16, 16, uint8_t, 16);
370            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
371            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
372    
373    printf( "\n ======  test SAD ======\n" );    printf( "\n ======  test SAD ======\n" );
374    for(i=0; i<16*16;++i) {    for(i=0; i<16*16;++i) {
# Line 235  Line 389 
389      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
390      emms();      emms();
391      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
392      printf( "%s - sad8    %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad8    %.3f usec       sad=%d %s\n",
393      if (s!=3776) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
394                               (s!=3776)?"| ERROR": "" );
395    
396      t = gettime_usec();      t = gettime_usec();
397      emms();      emms();
398      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);
399      emms();      emms();
400      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
401      printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad16   %.3f usec       sad=%d %s\n",
402      if (s!=27214) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
403                               (s!=27214)?"| ERROR": "" );
404    
405      t = gettime_usec();      t = gettime_usec();
406      emms();      emms();
407      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);
408      emms();      emms();
409      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
410      printf( "%s - sad16bi %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - sad16bi %.3f usec       sad=%d %s\n",
411      if (s!=26274) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
412                                    (s!=26274)?"| ERROR": "" );
413    
414      t = gettime_usec();      t = gettime_usec();
415      emms();      emms();
416      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
417      emms();      emms();
418      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
419      printf( "%s - dev16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - dev16   %.3f usec       sad=%d %s\n",
420      if (s!=3344) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
421                                    (s!=3344)?"| ERROR": "" );
422    
423      printf( " --- \n" );      printf( " --- \n" );
424    }    }
# Line 278  Line 436 
436  #define LEAVE \  #define LEAVE \
437      emms();                             \      emms();                             \
438      t = (gettime_usec() - t) / nb_tests;  \      t = (gettime_usec() - t) / nb_tests;  \
439      iCrc = 0;                           \          iCrc = calc_crc((uint8_t*)Dst, sizeof(Dst), CRC32_INITIAL)
     for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }  
440    
441  #define TEST_MB(FUNC, R)                \  #define TEST_MB(FUNC, R)                \
442      ENTER                               \      ENTER                               \
# Line 298  Line 455 
455    CPU *cpu;    CPU *cpu;
456    const uint8_t Src0[16*9] = {    const uint8_t Src0[16*9] = {
457          /* try to have every possible combinaison of rounding... */          /* try to have every possible combinaison of rounding... */
458        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,
459      , 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,
460      , 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,
461      , 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,
462      , 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,
463      , 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,
464      , 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,
465      , 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,
466      , 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
467    };    };
468    uint8_t Dst[16*8] = {0};    uint8_t Dst[16*8] = {0};
469    
# Line 321  Line 478 
478        continue;        continue;
479    
480      TEST_MB(interpolate8x8_halfpel_h, 0);      TEST_MB(interpolate8x8_halfpel_h, 0);
481      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",
482      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
483                               (iCrc!=0x115381ba)?"| ERROR": "" );
484    
485      TEST_MB(interpolate8x8_halfpel_h, 1);      TEST_MB(interpolate8x8_halfpel_h, 1);
486      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
487      if (iCrc!=8100) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
488                               (iCrc!=0x2b1f528f)?"| ERROR": "" );
489    
490    
491      TEST_MB(interpolate8x8_halfpel_v, 0);      TEST_MB(interpolate8x8_halfpel_v, 0);
492      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",
493      if (iCrc!=8108) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
494                               (iCrc!=0x423cdcc7)?"| ERROR": "" );
495    
496      TEST_MB(interpolate8x8_halfpel_v, 1);      TEST_MB(interpolate8x8_halfpel_v, 1);
497      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
498      if (iCrc!=8105) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
499                               (iCrc!=0x42202efe)?"| ERROR": "" );
500    
501    
502      TEST_MB(interpolate8x8_halfpel_hv, 0);      TEST_MB(interpolate8x8_halfpel_hv, 0);
503      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",
504      if (iCrc!=8112) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
505                               (iCrc!=0xd198d387)?"| ERROR": "" );
506    
507      TEST_MB(interpolate8x8_halfpel_hv, 1);      TEST_MB(interpolate8x8_halfpel_hv, 1);
508      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
509      if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
510                               (iCrc!=0x9ecfd921)?"| ERROR": "" );
511    
512    
513         /* this is a new function, as of 06.06.2002 */         /* this is a new function, as of 06.06.2002 */
514  #if 0  #if 0
515      TEST_MB2(interpolate8x8_avrg);      TEST_MB2(interpolate8x8_avrg);
516      printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
517      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
518                               (iCrc!=8107)?"| ERROR": "" );
519  #endif  #endif
520    
521      printf( " --- \n" );      printf( " --- \n" );
# Line 387  Line 551 
551      }                                         \      }                                         \
552      emms();                                   \      emms();                                   \
553      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
554      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]^i; }  byte_swap((uint8_t*)(DST), 8*32*sizeof((DST)[0]), sizeof((DST)[0]));  \
555    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
556    
557  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
558      TEST_TRANSFER_BEGIN(DST);                 \      TEST_TRANSFER_BEGIN(DST);                 \
# Line 413  Line 578 
578      }                                         \      }                                         \
579      emms();                                   \      emms();                                   \
580      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
581      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]; }  byte_swap((uint8_t*)(DST), 8*32*sizeof((DST)[0]), sizeof((DST)[0]));  \
582    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
583    
584  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
585      TEST_TRANSFER2_BEGIN(DST,SRC);            \      TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 430  Line 596 
596    const int nb_tests = 4000*speed_ref;    const int nb_tests = 4000*speed_ref;
597    int i;    int i;
598    CPU *cpu;    CPU *cpu;
599    uint8_t  Src8[8*32], Dst8[8*32], Ref1[8*32], Ref2[8*32];  //      uint8_t  Src8[8*32], Dst8[8*32], Ref1[8*32], Ref2[8*32];
600    int16_t Src16[8*32], Dst16[8*32];  //      int16_t Src16[8*32], Dst16[8*32];
601      DECLARE_ALIGNED_MATRIX(Src8, 8, 32, uint8_t, CACHE_LINE);
602      DECLARE_ALIGNED_MATRIX(Dst8, 8, 32, uint8_t, CACHE_LINE);
603      DECLARE_ALIGNED_MATRIX(Ref1, 8, 32, uint8_t, CACHE_LINE);
604      DECLARE_ALIGNED_MATRIX(Ref2, 8, 32, uint8_t, CACHE_LINE);
605      DECLARE_ALIGNED_MATRIX(Src16, 8, 32, uint16_t, CACHE_LINE);
606      DECLARE_ALIGNED_MATRIX(Dst16, 8, 32, uint16_t, CACHE_LINE);
607    
608    printf( "\n ===  test transfer ===\n" );    printf( "\n ===  test transfer ===\n" );
609    
610    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
611    {    {
612      double t, overhead;      double t, overhead;
613      int tst, s;      int tst, s;
# Line 444  Line 616 
616        continue;        continue;
617    
618      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
619      printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
620      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
621                               (s!=0x115814bb)?"| ERROR": "");
622    
623      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
624      printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
625      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
626                                    (s!=0xee7ccbb4)?"| ERROR": "");
627    
628      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
629      printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
630      if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
631                               (s!=0xd37b3295)?"| ERROR": "");
632    
633      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
634      printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
635      if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
636                               (s!=0xdd817bf4)?"| ERROR": "" );
637    
638      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
639      printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
640      if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
641      s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }                          s1 = calc_crc((uint8_t*)Dst16, 8*32*sizeof(Dst16[0]), CRC32_INITIAL);
642      printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, 8*32*sizeof(Src8[0]), CRC32_INITIAL);
643      if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
644  #if 1                                     cpu->name, t, s1, s2,
645                                       (s1!=0xa1e07163)?"| ERROR1": "",
646                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
647                    }
648    
649      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
650      printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
651      if (s!=20384) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
652  /*    for(i=0; i<64; ++i) printf( "[%d]", Dst16[i]); */                             (s!=0x99b6c4c7)?"| ERROR": "" );
653  /*    printf("\n"); */  
 #endif  
654      printf( " --- \n" );      printf( " --- \n" );
655    }    }
656  }  }
# Line 482  Line 661 
661    
662  #define TEST_QUANT(FUNC, DST, SRC)              \  #define TEST_QUANT(FUNC, DST, SRC)              \
663      t = gettime_usec();                         \      t = gettime_usec();                         \
664      for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
665        for(i=0; i<8*8; ++i) Quant[i] = qm;       \        for(i=0; i<8*8; ++i) Quant[i] = qm;       \
666        set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
667        emms();                                   \        emms();                                   \
668        for(q=1; q<=max_Q; ++q) {                 \        for(q=1; q<=max_Q; ++q) {                 \
669          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
670            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
671          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
672            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
673        }                                         \        }                                         \
674        emms();                                   \        emms();                                   \
675      }                                           \      }                                           \
676      t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
     s = (s&0xffff)^(s>>16)  
677    
678  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
679      t = gettime_usec();                         \      t = gettime_usec();                         \
680      for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
681        for(i=0; i<8*8; ++i) Quant[i] = qm;       \        for(i=0; i<8*8; ++i) Quant[i] = qm;       \
682        set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
683        emms();                                   \        emms();                                   \
684        for(q=1; q<=max_Q; ++q) {                 \        for(q=1; q<=max_Q; ++q) {                 \
685          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
686            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
687          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
688            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
689        }                                         \        }                                         \
690        emms();                                   \        emms();                                   \
691      }                                           \      }                                           \
692      t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
693      s = (s&0xffff)^(s>>16)  
694    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
695    { int i,q,s;\
696            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
697      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
698      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
699      for(q=1;q<=max_Q;q++)          \
700        for(s=-RANGE;s<RANGE;s++) { \
701          for(i=0;i<64;i++) Src[i]=s; \
702          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
703          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
704          for(i=0;i<64;i++)     \
705            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]);  \
706        }      \
707    }
708    
709    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
710    { int i,q,s;  \
711            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
712      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
713      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
714      for(q=1;q<=max_Q;q++)  \
715        for(s=-RANGE;s<RANGE;s++) {   \
716          for(i=0;i<64;i++) Src[i]=s; \
717          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
718          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
719          emms();           \
720          for(i=0;i<64;i++) \
721            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]); \
722        } \
723    }
724    
725  void test_quant()  void test_quant()
726  {  {
727    const int nb_tests = 1*speed_ref;    const int nb_tests = 1*speed_ref;
728    const int max_Q = 31;    const int max_Q = 31;
729            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
730    
731    int i, qm;    int i, qm;
732    CPU *cpu;    CPU *cpu;
733    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
734            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
735            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
736    uint8_t Quant[8*8];    uint8_t Quant[8*8];
737    
738    printf( "\n =====  test quant =====\n" );    printf( "\n =====  test quant =====\n" );
# Line 530  Line 744 
744      Dst[i] = 0;      Dst[i] = 0;
745    }    }
746    
747    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
748    {    {
749      double t, overhead;      double t, overhead;
750      int tst, q;      int tst, q;
# Line 539  Line 753 
753      if (!init_cpu(cpu))      if (!init_cpu(cpu))
754        continue;        continue;
755    
756                    // exhaustive tests to compare against the (ref) C-version
757                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
758                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
759                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
760                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
761    
762      overhead = -gettime_usec();      overhead = -gettime_usec();
763      for(s=0,qm=1; qm<=255; ++qm) {      for(s=0,qm=1; qm<=255; ++qm) {
764        for(i=0; i<8*8; ++i) Quant[i] = qm;        for(i=0; i<8*8; ++i) Quant[i] = qm;
765        set_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
766        for(q=1; q<=max_Q; ++q)        for(q=1; q<=max_Q; ++q)
767          for(i=0; i<64; ++i) s+=Dst[i]^i^qm;          for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
768      }      }
769      overhead += gettime_usec();      overhead += gettime_usec();
770    
771  #if 1                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
772      TEST_QUANT2(quant4_intra, Dst, Src);                  printf("%s -   quant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
773      printf( "%s -   quant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                             cpu->name, t, s,
774      if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             (s!=0xfd6a21a4)? "| ERROR": "");
775    
776      TEST_QUANT(quant4_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
777      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",
778      if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
779  #endif                             (s!=0xf6de7757)?"| ERROR": "");
780  #if 1  
781      TEST_QUANT2(dequant4_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
782      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",
783      if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
784                               (s!=0x2def7bc7)?"| ERROR": "");
785      TEST_QUANT(dequant4_inter, Dst, Src);  
786      printf( "%s - dequant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
787      if (s!=63847) printf( "*** CRC ERROR! ***\n" );                  printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
788  #endif                             cpu->name, t, s,
789  #if 1                             (s!=0xd878c722)?"| ERROR": "");
790      TEST_QUANT2(quant_intra, Dst, Src);  
791      printf( "%s -    quant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(quant_h263_intra, Dst, Src);
792      if (s!=25662) printf( "*** CRC ERROR! ***\n" );                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
793                               cpu->name, t, s,
794      TEST_QUANT(quant_inter, Dst, Src);                             (s!=0x2eba9d43)?"| ERROR": "");
795      printf( "%s -    quant_inter %.3f usec       crc=%d\n", cpu->name, t, s );  
796      if (s!=23972) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT(quant_h263_inter, Dst, Src);
797  #endif                  printf("%s -   quant_h263_inter %.3f usec       crc32=0x%08x %s\n",
798  #if 1                             cpu->name, t, s,
799      TEST_QUANT2(dequant_intra, Dst, Src);                             (s!=0xbd315a7e)?"| ERROR": "");
800      printf( "%s -  dequant_intra %.3f usec       crc=%d\n", cpu->name, t, s );  
801      if (s!=49900) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
802                    printf("%s - dequant_h263_intra %.3f usec       crc32=0x%08x %s\n",
803      TEST_QUANT(dequant_inter, Dst, Src);                             cpu->name, t, s,
804      printf( "%s -  dequant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                             (s!=0x9841212a)?"| ERROR": "");
805      if (s!=48899) printf( "*** CRC ERROR! ***\n" );  
806  #endif                  TEST_QUANT(dequant_h263_inter, Dst, Src);
807                    printf("%s - dequant_h263_inter %.3f usec       crc32=0x%08x %s\n",
808                               cpu->name, t, s,
809                               (s!=0xe7df8fba)?"| ERROR": "");
810    
811                    printf( " --- \n" );
812            }
813    }
814    
815    /*********************************************************************
816     * test distortion operators
817     *********************************************************************/
818    
819    static void ieee_reseed(long s);
820    static long ieee_rand(int Min, int Max);
821    
822    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
823      do { \
824        t = gettime_usec(); \
825        tst = nb_tests; \
826        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
827        emms(); \
828        t = (gettime_usec() - t)/(double)nb_tests;  \
829      } while(0)
830    
831    
832    void test_sse()
833    {
834            const int nb_tests = 100000*speed_ref;
835            int i;
836            CPU *cpu;
837            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
838            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
839            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
840            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
841    
842            printf( "\n =====  test sse =====\n" );
843    
844            ieee_reseed(1);
845            for(i=0; i<64; ++i) {
846                    Src1[i] = ieee_rand(-2048, 2047);
847                    Src2[i] = ieee_rand(-2048, 2047);
848                    Src3[i] = ieee_rand(-2048, 2047);
849                    Src4[i] = ieee_rand(-2048, 2047);
850            }
851    
852            for(cpu = cpu_list; cpu->name!=0; ++cpu)
853            {
854                    double t;
855                    int tst, sse;
856    
857                    if (!init_cpu(cpu))
858                            continue;
859    
860                    /* 16 bit element blocks */
861                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
862                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
863                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
864                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
865                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
866                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
867                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
868                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
869                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
870                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
871                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
872                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
873                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
874                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
875                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
876                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
877                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
878                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
879    
880                    /* 8 bit element blocks */
881                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
882                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
883                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
884                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
885                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
886                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
887                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
888                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
889                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
890                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
891                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
892                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
893                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
894                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
895                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
896                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
897                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
898                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
899    
900      printf( " --- \n" );      printf( " --- \n" );
901    }    }
902  }  }
# Line 592  Line 905 
905   * test non-zero AC counting   * test non-zero AC counting
906   *********************************************************************/   *********************************************************************/
907    
908  #define TEST_CBP(FUNC, SRC)                   \  #define TEST_CBP(FUNC, SRC, NB)           \
909      t = gettime_usec();                       \      t = gettime_usec();                       \
910      emms();                                   \      emms();                                   \
911      for(tst=0; tst<nb_tests; ++tst) {         \  for(tst=0; tst<NB; ++tst) {         \
912        cbp = (FUNC)((SRC));                    \        cbp = (FUNC)((SRC));                    \
913      }                                         \      }                                         \
914      emms();                                   \      emms();                                   \
# Line 604  Line 917 
917  void test_cbp()  void test_cbp()
918  {  {
919    const int nb_tests = 10000*speed_ref;    const int nb_tests = 10000*speed_ref;
920    int i;          int i, n, m;
921    CPU *cpu;    CPU *cpu;
922    int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
923            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
924            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
925            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
926      DECLARE_ALIGNED_MATRIX(Src5, 6, 64, int16_t, 16);
927    
928    printf( "\n =====  test cbp =====\n" );    printf( "\n =====  test cbp =====\n" );
929    
# Line 615  Line 932 
932      Src2[i] = (i<3*64);               /* half-full */      Src2[i] = (i<3*64);               /* half-full */
933      Src3[i] = ((i+32)>3*64);      Src3[i] = ((i+32)>3*64);
934      Src4[i] = (i==(3*64+2) || i==(5*64+9));      Src4[i] = (i==(3*64+2) || i==(5*64+9));
935        Src5[i] = ieee_rand(0,1) ? -1 : 1;  /* +/- test */
936    }    }
937    
938    for(cpu = cpu_short_list2; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
939    {    {
940      double t;      double t;
941      int tst, cbp;      int tst, cbp;
# Line 625  Line 943 
943      if (!init_cpu(cpu))      if (!init_cpu(cpu))
944        continue;        continue;
945    
946      TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1, nb_tests);
947      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",
948      if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
949      TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2, nb_tests);
950      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",
951      if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
952      TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3, nb_tests);
953      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",
954      if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
955      TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4, nb_tests);
956      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",
957      if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
958                    TEST_CBP(calc_cbp, Src5, nb_tests);
959                    printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
960                               cpu->name, t, cbp, (cbp!=0x3f)?"| ERROR": "" );
961      printf( " --- \n" );      printf( " --- \n" );
962    }    }
963    
964            for(cpu = cpu_list; cpu->name!=0; ++cpu)  /* bench suggested by Carlo (carlo dot bramix at libero dot it) */
965            {
966                    double t;
967                    int tst, cbp, err;
968    
969                    if (!init_cpu(cpu))
970                            continue;
971    
972        err = 0;
973        for(n=0; n<6; ++n)
974        {
975          for(m=0; m<64; ++m)
976          {
977            for(i=0; i<6*64; ++i)
978              Src1[i] = (i== (m + n*64));
979    
980            TEST_CBP(calc_cbp, Src1, 1);
981            if (cbp!= (((m!=0)<<(5-n))))
982            {
983              printf( "%s -   calc_cbp#5: ERROR at pos %d / %d!\n", cpu->name, n, m);
984              err = 1;
985              break;
986            }
987          }
988        }
989        if (!err)
990          printf( " %s -    calc_cbp#5 : OK\n", cpu->name );
991    
992            }
993  }  }
994    
995  /*********************************************************************  /*********************************************************************
# Line 767  Line 1118 
1118    }    }
1119  }  }
1120    
1121  /*//////////////////////////////////////////////////////// */  ///* ////////////////////////////////////////////////////// */
1122  /* Pseudo-random generator specified by IEEE 1180 */  /* Pseudo-random generator specified by IEEE 1180 */
1123    
1124  static long ieee_seed = 1;  static long ieee_seed = 1;
# Line 854  Line 1205 
1205    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 };
1206    int Loops = 10000;    int Loops = 10000;
1207    int i, m, n;    int i, m, n;
1208    short Blk0[64];     /* reference */          DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1209    short Blk[64], iBlk[64];          DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1210    short Ref_FDCT[64];          DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1211    short Ref_IDCT[64];          DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
1212            DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
1213    
1214    STATS_8x8 FStats; /* forward dct stats */    STATS_8x8 FStats; /* forward dct stats */
1215    STATS_8x8 IStats; /* inverse dct stats */    STATS_8x8 IStats; /* inverse dct stats */
# Line 910  Line 1262 
1262    
1263    
1264      printf( "\n  -- FDCT report --\n" );      printf( "\n  -- FDCT report --\n" );
1265  /*    print_stats(&FStats); */  //    print_stats(&FStats);
1266      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 */
1267    
1268      for(i=0; i<64; i++) Blk[i] = 0;      for(i=0; i<64; i++) Blk[i] = 0;
# Line 919  Line 1271 
1271      printf( "FDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );      printf( "FDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1272    
1273      printf( "\n  -- IDCT report --\n" );      printf( "\n  -- IDCT report --\n" );
1274  /*    print_stats(&IStats); */  //    print_stats(&IStats);
1275      report_stats(&IStats, ILimits);      report_stats(&IStats, ILimits);
1276    
1277    
# Line 937  Line 1289 
1289    
1290    int i, n, p;    int i, n, p;
1291    CPU *cpu;    CPU *cpu;
1292  /*  const short IDCT_MAX =  2047;  // 12bits input */  //  const short IDCT_MAX =  2047;  /* 12bits input */
1293  /*  const short IDCT_MIN = -2048; */  //  const short IDCT_MIN = -2048;
1294  /*  const short IDCT_OUT =   256;  // 9bits ouput */  //  const short IDCT_OUT =   256;  /* 9bits ouput */
1295    const int Partitions = 4;    const int Partitions = 4;
1296    const int Loops = 10000 / Partitions;    const int Loops = 10000 / Partitions;
1297    
# Line 987  Line 1339 
1339      report_stats(&Stats, 0);      report_stats(&Stats, 0);
1340    
1341    
1342                /* IDCT tests */                  /* IDCT tests // */
1343  #if 0  #if 0
1344        /* no finished yet */        /* no finished yet */
1345    
# Line 1031  Line 1383 
1383   * measure raw decoding speed   * measure raw decoding speed
1384   *********************************************************************/   *********************************************************************/
1385    
1386  void test_dec(const char *name, int width, int height, int with_chksum)  void test_dec(const char *name, int width, int height, int ref_chksum)
1387  {  {
1388    FILE *f = 0;    FILE *f = 0;
1389    void *dechandle = 0;    void *dechandle = 0;
1390    int xerr;    int xerr;
1391          XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
1392          XVID_DEC_PARAM xparam;          xvid_dec_create_t xparam;
1393          XVID_DEC_FRAME xframe;          xvid_dec_frame_t xframe;
1394          double t = 0.;          double t = 0.;
1395          int nb = 0;          int nb = 0;
1396    uint8_t *buf = 0;    uint8_t *buf = 0;
1397    uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1398    int buf_size, pos;    int buf_size, pos;
1399    uint32_t chksum = 0;    uint32_t chksum = 0;
1400            int bps = (width+31) & ~31;
1401    
1402          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          memset(&xinit, 0, sizeof(xinit));
1403          xvid_init(NULL, 0, &xinit, NULL);          xinit.cpu_flags = cpu_mask;
1404          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          xinit.version = XVID_VERSION;
1405            xvid_global(NULL, 0, &xinit, NULL);
1406    
1407            memset(&xparam, 0, sizeof(xparam));
1408          xparam.width = width;          xparam.width = width;
1409          xparam.height = height;          xparam.height = height;
1410            xparam.version = XVID_VERSION;
1411          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1412          if (xerr!=XVID_ERR_OK) {          if (xerr==XVID_ERR_FAIL) {
1413            printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1414            return;            return;
1415          }          }
1416          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1063  Line 1418 
1418    
1419          f = fopen(name, "rb");          f = fopen(name, "rb");
1420    if (f==0) {    if (f==0) {
1421      printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1422      return;      return;
1423    }    }
1424    fseek(f, 0, SEEK_END);    fseek(f, 0, SEEK_END);
1425    buf_size = ftell(f);    buf_size = ftell(f);
1426    fseek(f, 0, SEEK_SET);    fseek(f, 0, SEEK_SET);
1427    if (buf_size<=0) {    if (buf_size<=0) {
1428      printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1429      goto End;      goto End;
1430    }    }
   else printf( "Input size: %d\n", buf_size);  
1431    
1432    buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1433    rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1434    if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1435      printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1436      goto End;      goto End;
1437    }    }
1438    
1439    if (fread(buf, buf_size, 1, f)!=1) {    if (fread(buf, buf_size, 1, f)!=1) {
1440      printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1441      goto End;      goto End;
1442    }    }
1443    
# Line 1091  Line 1445 
1445    pos = 0;    pos = 0;
1446    t = -gettime_usec();    t = -gettime_usec();
1447    while(1) {    while(1) {
1448              int y;
1449    
1450                    memset(&xframe, 0, sizeof(xframe));
1451                    xframe.version = XVID_VERSION;
1452      xframe.bitstream = buf + pos;      xframe.bitstream = buf + pos;
1453      xframe.length = buf_size - pos;      xframe.length = buf_size - pos;
1454      xframe.image = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1455      xframe.stride = width;                  xframe.output.plane[1] = (uint8_t*)xframe.output.plane[0] + bps*height;
1456      xframe.colorspace = XVID_CSP_RGB24;                  xframe.output.plane[2] = (uint8_t*)xframe.output.plane[1] + bps/2;
1457                    xframe.output.stride[0] = bps;
1458                    xframe.output.stride[1] = bps;
1459                    xframe.output.stride[2] = bps;
1460                    xframe.output.csp = XVID_CSP_I420;
1461      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1462                    if (xerr<0) {
1463                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1464                            break;
1465                    }
1466                    else if (xerr==0)
1467                      break;
1468        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1469    
1470                    pos += xerr;
1471      nb++;      nb++;
1472      pos += xframe.length;  
1473      if (with_chksum) {      for(y=0; y<height/2; ++y) {
1474        int k = width*height;                    chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1475        uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1476        while(k-->0) chksum += *ptr++;                          chksum = calc_crc((uint8_t*)xframe.output.plane[1] + y*bps, width/2, chksum);
1477                            chksum = calc_crc((uint8_t*)xframe.output.plane[2] + y*bps, width/2, chksum);
1478      }      }
1479      if (pos==buf_size)      if (pos==buf_size)
1480        break;        break;
     if (xerr!=XVID_ERR_OK) {  
           printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
           break;  
         }  
1481    }    }
1482    t += gettime_usec();    t += gettime_usec();
1483            if (ref_chksum==0) {
1484    if (t>0.)    if (t>0.)
1485      printf( "%d frames decoded in %.3f s -> %.1f FPS\n", nb, t*1.e-6f, (float)(nb*1.e6f/t) );                    printf( "%d frames decoded in %.3f s -> %.1f FPS   Checksum:0x%.8x\n", nb, t*1.e-6f, (float)(nb*1.e6f/t), chksum );
1486    if (with_chksum)    }
1487      printf("checksum: 0x%.8x\n", chksum);    else {
1488                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1489                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1490      }
1491    
1492  End:  End:
1493    if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1494    if (buf!=0) free(buf);    if (buf!=0) free(buf);
1495    if (dechandle!=0) {    if (dechandle!=0) {
1496      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1497      if (xerr!=XVID_ERR_OK)                  if (xerr==XVID_ERR_FAIL)
1498              printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1499    }    }
1500    if (f!=0) fclose(f);    if (f!=0) fclose(f);
1501  }  }
# Line 1135  Line 1507 
1507  void test_bugs1()  void test_bugs1()
1508  {  {
1509    CPU *cpu;    CPU *cpu;
1510            uint16_t mpeg_quant_matrices[64*8];
1511    
1512    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1513    
1514    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1515    {    {
1516      int i;      int i;
1517      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 1147  Line 1520 
1520        continue;        continue;
1521    
1522      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1523      set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1524      dequant4_intra(Dst, Src, 31, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1525      printf( "dequant4_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1526      printf( "  Out[]= " );      printf( "  Out[]= " );
1527      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1528      printf( "\n" );      printf( "\n" );
# Line 1157  Line 1530 
1530    
1531    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );
1532    
1533    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1534    {    {
1535      int i;      int i;
1536      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 1166  Line 1539 
1539        continue;        continue;
1540    
1541      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1542      set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1543      dequant4_inter(Dst, Src, 31);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1544      printf( "dequant4_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1545      printf( "  Out[]= " );      printf( "  Out[]= " );
1546      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1547      printf( "\n" );      printf( "\n" );
# Line 1178  Line 1551 
1551  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1552  {  {
1553    CPU *cpu;    CPU *cpu;
1554    short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1555            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1556    
1557    printf( "\n =====  fdct/idct precision diffs =====\n" );    printf( "\n =====  fdct/idct precision diffs =====\n" );
1558    
1559    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1560    {    {
1561      int i;      int i;
1562    
# Line 1211  Line 1585 
1585    const int max_Q = 31;    const int max_Q = 31;
1586    int i, n, qm, q;    int i, n, qm, q;
1587    CPU *cpu;    CPU *cpu;
1588    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1589            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1590    uint8_t Quant[8*8];    uint8_t Quant[8*8];
1591    CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };    CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1592    uint16_t Crcs_Inter[2][32];    uint16_t Crcs_Inter[2][32];
1593    uint16_t Crcs_Intra[2][32];    uint16_t Crcs_Intra[2][32];
1594            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1595    
1596    printf( "\n =====  test MPEG4-quantize bug =====\n" );    printf( "\n =====  test MPEG4-quantize bug =====\n" );
1597    
1598    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 1224  Line 1601 
1601    for(qm=1; qm<=255; ++qm)    for(qm=1; qm<=255; ++qm)
1602    {    {
1603      for(i=0; i<8*8; ++i) Quant[i] = qm;      for(i=0; i<8*8; ++i) Quant[i] = qm;
1604      set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1605    
1606      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1607      {      {
# Line 1235  Line 1612 
1612    
1613        for(q=1; q<=max_Q; ++q) {        for(q=1; q<=max_Q; ++q) {
1614          emms();          emms();
1615          quant4_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1616          emms();          emms();
1617          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;
1618          Crcs_Inter[n][q] = s;          Crcs_Inter[n][q] = s;
# Line 1254  Line 1631 
1631    for(qm=1; qm<=255; ++qm)    for(qm=1; qm<=255; ++qm)
1632    {    {
1633      for(i=0; i<8*8; ++i) Quant[i] = qm;      for(i=0; i<8*8; ++i) Quant[i] = qm;
1634      set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1635    
1636      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1637      {      {
# Line 1265  Line 1642 
1642    
1643        for(q=1; q<=max_Q; ++q) {        for(q=1; q<=max_Q; ++q) {
1644          emms();          emms();
1645          quant4_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1646          emms();          emms();
1647          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;
1648          Crcs_Intra[n][q] = s;          Crcs_Intra[n][q] = s;
# Line 1280  Line 1657 
1657    }    }
1658  #endif  #endif
1659  }  }
1660    /*********************************************************************/
1661    
1662    static uint32_t __inline log2bin_v1(uint32_t value)
1663    {
1664      int n = 0;
1665      while (value) {
1666        value >>= 1;
1667        n++;
1668      }
1669      return n;
1670    }
1671    
1672    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1673    
1674    static uint32_t __inline log2bin_v2(uint32_t value)
1675    {
1676      int n = 0;
1677      if (value & 0xffff0000) {
1678        value >>= 16;
1679        n += 16;
1680      }
1681      if (value & 0xff00) {
1682        value >>= 8;
1683        n += 8;
1684      }
1685      if (value & 0xf0) {
1686        value >>= 4;
1687        n += 4;
1688      }
1689     return n + log2_tab_16[value];
1690    }
1691    
1692    void test_log2bin()
1693    {
1694            const int nb_tests = 3000*speed_ref;
1695      int n, crc1=0, crc2=0;
1696      uint32_t s, s0;
1697      double t1, t2;
1698    
1699      t1 = gettime_usec();
1700      s0 = (int)(t1*31.241);
1701      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1702        crc1 += log2bin_v1(s);
1703      t1 = (gettime_usec()-t1) / nb_tests;
1704    
1705      t2 = gettime_usec();
1706      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1707        crc2 += log2bin_v2(s);
1708      t2 = (gettime_usec() - t2) / nb_tests;
1709    
1710      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1711      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1712      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1713    }
1714    
1715    /*********************************************************************/
1716    
1717    static void __inline old_gcd(int *num, int *den)
1718    {
1719     int i = *num;
1720      while (i > 1) {
1721        if (*num % i == 0 && *den % i == 0) {
1722          *num /= i;
1723          *den /= i;
1724          i = *num;
1725          continue;
1726        }
1727        i--;
1728      }
1729    }
1730    
1731    static uint32_t gcd(int num, int den)
1732    {
1733      int tmp;
1734      while( (tmp=num%den) ) { num = den; den = tmp; }
1735      return den;
1736    }
1737    static void __inline new_gcd(int *num, int *den)
1738    {
1739      const int div = gcd(*num, *den);
1740      if (num) {
1741        *num /= div;
1742        *den /= div;
1743      }
1744    }
1745    
1746    void test_gcd()
1747    {
1748            const int nb_tests = 10*speed_ref;
1749      int i;
1750      uint32_t crc1=0, crc2=0;
1751      uint32_t n0, n, d0, d;
1752      double t1, t2;
1753    
1754      t1 = gettime_usec();
1755      n0 = 0xfffff & (int)(t1*31.241);
1756      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1757      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1758        old_gcd(&n, &d);
1759        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1760        n = d;
1761        d = (d*12363+31) & 0xffff;
1762        d |= !d;
1763      }
1764      t1 = (gettime_usec()-t1) / nb_tests;
1765    
1766      t2 = gettime_usec();
1767      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1768        new_gcd(&n, &d);
1769        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1770        n = d;
1771        d = (d*12363+31) & 0xffff;
1772        d |= !d;
1773      }
1774      t2 = (gettime_usec() - t2) / nb_tests;
1775    
1776      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1777      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1778      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1779    }
1780    
1781  /*********************************************************************  /*********************************************************************
1782   * main   * main
1783   *********************************************************************/   *********************************************************************/
1784    
1785  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
1786  {  {
1787    int what = 0;    printf( "missing argument after option '%s'\n", opt);
1788    if (argc>1) what = atoi(argv[1]);    exit(-1);
1789    }
1790    
1791    int main(int argc, const char *argv[])
1792    {
1793            int c, what = 0;
1794            int width, height;
1795            uint32_t chksum = 0;
1796      const char * test_bitstream = 0;
1797    
1798            cpu_mask = 0;  // default => will use autodectect
1799            for(c=1; c<argc; ++c)
1800            {
1801              if (!strcmp(argv[c], "-v")) verbose++;
1802              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
1803              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
1804              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1805              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1806              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
1807              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
1808              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
1809              else if (!strcmp(argv[c], "-spd")) {
1810          if (++c==argc) arg_missing( argv[argc-1] );
1811          speed_ref = atoi(argv[c]);
1812        }
1813              else if (argv[c][0]!='-') {
1814                what = atoi(argv[c]);
1815                if (what==9) {
1816                  if (c+4>argc) {
1817                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
1818                    exit(-1);
1819            }
1820            test_bitstream = argv[++c];
1821                  width  = atoi(argv[++c]);
1822                  height = atoi(argv[++c]);
1823                  if (c+1<argc && argv[c+1][0]!='-') {
1824                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
1825                      printf( "can't read checksum value.\n" );
1826                      exit(-1);
1827              }
1828              else c++;
1829            }
1830    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
1831          }
1832        }
1833        else {
1834          printf( "unrecognized option '%s'\n", argv[c]);
1835          exit(-1);
1836        }
1837      }
1838    
1839    
1840    if (what==0 || what==1) test_dct();    if (what==0 || what==1) test_dct();
1841    if (what==0 || what==2) test_mb();    if (what==0 || what==2) test_mb();
1842    if (what==0 || what==3) test_sad();    if (what==0 || what==3) test_sad();
1843    if (what==0 || what==4) test_transfer();    if (what==0 || what==4) test_transfer();
1844    if (what==0 || what==5) test_quant();    if (what==0 || what==5) test_quant();
1845    if (what==0 || what==6) test_cbp();    if (what==0 || what==6) test_cbp();
1846            if (what==0 || what==10) test_sse();
1847            if (what==0 || what==11) test_log2bin();
1848            if (what==0 || what==12) test_gcd();
1849    
1850    
1851    if (what==7) {    if (what==7) {
1852      test_IEEE1180_compliance(-256, 255, 1);      test_IEEE1180_compliance(-256, 255, 1);
 #if 0  
1853      test_IEEE1180_compliance(-256, 255,-1);      test_IEEE1180_compliance(-256, 255,-1);
1854      test_IEEE1180_compliance(  -5,   5, 1);      test_IEEE1180_compliance(  -5,   5, 1);
1855      test_IEEE1180_compliance(  -5,   5,-1);      test_IEEE1180_compliance(  -5,   5,-1);
1856      test_IEEE1180_compliance(-300, 300, 1);      test_IEEE1180_compliance(-300, 300, 1);
1857      test_IEEE1180_compliance(-300, 300,-1);      test_IEEE1180_compliance(-300, 300,-1);
 #endif  
1858    }    }
1859    if (what==8) test_dct_saturation(-256, 255);    if (what==8) test_dct_saturation(-256, 255);
1860    
1861    if (what==9) {          if (test_bitstream)
1862      int width, height;            test_dec(test_bitstream, width, height, chksum);
     if (argc<5) {  
       printf("usage: %s %d [bitstream] [width] [height]\n", argv[0], what);  
       return 1;  
     }  
     width = atoi(argv[3]);  
     height = atoi(argv[4]);  
     test_dec(argv[2], width, height, (argc>5));  
   }  
   
1863    if (what==-1) {    if (what==-1) {
1864      test_dct_precision_diffs();      test_dct_precision_diffs();
1865      test_bugs1();      test_bugs1();
# Line 1326  Line 1867 
1867    if (what==-2)    if (what==-2)
1868      test_quant_bug();      test_quant_bug();
1869    
1870    return 0;          if ((what >= 0 && what <= 6) || what == 10) {
1871                    printf("\n\n"
1872                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1873                               "    a C function is used instead. So don't panic if some functions\n"
1874                               "    may appear to be slow.\n");
1875  }  }
1876    
1877  /*********************************************************************  #ifdef ARCH_IS_IA32
1878   * 'Reference' output (except for timing) on a PIII 1.13Ghz/linux          if (what == 0 || what == 5) {
1879   *********************************************************************/                  printf("\n"
1880                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1881      /* as of 07/01/2002, there's a problem with mpeg4-quantization */                             "    for 1 or 2 coefficients a block. This is mainly caused by the fact the unit\n"
1882  /*                             "    test goes far behind the usual limits of real encoding. Please do not report\n"
1883                               "    this error to the developers.\n");
1884            }
1885    #endif
1886    
1887   ===== test fdct/idct =====          return 0;
1888  PLAINC -  3.312 usec       PSNR=13.291  MSE=3.000  }
 MMX    -  0.591 usec       PSNR=13.291  MSE=3.000  
 MMXEXT -  0.577 usec       PSNR=13.291  MSE=3.000  
 SSE2   -  0.588 usec       PSNR=13.291  MSE=3.000  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
  ===  test block motion ===  
 PLAINC - interp- h-round0 0.911 usec       iCrc=8107  
 PLAINC -           round1 0.863 usec       iCrc=8100  
 PLAINC - interp- v-round0 0.860 usec       iCrc=8108  
 PLAINC -           round1 0.857 usec       iCrc=8105  
 PLAINC - interp-hv-round0 2.103 usec       iCrc=8112  
 PLAINC -           round1 2.050 usec       iCrc=8103  
  ---  
 MMX    - interp- h-round0 0.105 usec       iCrc=8107  
 MMX    -           round1 0.106 usec       iCrc=8100  
 MMX    - interp- v-round0 0.106 usec       iCrc=8108  
 MMX    -           round1 0.106 usec       iCrc=8105  
 MMX    - interp-hv-round0 0.145 usec       iCrc=8112  
 MMX    -           round1 0.145 usec       iCrc=8103  
  ---  
 MMXEXT - interp- h-round0 0.028 usec       iCrc=8107  
 MMXEXT -           round1 0.041 usec       iCrc=8100  
 MMXEXT - interp- v-round0 0.027 usec       iCrc=8108  
 MMXEXT -           round1 0.041 usec       iCrc=8105  
 MMXEXT - interp-hv-round0 0.066 usec       iCrc=8112  
 MMXEXT -           round1 0.065 usec       iCrc=8103  
  ---  
 SSE2   - interp- h-round0 0.109 usec       iCrc=8107  
 SSE2   -           round1 0.105 usec       iCrc=8100  
 SSE2   - interp- v-round0 0.106 usec       iCrc=8108  
 SSE2   -           round1 0.109 usec       iCrc=8105  
 SSE2   - interp-hv-round0 0.145 usec       iCrc=8112  
 SSE2   -           round1 0.145 usec       iCrc=8103  
  ---  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
  ======  test SAD ======  
 PLAINC - sad8    0.251 usec       sad=3776  
 PLAINC - sad16   1.601 usec       sad=27214  
 PLAINC - sad16bi 2.371 usec       sad=26274  
 PLAINC - dev16   1.564 usec       sad=3344  
  ---  
 MMX    - sad8    0.057 usec       sad=3776  
 MMX    - sad16   0.182 usec       sad=27214  
 MMX    - sad16bi 2.462 usec       sad=26274  
 MMX    - dev16   0.311 usec       sad=3344  
  ---  
 MMXEXT - sad8    0.036 usec       sad=3776  
 MMXEXT - sad16   0.109 usec       sad=27214  
 MMXEXT - sad16bi 0.143 usec       sad=26274  
 MMXEXT - dev16   0.192 usec       sad=3344  
  ---  
 SSE2   - sad8    0.057 usec       sad=3776  
 SSE2   - sad16   0.179 usec       sad=27214  
 SSE2   - sad16bi 2.456 usec       sad=26274  
 SSE2   - dev16   0.321 usec       sad=3344  
  ---  
 3DNOW  - skipped...  
 3DNOWE - skipped...  
   
  ===  test transfer ===  
 PLAINC - 8to16     0.151 usec       crc=28288  
 PLAINC - 16to8     1.113 usec       crc=28288  
 PLAINC - 8to8      0.043 usec       crc=20352  
 PLAINC - 16to8add  1.069 usec       crc=25536  
 PLAINC - 8to16sub  0.631 usec       crc1=28064 crc2=16256  
 PLAINC - 8to16sub2 0.597 usec       crc=20384  
  ---  
 MMX    - 8to16     0.032 usec       crc=28288  
 MMX    - 16to8     0.024 usec       crc=28288  
 MMX    - 8to8      0.020 usec       crc=20352  
 MMX    - 16to8add  0.043 usec       crc=25536  
 MMX    - 8to16sub  0.066 usec       crc1=28064 crc2=16256  
 MMX    - 8to16sub2 0.111 usec       crc=20384  
  ---  
   
  =====  test quant =====  
 PLAINC -   quant4_intra 74.248 usec       crc=29809  
 PLAINC -   quant4_inter 70.850 usec       crc=12574  
 PLAINC - dequant4_intra 40.628 usec       crc=24052  
 PLAINC - dequant4_inter 45.691 usec       crc=63847  
 PLAINC -    quant_intra 43.357 usec       crc=25662  
 PLAINC -    quant_inter 33.410 usec       crc=23972  
 PLAINC -  dequant_intra 36.384 usec       crc=49900  
 PLAINC -  dequant_inter 48.930 usec       crc=48899  
  ---  
 MMX    -   quant4_intra 7.445 usec       crc=3459  
 *** CRC ERROR! ***  
 MMX    -   quant4_inter 5.384 usec       crc=51072  
 *** CRC ERROR! ***  
 MMX    - dequant4_intra 5.515 usec       crc=24052  
 MMX    - dequant4_inter 7.745 usec       crc=63847  
 MMX    -    quant_intra 4.661 usec       crc=25662  
 MMX    -    quant_inter 4.406 usec       crc=23972  
 MMX    -  dequant_intra 4.928 usec       crc=49900  
 MMX    -  dequant_inter 4.532 usec       crc=48899  
  ---  
   
  =====  test cbp =====  
 PLAINC -   calc_cbp#1 0.371 usec       cbp=0x15  
 PLAINC -   calc_cbp#2 0.432 usec       cbp=0x38  
 PLAINC -   calc_cbp#3 0.339 usec       cbp=0xf  
 PLAINC -   calc_cbp#4 0.506 usec       cbp=0x5  
  ---  
 MMX    -   calc_cbp#1 0.136 usec       cbp=0x15  
 MMX    -   calc_cbp#2 0.134 usec       cbp=0x38  
 MMX    -   calc_cbp#3 0.138 usec       cbp=0xf  
 MMX    -   calc_cbp#4 0.135 usec       cbp=0x5  
  ---  
 SSE2   -   calc_cbp#1 0.136 usec       cbp=0x15  
 SSE2   -   calc_cbp#2 0.133 usec       cbp=0x38  
 SSE2   -   calc_cbp#3 0.133 usec       cbp=0xf  
 SSE2   -   calc_cbp#4 0.141 usec       cbp=0x5  
  ---  
1889    
1890  */  /*********************************************************************/
Legend:
Removed from v.824  
changed lines
  Added in v.1641
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4