mcomp.cpp

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

   }
   dc.FunctionEnd();

dc.PutLabel(label_wrap);
   BuildWMMXLoadHorVerRow(dc, true, true);

   {
      void *loop = dc.Label();
      BuildWMMXLoadHorVerRow(dc, false, true);
      BuildWMMXSetHorVerRow(dc, add);
      BuildWMMXLoadHorVerRow(dc, true, true);
      BuildWMMXSetHorVerRow(dc, add);
      dc.Set(); dc.Sub(dc.r14, dc.r14, 2);
      dc.Branch(dc.NE, loop);
   }
   dc.FunctionEnd();
}

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

void BuildMotionCompensationFunctions(C_dyn_code &dc, bool use_wmmx){

#ifdef USE_IDCT_WMMX
   if(use_wmmx){
                              //AddBlock
      BuildWMMXAddBlock(dc);
                              //AddBlockHor
      BuildWMMXCopyBlockHor(dc, false, true);
                              //AddBlockVer
      BuildWMMXCopyBlockVer(dc, false, true);
                              //AddBlockHorVer
      BuildWMMXCopyBlockHorVer(dc, false, true);

                              //CopyBlock
      BuildWMMXCopyBlock(dc);
                              //CopyBlockHor
      BuildWMMXCopyBlockHor(dc, false, false);
                              //CopyBlockHorRound
      BuildWMMXCopyBlockHor(dc, true, false);
                              //CopyBlockVer
      BuildWMMXCopyBlockVer(dc, false, false);
                              //CopyBlockVerRound
      BuildWMMXCopyBlockVer(dc, true, false);
                              //CopyBlockHorVer
      BuildWMMXCopyBlockHorVer(dc, false, false);
                              //CopyBlockHorVerRound
      BuildWMMXCopyBlockHorVer(dc, true, false);
   }else
#endif
   {
                              //0 - 3
                              //AddBlock
      BuildCopyFunction(dc, BuildAddBlock, false, true);
                              //AddBlockHor
      BuildCopyFunction(dc, BuildCopyBlockHor, false, true);
                              //AddBlockVer
      BuildCopyFunction(dc, BuildCopyBlockVer, false, true);
                              //AddBlockHorVer
      BuildCopyFunction(dc, BuildCopyBlockHorVer, false, true);

                              //4 - 10
                              //CopyBlock
      BuildCopyFunction(dc, BuildCopyBlock, false, false, true);
                              //CopyBlockHor
      BuildCopyFunction(dc, BuildCopyBlockHor, false, false);
                              //CopyBlockHorRound
      BuildCopyFunction(dc, BuildCopyBlockHor, true, false);
                              //CopyBlockVer
      BuildCopyFunction(dc, BuildCopyBlockVer, false, false);
                              //CopyBlockVerRound
      BuildCopyFunction(dc, BuildCopyBlockVer, true, false);
                              //CopyBlockHorVer
      BuildCopyFunction(dc, BuildCopyBlockHorVer, false, false);
                              //CopyBlockHorVerRound
      BuildCopyFunction(dc, BuildCopyBlockHorVer, true, false);
   }
                              //11, 12
                              //CopyBlock8x8
   BuildCopyFunction(dc, BuildCopyBlock8x8, false, false, false);
                              //CopyBlock16x16
   BuildCopyFunction(dc, BuildCopyBlock16x16, false, false, false);
}


//----------------------------
#else//ARM
//----------------------------

#define LoadRow(a,b,o) { \
   a=Src[o+0]|(Src[o+1]<<8)|((Src[o+2]|((char)Src[o+3]<<8))<<16); \
   b=Src[o+4]|(Src[o+5]<<8)|((Src[o+6]|((char)Src[o+7]<<8))<<16); \
}
#define LoadMRow(a,b,c,d,o)   \
{                    \
   a=Src[o+0]|(Src[o+1]<<8)|(Src[o+2]<<16)|(Src[o+3]<<24); \
   b=Src[o+4]|(Src[o+5]<<8)|(Src[o+6]<<16)|(Src[o+7]<<24); \
   c=Src[o+8]|(Src[o+9]<<8)|(Src[o+10]<<16)|(Src[o+11]<<24); \
   d=Src[o+12]|(Src[o+13]<<8)|(Src[o+14]<<16)|(Src[o+15]<<24); \
}

#define SaveRow(a,b) \
{                 \
   ((dword*)Dst)[0]=a;\
   ((dword*)Dst)[1]=b;\
}
#define SaveMRow(a,b,c,d)  \
{                    \
   ((dword*)Dst)[0]=a;  \
   ((dword*)Dst)[1]=b;  \
   ((dword*)Dst)[2]=c;  \
   ((dword*)Dst)[3]=d;  \
}
#define AddRow(a,b,c,d)       \
{                       \
   dword q,w;           \
   c=((dword*)Dst)[0];     \
   d=((dword*)Dst)[1];     \
   q=(a|c) & 0x01010101;      \
   w=(b|d) & 0x01010101;      \
   q+=(a>>1) & 0x7F7F7F7F;    \
   w+=(b>>1) & 0x7F7F7F7F;    \
   q+=(c>>1) & 0x7F7F7F7F;    \
   w+=(d>>1) & 0x7F7F7F7F;    \
   ((dword*)Dst)[0]=q;     \
   ((dword*)Dst)[1]=w;     \
}
#define Avg2(a,b,c,d,e,f)              \
{                                \
   e=(a|c) & 0x01010101;               \
   f=(b|d) & 0x01010101;               \
   e+=(a>>1) & 0x7F7F7F7F;             \
   f+=(b>>1) & 0x7F7F7F7F;             \
   e+=(c>>1) & 0x7F7F7F7F;             \
   f+=(d>>1) & 0x7F7F7F7F;             \
}
#define Avg2Round(a,b,c,d,e,f)            \
{                                \
   e=(a&c) & 0x01010101;               \
   f=(b&d) & 0x01010101;               \
   e+=(a>>1) & 0x7F7F7F7F;             \
   f+=(b>>1) & 0x7F7F7F7F;             \
   e+=(c>>1) & 0x7F7F7F7F;             \
   f+=(d>>1) & 0x7F7F7F7F;             \
}
#define PrepareAvg4(a,b,c,d)           \
{                                \
   dword q,w;                    \
   q=(a & 0x03030303);                 \
   w=(b & 0x03030303);                 \
   q+=(c & 0x03030303);             \
   w+=(d & 0x03030303);             \
   a=(a>>2) & 0x3F3F3F3F;              \
   b=(b>>2) & 0x3F3F3F3F;              \
   a+=(c>>2) & 0x3F3F3F3F;             \
   b+=(d>>2) & 0x3F3F3F3F;             \
   c=q;                          \
   d=w;                          \
}
#define Avg4(a,b,c,d,g,h,i,j)          \
{                                \
   a+=g;                         \
   b+=h;                         \
   c+=i+0x02020202;                 \
   d+=j+0x02020202;                 \
   a+=(c>>2) & 0x03030303;             \
   b+=(d>>2) & 0x03030303;             \
}
#define Avg4Round(a,b,c,d,g,h,i,j)        \
{                                \
   a+=g;                         \
   b+=h;                         \
   c+=i+0x01010101;                 \
   d+=j+0x01010101;                 \
   a+=(c>>2) & 0x03030303;             \
   b+=(d>>2) & 0x03030303;             \
}

//----------------------------
// Dst[p] = Src[p]
void CopyBlock(const byte *Src, byte *Dst, int SrcPitch, int DstPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b;
   do {
      LoadRow(a,b,0)
      SaveRow(a,b)
      Dst += DstPitch;
      Src += SrcPitch;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (Src[p] + Src[p+1]+1) >> 1;
void CopyBlockHor(const byte *Src, byte *Dst, int SrcPitch, int DstPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,e,f;
   do {
      LoadRow(a,b,0)
      LoadRow(c,d,1)
      Avg2(a,b,c,d,e,f)
      SaveRow(e,f)
      Dst += DstPitch;
      Src += SrcPitch;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (Src[p] + Src[p+SrcPitch]+1) >> 1;
void CopyBlockVer(const byte *Src, byte *Dst, int SrcPitch, int DstPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,e,f;
   LoadRow(a,b,0)
   do {
      Src += SrcPitch;
      LoadRow(c,d,0)
      Avg2(a,b,c,d,e,f)
      SaveRow(e,f)
      Dst += DstPitch;

      Src += SrcPitch;
      LoadRow(a,b,0)
      Avg2(c,d,a,b,e,f)
      SaveRow(e,f)
      Dst += DstPitch;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (Src[p] + Src[p+1] + Src[p+SrcPitch] + Src[p+SrcPitch+1] + 2) >> 2;
void CopyBlockHorVer(const byte *Src, byte *Dst, int SrcPitch, int DstPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,g,h,i,j;
   LoadRow(a,b,0)
   LoadRow(c,d,1)
   PrepareAvg4(a,b,c,d)
   do {
      Src += SrcPitch;
      LoadRow(g,h,0)
      LoadRow(i,j,1)
      PrepareAvg4(g,h,i,j)
      Avg4(a,b,c,d,g,h,i,j)
      SaveRow(a,b)
      Dst += DstPitch;

      Src += SrcPitch;
      LoadRow(a,b,0)
      LoadRow(c,d,1)
      PrepareAvg4(a,b,c,d)
      Avg4(g,h,i,j,a,b,c,d)
      SaveRow(g,h)
      Dst += DstPitch;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (Src[p] + Src[p+1]) >> 1;
void CopyBlockHorRound(const byte *Src, byte *Dst, int SrcPitch, int DstPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,e,f;
   do {
      LoadRow(a,b,0)
      LoadRow(c,d,1)
      Avg2Round(a,b,c,d,e,f)
      SaveRow(e,f)
      Dst += DstPitch;
      Src += SrcPitch;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (Src[p] + Src[p+SrcPitch]) >> 1;
void CopyBlockVerRound(const byte *Src, byte *Dst, int SrcPitch, int DstPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,e,f;
   LoadRow(a,b,0)
   do{
      Src += SrcPitch;
      LoadRow(c,d,0)
      Avg2Round(a,b,c,d,e,f)
      SaveRow(e,f)
      Dst += DstPitch;

      Src += SrcPitch;
      LoadRow(a,b,0)
      Avg2Round(c,d,a,b,e,f)
      SaveRow(e,f)
      Dst += DstPitch;
   }while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (Src[p] + Src[p+1] + Src[p+SrcPitch] + Src[p+SrcPitch+1] + 1) >> 2;
void CopyBlockHorVerRound(const byte *Src, byte *Dst, int SrcPitch, int DstPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,g,h,i,j;
   LoadRow(a,b,0)
   LoadRow(c,d,1)
   PrepareAvg4(a,b,c,d)
   do{
      Src += SrcPitch;
      LoadRow(g,h,0)
      LoadRow(i,j,1)
      PrepareAvg4(g,h,i,j)
      Avg4Round(a,b,c,d,g,h,i,j)
      SaveRow(a,b)
      Dst += DstPitch;

      Src += SrcPitch;
      LoadRow(a,b,0)
      LoadRow(c,d,1)
      PrepareAvg4(a,b,c,d)
      Avg4Round(g,h,i,j,a,b,c,d)
      SaveRow(g,h)
      Dst += DstPitch;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (Src[p] + Dst[p] + 1) >> 1
void AddBlock(const byte *Src, byte *Dst, int SrcPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d;
   do {
      LoadRow(a,b,0)
      AddRow(a,b,c,d)
      Dst += 8;
      Src += SrcPitch;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (((Src[p] + Src[p+1]+1) >> 1) + Dst[p] + 1) >> 1
void AddBlockHor(const byte *Src, byte *Dst, int SrcPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,e,f;
   do {
      LoadRow(a,b,0)
      LoadRow(c,d,1)
      Avg2(a,b,c,d,e,f)
      AddRow(e,f,a,b)
      Dst += 8;
      Src += SrcPitch;
   }
   while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (((Src[p] + Src[p+SrcPitch]+1) >> 1) + Dst[p] + 1) >> 1
void AddBlockVer(const byte *Src, byte *Dst, int SrcPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,e,f;
   LoadRow(a,b,0)
   do {
      Src += SrcPitch;
      LoadRow(c,d,0)
      Avg2(a,b,c,d,e,f)
      AddRow(e,f,a,b)
      a=c;
      b=d;
      Dst += 8;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = (((Src[p] + Src[p+1] + Src[p+SrcPitch] + Src[p+SrcPitch+1] + 2) >> 2) + Dst[p] + 1) >> 1
void AddBlockHorVer(const byte *Src, byte *Dst, int SrcPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d,g,h,i,j;
   LoadRow(a,b,0)
   LoadRow(c,d,1)
   PrepareAvg4(a,b,c,d)
   do{
      Src += SrcPitch;
      LoadRow(g,h,0)
      LoadRow(i,j,1)
      PrepareAvg4(g,h,i,j)
      Avg4(a,b,c,d,g,h,i,j)
      AddRow(a,b,c,d)
      a=g;
      b=h;
      c=i;
      d=j;
      Dst += 8;
   }while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = Src[p]
void CopyBlock16x16(const byte *Src, byte *Dst, int SrcPitch,int DstPitch){
   const byte *SrcEnd = Src + 16*SrcPitch;
   dword a,b,c,d;
   do {
      a=((dword*)Src)[0];
      b=((dword*)Src)[1];
      c=((dword*)Src)[2];
      d=((dword*)Src)[3];
      ((dword*)Dst)[0]=a;
      ((dword*)Dst)[1]=b;
      ((dword*)Dst)[2]=c;
      ((dword*)Dst)[3]=d;
      Dst += DstPitch;
      Src += SrcPitch;
   } while (Src != SrcEnd);
}

//----------------------------
// Dst[p] = Src[p]
void CopyBlock8x8(const byte *Src, byte *Dst, int SrcPitch,int DstPitch){
   const byte *SrcEnd = Src + 8*SrcPitch;
   dword a,b,c,d;
   do {
      a=((dword*)Src)[0];
      b=((dword*)Src)[1];
      Src += SrcPitch;
      c=((dword*)Src)[0];
      d=((dword*)Src)[1];
      Src += SrcPitch;
      ((dword*)Dst)[0]=a;
      ((dword*)Dst)[1]=b;
      Dst += DstPitch;
      ((dword*)Dst)[0]=c;
      ((dword*)Dst)[1]=d;
      Dst += DstPitch;
   } while (Src != SrcEnd);
}

#endif//!ARM

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