idct.cpp

鼎鼎有名的手机mpeg4播放器smart movie－智能影院 解码内核

   BuildWMMXconst8x8addrow(dc);
   BuildWMMXconst8x8addrow(dc);
   dc.FunctionEnd();

dc.PutLabel(l_const8x8sub);
   dc.Rsb(dc.r0, dc.r0, 0);
   dc.Tbcstb(dc.wr0, dc.r0);
   BuildWMMXconst8x8subrow(dc);
   BuildWMMXconst8x8subrow(dc);
   BuildWMMXconst8x8subrow(dc);
   BuildWMMXconst8x8subrow(dc);
   dc.FunctionEnd();
}

//----------------------------
#endif
//----------------------------

void BuildIDCTFunctions(C_dyn_code &dc, bool use_wmmx){

   void *l_MCol8 = BuildMCol8(dc);
   void *l_RowConst = BuildRowConst(dc);
                              //IDCT_Block4x8 (13)
   BuildIDCT_Block4x8(dc, l_MCol8, l_RowConst);
                              //IDCT_Block8x8 (14)
   BuildIDCT_Block8x8(dc, l_MCol8, l_RowConst);
                              //IDCT_Const8x8 (15)
#ifdef USE_IDCT_WMMX
   if(use_wmmx){
      BuildWMMXIDCT_Const8x8(dc);
   }
#endif
   {
                              //implemented in C++, make empty function
      dc.FunctionBegin();
      dc.FunctionEnd();
   }
}

//----------------------------
#else //ARM
//----------------------------
#define W1 2841                 // 2048*sqrt(2)*cos(1*pi/16) 
#define W2 2676                 // 2048*sqrt(2)*cos(2*pi/16) 
#define W3 2408                 // 2048*sqrt(2)*cos(3*pi/16) 
#define W5 1609                 // 2048*sqrt(2)*cos(5*pi/16) 
#define W6 1108                 // 2048*sqrt(2)*cos(6*pi/16) 
#define W7 565                  // 2048*sqrt(2)*cos(7*pi/16) 

#define W1_minus_W7 2276
#define W1_plus_W7 3406
#define W3_minus_W5 799
#define W3_plus_W5 4017
#define W2_minus_W6 1568
#define W2_plus_W6 3784

static void IDCT_Col8(idct_block_t *Blk){
   int x0, x1, x2, x3, x4, x5, x6, x7, x8;
   int x567,x123;

   x0 = Blk[0];
   x4 = Blk[8];
   x3 = Blk[16];
   x7 = Blk[24];
   x1 = Blk[32] << 11;
   x6 = Blk[40];
   x2 = Blk[48];  
   x5 = Blk[56];
   
   x123=x1|x2|x3;
   x567=x5|x6|x7;

   if(!(x123|x567)){
      if (!x4) { // x0

         if (x0) 
            Blk[0] = Blk[8] = Blk[16] = Blk[24] = Blk[32] = Blk[40] = Blk[48] = Blk[56] = (idct_block_t)(x0 << 3);
      }else{ // x0,x4

         x0 = (x0 << 11) + 128;    
         x5 = W7 * x4;
         x1 = W1 * x4;
         x2 = ((181 * W1_plus_W7 + 128) >> 8) * x4;
         x4 = ((181 * W1_minus_W7 + 128) >> 8) * x4;

         Blk[0] = (idct_block_t)((x0 + x1) >> 8);
         Blk[8] = (idct_block_t)((x0 + x2) >> 8);
         Blk[16] = (idct_block_t)((x0 + x4) >> 8);
         Blk[24] = (idct_block_t)((x0 + x5) >> 8);
         Blk[32] = (idct_block_t)((x0 - x5) >> 8);
         Blk[40] = (idct_block_t)((x0 - x4) >> 8);
         Blk[48] = (idct_block_t)((x0 - x2) >> 8);
         Blk[56] = (idct_block_t)((x0 - x1) >> 8);
      }
   }else
   if (!(x4|x567)) { // x0,x1,x2,x3
   
      x0 = (x0 << 11) + 128;    
      
      x8 = x0 + x1;
      x0 -= x1;
      x1 = W6 * (x3 + x2);
      x2 = x1 - (W2_plus_W6) * x2;
      x3 = x1 + (W2_minus_W6) * x3;
      
      x7 = x8 + x3;
      x8 -= x3;
      x3 = x0 + x2;
      x0 -= x2;
      
      Blk[0] = (idct_block_t)(x7 >> 8);
      Blk[8] = (idct_block_t)(x3 >> 8);
      Blk[16] = (idct_block_t)(x0 >> 8);
      Blk[24] = (idct_block_t)(x8 >> 8);
      Blk[32] = (idct_block_t)(x8 >> 8);
      Blk[40] = (idct_block_t)(x0 >> 8);
      Blk[48] = (idct_block_t)(x3 >> 8);
      Blk[56] = (idct_block_t)(x7 >> 8);

      return;
   }else { //x0,x1,x2,x3,x4,x5,x6,x7

      x0 = (x0 << 11) + 128;    
      x8 = W7 * (x4 + x5);
      x4 = x8 + (W1_minus_W7) * x4;
      x5 = x8 - (W1_plus_W7) * x5;
      x8 = W3 * (x6 + x7);
      x6 = x8 - (W3_minus_W5) * x6;
      x7 = x8 - (W3_plus_W5) * x7;

      x8 = x0 + x1;
      x0 -= x1;
      x1 = W6 * (x3 + x2);
      x2 = x1 - (W2_plus_W6) * x2;
      x3 = x1 + (W2_minus_W6) * x3;
      x1 = x4 + x6;
      x4 -= x6;
      x6 = x5 + x7;
      x5 -= x7;

      x7 = x8 + x3;
      x8 -= x3;
      x3 = x0 + x2;
      x0 -= x2;
      x2 = (181 * (x4 + x5) + 128) >> 8;
      x4 = (181 * (x4 - x5) + 128) >> 8;

      Blk[0] = (idct_block_t)((x7 + x1) >> 8);
      Blk[8] = (idct_block_t)((x3 + x2) >> 8);
      Blk[16] = (idct_block_t)((x0 + x4) >> 8);
      Blk[24] = (idct_block_t)((x8 + x6) >> 8);
      Blk[32] = (idct_block_t)((x8 - x6) >> 8);
      Blk[40] = (idct_block_t)((x0 - x4) >> 8);
      Blk[48] = (idct_block_t)((x3 - x2) >> 8);
      Blk[56] = (idct_block_t)((x7 - x1) >> 8);
   }
}

static void IDCT_RowConst(int v, byte *Dst, const byte *Src){
   if (Src) {
      
      dword MaskCarry = 0x80808080U;
      dword a,b,c,d;

      a = ((dword*)Src)[0];
      d = ((dword*)Src)[1];
      if(v>0){
         v |= v << 8;
         v |= v << 16;
         ADDSAT32(a, ((dword*)Dst)[0], v);
         ADDSAT32(d, ((dword*)Dst)[1], v);
      }else
      if(v<0){
         v = -v;
         v |= v << 8;
         v |= v << 16;

         SUBSAT32(a,((dword*)Dst)[0],v);
         SUBSAT32(d,((dword*)Dst)[1],v);
      }else{
         ((dword*)Dst)[0] = a;
         ((dword*)Dst)[1] = d;
      }
   }else{
      SAT(v);
      v &= 255;
      v |= v << 8;
      v |= v << 16;

      ((dword*)Dst)[1] = ((dword*)Dst)[0] = v;
   }
}   

//----------------------------

static void IDCT_Row8(idct_block_t *Blk, byte *Dst, const byte *Src){

   int x0, x1, x2, x3, x4, x5, x6, x7, x8;

   x4 = Blk[1];
   x3 = Blk[2];
   x7 = Blk[3];
   x1 = Blk[4];
   x6 = Blk[5];
   x2 = Blk[6];
   x5 = Blk[7];
   
   if (!(x1|x2|x3|x4|x5|x6|x7))
   {
      IDCT_RowConst((Blk[0] + 32) >> 6,Dst,Src);
      return;
   }

   x1 <<= 8;
   x0 = (Blk[0] << 8) + 8192;

   x8 = W7 * (x4 + x5) + 4;
   x4 = (x8 + (W1_minus_W7) * x4) >> 3;
   x5 = (x8 - (W1_plus_W7) * x5) >> 3;
   x8 = W3 * (x6 + x7) + 4;
   x6 = (x8 - (W3_minus_W5) * x6) >> 3;
   x7 = (x8 - (W3_plus_W5) * x7) >> 3;

   x8 = x0 + x1;
   x0 -= x1;
   x1 = W6 * (x3 + x2) + 4;
   x2 = (x1 - (W2_plus_W6) * x2) >> 3;
   x3 = (x1 + (W2_minus_W6) * x3) >> 3;
   x1 = x4 + x6;
   x4 -= x6;
   x6 = x5 + x7;
   x5 -= x7;

   x7 = x8 + x3;
   x8 -= x3;
   x3 = x0 + x2;
   x0 -= x2;
   x2 = (181 * (x4 + x5) + 128) >> 8;
   x4 = (181 * (x4 - x5) + 128) >> 8;

   x5 = (x7 + x1) >> 14;
   x1 = (x7 - x1) >> 14;
   x7 = (x3 + x2) >> 14;
   x2 = (x3 - x2) >> 14;
   x3 = (x0 + x4) >> 14;
   x4 = (x0 - x4) >> 14;
   x0 = (x8 + x6) >> 14;
   x6 = (x8 - x6) >> 14;

   if (Src)
   {
      x5 += Src[0];
      x1 += Src[7];
      x7 += Src[1];
      x2 += Src[6];
      x3 += Src[2];
      x4 += Src[5];
      x0 += Src[3];
      x6 += Src[4];
   }
   
   x8 = (x5|x1|x7|x2|x3|x4|x0|x6)>>8;

   if (x8)
   {
      SAT(x5)
      SAT(x7)
      SAT(x3)
      SAT(x0)
      SAT(x6)
      SAT(x4)
      SAT(x2)
      SAT(x1)
   }

   Dst[0] = (byte)x5;
   Dst[1] = (byte)x7;
   Dst[2] = (byte)x3;
   Dst[3] = (byte)x0;
   Dst[4] = (byte)x6;
   Dst[5] = (byte)x4;
   Dst[6] = (byte)x2;
   Dst[7] = (byte)x1;
}

//----------------------------

static void IDCT_Row4(idct_block_t *Blk, byte *Dst, const byte *Src){

   int x0, x1, x2, x3, x4, x5, x6, x7, x8;
  
   x4 = Blk[1];
   x3 = Blk[2];
   x7 = Blk[3];
   
   if (!(x3|x4|x7))
   {
      IDCT_RowConst((Blk[0] + 32) >> 6,Dst,Src);
      return;
   }

   x0 = (Blk[0] << 8) + 8192;

   x5 = (W7 * x4 + 4) >> 3;
   x4 = (W1 * x4 + 4) >> 3;
   x6 = (W3 * x7 + 4) >> 3;
   x7 = (-W5 * x7 + 4) >> 3;

   x2 = (W6 * x3 + 4) >> 3;
   x3 = (W2 * x3 + 4) >> 3;
   x1 = x4 + x6;
   x4 -= x6;
   x6 = x5 + x7;
   x5 -= x7;

   x7 = x0 + x3;
   x8 = x0 - x3;
   x3 = x0 + x2;
   x0 -= x2;
   x2 = (181 * (x4 + x5) + 128) >> 8;
   x4 = (181 * (x4 - x5) + 128) >> 8;

   x5 = (x7 + x1) >> 14;
   x1 = (x7 - x1) >> 14;
   x7 = (x3 + x2) >> 14;
   x2 = (x3 - x2) >> 14;
   x3 = (x0 + x4) >> 14;
   x4 = (x0 - x4) >> 14;
   x0 = (x8 + x6) >> 14;
   x6 = (x8 - x6) >> 14;

   if (Src)
   {
      x5 += Src[0];
      x1 += Src[7];
      x7 += Src[1];
      x2 += Src[6];
      x3 += Src[2];
      x4 += Src[5];
      x0 += Src[3];
      x6 += Src[4];
   }
   
   x8 = (x5|x1|x7|x2|x3|x4|x0|x6)>>8;

   if (x8)
   {
      SAT(x5)
      SAT(x7)
      SAT(x3)
      SAT(x0)
      SAT(x6)
      SAT(x4)
      SAT(x2)
      SAT(x1)
   }

   Dst[0] = (byte)x5;
   Dst[1] = (byte)x7;
   Dst[2] = (byte)x3;
   Dst[3] = (byte)x0;
   Dst[4] = (byte)x6;
   Dst[5] = (byte)x4;
   Dst[6] = (byte)x2;
   Dst[7] = (byte)x1;
}

//----------------------------

void IDCT_Block8x8(idct_block_t *Block, byte *Dest, int DestStride, const byte *Src){
   int SrcStride;

   IDCT_Col8(Block+0);
   IDCT_Col8(Block+1);
   IDCT_Col8(Block+2);
   IDCT_Col8(Block+3);
   IDCT_Col8(Block+4);
   IDCT_Col8(Block+5);
   IDCT_Col8(Block+6);
   IDCT_Col8(Block+7);

   SrcStride = 0;
   if (Src) SrcStride = 8;

   IDCT_Row8(Block,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row8(Block+8,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row8(Block+16,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row8(Block+24,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row8(Block+32,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row8(Block+40,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row8(Block+48,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row8(Block+56,Dest,Src);
}

//----------------------------

void IDCT_Block4x8(idct_block_t *Block, byte *Dest, int DestStride, const byte *Src){
   int SrcStride;

   IDCT_Col8(Block);
   IDCT_Col8(Block+1);
   IDCT_Col8(Block+2);
   IDCT_Col8(Block+3);

   SrcStride = 0;
   if (Src) SrcStride = 8;

   IDCT_Row4(Block,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row4(Block+8,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row4(Block+16,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row4(Block+24,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row4(Block+32,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row4(Block+40,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row4(Block+48,Dest,Src);
   Dest+=DestStride;
   Src+=SrcStride;
   IDCT_Row4(Block+56,Dest,Src);
}

#endif   //!ARM

//----------------------------

void IDCT_Const8x8(int v, byte * Dst, int DstPitch, const byte *Src){

   int SrcPitch = 8;

   const byte* SrcEnd = Src + 8*SrcPitch;
   dword MaskCarry = 0x80808080U;
   dword a,b,c,d;

   if(v>0){
      v |= v << 8;
      v |= v << 16;
      do{
         a = ((dword*)Src)[0];
         d = ((dword*)Src)[1];
         ADDSAT32(a,((dword*)Dst)[0],v);
         ADDSAT32(d,((dword*)Dst)[1],v);
         Dst += DstPitch;
         Src += SrcPitch;
      }while (Src != SrcEnd);
   }else
   if(v<0){
      v = -v;
      v |= v << 8;
      v |= v << 16;
      do{
         a = ((dword*)Src)[0];
         d = ((dword*)Src)[1];
         SUBSAT32(a,((dword*)Dst)[0],v);
         SUBSAT32(d,((dword*)Dst)[1],v);
         Dst += DstPitch;
         Src += SrcPitch;
      }while (Src != SrcEnd);
   }
}

//----------------------------