test_dsp.cpp

mpeg4编解码器

        Dsp.IDct_Put(Src1, Dst, 8);
        Dsp.IDct_Add(Src1, Dst, 8);
      }
    }
    Dsp.Switch_Off();
    tm.Stop();
    printf( "      Put/Add   \t%.3f s\n", tm.Get_Sec() );
  }


  printf( "=== Sparse_8x4 tests ===\n" );

  for(Rows = 0x00; Rows<=0x0f; ++Rows) {
    SKL_BZERO( Src0[Rows], 64*sizeof(Src0[0][0]) );
    for(j=0; j<4; ++j)
      if (Rows & (1<<8))
        for(i=0; i<4; ++i)
          Src0[Rows][j*8+i] = Rnd.Get_SInt(-2048, 2047);
  }

  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++)
  {
    Skl_Init_Quant_DSP( &Dsp, *Cpu, 0 );
    SKL_PTIMER tm;
    tm.Reset();
    for(n=0; n<CNT*16; ++n) {
      for(int Rows = 0x00; Rows<=0x0f; ++Rows) {
        for(k=0; k<64; ++k) Src1[k] = Src2[k] = Src0[Rows][k];
        Dsp.IDct(Src1);
        Dsp.IDct_Sparse_8x4(Src2);
        for(i=0; i<64; ++i)  CHECKI(Src2[i], Src1[i]);
      }
    }
    Dsp.Switch_Off();
    tm.Stop();
    printf( "- %s - \tSparse 8x4: %.3f s", Dsp.Name, tm.Get_Sec() );
    
    tm.Reset();
    for(n=0; n<CNT*16; ++n) {
      for(Rows = 0x00; Rows<=0x0f; ++Rows) {
        SKL_BYTE Dst[64];
        for(k=0; k<64; ++k) Src1[k] = Src2[k] = Src0[Rows][k];
        Dsp.IDct_Put_8x4(Src1, Dst, 8);
        Dsp.IDct_Add_8x4(Src1, Dst, 8);
      }
    }
    Dsp.Switch_Off();
    tm.Stop();
    printf( "      Put/Add    \t%.3f s\n", tm.Get_Sec() );
  }
}
END_FUNC

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

extern "C" void Skl_Hadamard_Ref(SKL_INT16 *Out);
extern "C" void Skl_Hadamard_C(SKL_INT16 *Out);
extern "C" void Skl_Hadamard_MMX(SKL_INT16 *Out);
extern "C" void Skl_Hadamard_SSE(SKL_INT16 *Out);

#define TEST(FUNC,O,COUNT,S) \
  Rnd.Set_Seed(154);                          \
  printf( "=======%s========\n", S);  \
  for(n=0; n<64; ++n) O[n] = Rnd.Get_Int(256) - 128; FUNC(O); SKL_EMMS; \
  for(n=0; n<8; ++n) { for(i=0; i<8; ++i) printf( "%3d ", O[n*8+i] ); printf( "\n" ); } \
  if (COUNT>0) for(n=0; n<64; ++n) CHECKI(Ref[n],O[n]); \
  { SKL_INT16 Tmp[64]; for(n=0; n<64; ++n) Tmp[n] = Rnd.Get_Int(256) - 128; \
  pTimer.Reset(); for(n=0; n<COUNT; n++) FUNC(Tmp); SKL_EMMS; }; \
  pTimer.Stop(); printf( "   %.3f ms\n", pTimer.Get_mSec() )

TEST_FUNC(Test_Hadamard_8x8)
{
  SKL_INT16 Ref[64], Out[64];
  int n, i;
  SKL_RANDOM Rnd(1324);
  SKL_PTIMER pTimer;
  const int CNT = 500000;

  TEST(Skl_Hadamard_Ref,  Ref,   0, "Ref    ");
  TEST(Skl_Hadamard_C,    Out, CNT, "C      ");
#ifdef SKL_USE_ASM
  TEST(Skl_Hadamard_SSE,  Out, CNT, "SSE    ");
#endif
}
END_FUNC
   
#undef TEST

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

extern "C" SKL_UINT32 Skl_Hadamard_SAD_4x4_Ref(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);
extern "C" SKL_UINT32 Skl_Hadamard_SAD_4x4_C(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);
extern "C" SKL_UINT32 Skl_Hadamard_SAD_4x4_MMX(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);
extern "C" SKL_UINT32 Skl_Hadamard_SAD_8x8_C(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);
extern "C" SKL_UINT32 Skl_Hadamard_SAD_16x8_Field_C(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);
extern "C" SKL_UINT32 Skl_Hadamard_SAD_16x16_C(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);
extern "C" SKL_UINT32 Skl_Hadamard_SAD_8x8_MMX(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);
extern "C" SKL_UINT32 Skl_Hadamard_SAD_16x8_Field_MMX(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);
extern "C" SKL_UINT32 Skl_Hadamard_SAD_16x16_MMX(const SKL_BYTE *Src1, const SKL_BYTE *Src2, SKL_INT32 BpS);

#define TEST(FUNC,COUNT,S) \
  printf( "=======%s========\n", S);  \
  pTimer.Reset(); for(n=0; n<COUNT; n++) FUNC(Ref,Cur,SIZE); \
  Crc =  FUNC(Ref,Cur,SIZE); SKL_EMMS; \
  pTimer.Stop(); printf( "   %.3f ms   Crc=%d\n", pTimer.Get_mSec(), Crc )

TEST_FUNC(Test_Hadamard_SAD)
{
  enum { SIZE=256 };
  SKL_BYTE Ref[16*SIZE], Cur[16*SIZE];
  int n, i;
  SKL_UINT32 Crc;
  SKL_RANDOM Rnd(1324);
  for(i=0; i<16*SIZE;++i) {
    Ref[i] = Rnd.Get_Int(256);
    Cur[i] = Rnd.Get_Int(256);
  }

  SKL_PTIMER pTimer;
  const int CNT = 500000;

  TEST(Skl_Hadamard_SAD_4x4_Ref,  CNT, "4x4-Ref   ");
  TEST(Skl_Hadamard_SAD_4x4_C,    CNT, "4x4-C   ");
  TEST(Skl_Hadamard_SAD_4x4_MMX,  CNT, "4x4-MMX   ");
  TEST(Skl_Hadamard_SAD_8x8_C,    CNT, "8x8-C   ");
  TEST(Skl_Hadamard_SAD_16x16_C,  CNT, "16x16-C   ");
#ifdef SKL_USE_ASM
  TEST(Skl_Hadamard_SAD_8x8_MMX,  CNT, "8x8-MMX   ");
  TEST(Skl_Hadamard_SAD_16x8_Field_MMX,  CNT, "16x8-MMX  ");
  TEST(Skl_Hadamard_SAD_16x8_Field_MMX,  CNT, "16x8-C  ");
  TEST(Skl_Hadamard_SAD_16x16_MMX,CNT, "16x16-MMX ");
#endif
}
END_FUNC

#undef TEST

//////////////////////////////////////////////////////////
// Edges replication

TEST_FUNC(Test_Edges)
{
  SKL_CPU_FEATURE Cpu_List[] = {
    SKL_CPU_C,
    SKL_CPU_X86,
    SKL_CPU_MMX,
    SKL_CPU_SSE,
    SKL_CPU_LAST
  };

  const int W = 320, H = 240, BpS = W+2*16;
  const int YSize = (H+2*16)*BpS;
  const int UVSize = (H/2+2*8)*BpS;
  SKL_BYTE YU[YSize+UVSize];
  SKL_BYTE *YUV[3] = {
    YU+16+16*BpS,
    YU+YSize+8+8*BpS,
    YU+YSize+8+8*BpS +W/2+16 };
  SKL_PTIMER tm;
  const int CNT = 20000;

  SKL_CPU_FEATURE *Cpu;
  for(Cpu=Cpu_List; *Cpu != SKL_CPU_LAST; Cpu++) {
    int i, n, Crc;
    SKL_MB_DSP Dsp;
    Skl_Init_Mb_DSP( &Dsp, *Cpu );
    for(i=0; i<(int)sizeof(YU); ++i) YU[i] = (i*54+23)&0xff;    
    tm.Reset();
    for(n=0; n<CNT; ++n) Dsp.Make_Edges(YUV, W, H, BpS);
    tm.Stop();
    Dsp.Switch_Off();
    for(Crc=0,i=0; i<(int)sizeof(YU); ++i) Crc = ((Crc+YU[i]^i)^(Crc>>8))&0xffff;
    printf( "%s -Make_Edges- :\t%.3f s \tCrc: %d\n", Dsp.Name, tm.Get_Sec(), Crc );
    CHECKI(Crc, 12299);
  }
}
END_FUNC

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

TEST_FUNC(Test_YUV)
{
  SKL_CPU_FEATURE Cpu_List[] = {
    SKL_CPU_C,
    SKL_CPU_MMX,
    SKL_CPU_REF,
    SKL_CPU_LAST
  };
  SKL_YUV_DSP Dsp;

  const int W = 640, H = 480, BpS = W;
  const int YSize = H*BpS;
  const int UVSize = (H/2)*BpS;
  SKL_BYTE YU[YSize+UVSize];
  SKL_BYTE RGB[4*W*H];
  SKL_BYTE *Y = YU;
  SKL_BYTE *U = YU+YSize;
  SKL_BYTE *V = U +W/2;
  SKL_PTIMER tm;
  int i, n;
  const int CNT = 200;

  for(i=0; i<(int)sizeof(YU); ++i) YU[i] = (i*54+23)&0xff;

  for(SKL_CPU_FEATURE *Cpu = Cpu_List; *Cpu!=SKL_CPU_LAST; ++Cpu)
  {
    Skl_Init_YUV_DSP( &Dsp, *Cpu );
    printf( "====== YUV: '%s' ======\n", Dsp.Name );
    SKL_BZERO(RGB, sizeof(RGB));
    tm.Reset();
    for(n=0; n<CNT; ++n) Dsp.YUV_TO_RGB565(RGB, 2*W, Y, U, V, BpS, W, H);
    Dsp.Switch_Off();    
    tm.Stop();
    printf( "YUV_To_RGB565    :\t%.3f s\n", tm.Get_Sec());

    SKL_BZERO(RGB, sizeof(RGB));
    tm.Reset();
    for(n=0; n<CNT; ++n) Dsp.YUV_TO_RGB32(RGB, 4*W, Y, U, V, BpS, W, H);
    Dsp.Switch_Off();    
    tm.Stop();
    printf( "YUV_To_RGB32     :\t%.3f s\n", tm.Get_Sec());
  }
}
END_FUNC

TEST_FUNC(Test_RGB)
{
  SKL_CPU_FEATURE Cpu_List[] = {
    SKL_CPU_C,
    SKL_CPU_MMX,
    SKL_CPU_REF,
    SKL_CPU_LAST
  };

  const int W = 640, H = 480, BpS = W;
  const int YSize = H*BpS;
  const int UVSize = (H/2)*BpS;
  SKL_BYTE YU[YSize+UVSize];
  SKL_BYTE RGB[4*W*H];
  SKL_BYTE *Y = YU;
  SKL_BYTE *U = YU+YSize;
  SKL_BYTE *V = U +W/2;
  SKL_PTIMER tm;
  int i, n;
  const int CNT = 200;
  SKL_YUV_DSP Dsp;

  for(i=0; i<(int)sizeof(RGB); ++i) RGB[i] = (i*54+23)&0xff;

  for(SKL_CPU_FEATURE *Cpu = Cpu_List; *Cpu!=SKL_CPU_LAST; ++Cpu)
  {
    Skl_Init_YUV_DSP( &Dsp, *Cpu );
    printf( "====== RGB: '%s' ======\n", Dsp.Name );

    SKL_BZERO(YU, sizeof(YU));
    tm.Reset();
    for(n=0; n<CNT; ++n) Dsp.RGB24_TO_YUV(Y, U, V, BpS, RGB, 3*W, W, H);
    Dsp.Switch_Off();    
    tm.Stop();
    printf( "RGB24_TO_YUV     :\t%.3f s\n", tm.Get_Sec());

    SKL_BZERO(YU, sizeof(YU));
    tm.Reset();
    for(n=0; n<CNT; ++n) Dsp.RGB565_TO_YUV(Y, U, V, BpS, RGB, 2*W, W, H);
    Dsp.Switch_Off();    
    tm.Stop();
    printf( "RGB565_TO_YUV    :\t%.3f s\n", tm.Get_Sec());

    SKL_BZERO(YU, sizeof(YU));
    tm.Reset();
    for(n=0; n<CNT; ++n) Dsp.RGB32_TO_YUV(Y, U, V, BpS, RGB, 4*W, W, H);
    Dsp.Switch_Off();    
    tm.Stop();
    printf( "RGB32_TO_YUV     :\t%.3f s\n", tm.Get_Sec());
  }
}
END_FUNC

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

#include "skl_2d/skl_btm_cvrt.h"

TEST_FUNC(Test_Cvrt)
{
  const int W = 256*4, H = 256;
  SKL_BYTE Src[W*H], Dst[W*H];
  SKL_UINT32 Tab[4*256];
  SKL_PTIMER tm;
  int i, dIn, dOut, n;
  const int CNT = 500;

  for(i=0; i<4*256*4;++i) ((SKL_BYTE*)Tab)[i] = i | (i<<8) | (i<<16) | (i<<24);

  printf( "====== Converters ======\n" );
  for(dIn=1; dIn<=4; ++dIn) {
    for(dOut=1; dOut<=4; ++dOut) {
      SKL_BZERO(Dst, sizeof(Dst));
      for(i=0; i<W*H;++i) Src[i] = (i*54+23)&0xff;
      tm.Reset();
      for(n=0; n<CNT; ++n) 
        (Skl_Get_Cvrt_Convert_Ops(dIn,dOut))(Dst, W, Src, W, W/4, 256, Tab);
      tm.Stop();
      int Crc = 0;
      for(i=0; i<W*H; ++i) Crc = (((Dst[i]<<3) | (Crc>>3)) + Crc) & 0xffff;
      printf( " RGB%2d => RGB%2d    :\t%.3f s    Crc=0x%x\n", dIn*8, dOut*8, tm.Get_Sec(), Crc);
    }
    printf( " ----- \n" );
  }
}
END_FUNC

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

TEST_FUNC(Test_CPU)
{
  static const char *CPU_Names[] = { "  C ", " X86", " MMX", " SSE", "SSE2" };

  SKL_CPU_FEATURE Cpu = Skl_Detect_CPU_Feature();
  printf( "CPU Detected: [%s]\n", (Cpu<=SKL_CPU_SSE2 ? CPU_Names[Cpu] : "Unknown") );
  
  SKL_CPU_SPECS Specs;
  printf( "Specs infos:\n" );
  Specs.Print_Infos();
}
END_FUNC

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

int main(int argc, char *argv[])
{
  SKL_T_START;

    SKL_TEST( 1,Test_Img_DSP);
    SKL_TEST( 2,Test_Mb_DSP);
    SKL_TEST( 3,Test_Mb_QP_DSP);
    SKL_TEST( 4,Test_GMC_DSP);
    SKL_TEST( 5,Test_Quant_DSP);
    SKL_TEST( 6,Test_Quant_Sparse);
    SKL_TEST( 7,Test_Hadamard_8x8);
    SKL_TEST( 8,Test_Hadamard_SAD);
    SKL_TEST( 9,Test_Edges);
    SKL_TEST(10,Test_YUV);
    SKL_TEST(11,Test_RGB);
    SKL_TEST(12,Test_Cvrt);
    SKL_TEST(13,Test_CPU);

  SKL_T_END;
  SKL_T_RETURN;
}

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