[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 1746, Wed Nov 1 07:12:26 2006 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.34 2006-11-01 07:12:26 Skal Exp $
23   *   *
24   *************************************************************************/   ****************************************************************************/
25    
26  /************************************************************************  /*****************************************************************************
27   *   *
28   *  'Reference' output is at the end of file.   *  'Reference' output is at the end of file.
  *  Don't take the checksums and crc too seriouly, they aren't  
  *  bullet-proof (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"
59  #include "quant/quant_matrix.c"  #include "quant/quant_matrix.c"
60  #include "bitstream/cbp.h"  #include "bitstream/cbp.h"
61    #include "bitstream/bitstream.h"
62    
63  #include <math.h>  #include <math.h>
64    
65  #ifndef M_PI  #ifndef M_PI
66  #  define M_PI     3.14159265359  #define M_PI            3.14159265358979323846
 #  define M_PI_2   1.5707963268  
67  #endif  #endif
68  const int speed_ref = 100;  /* on slow machines, decrease this value */  
69    int speed_ref = 100;  /* on slow machines, decrease this value */
70    int verbose = 0;
71    unsigned int cpu_mask;
72    
73  /*********************************************************************  /*********************************************************************
74   * misc   * misc
# Line 73  Line 77 
77   /* returns time in micro-s*/   /* returns time in micro-s*/
78  double gettime_usec()  double gettime_usec()
79  {  {
80  #ifdef  WIN32  #ifndef WIN32
   return clock()*1000;  
 #else  
81    struct timeval  tv;    struct timeval  tv;
82    gettimeofday(&tv, 0);    gettimeofday(&tv, 0);
83    return tv.tv_sec*1.0e6 + tv.tv_usec;    return tv.tv_sec*1.0e6 + tv.tv_usec;
84    #else
85            clock_t clk;
86            clk = clock();
87            return clk * 1000. / CLOCKS_PER_SEC;  /* clock() returns time in Milliseconds */
88  #endif  #endif
89  }  }
90    
# Line 107  Line 113 
113    unsigned int cpu;    unsigned int cpu;
114  } CPU;  } CPU;
115    
116  CPU cpu_list[] =  CPU cpu_list[] = {
117  { { "PLAINC", 0 }          { "PLAINC ", 0 },
118  , { "MMX   ", XVID_CPU_MMX }  #ifdef ARCH_IS_IA32
119  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }          { "MMX    ", XVID_CPU_MMX },
120  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }          { "MMXEXT ", XVID_CPU_MMXEXT | XVID_CPU_MMX },
121  , { "3DNOW ", XVID_CPU_3DNOW }          { "SSE2   ", XVID_CPU_SSE2 | XVID_CPU_MMX },
122  , { "3DNOWE", XVID_CPU_3DNOWEXT }          { "3DNOW  ", XVID_CPU_3DNOW },
123  , { "IA64  ", XVID_CPU_IA64 }          { "3DNOWE ", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT },
124  /*, { "TSC   ", XVID_CPU_TSC } */  #endif
125  , { 0, 0 } }  #ifdef ARCH_IS_PPC
126            { "ALTIVEC", XVID_CPU_ALTIVEC },
127  , cpu_short_list[] =  #endif
128  { { "PLAINC", 0 }  #ifdef ARCH_IS_X86_64
129  , { "MMX   ", XVID_CPU_MMX }          { "X86_64 ", XVID_CPU_ASM},
130  /*, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX } */  #endif
131  , { "IA64  ", XVID_CPU_IA64 }  #ifdef ARCH_IS_IA64
132  , { 0, 0 } }  //      { "IA64   ", XVID_CPU_IA64 },
133    #endif
134  , cpu_short_list2[] =  //      { "TSC    ", XVID_CPU_TSC },
135  { { "PLAINC", 0 }          { 0, 0 }
136  , { "MMX   ", XVID_CPU_MMX }  };
 , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  
 , { 0, 0 } };  
137    
138    
139  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
140  {  {
141    int xerr, cpu_type;          xvid_gbl_info_t xinfo;
142    XVID_INIT_PARAM xinit;  
143            /* Get the available CPU flags */
144            memset(&xinfo, 0, sizeof(xinfo));
145            xinfo.version = XVID_VERSION;
146            xvid_global(NULL, XVID_GBL_INFO, &xinfo, NULL);
147    
148    cpu_type = check_cpu_features() & cpu->cpu;          /* Are we trying to test a subset of the host CPU features */
149    xinit.cpu_flags = cpu_type | XVID_CPU_FORCE;          if ((xinfo.cpu_flags & cpu->cpu) == cpu->cpu) {
150    /*    xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE; */                  int xerr;
151    xerr = xvid_init(NULL, 0, &xinit, NULL);                  xvid_gbl_init_t xinit;
152    if (cpu->cpu>0 && (cpu_type==0 || xerr!=XVID_ERR_OK)) {                  memset(&xinit, 0, sizeof(xinit));
153      printf( "%s - skipped...\n", cpu->name );                  xinit.cpu_flags = cpu->cpu | XVID_CPU_FORCE;
154                    xinit.version = XVID_VERSION;
155                    xerr = xvid_global(NULL, XVID_GBL_INIT, &xinit, NULL);
156                    if (xerr==XVID_ERR_FAIL) {
157                            /* libxvidcore failed to init */
158      return 0;      return 0;
159    }    }
160            } else {
161                    /* The host CPU doesn't support some required feature for this test */
162                    return(0);
163            }
164    return 1;    return 1;
165  }  }
166    
167    #define CRC32_REMAINDER 0xCBF43926
168    #define CRC32_INITIAL 0xffffffff
169    
170    #define DO1(c, crc) ((crc) = crc32tab[((unsigned int)((crc)>>24) ^ (*c++)) & 0xff] ^ ((crc) << 8))
171    #define DO2(c, crc)  DO1(c, crc); DO1(c, crc);
172    #define DO4(c, crc)  DO2(c, crc); DO2(c, crc);
173    #define DO8(c, crc)  DO4(c, crc); DO4(c, crc);
174    
175    /******************************************************************************
176    * Precomputed AAL5 CRC32 lookup table
177    ******************************************************************************/
178    
179    static unsigned long crc32tab[256] = {
180    
181            0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
182            0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
183            0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
184            0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
185            0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
186            0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
187            0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
188            0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
189            0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
190            0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
191            0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
192            0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
193            0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
194            0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
195            0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
196            0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
197            0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
198            0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
199            0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
200            0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
201            0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
202            0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
203            0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
204            0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
205            0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
206            0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
207            0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
208            0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
209            0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
210            0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
211            0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
212            0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
213            0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
214            0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
215            0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
216            0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
217            0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
218            0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
219            0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
220            0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
221            0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
222            0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
223            0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
224            0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
225            0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
226            0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
227            0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
228            0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
229            0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
230            0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
231            0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
232            0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
233            0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
234            0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
235            0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
236            0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
237            0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
238            0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
239            0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
240            0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
241            0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
242            0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
243            0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
244            0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
245    
246    };
247    
248    uint32_t
249    calc_crc(uint8_t *mem, int len, uint32_t crc)
250    {
251            while( len >= 8) {
252                    DO8(mem, crc);
253                    len -= 8;
254            }
255    
256            while( len ) {
257                    DO1(mem, crc);
258                    len--;
259            }
260    
261            return crc;
262    }
263    
264    void byte_swap(uint8_t *mem, int len, int element_size) {
265    #ifdef ARCH_IS_BIG_ENDIAN
266            int i;
267    
268            if(element_size == 1) {
269                    /* No need to swap */
270            } else if(element_size == 2) {
271                    uint8_t temp[2];
272    
273                    for(i=0; i < (len/2); i++ ) {
274                            temp[0] = mem[0];
275                            temp[1] = mem[1];
276                            mem[0] = temp[1];
277                            mem[1] = temp[0];
278    
279                            mem += 2;
280                    }
281            } else if(element_size == 4) {
282                    uint8_t temp[4];
283    
284                    for(i=0; i < (len/4); i++ ) {
285                            temp[0] = mem[0];
286                            temp[1] = mem[1];
287                            temp[2] = mem[2];
288                            temp[3] = mem[3];
289                            mem[0] = temp[3];
290                            mem[1] = temp[2];
291                            mem[2] = temp[1];
292                            mem[3] = temp[0];
293    
294                            mem += 4;
295                    }
296            } else {
297                    printf("ERROR: byte_swap unsupported element_size(%u)\n", element_size);
298            }
299    #endif
300    }
301    
302  /*********************************************************************  /*********************************************************************
303   * test DCT   * test DCT
304   *********************************************************************/   *********************************************************************/
# Line 160  Line 311 
311    int tst;    int tst;
312    CPU *cpu;    CPU *cpu;
313    int i;    int i;
314    short iDst0[8*8], iDst[8*8], fDst[8*8];          DECLARE_ALIGNED_MATRIX(iDst0, 8, 8, short, 16);
315            DECLARE_ALIGNED_MATRIX(iDst,  8, 8, short, 16);
316            DECLARE_ALIGNED_MATRIX(fDst,  8, 8, short, 16);
317    double overhead;    double overhead;
318    
319    printf( "\n ===== test fdct/idct =====\n" );    printf( "\n ===== test fdct/idct =====\n" );
# Line 198  Line 351 
351        MSE += delta*delta;        MSE += delta*delta;
352      }      }
353      PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );      PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
354      printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f\n",                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
355        cpu->name, t, PSNR, MSE );                                  cpu->name, t, PSNR, MSE,
356      if (ABS(MSE)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
357    }    }
358  }  }
359    
# Line 214  Line 367 
367    int tst;    int tst;
368    CPU *cpu;    CPU *cpu;
369    int i;    int i;
370    uint8_t Cur[16*16], Ref1[16*16], Ref2[16*16];          DECLARE_ALIGNED_MATRIX(Cur,  16, 16, uint8_t, 16);
371            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
372            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
373    
374    printf( "\n ======  test SAD ======\n" );    printf( "\n ======  test SAD ======\n" );
375    for(i=0; i<16*16;++i) {    for(i=0; i<16*16;++i) {
# Line 235  Line 390 
390      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
391      emms();      emms();
392      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
393      printf( "%s - sad8    %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad8    %.3f usec       sad=%d %s\n",
394      if (s!=3776) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
395                               (s!=3776)?"| ERROR": "" );
396    
397      t = gettime_usec();      t = gettime_usec();
398      emms();      emms();
399      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);
400      emms();      emms();
401      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
402      printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad16   %.3f usec       sad=%d %s\n",
403      if (s!=27214) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
404                               (s!=27214)?"| ERROR": "" );
405    
406      t = gettime_usec();      t = gettime_usec();
407      emms();      emms();
408      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);
409      emms();      emms();
410      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
411      printf( "%s - sad16bi %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - sad16bi %.3f usec       sad=%d %s\n",
412      if (s!=26274) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
413                                    (s!=26274)?"| ERROR": "" );
414    
415      t = gettime_usec();      t = gettime_usec();
416      emms();      emms();
417      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
418      emms();      emms();
419      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
420      printf( "%s - dev16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - dev16   %.3f usec       sad=%d %s\n",
421      if (s!=3344) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
422                                    (s!=3344)?"| ERROR": "" );
423    
424      printf( " --- \n" );      printf( " --- \n" );
425    }    }
# Line 278  Line 437 
437  #define LEAVE \  #define LEAVE \
438      emms();                             \      emms();                             \
439      t = (gettime_usec() - t) / nb_tests;  \      t = (gettime_usec() - t) / nb_tests;  \
440      iCrc = 0;                           \          iCrc = calc_crc((uint8_t*)Dst, sizeof(Dst), CRC32_INITIAL)
     for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }  
441    
442  #define TEST_MB(FUNC, R)                \  #define TEST_MB(FUNC, R)                \
443      ENTER                               \      ENTER                               \
# Line 298  Line 456 
456    CPU *cpu;    CPU *cpu;
457    const uint8_t Src0[16*9] = {    const uint8_t Src0[16*9] = {
458          /* try to have every possible combinaison of rounding... */          /* try to have every possible combinaison of rounding... */
459        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,
460      , 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,
461      , 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,
462      , 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,
463      , 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,
464      , 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,
465      , 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,
466      , 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,
467      , 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
468    };    };
469    uint8_t Dst[16*8] = {0};    uint8_t Dst[16*8] = {0};
470    
# Line 321  Line 479 
479        continue;        continue;
480    
481      TEST_MB(interpolate8x8_halfpel_h, 0);      TEST_MB(interpolate8x8_halfpel_h, 0);
482      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",
483      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
484                               (iCrc!=0x115381ba)?"| ERROR": "" );
485    
486      TEST_MB(interpolate8x8_halfpel_h, 1);      TEST_MB(interpolate8x8_halfpel_h, 1);
487      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
488      if (iCrc!=8100) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
489                               (iCrc!=0x2b1f528f)?"| ERROR": "" );
490    
491    
492      TEST_MB(interpolate8x8_halfpel_v, 0);      TEST_MB(interpolate8x8_halfpel_v, 0);
493      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",
494      if (iCrc!=8108) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
495                               (iCrc!=0x423cdcc7)?"| ERROR": "" );
496    
497      TEST_MB(interpolate8x8_halfpel_v, 1);      TEST_MB(interpolate8x8_halfpel_v, 1);
498      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
499      if (iCrc!=8105) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
500                               (iCrc!=0x42202efe)?"| ERROR": "" );
501    
502    
503      TEST_MB(interpolate8x8_halfpel_hv, 0);      TEST_MB(interpolate8x8_halfpel_hv, 0);
504      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",
505      if (iCrc!=8112) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
506                               (iCrc!=0xd198d387)?"| ERROR": "" );
507    
508      TEST_MB(interpolate8x8_halfpel_hv, 1);      TEST_MB(interpolate8x8_halfpel_hv, 1);
509      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
510      if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
511                               (iCrc!=0x9ecfd921)?"| ERROR": "" );
512    
513    
514         /* this is a new function, as of 06.06.2002 */         /* this is a new function, as of 06.06.2002 */
515  #if 0  #if 0
516      TEST_MB2(interpolate8x8_avrg);      TEST_MB2(interpolate8x8_avrg);
517      printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
518      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
519                               (iCrc!=8107)?"| ERROR": "" );
520  #endif  #endif
521    
522        /* New functions for field prediction by CK 1.10.2005 */
523    #pragma NEW8X4
524                    TEST_MB(interpolate8x4_halfpel_h, 0);
525                    printf("%s - interpfield-h -round0 %.3f usec       crc32=0x%08x %s\n",
526                               cpu->name, t, iCrc,
527                               (iCrc!=0x9538d6df)?"| ERROR": "" );
528    
529                    TEST_MB(interpolate8x4_halfpel_h, 1);
530                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
531                               cpu->name, t, iCrc,
532                               (iCrc!=0xde5f1db4)?"| ERROR": "" );
533    
534    
535                    TEST_MB(interpolate8x4_halfpel_v, 0);
536                    printf("%s - interpfield- v-round0 %.3f usec       crc32=0x%08x %s\n",
537                               cpu->name, t, iCrc,
538                               (iCrc!=0xea5a69ef)?"| ERROR": "" );
539    
540                    TEST_MB(interpolate8x4_halfpel_v, 1);
541                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
542                               cpu->name, t, iCrc,
543                               (iCrc!=0x4f10ec0f)?"| ERROR": "" );
544    
545    
546                    TEST_MB(interpolate8x4_halfpel_hv, 0);
547                    printf("%s - interpfield-hv-round0 %.3f usec       crc32=0x%08x %s\n",
548                               cpu->name, t, iCrc,
549                               (iCrc!=0xf97ee367)?"| ERROR": "" );
550    
551                    TEST_MB(interpolate8x4_halfpel_hv, 1);
552                    printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
553                               cpu->name, t, iCrc,
554                               (iCrc!=0xb6a9f581)?"| ERROR": "" );
555    /* End of 8x4 functions */
556    
557      printf( " --- \n" );      printf( " --- \n" );
558    }    }
559  }  }
560    
561    #undef ENTER
562    #undef LEAVE
563    #undef TEST_MB
564    #undef TEST_MB2
565    
566  /*********************************************************************  /*********************************************************************
567   * test transfer   * test transfer
568   *********************************************************************/   *********************************************************************/
# Line 387  Line 592 
592      }                                         \      }                                         \
593      emms();                                   \      emms();                                   \
594      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
595      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]));  \
596    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
597    
598  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
599      TEST_TRANSFER_BEGIN(DST);                 \      TEST_TRANSFER_BEGIN(DST);                 \
# Line 413  Line 619 
619      }                                         \      }                                         \
620      emms();                                   \      emms();                                   \
621      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
622      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]));  \
623    s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
624    
625  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
626      TEST_TRANSFER2_BEGIN(DST,SRC);            \      TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 430  Line 637 
637    const int nb_tests = 4000*speed_ref;    const int nb_tests = 4000*speed_ref;
638    int i;    int i;
639    CPU *cpu;    CPU *cpu;
640    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];
641    int16_t Src16[8*32], Dst16[8*32];  //      int16_t Src16[8*32], Dst16[8*32];
642      DECLARE_ALIGNED_MATRIX(Src8, 8, 32, uint8_t, CACHE_LINE);
643      DECLARE_ALIGNED_MATRIX(Dst8, 8, 32, uint8_t, CACHE_LINE);
644      DECLARE_ALIGNED_MATRIX(Ref1, 8, 32, uint8_t, CACHE_LINE);
645      DECLARE_ALIGNED_MATRIX(Ref2, 8, 32, uint8_t, CACHE_LINE);
646      DECLARE_ALIGNED_MATRIX(Src16, 8, 32, uint16_t, CACHE_LINE);
647      DECLARE_ALIGNED_MATRIX(Dst16, 8, 32, uint16_t, CACHE_LINE);
648    
649    printf( "\n ===  test transfer ===\n" );    printf( "\n ===  test transfer ===\n" );
650    
651    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
652    {    {
653      double t, overhead;      double t, overhead;
654      int tst, s;      int tst, s;
# Line 444  Line 657 
657        continue;        continue;
658    
659      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
660      printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
661      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
662                               (s!=0x115814bb)?"| ERROR": "");
663    
664      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
665      printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
666      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
667                                    (s!=0xee7ccbb4)?"| ERROR": "");
668    
669        /* New functions for field prediction by CK 1.10.2005 */
670    #pragma NEW8X4
671                    TEST_TRANSFER(transfer8x4_copy, Dst8, Src8);
672                    printf("%s - 8to4      %.3f usec       crc32=0x%08x %s\n",
673                               cpu->name, t, s,
674                               (s!=0xbb9c3db5)?"| ERROR": "");
675    /* End of new functions */
676    
677      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
678      printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
679      if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
680                               (s!=0xd37b3295)?"| ERROR": "");
681    
682      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
683      printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
684      if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
685                               (s!=0xdd817bf4)?"| ERROR": "" );
686    
687      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
688      printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
689      if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
690      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);
691      printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, 8*32*sizeof(Src8[0]), CRC32_INITIAL);
692      if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
693  #if 1                                     cpu->name, t, s1, s2,
694                                       (s1!=0xa1e07163)?"| ERROR1": "",
695                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
696                    }
697    
698      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
699      printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
700      if (s!=20384) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
701  /*    for(i=0; i<64; ++i) printf( "[%d]", Dst16[i]); */                             (s!=0x99b6c4c7)?"| ERROR": "" );
702  /*    printf("\n"); */  
 #endif  
703      printf( " --- \n" );      printf( " --- \n" );
704    }    }
705  }  }
# Line 482  Line 710 
710    
711  #define TEST_QUANT(FUNC, DST, SRC)              \  #define TEST_QUANT(FUNC, DST, SRC)              \
712      t = gettime_usec();                         \      t = gettime_usec();                         \
713      for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
714        for(i=0; i<8*8; ++i) Quant[i] = qm;       \        for(i=0; i<8*8; ++i) Quant[i] = qm;       \
715        set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
716        emms();                                   \        emms();                                   \
717        for(q=1; q<=max_Q; ++q) {                 \        for(q=1; q<=max_Q; ++q) {                 \
718          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
719            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
720          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
721            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
722        }                                         \        }                                         \
723        emms();                                   \        emms();                                   \
724      }                                           \      }                                           \
725      t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
     s = (s&0xffff)^(s>>16)  
726    
727  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
728      t = gettime_usec();                         \      t = gettime_usec();                         \
729      for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
730        for(i=0; i<8*8; ++i) Quant[i] = qm;       \        for(i=0; i<8*8; ++i) Quant[i] = qm;       \
731        set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
732        emms();                                   \        emms();                                   \
733        for(q=1; q<=max_Q; ++q) {                 \        for(q=1; q<=max_Q; ++q) {                 \
734          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
735            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
736          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
737            s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
738      }                                         \
739      emms();                                   \
740    }                                           \
741    t = (gettime_usec()-t-overhead)/nb_tests/qm
742    
743    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
744    { int i,q,s;\
745            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
746      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
747      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
748      for(q=1;q<=max_Q;q++)          \
749        for(s=-RANGE;s<RANGE;s++) { \
750          for(i=0;i<64;i++) Src[i]=s; \
751          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
752          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
753          for(i=0;i<64;i++)     \
754            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]);  \
755        }                                         \        }                                         \
756    }
757    
758    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
759    { int i,q,s;  \
760            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
761      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
762      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
763      for(q=1;q<=max_Q;q++)  \
764        for(s=-RANGE;s<RANGE;s++) {   \
765          for(i=0;i<64;i++) Src[i]=s; \
766          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
767          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
768        emms();                                   \        emms();                                   \
769          for(i=0;i<64;i++) \
770            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]); \
771      }                                           \      }                                           \
772      t = (gettime_usec()-t-overhead)/nb_tests/qm;\  }
     s = (s&0xffff)^(s>>16)  
773    
774  void test_quant()  void test_quant()
775  {  {
776    const int nb_tests = 1*speed_ref;    const int nb_tests = 1*speed_ref;
777    const int max_Q = 31;    const int max_Q = 31;
778            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
779    
780    int i, qm;    int i, qm;
781    CPU *cpu;    CPU *cpu;
782    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
783            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
784            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
785    uint8_t Quant[8*8];    uint8_t Quant[8*8];
786    
787    printf( "\n =====  test quant =====\n" );    printf( "\n =====  test quant =====\n" );
# Line 530  Line 793 
793      Dst[i] = 0;      Dst[i] = 0;
794    }    }
795    
796    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
797    {    {
798      double t, overhead;      double t, overhead;
799      int tst, q;      int tst, q;
# Line 539  Line 802 
802      if (!init_cpu(cpu))      if (!init_cpu(cpu))
803        continue;        continue;
804    
805                    // exhaustive tests to compare against the (ref) C-version
806                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
807                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
808                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
809                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
810    
811      overhead = -gettime_usec();      overhead = -gettime_usec();
812      for(s=0,qm=1; qm<=255; ++qm) {      for(s=0,qm=1; qm<=255; ++qm) {
813        for(i=0; i<8*8; ++i) Quant[i] = qm;        for(i=0; i<8*8; ++i) Quant[i] = qm;
814        set_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
815        for(q=1; q<=max_Q; ++q)        for(q=1; q<=max_Q; ++q)
816          for(i=0; i<64; ++i) s+=Dst[i]^i^qm;          for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
817      }      }
818      overhead += gettime_usec();      overhead += gettime_usec();
819    
820  #if 1                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
821      TEST_QUANT2(quant4_intra, Dst, Src);                  printf("%s -   quant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
822      printf( "%s -   quant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                             cpu->name, t, s,
823      if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             (s!=0xfd6a21a4)? "| ERROR": "");
824    
825      TEST_QUANT(quant4_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
826      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",
827      if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
828  #endif                             (s!=0xf6de7757)?"| ERROR": "");
829  #if 1  
830      TEST_QUANT2(dequant4_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
831      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",
832      if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
833                               (s!=0x2def7bc7)?"| ERROR": "");
834      TEST_QUANT(dequant4_inter, Dst, Src);  
835      printf( "%s - dequant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
836      if (s!=63847) printf( "*** CRC ERROR! ***\n" );                  printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
837  #endif                             cpu->name, t, s,
838  #if 1                             (s!=0xd878c722)?"| ERROR": "");
839      TEST_QUANT2(quant_intra, Dst, Src);  
840      printf( "%s -    quant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(quant_h263_intra, Dst, Src);
841      if (s!=25662) printf( "*** CRC ERROR! ***\n" );                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
842                               cpu->name, t, s,
843      TEST_QUANT(quant_inter, Dst, Src);                             (s!=0x2eba9d43)?"| ERROR": "");
844      printf( "%s -    quant_inter %.3f usec       crc=%d\n", cpu->name, t, s );  
845      if (s!=23972) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT(quant_h263_inter, Dst, Src);
846  #endif                  printf("%s -   quant_h263_inter %.3f usec       crc32=0x%08x %s\n",
847  #if 1                             cpu->name, t, s,
848      TEST_QUANT2(dequant_intra, Dst, Src);                             (s!=0xbd315a7e)?"| ERROR": "");
849      printf( "%s -  dequant_intra %.3f usec       crc=%d\n", cpu->name, t, s );  
850      if (s!=49900) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
851                    printf("%s - dequant_h263_intra %.3f usec       crc32=0x%08x %s\n",
852      TEST_QUANT(dequant_inter, Dst, Src);                             cpu->name, t, s,
853      printf( "%s -  dequant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                             (s!=0x9841212a)?"| ERROR": "");
854      if (s!=48899) printf( "*** CRC ERROR! ***\n" );  
855  #endif                  TEST_QUANT(dequant_h263_inter, Dst, Src);
856                    printf("%s - dequant_h263_inter %.3f usec       crc32=0x%08x %s\n",
857                               cpu->name, t, s,
858                               (s!=0xe7df8fba)?"| ERROR": "");
859    
860                    printf( " --- \n" );
861            }
862    }
863    
864    /*********************************************************************
865     * test distortion operators
866     *********************************************************************/
867    
868    static void ieee_reseed(long s);
869    static long ieee_rand(int Min, int Max);
870    
871    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
872      do { \
873        t = gettime_usec(); \
874        tst = nb_tests; \
875        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
876        emms(); \
877        t = (gettime_usec() - t)/(double)nb_tests;  \
878      } while(0)
879    
880    
881    void test_sse()
882    {
883            const int nb_tests = 100000*speed_ref;
884            int i;
885            CPU *cpu;
886            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
887            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
888            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
889            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
890    
891            printf( "\n =====  test sse =====\n" );
892    
893            ieee_reseed(1);
894            for(i=0; i<64; ++i) {
895                    Src1[i] = ieee_rand(-2048, 2047);
896                    Src2[i] = ieee_rand(-2048, 2047);
897                    Src3[i] = ieee_rand(-2048, 2047);
898                    Src4[i] = ieee_rand(-2048, 2047);
899            }
900    
901            for(cpu = cpu_list; cpu->name!=0; ++cpu)
902            {
903                    double t;
904                    int tst, sse;
905    
906                    if (!init_cpu(cpu))
907                            continue;
908    
909                    /* 16 bit element blocks */
910                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
911                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
912                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
913                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
914                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
915                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
916                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
917                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
918                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
919                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
920                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
921                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
922                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
923                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
924                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
925                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
926                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
927                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
928    
929                    /* 8 bit element blocks */
930                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
931                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
932                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
933                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
934                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
935                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
936                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
937                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
938                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
939                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
940                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
941                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
942                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
943                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
944                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
945                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
946                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
947                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
948    
949      printf( " --- \n" );      printf( " --- \n" );
950    }    }
951  }  }
# Line 592  Line 954 
954   * test non-zero AC counting   * test non-zero AC counting
955   *********************************************************************/   *********************************************************************/
956    
957  #define TEST_CBP(FUNC, SRC)                   \  #define TEST_CBP(FUNC, SRC, NB)           \
958      t = gettime_usec();                       \      t = gettime_usec();                       \
959      emms();                                   \      emms();                                   \
960      for(tst=0; tst<nb_tests; ++tst) {         \  for(tst=0; tst<NB; ++tst) {         \
961        cbp = (FUNC)((SRC));                    \        cbp = (FUNC)((SRC));                    \
962      }                                         \      }                                         \
963      emms();                                   \      emms();                                   \
# Line 604  Line 966 
966  void test_cbp()  void test_cbp()
967  {  {
968    const int nb_tests = 10000*speed_ref;    const int nb_tests = 10000*speed_ref;
969    int i;          int i, n, m;
970    CPU *cpu;    CPU *cpu;
971    int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
972            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
973            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
974            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
975      DECLARE_ALIGNED_MATRIX(Src5, 6, 64, int16_t, 16);
976    
977    printf( "\n =====  test cbp =====\n" );    printf( "\n =====  test cbp =====\n" );
978    
# Line 615  Line 981 
981      Src2[i] = (i<3*64);               /* half-full */      Src2[i] = (i<3*64);               /* half-full */
982      Src3[i] = ((i+32)>3*64);      Src3[i] = ((i+32)>3*64);
983      Src4[i] = (i==(3*64+2) || i==(5*64+9));      Src4[i] = (i==(3*64+2) || i==(5*64+9));
984        Src5[i] = ieee_rand(0,1) ? -1 : 1;  /* +/- test */
985    }    }
986    
987    for(cpu = cpu_short_list2; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
988    {    {
989      double t;      double t;
990      int tst, cbp;      int tst, cbp;
# Line 625  Line 992 
992      if (!init_cpu(cpu))      if (!init_cpu(cpu))
993        continue;        continue;
994    
995      TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1, nb_tests);
996      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",
997      if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
998      TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2, nb_tests);
999      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",
1000      if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
1001      TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3, nb_tests);
1002      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",
1003      if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
1004      TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4, nb_tests);
1005      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",
1006      if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
1007                    TEST_CBP(calc_cbp, Src5, nb_tests);
1008                    printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
1009                               cpu->name, t, cbp, (cbp!=0x3f)?"| ERROR": "" );
1010      printf( " --- \n" );      printf( " --- \n" );
1011    }    }
1012    
1013            for(cpu = cpu_list; cpu->name!=0; ++cpu)  /* bench suggested by Carlo (carlo dot bramix at libero dot it) */
1014            {
1015                    double t;
1016                    int tst, cbp, err;
1017    
1018                    if (!init_cpu(cpu))
1019                            continue;
1020    
1021        err = 0;
1022        for(n=0; n<6; ++n)
1023        {
1024          for(m=0; m<64; ++m)
1025          {
1026            for(i=0; i<6*64; ++i)
1027              Src1[i] = (i== (m + n*64));
1028    
1029            TEST_CBP(calc_cbp, Src1, 1);
1030            if (cbp!= (((m!=0)<<(5-n))))
1031            {
1032              printf( "%s -   calc_cbp#5: ERROR at pos %d / %d!\n", cpu->name, n, m);
1033              err = 1;
1034              break;
1035            }
1036          }
1037        }
1038        if (!err)
1039          printf( " %s -    calc_cbp#5 : OK\n", cpu->name );
1040    
1041            }
1042  }  }
1043    
1044  /*********************************************************************  /*********************************************************************
# Line 767  Line 1167 
1167    }    }
1168  }  }
1169    
1170  /*//////////////////////////////////////////////////////// */  ///* ////////////////////////////////////////////////////// */
1171  /* Pseudo-random generator specified by IEEE 1180 */  /* Pseudo-random generator specified by IEEE 1180 */
1172    
1173  static long ieee_seed = 1;  static long ieee_seed = 1;
# Line 854  Line 1254 
1254    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 };
1255    int Loops = 10000;    int Loops = 10000;
1256    int i, m, n;    int i, m, n;
1257    short Blk0[64];     /* reference */          DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1258    short Blk[64], iBlk[64];          DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1259    short Ref_FDCT[64];          DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1260    short Ref_IDCT[64];          DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
1261            DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
1262    
1263    STATS_8x8 FStats; /* forward dct stats */    STATS_8x8 FStats; /* forward dct stats */
1264    STATS_8x8 IStats; /* inverse dct stats */    STATS_8x8 IStats; /* inverse dct stats */
# Line 910  Line 1311 
1311    
1312    
1313      printf( "\n  -- FDCT report --\n" );      printf( "\n  -- FDCT report --\n" );
1314  /*    print_stats(&FStats); */  //    print_stats(&FStats);
1315      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 */
1316    
1317      for(i=0; i<64; i++) Blk[i] = 0;      for(i=0; i<64; i++) Blk[i] = 0;
# Line 919  Line 1320 
1320      printf( "FDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );      printf( "FDCT(0) == 0 ?  %s\n", (m!=0) ? "NOPE!" : "yup." );
1321    
1322      printf( "\n  -- IDCT report --\n" );      printf( "\n  -- IDCT report --\n" );
1323  /*    print_stats(&IStats); */  //    print_stats(&IStats);
1324      report_stats(&IStats, ILimits);      report_stats(&IStats, ILimits);
1325    
1326    
# Line 937  Line 1338 
1338    
1339    int i, n, p;    int i, n, p;
1340    CPU *cpu;    CPU *cpu;
1341  /*  const short IDCT_MAX =  2047;  // 12bits input */  //  const short IDCT_MAX =  2047;  /* 12bits input */
1342  /*  const short IDCT_MIN = -2048; */  //  const short IDCT_MIN = -2048;
1343  /*  const short IDCT_OUT =   256;  // 9bits ouput */  //  const short IDCT_OUT =   256;  /* 9bits ouput */
1344    const int Partitions = 4;    const int Partitions = 4;
1345    const int Loops = 10000 / Partitions;    const int Loops = 10000 / Partitions;
1346    
# Line 987  Line 1388 
1388      report_stats(&Stats, 0);      report_stats(&Stats, 0);
1389    
1390    
1391                /* IDCT tests */                  /* IDCT tests // */
1392  #if 0  #if 0
1393        /* no finished yet */        /* no finished yet */
1394    
# Line 1031  Line 1432 
1432   * measure raw decoding speed   * measure raw decoding speed
1433   *********************************************************************/   *********************************************************************/
1434    
1435  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)
1436  {  {
1437    FILE *f = 0;    FILE *f = 0;
1438    void *dechandle = 0;    void *dechandle = 0;
1439    int xerr;    int xerr;
1440          XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
1441          XVID_DEC_PARAM xparam;          xvid_dec_create_t xparam;
1442          XVID_DEC_FRAME xframe;          xvid_dec_frame_t xframe;
1443          double t = 0.;          double t = 0.;
1444          int nb = 0;          int nb = 0;
1445    uint8_t *buf = 0;    uint8_t *buf = 0;
1446    uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1447    int buf_size, pos;    int buf_size, pos;
1448    uint32_t chksum = 0;    uint32_t chksum = 0;
1449            int bps = (width+31) & ~31;
1450    
1451          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          memset(&xinit, 0, sizeof(xinit));
1452          xvid_init(NULL, 0, &xinit, NULL);          xinit.cpu_flags = cpu_mask;
1453          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          xinit.version = XVID_VERSION;
1454            xvid_global(NULL, 0, &xinit, NULL);
1455    
1456            memset(&xparam, 0, sizeof(xparam));
1457          xparam.width = width;          xparam.width = width;
1458          xparam.height = height;          xparam.height = height;
1459            xparam.version = XVID_VERSION;
1460          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1461          if (xerr!=XVID_ERR_OK) {          if (xerr==XVID_ERR_FAIL) {
1462            printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1463            return;            return;
1464          }          }
1465          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1063  Line 1467 
1467    
1468          f = fopen(name, "rb");          f = fopen(name, "rb");
1469    if (f==0) {    if (f==0) {
1470      printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1471      return;      return;
1472    }    }
1473    fseek(f, 0, SEEK_END);    fseek(f, 0, SEEK_END);
1474    buf_size = ftell(f);    buf_size = ftell(f);
1475    fseek(f, 0, SEEK_SET);    fseek(f, 0, SEEK_SET);
1476    if (buf_size<=0) {    if (buf_size<=0) {
1477      printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1478      goto End;      goto End;
1479    }    }
   else printf( "Input size: %d\n", buf_size);  
1480    
1481    buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1482    rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1483    if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1484      printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1485      goto End;      goto End;
1486    }    }
1487    
1488    if (fread(buf, buf_size, 1, f)!=1) {    if (fread(buf, buf_size, 1, f)!=1) {
1489      printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1490      goto End;      goto End;
1491    }    }
1492    
# Line 1091  Line 1494 
1494    pos = 0;    pos = 0;
1495    t = -gettime_usec();    t = -gettime_usec();
1496    while(1) {    while(1) {
1497              int y;
1498    
1499                    memset(&xframe, 0, sizeof(xframe));
1500                    xframe.version = XVID_VERSION;
1501      xframe.bitstream = buf + pos;      xframe.bitstream = buf + pos;
1502      xframe.length = buf_size - pos;      xframe.length = buf_size - pos;
1503      xframe.image = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1504      xframe.stride = width;                  xframe.output.plane[1] = (uint8_t*)xframe.output.plane[0] + bps*height;
1505      xframe.colorspace = XVID_CSP_RGB24;                  xframe.output.plane[2] = (uint8_t*)xframe.output.plane[1] + bps/2;
1506                    xframe.output.stride[0] = bps;
1507                    xframe.output.stride[1] = bps;
1508                    xframe.output.stride[2] = bps;
1509                    xframe.output.csp = XVID_CSP_I420;
1510      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1511                    if (xerr<0) {
1512                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1513                            break;
1514                    }
1515                    else if (xerr==0)
1516                      break;
1517        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1518    
1519                    pos += xerr;
1520      nb++;      nb++;
1521      pos += xframe.length;  
1522      if (with_chksum) {      for(y=0; y<height/2; ++y) {
1523        int k = width*height;                    chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1524        uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1525        while(k-->0) chksum += *ptr++;                          chksum = calc_crc((uint8_t*)xframe.output.plane[1] + y*bps, width/2, chksum);
1526                            chksum = calc_crc((uint8_t*)xframe.output.plane[2] + y*bps, width/2, chksum);
1527      }      }
1528      if (pos==buf_size)      if (pos==buf_size)
1529        break;        break;
     if (xerr!=XVID_ERR_OK) {  
           printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
           break;  
         }  
1530    }    }
1531    t += gettime_usec();    t += gettime_usec();
1532            if (ref_chksum==0) {
1533    if (t>0.)    if (t>0.)
1534      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 );
1535    if (with_chksum)    }
1536      printf("checksum: 0x%.8x\n", chksum);    else {
1537                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1538                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1539      }
1540    
1541  End:  End:
1542    if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1543    if (buf!=0) free(buf);    if (buf!=0) free(buf);
1544    if (dechandle!=0) {    if (dechandle!=0) {
1545      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1546      if (xerr!=XVID_ERR_OK)                  if (xerr==XVID_ERR_FAIL)
1547              printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1548    }    }
1549    if (f!=0) fclose(f);    if (f!=0) fclose(f);
1550  }  }
# Line 1135  Line 1556 
1556  void test_bugs1()  void test_bugs1()
1557  {  {
1558    CPU *cpu;    CPU *cpu;
1559            uint16_t mpeg_quant_matrices[64*8];
1560    
1561    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1562    
1563    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1564    {    {
1565      int i;      int i;
1566      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 1147  Line 1569 
1569        continue;        continue;
1570    
1571      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1572      set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1573      dequant4_intra(Dst, Src, 31, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1574      printf( "dequant4_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1575      printf( "  Out[]= " );      printf( "  Out[]= " );
1576      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1577      printf( "\n" );      printf( "\n" );
# Line 1157  Line 1579 
1579    
1580    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );
1581    
1582    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1583    {    {
1584      int i;      int i;
1585      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 1166  Line 1588 
1588        continue;        continue;
1589    
1590      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1591      set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1592      dequant4_inter(Dst, Src, 31);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1593      printf( "dequant4_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1594      printf( "  Out[]= " );      printf( "  Out[]= " );
1595      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1596      printf( "\n" );      printf( "\n" );
# Line 1178  Line 1600 
1600  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1601  {  {
1602    CPU *cpu;    CPU *cpu;
1603    short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1604            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1605    
1606    printf( "\n =====  fdct/idct precision diffs =====\n" );    printf( "\n =====  fdct/idct precision diffs =====\n" );
1607    
1608    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1609    {    {
1610      int i;      int i;
1611    
# Line 1211  Line 1634 
1634    const int max_Q = 31;    const int max_Q = 31;
1635    int i, n, qm, q;    int i, n, qm, q;
1636    CPU *cpu;    CPU *cpu;
1637    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1638            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1639    uint8_t Quant[8*8];    uint8_t Quant[8*8];
1640    CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };    CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1641    uint16_t Crcs_Inter[2][32];    uint16_t Crcs_Inter[2][32];
1642    uint16_t Crcs_Intra[2][32];    uint16_t Crcs_Intra[2][32];
1643            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1644    
1645    printf( "\n =====  test MPEG4-quantize bug =====\n" );    printf( "\n =====  test MPEG4-quantize bug =====\n" );
1646    
1647    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 1650 
1650    for(qm=1; qm<=255; ++qm)    for(qm=1; qm<=255; ++qm)
1651    {    {
1652      for(i=0; i<8*8; ++i) Quant[i] = qm;      for(i=0; i<8*8; ++i) Quant[i] = qm;
1653      set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1654    
1655      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1656      {      {
# Line 1235  Line 1661 
1661    
1662        for(q=1; q<=max_Q; ++q) {        for(q=1; q<=max_Q; ++q) {
1663          emms();          emms();
1664          quant4_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1665          emms();          emms();
1666          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;
1667          Crcs_Inter[n][q] = s;          Crcs_Inter[n][q] = s;
# Line 1254  Line 1680 
1680    for(qm=1; qm<=255; ++qm)    for(qm=1; qm<=255; ++qm)
1681    {    {
1682      for(i=0; i<8*8; ++i) Quant[i] = qm;      for(i=0; i<8*8; ++i) Quant[i] = qm;
1683      set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1684    
1685      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1686      {      {
# Line 1265  Line 1691 
1691    
1692        for(q=1; q<=max_Q; ++q) {        for(q=1; q<=max_Q; ++q) {
1693          emms();          emms();
1694          quant4_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1695          emms();          emms();
1696          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;
1697          Crcs_Intra[n][q] = s;          Crcs_Intra[n][q] = s;
# Line 1282  Line 1708 
1708  }  }
1709    
1710  /*********************************************************************  /*********************************************************************
1711     * test some YUV func
1712     *********************************************************************/
1713    
1714    #define ENTER \
1715    for(i=0; i<(int)sizeof(Dst0); ++i) Dst0[0][i] = 0;   \
1716    t = gettime_usec();                   \
1717    emms();
1718    
1719    #define LEAVE \
1720    emms();                             \
1721    t = (gettime_usec() - t) / nb_tests;  \
1722            iCrc = calc_crc((uint8_t*)Dst0, sizeof(Dst0), CRC32_INITIAL)
1723    
1724    #define TEST_YUYV(FUNC, S)                \
1725    ENTER                               \
1726    for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst0[0], S*WIDTH, Src0[0], Src0[1], Src0[2], WIDTH, WIDTH/2, WIDTH, HEIGHT, 0); \
1727    LEAVE
1728    
1729    #define WIDTH 128
1730    #define HEIGHT 32
1731    void test_yuv()
1732    {
1733            const int nb_tests = 200*speed_ref;
1734            CPU *cpu;
1735            uint8_t Src0[3][WIDTH*HEIGHT];
1736            uint8_t Dst0[4][WIDTH*HEIGHT];
1737            int i, j;
1738            double t;
1739            int tst, iCrc;
1740    
1741            colorspace_init();
1742            ieee_reseed(1);
1743            for(i=0; i<(int)sizeof(Src0); ++i) Src0[0][i] = ieee_rand(0,255);
1744            for(i=0; i<(int)sizeof(Dst0); ++i) Dst0[0][i] = 0x5a;
1745    
1746            printf( "\n ===  test YUV ===\n" );
1747    
1748            init_cpu(&cpu_list[0]);
1749            TEST_YUYV(yv12_to_yuyv_c, 4);
1750            printf(" yv12_to_yuyv_c %.3f usec       crc32=0x%08x %s\n",
1751                       t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1752            TEST_YUYV(yv12_to_uyvy_c, 4);
1753            printf(" yv12_to_uyvy_c %.3f usec       crc32=0x%08x %s\n",
1754                       t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1755    
1756    #ifdef ARCH_IS_IA32
1757            init_cpu(&cpu_list[1]);
1758            TEST_YUYV(yv12_to_yuyv_mmx, 4);
1759            printf(" yv12_to_yuyv_mmx %.3f usec       crc32=0x%08x %s\n",
1760                    t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1761    
1762            TEST_YUYV(yv12_to_uyvy_mmx, 4);
1763            printf(" yv12_to_uyvy_mmx %.3f usec       crc32=0x%08x %s\n",
1764                    t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1765    #endif
1766    
1767    #ifdef ARCH_IS_PPC
1768            init_cpu(&cpu_list[1]);
1769            TEST_YUYV(yv12_to_yuyv_altivec_c, 4);
1770            printf(" yv12_to_yuyv_altivec_c %.3f usec       crc32=0x%08x %s\n",
1771                    t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
1772    
1773            TEST_YUYV(yv12_to_uyvy_altivec_c, 4);
1774            printf(" yv12_to_uyvy_altivec_c %.3f usec       crc32=0x%08x %s\n",
1775                    t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
1776    #endif
1777            printf( " --- \n" );
1778    }
1779    
1780    #define TEST_YV2(FUNC, WITH_UV, WITH_FLIP)        \
1781    ENTER                               \
1782    for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst0[0], Dst0[1], Dst0[2], WIDTH, WIDTH, \
1783            Src0[0], (WITH_UV) ? Src0[1] : 0, (WITH_UV) ? Src0[2] : 0,  WIDTH, WIDTH, \
1784            WIDTH-2, HEIGHT-2, WITH_FLIP); \
1785    LEAVE
1786    
1787    #define PRINT_NxN(DATA,W,H,STR)   {   \
1788            int i,j; \
1789            for(j=0; j<(H); ++j) { \
1790                    for(i=0; i<(W); ++i) printf( "0x%.2x ", (DATA)[i+j*(STR)] );\
1791                    printf("\n"); \
1792            } \
1793            printf("---\n"); \
1794    }
1795    
1796    static const int yv12_CRCs[2][2] = {
1797            {0x5cab7cf0,0xdab46541}
1798    ,       {0xe8bae865,0x1faf77b7}
1799    };
1800    
1801    void test_yuv2()
1802    {
1803            const int nb_tests = 800*speed_ref;
1804            CPU *cpu;
1805            uint8_t Src0[3][WIDTH*HEIGHT];
1806            uint8_t Dst0[3][WIDTH*HEIGHT];
1807            int with_uv, with_flip;
1808            int i, j;
1809            double t;
1810            int tst, iCrc;
1811    
1812            colorspace_init();
1813            ieee_reseed(1);
1814            for(i=0; i<(int)sizeof(Src0); ++i) Src0[0][i] = ieee_rand(0,255);
1815    
1816            printf( "\n ===  test YV2 ===\n" );
1817            for(with_flip=0; with_flip<=1; ++with_flip) {
1818                    for(with_uv=0; with_uv<=1; ++with_uv) {
1819                            init_cpu(&cpu_list[0]);
1820                            TEST_YV2(yv12_to_yv12_c, with_uv, with_flip);
1821                            printf(" yv12_to_yv12_c   %.3f usec      \tcrc32=0x%08x %s\n",
1822                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1823                            /* if (!with_uv) PRINT_NxN(Dst0[1], WIDTH/2, HEIGHT/2, WIDTH ); */
1824    
1825    #ifdef ARCH_IS_IA32
1826                            init_cpu(&cpu_list[1]);
1827                            TEST_YV2(yv12_to_yv12_mmx, with_uv, with_flip);
1828                            printf(" yv12_to_yv12_mmx %.3f usec     \tcrc32=0x%08x %s\n",
1829                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1830                            /* if (!with_uv) PRINT_NxN(Dst0[1], WIDTH/2, HEIGHT/2, WIDTH ); */
1831    
1832                            TEST_YV2(yv12_to_yv12_xmm, with_uv, with_flip);
1833                            printf(" yv12_to_yv12_xmm %.3f usec     \tcrc32=0x%08x %s\n",
1834                                    t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
1835    #endif
1836                    }
1837    
1838                    printf( " --- \n" );
1839            }
1840            printf( " ===== \n" );
1841    }
1842    
1843    #undef WIDTH
1844    #undef HEIGHT
1845    #undef ENTER
1846    #undef LEAVE
1847    
1848    /*********************************************************************/
1849    
1850    static uint32_t __inline log2bin_v1(uint32_t value)
1851    {
1852      int n = 0;
1853      while (value) {
1854        value >>= 1;
1855        n++;
1856      }
1857      return n;
1858    }
1859    
1860    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1861    
1862    static uint32_t __inline log2bin_v2(uint32_t value)
1863    {
1864      int n = 0;
1865      if (value & 0xffff0000) {
1866        value >>= 16;
1867        n += 16;
1868      }
1869      if (value & 0xff00) {
1870        value >>= 8;
1871        n += 8;
1872      }
1873      if (value & 0xf0) {
1874        value >>= 4;
1875        n += 4;
1876      }
1877     return n + log2_tab_16[value];
1878    }
1879    
1880    void test_log2bin()
1881    {
1882            const int nb_tests = 3000*speed_ref;
1883      int n, crc1=0, crc2=0;
1884      uint32_t s, s0;
1885      double t1, t2;
1886    
1887      t1 = gettime_usec();
1888      s0 = (int)(t1*31.241);
1889      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1890        crc1 += log2bin_v1(s);
1891      t1 = (gettime_usec()-t1) / nb_tests;
1892    
1893      t2 = gettime_usec();
1894      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1895        crc2 += log2bin_v2(s);
1896      t2 = (gettime_usec() - t2) / nb_tests;
1897    
1898      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1899      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1900      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1901    }
1902    
1903    /*********************************************************************/
1904    
1905    static void __inline old_gcd(int *num, int *den)
1906    {
1907     int i = *num;
1908      while (i > 1) {
1909        if (*num % i == 0 && *den % i == 0) {
1910          *num /= i;
1911          *den /= i;
1912          i = *num;
1913          continue;
1914        }
1915        i--;
1916      }
1917    }
1918    
1919    static uint32_t gcd(int num, int den)
1920    {
1921      int tmp;
1922      while( (tmp=num%den) ) { num = den; den = tmp; }
1923      return den;
1924    }
1925    static void __inline new_gcd(int *num, int *den)
1926    {
1927      const int div = gcd(*num, *den);
1928      if (num) {
1929        *num /= div;
1930        *den /= div;
1931      }
1932    }
1933    
1934    void test_gcd()
1935    {
1936      const int nb_tests = 10*speed_ref;
1937      int i;
1938      uint32_t crc1=0, crc2=0;
1939      uint32_t n0, n, d0, d;
1940      double t1, t2;
1941    
1942      t1 = gettime_usec();
1943      n0 = 0xfffff & (int)(t1*31.241);
1944      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1945      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1946        old_gcd(&n, &d);
1947        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1948        n = d;
1949        d = (d*12363+31) & 0xffff;
1950        d |= !d;
1951      }
1952      t1 = (gettime_usec()-t1) / nb_tests;
1953    
1954      t2 = gettime_usec();
1955      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1956        new_gcd(&n, &d);
1957        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1958        n = d;
1959        d = (d*12363+31) & 0xffff;
1960        d |= !d;
1961      }
1962      t2 = (gettime_usec() - t2) / nb_tests;
1963    
1964      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1965      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1966      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1967    }
1968    
1969    /*********************************************************************
1970     * test compiler
1971     *********************************************************************/
1972    
1973    void test_compiler() {
1974      int nb_err = 0;
1975      int32_t v;
1976      if (sizeof(uint16_t)<2) {
1977        printf( "ERROR: sizeof(uint16_t)<2 !!\n" );
1978        nb_err++;
1979      }
1980      if (sizeof(int16_t)<2) {
1981        printf( "ERROR: sizeof(int16_t)<2 !!\n" );
1982        nb_err++;
1983      }
1984      if (sizeof(uint8_t)!=1) {
1985        printf( "ERROR: sizeof(uint8_t)!=1 !!\n" );
1986        nb_err++;
1987      }
1988      if (sizeof(int8_t)!=1) {
1989        printf( "ERROR: sizeof(int8_t)!=1 !!\n" );
1990        nb_err++;
1991      }
1992      if (sizeof(uint32_t)<4) {
1993        printf( "ERROR: sizeof(uint32_t)<4 !!\n" );
1994        nb_err++;
1995      }
1996      if (sizeof(int32_t)<4) {
1997        printf( "ERROR: sizeof(int32_t)<4 !!\n" );
1998        nb_err++;
1999      }
2000             /* yes, i know, this test is silly. But better be safe than sorry. :) */
2001      for(v=1000; v>=0; v--) {
2002        if ( (v>>2) != v/4)
2003          nb_err++;
2004      }
2005      for(v=-1000; v!=-1; v++) {
2006        if ( (v>>2) != (v/4)-!!(v%4))
2007          nb_err++;
2008      }
2009      if (nb_err!=0) {
2010        printf( "ERROR! please post your platform/compiler specs to xvid-devel@xvid.org !\n" );
2011      }
2012    }
2013    
2014    /*********************************************************************
2015     * test SSIM functions
2016     *********************************************************************/
2017    
2018    typedef int (*lumfunc)(uint8_t* ptr, int stride);
2019    typedef void (*csfunc)(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2020    
2021    extern int lum_8x8_c(uint8_t* ptr, int stride);
2022    extern int lum_8x8_mmx(uint8_t* ptr, int stride);
2023    extern int lum_2x8_c(uint8_t* ptr, int stride);
2024    extern void consim_c(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2025    extern void consim_mmx(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2026    extern void consim_sse2(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
2027    
2028    void test_SSIM()
2029    {
2030            const int nb_tests = 3000*speed_ref;
2031            int tst;
2032            CPU *cpu;
2033            int i;
2034            int devs[3];
2035            long lumo, lumc;
2036            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
2037            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
2038            lumfunc lum8x8;
2039            lumfunc lum2x8;
2040            csfunc  csim;
2041    
2042            ieee_reseed(1);
2043            printf( "\n ======  test SSIM ======\n" );
2044            for(i=0; i<16*16;++i) {
2045                    long v1, v2;
2046                    v1 = ieee_rand(-256, 511);
2047                    v2 = ieee_rand(-256, 511);
2048                    Ref1[i] = (v1<0) ? 0 : (v1>255) ? 255 : v1;
2049                    Ref2[i] = (v2<0) ? 0 : (v2>255) ? 255 : v2;
2050            }
2051            lumc = ieee_rand(0, 255);
2052            lumo = ieee_rand(0, 255);
2053    
2054            for(cpu = cpu_list; cpu->name!=0; ++cpu)
2055            {
2056                    double t;
2057                    int m;
2058                    if (!init_cpu(cpu))
2059                            continue;
2060                    lum8x8 = lum_8x8_c;
2061                    lum2x8 = lum_2x8_c;
2062                    csim   = consim_c;
2063                    if (cpu->cpu & XVID_CPU_MMX){
2064                            lum8x8 = lum_8x8_mmx;
2065                            csim = consim_mmx;
2066                    }
2067                    if (cpu->cpu & XVID_CPU_MMX){
2068                            csim = consim_sse2;
2069                    }
2070    
2071                    t = gettime_usec();
2072                    emms();
2073                    for(tst=0; tst<nb_tests; ++tst) m = lum8x8(Ref1, 16);
2074                    emms();
2075                    t = (gettime_usec() - t) / nb_tests;
2076                    printf("%s - ssim-lum8x8    %.3f usec       m=%d %s\n",
2077                               cpu->name, t, m,
2078                               (m!=8230)?"| ERROR": "" );
2079    
2080                    t = gettime_usec();
2081                    emms();
2082                    for(tst=0; tst<nb_tests; ++tst) m = lum2x8(Ref1+8, 16);
2083                    emms();
2084                    t = (gettime_usec() - t) / nb_tests;
2085                    printf("%s - ssim-lum2x8    %.3f usec       m=%d %s\n",
2086                               cpu->name, t, m,
2087                               (m!=681)?"| ERROR": "" );
2088    
2089                    t = gettime_usec();
2090                    emms();
2091                    for(tst=0; tst<nb_tests; ++tst) csim(Ref1, Ref2, 16, lumo, lumc, devs+0, devs+1, devs+2);
2092                    emms();
2093                    t = (gettime_usec() - t) / nb_tests;
2094                    printf("%s - ssim-consim    %.3f usec       devs=[0x%x 0x%x 0x%x] %s\n",
2095                               cpu->name, t, devs[0], devs[1], devs[2],
2096                               (devs[0]!=0x1bdf0f || devs[1]!=0x137258 ||  devs[2]!=0xcdb13)?"| ERROR": "" );
2097                    printf( " --- \n" );
2098            }
2099    }
2100    
2101    /*********************************************************************
2102     * test bitstream functions
2103     *********************************************************************/
2104    
2105    #define BIT_BUF_SIZE 2000
2106    
2107    static void test_bits()
2108    {
2109      const int nb_tests = 50*speed_ref;
2110      int tst;
2111      uint32_t Crc;
2112      uint8_t Buf[BIT_BUF_SIZE];
2113      uint32_t Extracted[BIT_BUF_SIZE*8]; /* worst case: bits read 1 by 1 */
2114      int Lens[BIT_BUF_SIZE*8];
2115      double t1;
2116    
2117    
2118      printf( "\n ===  test bitstream ===\n" );
2119      ieee_reseed(1);
2120      Crc = 0;
2121    
2122      t1 = gettime_usec();
2123      for(tst=0; tst<nb_tests; ++tst) {
2124            Bitstream bs;
2125            int m, m2, l, l2;
2126    
2127            for(l=0; l<BIT_BUF_SIZE; ++l)
2128                    Buf[l] = (uint8_t)ieee_rand(0,255);
2129    
2130            l = BIT_BUF_SIZE - ieee_rand(1,BIT_BUF_SIZE/10);
2131            BitstreamInit(&bs, (void*)(Buf+BIT_BUF_SIZE-l), l);
2132    
2133    
2134            BitstreamReset(&bs);
2135            for(l2=l*8, m=0; l2>0; m++) {
2136                    const int b = ieee_rand(1,32);
2137                    Lens[m] = b;
2138                    l2 -= b;
2139                    if (l2<0) break;
2140                    Extracted[m] = BitstreamShowBits(&bs, b);
2141                    BitstreamSkip(&bs, b);
2142    //              printf( "<= %d: %d 0x%x\n", m, b, Extracted[m]);
2143            }
2144    
2145            BitstreamReset(&bs);
2146            for(m2=0; m2<m; ++m2) {
2147                    const int b = Lens[m2];
2148                    const uint32_t v = BitstreamGetBits(&bs, b);
2149                    Crc |= (v!=Extracted[m2]);
2150    //              printf( "=> %d: %d 0x%x %c\n", m2, b, v, " *"[Crc]);
2151            }
2152      }
2153      t1 = (gettime_usec() - t1) / nb_tests;
2154      printf(" test_bits   %.3f usec   %s\n", t1, (Crc!=0)?"| ERROR": "" );
2155    }
2156    
2157    /*********************************************************************
2158   * main   * main
2159   *********************************************************************/   *********************************************************************/
2160    
2161  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
2162  {  {
2163    int what = 0;    printf( "missing argument after option '%s'\n", opt);
2164    if (argc>1) what = atoi(argv[1]);    exit(-1);
2165    }
2166    
2167    int main(int argc, const char *argv[])
2168    {
2169            int c, what = 0;
2170            int width, height;
2171            uint32_t chksum = 0;
2172            const char * test_bitstream = 0;
2173    
2174            cpu_mask = 0;  // default => will use autodectect
2175            for(c=1; c<argc; ++c)
2176            {
2177              if (!strcmp(argv[c], "-v")) verbose++;
2178              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
2179              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
2180              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
2181              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
2182              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
2183              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
2184              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
2185              else if (!strcmp(argv[c], "-spd")) {
2186          if (++c==argc) arg_missing( argv[argc-1] );
2187          speed_ref = atoi(argv[c]);
2188        }
2189              else if (argv[c][0]!='-') {
2190                what = atoi(argv[c]);
2191                if (what==9) {
2192                  if (c+4>argc) {
2193                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
2194                    exit(-1);
2195            }
2196            test_bitstream = argv[++c];
2197                  width  = atoi(argv[++c]);
2198                  height = atoi(argv[++c]);
2199                  if (c+1<argc && argv[c+1][0]!='-') {
2200                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
2201                      printf( "can't read checksum value.\n" );
2202                      exit(-1);
2203              }
2204              else c++;
2205            }
2206    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
2207          }
2208        }
2209        else {
2210          printf( "unrecognized option '%s'\n", argv[c]);
2211          exit(-1);
2212        }
2213      }
2214    
2215    
2216    if (what==0 || what==1) test_dct();    if (what==0 || what==1) test_dct();
2217    if (what==0 || what==2) test_mb();    if (what==0 || what==2) test_mb();
2218    if (what==0 || what==3) test_sad();    if (what==0 || what==3) test_sad();
2219    if (what==0 || what==4) test_transfer();    if (what==0 || what==4) test_transfer();
2220    if (what==0 || what==5) test_quant();    if (what==0 || what==5) test_quant();
2221    if (what==0 || what==6) test_cbp();    if (what==0 || what==6) test_cbp();
2222            if (what==0 || what==10) test_sse();
2223            if (what==0 || what==11) test_log2bin();
2224            if (what==0 || what==12) test_gcd();
2225            if (what==0 || what==13) test_compiler();
2226            if (what==0 || what==14) test_yuv();
2227            if (what==0 || what==15) test_SSIM();
2228            if (what==0 || what==16) test_yuv2();
2229            if (what==0 || what==17) test_bits();
2230    
2231    if (what==7) {    if (what==7) {
2232      test_IEEE1180_compliance(-256, 255, 1);      test_IEEE1180_compliance(-256, 255, 1);
 #if 0  
2233      test_IEEE1180_compliance(-256, 255,-1);      test_IEEE1180_compliance(-256, 255,-1);
2234      test_IEEE1180_compliance(  -5,   5, 1);      test_IEEE1180_compliance(  -5,   5, 1);
2235      test_IEEE1180_compliance(  -5,   5,-1);      test_IEEE1180_compliance(  -5,   5,-1);
2236      test_IEEE1180_compliance(-300, 300, 1);      test_IEEE1180_compliance(-300, 300, 1);
2237      test_IEEE1180_compliance(-300, 300,-1);      test_IEEE1180_compliance(-300, 300,-1);
 #endif  
2238    }    }
2239    if (what==8) test_dct_saturation(-256, 255);    if (what==8) test_dct_saturation(-256, 255);
2240    
2241    if (what==9) {          if (test_bitstream)
2242      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));  
   }  
   
2243    if (what==-1) {    if (what==-1) {
2244      test_dct_precision_diffs();      test_dct_precision_diffs();
2245      test_bugs1();      test_bugs1();
# Line 1326  Line 2247 
2247    if (what==-2)    if (what==-2)
2248      test_quant_bug();      test_quant_bug();
2249    
2250    return 0;          if ((what >= 0 && what <= 6) || what == 10) {
2251                    printf("\n\n"
2252                               "NB: If a function isn't optimised for a specific set of intructions,\n"
2253                               "    a C function is used instead. So don't panic if some functions\n"
2254                               "    may appear to be slow.\n");
2255  }  }
2256    
2257  /*********************************************************************  #ifdef ARCH_IS_IA32
2258   * 'Reference' output (except for timing) on a PIII 1.13Ghz/linux          if (what == 0 || what == 5) {
2259   *********************************************************************/                  printf("\n"
2260                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
2261      /* 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"
2262  /*                             "    test goes far behind the usual limits of real encoding. Please do not report\n"
2263                               "    this error to the developers.\n");
2264            }
2265    #endif
2266    
2267   ===== test fdct/idct =====          return 0;
2268  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  
  ---  
2269    
2270  */  /*********************************************************************/
Legend:
Removed from v.824  
changed lines
  Added in v.1746
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4