[svn] / branches / dev-api-4 / xvidcore / examples / xvid_bench.c Repository:
ViewVC logotype

Diff of /branches/dev-api-4/xvidcore/examples/xvid_bench.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/xvidcore/examples/xvid_bench.c revision 279, Wed Jul 10 13:23:29 2002 UTC branches/dev-api-4/xvidcore/examples/xvid_bench.c revision 1060, Tue Jun 10 09:14:48 2003 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.9.2.3 2003-06-10 09:14:48 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 <sys/time.h>  // for gettimeofday  #include <string.h>    /* for memset */
 #include <string.h>    // for memset  
40  #include <assert.h>  #include <assert.h>
41    
42    #ifndef WIN32
43    #include <sys/time.h>   /* for gettimeofday */
44    #else
45    #include <time.h>
46    #endif
47    
48    
49  #include "xvid.h"  #include "xvid.h"
50    
51  // inner guts  // inner guts
# Line 56  Line 63 
63  #include "bitstream/cbp.h"  #include "bitstream/cbp.h"
64    
65  #include <math.h>  #include <math.h>
66  const int speed_ref = 100;  // on slow machines, decrease this value  
67    #ifndef M_PI
68    #define M_PI            3.14159265358979323846
69    #endif
70    
71    const int speed_ref = 100;  /* on slow machines, decrease this value */
72    
73  /*********************************************************************  /*********************************************************************
74   * misc   * misc
# Line 65  Line 77 
77   /* returns time in micro-s*/   /* returns time in micro-s*/
78  double gettime_usec()  double gettime_usec()
79  {  {
80    #ifndef WIN32
81    struct timeval  tv;    struct timeval  tv;
82    gettimeofday(&tv, 0);    gettimeofday(&tv, 0);
83    return tv.tv_sec*1.0e6 + tv.tv_usec;    return tv.tv_sec*1.0e6 + tv.tv_usec;
84    #else
85            clock_t clk;
86            clk = clock();
87            return clk * 1000000 / CLOCKS_PER_SEC;
88    #endif
89  }  }
90    
91   /* returns squared deviates (mean(v*v)-mean(v)^2) of a 8x8 block */   /* returns squared deviates (mean(v*v)-mean(v)^2) of a 8x8 block */
# Line 102  Line 120 
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_3DNOWEXT }
123  , { "IA64  ", XVID_CPU_IA64 }  //, { "IA64  ", XVID_CPU_IA64 }
124  //, { "TSC   ", XVID_CPU_TSC }  //, { "TSC   ", XVID_CPU_TSC }
125  , { 0, 0 } }    , { 0, 0 } };
126    
127  , cpu_short_list[] =  CPU  cpu_short_list[] =
128  { { "PLAINC", 0 }  { { "PLAINC", 0 }
129  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
130  //, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }  //, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }
131  , { "IA64  ", XVID_CPU_IA64 }  //, { "IA64  ", XVID_CPU_IA64 }
132  , { 0, 0 } }    , { 0, 0 } };
133    
134  , cpu_short_list2[] =  CPU cpu_short_list2[] =
135  { { "PLAINC", 0 }  { { "PLAINC", 0 }
136  , { "MMX   ", XVID_CPU_MMX }  , { "MMX   ", XVID_CPU_MMX }
137  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }
# Line 123  Line 141 
141  int init_cpu(CPU *cpu)  int init_cpu(CPU *cpu)
142  {  {
143    int xerr, cpu_type;    int xerr, cpu_type;
144    XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
145    
146    cpu_type = check_cpu_features() & cpu->cpu;    cpu_type = check_cpu_features() & cpu->cpu;
147            memset(&xinit, 0, sizeof(xinit));
148    xinit.cpu_flags = cpu_type | XVID_CPU_FORCE;    xinit.cpu_flags = cpu_type | XVID_CPU_FORCE;
149    //    xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.version = XVID_VERSION;
150    xerr = xvid_init(NULL, 0, &xinit, NULL);          xerr = xvid_global(NULL, 0, &xinit, NULL);
151    if (cpu->cpu>0 && (cpu_type==0 || xerr!=XVID_ERR_OK)) {          if (cpu->cpu>0 && (cpu_type==0 || xerr==XVID_ERR_FAIL)) {
152      printf( "%s - skipped...\n", cpu->name );      printf( "%s - skipped...\n", cpu->name );
153      return 0;      return 0;
154    }    }
# Line 285  Line 304 
304    const int nb_tests = 2000*speed_ref;    const int nb_tests = 2000*speed_ref;
305    CPU *cpu;    CPU *cpu;
306    const uint8_t Src0[16*9] = {    const uint8_t Src0[16*9] = {
307          // try to have every possible combinaison of rounding...                  /* try to have every possible combinaison of rounding... */
308        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
309      , 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
310      , 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
# Line 335  Line 354 
354      if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );      if (iCrc!=8103) printf( "*** CRC ERROR! ***\n" );
355    
356    
357         // this is a new function, as of 06.06.2002                  /* this is a new function, as of 06.06.2002 */
358  #if 0  #if 0
359      TEST_MB2(interpolate8x8_avrg);      TEST_MB2(interpolate8x8_avrg);
360      printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );      printf( "%s - interpolate8x8_c %.3f usec       iCrc=%d\n", cpu->name, t, iCrc );
# Line 511  Line 530 
530    
531    printf( "\n =====  test quant =====\n" );    printf( "\n =====  test quant =====\n" );
532    
533      // we deliberately enfringe the norm's specified range [-127,127],  /* we deliberately enfringe the norm's specified range [-127,127], */
534      // to test the robustness of the iquant module  /* to test the robustness of the iquant module */
535    for(i=0; i<64; ++i) {    for(i=0; i<64; ++i) {
536      Src[i] = 1 + (i-32) * (i&6);      Src[i] = 1 + (i-32) * (i&6);
537      Dst[i] = 0;      Dst[i] = 0;
# Line 599  Line 618 
618    printf( "\n =====  test cbp =====\n" );    printf( "\n =====  test cbp =====\n" );
619    
620    for(i=0; i<6*64; ++i) {    for(i=0; i<6*64; ++i) {
621      Src1[i] = (i*i*3/8192)&(i/64)&1;  // 'random'                  Src1[i] = (i*i*3/8192)&(i/64)&1;  /* 'random' */
622      Src2[i] = (i<3*64);               // half-full                  Src2[i] = (i<3*64);               /* half-full */
623      Src3[i] = ((i+32)>3*64);      Src3[i] = ((i+32)>3*64);
624      Src4[i] = (i==(3*64+2) || i==(5*64+9));      Src4[i] = (i==(3*64+2) || i==(5*64+9));
625    }    }
# Line 755  Line 774 
774    }    }
775  }  }
776    
777  //////////////////////////////////////////////////////////  ///* ////////////////////////////////////////////////////// */
778  /* Pseudo-random generator specified by IEEE 1180 */  /* Pseudo-random generator specified by IEEE 1180 */
779    
780  static long ieee_seed = 1;  static long ieee_seed = 1;
# Line 842  Line 861 
861    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 };
862    int Loops = 10000;    int Loops = 10000;
863    int i, m, n;    int i, m, n;
864    short Blk0[64];     // reference          short Blk0[64];     /* reference */
865    short Blk[64], iBlk[64];    short Blk[64], iBlk[64];
866    short Ref_FDCT[64];    short Ref_FDCT[64];
867    short Ref_IDCT[64];    short Ref_IDCT[64];
868    
869    STATS_8x8 FStats; // forward dct stats          STATS_8x8 FStats; /* forward dct stats */
870    STATS_8x8 IStats; // inverse dct stats          STATS_8x8 IStats; /* inverse dct stats */
871    
872    CPU *cpu;    CPU *cpu;
873    
# Line 871  Line 890 
890        for(i=0; i<64; ++i)        for(i=0; i<64; ++i)
891          Blk0[i] = (short)ieee_rand(Min,Max) * Sign;          Blk0[i] = (short)ieee_rand(Min,Max) * Sign;
892    
893          // hmm, I'm not quite sure this is exactly                          /* hmm, I'm not quite sure this is exactly */
894          // the tests described in the norm. check...                          /* the tests described in the norm. check... */
895    
896        memcpy(Ref_FDCT, Blk0, 64*sizeof(short));        memcpy(Ref_FDCT, Blk0, 64*sizeof(short));
897        ref_fdct(Ref_FDCT);        ref_fdct(Ref_FDCT);
# Line 899  Line 918 
918    
919      printf( "\n  -- FDCT report --\n" );      printf( "\n  -- FDCT report --\n" );
920  //    print_stats(&FStats);  //    print_stats(&FStats);
921      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 */
922    
923      for(i=0; i<64; i++) Blk[i] = 0;      for(i=0; i<64; i++) Blk[i] = 0;
924      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
# Line 921  Line 940 
940    
941  void test_dct_saturation(int Min, int Max)  void test_dct_saturation(int Min, int Max)
942  {  {
943      // test behaviour on input range fringe  /* test behaviour on input range fringe */
944    
945    int i, n, p;    int i, n, p;
946    CPU *cpu;    CPU *cpu;
947  //  const short IDCT_MAX =  2047;  // 12bits input  //  const short IDCT_MAX =  2047;  /* 12bits input */
948  //  const short IDCT_MIN = -2048;  //  const short IDCT_MIN = -2048;
949  //  const short IDCT_OUT =   256;  // 9bits ouput  //  const short IDCT_OUT =   256;  /* 9bits ouput */
950    const int Partitions = 4;    const int Partitions = 4;
951    const int Loops = 10000 / Partitions;    const int Loops = 10000 / Partitions;
952    
# Line 944  Line 963 
963      printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",      printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",
964        cpu->name, Min, Max );        cpu->name, Min, Max );
965    
966                // FDCT tests //                  /* FDCT tests // */
967    
968      init_stats(&Stats);      init_stats(&Stats);
969    
970        // test each computation channels separately                  /* test each computation channels separately */
971      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;
972      ref_fdct(Blk0);      ref_fdct(Blk0);
973      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
# Line 959  Line 978 
978      emms(); fdct(Blk); emms();      emms(); fdct(Blk); emms();
979      store_stats(&Stats, Blk, Blk0);      store_stats(&Stats, Blk, Blk0);
980    
981        // randomly saturated inputs                  /* randomly saturated inputs */
982      for(p=0; p<Partitions; ++p)      for(p=0; p<Partitions; ++p)
983      {      {
984        for(n=0; n<Loops; ++n)        for(n=0; n<Loops; ++n)
# Line 975  Line 994 
994      report_stats(&Stats, 0);      report_stats(&Stats, 0);
995    
996    
997                // IDCT tests //                  /* IDCT tests // */
998  #if 0  #if 0
999        // no finished yet                  /* no finished yet */
1000    
1001      init_stats(&Stats);      init_stats(&Stats);
1002    
1003      // test each computation channel separately  /* test each computation channel separately */
1004      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;
1005      ref_idct(Blk0);      ref_idct(Blk0);
1006      emms(); idct(Blk); emms();      emms(); idct(Blk); emms();
# Line 994  Line 1013 
1013      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); }
1014      store_stats(&Stats, Blk, Blk0);      store_stats(&Stats, Blk, Blk0);
1015    
1016        // randomly saturated inputs                  /* randomly saturated inputs */
1017      for(p=0; p<Partitions; ++p)      for(p=0; p<Partitions; ++p)
1018      {      {
1019        for(n=0; n<Loops; ++n)        for(n=0; n<Loops; ++n)
# Line 1024  Line 1043 
1043    FILE *f = 0;    FILE *f = 0;
1044    void *dechandle = 0;    void *dechandle = 0;
1045    int xerr;    int xerr;
1046          XVID_INIT_PARAM xinit;          xvid_gbl_init_t xinit;
1047          XVID_DEC_PARAM xparam;          xvid_dec_create_t xparam;
1048          XVID_DEC_FRAME xframe;          xvid_dec_frame_t xframe;
1049          double t = 0.;          double t = 0.;
1050          int nb = 0;          int nb = 0;
1051    uint8_t *buf = 0;    uint8_t *buf = 0;
# Line 1034  Line 1053 
1053    int buf_size, pos;    int buf_size, pos;
1054    uint32_t chksum = 0;    uint32_t chksum = 0;
1055    
1056            memset(&xinit, 0, sizeof(xinit));
1057          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;          xinit.cpu_flags = XVID_CPU_MMX | XVID_CPU_FORCE;
1058          xvid_init(NULL, 0, &xinit, NULL);          xinit.version = XVID_VERSION;
1059          printf( "API version: %d, core build:%d\n", xinit.api_version, xinit.core_build);          xvid_global(NULL, 0, &xinit, NULL);
   
1060    
1061            memset(&xparam, 0, sizeof(xparam));
1062          xparam.width = width;          xparam.width = width;
1063          xparam.height = height;          xparam.height = height;
1064            xparam.version = XVID_VERSION;
1065          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);          xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1066          if (xerr!=XVID_ERR_OK) {          if (xerr==XVID_ERR_FAIL) {
1067            printf("can't init decoder (err=%d)\n", xerr);            printf("can't init decoder (err=%d)\n", xerr);
1068            return;            return;
1069          }          }
# Line 1063  Line 1084 
1084    }    }
1085    else printf( "Input size: %d\n", buf_size);    else printf( "Input size: %d\n", buf_size);
1086    
1087    buf = malloc(buf_size); // should be enuf'          buf = malloc(buf_size); /* should be enuf' */
1088    rgb_out = calloc(4, width*height);  // <-room for _RGB24          rgb_out = calloc(4, width*height);  /* <-room for _RGB24 */
1089    if (buf==0 || rgb_out==0) {    if (buf==0 || rgb_out==0) {
1090      printf( "malloc failed!\n" );      printf( "malloc failed!\n" );
1091      goto End;      goto End;
# Line 1079  Line 1100 
1100    pos = 0;    pos = 0;
1101    t = -gettime_usec();    t = -gettime_usec();
1102    while(1) {    while(1) {
1103                    memset(&xframe, 0, sizeof(xframe));
1104                    xframe.version = XVID_VERSION;
1105      xframe.bitstream = buf + pos;      xframe.bitstream = buf + pos;
1106      xframe.length = buf_size - pos;      xframe.length = buf_size - pos;
1107      xframe.image = rgb_out;                  xframe.output.plane[0] = rgb_out;
1108      xframe.stride = width;                  xframe.output.stride[0] = width;
1109      xframe.colorspace = XVID_CSP_RGB24;                  xframe.output.csp = XVID_CSP_BGR;
1110      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);      xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1111      nb++;      nb++;
1112      pos += xframe.length;      pos += xframe.length;
# Line 1094  Line 1117 
1117      }      }
1118      if (pos==buf_size)      if (pos==buf_size)
1119        break;        break;
1120      if (xerr!=XVID_ERR_OK) {                  if (xerr==XVID_ERR_FAIL) {
1121            printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);            printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1122            break;            break;
1123          }          }
# Line 1110  Line 1133 
1133    if (buf!=0) free(buf);    if (buf!=0) free(buf);
1134    if (dechandle!=0) {    if (dechandle!=0) {
1135      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);      xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1136      if (xerr!=XVID_ERR_OK)                  if (xerr==XVID_ERR_FAIL)
1137              printf("destroy-decoder failed (err=%d)!\n", xerr);              printf("destroy-decoder failed (err=%d)!\n", xerr);
1138    }    }
1139    if (f!=0) fclose(f);    if (f!=0) fclose(f);
Legend:
Removed from v.279  
changed lines
  Added in v.1060
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4