img_luma.c

H.264编码实现

      wxLineDst[ipad] = (imgpel) iClip1 (img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
    }
  }
  // center
  for (jpad = 2; jpad < ypadded_size - 3; jpad++)
  {
    wxLineDst = dstImg[jpad];
    srcImgA = srcImg[jpad ];
    srcImgB = srcImg[jpad - 1];      
    srcImgC = srcImg[jpad - 2];
    srcImgD = srcImg[jpad + 1];
    srcImgE = srcImg[jpad + 2];
    srcImgF = srcImg[jpad + 3];
    for (ipad = 0; ipad < xpadded_size; ipad++)
    {
      is =
        (tap0 * (*srcImgA++ + *srcImgD++) +
        tap1 *  (*srcImgB++ + *srcImgE++) +
        tap2 *  (*srcImgC++ + *srcImgF++));

      wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
    }
  }

  // bottom
  for (jpad = ypadded_size - 3; jpad < ypadded_size; jpad++)
  {
    wxLineDst = dstImg[jpad];
    srcImgA = srcImg[jpad ];
    srcImgB = srcImg[jpad - 1];      
    srcImgC = srcImg[jpad - 2];
    srcImgD = srcImg[imin (maxy, jpad + 1)];
    srcImgE = srcImg[maxy];
    srcImgF = srcImg[maxy];
    for (ipad = 0; ipad < xpadded_size; ipad++)
    {
      is =
        (tap0 * (*srcImgA++ + *srcImgD++) +
        tap1 *  (*srcImgB++ + *srcImgE++) +
        tap2 *  (*srcImgC++ + *srcImgF++));

      wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
    }
  }
}

/*!
 ************************************************************************
 * \brief
 *    Does _vertical_ interpolation using the SIX TAP filters
 *
 * \param s
 *    pointer to StorablePicture structure
 * \param dstImg
 *    pointer to target image
 * \param srcImg
 *    pointer to source image
 ************************************************************************
 */
void getVerSubImageSixTapTmp( StorablePicture *s, imgpel **dstImg, imgpel **srcImg)
{
  int is, jpad, ipad;
  int ypadded_size = s->size_y_padded;
  int xpadded_size = s->size_x_padded;
  int maxy = ypadded_size - 1;

  static imgpel *wxLineDst;
  static int *srcImgA, *srcImgB, *srcImgC, *srcImgD, *srcImgE, *srcImgF;
  const int tap0 = ONE_FOURTH_TAP[0][0];
  const int tap1 = ONE_FOURTH_TAP[0][1];
  const int tap2 = ONE_FOURTH_TAP[0][2];

  // top
  for (jpad = 0; jpad < 2; jpad++)
  {
    wxLineDst = dstImg[jpad];
    srcImgA = imgY_sub_tmp[jpad ];
    srcImgB = imgY_sub_tmp[0];      
    srcImgC = imgY_sub_tmp[0];
    srcImgD = imgY_sub_tmp[jpad + 1];
    srcImgE = imgY_sub_tmp[jpad + 2];
    srcImgF = imgY_sub_tmp[jpad + 3];

    for (ipad = 0; ipad < xpadded_size; ipad++)
    {
      is =
        (tap0 * (*srcImgA++ + *srcImgD++) +
        tap1 *  (*srcImgB++ + *srcImgE++) +
        tap2 *  (*srcImgC++ + *srcImgF++));

      wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
    }
  }

  // center
  for (jpad = 2; jpad < ypadded_size - 3; jpad++)
  {
    wxLineDst = dstImg[jpad];
    srcImgA = imgY_sub_tmp[jpad ];
    srcImgB = imgY_sub_tmp[jpad - 1];      
    srcImgC = imgY_sub_tmp[jpad - 2];
    srcImgD = imgY_sub_tmp[jpad + 1];
    srcImgE = imgY_sub_tmp[jpad + 2];
    srcImgF = imgY_sub_tmp[jpad + 3];
    for (ipad = 0; ipad < xpadded_size; ipad++)
    {
      is =
        (tap0 * (*srcImgA++ + *srcImgD++) +
        tap1 *  (*srcImgB++ + *srcImgE++) +
        tap2 *  (*srcImgC++ + *srcImgF++));

      wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
    }
  }

  // bottom
  for (jpad = ypadded_size - 3; jpad < ypadded_size; jpad++)
  {
    wxLineDst = dstImg[jpad];
    srcImgA = imgY_sub_tmp[jpad ];
    srcImgB = imgY_sub_tmp[jpad - 1];      
    srcImgC = imgY_sub_tmp[jpad - 2];
    srcImgD = imgY_sub_tmp[imin (maxy, jpad + 1)];
    srcImgE = imgY_sub_tmp[maxy];
    srcImgF = imgY_sub_tmp[maxy];
    for (ipad = 0; ipad < xpadded_size; ipad++)
    {
      is =
        (tap0 * (*srcImgA++ + *srcImgD++) +
        tap1 *  (*srcImgB++ + *srcImgE++) +
        tap2 *  (*srcImgC++ + *srcImgF++));

      wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
    }
  }
}

/*!
 ************************************************************************
 * \brief
 *    Does _horizontal_ interpolation using the BiLinear filter
 *
 * \param s
 *    pointer to StorablePicture structure
 * \param dstImg
 *    destination Image
 * \param srcImgL
 *    source left image
 * \param srcImgR
 *    source right image 
 ************************************************************************
 */
void getSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgL, imgpel **srcImgR)
{
  int jpad, ipad;
  int ypadded_size = s->size_y_padded;
  int xpadded_size = s->size_x_padded;

  static imgpel *wBufSrcL, *wBufSrcR, *wBufDst;

  for (jpad = 0; jpad < ypadded_size; jpad++)
  {
    wBufSrcL = srcImgL[jpad]; // 4:4:4 independent mode
    wBufSrcR = srcImgR[jpad]; // 4:4:4 independent mode
    wBufDst  = dstImg[jpad];  // 4:4:4 independent mode

    for (ipad = 0; ipad < xpadded_size; ipad++)
    {
      *wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + *wBufSrcR++, 1 );
    }
  }
}


/*!
 ************************************************************************
 * \brief
 *    Does _horizontal_ interpolation using the BiLinear filter
 *
 * \param s
 *    pointer to StorablePicture structure
 * \param dstImg
 *    destination Image
 * \param srcImgL
 *    source left image
 * \param srcImgR
 *    source right image 
 ************************************************************************
 */
void getHorSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgL, imgpel **srcImgR)
{
  int jpad, ipad;
  int ypadded_size = s->size_y_padded;
  int xpadded_size = s->size_x_padded - 1;

  static imgpel *wBufSrcL, *wBufSrcR, *wBufDst;

  for (jpad = 0; jpad < ypadded_size; jpad++)
  {
    wBufSrcL = srcImgL[jpad]; // 4:4:4 independent mode
    wBufSrcR = &srcImgR[jpad][1]; // 4:4:4 independent mode
    wBufDst  = dstImg[jpad];     // 4:4:4 independent mode

    // left padded area + center
    for (ipad = 0; ipad < xpadded_size; ipad++)
    {
      *wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + *wBufSrcR++, 1 );
    }
    // right padded area
      *wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + wBufSrcR[-1], 1 );
  }
}


/*!
 ************************************************************************
 * \brief
 *    Does _vertical_ interpolation using the BiLinear filter
 *
 * \param s
 *    pointer to StorablePicture structure
 * \param dstImg
 *    destination Image
 * \param srcImgT
 *    source top image
 * \param srcImgB
 *    source bottom image 
 ************************************************************************
 */
void getVerSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgT, imgpel **srcImgB)
{
  int jpad, ipad;
  int ypadded_size = s->size_y_padded - 1;
  int xpadded_size = s->size_x_padded;  

  static imgpel *wBufSrcT, *wBufSrcB, *wBufDst;

  // top
  for (jpad = 0; jpad < ypadded_size; jpad++)
  {
    wBufSrcT = srcImgT[jpad];           // 4:4:4 independent mode
    wBufDst  = dstImg[jpad];            // 4:4:4 independent mode
    wBufSrcB = srcImgB[jpad + 1];  // 4:4:4 independent mode

    for (ipad = 0; ipad < xpadded_size; ipad++)
    {
      *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcT++ + *wBufSrcB++, 1);
    }
  }
  // bottom
  wBufSrcT = srcImgT[ypadded_size];           // 4:4:4 independent mode
  wBufDst  = dstImg[ypadded_size];            // 4:4:4 independent mode
  wBufSrcB = srcImgB[ypadded_size];           // 4:4:4 independent mode

  for (ipad = 0; ipad < xpadded_size; ipad++)
  {
    *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcT++ + *wBufSrcB++, 1);
  }
}


/*!
 ************************************************************************
 * \brief
 *    Does _diagonal_ interpolation using the BiLinear filter
 *
 * \param s
 *    pointer to StorablePicture structure
 * \param dstImg
 *    destination Image
 * \param srcImgT
 *    source top/left image
 * \param srcImgB
 *    source bottom/right image 
 ************************************************************************
 */
void getDiagSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgT, imgpel **srcImgB )
{
  int jpad, ipad;
  int maxx = s->size_x_padded - 1;
  int maxy = s->size_y_padded - 1;

  static imgpel *wBufSrcL, *wBufSrcR, *wBufDst;

  for (jpad = 0; jpad < maxy; jpad++)
  {
    wBufSrcL = srcImgT[jpad + 1]; // 4:4:4 independent mode
    wBufSrcR = &srcImgB[jpad][1]; // 4:4:4 independent mode
    wBufDst  = dstImg[jpad];      // 4:4:4 independent mode

    for (ipad = 0; ipad < maxx; ipad++)
    {
      *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + *wBufSrcR++, 1);
    }

    *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ +  wBufSrcR[-1], 1);
  }

  wBufSrcL = srcImgT[maxy];     // 4:4:4 independent mode
  wBufSrcR = &srcImgB[maxy][1]; // 4:4:4 independent mode
  wBufDst = dstImg[maxy];       // 4:4:4 independent mode

  for (ipad = 0; ipad < maxx; ipad++)
  {
    *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + *wBufSrcR++, 1);
  }

    *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + wBufSrcR[-1], 1);
}