refframe.c

This document aims to provide instructions on how to configure the H.264/AVC encoder and decoder usi

        *lnPtr++ = clip8Buf[tmp];

        e = *((int16 *) (lnPtr + 6));
        *lnPtr++ = clip8Buf[b>>5];
        tmp = (f + 5*(-a + 4*(b + c) - d) + e) >> 10;
        *lnPtr++ = clip8Buf[tmp];
      }

      // Interpolate remaining (2 + picWidth - 3)%6 values
      for (j = j + 6; j > 0; j--) {
        f = *((int16 *) (lnPtr + 6));
        *lnPtr++ = clip8Buf[c>>5];
        tmp = (a + 5*(-b + 4*(c + d) - e) + f) >> 10;
        *lnPtr++ = clip8Buf[tmp];
        a = b;
        b = c;
        c = d;
        d = e;
        e = f;
      }

      // Interpolate 4 last values that are interpolated
      // across the picture border
      f = e;
      for (j = 4; j > 0; j--) {
        *lnPtr++ = clip8Buf[c>>5];
        tmp = (a + 5*(-b + 4*(c + d) - e) + f) >> 10;
        *lnPtr++ = clip8Buf[tmp];
        a = b;
        b = c;
        c = d;
        d = e;
      }

      // right extension, these pixels are indentical
      tmp = clip8Buf[e>>5];
      for (j = xExt-1; j > 0; j--)
      {
        // right boundary
        *lnPtr++ = (u_int8) tmp;
        *lnPtr++ = (u_int8) tmp;
      }

      lnPtr += extBufWidth;
    }

  }
}


/*
 *
 * refFrmPartialSum8x8:
 *
 * Parameters:
 *      yBufIn               Luma pixels
 *      seaYBufIn            SEA buffer
 *      picWidth             Picture width in pixels
 *      picHeight            Picture height in pixels
 *      xExt                 Reference frame x-extension in pixels
 *      yExt                 Reference frame y-extension in pixels
 *
 * Function:
 *      Calculate 8x8 partial sum.
 *
 * Returns:
 *      -
 */
void refFrmPartialSum8x8(u_int8  *yBufIn, u_int16 *seaYBufIn,
                         int picWidth, int picHeight, int xExt, int yExt)
{
  u_int8 *yBuf;
  u_int16 *seaYBuf;
  int bufWidth;
  int i, j;
  u_int32 sum;
  u_int32 borderPixel;
  u_int32 tmp;

  bufWidth = picWidth + 2*xExt;

  yBuf = yBufIn;
  seaYBuf = seaYBufIn + yExt*bufWidth;

  // calculate partial sums horizontally
  for (i = 0; i < picHeight; i++)
  {
    borderPixel = *yBuf++;

    // left border pixels
    sum = borderPixel * 8;
    for (j = xExt-8+2; j > 0; j--)
      *seaYBuf++ = (u_int16) sum;

    // sum over picture border
    for (j = 8; j > 0; j--) {
      sum -= borderPixel;
      sum += *yBuf++;
      *seaYBuf++ = (u_int16) sum;
    }

    // middle picture
    for (j = picWidth-8+1-3; j > 0; j--) {
      sum -= yBuf[-8];
      sum += *yBuf++;
      *seaYBuf++ = (u_int16) sum;
    }

    borderPixel = *yBuf;
    yBuf -= 8;

    // sum over picture border
    for (j = 7; j > 0; j--) {
      sum -= *yBuf++;
      sum += borderPixel;
      *seaYBuf++ = (u_int16) sum;
    }

    // right border pixels
    sum = borderPixel * 8;
    for (j = xExt-8+2; j > 0; j--)
      *seaYBuf++ = (u_int16) sum;

    *seaYBuf++ = (u_int16) sum;

    yBuf += 2;
    seaYBuf += 6;
  }

  // sum up 1-D partial sums vertically to get 2-D partial sum
#if 0
  for (j = 0; j < bufWidth - 7; j ++)
  {
    seaYBuf = seaYBufIn + j;

    borderPixel = seaYBuf[yExt * bufWidth];

    // top border pixels only
    sum = borderPixel * 8;
    for (i = yExt-8+2; i > 0; i--, seaYBuf+=bufWidth)
      *seaYBuf = (u_int16) sum;

    // sum over picture border
    for (i = 6; i > 0; i--, seaYBuf+=bufWidth) {
      sum -= borderPixel;
      sum += seaYBuf[7*bufWidth];
      *seaYBuf = (u_int16) sum;
    }

    sum -= borderPixel;

    // middle picture
    for (i = picHeight-8+1-1; i > 0; i--, seaYBuf+=bufWidth) {
      sum += seaYBuf[7*bufWidth];
      tmp  = seaYBuf[0];
      seaYBuf[0] = (u_int16) sum;
      sum -= tmp;
    }

    borderPixel = seaYBuf[7*bufWidth];

    // sum over picture border
    for (i = 7; i > 0; i--, seaYBuf+=bufWidth) {
      sum += borderPixel;
      tmp  = seaYBuf[0];
      seaYBuf[0] = (u_int16) sum;
      sum -= tmp;
    }

    // bottom border pixels
    sum = borderPixel * 8;
    for (i = yExt-8+2; i > 0; i--, seaYBuf+=bufWidth)
      *seaYBuf = (u_int16) sum;
  }
#else
  // this is a SIMD version, i.e. it generates two 16 bits sums in one 32 bit variable
  for (j = 0; j < bufWidth - 6; j += 2)
  {
    seaYBuf = seaYBufIn + j;

    borderPixel = *((u_int32 *)(seaYBuf + yExt * bufWidth));

    // top border pixels only
    sum = borderPixel * 8;
    for (i = yExt-8+2; i > 0; i--, seaYBuf+=bufWidth)
      *((u_int32 *)seaYBuf) = sum;

    // sum over picture border
    for (i = 6; i > 0; i--, seaYBuf+=bufWidth) {
      sum -= borderPixel;
      sum += *((u_int32 *)(seaYBuf + 7*bufWidth));
      *((u_int32 *)seaYBuf) = sum;
    }

    sum -= borderPixel;

    // middle picture
    for (i = picHeight-8+1-1; i > 0; i--, seaYBuf+=bufWidth) {
      sum += *((u_int32 *)(seaYBuf + 7*bufWidth));
      tmp  = *((u_int32 *)seaYBuf);
      *((u_int32 *)seaYBuf) = sum;
      sum -= tmp;
    }

    borderPixel = *((u_int32 *)(seaYBuf + 7*bufWidth));

    // sum over picture border
    for (i = 7; i > 0; i--, seaYBuf+=bufWidth) {
      sum += borderPixel;
      tmp  = *((u_int32 *)seaYBuf);
      *((u_int32 *)seaYBuf) = sum;
      sum -= tmp;
    }

    // bottom border pixels
    sum = borderPixel * 8;
    for (i = yExt-8+2; i > 0; i--, seaYBuf+=bufWidth)
      *((u_int32 *)seaYBuf) = sum;
  }
#endif
} 


/*
 *
 * refFrmUpsampleLuma
 *
 * Parameters:
 *      pRefFrm         Reference frame object
 *      reco            y component of reconstructed frame
 *      low_complex_prof3   Low complexity profile 3
 *      use_search_win  Use internal search window
 *      reconstFrm      Previous reconstructed frame, use by internal search window
 *
 * Function:
 *      Make a new luma reference frame buffer from luma reconstruction frame
 *      buffer by upsampling with factor of 2 horizontally and vertically.
 *
 * Returns:
 *      -
 */
void refFrmUpsampleLuma(refFrmBuf_s *pRefFrm, u_int8 *reco, int low_complex_prof3)
{
  // constraints on boundary extension, could be enforced at the top level

  // the following functions do not if work extension smaller than 4 pixels
  assert((pRefFrm->xExt >= 4) && (pRefFrm->yExt >= 4));

  // make line buffer aligned at at leeat 4-byte boundary
  assert(((pRefFrm->xExt & 3) == 0) && ((pRefFrm->yExt & 3) == 0));



  // calculate partial sum for Successive Elimination Algorithm Implementation

  //   : take away partial
  if (!low_complex_prof3)
    refFrmPartialSum8x8(reco, pRefFrm->seaYBuf,
                      pRefFrm->picWidth, pRefFrm->picHeight,
                      pRefFrm->xExt, pRefFrm->yExt);



  //  : here upsample frame!!!  reco is prev output frame, pRefFrm->yBuf use later

  refFrmUpsampleLumaH(reco, pRefFrm->yBuf, pRefFrm->picWidth,
                      pRefFrm->picHeight, pRefFrm->xExt, pRefFrm->yExt);

  refFrmUpsampleLumaV(pRefFrm->yBuf, pRefFrm->picWidth, pRefFrm->picHeight,
                      pRefFrm->xExt, pRefFrm->yExt);

//  DumpRefY(pRefFrm);
}


/*
 *
 * refFrmExtendChroma:
 *
 * Parameters:
 *      frame                 Frame object
 *      pRefFrm               Reference frame buffer
 *
 * Function:
 *      Make a new chroma reference frame buffer from chroma reconstruction
 *      frame buffer. Chroma reference frame buffers are not stored in
 *      upsampled form. Therefore, we can make reference frame just by copying
 *      pointers.
 *
 * Returns:
 *      -
 */
void refFrmExtendChroma(refFrmBuf_s *pRefFrm, u_int8 *recoU, u_int8 *recoV)
{
  int c, i, j;
  int xExt, yExt;                         // extension for chroma
  int picWidth, picHeight, extBufWidth;   // sizes for chroma
  u_int8 *srcLine, *dstLine;

  // boundary extension is performed
  picWidth    = pRefFrm->picWidth >> 1;
  picHeight   = pRefFrm->picHeight >> 1;
  extBufWidth = pRefFrm->cBufWidth;

  xExt = pRefFrm->xExt >> 1;
  yExt = pRefFrm->yExt >> 1;

  srcLine = recoU;
  dstLine = pRefFrm->uBuf + xExt;
  for (c = 0; c < 2; c ++)
  {
    for (i = -yExt; i < picHeight + yExt; i ++)
    {
      memcpy(dstLine, srcLine, picWidth);

      // horizontal extension
      for (j = 0; j < xExt; j ++)
      {
        dstLine[-1 - j]       = srcLine[0];
        dstLine[picWidth + j] = srcLine[picWidth - 1];
      }

      // so the first line is extended up and the last line is extended down
      if ((i >= 0) && (i < picHeight - 1))
        srcLine += picWidth;

      dstLine += extBufWidth;
    }

    // process v
    srcLine = recoV;
    dstLine = pRefFrm->vBuf + xExt;
  }
}
void refFrmStoreChannelDistortion(refFrmBuf_s *pRefFrm, int *channelDistortion)
{
  int numMbs;

  numMbs = pRefFrm->picWidth/MBK_SIZE * pRefFrm->picHeight/MBK_SIZE;
  if (pRefFrm->channelDistortion && channelDistortion) {
    memcpy(pRefFrm->channelDistortion, channelDistortion, numMbs*sizeof(int));
  }
}