[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 1382, Mon Mar 22 22:36:25 2004 UTC revision 1620, Tue Jun 14 13:58:21 2005 UTC
# Line 19  Line 19 
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21   *   *
22   * $Id: xvid_bench.c,v 1.11 2004-03-22 22:36:23 edgomez Exp $   * $Id: xvid_bench.c,v 1.21 2005-06-14 13:58:21 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
# Line 67  Line 65 
65  #define M_PI            3.14159265358979323846  #define M_PI            3.14159265358979323846
66  #endif  #endif
67    
68  const int speed_ref = 100;  /* on slow machines, decrease this value */  int speed_ref = 100;  /* on slow machines, decrease this value */
69    int verbose = 0;
70    unsigned int cpu_mask;
71    
72  /*********************************************************************  /*********************************************************************
73   * misc   * misc
# Line 83  Line 83 
83  #else  #else
84          clock_t clk;          clock_t clk;
85          clk = clock();          clk = clock();
86          return clk * 1000000 / CLOCKS_PER_SEC;          return clk * 1000. / CLOCKS_PER_SEC;  /* clock() returns time in Milliseconds */
87  #endif  #endif
88  }  }
89    
# Line 121  Line 121 
121    , { "3DNOW ", XVID_CPU_3DNOW }    , { "3DNOW ", XVID_CPU_3DNOW }
122    , { "3DNOWE", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT }    , { "3DNOWE", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT }
123  #endif  #endif
124    #ifdef ARCH_IS_PPC
125      , { "ALTIVEC", XVID_CPU_ALTIVEC }
126    #endif
127    #ifdef ARCH_IS_X86_64
128      , { "X86_64", XVID_CPU_ASM}
129    #endif
130  //, { "IA64  ", XVID_CPU_IA64 }  //, { "IA64  ", XVID_CPU_IA64 }
131  //, { "TSC   ", XVID_CPU_TSC }  //, { "TSC   ", XVID_CPU_TSC }
132    , { 0, 0 } };    , { 0, 0 } };
# Line 253  Line 259 
259  };  };
260    
261  uint32_t  uint32_t
262  calc_crc(uint8_t *mem, int len, uint32_t initial)  calc_crc(uint8_t *mem, int len, uint32_t crc)
263  {  {
   
         register unsigned int crc;  
   
         crc = initial;  
   
264          while( len >= 8) {          while( len >= 8) {
265                  DO8(mem, crc);                  DO8(mem, crc);
266                  len -= 8;                  len -= 8;
# Line 270  Line 271 
271                  len--;                  len--;
272          }          }
273    
274          return(crc);          return crc;
   
275  }  }
276    
277  /*********************************************************************  /*********************************************************************
# Line 527  Line 527 
527  }                                         \  }                                         \
528  emms();                                   \  emms();                                   \
529  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
530  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)  s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), 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 553  Line 553 
553  }                                         \  }                                         \
554  emms();                                   \  emms();                                   \
555  t = (gettime_usec()-t -overhead) / nb_tests;\  t = (gettime_usec()-t -overhead) / nb_tests;\
556  s = calc_crc((uint8_t*)(DST), sizeof((DST)), CRC32_INITIAL)  s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), 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 570  Line 570 
570          const int nb_tests = 4000*speed_ref;          const int nb_tests = 4000*speed_ref;
571          int i;          int i;
572          CPU *cpu;          CPU *cpu;
573          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];
574          int16_t Src16[8*32], Dst16[8*32];  //      int16_t Src16[8*32], Dst16[8*32];
575      DECLARE_ALIGNED_MATRIX(Src8, 8, 32, uint8_t, CACHE_LINE);
576      DECLARE_ALIGNED_MATRIX(Dst8, 8, 32, uint8_t, CACHE_LINE);
577      DECLARE_ALIGNED_MATRIX(Ref1, 8, 32, uint8_t, CACHE_LINE);
578      DECLARE_ALIGNED_MATRIX(Ref2, 8, 32, uint8_t, CACHE_LINE);
579      DECLARE_ALIGNED_MATRIX(Src16, 8, 32, uint16_t, CACHE_LINE);
580      DECLARE_ALIGNED_MATRIX(Dst16, 8, 32, uint16_t, CACHE_LINE);
581    
582          printf( "\n ===  test transfer ===\n" );          printf( "\n ===  test transfer ===\n" );
583    
# Line 606  Line 612 
612                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);                  TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
613                  {                  {
614                          int s1, s2;                          int s1, s2;
615                          s1 = calc_crc((uint8_t*)Dst16, sizeof(Dst16), CRC32_INITIAL);                          s1 = calc_crc((uint8_t*)Dst16, 8*32*sizeof(Dst16[0]), CRC32_INITIAL);
616                          s2 = calc_crc((uint8_t*)Src8, sizeof(Src8), CRC32_INITIAL);                          s2 = calc_crc((uint8_t*)Src8, 8*32*sizeof(Src8[0]), CRC32_INITIAL);
617                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",                          printf("%s - 8to16sub  %.3f usec       crc32(1)=0x%08x crc32(2)=0x%08x %s %s\n",
618                                     cpu->name, t, s1, s2,                                     cpu->name, t, s1, s2,
619                                     (s1!=0xa1e07163)?"| ERROR1": "",                                     (s1!=0xa1e07163)?"| ERROR1": "",
# Line 657  Line 663 
663  }                                           \  }                                           \
664  t = (gettime_usec()-t-overhead)/nb_tests/qm  t = (gettime_usec()-t-overhead)/nb_tests/qm
665    
666    #define TEST_INTRA(REFFUNC, NEWFUNC, RANGE)              \
667    { int i,q,s;\
668            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
669      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
670      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
671      for(q=1;q<=max_Q;q++)          \
672        for(s=-RANGE;s<RANGE;s++) { \
673          for(i=0;i<64;i++) Src[i]=s; \
674          (REFFUNC)((Dst),(Src),q,q,mpeg_quant_matrices);   \
675          (NEWFUNC)((Dst2),(Src),q,q,mpeg_quant_matrices);  \
676          for(i=0;i<64;i++)     \
677            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]);  \
678        }      \
679    }
680    
681    #define TEST_INTER(REFFUNC, NEWFUNC, RANGE)              \
682    { int i,q,s;  \
683            DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16); \
684      DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16); \
685      DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16); \
686      for(q=1;q<=max_Q;q++)  \
687        for(s=-RANGE;s<RANGE;s++) {   \
688          for(i=0;i<64;i++) Src[i]=s; \
689          (REFFUNC)((Dst),(Src),q,mpeg_quant_matrices);  \
690          (NEWFUNC)((Dst2),(Src),q,mpeg_quant_matrices); \
691          emms();           \
692          for(i=0;i<64;i++) \
693            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]); \
694        } \
695    }
696    
697  void test_quant()  void test_quant()
698  {  {
699          const int nb_tests = 1*speed_ref;          const int nb_tests = 1*speed_ref;
# Line 667  Line 704 
704          CPU *cpu;          CPU *cpu;
705          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
706          DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);          DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);
707            DECLARE_ALIGNED_MATRIX(Dst2,8, 8, int16_t, 16);
708          uint8_t Quant[8*8];          uint8_t Quant[8*8];
709    
710          printf( "\n =====  test quant =====\n" );          printf( "\n =====  test quant =====\n" );
# Line 687  Line 725 
725                  if (!init_cpu(cpu))                  if (!init_cpu(cpu))
726                  continue;                  continue;
727    
728                    // exhaustive tests to compare against the (ref) C-version
729                    TEST_INTRA(quant_h263_intra_c,   quant_h263_intra,    2048);
730                    TEST_INTRA(dequant_h263_intra_c, dequant_h263_intra , 512 );
731                    TEST_INTER(quant_h263_inter_c,   quant_h263_inter ,   2048);
732                    TEST_INTER(dequant_h263_inter_c, dequant_h263_inter , 512 );
733    
734                  overhead = -gettime_usec();                  overhead = -gettime_usec();
735                  for(s=0,qm=1; qm<=255; ++qm) {                  for(s=0,qm=1; qm<=255; ++qm) {
736                          for(i=0; i<8*8; ++i) Quant[i] = qm;                          for(i=0; i<8*8; ++i) Quant[i] = qm;
# Line 741  Line 785 
785  }  }
786    
787  /*********************************************************************  /*********************************************************************
788     * test distortion operators
789     *********************************************************************/
790    
791    static void ieee_reseed(long s);
792    static long ieee_rand(int Min, int Max);
793    
794    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
795      do { \
796        t = gettime_usec(); \
797        tst = nb_tests; \
798        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
799        emms(); \
800        t = (gettime_usec() - t)/(double)nb_tests;  \
801      } while(0)
802    
803    
804    void test_sse()
805    {
806            const int nb_tests = 100000*speed_ref;
807            int i;
808            CPU *cpu;
809            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
810            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
811            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
812            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
813    
814            printf( "\n =====  test sse =====\n" );
815    
816            ieee_reseed(1);
817            for(i=0; i<64; ++i) {
818                    Src1[i] = ieee_rand(-2048, 2047);
819                    Src2[i] = ieee_rand(-2048, 2047);
820                    Src3[i] = ieee_rand(-2048, 2047);
821                    Src4[i] = ieee_rand(-2048, 2047);
822            }
823    
824            for(cpu = cpu_list; cpu->name!=0; ++cpu)
825            {
826                    double t;
827                    int tst, sse;
828    
829                    if (!init_cpu(cpu))
830                            continue;
831    
832                    /* 16 bit element blocks */
833                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
834                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
835                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
836                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
837                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
838                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
839                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
840                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
841                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
842                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
843                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
844                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
845                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
846                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
847                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
848                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
849                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
850                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
851    
852                    /* 8 bit element blocks */
853                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
854                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
855                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
856                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
857                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
858                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
859                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
860                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
861                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
862                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
863                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
864                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
865                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
866                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
867                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
868                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
869                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
870                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
871    
872                    printf(" ---\n");
873            }
874    }
875    
876    /*********************************************************************
877   * test non-zero AC counting   * test non-zero AC counting
878   *********************************************************************/   *********************************************************************/
879    
# Line 781  Line 914 
914                          continue;                          continue;
915    
916                  TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1);
917                  printf("%s -   calc_cbp#1 %.3f usec       cbp=0x%02x\n",                  printf("%s -   calc_cbp#1 %.3f usec       cbp=0x%02x %s\n",
918                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
919                  TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2);
920                  printf("%s -   calc_cbp#2 %.3f usec       cbp=0x%02x\n",                  printf("%s -   calc_cbp#2 %.3f usec       cbp=0x%02x %s\n",
921                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
922                  TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3);
923                  printf("%s -   calc_cbp#3 %.3f usec       cbp=0x%02x\n",                  printf("%s -   calc_cbp#3 %.3f usec       cbp=0x%02x %s\n",
924                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
925                  TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4);
926                  printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x\n",                  printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
927                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
928                  printf( " --- \n" );                  printf( " --- \n" );
929          }          }
# Line 1187  Line 1320 
1320   * measure raw decoding speed   * measure raw decoding speed
1321   *********************************************************************/   *********************************************************************/
1322    
1323  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)
1324  {  {
1325          FILE *f = 0;          FILE *f = 0;
1326          void *dechandle = 0;          void *dechandle = 0;
# Line 1198  Line 1331 
1331          double t = 0.;          double t = 0.;
1332          int nb = 0;          int nb = 0;
1333          uint8_t *buf = 0;          uint8_t *buf = 0;
1334          uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1335          int buf_size, pos;          int buf_size, pos;
1336          uint32_t chksum = 0;          uint32_t chksum = 0;
1337            int bps = (width+31) & ~31;
1338    
1339          memset(&xinit, 0, sizeof(xinit));          memset(&xinit, 0, sizeof(xinit));
1340          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = cpu_mask;
1341          xinit.version = XVID_VERSION;          xinit.version = XVID_VERSION;
1342          xvid_global(NULL, 0, &xinit, NULL);          xvid_global(NULL, 0, &xinit, NULL);
1343    
# Line 1213  Line 1347 
1347          xparam.version = XVID_VERSION;          xparam.version = XVID_VERSION;
1348          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1349          if (xerr==XVID_ERR_FAIL) {          if (xerr==XVID_ERR_FAIL) {
1350                  printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1351                  return;                  return;
1352          }          }
1353          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1221  Line 1355 
1355    
1356          f = fopen(name, "rb");          f = fopen(name, "rb");
1357          if (f==0) {          if (f==0) {
1358                  printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1359                  return;                  return;
1360          }          }
1361          fseek(f, 0, SEEK_END);          fseek(f, 0, SEEK_END);
1362          buf_size = ftell(f);          buf_size = ftell(f);
1363          fseek(f, 0, SEEK_SET);          fseek(f, 0, SEEK_SET);
1364          if (buf_size<=0) {          if (buf_size<=0) {
1365                  printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1366                  goto End;                  goto End;
1367          }          }
         else printf( "Input size: %d\n", buf_size);  
1368    
1369          buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1370          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1371          if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1372                  printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1373                  goto End;                  goto End;
1374          }          }
1375    
1376          if (fread(buf, buf_size, 1, f)!=1) {          if (fread(buf, buf_size, 1, f)!=1) {
1377                  printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1378                  goto End;                  goto End;
1379          }          }
1380    
# Line 1249  Line 1382 
1382          pos = 0;          pos = 0;
1383          t = -gettime_usec();          t = -gettime_usec();
1384          while(1) {          while(1) {
1385              int y;
1386    
1387                  memset(&xframe, 0, sizeof(xframe));                  memset(&xframe, 0, sizeof(xframe));
1388                  xframe.version = XVID_VERSION;                  xframe.version = XVID_VERSION;
1389                  xframe.bitstream = buf + pos;                  xframe.bitstream = buf + pos;
1390                  xframe.length = buf_size - pos;                  xframe.length = buf_size - pos;
1391                  xframe.output.plane[0] = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1392                  xframe.output.stride[0] = width;                  xframe.output.plane[1] = xframe.output.plane[0] + bps*height;
1393                  xframe.output.csp = XVID_CSP_BGR;                  xframe.output.plane[2] = xframe.output.plane[1] + bps/2;
1394                    xframe.output.stride[0] = bps;
1395                    xframe.output.stride[1] = bps;
1396                    xframe.output.stride[2] = bps;
1397                    xframe.output.csp = XVID_CSP_I420;
1398                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1399                    if (xerr<0) {
1400                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1401                            break;
1402                    }
1403                    else if (xerr==0)
1404                      break;
1405        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1406    
1407                    pos += xerr;
1408                  nb++;                  nb++;
1409                  pos += xframe.length;  
1410                  if (with_chksum) {      for(y=0; y<height/2; ++y) {
1411                          int k = width*height;                    chksum = calc_crc(xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1412                          uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc(xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1413                          while(k-->0) chksum += *ptr++;                          chksum = calc_crc(xframe.output.plane[1] + y*bps, width/2, chksum);
1414                            chksum = calc_crc(xframe.output.plane[2] + y*bps, width/2, chksum);
1415                  }                  }
1416                  if (pos==buf_size)                  if (pos==buf_size)
1417                          break;                          break;
                 if (xerr==XVID_ERR_FAIL) {  
                         printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
                         break;  
                 }  
1418          }          }
1419          t += gettime_usec();          t += gettime_usec();
1420            if (ref_chksum==0) {
1421          if (t>0.)          if (t>0.)
1422                  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 );
1423          if (with_chksum)    }
1424                  printf("checksum: 0x%.8x\n", chksum);    else {
1425                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1426                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1427      }
1428    
1429   End:   End:
1430          if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1431          if (buf!=0) free(buf);          if (buf!=0) free(buf);
1432          if (dechandle!=0) {          if (dechandle!=0) {
1433                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1434                  if (xerr==XVID_ERR_FAIL)                  if (xerr==XVID_ERR_FAIL)
1435                          printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1436          }          }
1437          if (f!=0) fclose(f);          if (f!=0) fclose(f);
1438  }  }
# Line 1445  Line 1594 
1594          }          }
1595  #endif  #endif
1596  }  }
1597    /*********************************************************************/
1598    
1599    static uint32_t __inline log2bin_v1(uint32_t value)
1600    {
1601      int n = 0;
1602      while (value) {
1603        value >>= 1;
1604        n++;
1605      }
1606      return n;
1607    }
1608    
1609    static const uint8_t log2_tab_16[16] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1610    
1611    static uint32_t __inline log2bin_v2(uint32_t value)
1612    {
1613      int n = 0;
1614      if (value & 0xffff0000) {
1615        value >>= 16;
1616        n += 16;
1617      }
1618      if (value & 0xff00) {
1619        value >>= 8;
1620        n += 8;
1621      }
1622      if (value & 0xf0) {
1623        value >>= 4;
1624        n += 4;
1625      }
1626     return n + log2_tab_16[value];
1627    }
1628    
1629    void test_log2bin()
1630    {
1631            const int nb_tests = 3000*speed_ref;
1632      int n, crc1=0, crc2=0;
1633      uint32_t s, s0;
1634      double t1, t2;
1635    
1636      t1 = gettime_usec();
1637      s0 = (int)(t1*31.241);
1638      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1639        crc1 += log2bin_v1(s);
1640      t1 = (gettime_usec()-t1) / nb_tests;
1641    
1642      t2 = gettime_usec();
1643      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1644        crc2 += log2bin_v2(s);
1645      t2 = (gettime_usec() - t2) / nb_tests;
1646    
1647      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1648      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1649      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1650    }
1651    
1652    /*********************************************************************/
1653    
1654    static void __inline old_gcd(int *num, int *den)
1655    {
1656     int i = *num;
1657      while (i > 1) {
1658        if (*num % i == 0 && *den % i == 0) {
1659          *num /= i;
1660          *den /= i;
1661          i = *num;
1662          continue;
1663        }
1664        i--;
1665      }
1666    }
1667    
1668    static uint32_t gcd(int num, int den)
1669    {
1670      int tmp;
1671      while( (tmp=num%den) ) { num = den; den = tmp; }
1672      return den;
1673    }
1674    static void __inline new_gcd(int *num, int *den)
1675    {
1676      const int div = gcd(*num, *den);
1677      if (num) {
1678        *num /= div;
1679        *den /= div;
1680      }
1681    }
1682    
1683    void test_gcd()
1684    {
1685            const int nb_tests = 10*speed_ref;
1686      int i;
1687      uint32_t crc1=0, crc2=0;
1688      uint32_t n0, n, d0, d;
1689      double t1, t2;
1690    
1691      t1 = gettime_usec();
1692      n0 = 0xfffff & (int)(t1*31.241);
1693      d0 = 0xfffff & (int)( ((n0*4123)%17) | 1 );
1694      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1695        old_gcd(&n, &d);
1696        crc1 = (((crc1>>4)^d) + ((crc1<<2)^n) ) & 0xffffff;
1697        n = d;
1698        d = (d*12363+31) & 0xffff;
1699        d |= !d;
1700      }
1701      t1 = (gettime_usec()-t1) / nb_tests;
1702    
1703      t2 = gettime_usec();
1704      for(n=n0, d=d0, i=0; i<nb_tests; ++i) {
1705        new_gcd(&n, &d);
1706        crc2 = (((crc2>>4)^d) + ((crc2<<2)^n) ) & 0xffffff;
1707        n = d;
1708        d = (d*12363+31) & 0xffff;
1709        d |= !d;
1710      }
1711      t2 = (gettime_usec() - t2) / nb_tests;
1712    
1713      printf( "old_gcd: %.3f sec  crc=%d\n", t1, crc1 );
1714      printf( "new_gcd: %.3f sec  crc=%d\n", t2, crc2 );
1715      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1716    }
1717    
1718  /*********************************************************************  /*********************************************************************
1719   * main   * main
1720   *********************************************************************/   *********************************************************************/
1721    
1722  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
1723  {  {
1724          int what = 0;    printf( "missing argument after option '%s'\n", opt);
1725          if (argc>1) what = atoi(argv[1]);    exit(-1);
1726    }
1727    
1728    int main(int argc, const char *argv[])
1729    {
1730            int c, what = 0;
1731            int width, height;
1732            uint32_t chksum = 0;
1733      const char * test_bitstream = 0;
1734    
1735            cpu_mask = 0;  // default => will use autodectect
1736            for(c=1; c<argc; ++c)
1737            {
1738              if (!strcmp(argv[c], "-v")) verbose++;
1739              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
1740              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
1741              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1742              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1743              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
1744              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
1745              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
1746              else if (!strcmp(argv[c], "-spd")) {
1747          if (++c==argc) arg_missing( argv[argc-1] );
1748          speed_ref = atoi(argv[c]);
1749        }
1750              else if (argv[c][0]!='-') {
1751                what = atoi(argv[c]);
1752                if (what==9) {
1753                  if (c+4>argc) {
1754                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
1755                    exit(-1);
1756            }
1757            test_bitstream = argv[++c];
1758                  width  = atoi(argv[++c]);
1759                  height = atoi(argv[++c]);
1760                  if (c+1<argc && argv[c+1][0]!='-') {
1761                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
1762                      printf( "can't read checksum value.\n" );
1763                      exit(-1);
1764              }
1765              else c++;
1766            }
1767    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
1768          }
1769        }
1770        else {
1771          printf( "unrecognized option '%s'\n", argv[c]);
1772          exit(-1);
1773        }
1774      }
1775    
1776    
1777          if (what==0 || what==1) test_dct();          if (what==0 || what==1) test_dct();
1778          if (what==0 || what==2) test_mb();          if (what==0 || what==2) test_mb();
1779          if (what==0 || what==3) test_sad();          if (what==0 || what==3) test_sad();
1780          if (what==0 || what==4) test_transfer();          if (what==0 || what==4) test_transfer();
1781          if (what==0 || what==5) test_quant();          if (what==0 || what==5) test_quant();
1782          if (what==0 || what==6) test_cbp();          if (what==0 || what==6) test_cbp();
1783            if (what==0 || what==10) test_sse();
1784            if (what==0 || what==11) test_log2bin();
1785            if (what==0 || what==12) test_gcd();
1786    
1787    
1788          if (what==7) {          if (what==7) {
1789                  test_IEEE1180_compliance(-256, 255, 1);                  test_IEEE1180_compliance(-256, 255, 1);
# Line 1471  Line 1795 
1795          }          }
1796          if (what==8) test_dct_saturation(-256, 255);          if (what==8) test_dct_saturation(-256, 255);
1797    
1798          if (what==9) {          if (test_bitstream)
1799                  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));  
         }  
   
1800          if (what==-1) {          if (what==-1) {
1801                  test_dct_precision_diffs();                  test_dct_precision_diffs();
1802                  test_bugs1();                  test_bugs1();
# Line 1489  Line 1804 
1804          if (what==-2)          if (what==-2)
1805                  test_quant_bug();                  test_quant_bug();
1806    
1807          if (what >= 0 && what <= 6) {          if ((what >= 0 && what <= 6) || what == 10) {
1808                  printf("\n\n"                  printf("\n\n"
1809                             "NB: If a function isn't optimised for a specific set of intructions,\n"                             "NB: If a function isn't optimised for a specific set of intructions,\n"
1810                             "    a C function is used instead. So don't panic if some functions\n"                             "    a C function is used instead. So don't panic if some functions\n"
# Line 1509  Line 1824 
1824          return 0;          return 0;
1825  }  }
1826    
1827  /*********************************************************************  /*********************************************************************/
  * 'Reference' output (except for timing) on an Athlon XP 2200+  
  *********************************************************************/  
   
 /* as of 2002-01-07, there's a problem with MMX mpeg4-quantization */  
 /* as of 2003-11-30, the problem is still here */  
   
 /*********************************************************************  
   
   
  ===== test fdct/idct =====  
 PLAINC -  2.867 usec       PSNR=13.291  MSE=3.000  
 MMX    -  -0.211 usec       PSNR=9.611  MSE=7.000  
 MMXEXT -  -0.256 usec       PSNR=9.611  MSE=7.000  
 3DNOW  -  2.855 usec       PSNR=13.291  MSE=3.000  
 3DNOWE -  1.429 usec       PSNR=13.291  MSE=3.000  
   
  ===  test block motion ===  
 PLAINC - interp- h-round0 0.538 usec       crc32=0x115381ba  
 PLAINC -           round1 0.527 usec       crc32=0x2b1f528f  
 PLAINC - interp- v-round0 0.554 usec       crc32=0x423cdcc7  
 PLAINC -           round1 0.551 usec       crc32=0x42202efe  
 PLAINC - interp-hv-round0 1.041 usec       crc32=0xd198d387  
 PLAINC -           round1 1.038 usec       crc32=0x9ecfd921  
  ---  
 MMX    - interp- h-round0 0.051 usec       crc32=0x115381ba  
 MMX    -           round1 0.053 usec       crc32=0x2b1f528f  
 MMX    - interp- v-round0 0.048 usec       crc32=0x423cdcc7  
 MMX    -           round1 0.048 usec       crc32=0x42202efe  
 MMX    - interp-hv-round0 0.074 usec       crc32=0xd198d387  
 MMX    -           round1 0.073 usec       crc32=0x9ecfd921  
  ---  
 MMXEXT - interp- h-round0 0.020 usec       crc32=0x115381ba  
 MMXEXT -           round1 0.025 usec       crc32=0x2b1f528f  
 MMXEXT - interp- v-round0 0.016 usec       crc32=0x423cdcc7  
 MMXEXT -           round1 0.024 usec       crc32=0x42202efe  
 MMXEXT - interp-hv-round0 0.037 usec       crc32=0xd198d387  
 MMXEXT -           round1 0.037 usec       crc32=0x9ecfd921  
  ---  
 3DNOW  - interp- h-round0 0.020 usec       crc32=0x115381ba  
 3DNOW  -           round1 0.029 usec       crc32=0x2b1f528f  
 3DNOW  - interp- v-round0 0.016 usec       crc32=0x423cdcc7  
 3DNOW  -           round1 0.024 usec       crc32=0x42202efe  
 3DNOW  - interp-hv-round0 0.038 usec       crc32=0xd198d387  
 3DNOW  -           round1 0.039 usec       crc32=0x9ecfd921  
  ---  
 3DNOWE - interp- h-round0 0.020 usec       crc32=0x115381ba  
 3DNOWE -           round1 0.024 usec       crc32=0x2b1f528f  
 3DNOWE - interp- v-round0 0.016 usec       crc32=0x423cdcc7  
 3DNOWE -           round1 0.021 usec       crc32=0x42202efe  
 3DNOWE - interp-hv-round0 0.037 usec       crc32=0xd198d387  
 3DNOWE -           round1 0.036 usec       crc32=0x9ecfd921  
  ---  
   
  ======  test SAD ======  
 PLAINC - sad8    0.505 usec       sad=3776  
 PLAINC - sad16   1.941 usec       sad=27214  
 PLAINC - sad16bi 4.925 usec       sad=26274  
 PLAINC - dev16   4.254 usec       sad=3344  
  ---  
 MMX    - sad8    0.036 usec       sad=3776  
 MMX    - sad16   0.107 usec       sad=27214  
 MMX    - sad16bi 0.259 usec       sad=26274  
 MMX    - dev16   0.187 usec       sad=3344  
  ---  
 MMXEXT - sad8    0.016 usec       sad=3776  
 MMXEXT - sad16   0.050 usec       sad=27214  
 MMXEXT - sad16bi 0.060 usec       sad=26274  
 MMXEXT - dev16   0.086 usec       sad=3344  
  ---  
 3DNOW  - sad8    0.506 usec       sad=3776  
 3DNOW  - sad16   1.954 usec       sad=27214  
 3DNOW  - sad16bi 0.119 usec       sad=26274  
 3DNOW  - dev16   4.252 usec       sad=3344  
  ---  
 3DNOWE - sad8    0.017 usec       sad=3776  
 3DNOWE - sad16   0.038 usec       sad=27214  
 3DNOWE - sad16bi 0.052 usec       sad=26274  
 3DNOWE - dev16   0.067 usec       sad=3344  
  ---  
   
  ===  test transfer ===  
 PLAINC - 8to16     0.603 usec       crc32=0x115814bb  
 PLAINC - 16to8     1.077 usec       crc32=0xee7ccbb4  
 PLAINC - 8to8      0.679 usec       crc32=0xd37b3295  
 PLAINC - 16to8add  1.341 usec       crc32=0xdd817bf4  
 PLAINC - 8to16sub  1.566 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23  
 PLAINC - 8to16sub2 2.206 usec       crc32=0x99b6c4c7  
  ---  
 MMX    - 8to16     -0.025 usec       crc32=0x115814bb  
 MMX    - 16to8     -0.049 usec       crc32=0xee7ccbb4  
 MMX    - 8to8      0.014 usec       crc32=0xd37b3295  
 MMX    - 16to8add  0.011 usec       crc32=0xdd817bf4  
 MMX    - 8to16sub  0.108 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23  
 MMX    - 8to16sub2 0.164 usec       crc32=0x99b6c4c7  
  ---  
 MMXEXT - 8to16     -0.054 usec       crc32=0x115814bb  
 MMXEXT - 16to8     0.010 usec       crc32=0xee7ccbb4  
 MMXEXT - 8to8      0.015 usec       crc32=0xd37b3295  
 MMXEXT - 16to8add  0.008 usec       crc32=0xdd817bf4  
 MMXEXT - 8to16sub  0.263 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23  
 MMXEXT - 8to16sub2 0.178 usec       crc32=0x99b6c4c7  
  ---  
 3DNOW  - 8to16     0.666 usec       crc32=0x115814bb  
 3DNOW  - 16to8     1.078 usec       crc32=0xee7ccbb4  
 3DNOW  - 8to8      0.665 usec       crc32=0xd37b3295  
 3DNOW  - 16to8add  1.365 usec       crc32=0xdd817bf4  
 3DNOW  - 8to16sub  1.356 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23  
 3DNOW  - 8to16sub2 2.098 usec       crc32=0x99b6c4c7  
  ---  
 3DNOWE - 8to16     -0.024 usec       crc32=0x115814bb  
 3DNOWE - 16to8     0.010 usec       crc32=0xee7ccbb4  
 3DNOWE - 8to8      0.014 usec       crc32=0xd37b3295  
 3DNOWE - 16to8add  0.016 usec       crc32=0xdd817bf4  
 3DNOWE - 8to16sub  -0.000 usec       crc32(1)=0xa1e07163 crc32(2)=0xd86c5d23  
 3DNOWE - 8to16sub2 -0.031 usec       crc32=0x99b6c4c7  
  ---  
   
  =====  test quant =====  
 PLAINC -   quant_mpeg_intra 98.631 usec       crc32=0xfd6a21a4  
 PLAINC -   quant_mpeg_inter 104.876 usec       crc32=0xf6de7757  
 PLAINC - dequant_mpeg_intra 50.285 usec       crc32=0x2def7bc7  
 PLAINC - dequant_mpeg_inter 58.316 usec       crc32=0xd878c722  
 PLAINC -   quant_h263_intra 33.803 usec       crc32=0x2eba9d43  
 PLAINC -   quant_h263_inter 45.411 usec       crc32=0xbd315a7e  
 PLAINC - dequant_h263_intra 39.302 usec       crc32=0x9841212a  
 PLAINC - dequant_h263_inter 44.124 usec       crc32=0xe7df8fba  
  ---  
 MMX    -   quant_mpeg_intra 4.273 usec       crc32=0xdacabdb6 | ERROR  
 MMX    -   quant_mpeg_inter 3.576 usec       crc32=0x72883ab6 | ERROR  
 MMX    - dequant_mpeg_intra 3.793 usec       crc32=0x2def7bc7  
 MMX    - dequant_mpeg_inter 4.808 usec       crc32=0xd878c722  
 MMX    -   quant_h263_intra 2.881 usec       crc32=0x2eba9d43  
 MMX    -   quant_h263_inter 2.550 usec       crc32=0xbd315a7e  
 MMX    - dequant_h263_intra 2.974 usec       crc32=0x9841212a  
 MMX    - dequant_h263_inter 2.906 usec       crc32=0xe7df8fba  
  ---  
 MMXEXT -   quant_mpeg_intra 4.221 usec       crc32=0xfd6a21a4  
 MMXEXT -   quant_mpeg_inter 4.339 usec       crc32=0xf6de7757  
 MMXEXT - dequant_mpeg_intra 3.802 usec       crc32=0x2def7bc7  
 MMXEXT - dequant_mpeg_inter 4.821 usec       crc32=0xd878c722  
 MMXEXT -   quant_h263_intra 2.884 usec       crc32=0x2eba9d43  
 MMXEXT -   quant_h263_inter 2.554 usec       crc32=0xbd315a7e  
 MMXEXT - dequant_h263_intra 2.728 usec       crc32=0x9841212a  
 MMXEXT - dequant_h263_inter 2.611 usec       crc32=0xe7df8fba  
  ---  
 3DNOW  -   quant_mpeg_intra 98.512 usec       crc32=0xfd6a21a4  
 3DNOW  -   quant_mpeg_inter 104.873 usec       crc32=0xf6de7757  
 3DNOW  - dequant_mpeg_intra 50.219 usec       crc32=0x2def7bc7  
 3DNOW  - dequant_mpeg_inter 58.254 usec       crc32=0xd878c722  
 3DNOW  -   quant_h263_intra 33.778 usec       crc32=0x2eba9d43  
 3DNOW  -   quant_h263_inter 41.998 usec       crc32=0xbd315a7e  
 3DNOW  - dequant_h263_intra 39.344 usec       crc32=0x9841212a  
 3DNOW  - dequant_h263_inter 43.607 usec       crc32=0xe7df8fba  
  ---  
 3DNOWE -   quant_mpeg_intra 98.490 usec       crc32=0xfd6a21a4  
 3DNOWE -   quant_mpeg_inter 104.889 usec       crc32=0xf6de7757  
 3DNOWE - dequant_mpeg_intra 3.277 usec       crc32=0x2def7bc7  
 3DNOWE - dequant_mpeg_inter 4.485 usec       crc32=0xd878c722  
 3DNOWE -   quant_h263_intra 1.882 usec       crc32=0x2eba9d43  
 3DNOWE -   quant_h263_inter 2.246 usec       crc32=0xbd315a7e  
 3DNOWE - dequant_h263_intra 3.457 usec       crc32=0x9841212a  
 3DNOWE - dequant_h263_inter 3.275 usec       crc32=0xe7df8fba  
  ---  
   
  =====  test cbp =====  
 PLAINC -   calc_cbp#1 0.168 usec       cbp=0x15  
 PLAINC -   calc_cbp#2 0.168 usec       cbp=0x38  
 PLAINC -   calc_cbp#3 0.157 usec       cbp=0x0f  
 PLAINC -   calc_cbp#4 0.235 usec       cbp=0x05  
  ---  
 MMX    -   calc_cbp#1 0.070 usec       cbp=0x15  
 MMX    -   calc_cbp#2 0.062 usec       cbp=0x38  
 MMX    -   calc_cbp#3 0.062 usec       cbp=0x0f  
 MMX    -   calc_cbp#4 0.061 usec       cbp=0x05  
  ---  
 MMXEXT -   calc_cbp#1 0.062 usec       cbp=0x15  
 MMXEXT -   calc_cbp#2 0.061 usec       cbp=0x38  
 MMXEXT -   calc_cbp#3 0.061 usec       cbp=0x0f  
 MMXEXT -   calc_cbp#4 0.061 usec       cbp=0x05  
  ---  
 3DNOW  -   calc_cbp#1 0.168 usec       cbp=0x15  
 3DNOW  -   calc_cbp#2 0.168 usec       cbp=0x38  
 3DNOW  -   calc_cbp#3 0.157 usec       cbp=0x0f  
 3DNOW  -   calc_cbp#4 0.238 usec       cbp=0x05  
  ---  
 3DNOWE -   calc_cbp#1 0.049 usec       cbp=0x15  
 3DNOWE -   calc_cbp#2 0.049 usec       cbp=0x38  
 3DNOWE -   calc_cbp#3 0.049 usec       cbp=0x0f  
 3DNOWE -   calc_cbp#4 0.049 usec       cbp=0x05  
  ---  
   
   
 NB: If a function isn't optimised for a specific set of intructions,  
     a C function is used instead. So don't panic if some functions  
     may appear to be slow.  
   
 NB: MMX mpeg4 quantization is known to have very small errors (+/-1 magnitude)  
     for 1 or 2 coefficients a block. This is mainly caused by the fact the unit  
     test goes far behind the usual limits of real encoding. Please do not report  
     this error to the developers  
   
 *********************************************************************/  
Legend:
Removed from v.1382  
changed lines
  Added in v.1620
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4