quarterpelfilter.cpp

JVT-Z203_jsvm.rar

  for( UInt y = 0; y < uiSizeY; y++)
  {
    for( UInt x = 0; x < uiSizeX; x++)
    {
      Int iTemp;
      iTemp  = pucSrc[x - 0];
      iTemp += pucSrc[x + 1];
      iTemp  = iTemp << 2;
      iTemp -= pucSrc[x - 1];
      iTemp -= pucSrc[x + 2];
      iTemp += iTemp << 2;
      iTemp += pucSrc[x - 2];
      iTemp += pucSrc[x + 3];

#if AR_FGS_COMPENSATE_SIGNED_FRAME
      if( ! m_bClip )
      {
        iTemp     += pucSrc[ x + iDx] << 5;
        pucDest[x] = SIGNED_ROUNDING( iTemp,  32, 6 );
      }
      else
      {
        iTemp = xClip( (iTemp + 16) / 32 );
        pucDest[x] = (iTemp + pucSrc[ x + iDx] + 1) / 2;
      }
#else
      iTemp = xClip( (iTemp + 16) / 32 );
      pucDest[x] = (iTemp + pucSrc[ x + iDx] + 1) / 2;
#endif
    }
    pucDest += iDestStride;
    pucSrc  += iSrcStride;
  }
}


Void QuarterPelFilter::xPredDx0Dy2( XPel* pucDest, XPel* pucSrc, Int iDestStride, Int iSrcStride, UInt uiSizeY, UInt uiSizeX )
{
  for( UInt y = 0; y < uiSizeY; y++)
  {
    for( UInt x = 0; x < uiSizeX; x++)
    {
      Int iTemp;
      iTemp  = pucSrc[x - 0*iSrcStride];
      iTemp += pucSrc[x + 1*iSrcStride];
      iTemp  = iTemp << 2;
      iTemp -= pucSrc[x - 1*iSrcStride];
      iTemp -= pucSrc[x + 2*iSrcStride];
      iTemp += iTemp << 2;
      iTemp += pucSrc[x - 2*iSrcStride];
      iTemp += pucSrc[x + 3*iSrcStride];
#if AR_FGS_COMPENSATE_SIGNED_FRAME
      if( ! m_bClip )
        pucDest[x] = SIGNED_ROUNDING( iTemp, 16, 5 );
      else
#endif
      pucDest[x] = xClip( (iTemp + 16) / 32 );
    }
    pucDest += iDestStride;
    pucSrc  += iSrcStride;
  }
}


Void QuarterPelFilter::xPredDx0Dy13( XPel* pucDest, XPel* pucSrc, Int iDestStride, Int iSrcStride, Int iDx, Int iDy, UInt uiSizeY, UInt uiSizeX )
{
  iDy = (iDy>>1) * iSrcStride;
  for( UInt y = 0; y < uiSizeY; y++)
  {
    for( UInt x = 0; x < uiSizeX; x++)
    {
      Int iTemp;
      iTemp  = pucSrc[x - 0*iSrcStride];
      iTemp += pucSrc[x + 1*iSrcStride];
      iTemp  = iTemp << 2;
      iTemp -= pucSrc[x - 1*iSrcStride];
      iTemp -= pucSrc[x + 2*iSrcStride];
      iTemp += iTemp << 2;
      iTemp += pucSrc[x - 2*iSrcStride];
      iTemp += pucSrc[x + 3*iSrcStride];
#if AR_FGS_COMPENSATE_SIGNED_FRAME
      if( ! m_bClip )
      {
        iTemp     += pucSrc[ x + iDy] << 5;
        pucDest[x] = SIGNED_ROUNDING( iTemp, 32, 6 );
      }
      else
      {
        iTemp = xClip( (iTemp + 16) / 32 );
        pucDest[x] = (iTemp + pucSrc[ x + iDy] + 1)/2;
      }
#else
      iTemp = xClip( (iTemp + 16) / 32 );
      pucDest[x] = (iTemp + pucSrc[ x + iDy] + 1)/2;
#endif
    }
    pucDest += iDestStride;
    pucSrc  += iSrcStride;
  }
}



Void QuarterPelFilter::xPredDx2( XXPel*  psDest, XPel*  pucSrc, Int iSrcStride, UInt uiSizeY, UInt uiSizeX )
{
  pucSrc -= 2*iSrcStride;

  for( UInt y = 0; y < uiSizeY + 5; y++)
  {
    for( UInt x = 0; x < uiSizeX; x++)
    {
      XPel* puc = pucSrc + x;
      Int iTemp;
      iTemp  = puc[0];
      iTemp += puc[1];
      iTemp  = iTemp << 2;
      iTemp -= puc[-1];
      iTemp -= puc[2];
      iTemp += iTemp << 2;
      iTemp += puc[-2];
      iTemp += puc[3];
      psDest[x] = iTemp;

    }
    psDest += 16;
    pucSrc += iSrcStride;
  }
}



Void QuarterPelFilter::xPredDx2Dy2( XPel* pucDest, XPel* pucSrc, Int iDestStride, Int iSrcStride, Int iDx, Int iDy, UInt uiSizeY, UInt uiSizeX )
{
  XXPel   asTemp[16*(16+6)];
  XXPel*  psTemp = asTemp;
  xPredDx2( asTemp, pucSrc, iSrcStride, uiSizeY, uiSizeX );

  for( UInt y = 0; y < uiSizeY; y++)
  {
    for( UInt x = 0; x < uiSizeX; x++)
    {
      Int iIndex = x + 0x20;
      Int iTemp;
      iTemp  = psTemp[ 0x00 + iIndex];
      iTemp += psTemp[ 0x10 + iIndex];
      iTemp  = iTemp << 2;
      iTemp -= psTemp[-0x10 + iIndex];
      iTemp -= psTemp[ 0x20 + iIndex];
      iTemp += iTemp << 2;
      iTemp += psTemp[-0x20 + iIndex];
      iTemp += psTemp[ 0x30 + iIndex];

#if AR_FGS_COMPENSATE_SIGNED_FRAME
      if( ! m_bClip )
        pucDest[x] = SIGNED_ROUNDING( iTemp, 512, 10 );
      else
#endif
      pucDest[x] = xClip( (iTemp + 512) / 1024 );
    }
    psTemp  += 0x10;
    pucDest += iDestStride;
  }

}


Void QuarterPelFilter::xPredDx2Dy13( XPel* pucDest, XPel* pucSrc, Int iDestStride, Int iSrcStride, Int iDx, Int iDy, UInt uiSizeY, UInt uiSizeX )
{
  XXPel   asTemp[16*(16+6)];
  XXPel*  psTemp = asTemp;
  xPredDx2( asTemp, pucSrc, iSrcStride, uiSizeY, uiSizeX );

  iDy = (iDy == 1) ? 0 : 0x10;

  for( UInt y = 0; y < uiSizeY; y++)
  {
    for( UInt x = 0; x < uiSizeX; x++)
    {
      Int iIndex = x + 0x20;
      Int iTemp;
      iTemp  = psTemp[ 0x00 + iIndex];
      iTemp += psTemp[ 0x10 + iIndex];
      iTemp  = iTemp << 2;
      iTemp -= psTemp[-0x10 + iIndex];
      iTemp -= psTemp[ 0x20 + iIndex];
      iTemp += iTemp << 2;
      iTemp += psTemp[-0x20 + iIndex];
      iTemp += psTemp[ 0x30 + iIndex];
#if AR_FGS_COMPENSATE_SIGNED_FRAME
      if( ! m_bClip )
      {
        iTemp     += psTemp[iDy + iIndex] << 5;
        pucDest[x] = SIGNED_ROUNDING( iTemp, 1024, 11 );
      }
      else
      {
        iTemp = xClip( (iTemp + 512) / 1024 );
        pucDest[x] = (iTemp + xClip( (psTemp[iDy + iIndex] + 16) / 32 ) + 1) / 2;
      }
#else
      iTemp = xClip( (iTemp + 512) / 1024 );
      pucDest[x] = (iTemp + xClip( (psTemp[iDy + iIndex] + 16) / 32 ) + 1) / 2;
#endif
    }
    psTemp  += 0x10;
    pucDest += iDestStride;
  }
}


Void QuarterPelFilter::xPredDy2Dx13( XPel* pucDest, XPel* pucSrc, Int iDestStride, Int iSrcStride, Int iDx, Int iDy, UInt uiSizeY, UInt uiSizeX )
{
  iDx = (iDx == 1) ? 2 : 3;
  for( UInt y = 0; y < uiSizeY; y++)
  {
    Int aiTemp[6+16];
    for( UInt n = 0; n < 6+uiSizeX; n++)
    {
      XPel* puc = pucSrc + n - 2;
      aiTemp[n]  = puc[ 0*iSrcStride];
      aiTemp[n] += puc[ 1*iSrcStride];
      aiTemp[n]  = aiTemp[n] << 2;
      aiTemp[n] -= puc[-1*iSrcStride];
      aiTemp[n] -= puc[ 2*iSrcStride];
      aiTemp[n] += aiTemp[n] << 2;
      aiTemp[n] += puc[-2*iSrcStride];
      aiTemp[n] += puc[ 3*iSrcStride];
    }

    for( UInt x = 0; x < uiSizeX; x++)
    {
      Int iTemp = 0;
      for( Int n = 0; n < 6; n++ )
      {
        iTemp += aiTemp[n+x]*g_aiTapCoeff[n];
      }
#if AR_FGS_COMPENSATE_SIGNED_FRAME
      if( ! m_bClip )
      {
        iTemp     += aiTemp[x+iDx] << 5;
        pucDest[x] = SIGNED_ROUNDING( iTemp, 1024, 11 );
      }
      else
      {
        iTemp = xClip( (iTemp + 512) / 1024 );
        pucDest[x] = (iTemp + xClip( (aiTemp[x+iDx] + 16) / 32 ) + 1) / 2;
      }
#else
      iTemp = xClip( (iTemp + 512) / 1024 );
      pucDest[x] = (iTemp + xClip( (aiTemp[x+iDx] + 16) / 32 ) + 1) / 2;
#endif
    }
    pucDest += iDestStride;
    pucSrc  += iSrcStride;
  }
}



Void QuarterPelFilter::xPredElse( XPel* pucDest, XPel* pucSrc, Int iDestStride, Int iSrcStride, Int iDx, Int iDy, UInt uiSizeY, UInt uiSizeX )
{
  XPel* pucSrcX = pucSrc;
  XPel* pucSrcY = pucSrc;

  pucSrcY += (iDx == 1) ? 0 : 1;
  pucSrcX += (iDy == 1) ? 0 : iSrcStride;

  for( UInt y = 0; y < uiSizeY; y++)
  {
    for( UInt x = 0; x < uiSizeX; x++)
    {
      Int iTempX;
      iTempX  = pucSrcX[x - 0];
      iTempX += pucSrcX[x + 1];
      iTempX  = iTempX << 2;
      iTempX -= pucSrcX[x - 1];
      iTempX -= pucSrcX[x + 2];
      iTempX += iTempX << 2;
      iTempX += pucSrcX[x - 2];
      iTempX += pucSrcX[x + 3];
#if ! AR_FGS_COMPENSATE_SIGNED_FRAME
      iTempX = xClip( (iTempX + 16) / 32 );
#endif

      Int iTempY;
      iTempY  = pucSrcY[x - 0*iSrcStride];
      iTempY += pucSrcY[x + 1*iSrcStride];
      iTempY  = iTempY << 2;
      iTempY -= pucSrcY[x - 1*iSrcStride];
      iTempY -= pucSrcY[x + 2*iSrcStride];
      iTempY += iTempY << 2;
      iTempY += pucSrcY[x - 2*iSrcStride];
      iTempY += pucSrcY[x + 3*iSrcStride];
#if AR_FGS_COMPENSATE_SIGNED_FRAME
      if( ! m_bClip )
      {
        pucDest[x] = SIGNED_ROUNDING( iTempX + iTempY, 32, 6 );
      }
      else
      {
        iTempX = xClip( (iTempX + 16) / 32 );
        iTempY = xClip( (iTempY + 16) / 32 );
        pucDest[x] = (iTempX + iTempY + 1) >> 1;
      }
#else
      iTempY = xClip( (iTempY + 16) / 32 );
      pucDest[x] = (iTempX + iTempY + 1) >> 1;
#endif
    }
    pucDest += iDestStride;
    pucSrcX += iSrcStride;
    pucSrcY += iSrcStride;
  }
}


Void QuarterPelFilter::xUpdInterpBlnr(Int* pucDest, XPel* pucSrc, Int iDestStride, Int iSrcStride, Int iDx, Int iDy, 
                                    Int iSizeY, Int iSizeX )
{
  static int f2tap[4][2] = {
    { 4,  0}, 
    { 3,  1},
    { 2,  2},
    { 1,  3}
  };
  int sx1, sx2, sy1, sy2; 
  for( Int y = 0; y < iSizeY + 1; y++)
  {
    for( Int x = 0; x < iSizeX + 1; x++)
    {
      Int iTemp1[2], iTemp2;
      int i, j;
      sx1 = max(0, x + 1 - iSizeX);
      sx2 = min(2, x + 1);
      sy1 = max(0, y + 1 - iSizeY);
      sy2 = min(2, y + 1);

      for(i = sy1; i < sy2; i++)
      {
        iTemp1[i] = 0;
       
        for(j = sx1; j < sx2; j++ )
          iTemp1[i] += pucSrc[x - i*iSrcStride - j] * f2tap[iDx][j];
      }

      iTemp2 = 0;
      for(i = sy1; i < sy2; i++)
        iTemp2 += iTemp1[i] * f2tap[iDy][i];

      pucDest[x] = iTemp2;
    }
    pucDest += iDestStride;
    pucSrc += iSrcStride; 
  }
}


Void QuarterPelFilter::xUpdInterp4Tap(Int* pucDest, XPel* pucSrc, Int iDestStride, Int iSrcStride, Int iDx, Int iDy, 
                                    Int iSizeY, Int iSizeX )
{
  static int f4tap[4][4] = {
    { 0, 16,  0,  0}, 
    {-2, 14,  5, -1},
    {-2, 10, 10, -2},
    {-1,  5, 14, -2}
  };

  int sx1, sx2, sy1, sy2; 
  for( Int y = 0; y < iSizeY + 3; y++)
  {
    for( Int x = 0; x < iSizeX + 3; x++)
    {
      Int iTemp1[4], iTemp2;
      int i, j;
      sx1 = max(0, x + 1 - iSizeX);
      sx2 = min(4, x + 1);
      sy1 = max(0, y + 1 - iSizeY);
      sy2 = min(4, y + 1);

      for(i = sy1; i < sy2; i++)
      {
        iTemp1[i] = 0;
       
        for(j = sx1; j < sx2; j++ )
          iTemp1[i] += pucSrc[x - i*iSrcStride - j] * f4tap[iDx][j];
      }

      iTemp2 = 0;
      for(i = sy1; i < sy2; i++)
        iTemp2 += iTemp1[i] * f4tap[iDy][i];

      pucDest[x] = iTemp2;
    }
    pucDest += iDestStride;
    pucSrc += iSrcStride; 
  }
}

Void QuarterPelFilter::xUpdInterpChroma( Int* pucDest, Int iDestStride, XPel* pucSrc, Int iSrcStride, Mv cMv, Int iSizeY, Int iSizeX )
{
  Int iDx = (cMv.getHor() & 0x7);
  Int iDy = (cMv.getVer() & 0x7);

  static int f2tapC[8][2] = {
    { 8,  0}, 
    { 7,  1},
    { 6,  2},
    { 5,  3},
    { 4,  4}, 
    { 3,  5},
    { 2,  6},
    { 1,  7}
  };
  int sx1, sx2, sy1, sy2; 
  for( Int y = 0; y < iSizeY + 1; y++)
  {
    for( Int x = 0; x < iSizeX + 1; x++)
    {
      Int iTemp1[2], iTemp2;
      int i, j;
      sx1 = max(0, x + 1 - (int)iSizeX);
      sx2 = min(2, x + 1);
      sy1 = max(0, y + 1 - (int)iSizeY);
      sy2 = min(2, y + 1);

      for(i = sy1; i < sy2; i++)
      {
        iTemp1[i] = 0;
       
        for(j = sx1; j < sx2; j++ )
          iTemp1[i] += pucSrc[x - i*iSrcStride - j] * f2tapC[iDx][j];
      }

      iTemp2 = 0;
      for(i = sy1; i < sy2; i++)
        iTemp2 += iTemp1[i] * f2tapC[iDy][i];

      pucDest[x] = iTemp2;
    }
    pucDest += iDestStride;
    pucSrc += iSrcStride; 
  }
}

Void QuarterPelFilter::weightOnEnergy(UShort *usWeight, XPel* pucSrc, Int iSrcStride, Int iSizeY, Int iSizeX)
{
  Int iSSD = 0;
  int bitsShift = 8, i;

  for( Int y = 0; y < iSizeY; y++)
  {
    for( Int x = 0; x < iSizeX; x++)
    {
      Int iTemp;
      iTemp  = xClip( pucSrc[iSrcStride*y + x]);
      iSSD += iTemp*iTemp;
    }
  }


  for( i = (iSizeY/4)*(iSizeX/4); i > 1; i >>= 1 )
    bitsShift ++;

  iSSD                                = ( iSSD + (1 << (bitsShift-1)) ) >> bitsShift;
  *usWeight                           = (UShort) max( 0, min( 16, 20 - iSSD ) );
}

H264AVC_NAMESPACE_END