[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 1616, Tue May 17 21:03:32 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.18 2005-05-17 21:03:32 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 657  Line 657 
657  }                                           \  }                                           \
658  t = (gettime_usec()-t-overhead)/nb_tests/qm  t = (gettime_usec()-t-overhead)/nb_tests/qm
659    
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;
# Line 667  Line 698 
698          CPU *cpu;          CPU *cpu;
699          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);          DECLARE_ALIGNED_MATRIX(Src, 8, 8, int16_t, 16);
700          DECLARE_ALIGNED_MATRIX(Dst, 8, 8, int16_t, 16);          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" );
# Line 687  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;
# Line 741  Line 779 
779  }  }
780    
781  /*********************************************************************  /*********************************************************************
782     * test distortion operators
783     *********************************************************************/
784    
785    static void ieee_reseed(long s);
786    static long ieee_rand(int Min, int Max);
787    
788    #define TEST_SSE(FUNCTION, SRC1, SRC2, STRIDE) \
789      do { \
790        t = gettime_usec(); \
791        tst = nb_tests; \
792        while((tst--)>0) sse = (FUNCTION)((SRC1), (SRC2), (STRIDE)); \
793        emms(); \
794        t = (gettime_usec() - t)/(double)nb_tests;  \
795      } while(0)
796    
797    
798    void test_sse()
799    {
800            const int nb_tests = 100000*speed_ref;
801            int i;
802            CPU *cpu;
803            DECLARE_ALIGNED_MATRIX(Src1, 8, 8, int16_t, 16);
804            DECLARE_ALIGNED_MATRIX(Src2, 8, 8, int16_t, 16);
805            DECLARE_ALIGNED_MATRIX(Src3, 8, 8, int16_t, 16);
806            DECLARE_ALIGNED_MATRIX(Src4, 8, 8, int16_t, 16);
807    
808            printf( "\n =====  test sse =====\n" );
809    
810            ieee_reseed(1);
811            for(i=0; i<64; ++i) {
812                    Src1[i] = ieee_rand(-2048, 2047);
813                    Src2[i] = ieee_rand(-2048, 2047);
814                    Src3[i] = ieee_rand(-2048, 2047);
815                    Src4[i] = ieee_rand(-2048, 2047);
816            }
817    
818            for(cpu = cpu_list; cpu->name!=0; ++cpu)
819            {
820                    double t;
821                    int tst, sse;
822    
823                    if (!init_cpu(cpu))
824                            continue;
825    
826                    /* 16 bit element blocks */
827                    TEST_SSE(sse8_16bit, Src1, Src2, 16);
828                    printf("%s -   sse8_16bit#1 %.3f usec       sse=%d %s\n",
829                               cpu->name, t, sse, (sse!=182013834)?"| ERROR": "");
830                    TEST_SSE(sse8_16bit, Src1, Src3, 16);
831                    printf("%s -   sse8_16bit#2 %.3f usec       sse=%d %s\n",
832                               cpu->name, t, sse, (sse!=142545203)?"| ERROR": "");
833                    TEST_SSE(sse8_16bit, Src1, Src4, 16);
834                    printf("%s -   sse8_16bit#3 %.3f usec       sse=%d %s\n",
835                               cpu->name, t, sse, (sse!=146340935)?"| ERROR": "");
836                    TEST_SSE(sse8_16bit, Src2, Src3, 16);
837                    printf("%s -   sse8_16bit#4 %.3f usec       sse=%d %s\n",
838                               cpu->name, t, sse, (sse!=130136661)?"| ERROR": "");
839                    TEST_SSE(sse8_16bit, Src2, Src4, 16);
840                    printf("%s -   sse8_16bit#5 %.3f usec       sse=%d %s\n",
841                               cpu->name, t, sse, (sse!=136870353)?"| ERROR": "");
842                    TEST_SSE(sse8_16bit, Src3, Src4, 16);
843                    printf("%s -   sse8_16bit#6 %.3f usec       sse=%d %s\n",
844                               cpu->name, t, sse, (sse!=164107772)?"| ERROR": "");
845    
846                    /* 8 bit element blocks */
847                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src2, 8);
848                    printf("%s -    sse8_8bit#1 %.3f usec       sse=%d %s\n",
849                               cpu->name, t, sse, (sse!=1356423)?"| ERROR": "");
850                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src3, 8);
851                    printf("%s -    sse8_8bit#2 %.3f usec       sse=%d %s\n",
852                               cpu->name, t, sse, (sse!=1173074)?"| ERROR": "");
853                    TEST_SSE(sse8_8bit, (int8_t*)Src1, (int8_t*)Src4, 8);
854                    printf("%s -    sse8_8bit#3 %.3f usec       sse=%d %s\n",
855                               cpu->name, t, sse, (sse!=1092357)?"| ERROR": "");
856                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src3, 8);
857                    printf("%s -    sse8_8bit#4 %.3f usec       sse=%d %s\n",
858                               cpu->name, t, sse, (sse!=1360239)?"| ERROR": "");
859                    TEST_SSE(sse8_8bit, (int8_t*)Src2, (int8_t*)Src4, 8);
860                    printf("%s -    sse8_8bit#5 %.3f usec       sse=%d %s\n",
861                               cpu->name, t, sse, (sse!=1208414)?"| ERROR": "");
862                    TEST_SSE(sse8_8bit, (int8_t*)Src3, (int8_t*)Src4, 8);
863                    printf("%s -    sse8_8bit#6 %.3f usec       sse=%d %s\n",
864                               cpu->name, t, sse, (sse!=1099285)?"| ERROR": "");
865    
866                    printf(" ---\n");
867            }
868    }
869    
870    /*********************************************************************
871   * test non-zero AC counting   * test non-zero AC counting
872   *********************************************************************/   *********************************************************************/
873    
# Line 781  Line 908 
908                          continue;                          continue;
909    
910                  TEST_CBP(calc_cbp, Src1);                  TEST_CBP(calc_cbp, Src1);
911                  printf("%s -   calc_cbp#1 %.3f usec       cbp=0x%02x\n",                  printf("%s -   calc_cbp#1 %.3f usec       cbp=0x%02x %s\n",
912                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");                             cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
913                  TEST_CBP(calc_cbp, Src2);                  TEST_CBP(calc_cbp, Src2);
914                  printf("%s -   calc_cbp#2 %.3f usec       cbp=0x%02x\n",                  printf("%s -   calc_cbp#2 %.3f usec       cbp=0x%02x %s\n",
915                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");                             cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
916                  TEST_CBP(calc_cbp, Src3);                  TEST_CBP(calc_cbp, Src3);
917                  printf("%s -   calc_cbp#3 %.3f usec       cbp=0x%02x\n",                  printf("%s -   calc_cbp#3 %.3f usec       cbp=0x%02x %s\n",
918                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );                             cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
919                  TEST_CBP(calc_cbp, Src4);                  TEST_CBP(calc_cbp, Src4);
920                  printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x\n",                  printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
921                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );                             cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
922                  printf( " --- \n" );                  printf( " --- \n" );
923          }          }
# Line 1187  Line 1314 
1314   * measure raw decoding speed   * measure raw decoding speed
1315   *********************************************************************/   *********************************************************************/
1316    
1317  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)
1318  {  {
1319          FILE *f = 0;          FILE *f = 0;
1320          void *dechandle = 0;          void *dechandle = 0;
# Line 1198  Line 1325 
1325          double t = 0.;          double t = 0.;
1326          int nb = 0;          int nb = 0;
1327          uint8_t *buf = 0;          uint8_t *buf = 0;
1328          uint8_t *rgb_out = 0;          uint8_t *yuv_out = 0;
1329          int buf_size, pos;          int buf_size, pos;
1330          uint32_t chksum = 0;          uint32_t chksum = 0;
1331            int bps = (width+31) & ~31;
1332    
1333          memset(&xinit, 0, sizeof(xinit));          memset(&xinit, 0, sizeof(xinit));
1334          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = cpu_mask;
1335          xinit.version = XVID_VERSION;          xinit.version = XVID_VERSION;
1336          xvid_global(NULL, 0, &xinit, NULL);          xvid_global(NULL, 0, &xinit, NULL);
1337    
# Line 1213  Line 1341 
1341          xparam.version = XVID_VERSION;          xparam.version = XVID_VERSION;
1342          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1343          if (xerr==XVID_ERR_FAIL) {          if (xerr==XVID_ERR_FAIL) {
1344                  printf("can't init decoder (err=%d)\n", xerr);                  printf("ERROR: can't init decoder (err=%d)\n", xerr);
1345                  return;                  return;
1346          }          }
1347          dechandle = xparam.handle;          dechandle = xparam.handle;
# Line 1221  Line 1349 
1349    
1350          f = fopen(name, "rb");          f = fopen(name, "rb");
1351          if (f==0) {          if (f==0) {
1352                  printf( "can't open file '%s'\n", name);                  printf( "ERROR: can't open file '%s'\n", name);
1353                  return;                  return;
1354          }          }
1355          fseek(f, 0, SEEK_END);          fseek(f, 0, SEEK_END);
1356          buf_size = ftell(f);          buf_size = ftell(f);
1357          fseek(f, 0, SEEK_SET);          fseek(f, 0, SEEK_SET);
1358          if (buf_size<=0) {          if (buf_size<=0) {
1359                  printf("error while stating file\n");                  printf("ERROR: error while stating file\n");
1360                  goto End;                  goto End;
1361          }          }
         else printf( "Input size: %d\n", buf_size);  
1362    
1363          buf = malloc(buf_size); /* should be enuf' */          buf = malloc(buf_size);
1364          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */          yuv_out = calloc(1, bps*height*3/2 + 15);
1365          if (buf==0 || rgb_out==0) {          if (buf==0 || yuv_out==0) {
1366                  printf( "malloc failed!\n" );                  printf( "ERROR: malloc failed!\n" );
1367                  goto End;                  goto End;
1368          }          }
1369    
1370          if (fread(buf, buf_size, 1, f)!=1) {          if (fread(buf, buf_size, 1, f)!=1) {
1371                  printf( "file-read failed\n" );                  printf( "ERROR: file-read failed\n" );
1372                  goto End;                  goto End;
1373          }          }
1374    
# Line 1249  Line 1376 
1376          pos = 0;          pos = 0;
1377          t = -gettime_usec();          t = -gettime_usec();
1378          while(1) {          while(1) {
1379              int y;
1380    
1381                  memset(&xframe, 0, sizeof(xframe));                  memset(&xframe, 0, sizeof(xframe));
1382                  xframe.version = XVID_VERSION;                  xframe.version = XVID_VERSION;
1383                  xframe.bitstream = buf + pos;                  xframe.bitstream = buf + pos;
1384                  xframe.length = buf_size - pos;                  xframe.length = buf_size - pos;
1385                  xframe.output.plane[0] = rgb_out;                  xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
1386                  xframe.output.stride[0] = width;                  xframe.output.plane[1] = xframe.output.plane[0] + bps*height;
1387                  xframe.output.csp = XVID_CSP_BGR;                  xframe.output.plane[2] = xframe.output.plane[1] + bps/2;
1388                    xframe.output.stride[0] = bps;
1389                    xframe.output.stride[1] = bps;
1390                    xframe.output.stride[2] = bps;
1391                    xframe.output.csp = XVID_CSP_I420;
1392                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);                  xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1393                    if (xerr<0) {
1394                            printf("ERROR: decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1395                            break;
1396                    }
1397                    else if (xerr==0)
1398                      break;
1399        else if (verbose>0) printf("#%d %d\n", nb, xerr );
1400    
1401                    pos += xerr;
1402                  nb++;                  nb++;
1403                  pos += xframe.length;  
1404                  if (with_chksum) {      for(y=0; y<height/2; ++y) {
1405                          int k = width*height;                    chksum = calc_crc(xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
1406                          uint32_t *ptr = (uint32_t *)rgb_out;                          chksum = calc_crc(xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
1407                          while(k-->0) chksum += *ptr++;                          chksum = calc_crc(xframe.output.plane[1] + y*bps, width/2, chksum);
1408                            chksum = calc_crc(xframe.output.plane[2] + y*bps, width/2, chksum);
1409                  }                  }
1410                  if (pos==buf_size)                  if (pos==buf_size)
1411                          break;                          break;
                 if (xerr==XVID_ERR_FAIL) {  
                         printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);  
                         break;  
                 }  
1412          }          }
1413          t += gettime_usec();          t += gettime_usec();
1414            if (ref_chksum==0) {
1415          if (t>0.)          if (t>0.)
1416                  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 );
1417          if (with_chksum)    }
1418                  printf("checksum: 0x%.8x\n", chksum);    else {
1419                    printf("FPS:%.1f Checksum: 0x%.8x Expected:0x%.8x | %s\n",
1420                      t>0. ? (float)(nb*1.e6f/t) : 0.f, chksum, ref_chksum, (chksum==ref_chksum) ? "OK" : "ERROR");
1421      }
1422    
1423   End:   End:
1424          if (rgb_out!=0) free(rgb_out);          if (yuv_out!=0) free(yuv_out);
1425          if (buf!=0) free(buf);          if (buf!=0) free(buf);
1426          if (dechandle!=0) {          if (dechandle!=0) {
1427                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);                  xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1428                  if (xerr==XVID_ERR_FAIL)                  if (xerr==XVID_ERR_FAIL)
1429                          printf("destroy-decoder failed (err=%d)!\n", xerr);                          printf("ERROR: destroy-decoder failed (err=%d)!\n", xerr);
1430          }          }
1431          if (f!=0) fclose(f);          if (f!=0) fclose(f);
1432  }  }
# Line 1445  Line 1588 
1588          }          }
1589  #endif  #endif
1590  }  }
1591    /*********************************************************************/
1592    
1593    static uint32_t __inline log2bin_v1(uint32_t value)
1594    {
1595      int n = 0;
1596      while (value) {
1597        value >>= 1;
1598        n++;
1599      }
1600      return n;
1601    }
1602    
1603    static const uint8_t log2_tab_16[256] =  { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
1604    
1605    static uint32_t __inline log2bin_v2(uint32_t value)
1606    {
1607      int n = 0;
1608      if (value & 0xffff0000) {
1609        value >>= 16;
1610        n += 16;
1611      }
1612      if (value & 0xff00) {
1613        value >>= 8;
1614        n += 8;
1615      }
1616      if (value & 0xf0) {
1617        value >>= 4;
1618        n += 4;
1619      }
1620     return n + log2_tab_16[value];
1621    }
1622    
1623    void test_log2bin()
1624    {
1625            const int nb_tests = 3000*speed_ref;
1626      int n, crc1=0, crc2=0;
1627      uint32_t s, s0;
1628      double t1, t2;
1629    
1630      t1 = gettime_usec();
1631      s0 = (int)(t1*31.241);
1632      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1633        crc1 += log2bin_v1(s);
1634      t1 = (gettime_usec()-t1) / nb_tests;
1635    
1636      t2 = gettime_usec();
1637      for(s=s0, n=0; n<nb_tests; ++n, s=(s*12363+31)&0x7fffffff)
1638        crc2 += log2bin_v2(s);
1639      t2 = (gettime_usec() - t2) / nb_tests;
1640      printf( "log2bin_v1: %.3f sec  crc=%d\n", t1, crc1 );
1641      printf( "log2bin_v2: %.3f sec  crc=%d\n", t2, crc2 );
1642      if (crc1!=crc2) printf( " CRC ERROR !\n" );
1643    }
1644    
1645  /*********************************************************************  /*********************************************************************
1646   * main   * main
1647   *********************************************************************/   *********************************************************************/
1648    
1649  int main(int argc, char *argv[])  static void arg_missing(const char *opt)
1650    {
1651      printf( "missing argument after option '%s'\n", opt);
1652      exit(-1);
1653    }
1654    
1655    int main(int argc, const char *argv[])
1656  {  {
1657          int what = 0;          int c, what = 0;
1658          if (argc>1) what = atoi(argv[1]);          int width, height;
1659            uint32_t chksum = 0;
1660      const char * test_bitstream = 0;
1661    
1662            cpu_mask = 0;  // default => will use autodectect
1663            for(c=1; c<argc; ++c)
1664            {
1665              if (!strcmp(argv[c], "-v")) verbose++;
1666              else if (!strcmp(argv[c], "-c"))      cpu_mask = 0 /* PLAIN_C */ | XVID_CPU_FORCE;
1667              else if (!strcmp(argv[c], "-mmx"))    cpu_mask = XVID_CPU_MMX    | XVID_CPU_FORCE;
1668              else if (!strcmp(argv[c], "-mmxext")) cpu_mask = XVID_CPU_MMXEXT | XVID_CPU_MMX | XVID_CPU_FORCE;
1669              else if (!strcmp(argv[c], "-sse2"))   cpu_mask = XVID_CPU_SSE2   | XVID_CPU_MMX | XVID_CPU_FORCE;
1670              else if (!strcmp(argv[c], "-3dnow"))  cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_FORCE;
1671              else if (!strcmp(argv[c], "-3dnowe")) cpu_mask = XVID_CPU_3DNOW  | XVID_CPU_3DNOWEXT | XVID_CPU_FORCE;
1672              else if (!strcmp(argv[c], "-altivec")) cpu_mask = XVID_CPU_ALTIVEC | XVID_CPU_FORCE;
1673              else if (!strcmp(argv[c], "-spd")) {
1674          if (++c==argc) arg_missing( argv[argc-1] );
1675          speed_ref = atoi(argv[c]);
1676        }
1677              else if (argv[c][0]!='-') {
1678                what = atoi(argv[c]);
1679                if (what==9) {
1680                  if (c+4>argc) {
1681                    printf("usage: %s %d bitstream width height (checksum)\n", argv[0], what);
1682                    exit(-1);
1683            }
1684            test_bitstream = argv[++c];
1685                  width  = atoi(argv[++c]);
1686                  height = atoi(argv[++c]);
1687                  if (c+1<argc && argv[c+1][0]!='-') {
1688                    if (sscanf(argv[c+1], "0x%x", &chksum)!=1) {
1689                      printf( "can't read checksum value.\n" );
1690                      exit(-1);
1691              }
1692              else c++;
1693            }
1694    //        printf( "[%s] %dx%d (0x%.8x)\n", test_bitstream, width, height, chksum);
1695          }
1696        }
1697        else {
1698          printf( "unrecognized option '%s'\n", argv[c]);
1699          exit(-1);
1700        }
1701      }
1702    
1703    
1704          if (what==0 || what==1) test_dct();          if (what==0 || what==1) test_dct();
1705          if (what==0 || what==2) test_mb();          if (what==0 || what==2) test_mb();
1706          if (what==0 || what==3) test_sad();          if (what==0 || what==3) test_sad();
1707          if (what==0 || what==4) test_transfer();          if (what==0 || what==4) test_transfer();
1708          if (what==0 || what==5) test_quant();          if (what==0 || what==5) test_quant();
1709          if (what==0 || what==6) test_cbp();          if (what==0 || what==6) test_cbp();
1710            if (what==0 || what==10) test_sse();
1711            if (what==0 || what==11) test_log2bin();
1712    
1713    
1714          if (what==7) {          if (what==7) {
1715                  test_IEEE1180_compliance(-256, 255, 1);                  test_IEEE1180_compliance(-256, 255, 1);
# Line 1471  Line 1721 
1721          }          }
1722          if (what==8) test_dct_saturation(-256, 255);          if (what==8) test_dct_saturation(-256, 255);
1723    
1724          if (what==9) {          if (test_bitstream)
1725                  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));  
         }  
   
1726          if (what==-1) {          if (what==-1) {
1727                  test_dct_precision_diffs();                  test_dct_precision_diffs();
1728                  test_bugs1();                  test_bugs1();
# Line 1489  Line 1730 
1730          if (what==-2)          if (what==-2)
1731                  test_quant_bug();                  test_quant_bug();
1732    
1733          if (what >= 0 && what <= 6) {          if ((what >= 0 && what <= 6) || what == 10) {
1734                  printf("\n\n"                  printf("\n\n"
1735                             "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"
1736                             "    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"
Legend:
Removed from v.1382  
changed lines
  Added in v.1616
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4