[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 860, Sun Feb 16 05:11:39 2003 UTC revision 1398, Fri Apr 2 21:29:21 2004 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC - Unit tests and benches   *  XVID MPEG-4 VIDEO CODEC
4     *  - Unit tests and benches -
5     *
6     *  Copyright(C) 2002 Pascal Massimino <skal@planet-d.net>
7   *   *
8   *      This program is free software; you can redistribute it and/or modify   *      This program is free software; you can redistribute it and/or modify
9   *      it under the terms of the GNU General Public License as published by   *      it under the terms of the GNU General Public License as published by
# Line 14  Line 17 
17   *   *
18   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
19   *      along with this program; if not, write to the Free Software   *      along with this program; if not, write to the Free Software
20   *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21     *
22     * $Id: xvid_bench.c,v 1.12 2004-04-02 21:29:21 edgomez Exp $
23   *   *
24   *************************************************************************/   ****************************************************************************/
25    
26  /************************************************************************  /*****************************************************************************
27   *   *
28   *  'Reference' output is at the end of file.   *  'Reference' output is at the end of file.
29   *  Don't take the checksums and crc too seriouly, they aren't   *  Don't take the checksums and crc too seriouly, they aren't
# Line 27  Line 32 
32   *   compiles with something like:   *   compiles with something like:
33   *   gcc -o xvid_bench xvid_bench.c  -I../src/ -lxvidcore -lm   *   gcc -o xvid_bench xvid_bench.c  -I../src/ -lxvidcore -lm
34   *   *
35   *      History:   ****************************************************************************/
  *  
  *      06.06.2002  initial coding      -Skal-  
  *  
  *************************************************************************/  
36    
37  #include <stdio.h>  #include <stdio.h>
38  #include <stdlib.h>  #include <stdlib.h>
39  #include <string.h>    // for memset  #include <string.h>    /* for memset */
40  #include <assert.h>  #include <assert.h>
41    
42  #ifndef WIN32  #ifndef WIN32
43  #include <sys/time.h>   // for gettimeofday  #include <sys/time.h>   /* for gettimeofday */
44  #else  #else
45  #include <time.h>  #include <time.h>
46  #endif  #endif
# Line 53  Line 54 
54  #include "image/colorspace.h"  #include "image/colorspace.h"
55  #include "image/interpolate8x8.h"  #include "image/interpolate8x8.h"
56  #include "utils/mem_transfer.h"  #include "utils/mem_transfer.h"
57  #include "quant/quant_h263.h"  #include "quant/quant.h"
 #include "quant/quant_mpeg4.h"  
58  #include "motion/sad.h"  #include "motion/sad.h"
59  #include "utils/emms.h"  #include "utils/emms.h"
60  #include "utils/timer.h"  #include "utils/timer.h"
# Line 67  Line 67 
67  #define M_PI            3.14159265358979323846  #define M_PI            3.14159265358979323846
68  #endif  #endif
69    
70  const int speed_ref = 100;  // on slow machines, decrease this value  const int speed_ref = 100;  /* on slow machines, decrease this value */
71    
72  /*********************************************************************  /*********************************************************************
73   * misc   * misc
# Line 114  Line 114 
114    
115  CPU cpu_list[] =  CPU cpu_list[] =
116  { { "PLAINC", 0 }  { { "PLAINC", 0 }
117    #ifdef ARCH_IS_IA32
118  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
119  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }
120  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }
121  , { "3DNOW ", XVID_CPU_3DNOW }  , { "3DNOW ", XVID_CPU_3DNOW }
122  , { "3DNOWE", XVID_CPU_3DNOWEXT }    , { "3DNOWE", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT }
123  , { "IA64  ", XVID_CPU_IA64 }  #endif
124    //, { "IA64  ", XVID_CPU_IA64 }
125  //, { "TSC   ", XVID_CPU_TSC }  //, { "TSC   ", XVID_CPU_TSC }
126  , { 0, 0 } }    , { 0, 0 } };
127    
128  , cpu_short_list[] =  CPU  cpu_short_list[] =
129  { { "PLAINC", 0 }  { { "PLAINC", 0 }
130    #ifdef ARCH_IS_IA32
131  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
132  //, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }  //, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }
133  , { "IA64  ", XVID_CPU_IA64 }  #endif
134  , { 0, 0 } }  //, { "IA64  ", XVID_CPU_IA64 }
135      , { 0, 0 } };
136    
137  , cpu_short_list2[] =  CPU cpu_short_list2[] =
138  { { "PLAINC", 0 }  { { "PLAINC", 0 }
139    #ifdef ARCH_IS_IA32
140  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
141  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }
142    #endif
143  , { 0, 0 } };  , { 0, 0 } };
144    
145    
146  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
147  {  {
148    int xerr, cpu_type;          xvid_gbl_info_t xinfo;
   XVID_INIT_PARAM xinit;  
149    
150    cpu_type = check_cpu_features() & cpu->cpu;          /* Get the available CPU flags */
151    xinit.cpu_flags = cpu_type | XVID_CPU_FORCE;          memset(&xinfo, 0, sizeof(xinfo));
152    //    xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinfo.version = XVID_VERSION;
153    xerr = xvid_init(NULL, 0, &xinit, NULL);          xvid_global(NULL, XVID_GBL_INFO, &xinfo, NULL);
154    if (cpu->cpu>0 && (cpu_type==0 || xerr!=XVID_ERR_OK)) {  
155      printf( "%s - skipped...\n", cpu->name );          /* Are we trying to test a subset of the host CPU features */
156            if ((xinfo.cpu_flags & cpu->cpu) == cpu->cpu) {
157                    int xerr;
158                    xvid_gbl_init_t xinit;
159                    memset(&xinit, 0, sizeof(xinit));
160                    xinit.cpu_flags = cpu->cpu | XVID_CPU_FORCE;
161                    xinit.version = XVID_VERSION;
162                    xerr = xvid_global(NULL, XVID_GBL_INIT, &xinit, NULL);
163                    if (xerr==XVID_ERR_FAIL) {
164                            /* libxvidcore failed to init */
165      return 0;      return 0;
166    }    }
167            } else {
168                    /* The host CPU doesn't support some required feature for this test */
169                    return(0);
170            }
171    return 1;    return 1;
172  }  }
173    
174    #define CRC32_REMAINDER 0xCBF43926
175    #define CRC32_INITIAL 0xffffffff
176    
177    #define DO1(c, crc) ((crc) = crc32tab[((unsigned int)((crc)>>24) ^ (*c++)) & 0xff] ^ ((crc) << 8))
178    #define DO2(c, crc)  DO1(c, crc); DO1(c, crc);
179    #define DO4(c, crc)  DO2(c, crc); DO2(c, crc);
180    #define DO8(c, crc)  DO4(c, crc); DO4(c, crc);
181    
182    /******************************************************************************
183    * Precomputed AAL5 CRC32 lookup table
184    ******************************************************************************/
185    
186    static unsigned long crc32tab[256] = {
187    
188            0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
189            0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
190            0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
191            0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
192            0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
193            0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
194            0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
195            0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
196            0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
197            0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
198            0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
199            0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
200            0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
201            0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
202            0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
203            0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
204            0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
205            0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
206            0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
207            0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
208            0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
209            0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
210            0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
211            0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
212            0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
213            0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
214            0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
215            0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
216            0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
217            0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
218            0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
219            0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
220            0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
221            0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
222            0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
223            0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
224            0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
225            0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
226            0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
227            0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
228            0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
229            0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
230            0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
231            0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
232            0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
233            0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
234            0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
235            0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
236            0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
237            0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
238            0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
239            0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
240            0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
241            0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
242            0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
243            0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
244            0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
245            0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
246            0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
247            0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
248            0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
249            0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
250            0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
251            0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
252    
253    };
254    
255    uint32_t
256    calc_crc(uint8_t *mem, int len, uint32_t initial)
257    {
258    
259            register unsigned int crc;
260    
261            crc = initial;
262    
263            while( len >= 8) {
264                    DO8(mem, crc);
265                    len -= 8;
266            }
267    
268            while( len ) {
269                    DO1(mem, crc);
270                    len--;
271            }
272    
273            return(crc);
274    
275    }
276    
277  /*********************************************************************  /*********************************************************************
278   * test DCT   * test DCT
279   *********************************************************************/   *********************************************************************/
# Line 165  Line 286 
286    int tst;    int tst;
287    CPU *cpu;    CPU *cpu;
288    int i;    int i;
289    short iDst0[8*8], iDst[8*8], fDst[8*8];          DECLARE_ALIGNED_MATRIX(iDst0, 8, 8, short, 16);
290            DECLARE_ALIGNED_MATRIX(iDst,  8, 8, short, 16);
291            DECLARE_ALIGNED_MATRIX(fDst,  8, 8, short, 16);
292    double overhead;    double overhead;
293    
294    printf( "\n ===== test fdct/idct =====\n" );    printf( "\n ===== test fdct/idct =====\n" );
# Line 203  Line 326 
326        MSE += delta*delta;        MSE += delta*delta;
327      }      }
328      PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );      PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
329      printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f\n",                  printf( "%s -  %.3f usec       PSNR=%.3f  MSE=%.3f %s\n",
330        cpu->name, t, PSNR, MSE );                                  cpu->name, t, PSNR, MSE,
331      if (ABS(MSE)>=64) printf( "*** CRC ERROR! ***\n" );                                  (ABS(MSE)>=64)? "| ERROR" :"");
332    }    }
333  }  }
334    
# Line 219  Line 342 
342    int tst;    int tst;
343    CPU *cpu;    CPU *cpu;
344    int i;    int i;
345    uint8_t Cur[16*16], Ref1[16*16], Ref2[16*16];          DECLARE_ALIGNED_MATRIX(Cur,  16, 16, uint8_t, 16);
346            DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
347            DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
348    
349    printf( "\n ======  test SAD ======\n" );    printf( "\n ======  test SAD ======\n" );
350    for(i=0; i<16*16;++i) {    for(i=0; i<16*16;++i) {
# Line 240  Line 365 
365      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);      for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
366      emms();      emms();
367      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
368      printf( "%s - sad8    %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad8    %.3f usec       sad=%d %s\n",
369      if (s!=3776) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
370                               (s!=3776)?"| ERROR": "" );
371    
372      t = gettime_usec();      t = gettime_usec();
373      emms();      emms();
374      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);
375      emms();      emms();
376      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
377      printf( "%s - sad16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf("%s - sad16   %.3f usec       sad=%d %s\n",
378      if (s!=27214) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
379                               (s!=27214)?"| ERROR": "" );
380    
381      t = gettime_usec();      t = gettime_usec();
382      emms();      emms();
383      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);
384      emms();      emms();
385      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
386      printf( "%s - sad16bi %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - sad16bi %.3f usec       sad=%d %s\n",
387      if (s!=26274) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
388                                    (s!=26274)?"| ERROR": "" );
389    
390      t = gettime_usec();      t = gettime_usec();
391      emms();      emms();
392      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);      for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
393      emms();      emms();
394      t = (gettime_usec() - t) / nb_tests;      t = (gettime_usec() - t) / nb_tests;
395      printf( "%s - dev16   %.3f usec       sad=%d\n", cpu->name, t, s );                  printf( "%s - dev16   %.3f usec       sad=%d %s\n",
396      if (s!=3344) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
397                                    (s!=3344)?"| ERROR": "" );
398    
399      printf( " --- \n" );      printf( " --- \n" );
400    }    }
# Line 283  Line 412 
412  #define LEAVE \  #define LEAVE \
413      emms();                             \      emms();                             \
414      t = (gettime_usec() - t) / nb_tests;  \      t = (gettime_usec() - t) / nb_tests;  \
415      iCrc = 0;                           \          iCrc = calc_crc((uint8_t*)Dst, sizeof(Dst), CRC32_INITIAL)
     for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }  
416    
417  #define TEST_MB(FUNC, R)                \  #define TEST_MB(FUNC, R)                \
418      ENTER                               \      ENTER                               \
# Line 302  Line 430 
430    const int nb_tests = 2000*speed_ref;    const int nb_tests = 2000*speed_ref;
431    CPU *cpu;    CPU *cpu;
432    const uint8_t Src0[16*9] = {    const uint8_t Src0[16*9] = {
433          // try to have every possible combinaison of rounding...                  /* try to have every possible combinaison of rounding... */
434        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,
435      , 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,
436      , 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,
437      , 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,
438      , 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,
439      , 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,
440      , 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,
441      , 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,
442      , 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
443    };    };
444    uint8_t Dst[16*8] = {0};    uint8_t Dst[16*8] = {0};
445    
# Line 326  Line 454 
454        continue;        continue;
455    
456      TEST_MB(interpolate8x8_halfpel_h, 0);      TEST_MB(interpolate8x8_halfpel_h, 0);
457      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",
458      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
459                               (iCrc!=0x115381ba)?"| ERROR": "" );
460    
461      TEST_MB(interpolate8x8_halfpel_h, 1);      TEST_MB(interpolate8x8_halfpel_h, 1);
462      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
463      if (iCrc!=8100) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
464                               (iCrc!=0x2b1f528f)?"| ERROR": "" );
465    
466    
467      TEST_MB(interpolate8x8_halfpel_v, 0);      TEST_MB(interpolate8x8_halfpel_v, 0);
468      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",
469      if (iCrc!=8108) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
470                               (iCrc!=0x423cdcc7)?"| ERROR": "" );
471    
472      TEST_MB(interpolate8x8_halfpel_v, 1);      TEST_MB(interpolate8x8_halfpel_v, 1);
473      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
474      if (iCrc!=8105) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
475                               (iCrc!=0x42202efe)?"| ERROR": "" );
476    
477    
478      TEST_MB(interpolate8x8_halfpel_hv, 0);      TEST_MB(interpolate8x8_halfpel_hv, 0);
479      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",
480      if (iCrc!=8112) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
481                               (iCrc!=0xd198d387)?"| ERROR": "" );
482    
483      TEST_MB(interpolate8x8_halfpel_hv, 1);      TEST_MB(interpolate8x8_halfpel_hv, 1);
484      printf( "%s -           round1 %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s -           round1 %.3f usec       crc32=0x%08x %s\n",
485      if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
486                               (iCrc!=0x9ecfd921)?"| ERROR": "" );
487    
488    
489         // this is a new function, as of 06.06.2002                  /* this is a new function, as of 06.06.2002 */
490  #if 0  #if 0
491      TEST_MB2(interpolate8x8_avrg);      TEST_MB2(interpolate8x8_avrg);
492      printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );                  printf("%s - interpolate8x8_c %.3f usec       crc32=0x%08x %s\n",
493      if (iCrc!=8107) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, iCrc,
494                               (iCrc!=8107)?"| ERROR": "" );
495  #endif  #endif
496    
497      printf( " --- \n" );      printf( " --- \n" );
# Line 392  Line 527 
527      }                                         \      }                                         \
528      emms();                                   \      emms();                                   \
529      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
530      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]^i; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
531    
532  #define TEST_TRANSFER(FUNC, DST, SRC)         \  #define TEST_TRANSFER(FUNC, DST, SRC)         \
533      TEST_TRANSFER_BEGIN(DST);                 \      TEST_TRANSFER_BEGIN(DST);                 \
# Line 418  Line 553 
553      }                                         \      }                                         \
554      emms();                                   \      emms();                                   \
555      t = (gettime_usec()-t -overhead) / nb_tests;\      t = (gettime_usec()-t -overhead) / nb_tests;\
556      s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]; }  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)
557    
558  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \  #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
559      TEST_TRANSFER2_BEGIN(DST,SRC);            \      TEST_TRANSFER2_BEGIN(DST,SRC);            \
# Line 440  Line 575 
575    
576    printf( "\n ===  test transfer ===\n" );    printf( "\n ===  test transfer ===\n" );
577    
578    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
579    {    {
580      double t, overhead;      double t, overhead;
581      int tst, s;      int tst, s;
# Line 449  Line 584 
584        continue;        continue;
585    
586      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);      TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
587      printf( "%s - 8to16     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16     %.3f usec       crc32=0x%08x %s\n",
588      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
589                               (s!=0x115814bb)?"| ERROR": "");
590    
591      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);      TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
592      printf( "%s - 16to8     %.3f usec       crc=%d\n", cpu->name, t, s );                  printf( "%s - 16to8     %.3f usec       crc32=0x%08x %s\n",
593      if (s!=28288) printf( "*** CRC ERROR! ***\n" );                                  cpu->name, t, s,
594                                    (s!=0xee7ccbb4)?"| ERROR": "");
595    
596      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);      TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
597      printf( "%s - 8to8      %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
598      if (s!=20352) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
599                               (s!=0xd37b3295)?"| ERROR": "");
600    
601      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);      TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
602      printf( "%s - 16to8add  %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 16to8add  %.3f usec       crc32=0x%08x %s\n",
603      if (s!=25536) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
604                               (s!=0xdd817bf4)?"| ERROR": "" );
605    
606      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);      TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
607      printf( "%s - 8to16sub  %.3f usec       crc1=%d ", cpu->name, t, s );                  {
608      if (s!=28064) printf( "*** CRC ERROR! ***\n" );                          int s1, s2;
609      s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }                          s1 = calc_crc((uint8_t*)Dst16, sizeof(Dst16), CRC32_INITIAL);
610      printf( "crc2=%d\n", s);                          s2 = calc_crc((uint8_t*)Src8, sizeof(Src8), CRC32_INITIAL);
611      if (s!=16256) printf( "*** CRC ERROR! ***\n" );                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
612  #if 1                                     cpu->name, t, s1, s2,
613                                       (s1!=0xa1e07163)?"| ERROR1": "",
614                                       (s2!=0xd86c5d23)?"| ERROR2": "" );
615                    }
616    
617      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);      TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
618      printf( "%s - 8to16sub2 %.3f usec       crc=%d\n", cpu->name, t, s );                  printf("%s - 8to16sub2 %.3f usec       crc32=0x%08x %s\n",
619      if (s!=20384) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
620  //    for(i=0; i<64; ++i) printf( "[%d]", Dst16[i]);                             (s!=0x99b6c4c7)?"| ERROR": "" );
621  //    printf("\n");  
 #endif  
622      printf( " --- \n" );      printf( " --- \n" );
623    }    }
624  }  }
# Line 487  Line 629 
629    
630  #define TEST_QUANT(FUNC, DST, SRC)              \  #define TEST_QUANT(FUNC, DST, SRC)              \
631      t = gettime_usec();                         \      t = gettime_usec();                         \
632      for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
633        for(i=0; i<8*8; ++i) Quant[i] = qm;       \        for(i=0; i<8*8; ++i) Quant[i] = qm;       \
634        set_inter_matrix( Quant );                \    set_inter_matrix( mpeg_quant_matrices, Quant );                \
635        emms();                                   \        emms();                                   \
636        for(q=1; q<=max_Q; ++q) {                 \        for(q=1; q<=max_Q; ++q) {                 \
637          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
638            (FUNC)((DST), (SRC), q);              \            (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
639          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
640        }                                         \        }                                         \
641        emms();                                   \        emms();                                   \
642      }                                           \      }                                           \
643      t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
     s = (s&0xffff)^(s>>16)  
644    
645  #define TEST_QUANT2(FUNC, DST, SRC)             \  #define TEST_QUANT2(FUNC, DST, SRC)             \
646      t = gettime_usec();                         \      t = gettime_usec();                         \
647      for(s=0,qm=1; qm<=255; ++qm) {              \  for(s=CRC32_INITIAL,qm=1; qm<=255; ++qm) {              \
648        for(i=0; i<8*8; ++i) Quant[i] = qm;       \        for(i=0; i<8*8; ++i) Quant[i] = qm;       \
649        set_intra_matrix( Quant );                \    set_intra_matrix( mpeg_quant_matrices, Quant );                \
650        emms();                                   \        emms();                                   \
651        for(q=1; q<=max_Q; ++q) {                 \        for(q=1; q<=max_Q; ++q) {                 \
652          for(tst=0; tst<nb_tests; ++tst)         \          for(tst=0; tst<nb_tests; ++tst)         \
653            (FUNC)((DST), (SRC), q, q);           \            (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
654          for(i=0; i<64; ++i) s+=(DST)[i]^i^qm;   \          s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
655        }                                         \        }                                         \
656        emms();                                   \        emms();                                   \
657      }                                           \      }                                           \
658      t = (gettime_usec()-t-overhead)/nb_tests/qm;\  t = (gettime_usec()-t-overhead)/nb_tests/qm
659      s = (s&0xffff)^(s>>16)  
660    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
661    { int i,q,s;\
662            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
663      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
664      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
665      for(q=1;q<=max_Q;q++)          \
666        for(s=-RANGE;s<RANGE;s++) { \
667          for(i=0;i<64;i++) Src[i]=s; \
668          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
669          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
670          for(i=0;i<64;i++)     \
671            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]);  \
672        }      \
673    }
674    
675    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
676    { int i,q,s;  \
677            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
678      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
679      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
680      for(q=1;q<=max_Q;q++)  \
681        for(s=-RANGE;s<RANGE;s++) {   \
682          for(i=0;i<64;i++) Src[i]=s; \
683          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
684          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
685          emms();           \
686          for(i=0;i<64;i++) \
687            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]); \
688        } \
689    }
690    
691  void test_quant()  void test_quant()
692  {  {
693    const int nb_tests = 1*speed_ref;    const int nb_tests = 1*speed_ref;
694    const int max_Q = 31;    const int max_Q = 31;
695            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
696    
697    int i, qm;    int i, qm;
698    CPU *cpu;    CPU *cpu;
699    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
700            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
701            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
702    uint8_t Quant[8*8];    uint8_t Quant[8*8];
703    
704    printf( "\n =====  test quant =====\n" );    printf( "\n =====  test quant =====\n" );
705    
706      // we deliberately enfringe the norm's specified range [-127,127],  /* we deliberately enfringe the norm's specified range [-127,127], */
707      // to test the robustness of the iquant module  /* to test the robustness of the iquant module */
708    for(i=0; i<64; ++i) {    for(i=0; i<64; ++i) {
709      Src[i] = 1 + (i-32) * (i&6);      Src[i] = 1 + (i-32) * (i&6);
710      Dst[i] = 0;      Dst[i] = 0;
711    }    }
712    
713    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
714    {    {
715      double t, overhead;      double t, overhead;
716      int tst, q;      int tst, q;
# Line 544  Line 719 
719      if (!init_cpu(cpu))      if (!init_cpu(cpu))
720        continue;        continue;
721    
722                    // exhaustive tests to compare against the (ref) C-version
723                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
724                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
725                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
726                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
727    
728      overhead = -gettime_usec();      overhead = -gettime_usec();
729      for(s=0,qm=1; qm<=255; ++qm) {      for(s=0,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_inter_matrix( Quant );                          set_inter_matrix(mpeg_quant_matrices, Quant );
732        for(q=1; q<=max_Q; ++q)        for(q=1; q<=max_Q; ++q)
733          for(i=0; i<64; ++i) s+=Dst[i]^i^qm;          for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
734      }      }
735      overhead += gettime_usec();      overhead += gettime_usec();
736    
737  #if 1                  TEST_QUANT2(quant_mpeg_intra, Dst, Src);
738      TEST_QUANT2(quant4_intra, Dst, Src);                  printf("%s -   quant_mpeg_intra %.3f usec       crc32=0x%08x %s\n",
739      printf( "%s -   quant4_intra %.3f usec       crc=%d\n", cpu->name, t, s );                             cpu->name, t, s,
740      if (s!=29809) printf( "*** CRC ERROR! ***\n" );                             (s!=0xfd6a21a4)? "| ERROR": "");
741    
742      TEST_QUANT(quant4_inter, Dst, Src);                  TEST_QUANT(quant_mpeg_inter, Dst, Src);
743      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",
744      if (s!=12574) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
745  #endif                             (s!=0xf6de7757)?"| ERROR": "");
746  #if 1  
747      TEST_QUANT2(dequant4_intra, Dst, Src);                  TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
748      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",
749      if (s!=24052) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, s,
750                               (s!=0x2def7bc7)?"| ERROR": "");
751      TEST_QUANT(dequant4_inter, Dst, Src);  
752      printf( "%s - dequant4_inter %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT(dequant_mpeg_inter, Dst, Src);
753      if (s!=63847) printf( "*** CRC ERROR! ***\n" );                  printf("%s - dequant_mpeg_inter %.3f usec       crc32=0x%08x %s\n",
754  #endif                             cpu->name, t, s,
755  #if 1                             (s!=0xd878c722)?"| ERROR": "");
756      TEST_QUANT2(quant_intra, Dst, Src);  
757      printf( "%s -    quant_intra %.3f usec       crc=%d\n", cpu->name, t, s );                  TEST_QUANT2(quant_h263_intra, Dst, Src);
758      if (s!=25662) printf( "*** CRC ERROR! ***\n" );                  printf("%s -   quant_h263_intra %.3f usec       crc32=0x%08x %s\n",
759                               cpu->name, t, s,
760      TEST_QUANT(quant_inter, Dst, Src);                             (s!=0x2eba9d43)?"| ERROR": "");
761      printf( "%s -    quant_inter %.3f usec       crc=%d\n", cpu->name, t, s );  
762      if (s!=23972) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT(quant_h263_inter, Dst, Src);
763  #endif                  printf("%s -   quant_h263_inter %.3f usec       crc32=0x%08x %s\n",
764  #if 1                             cpu->name, t, s,
765      TEST_QUANT2(dequant_intra, Dst, Src);                             (s!=0xbd315a7e)?"| ERROR": "");
766      printf( "%s -  dequant_intra %.3f usec       crc=%d\n", cpu->name, t, s );  
767      if (s!=49900) printf( "*** CRC ERROR! ***\n" );                  TEST_QUANT2(dequant_h263_intra, Dst, Src);
768                    printf("%s - dequant_h263_intra %.3f usec       crc32=0x%08x %s\n",
769      TEST_QUANT(dequant_inter, Dst, Src);                             cpu->name, t, s,
770      printf( "%s -  dequant_inter %.3f usec       crc=%d\n", cpu->name, t, s );                             (s!=0x9841212a)?"| ERROR": "");
771      if (s!=48899) printf( "*** CRC ERROR! ***\n" );  
772  #endif                  TEST_QUANT(dequant_h263_inter, Dst, Src);
773                    printf("%s - dequant_h263_inter %.3f usec       crc32=0x%08x %s\n",
774                               cpu->name, t, s,
775                               (s!=0xe7df8fba)?"| ERROR": "");
776    
777      printf( " --- \n" );      printf( " --- \n" );
778    }    }
779  }  }
# Line 611  Line 796 
796    const int nb_tests = 10000*speed_ref;    const int nb_tests = 10000*speed_ref;
797    int i;    int i;
798    CPU *cpu;    CPU *cpu;
799    int16_t  Src1[6*64], Src2[6*64], Src3[6*64], Src4[6*64];          DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
800            DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
801            DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
802            DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
803    
804    printf( "\n =====  test cbp =====\n" );    printf( "\n =====  test cbp =====\n" );
805    
806    for(i=0; i<6*64; ++i) {    for(i=0; i<6*64; ++i) {
807      Src1[i] = (i*i*3/8192)&(i/64)&1;  // 'random'                  Src1[i] = (i*i*3/8192)&(i/64)&1;  /* 'random' */
808      Src2[i] = (i<3*64);               // half-full                  Src2[i] = (i<3*64);               /* half-full */
809      Src3[i] = ((i+32)>3*64);      Src3[i] = ((i+32)>3*64);
810      Src4[i] = (i==(3*64+2) || i==(5*64+9));      Src4[i] = (i==(3*64+2) || i==(5*64+9));
811    }    }
812    
813    for(cpu = cpu_short_list2; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
814    {    {
815      double t;      double t;
816      int tst, cbp;      int tst, cbp;
# Line 631  Line 819 
819        continue;        continue;
820    
821      TEST_CBP(calc_cbp, Src1);      TEST_CBP(calc_cbp, Src1);
822      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\n",
823      if (cbp!=0x15) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
824      TEST_CBP(calc_cbp, Src2);      TEST_CBP(calc_cbp, Src2);
825      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\n",
826      if (cbp!=0x38) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
827      TEST_CBP(calc_cbp, Src3);      TEST_CBP(calc_cbp, Src3);
828      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\n",
829      if (cbp!=0x0f) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
830      TEST_CBP(calc_cbp, Src4);      TEST_CBP(calc_cbp, Src4);
831      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\n",
832      if (cbp!=0x05) printf( "*** CRC ERROR! ***\n" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
833      printf( " --- \n" );      printf( " --- \n" );
834    }    }
835  }  }
# Line 772  Line 960 
960    }    }
961  }  }
962    
963  //////////////////////////////////////////////////////////  ///* ////////////////////////////////////////////////////// */
964  /* Pseudo-random generator specified by IEEE 1180 */  /* Pseudo-random generator specified by IEEE 1180 */
965    
966  static long ieee_seed = 1;  static long ieee_seed = 1;
# Line 859  Line 1047 
1047    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 };
1048    int Loops = 10000;    int Loops = 10000;
1049    int i, m, n;    int i, m, n;
1050    short Blk0[64];     // reference          DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
1051    short Blk[64], iBlk[64];          DECLARE_ALIGNED_MATRIX(Blk,  8, 8, short, 16);
1052    short Ref_FDCT[64];          DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
1053    short Ref_IDCT[64];          DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
1054            DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
1055    
1056    STATS_8x8 FStats; // forward dct stats          STATS_8x8 FStats; /* forward dct stats */
1057    STATS_8x8 IStats; // inverse dct stats          STATS_8x8 IStats; /* inverse dct stats */
1058    
1059    CPU *cpu;    CPU *cpu;
1060    
# Line 888  Line 1077 
1077        for(i=0; i<64; ++i)        for(i=0; i<64; ++i)
1078          Blk0[i] = (short)ieee_rand(Min,Max) * Sign;          Blk0[i] = (short)ieee_rand(Min,Max) * Sign;
1079    
1080          // hmm, I'm not quite sure this is exactly                          /* hmm, I'm not quite sure this is exactly */
1081          // the tests described in the norm. check...                          /* the tests described in the norm. check... */
1082    
1083        memcpy(Ref_FDCT, Blk0, 64*sizeof(short));        memcpy(Ref_FDCT, Blk0, 64*sizeof(short));
1084        ref_fdct(Ref_FDCT);        ref_fdct(Ref_FDCT);
# Line 916  Line 1105 
1105    
1106      printf( "\n  -- FDCT report --\n" );      printf( "\n  -- FDCT report --\n" );
1107  //    print_stats(&FStats);  //    print_stats(&FStats);
1108      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 */
1109    
1110      for(i=0; i<64; i++) Blk[i] = 0;      for(i=0; i<64; i++) Blk[i] = 0;
1111      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
# Line 938  Line 1127 
1127    
1128  void test_dct_saturation(int Min, int Max)  void test_dct_saturation(int Min, int Max)
1129  {  {
1130      // test behaviour on input range fringe  /* test behaviour on input range fringe */
1131    
1132    int i, n, p;    int i, n, p;
1133    CPU *cpu;    CPU *cpu;
1134  //  const short IDCT_MAX =  2047;  // 12bits input  //  const short IDCT_MAX =  2047;  /* 12bits input */
1135  //  const short IDCT_MIN = -2048;  //  const short IDCT_MIN = -2048;
1136  //  const short IDCT_OUT =   256;  // 9bits ouput  //  const short IDCT_OUT =   256;  /* 9bits ouput */
1137    const int Partitions = 4;    const int Partitions = 4;
1138    const int Loops = 10000 / Partitions;    const int Loops = 10000 / Partitions;
1139    
# Line 961  Line 1150 
1150      printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",      printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",
1151        cpu->name, Min, Max );        cpu->name, Min, Max );
1152    
1153                // FDCT tests //                  /* FDCT tests // */
1154    
1155      init_stats(&Stats);      init_stats(&Stats);
1156    
1157        // test each computation channels separately                  /* test each computation channels separately */
1158      for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;      for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;
1159      ref_fdct(Blk0);      ref_fdct(Blk0);
1160      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
# Line 976  Line 1165 
1165      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
1166      store_stats(&Stats, Blk, Blk0);      store_stats(&Stats, Blk, Blk0);
1167    
1168        // randomly saturated inputs                  /* randomly saturated inputs */
1169      for(p=0; p<Partitions; ++p)      for(p=0; p<Partitions; ++p)
1170      {      {
1171        for(n=0; n<Loops; ++n)        for(n=0; n<Loops; ++n)
# Line 992  Line 1181 
1181      report_stats(&Stats, 0);      report_stats(&Stats, 0);
1182    
1183    
1184                // IDCT tests //                  /* IDCT tests // */
1185  #if 0  #if 0
1186        // no finished yet                  /* no finished yet */
1187    
1188      init_stats(&Stats);      init_stats(&Stats);
1189    
1190      // test each computation channel separately  /* test each computation channel separately */
1191      for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 0;      for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 0;
1192      ref_idct(Blk0);      ref_idct(Blk0);
1193      emms(); idct(Blk); emms();      emms(); idct(Blk); emms();
# Line 1011  Line 1200 
1200      for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }      for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1201      store_stats(&Stats, Blk, Blk0);      store_stats(&Stats, Blk, Blk0);
1202    
1203        // randomly saturated inputs                  /* randomly saturated inputs */
1204      for(p=0; p<Partitions; ++p)      for(p=0; p<Partitions; ++p)
1205      {      {
1206        for(n=0; n<Loops; ++n)        for(n=0; n<Loops; ++n)
# Line 1041  Line 1230 
1230    FILE *f = 0;    FILE *f = 0;
1231    void *dechandle = 0;    void *dechandle = 0;
1232    int xerr;    int xerr;
1233          XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
1234          XVID_DEC_PARAM xparam;          xvid_dec_create_t xparam;
1235          XVID_DEC_FRAME xframe;          xvid_dec_frame_t xframe;
1236          double t = 0.;          double t = 0.;
1237          int nb = 0;          int nb = 0;
1238    uint8_t *buf = 0;    uint8_t *buf = 0;
# Line 1051  Line 1240 
1240    int buf_size, pos;    int buf_size, pos;
1241    uint32_t chksum = 0;    uint32_t chksum = 0;
1242    
1243            memset(&xinit, 0, sizeof(xinit));
1244          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;
1245          xvid_init(NULL, 0, &xinit, NULL);          xinit.version = XVID_VERSION;
1246          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          xvid_global(NULL, 0, &xinit, NULL);
   
1247    
1248            memset(&xparam, 0, sizeof(xparam));
1249          xparam.width = width;          xparam.width = width;
1250          xparam.height = height;          xparam.height = height;
1251            xparam.version = XVID_VERSION;
1252          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1253          if (xerr!=XVID_ERR_OK) {          if (xerr==XVID_ERR_FAIL) {
1254            printf("can't init decoder (err=%d)\n", xerr);            printf("can't init decoder (err=%d)\n", xerr);
1255            return;            return;
1256          }          }
# Line 1080  Line 1271 
1271    }    }
1272    else printf( "Input size: %d\n", buf_size);    else printf( "Input size: %d\n", buf_size);
1273    
1274    buf = malloc(buf_size); // should be enuf'          buf = malloc(buf_size); /* should be enuf' */
1275    rgb_out = calloc(4, width*height);  // <-room for _RGB24          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */
1276    if (buf==0 || rgb_out==0) {    if (buf==0 || rgb_out==0) {
1277      printf( "malloc failed!\n" );      printf( "malloc failed!\n" );
1278      goto End;      goto End;
# Line 1096  Line 1287 
1287    pos = 0;    pos = 0;
1288    t = -gettime_usec();    t = -gettime_usec();
1289    while(1) {    while(1) {
1290                    memset(&xframe, 0, sizeof(xframe));
1291                    xframe.version = XVID_VERSION;
1292      xframe.bitstream = buf + pos;      xframe.bitstream = buf + pos;
1293      xframe.length = buf_size - pos;      xframe.length = buf_size - pos;
1294      xframe.image = rgb_out;                  xframe.output.plane[0] = rgb_out;
1295      xframe.stride = width;                  xframe.output.stride[0] = width;
1296      xframe.colorspace = XVID_CSP_RGB24;                  xframe.output.csp = XVID_CSP_BGR;
1297      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1298      nb++;      nb++;
1299      pos += xframe.length;      pos += xframe.length;
# Line 1111  Line 1304 
1304      }      }
1305      if (pos==buf_size)      if (pos==buf_size)
1306        break;        break;
1307      if (xerr!=XVID_ERR_OK) {                  if (xerr==XVID_ERR_FAIL) {
1308            printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);            printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1309            break;            break;
1310          }          }
# Line 1127  Line 1320 
1320    if (buf!=0) free(buf);    if (buf!=0) free(buf);
1321    if (dechandle!=0) {    if (dechandle!=0) {
1322      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1323      if (xerr!=XVID_ERR_OK)                  if (xerr==XVID_ERR_FAIL)
1324              printf("destroy-decoder failed (err=%d)!\n", xerr);              printf("destroy-decoder failed (err=%d)!\n", xerr);
1325    }    }
1326    if (f!=0) fclose(f);    if (f!=0) fclose(f);
# Line 1140  Line 1333 
1333  void test_bugs1()  void test_bugs1()
1334  {  {
1335    CPU *cpu;    CPU *cpu;
1336            uint16_t mpeg_quant_matrices[64*8];
1337    
1338    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );    printf( "\n =====  (de)quant4_intra saturation bug? =====\n" );
1339    
1340    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1341    {    {
1342      int i;      int i;
1343      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 1152  Line 1346 
1346        continue;        continue;
1347    
1348      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1349      set_intra_matrix( get_default_intra_matrix() );                  set_intra_matrix( mpeg_quant_matrices, get_default_intra_matrix() );
1350      dequant4_intra(Dst, Src, 31, 5);                  dequant_mpeg_intra(Dst, Src, 31, 5, mpeg_quant_matrices);
1351      printf( "dequant4_intra with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_intra with CPU=%s:  ", cpu->name);
1352      printf( "  Out[]= " );      printf( "  Out[]= " );
1353      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1354      printf( "\n" );      printf( "\n" );
# Line 1162  Line 1356 
1356    
1357    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );    printf( "\n =====  (de)quant4_inter saturation bug? =====\n" );
1358    
1359    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1360    {    {
1361      int i;      int i;
1362      int16_t  Src[8*8], Dst[8*8];      int16_t  Src[8*8], Dst[8*8];
# Line 1171  Line 1365 
1365        continue;        continue;
1366    
1367      for(i=0; i<64; ++i) Src[i] = i-32;      for(i=0; i<64; ++i) Src[i] = i-32;
1368      set_inter_matrix( get_default_inter_matrix() );                  set_inter_matrix( mpeg_quant_matrices, get_default_inter_matrix() );
1369      dequant4_inter(Dst, Src, 31);                  dequant_mpeg_inter(Dst, Src, 31, mpeg_quant_matrices);
1370      printf( "dequant4_inter with CPU=%s:  ", cpu->name);                  printf( "dequant_mpeg_inter with CPU=%s:  ", cpu->name);
1371      printf( "  Out[]= " );      printf( "  Out[]= " );
1372      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);      for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1373      printf( "\n" );      printf( "\n" );
# Line 1183  Line 1377 
1377  void test_dct_precision_diffs()  void test_dct_precision_diffs()
1378  {  {
1379    CPU *cpu;    CPU *cpu;
1380    short Blk[8*8], Blk0[8*8];          DECLARE_ALIGNED_MATRIX(Blk, 8, 8, int16_t, 16);
1381            DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, int16_t, 16);
1382    
1383    printf( "\n =====  fdct/idct precision diffs =====\n" );    printf( "\n =====  fdct/idct precision diffs =====\n" );
1384    
1385    for(cpu = cpu_short_list; cpu->name!=0; ++cpu)          for(cpu = cpu_list; cpu->name!=0; ++cpu)
1386    {    {
1387      int i;      int i;
1388    
# Line 1216  Line 1411 
1411    const int max_Q = 31;    const int max_Q = 31;
1412    int i, n, qm, q;    int i, n, qm, q;
1413    CPU *cpu;    CPU *cpu;
1414    int16_t  Src[8*8], Dst[8*8];          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
1415            DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
1416    uint8_t Quant[8*8];    uint8_t Quant[8*8];
1417    CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };    CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX   ", XVID_CPU_MMX }, {0,0} };
1418    uint16_t Crcs_Inter[2][32];    uint16_t Crcs_Inter[2][32];
1419    uint16_t Crcs_Intra[2][32];    uint16_t Crcs_Intra[2][32];
1420            DECLARE_ALIGNED_MATRIX(mpeg_quant_matrices, 8, 64, uint16_t, 16);
1421    
1422    printf( "\n =====  test MPEG4-quantize bug =====\n" );    printf( "\n =====  test MPEG4-quantize bug =====\n" );
1423    
1424    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 1229  Line 1427 
1427    for(qm=1; qm<=255; ++qm)    for(qm=1; qm<=255; ++qm)
1428    {    {
1429      for(i=0; i<8*8; ++i) Quant[i] = qm;      for(i=0; i<8*8; ++i) Quant[i] = qm;
1430      set_inter_matrix( Quant );                  set_inter_matrix( mpeg_quant_matrices, Quant );
1431    
1432      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1433      {      {
# Line 1240  Line 1438 
1438    
1439        for(q=1; q<=max_Q; ++q) {        for(q=1; q<=max_Q; ++q) {
1440          emms();          emms();
1441          quant4_inter( Dst, Src, q );                                  quant_mpeg_inter( Dst, Src, q, mpeg_quant_matrices );
1442          emms();          emms();
1443          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;
1444          Crcs_Inter[n][q] = s;          Crcs_Inter[n][q] = s;
# Line 1259  Line 1457 
1457    for(qm=1; qm<=255; ++qm)    for(qm=1; qm<=255; ++qm)
1458    {    {
1459      for(i=0; i<8*8; ++i) Quant[i] = qm;      for(i=0; i<8*8; ++i) Quant[i] = qm;
1460      set_intra_matrix( Quant );                  set_intra_matrix( mpeg_quant_matrices, Quant );
1461    
1462      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)      for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1463      {      {
# Line 1270  Line 1468 
1468    
1469        for(q=1; q<=max_Q; ++q) {        for(q=1; q<=max_Q; ++q) {
1470          emms();          emms();
1471          quant4_intra( Dst, Src, q, q);                                  quant_mpeg_intra( Dst, Src, q, q, mpeg_quant_matrices);
1472          emms();          emms();
1473          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;
1474          Crcs_Intra[n][q] = s;          Crcs_Intra[n][q] = s;
# Line 1303  Line 1501 
1501    
1502    if (what==7) {    if (what==7) {
1503      test_IEEE1180_compliance(-256, 255, 1);      test_IEEE1180_compliance(-256, 255, 1);
 #if 0  
1504      test_IEEE1180_compliance(-256, 255,-1);      test_IEEE1180_compliance(-256, 255,-1);
1505      test_IEEE1180_compliance(  -5,   5, 1);      test_IEEE1180_compliance(  -5,   5, 1);
1506      test_IEEE1180_compliance(  -5,   5,-1);      test_IEEE1180_compliance(  -5,   5,-1);
1507      test_IEEE1180_compliance(-300, 300, 1);      test_IEEE1180_compliance(-300, 300, 1);
1508      test_IEEE1180_compliance(-300, 300,-1);      test_IEEE1180_compliance(-300, 300,-1);
 #endif  
1509    }    }
1510    if (what==8) test_dct_saturation(-256, 255);    if (what==8) test_dct_saturation(-256, 255);
1511    
# Line 1331  Line 1527 
1527    if (what==-2)    if (what==-2)
1528      test_quant_bug();      test_quant_bug();
1529    
1530            if (what >= 0 && what <= 6) {
1531                    printf("\n\n"
1532                               "NB: If a function isn't optimised for a specific set of intructions,\n"
1533                               "    a C function is used instead. So don't panic if some functions\n"
1534                               "    may appear to be slow.\n");
1535            }
1536    
1537    #ifdef ARCH_IS_IA32
1538            if (what == 0 || what == 5) {
1539                    printf("\n"
1540                               "NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)\n"
1541                               "    for 1 or 2 coefficients a block. This is mainly caused by the fact the unit\n"
1542                               "    test goes far behind the usual limits of real encoding. Please do not report\n"
1543                               "    this error to the developers.\n");
1544            }
1545    #endif
1546    
1547    return 0;    return 0;
1548  }  }
1549    
1550  /*********************************************************************  /*********************************************************************
1551   * 'Reference' output (except for timing) on a PIII 1.13Ghz/linux   * 'Reference' output (except for timing) on an Athlon XP 2200+
1552   *********************************************************************/   *********************************************************************/
1553    
1554      /* as of 07/01/2002, there's a problem with mpeg4-quantization */  /* as of 2002-01-07, there's a problem with MMX mpeg4-quantization */
1555  /*  /* as of 2003-11-30, the problem is still here */
1556    
1557    /*********************************************************************
1558    
1559    
1560   ===== test fdct/idct =====   ===== test fdct/idct =====
1561  PLAINC -  3.312 usec       PSNR=13.291  MSE=3.000  PLAINC -  2.867 usec       PSNR=13.291  MSE=3.000
1562  MMX    -  0.591 usec       PSNR=13.291  MSE=3.000  MMX    -  -0.211 usec       PSNR=9.611  MSE=7.000
1563  MMXEXT -  0.577 usec       PSNR=13.291  MSE=3.000  MMXEXT -  -0.256 usec       PSNR=9.611  MSE=7.000
1564  SSE2   -  0.588 usec       PSNR=13.291  MSE=3.000  3DNOW  -  2.855 usec       PSNR=13.291  MSE=3.000
1565  3DNOW  - skipped...  3DNOWE -  1.429 usec       PSNR=13.291  MSE=3.000
 3DNOWE - skipped...  
1566    
1567   ===  test block motion ===   ===  test block motion ===
1568  PLAINC - interp- h-round0 0.911 usec       iCrc=8107  PLAINC - interp- h-round0 0.538 usec       crc32=0x115381ba
1569  PLAINC -           round1 0.863 usec       iCrc=8100  PLAINC -           round1 0.527 usec       crc32=0x2b1f528f
1570  PLAINC - interp- v-round0 0.860 usec       iCrc=8108  PLAINC - interp- v-round0 0.554 usec       crc32=0x423cdcc7
1571  PLAINC -           round1 0.857 usec       iCrc=8105  PLAINC -           round1 0.551 usec       crc32=0x42202efe
1572  PLAINC - interp-hv-round0 2.103 usec       iCrc=8112  PLAINC - interp-hv-round0 1.041 usec       crc32=0xd198d387
1573  PLAINC -           round1 2.050 usec       iCrc=8103  PLAINC -           round1 1.038 usec       crc32=0x9ecfd921
1574   ---   ---
1575  MMX    - interp- h-round0 0.105 usec       iCrc=8107  MMX    - interp- h-round0 0.051 usec       crc32=0x115381ba
1576  MMX    -           round1 0.106 usec       iCrc=8100  MMX    -           round1 0.053 usec       crc32=0x2b1f528f
1577  MMX    - interp- v-round0 0.106 usec       iCrc=8108  MMX    - interp- v-round0 0.048 usec       crc32=0x423cdcc7
1578  MMX    -           round1 0.106 usec       iCrc=8105  MMX    -           round1 0.048 usec       crc32=0x42202efe
1579  MMX    - interp-hv-round0 0.145 usec       iCrc=8112  MMX    - interp-hv-round0 0.074 usec       crc32=0xd198d387
1580  MMX    -           round1 0.145 usec       iCrc=8103  MMX    -           round1 0.073 usec       crc32=0x9ecfd921
1581   ---   ---
1582  MMXEXT - interp- h-round0 0.028 usec       iCrc=8107  MMXEXT - interp- h-round0 0.020 usec       crc32=0x115381ba
1583  MMXEXT -           round1 0.041 usec       iCrc=8100  MMXEXT -           round1 0.025 usec       crc32=0x2b1f528f
1584  MMXEXT - interp- v-round0 0.027 usec       iCrc=8108  MMXEXT - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1585  MMXEXT -           round1 0.041 usec       iCrc=8105  MMXEXT -           round1 0.024 usec       crc32=0x42202efe
1586  MMXEXT - interp-hv-round0 0.066 usec       iCrc=8112  MMXEXT - interp-hv-round0 0.037 usec       crc32=0xd198d387
1587  MMXEXT -           round1 0.065 usec       iCrc=8103  MMXEXT -           round1 0.037 usec       crc32=0x9ecfd921
1588   ---   ---
1589  SSE2   - interp- h-round0 0.109 usec       iCrc=8107  3DNOW  - interp- h-round0 0.020 usec       crc32=0x115381ba
1590  SSE2   -           round1 0.105 usec       iCrc=8100  3DNOW  -           round1 0.029 usec       crc32=0x2b1f528f
1591  SSE2   - interp- v-round0 0.106 usec       iCrc=8108  3DNOW  - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1592  SSE2   -           round1 0.109 usec       iCrc=8105  3DNOW  -           round1 0.024 usec       crc32=0x42202efe
1593  SSE2   - interp-hv-round0 0.145 usec       iCrc=8112  3DNOW  - interp-hv-round0 0.038 usec       crc32=0xd198d387
1594  SSE2   -           round1 0.145 usec       iCrc=8103  3DNOW  -           round1 0.039 usec       crc32=0x9ecfd921
1595     ---
1596    3DNOWE - interp- h-round0 0.020 usec       crc32=0x115381ba
1597    3DNOWE -           round1 0.024 usec       crc32=0x2b1f528f
1598    3DNOWE - interp- v-round0 0.016 usec       crc32=0x423cdcc7
1599    3DNOWE -           round1 0.021 usec       crc32=0x42202efe
1600    3DNOWE - interp-hv-round0 0.037 usec       crc32=0xd198d387
1601    3DNOWE -           round1 0.036 usec       crc32=0x9ecfd921
1602   ---   ---
 3DNOW  - skipped...  
 3DNOWE - skipped...  
1603    
1604   ======  test SAD ======   ======  test SAD ======
1605  PLAINC - sad8    0.251 usec       sad=3776  PLAINC - sad8    0.505 usec       sad=3776
1606  PLAINC - sad16   1.601 usec       sad=27214  PLAINC - sad16   1.941 usec       sad=27214
1607  PLAINC - sad16bi 2.371 usec       sad=26274  PLAINC - sad16bi 4.925 usec       sad=26274
1608  PLAINC - dev16   1.564 usec       sad=3344  PLAINC - dev16   4.254 usec       sad=3344
1609   ---   ---
1610  MMX    - sad8    0.057 usec       sad=3776  MMX    - sad8    0.036 usec       sad=3776
1611  MMX    - sad16   0.182 usec       sad=27214  MMX    - sad16   0.107 usec       sad=27214
1612  MMX    - sad16bi 2.462 usec       sad=26274  MMX    - sad16bi 0.259 usec       sad=26274
1613  MMX    - dev16   0.311 usec       sad=3344  MMX    - dev16   0.187 usec       sad=3344
1614   ---   ---
1615  MMXEXT - sad8    0.036 usec       sad=3776  MMXEXT - sad8    0.016 usec       sad=3776
1616  MMXEXT - sad16   0.109 usec       sad=27214  MMXEXT - sad16   0.050 usec       sad=27214
1617  MMXEXT - sad16bi 0.143 usec       sad=26274  MMXEXT - sad16bi 0.060 usec       sad=26274
1618  MMXEXT - dev16   0.192 usec       sad=3344  MMXEXT - dev16   0.086 usec       sad=3344
1619   ---   ---
1620  SSE2   - sad8    0.057 usec       sad=3776  3DNOW  - sad8    0.506 usec       sad=3776
1621  SSE2   - sad16   0.179 usec       sad=27214  3DNOW  - sad16   1.954 usec       sad=27214
1622  SSE2   - sad16bi 2.456 usec       sad=26274  3DNOW  - sad16bi 0.119 usec       sad=26274
1623  SSE2   - dev16   0.321 usec       sad=3344  3DNOW  - dev16   4.252 usec       sad=3344
1624     ---
1625    3DNOWE - sad8    0.017 usec       sad=3776
1626    3DNOWE - sad16   0.038 usec       sad=27214
1627    3DNOWE - sad16bi 0.052 usec       sad=26274
1628    3DNOWE - dev16   0.067 usec       sad=3344
1629   ---   ---
 3DNOW  - skipped...  
 3DNOWE - skipped...  
1630    
1631   ===  test transfer ===   ===  test transfer ===
1632  PLAINC - 8to16     0.151 usec       crc=28288  PLAINC - 8to16     0.603 usec       crc32=0x115814bb
1633  PLAINC - 16to8     1.113 usec       crc=28288  PLAINC - 16to8     1.077 usec       crc32=0xee7ccbb4
1634  PLAINC - 8to8      0.043 usec       crc=20352  PLAINC - 8to8      0.679 usec       crc32=0xd37b3295
1635  PLAINC - 16to8add  1.069 usec       crc=25536  PLAINC - 16to8add  1.341 usec       crc32=0xdd817bf4
1636  PLAINC - 8to16sub  0.631 usec       crc1=28064 crc2=16256  PLAINC - 8to16sub  1.566 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1637  PLAINC - 8to16sub2 0.597 usec       crc=20384  PLAINC - 8to16sub2 2.206 usec       crc32=0x99b6c4c7
1638   ---   ---
1639  MMX    - 8to16     0.032 usec       crc=28288  MMX    - 8to16     -0.025 usec       crc32=0x115814bb
1640  MMX    - 16to8     0.024 usec       crc=28288  MMX    - 16to8     -0.049 usec       crc32=0xee7ccbb4
1641  MMX    - 8to8      0.020 usec       crc=20352  MMX    - 8to8      0.014 usec       crc32=0xd37b3295
1642  MMX    - 16to8add  0.043 usec       crc=25536  MMX    - 16to8add  0.011 usec       crc32=0xdd817bf4
1643  MMX    - 8to16sub  0.066 usec       crc1=28064 crc2=16256  MMX    - 8to16sub  0.108 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1644  MMX    - 8to16sub2 0.111 usec       crc=20384  MMX    - 8to16sub2 0.164 usec       crc32=0x99b6c4c7
1645     ---
1646    MMXEXT - 8to16     -0.054 usec       crc32=0x115814bb
1647    MMXEXT - 16to8     0.010 usec       crc32=0xee7ccbb4
1648    MMXEXT - 8to8      0.015 usec       crc32=0xd37b3295
1649    MMXEXT - 16to8add  0.008 usec       crc32=0xdd817bf4
1650    MMXEXT - 8to16sub  0.263 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1651    MMXEXT - 8to16sub2 0.178 usec       crc32=0x99b6c4c7
1652     ---
1653    3DNOW  - 8to16     0.666 usec       crc32=0x115814bb
1654    3DNOW  - 16to8     1.078 usec       crc32=0xee7ccbb4
1655    3DNOW  - 8to8      0.665 usec       crc32=0xd37b3295
1656    3DNOW  - 16to8add  1.365 usec       crc32=0xdd817bf4
1657    3DNOW  - 8to16sub  1.356 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1658    3DNOW  - 8to16sub2 2.098 usec       crc32=0x99b6c4c7
1659     ---
1660    3DNOWE - 8to16     -0.024 usec       crc32=0x115814bb
1661    3DNOWE - 16to8     0.010 usec       crc32=0xee7ccbb4
1662    3DNOWE - 8to8      0.014 usec       crc32=0xd37b3295
1663    3DNOWE - 16to8add  0.016 usec       crc32=0xdd817bf4
1664    3DNOWE - 8to16sub  -0.000 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23
1665    3DNOWE - 8to16sub2 -0.031 usec       crc32=0x99b6c4c7
1666   ---   ---
1667    
1668   =====  test quant =====   =====  test quant =====
1669  PLAINC -   quant4_intra 74.248 usec       crc=29809  PLAINC -   quant_mpeg_intra 98.631 usec       crc32=0xfd6a21a4
1670  PLAINC -   quant4_inter 70.850 usec       crc=12574  PLAINC -   quant_mpeg_inter 104.876 usec       crc32=0xf6de7757
1671  PLAINC - dequant4_intra 40.628 usec       crc=24052  PLAINC - dequant_mpeg_intra 50.285 usec       crc32=0x2def7bc7
1672  PLAINC - dequant4_inter 45.691 usec       crc=63847  PLAINC - dequant_mpeg_inter 58.316 usec       crc32=0xd878c722
1673  PLAINC -    quant_intra 43.357 usec       crc=25662  PLAINC -   quant_h263_intra 33.803 usec       crc32=0x2eba9d43
1674  PLAINC -    quant_inter 33.410 usec       crc=23972  PLAINC -   quant_h263_inter 45.411 usec       crc32=0xbd315a7e
1675  PLAINC -  dequant_intra 36.384 usec       crc=49900  PLAINC - dequant_h263_intra 39.302 usec       crc32=0x9841212a
1676  PLAINC -  dequant_inter 48.930 usec       crc=48899  PLAINC - dequant_h263_inter 44.124 usec       crc32=0xe7df8fba
1677   ---   ---
1678  MMX    -   quant4_intra 7.445 usec       crc=3459  MMX    -   quant_mpeg_intra 4.273 usec       crc32=0xdacabdb6 | ERROR
1679  *** CRC ERROR! ***  MMX    -   quant_mpeg_inter 3.576 usec       crc32=0x72883ab6 | ERROR
1680  MMX    -   quant4_inter 5.384 usec       crc=51072  MMX    - dequant_mpeg_intra 3.793 usec       crc32=0x2def7bc7
1681  *** CRC ERROR! ***  MMX    - dequant_mpeg_inter 4.808 usec       crc32=0xd878c722
1682  MMX    - dequant4_intra 5.515 usec       crc=24052  MMX    -   quant_h263_intra 2.881 usec       crc32=0x2eba9d43
1683  MMX    - dequant4_inter 7.745 usec       crc=63847  MMX    -   quant_h263_inter 2.550 usec       crc32=0xbd315a7e
1684  MMX    -    quant_intra 4.661 usec       crc=25662  MMX    - dequant_h263_intra 2.974 usec       crc32=0x9841212a
1685  MMX    -    quant_inter 4.406 usec       crc=23972  MMX    - dequant_h263_inter 2.906 usec       crc32=0xe7df8fba
1686  MMX    -  dequant_intra 4.928 usec       crc=49900   ---
1687  MMX    -  dequant_inter 4.532 usec       crc=48899  MMXEXT -   quant_mpeg_intra 4.221 usec       crc32=0xfd6a21a4
1688    MMXEXT -   quant_mpeg_inter 4.339 usec       crc32=0xf6de7757
1689    MMXEXT - dequant_mpeg_intra 3.802 usec       crc32=0x2def7bc7
1690    MMXEXT - dequant_mpeg_inter 4.821 usec       crc32=0xd878c722
1691    MMXEXT -   quant_h263_intra 2.884 usec       crc32=0x2eba9d43
1692    MMXEXT -   quant_h263_inter 2.554 usec       crc32=0xbd315a7e
1693    MMXEXT - dequant_h263_intra 2.728 usec       crc32=0x9841212a
1694    MMXEXT - dequant_h263_inter 2.611 usec       crc32=0xe7df8fba
1695     ---
1696    3DNOW  -   quant_mpeg_intra 98.512 usec       crc32=0xfd6a21a4
1697    3DNOW  -   quant_mpeg_inter 104.873 usec       crc32=0xf6de7757
1698    3DNOW  - dequant_mpeg_intra 50.219 usec       crc32=0x2def7bc7
1699    3DNOW  - dequant_mpeg_inter 58.254 usec       crc32=0xd878c722
1700    3DNOW  -   quant_h263_intra 33.778 usec       crc32=0x2eba9d43
1701    3DNOW  -   quant_h263_inter 41.998 usec       crc32=0xbd315a7e
1702    3DNOW  - dequant_h263_intra 39.344 usec       crc32=0x9841212a
1703    3DNOW  - dequant_h263_inter 43.607 usec       crc32=0xe7df8fba
1704     ---
1705    3DNOWE -   quant_mpeg_intra 98.490 usec       crc32=0xfd6a21a4
1706    3DNOWE -   quant_mpeg_inter 104.889 usec       crc32=0xf6de7757
1707    3DNOWE - dequant_mpeg_intra 3.277 usec       crc32=0x2def7bc7
1708    3DNOWE - dequant_mpeg_inter 4.485 usec       crc32=0xd878c722
1709    3DNOWE -   quant_h263_intra 1.882 usec       crc32=0x2eba9d43
1710    3DNOWE -   quant_h263_inter 2.246 usec       crc32=0xbd315a7e
1711    3DNOWE - dequant_h263_intra 3.457 usec       crc32=0x9841212a
1712    3DNOWE - dequant_h263_inter 3.275 usec       crc32=0xe7df8fba
1713   ---   ---
1714    
1715   =====  test cbp =====   =====  test cbp =====
1716  PLAINC -   calc_cbp#1 0.371 usec       cbp=0x15  PLAINC -   calc_cbp#1 0.168 usec       cbp=0x15
1717  PLAINC -   calc_cbp#2 0.432 usec       cbp=0x38  PLAINC -   calc_cbp#2 0.168 usec       cbp=0x38
1718  PLAINC -   calc_cbp#3 0.339 usec       cbp=0xf  PLAINC -   calc_cbp#3 0.157 usec       cbp=0x0f
1719  PLAINC -   calc_cbp#4 0.506 usec       cbp=0x5  PLAINC -   calc_cbp#4 0.235 usec       cbp=0x05
1720   ---   ---
1721  MMX    -   calc_cbp#1 0.136 usec       cbp=0x15  MMX    -   calc_cbp#1 0.070 usec       cbp=0x15
1722  MMX    -   calc_cbp#2 0.134 usec       cbp=0x38  MMX    -   calc_cbp#2 0.062 usec       cbp=0x38
1723  MMX    -   calc_cbp#3 0.138 usec       cbp=0xf  MMX    -   calc_cbp#3 0.062 usec       cbp=0x0f
1724  MMX    -   calc_cbp#4 0.135 usec       cbp=0x5  MMX    -   calc_cbp#4 0.061 usec       cbp=0x05
1725   ---   ---
1726  SSE2   -   calc_cbp#1 0.136 usec       cbp=0x15  MMXEXT -   calc_cbp#1 0.062 usec       cbp=0x15
1727  SSE2   -   calc_cbp#2 0.133 usec       cbp=0x38  MMXEXT -   calc_cbp#2 0.061 usec       cbp=0x38
1728  SSE2   -   calc_cbp#3 0.133 usec       cbp=0xf  MMXEXT -   calc_cbp#3 0.061 usec       cbp=0x0f
1729  SSE2   -   calc_cbp#4 0.141 usec       cbp=0x5  MMXEXT -   calc_cbp#4 0.061 usec       cbp=0x05
1730   ---   ---
1731    3DNOW  -   calc_cbp#1 0.168 usec       cbp=0x15
1732    3DNOW  -   calc_cbp#2 0.168 usec       cbp=0x38
1733    3DNOW  -   calc_cbp#3 0.157 usec       cbp=0x0f
1734    3DNOW  -   calc_cbp#4 0.238 usec       cbp=0x05
1735     ---
1736    3DNOWE -   calc_cbp#1 0.049 usec       cbp=0x15
1737    3DNOWE -   calc_cbp#2 0.049 usec       cbp=0x38
1738    3DNOWE -   calc_cbp#3 0.049 usec       cbp=0x0f
1739    3DNOWE -   calc_cbp#4 0.049 usec       cbp=0x05
1740     ---
1741    
1742    
1743  */  NB: If a function isn't optimised for a specific set of intructions,
1744        a C function is used instead. So don't panic if some functions
1745        may appear to be slow.
1746    
1747    NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)
1748        for 1 or 2 coefficients a block. This is mainly caused by the fact the unit
1749        test goes far behind the usual limits of real encoding. Please do not report
1750        this error to the developers
1751    
1752    *********************************************************************/
Legend:
Removed from v.860  
changed lines
  Added in v.1398
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4