motcomp.c

Nokia H.264/AVC Encoder/Decoder Usage Manual

        blkAddr = mpBlkAddr + (modeBlkIndices[subMbMode + 1][i - lastNumVecs] >> 1);

      mrPair = & blkInfo[blkAddr];
      predVec = mcpFindPredMv(pMb, mrPair->ref, blkMode, blkAddr);

      pMb->diffVecs[i][0] = (int16)(mrPair->mv.x - predVec.x);
      pMb->diffVecs[i][1] = (int16)(mrPair->mv.y - predVec.y);

      mvBits += vlcGetMvBits(pMb->diffVecs[i][0], pMb->diffVecs[i][1]);
    }
  }

  if (interMode == MOT_8x8)
  {
    if ((pMb->refIndices[0] | pMb->refIndices[1] | pMb->refIndices[2] | 
      pMb->refIndices[3]) == 0)
    {
      if (refIdxRange > 1)
        mvBits -= 4;
    }
  }
  // else, no reference frame indices are sent at all

  pMb->numVecs = numVecs;

  return mvBits;
}


extern const int16 bufOffs[4][4][2];
int8 mcpModePartWidth[5]  = {4, 4, 4, 2, 1};
int8 mcpModePartHeight[5] = {4, 4, 2, 4, 1};


/*
 * mcpGetQuarterPixels:
 *
 * Parameters:
 *      ref                 ref frame buffer, luma, adjusted for partition
 *      w                   ref frame buffer width
 *      vecX                Motion vector, x component, in 1/4 pixel
 *      vecY                Motion vector, y component, in 1/4 pixel
 *      mbPartW             MB partition width
 *      mbPartH             MB partition height
 *      pred                Predict pixel buffer, adjusted for partition
 *      bufOffs             Offsets in accessing reference pixels
 *
 * Function:
 *      Get luma pixels from the reference frame buffer. Perform quarter
 *      pixel interpolation if necessary.
 *
 * Returns:
 *      -
 */
void mcpGetQuarterPixels(u_int8 *ref, 
                         int    w, 
                         int    vecX, 
                         int    vecY,
                         int    mbPartW, 
                         int    mbPartH,
                         u_int8 pred[][16]
                         )
{
  int i, j, dx, dy;
  u_int8 *ref2;

  if (((vecX | vecY) & 1) == 0) 
  {
    // integer or half-pixel locations, already interpolated
    for (j = 0; j < mbPartH; j ++) {
      for (i = 0; i < mbPartW; i += BLK_SIZE) {
        pred[j][i + 0] = ref[i * 2 + 0];
        pred[j][i + 1] = ref[i * 2 + 2];
        pred[j][i + 2] = ref[i * 2 + 4];
        pred[j][i + 3] = ref[i * 2 + 6];
      }
      ref += (2 * w);
    }
  }
  else 
  {
    dx = vecX & 3;
    dy = vecY & 3;

    // do not swap these 2 lines
    ref2 = & ref[bufOffs[dy][dx][1]];
    ref  = & ref[bufOffs[dy][dx][0]];

    for (j = 0; j < mbPartH; j ++) {
      for (i = 0; i < mbPartW; i += BLK_SIZE) {
        pred[j][i + 0] = (u_int8)((ref[i * 2 + 0] + ref2[i * 2 + 0] + 1) >> 1);
        pred[j][i + 1] = (u_int8)((ref[i * 2 + 2] + ref2[i * 2 + 2] + 1) >> 1);
        pred[j][i + 2] = (u_int8)((ref[i * 2 + 4] + ref2[i * 2 + 4] + 1) >> 1);
        pred[j][i + 3] = (u_int8)((ref[i * 2 + 6] + ref2[i * 2 + 6] + 1) >> 1);
      }
      ref  += (2 * w);
      ref2 += (2 * w);
    }

  }
}


/*
 * mcpGetPred
 *
 * Parameters:
 *      pMb                 Macroblock information
 *      refBufList          Reference frames
 *
 * Function:
 *      Compute luminance and chrominance prediction for the current
 *      macroblock using motion vector found.
 *
 * Returns:
 *      -
 */
void mcpGetPred(macroblock_s *pMb,
                refFrmBuf_s  **refBufList)
{
  int blkIdxX, blkIdxY;
  int shapeX, shapeY, mbPartW, mbPartH, mbPartChromaW, mbPartChromaH;
  int i0, j0;
  int c, i, j;
  int dx, dy;
  int yBufWidth, cBufWidth;
  u_int8 *refPtr, *predPtr, *predPtrC;
  refFrmBuf_s *pRefFrm;



  yBufWidth = refBufList[0]->yBufWidth;
  cBufWidth = refBufList[0]->cBufWidth;

  shapeX = mcpModePartWidth[pMb->interMode];
  shapeY = mcpModePartHeight[pMb->interMode];
  mbPartW = shapeX * BLK_SIZE;
  mbPartH = shapeY * BLK_SIZE;
  mbPartChromaW = mbPartW >> 1;
  mbPartChromaH = mbPartH >> 1;

  for (blkIdxY = 0; blkIdxY < BLK_PER_MB; blkIdxY += shapeY) {
    for (blkIdxX = 0; blkIdxX < BLK_PER_MB; blkIdxX += shapeX) {
      blkState_s *pBlkState;

      // Absolute motion vector coordinates of the macroblock
      pBlkState = & pMb->current[blkIdxY][blkIdxX];
      predPtr   = & pMb->predY[blkIdxY*BLK_SIZE][blkIdxX*BLK_SIZE];

      i0 = (pMb->idxX * BLK_PER_MB + blkIdxX) * BLK_SIZE * 4 + 
        pBlkState->mv.x;
      j0 = (pMb->idxY * BLK_PER_MB + blkIdxY) * BLK_SIZE * 4 + 
        pBlkState->mv.y;

      pRefFrm = refBufList[pBlkState->ref];
      refPtr  = & pRefFrm->y[(j0 >> 1) * yBufWidth + (i0 >> 1)];

        mcpGetQuarterPixels(refPtr, yBufWidth, i0, j0, mbPartW, mbPartH, 
          (u_int8 (*)[MBK_SIZE]) predPtr);

      dx = i0 & 7;
      dy = j0 & 7;
      i0 = i0 >> 3;
      j0 = j0 >> 3;

      /* Chroma vectors have 1/8 pel precision, Bilinear interpolation */

      refPtr = pRefFrm->u;
      for (c = 0; c < 16; c += 8) {  // 2 chroma components
        int h0, h1;
        u_int8 *upPoint;

        predPtrC = & pMb->predC[blkIdxY*(BLK_SIZE/2)][blkIdxX * (BLK_SIZE/2)] + c;
        refPtr = & refPtr[j0 * cBufWidth + i0];

        for (j = 0; j < mbPartChromaH; j ++) {
          upPoint = refPtr;
          h0 = 8 * upPoint[0] - (upPoint[0] - upPoint[cBufWidth]) * dy;
          upPoint ++;
          for (i = 0; i < mbPartChromaW; i += 2) {
            h1 = 8 * upPoint[i    ] - (upPoint[i    ] - upPoint[cBufWidth + i    ]) * dy;
            predPtrC[j * 16 + i    ] = (u_int8) ((8*h0 - (h0 - h1)*dx + 32) >> 6);
            h0 = 8 * upPoint[i + 1] - (upPoint[i + 1] - upPoint[cBufWidth + i + 1]) * dy;
            predPtrC[j * 16 + i + 1] = (u_int8) ((8*h1 - (h1 - h0)*dx + 32) >> 6);
          }
          refPtr += cBufWidth;
        }

        refPtr = pRefFrm->v;
      }
    }
  }

}

/*
 * mcpGetColocatedMb
 *
 * Parameters:
 *      pMb                 Macroblock information
 *      refBufList          Reference frames
 *
 * Function:
 *      Get the colocated MB from the last picture (in display order).
 *
 * Returns:
 *      -
 */
void mcpGetColocatedMb(macroblock_s *pMb,
                       refFrmBuf_s  **refBufList,
                       u_int8 colMbY[MBK_SIZE][MBK_SIZE],
                       u_int8 colMbC[MBK_SIZE/2][2 * (MBK_SIZE/2)])
{
  int blkIdxX, blkIdxY;
  int shapeX, shapeY, mbPartW, mbPartH, mbPartChromaW, mbPartChromaH;
  int i0, j0;
  int c, i, j;
  int dx, dy;
  int yBufWidth, cBufWidth;
  u_int8 *refPtr, *predPtr, *predPtrC;
  refFrmBuf_s *pRefFrm;



  yBufWidth = refBufList[0]->yBufWidth;
  cBufWidth = refBufList[0]->cBufWidth;

  shapeX = mcpModePartWidth[pMb->interMode];
  shapeY = mcpModePartHeight[pMb->interMode];
  mbPartW = shapeX * BLK_SIZE;
  mbPartH = shapeY * BLK_SIZE;
  mbPartChromaW = mbPartW >> 1;
  mbPartChromaH = mbPartH >> 1;

  for (blkIdxY = 0; blkIdxY < BLK_PER_MB; blkIdxY += shapeY) {
    for (blkIdxX = 0; blkIdxX < BLK_PER_MB; blkIdxX += shapeX) {

      // Absolute motion vector coordinates of the macroblock
      predPtr   = & colMbY[blkIdxY*BLK_SIZE][blkIdxX*BLK_SIZE];

      i0 = (pMb->idxX * BLK_PER_MB + blkIdxX) * BLK_SIZE * 4;
      j0 = (pMb->idxY * BLK_PER_MB + blkIdxY) * BLK_SIZE * 4;

      pRefFrm = refBufList[0];
      refPtr  = & pRefFrm->y[(j0 >> 1) * yBufWidth + (i0 >> 1)];

      mcpGetQuarterPixels(refPtr, yBufWidth, i0, j0, mbPartW, mbPartH, 
          (u_int8 (*)[MBK_SIZE]) predPtr);

      dx = i0 & 7;
      dy = j0 & 7;
      i0 = i0 >> 3;
      j0 = j0 >> 3;

      /* Chroma vectors have 1/8 pel precision, Bilinear interpolation */

      refPtr = pRefFrm->u;
      for (c = 0; c < 16; c += 8) {  // 2 chroma components
        int h0, h1;
        u_int8 *upPoint;

        predPtrC = & colMbC[blkIdxY*(BLK_SIZE/2)][blkIdxX * (BLK_SIZE/2)] + c;
        refPtr = & refPtr[j0 * cBufWidth + i0];

        for (j = 0; j < mbPartChromaH; j ++) {
          upPoint = refPtr;
          h0 = 8 * upPoint[0] - (upPoint[0] - upPoint[cBufWidth]) * dy;
          upPoint ++;
          for (i = 0; i < mbPartChromaW; i += 2) {
            h1 = 8 * upPoint[i    ] - (upPoint[i    ] - upPoint[cBufWidth + i    ]) * dy;
            predPtrC[j * 16 + i    ] = (u_int8) ((8*h0 - (h0 - h1)*dx + 32) >> 6);
            h0 = 8 * upPoint[i + 1] - (upPoint[i + 1] - upPoint[cBufWidth + i + 1]) * dy;
            predPtrC[j * 16 + i + 1] = (u_int8) ((8*h1 - (h1 - h0)*dx + 32) >> 6);
          }
          refPtr += cBufWidth;
        }

        refPtr = pRefFrm->v;
      }
    }
  }

}