mcenc.cpp

完整的RTP RTSP代码库

					   &m_rctRefVOPY0); // added by Y.Suzuki for the extended bounding box support

    if (m_volmd.bQuarterSample) // Quarter sample, added by mwi
          motionCompQuarterSample (
                                   m_ppxlcPredMBBackY, 
                                   m_pvopcRefQ1->pixelsY () + pmbmd->m_bBackwardTop * m_iFrameWidthY,
                                   0,
                                   xQP + 2*pmvBakTop->iMVX + pmvBakTop->iHalfX,
                                   yQP + 2*pmvBakTop->iMVY + pmvBakTop->iHalfY,
                                   m_vopmd.iRoundingControl, &m_rctRefVOPY1
                                   );
    else      
      motionCompYField(m_ppxlcPredMBBackY,
                       m_pvopcRefQ1->pixelsY () + pmbmd->m_bBackwardTop * m_iFrameWidthY,
                       x + pmvBakTop->m_vctTrueHalfPel.x, y + pmvBakTop->m_vctTrueHalfPel.y,
                      &m_rctRefVOPY1); // added by Y.Suzuki for the extended bounding box support

    if (m_volmd.bQuarterSample) // Quarter sample, added by mwi
          motionCompQuarterSample (
                                   m_ppxlcPredMBBackY + MB_SIZE, 
                                   m_pvopcRefQ1->pixelsY () + pmbmd->m_bBackwardBottom * m_iFrameWidthY,
                                   0,
                                   xQP + 2*pmvBakBot->iMVX + pmvBakBot->iHalfX,
                                   yQP + 2*pmvBakBot->iMVY + pmvBakBot->iHalfY,
                                   m_vopmd.iRoundingControl, &m_rctRefVOPY1
                                   );
    else      
      motionCompYField(m_ppxlcPredMBBackY + MB_SIZE,
                       m_pvopcRefQ1->pixelsY () + pmbmd->m_bBackwardBottom * m_iFrameWidthY,
                       x + pmvBakBot->m_vctTrueHalfPel.x, y + pmvBakBot->m_vctTrueHalfPel.y,
                      &m_rctRefVOPY1); // added by Y.Suzuki for the extended bounding box support
	
	Int ic;
	Int iSAD = 0;
// new changes by X. Chen
	if (pmbmd->m_rgTranspStatus[0]==NONE) {
		for (ic = 0; ic < MB_SQUARE_SIZE; ic++)
			iSAD += abs (m_ppxlcCurrMBY [ic] - ((m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1));
	} else if (pmbmd->m_rgTranspStatus[0]==PARTIAL) {
		for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
			if (m_ppxlcCurrMBBY [ic] != transpValue)
				iSAD += abs (m_ppxlcCurrMBY [ic] - ((m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1));
		}
	}
// end of new changes
	return iSAD;
}

// for QuarterPel MC
Int CVideoObjectEncoder::interpolateAndDiffY8 (
	const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
	CoordI x, CoordI y,Int iBlkNo,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
    )
{
  Int iOffset = 0;
  CoordI iOffX = 0, iOffY = 0;
  const CMotionVector *pmvFblk, *pmvBblk;
  
  if (iBlkNo == 1) {
    iOffset = 0;
    iOffX = 0;
    iOffY = 0;
  }
  else if (iBlkNo == 2) {
    iOffset = OFFSET_BLK1;
    iOffX = BLOCK_SIZE;
    iOffY = 0;
  }
  else if (iBlkNo == 3) {
    iOffset = OFFSET_BLK2;
    iOffX = 0;
    iOffY = BLOCK_SIZE;
  }
  else if (iBlkNo == 4) {
    iOffset = OFFSET_BLK3;
    iOffX = BLOCK_SIZE;
    iOffY = BLOCK_SIZE;
  }
  
  pmvFblk = pmvForward + iBlkNo;
  pmvBblk = pmvBackward + iBlkNo;
  
  if (!m_volmd.bQuarterSample) {
	motionCompEncY (
                    m_pvopcRefQ0->pixelsY (), 
                    m_puciRefQZoom0->pixels (),
                    m_ppxlcPredMBY + iOffset, BLOCK_SIZE, pmvFblk, x+iOffX, y+iOffY,
                    prctMVLimitForward
                    );

	motionCompEncY (
                    m_pvopcRefQ1->pixelsY (), 
                    m_puciRefQZoom1->pixels (),
                    m_ppxlcPredMBBackY + iOffset, BLOCK_SIZE, pmvBblk, x+iOffX, y+iOffY,
                    prctMVLimitBackward
                    );
  }
  else {
    motionCompQuarterSample (m_ppxlcPredMBY + iOffset,
                             m_pvopcRefQ0->pixelsY (), 
                             BLOCK_SIZE,
                             4*(x+iOffX) + 2 * pmvFblk->iMVX + pmvFblk->iHalfX,
                             4*(y+iOffY) + 2 * pmvFblk->iMVY + pmvFblk->iHalfY,
                             m_vopmd.iRoundingControl,
                             prctMVLimitForward
                             );

    motionCompQuarterSample (m_ppxlcPredMBBackY + iOffset,
                             m_pvopcRefQ1->pixelsY (), 
                             BLOCK_SIZE,
                             4*(x+iOffX) + 2 * pmvBblk->iMVX + pmvBblk->iHalfX,
                             4*(y+iOffY) + 2 * pmvBblk->iMVY + pmvBblk->iHalfY,
                             m_vopmd.iRoundingControl,
                             prctMVLimitBackward
                             );
  }
  
  Int ix,iy;
  Int iSAD = 0;
  for (iy = 0; iy < BLOCK_SIZE; iy++) {
    for (ix = 0; ix < BLOCK_SIZE; ix++) {
      iSAD += abs (m_ppxlcCurrMBY [ix+iOffX+MB_SIZE*(iy+iOffY)] - 
                   ((m_ppxlcPredMBY [ix+iOffX+MB_SIZE*(iy+iOffY)] + 
                     m_ppxlcPredMBBackY [ix+iOffX+MB_SIZE*(iy+iOffY)] + 1) >> 1));
    }
  }
    
  return iSAD;
}
// ~for QuarterPel MC

Void CVideoObjectEncoder::motionCompInterpAndError (
	const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
	CoordI x, CoordI y,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
)
{
  if (!m_volmd.bQuarterSample) {
	motionCompEncY (
                    m_pvopcRefQ0->pixelsY (), 
                    m_puciRefQZoom0->pixels (),
                    m_ppxlcPredMBY, MB_SIZE, pmvForward, x, y,
                    prctMVLimitForward
                    );
	motionCompEncY (
                    m_pvopcRefQ1->pixelsY (), 
                    m_puciRefQZoom1->pixels (),
                    m_ppxlcPredMBBackY, MB_SIZE, pmvBackward, x, y,
                    prctMVLimitBackward
                    );
  }
  else {
    motionCompQuarterSample (m_ppxlcPredMBY,
                             m_pvopcRefQ0->pixelsY (), 
                             MB_SIZE,
                             4*x + 2 * pmvForward->iMVX + pmvForward->iHalfX,
                             4*y + 2 * pmvForward->iMVY + pmvForward->iHalfY,
                             m_vopmd.iRoundingControl,
                             prctMVLimitForward
                             );

    motionCompQuarterSample (m_ppxlcPredMBBackY,
                             m_pvopcRefQ1->pixelsY (), 
                             MB_SIZE,
                             4*x + 2 * pmvBackward->iMVX + pmvBackward->iHalfX,
                             4*y + 2 * pmvBackward->iMVY + pmvBackward->iHalfY,
                             m_vopmd.iRoundingControl,
                             prctMVLimitBackward
                             );
  }
  Int ic;
  for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
    m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
    m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
  }
}

// for QuarterPel MC
Void CVideoObjectEncoder::motionCompInterpAndErrorDirect (
                                                          const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
                                                          CoordI x, CoordI y,
                                                          CRct *prctMVLimitForward,CRct *prctMVLimitBackward
                                                          )
{
  Int iOffset = 0, iBlkNo;
  CoordI iOffX = 0, iOffY = 0;
  const CMotionVector *pmvFblk, *pmvBblk;
  
  for (iBlkNo=1; iBlkNo<=4; iBlkNo++) {
    if (iBlkNo == 1) {
      iOffset = 0;
      iOffX = 0;
      iOffY = 0;
    }
    else if (iBlkNo == 2) {
      iOffset = OFFSET_BLK1;
      iOffX = BLOCK_SIZE;
      iOffY = 0;
    }
    else if (iBlkNo == 3) {
      iOffset = OFFSET_BLK2;
      iOffX = 0;
      iOffY = BLOCK_SIZE;
    }
    else if (iBlkNo == 4) {
      iOffset = OFFSET_BLK3;
      iOffX = BLOCK_SIZE;
      iOffY = BLOCK_SIZE;
    }
    pmvFblk = pmvForward + iBlkNo;
    pmvBblk = pmvBackward + iBlkNo;
  
    if (!m_volmd.bQuarterSample) {
      motionCompEncY (
                      m_pvopcRefQ0->pixelsY (), 
                      m_puciRefQZoom0->pixels (),
                      m_ppxlcPredMBY + iOffset, BLOCK_SIZE, pmvFblk, x+iOffX, y+iOffY,
                      prctMVLimitForward
                      );

      motionCompEncY (
                      m_pvopcRefQ1->pixelsY (), 
                      m_puciRefQZoom1->pixels (),
                      m_ppxlcPredMBBackY + iOffset, BLOCK_SIZE, pmvBblk, x+iOffX, y+iOffY,
                      prctMVLimitBackward
                      );
    }
    else {
      motionCompQuarterSample (m_ppxlcPredMBY + iOffset,
                               m_pvopcRefQ0->pixelsY (), 
                               BLOCK_SIZE,
                               4*(x+iOffX) + 2 * pmvFblk->iMVX + pmvFblk->iHalfX,
                               4*(y+iOffY) + 2 * pmvFblk->iMVY + pmvFblk->iHalfY,
                               m_vopmd.iRoundingControl,
                               prctMVLimitForward
                               );

      motionCompQuarterSample (m_ppxlcPredMBBackY + iOffset,
                               m_pvopcRefQ1->pixelsY (), 
                               BLOCK_SIZE,
                               4*(x+iOffX) + 2 * pmvBblk->iMVX + pmvBblk->iHalfX,
                               4*(y+iOffY) + 2 * pmvBblk->iMVY + pmvBblk->iHalfY,
                               m_vopmd.iRoundingControl,
                               prctMVLimitBackward
                               );
    }
  }

  Int ic;
  for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
    m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
    m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
  }
}
// ~for QuarterPel MC

Void CVideoObjectEncoder::motionCompInterpAndError_WithShape (
    const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
	CoordI x, CoordI y,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
)
{
  if (!m_volmd.bQuarterSample) {
	motionCompEncY (
		m_pvopcRefQ0->pixelsY (), 
		m_puciRefQZoom0->pixels (),
		m_ppxlcPredMBY, MB_SIZE, pmvForward, x, y,
		prctMVLimitForward
	);
	motionCompEncY (
		m_pvopcRefQ1->pixelsY (), 
		m_puciRefQZoom1->pixels (),
		m_ppxlcPredMBBackY, MB_SIZE, pmvBackward, x, y,
		prctMVLimitBackward
	);
  }
  else {
    motionCompQuarterSample (m_ppxlcPredMBY,
                             m_pvopcRefQ0->pixelsY (), 
                             MB_SIZE,
                             4*x + 2 * pmvForward->iMVX + pmvForward->iHalfX,
                             4*y + 2 * pmvForward->iMVY + pmvForward->iHalfY,
                             m_vopmd.iRoundingControl,
                             prctMVLimitForward
                             );

    motionCompQuarterSample (m_ppxlcPredMBBackY,
                             m_pvopcRefQ1->pixelsY (), 
                             MB_SIZE,
                             4*x + 2 * pmvBackward->iMVX + pmvBackward->iHalfX,
                             4*y + 2 * pmvBackward->iMVY + pmvBackward->iHalfY,
                             m_vopmd.iRoundingControl,
                             prctMVLimitBackward
                             );
  }
	Int ic;
	for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
		if (m_ppxlcCurrMBBY [ic] == transpValue){
		m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
		/*m_ppxlcPredMBY [ic] = */m_ppxliErrorMBY [ic] = 0;
		}
		else {
			m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
			m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
		}
	}
}

// for QuarterPel MC
Void CVideoObjectEncoder::motionCompInterpAndError_WithShapeDirect (
	const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
	CoordI x, CoordI y,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
)
{
  Int iOffset = 0, iBlkNo;
  CoordI iOffX = 0, iOffY = 0;
  const CMotionVector *pmvFblk, *pmvBblk;
  
  for (iBlkNo=1; iBlkNo<=4; iBlkNo++) {
    if (iBlkNo == 1) {
      iOffset = 0;
      iOffX = 0;
      iOffY = 0;
    }
    else if (iBlkNo == 2) {
      iOffset = OFFSET_BLK1;
      iOffX = BLOCK_SIZE;
      iOffY = 0;
    }
    else if (iBlkNo == 3) {
      iOffset = OFFSET_BLK2;
      iOffX = 0;
      iOffY = BLOCK_SIZE;
    }
    else if (iBlkNo == 4) {
      iOffset = OFFSET_BLK3;
      iOffX = BLOCK_SIZE;
      iOffY = BLOCK_SIZE;
    }
    pmvFblk = pmvForward + iBlkNo;
    pmvBblk = pmvBackward + iBlkNo;
  
    if (!m_volmd.bQuarterSample) {
      motionCompEncY (
                      m_pvopcRefQ0->pixelsY (), 
                      m_puciRefQZoom0->pixels (),
                      m_ppxlcPredMBY + iOffset, BLOCK_SIZE, pmvFblk, x+iOffX, y+iOffY,
                      prctMVLimitForward
                      );

      motionCompEncY (
                      m_pvopcRefQ1->pixelsY (), 
                      m_puciRefQZoom1->pixels (),
                      m_ppxlcPredMBBackY + iOffset, BLOCK_SIZE, pmvBblk, x+iOffX, y+iOffY,
                      prctMVLimitBackward
                      );
    }
    else {
      motionCompQuarterSample (m_ppxlcPredMBY + iOffset,
                               m_pvopcRefQ0->pixelsY (), 
                               BLOCK_SIZE,
                               4*(x+iOffX) + 2 * pmvFblk->iMVX + pmvFblk->iHalfX,
                               4*(y+iOffY) + 2 * pmvFblk->iMVY + pmvFblk->iHalfY,
                               m_vopmd.iRoundingControl,
                               prctMVLimitForward
                               );

      motionCompQuarterSample (m_ppxlcPredMBBackY + iOffset,
                               m_pvopcRefQ1->pixelsY (), 
                               BLOCK_SIZE,
                               4*(x+iOffX) + 2 * pmvBblk->iMVX + pmvBblk->iHalfX,
                               4*(y+iOffY) + 2 * pmvBblk->iMVY + pmvBblk->iHalfY,
                               m_vopmd.iRoundingControl,
                               prctMVLimitBackward
                               );
    }
  }
  Int ic;
  for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
    if (m_ppxlcCurrMBBY [ic] == transpValue){
      m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
      /*m_ppxlcPredMBY [ic] = */m_ppxliErrorMBY [ic] = 0;
    }
    else {
      m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
      m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
    }
  }
}
// ~for QuarterPel MC