test_dsp.cpp

mpeg4编解码器

/********************************************************
 * Some code. Copyright (C) 2003 by Pascal Massimino.   *
 * All Rights Reserved.      (http://skal.planet-d.net) *
 * For Educational/Academic use ONLY. See 'LICENSE.TXT'.*
 ********************************************************/
/*
 * test_dsp.cpp
 *
 *    DSP tests I
 *
 ********************************************************/

#include "skl_tester.h"
#include "skl_syst/skl_dsp.h"
#include "skl_syst/skl_random.h"
#include "skl_syst/skl_ptimer.h"

extern "C" double fabs(double);

//////////////////////////////////////////////////////////

SKL_CPU_FEATURE Cpu_List[] = {
  SKL_CPU_C,
  SKL_CPU_X86,
  SKL_CPU_MMX,
  SKL_CPU_SSE,
  SKL_CPU_REF,
  SKL_CPU_LAST
};

#define PRINT_NxN(S,I,J,BPS)      \
  { for(j=0; j<J; ++j) {          \
     for(i=0; i<I; ++i)  printf( "%3d ", (int)(S)[i+j*BPS] ); \
     printf( "\n" ); } printf( "-----\n" ); }

//////////////////////////////////////////////////////////

TEST_FUNC(Test_DCT_Ref)
{
  SHOW_FLT_ERROR_ON;
  const int MAX=3;
  const int Sizes[MAX] = { 6, 12, 36 };
  const double Crcs[MAX] = { -3.664200, -2849.800781, 615.346741 };
  SKL_RANDOM Rnd(1324);

  for(int k=0; k<MAX; ++k)
  {
    int N = Sizes[k];
    float In[36], Out[2*36];

    int i;
    for(i=0; i<N; i++)
      In[i] = 1.0f*( Rnd.Get_Float(256.0f) );

    Skl_Generic_IDct_Ref( N, In, Out );

    double Crc = 0.0;
    for(i=0; i<2*N; i++) {
      Crc += Out[i];
//      printf( "#%d Out=%f\n", i, Out[i] );
    }
    CHECKFEPS( Crc, Crcs[k], 1.0e-6f );
  }
}
END_FUNC

//////////////////////////////////////////////////////////

#define TEST1_PROLOG(CNT, OFF)                      \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Img_DSP( &Dsp, *Cpu );                 \
    tm.Reset();                                     \
    for(n=0; n<CNT; ++n)                            \
      for(Crc=0, j=0; j<WIDTH-(OFF); ++j)           \
        for(i=0; i<WIDTH-(OFF); ++i) {              \
          SKL_BYTE *Src2=Src+i+j*WIDTH; (void)Src2; \
          Crc += Dsp.

#define TEST1_EPILOG(CRC0, CALL)                    \
        }                                           \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    Crc /= i*j;                                     \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL); \
    CHECKI( Crc, CRC0 );                            \
  }

#define TEST_IMG_2(CNT, CRC0, D,S, CALL)            \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Img_DSP( &Dsp, *Cpu );                 \
    tm.Reset();                                     \
    for(j=0; j<18; ++j) for(i=0; i<18; ++i)         \
      Src[i+j*WIDTH] = ((i^j)*7-5)&255;             \
    for(i=0; i<8*8; ++i) Dst[i]=255;                \
    for(n=0; n<CNT*10000; ++n) {                    \
      Dsp.CALL((D),8,(S)+1+WIDTH,WIDTH);            \
      /*if (n==0) PRINT_NxN((D), 8,8,8);*/          \
    }                                               \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(Crc=0, j=0; j<8; ++j) for(i=0; i<8; ++i)    \
      Crc += (D)[i+j*8]^i;                          \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL);       \
    CHECKI( Crc, CRC0 );                            \
  }

TEST_FUNC(Test_Img_DSP)
{
  SKL_CPU_FEATURE Cpu_List[] = {
    SKL_CPU_C,
    SKL_CPU_MMX,
    SKL_CPU_SSE,
    SKL_CPU_LAST
  };
  SKL_IMG_DSP Dsp;

  int i, j, n;
  const int CNT1 = 25, CNT2 = 120, CNT3 = 200;
  const int WIDTH = 128;
  const int SIZE = 32;
  SKL_BYTE Dst0[8*8+31];
  SKL_BYTE Src0[WIDTH*WIDTH+31];
  SKL_BYTE *Dst = (SKL_BYTE*)(((SKL_SAFE_INT)Dst0 + 31)&~31);
  SKL_BYTE *Src = (SKL_BYTE*)(((SKL_SAFE_INT)Src0 + 31)&~31);

  SKL_UINT32 Crc;
  for(i=0; i<WIDTH*WIDTH; ++i) Src[i] = i&255;
  SKL_PTIMER tm;
  SKL_CPU_FEATURE *Cpu;

  printf("== SAD  16x16 ==\n");
  TEST1_PROLOG(CNT2, 16) SAD_16x16(Src,Src2,WIDTH); TEST1_EPILOG(23488, SAD_16x16);
  printf("== SAD  16x8  ==\n");
  TEST1_PROLOG(CNT2, 16) SAD_16x8_Field(Src,Src2,WIDTH); TEST1_EPILOG(15296, SAD_16x16);
  printf("== SAD  8 x 8 ==\n");
  TEST1_PROLOG(CNT3, 8) SAD_8x8(Src,Src2,WIDTH); TEST1_EPILOG(6000, SAD_8x8);
  printf("== SAD  16x 7 ==\n");
  TEST1_PROLOG(CNT3, 8) SAD_16x7_Self(Src,WIDTH); TEST1_EPILOG(14336, SAD_16x7_Self);
  printf("== SAD  4x4 ==\n");
  TEST1_PROLOG(CNT2, 4) SAD_4x4(Src,Src2,WIDTH); TEST1_EPILOG(1516, SAD_4x4);

  printf("== SSD  16x16 ==\n");
  TEST1_PROLOG(CNT2, 16) SSD_16x16(Src,Src2,WIDTH)>>8; TEST1_EPILOG(12317, SSD_16x16);
  printf("== SSD  16x8  ==\n");
  TEST1_PROLOG(CNT2, 16) SSD_16x8_Field(Src,Src2,WIDTH)>>8; TEST1_EPILOG(9710, SSD_16x16);
  printf("== SSD  8 x 8 ==\n");
  TEST1_PROLOG(CNT3, 8) SSD_8x8(Src,Src2,WIDTH)>>8; TEST1_EPILOG(3232, SSD_8x8);
  printf("== SSD  4x4 ==\n");
  TEST1_PROLOG(CNT2, 4) SSD_4x4(Src,Src2,WIDTH)>>8; TEST1_EPILOG(828, SSD_4x4);

  printf("== Mean 16x16 ==\n");
  TEST1_PROLOG(CNT2, 16) Mean_16x16(Src,WIDTH); TEST1_EPILOG(71, Mean_16x16);
  printf("== Mean 8 x 8 ==\n");
  TEST1_PROLOG(CNT3, 8) Mean_8x8(Src,WIDTH); TEST1_EPILOG(67, Mean_8x8);
  printf("== Mean 4x4 ==\n");
  TEST1_PROLOG(CNT2, 4) Mean_4x4(Src,WIDTH); TEST1_EPILOG(65, Mean_4x4);

  printf("== Sqr. 16x16 ==\n");
  TEST1_PROLOG(CNT2, 16) Sqr_16x16(Src2,WIDTH); TEST1_EPILOG(21291, Sqr_16x16);
  printf("== Sqr. 8 x 8 ==\n");
  TEST1_PROLOG(CNT3, 8) Sqr_8x8(Src2,WIDTH); TEST1_EPILOG(21429, Sqr_8x8);
  printf("== Sqr. 4x4 ==\n");
  TEST1_PROLOG(CNT2, 4) Sqr_4x4(Src2,WIDTH); TEST1_EPILOG(21507, Sqr_4x4);

  printf("== SAD  W x H ==\n");
  TEST1_PROLOG(CNT1, SIZE) SAD(Src,Src2,SIZE,SIZE,WIDTH); TEST1_EPILOG(89856, SAD);
  printf("== Mean W x H ==\n");
  TEST1_PROLOG(CNT1, SIZE) Mean(Src,SIZE,SIZE,WIDTH); TEST1_EPILOG(79, Mean);

  printf("==  Sqr. Dev  ==\n");
  TEST1_PROLOG(CNT1, SIZE) Square_Dev(Src2,SIZE,SIZE,WIDTH); TEST1_EPILOG(4307, Square_Dev);
  printf("==  Abs. Dev  ==\n");
  TEST1_PROLOG(CNT1, SIZE) Abs_Dev(Src2,SIZE,SIZE,WIDTH); TEST1_EPILOG(65536, Abs_Dev);

  printf("==  Smooth  ==\n");
  TEST_IMG_2(CNT1, 4968, Dst, Src, Smooth_18x18_To_8x8 );
  printf("==  Gradx   ==\n");
  TEST_IMG_2(CNT1, 268, (SKL_INT8*)Dst, Src, Gradx_18x18_To_8x8 );
  printf("==  Grady   ==\n");
  TEST_IMG_2(CNT1, 364, (SKL_INT8*)Dst, Src, Grady_18x18_To_8x8 );
  printf("==  Grad2   ==\n");
  TEST_IMG_2(CNT1, 8490, Dst, Src, Grad2_18x18_To_8x8 );
}
END_FUNC

//////////////////////////////////////////////////////////

#define TEST2(S, CNT, CALL, CRC0)                   \
  printf("== %s ==\n", S);                    \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Mb_DSP( &Dsp, *Cpu );                  \
    tm.Reset();                                     \
    for(n=0; n<CNT; ++n) {                          \
      Rnd.Set_Seed(WIDTH);                          \
      for(i=0; i<16*WIDTH; ++i)                     \
        Dst[i] = (SKL_BYTE)Rnd.Get_Int(256);        \
      for(j=0; j<WIDTH-16-1; ++j)                   \
        for(i=0; i<WIDTH-16-1; ++i) {               \
          SKL_BYTE *Src2=Src+i+j*WIDTH;             \
          Dsp.CALL(Dst,Src2,WIDTH);                 \
        }                                           \
    }                                               \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(Crc=0, j=0; j<8; ++j) for(i=0; i<16; ++i)   \
      Crc += Dst[i+j*WIDTH];                        \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL);       \
    CHECKI( Crc, CRC0 );                            \
  }

#define TEST3(S, CNT, CALL, CRC0)                   \
  printf("== %s ==\n", S);                    \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Mb_DSP( &Dsp, *Cpu );                  \
    tm.Reset();                                     \
    for(n=0; n<CNT*10; ++n) {                       \
      for(i=0; i<16*WIDTH; ++i) Dst[i] = i;         \
      for(i=0; i<5; ++i) {                          \
          SKL_INT16 *Src2=Src6+i*64;                \
          Dsp.CALL(Dst,Src2,WIDTH);                 \
        }                                           \
    }                                               \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(Crc=0, j=0; j<8; ++j) for(i=0; i<16; ++i)   \
      Crc += Dst[i+j*WIDTH]^i^j;                    \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL);       \
    CHECKI( Crc, CRC0 );                            \
  }

#define TEST4(S, CNT, CALL, CRC0)                   \
  printf("== %s ==\n", S);                    \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Mb_DSP( &Dsp, *Cpu );                  \
    tm.Reset();                                     \
    for(n=0; n<CNT; ++n) {                          \
      for(i=0; i<2*64; ++i) Dst16[i] = i;           \
      for(j=0; j<WIDTH-16-1; ++j)                   \
        for(i=0; i<WIDTH-16-1; ++i) {               \
          SKL_BYTE *Src2=Src+i+j*WIDTH;             \
          Dsp.CALL(Dst16,Src2,WIDTH);               \
        }                                           \
    }                                               \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(Crc=0, j=0; j<2*64; ++j) Crc += Dst16[j];   \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL);       \
    CHECKI( Crc, CRC0 );                            \
  }

#define TEST5(S, CNT, CALL, CRC0)                   \
  printf("== %s ==\n", S);                    \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Mb_DSP( &Dsp, *Cpu );                  \
    tm.Reset();                                     \
    for(n=0; n<CNT; ++n) {                          \
      for(j=0; j<WIDTH-16-1; ++j) {                 \
        for(i=0; i<2*64; ++i) Dst16[i] = 20000-i;   \
        for(i=0; i<WIDTH-16-1; ++i) {               \
          SKL_BYTE *Src2=Src+i+j*WIDTH;             \
          Dsp.CALL(Dst16,Src2,WIDTH);               \
        }                                           \
      }                                             \
    }                                               \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(Crc=0, j=0; j<2*64; ++j) Crc += Dst16[j];   \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL);       \
    CHECKI( Crc, CRC0 );                            \
  }

#define TEST6(S, CNT, CALL, CRC0)                   \
  printf("== %s ==\n", S);                    \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Mb_DSP( &Dsp, *Cpu );                  \
    tm.Reset();                                     \
    for(n=0; n<CNT; ++n) {                          \
      for(j=0; j<WIDTH-16-1; ++j) {                 \
        for(i=0; i<2*64; ++i) Dst16[i] = 20000-i;   \
        for(i=0; i<WIDTH-16-1; ++i) {               \
          SKL_BYTE *Src2=Src+i+j*WIDTH;             \
          Dsp.CALL(Dst16, Src, Src2,WIDTH);         \
        }                                           \
      }                                             \
    }                                               \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(Crc=0, j=0; j<2*64; ++j) Crc += Dst16[j];   \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL);       \
    CHECKI( Crc, CRC0 );                            \
  }

#define TEST71(S, CNT, CALL, CRC0)                  \
  printf("== %s ==\n", S);                    \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Mb_DSP( &Dsp, *Cpu );                  \
    tm.Reset();                                     \
    for(i=0; i<4*64; ++i) Src6[i] = i;              \
    Crc = Dsp.CALL(Src6);                           \
    for(n=0; n<700*CNT; ++n) Dsp.CALL(Src6);        \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(j=0; j<4*64; ++j) Crc += (Src6[j]^j);       \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL);       \
    CHECKI( Crc, CRC0 );                            \
  }
#define TEST72(S, CNT, CALL, CRC0)                  \
  printf("== %s ==\n", S);                    \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Mb_DSP( &Dsp, *Cpu );                  \
    tm.Reset();                                     \
    for(n=0; n<700*CNT; ++n) {                      \
      for(i=0; i<4*64; ++i) Src6[i] = i;            \
      Dsp.CALL(Src6);                               \
    }                                               \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(Crc=0,j=0; j<4*64; ++j) Crc += (Src6[j]^j); \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \
      Dsp.Name, tm.Get_Sec(), Crc, Dsp.CALL);       \
    CHECKI( Crc, CRC0 );                            \
  }

#define PRINT16x16(S)                               \
{ for(j=0; j<16; ++j) {                             \
    for(i=0; i<16; ++i)  printf( "%3d ", (int)(S)[i+j*WIDTH] ); \
    printf( "\n" ); } printf("---\n"); }

#define TEST81(S, CNT, CALL, CRC0, SHFT)            \
  printf("== %s ==\n", S);                    \
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {  \
    Skl_Init_Mb_DSP( &Dsp, *Cpu );                  \
    tm.Reset();                                     \
    for(n=0; n<CNT*10; ++n) {                       \
      for(i=0; i<16*WIDTH; ++i) {                   \
        Dst[i] = 128;                               \
        Src6[i] = (SHFT)-(i&0xff);                  \
      }                                             \
      Dsp.CALL(Dst,Src6,WIDTH);                     \
      /*if (n==0) { PRINT16x16(Dst); PRINT16x16(Src6); }*/ \
    }                                               \
    Dsp.Switch_Off();                               \
    tm.Stop();                                      \
    for(Crc=0, j=0; j<16; ++j) for(i=0; i<16; ++i)  \
      Crc += Dst[i+j*WIDTH]^i^j;                    \
    printf( "%s:\t%.3f s \tCrc: %d \tFunc:%p\n", \