intraprediction.cpp

JVT-Z203_jsvm.rar

Void IntraPrediction::xPredMode4DiagDownRight( Pel* puc, Int iStride ) // Diagonal Down Right Pred
{
  AOF( xIsAllLeftAboveRef() )
  UInt A,B,C,D;
  UInt I,J,K,L;
  UInt X;

  xLoadPredictorsABCD ( puc, iStride, A, B, C, D );
  xLoadPredictorsIJKL ( puc, iStride, I, J, K, L );
  xLoadPredictorsX    ( puc, iStride, X );

  puc[3]                                                        = (B + 2 * C + D + 2)/4;
  puc[2] = puc[iStride+3]                                       = (A + 2 * B + C + 2)/4;
  puc[1] = puc[iStride+2] = puc[2*iStride+3]                    = (X + 2 * A + B + 2)/4;
  puc[0] = puc[iStride+1] = puc[2*iStride+2] = puc[3*iStride+3] = (A + 2 * X + I + 2)/4;
           puc[iStride+0] = puc[2*iStride+1] = puc[3*iStride+2] = (X + 2 * I + J + 2)/4;
                            puc[2*iStride+0] = puc[3*iStride+1] = (I + 2 * J + K + 2)/4;
                                               puc[3*iStride+0] = (J + 2 * K + L + 2)/4;
}


Void IntraPrediction::xPredMode5VertRight( Pel* puc, Int iStride )  // Vertical Right Pred
{
  AOF( xIsAllLeftAboveRef() )

  UInt A,B,C,D;
  UInt I,J,K,L;
  UInt X;

  xLoadPredictorsABCD ( puc, iStride, A, B, C, D );
  xLoadPredictorsIJKL ( puc, iStride, I, J, K, L );
  xLoadPredictorsX    ( puc, iStride, X );


  puc[0]         = puc[2*iStride+1] = (X + A + 1) >> 1;
  puc[1]         = puc[2*iStride+2] = (A + B + 1) >> 1;
  puc[2]         = puc[2*iStride+3] = (B + C + 1) >> 1;
  puc[3]                            = (C + D + 1) >> 1;

  puc[iStride+0] = puc[3*iStride+1] = (I + 2*X + A + 2) >> 2;
  puc[iStride+1] = puc[3*iStride+2] = (X + 2*A + B + 2) >> 2;
  puc[iStride+2] = puc[3*iStride+3] = (A + 2*B + C + 2) >> 2;
  puc[iStride+3]                    = (B + 2*C + D + 2) >> 2;

  puc[2*iStride] = (X + 2*I + J + 2) >> 2;
  puc[3*iStride] = (I + 2*J + K + 2) >> 2;
}


Void IntraPrediction::xPredMode6HorizDown( Pel* puc, Int iStride ) // Horizontal DownPred
{
  AOF( xIsAllLeftAboveRef() )

  UInt A,B,C,D;
  UInt I,J,K,L;
  UInt X;

  xLoadPredictorsABCD ( puc, iStride, A, B, C, D );
  xLoadPredictorsIJKL ( puc, iStride, I, J, K, L );
  xLoadPredictorsX    ( puc, iStride, X );

  puc[0] = puc[iStride+2] = (X + I + 1) >> 1;
  puc[1] = puc[iStride+3] = (I + 2*X + A + 2) >> 2;
  puc[2] =                  (X + 2*A + B + 2) >> 2;
  puc[3] =                  (A + 2*B + C + 2) >> 2;

  puc[iStride+0]   = puc[2*iStride+2] = (I + J + 1) >> 1;
  puc[iStride+1]   = puc[2*iStride+3] = (X + 2*I + J + 2) >> 2;
  puc[2*iStride+0] = puc[3*iStride+2] = (J + K + 1) >> 1;
  puc[2*iStride+1] = puc[3*iStride+3] = (I + 2*J + K + 2) >> 2;

  puc[3*iStride+0] = (K + L + 1) >> 1;
  puc[3*iStride+1] = (J + 2*K + L + 2) >> 2;

}



Void IntraPrediction::xPredMode7VertLeft( Pel* puc, Int iStride ) // Vertical Left Pred
{
  AOF( xIsAboveRef() ); //!!!

  UInt A,B,C,D;
  UInt E,F,G,H;

  xLoadPredictorsABCD ( puc, iStride, A, B, C, D );
  xLoadPredictorsEFGH ( puc, iStride, E, F, G, H );

  puc[0] = (A + B + 1) >> 1;

  puc[1] = puc[2*iStride+0] = (B + C + 1) >> 1;
  puc[2] = puc[2*iStride+1] = (C + D + 1) >> 1;
  puc[3] = puc[2*iStride+2] = (D + E + 1) >> 1;
           puc[2*iStride+3] = (E + F + 1) >> 1;

  puc[iStride+0]                    = (A + 2*B + C + 2) >> 2;
  puc[iStride+1] = puc[3*iStride+0] = (B + 2*C + D + 2) >> 2;
  puc[iStride+2] = puc[3*iStride+1] = (C + 2*D + E + 2) >> 2;
  puc[iStride+3] = puc[3*iStride+2] = (D + 2*E + F + 2) >> 2;
                   puc[3*iStride+3] = (E + 2*F + G + 2) >> 2;
}


Void IntraPrediction::xPredMode8HorizUp( Pel* puc, Int iStride ) // Horizontal Up Pred
{
  AOF( xIsLeftRef() ); //!!!

  UInt I,J,K,L;

  xLoadPredictorsIJKL ( puc, iStride, I, J, K, L );

  puc[0] = (I + J + 1) >> 1;
  puc[1] = (I + 2*J + K + 2) >> 2;
  puc[2] = puc[iStride + 0] = (J + K + 1) >> 1;
  puc[3] = puc[iStride + 1] = (J + 2*K + L + 2) >> 2;

  puc[iStride + 2] = puc[2*iStride + 0] = (K + L + 1) >> 1;
  puc[iStride + 3] = puc[2*iStride + 1] = (K + 2*L + L + 2) >> 2;

  puc[2*iStride + 2] = puc[3*iStride + 0] =
  puc[2*iStride + 3] = puc[3*iStride + 1] =
  puc[3*iStride + 2] = puc[3*iStride + 3] = L;
}



Void IntraPrediction::xPred16x16IMode0Vert( Pel* puc, Int iStride ) // vertical
{
  AOF( xIsAboveRef() );

  for( UInt n = 0; n < 16; n++ )
  {
    ::memcpy( puc, puc - iStride, 16 );
    puc += iStride;
  }
}



Void IntraPrediction::xPred16x16IMode1Hori( Pel* puc, Int iStride ) // horizontal
{
  AOF( xIsLeftRef() );

  for( UInt n = 0; n < 16; n++ )
  {
   ::memset( puc, puc[-1], 16 );
    puc += iStride;
  }
}


Void IntraPrediction::xPred16x16IMode2DC( Pel* puc, Int iStride ) // DC prediction
{
  Int n, m;
  UInt uiDcValue = 0;

  if( ! xIsLeftRef() )
  {
    if( ! xIsAboveRef() )
    {
      uiDcValue = 0x80;
    }
    else
    {
      for( n = 0; n < 16; n++ )
      {
        uiDcValue += puc[n - iStride];
      }
      uiDcValue += 8;
      uiDcValue >>= 4;
    }
  }
  else
  {
    for( m = -1, n = 0; n < 16; n++, m+= iStride )
    {
      uiDcValue += puc[m];
    }

    if( ! xIsAboveRef() )
    {
      uiDcValue += 8;
      uiDcValue >>= 4;
    }
    else
    {
      for( n = 0; n < 16; n++ )
      {
        uiDcValue += puc[n - iStride];
      }
      uiDcValue += 16;
      uiDcValue >>= 5;
    }
  }


  for( n = 0; n < 16; n++ )
  {
   ::memset( puc, uiDcValue, 16 );
    puc += iStride;
  }
}


Void IntraPrediction::xPred16x16IMode3Plane( Pel* puc, Int iStride ) // plane prediction
{
  Int n, m;
  Int iH = 0;
  Int iV = 0;

  AOF( xIsAllLeftAboveRef() );

  Pel* pucDes = puc;

  puc += 7 - iStride;
  for( n = 1; n < 9; n++ )
  {
    iH += n * (Int)(puc[n] - puc[-n]);
  }

  puc += (iStride << 3) - 8;
  for( m = iStride, n = 1; n < 9; n++, m += iStride)
  {
    iV += n * (Int)(puc[m] - puc[-m]);
  }
  puc -= 7 * iStride - 1;


  Int iB =  (5 * iH + 32) >> 6;
  Int iC =  (5 * iV + 32) >> 6;
  Int iA = 16 * (Int)(puc[(iStride << 4) - (iStride + 1)] + puc[ 15 - iStride ]);
  Int x, y;

  for( y = 0; y < 16; y++ )
  {
    Int iYSum = iA + (y-7) * iC + 16;
    for( x = 0; x < 16; x++ )
    {
      pucDes[x] = gClip((iYSum + (x-7) * iB) >> 5);
    }
    pucDes += iStride;
  }
}





Void IntraPrediction::xPred8x8IMode2Vert( Pel* puc, Int iStride ) // vertical
{
  AOF( xIsAboveRef() );

  for( UInt n = 0; n < 8; n++ )
  {
    ::memcpy( puc, puc - iStride, 8 );
    puc += iStride;
  }
}


Void IntraPrediction::xPred8x8IMode1Hori( Pel* puc, Int iStride ) // horizontal
{
  AOF( xIsLeftRef() );

  for( UInt n = 0; n < 8; n++ )
  {
   ::memset( puc, puc[-1], 8 );
    puc += iStride;
  }
}


Void IntraPrediction::xPred8x8IMode0DC( Pel* puc, Int iStride ) // DC prediction
{
  if( ! xIsLeftRef() )
  {
    if( ! xIsAboveRef() )
    {
      xChroma0PredAllOutside( puc, iStride );
    }
    else
    {
      xChroma0PredNoLeftRef( puc, iStride );
    }
  }
  else
  {
    if( ! xIsAboveRef() )
    {
      xChroma0PredNoAboveRef( puc, iStride );
    }
    else
    {
      xChroma0PredAllInside( puc, iStride );
    }
  }
}


Void IntraPrediction::xPred8x8IMode3Plane( Pel* puc, Int iStride ) // plane prediction
{
  Int n, m;
  Int iH = 0;
  Int iV = 0;

  AOF( xIsAllLeftAboveRef() );

  Pel* pucDes = puc;

  puc += 3 - iStride;
  for( n = 1; n < 5; n++ )
  {
    iH += n * (Int)(puc[n] - puc[-n]);
  }

  puc += (iStride << 2) - 4;
  for( m = iStride, n = 1; n < 5; n++, m += iStride)
  {
    iV += n * (Int)(puc[m] - puc[-m]);
  }
  puc -= 3 * iStride - 1;

  Int iB =  (17 * iH + 16) >> 5;
  Int iC =  (17 * iV + 16) >> 5;
  Int iA = 16 * (Int)(puc[(iStride << 3) - (iStride + 1)] + puc[ 7 - iStride ]);
  Int x, y;

  for( y = 0; y < 8; y++ )
  {
    Int iYSum = iA + (y-3) * iC + 16;
    for( x = 0; x < 8; x++ )
    {
      pucDes[x] = gClip((iYSum + (x-3) * iB) >> 5);
    }
    pucDes += iStride;
  }
}









Void IntraPrediction::xPred16x16IMode0Vert( XPel* puc, Int iStride ) // vertical
{
  AOF( xIsAboveRef() );

  for( UInt n = 0; n < 16; n++ )
  {
    ::memcpy( puc, puc - iStride, 16*sizeof(XPel) );
    puc += iStride;
  }
}

Void IntraPrediction::xPred16x16IMode1Hori( XPel* puc, Int iStride ) // horizontal
{
  AOF( xIsLeftRef() );

  for( UInt n = 0; n < 16; n++ )
  {
    for( UInt m = 0; m < 16; m++ )
    {
      puc[m] = puc[m-1];
    }
    puc += iStride;
  }
}


Void IntraPrediction::xPred16x16IMode2DC( XPel* puc, Int iStride ) // DC prediction
{
  Int n, m;
  UInt uiDcValue = 0;

  if( ! xIsLeftRef() )
  {
    if( ! xIsAboveRef() )
    {
      uiDcValue = 0x80;
    }
    else
    {
      for( n = 0; n < 16; n++ )
      {
        uiDcValue += puc[n - iStride];
      }
      uiDcValue += 8;
      uiDcValue >>= 4;
    }
  }
  else
  {
    for( m = -1, n = 0; n < 16; n++, m+= iStride )
    {
      uiDcValue += puc[m];
    }

    if( ! xIsAboveRef() )
    {
      uiDcValue += 8;
      uiDcValue >>= 4;
    }
    else
    {
      for( n = 0; n < 16; n++ )
      {
        uiDcValue += puc[n - iStride];
      }
      uiDcValue += 16;
      uiDcValue >>= 5;
    }
  }


  for( n = 0; n < 16; n++ )
  {
    for( m = 0; m < 16; m++ )
    {
      puc[m] = uiDcValue;
    }
    puc += iStride;
  }
}


Void IntraPrediction::xPred16x16IMode3Plane( XPel* puc, Int iStride ) // plane prediction
{
  Int n, m;
  Int iH = 0;
  Int iV = 0;

  AOF( xIsAllLeftAboveRef() );

  XPel* pucDes = puc;

  puc += 7 - iStride;
  for( n = 1; n < 9; n++ )
  {
    iH += n * (Int)(puc[n] - puc[-n]);
  }

  puc += (iStride << 3) - 8;
  for( m = iStride, n = 1; n < 9; n++, m += iStride)
  {
    iV += n * (Int)(puc[m] - puc[-m]);
  }
  puc -= 7 * iStride - 1;


  Int iB =  (5 * iH + 32) >> 6;
  Int iC =  (5 * iV + 32) >> 6;
  Int iA = 16 * (Int)(puc[(iStride << 4) - (iStride + 1)] + puc[ 15 - iStride ]);
  Int x, y;

  for( y = 0; y < 16; y++ )
  {
    Int iYSum = iA + (y-7) * iC + 16;
    for( x = 0; x < 16; x++ )
    {
      pucDes[x] = gClip((iYSum + (x-7) * iB) >> 5);
    }
    pucDes += iStride;
  }
}





Void IntraPrediction::xPredMode0Vert( XPel* puc, Int iStride ) // Vertical prediction
{
  //If A,B,C,D are inside the picture,
  AOF( xIsAboveRef() );

  ::memcpy( puc, puc - iStride, 4*sizeof(XPel) );
  puc += iStride;

  ::memcpy( puc, puc - iStride, 4*sizeof(XPel) );
  puc += iStride;

  ::memcpy( puc, puc - iStride, 4*sizeof(XPel) );
  puc += iStride;

  ::memcpy( puc, puc - iStride, 4*sizeof(XPel) );
}


Void IntraPrediction::xPredMode1Horiz( XPel* puc, Int iStride ) // Horizontal prediction
{
  // If E,F,G,H are inside the picture
  AOF( xIsLeftRef() );

  Int n;

  for( n=0; n<4; n++ )  puc[n] = puc[n-1];
  puc += iStride;

  for( n=0; n<4; n++ )  puc[n] = puc[n-1];
  puc += iStride;

  for( n=0; n<4; n++ )  puc[n] = puc[n-1];
  puc += iStride;

  for( n=0; n<4; n++ )  puc[n] = puc[n-1];
}