mc.cpp

网络MPEG4IP流媒体开发源代码

		(((yRef >> 1) & ~1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRef >> 1) + EXPANDY_REF_FRAME;
	Int iRound = 1 - m_vopmd.iRoundingControl;
	Int iFieldStep = 2 * m_iFrameWidthY;

	if (!(yRef & 2)) {
		if (!(xRef & 1)) {  //!bXSubPxl && !bYSubPxl
			for (iy = 0; iy < MB_SIZE; iy+=2) {
				memcpy (ppxlcPred, ppxlcRef, MB_SIZE*sizeof(PixelC));
				ppxlcRef += iFieldStep;
				ppxlcPred += MB_SIZE*2;
			}
		}
		else {  //bXSubPxl && !bYSubPxl
			for (iy = 0; iy < MB_SIZE; iy+=2){
				for (ix = 0; ix < MB_SIZE; ix++)
					ppxlcPred [ix] = (ppxlcRef [ix] + ppxlcRef [ix + 1] + iRound) >> 1;
				ppxlcRef += iFieldStep;
				ppxlcPred += MB_SIZE*2;
			}
		}
	}
	else {
		const PixelC* ppxlcRefBot;
		if (!(xRef & 1)) {  //!bXSubPxl&& bYSubPxl
			for (iy = 0; iy < MB_SIZE; iy+=2) {
				ppxlcRefBot = ppxlcRef + iFieldStep;		//UPln -> pixels (xInt,yInt+1);
				for (ix = 0; ix < MB_SIZE; ix++) 
					ppxlcPred [ix] = (ppxlcRef [ix] + ppxlcRefBot [ix] + iRound) >> 1;
				ppxlcRef = ppxlcRefBot;
				ppxlcPred += MB_SIZE*2;
			}
		}
		else { // bXSubPxl && bYSubPxl
			iRound++;
			for (iy = 0; iy < MB_SIZE; iy+=2) {
				ppxlcRefBot = ppxlcRef + iFieldStep;		//UPln -> pixels (xInt,yInt+1);
				for (ix = 0; ix < MB_SIZE; ix++){
					ppxlcPred [ix] = (ppxlcRef [ix + 1] + ppxlcRef [ix] +
						ppxlcRefBot [ix + 1] + ppxlcRefBot [ix] + iRound) >> 2;

				}
				ppxlcRef = ppxlcRefBot;
				ppxlcPred += MB_SIZE*2;
			}
		}
	}
}

Void CVideoObject::motionCompFieldUV (	PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
								 const CVOPU8YUVBA* pvopcRef,
								 CoordI x, CoordI y, 
								 CoordI xRefUV, CoordI yRefUV,Int iRefFieldSelect
								 )
{
	UInt ix, iy;
	// delete by Hyundai for Microsoft and MoMusys alignment
	//Int iPxLoc = ((((y + yRefUV) >> 1) & ~1) + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + ((x + xRefUV) >> 1) + EXPANDUV_REF_FRAME;
	// insert by Hyundai for Microsoft and MoMusys alignment
	Int iPxLoc = (y/2 + ((yRefUV >> 1) & ~1) + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + ((x + xRefUV) >> 1) + EXPANDUV_REF_FRAME;

	const PixelC* ppxlcPrevU = pvopcRef->pixelsU () + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
	const PixelC* ppxlcPrevV = pvopcRef->pixelsV () + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
	Int iRound = 1 - m_vopmd.iRoundingControl;
	Int iFieldStep = 2 * m_iFrameWidthUV;

	if (!(yRefUV & 2)) {
		if (!(xRefUV & 1)) {  //!bXSubPxl && !bYSubPxl
			for (iy = 0; iy < BLOCK_SIZE; iy+=2) {
				memcpy (ppxlcPredMBU, ppxlcPrevU, BLOCK_SIZE*sizeof(PixelC));
				memcpy (ppxlcPredMBV, ppxlcPrevV, BLOCK_SIZE*sizeof(PixelC));
				ppxlcPrevU += iFieldStep;
				ppxlcPrevV += iFieldStep;
				ppxlcPredMBU += 2*BLOCK_SIZE;
				ppxlcPredMBV += 2*BLOCK_SIZE;
			}
		}
		else {  //bXSubPxl && !bYSubPxl
			for (iy = 0; iy < BLOCK_SIZE; iy+=2) {
				for (ix = 0; ix < BLOCK_SIZE; ix++) {
					ppxlcPredMBU [ix] = (ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + iRound) >> 1;
					ppxlcPredMBV [ix] = (ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + iRound) >> 1;
				}
				ppxlcPrevU += iFieldStep;
				ppxlcPrevV += iFieldStep;
				ppxlcPredMBU += 2*BLOCK_SIZE;
				ppxlcPredMBV += 2*BLOCK_SIZE;
			}
		}
	}
	else {
		const PixelC* ppxlcPrevUBot; 
		const PixelC* ppxlcPrevVBot; 
		if (!(xRefUV & 1)) {  //!bXSubPxl&& bYSubPxl
			for (iy = 0; iy < BLOCK_SIZE; iy+=2) {
				ppxlcPrevUBot = ppxlcPrevU + iFieldStep;            //UPln -> pixels (xInt,yInt+1);
				ppxlcPrevVBot = ppxlcPrevV + iFieldStep;            //VPln -> pixels (xInt,yInt+1);
				for (ix = 0; ix < BLOCK_SIZE; ix++) {
					ppxlcPredMBU [ix] = (ppxlcPrevU [ix] + ppxlcPrevUBot [ix] + iRound) >> 1;
					ppxlcPredMBV [ix] = (ppxlcPrevV [ix] + ppxlcPrevVBot [ix] + iRound) >> 1;
				}
				ppxlcPredMBU += 2*BLOCK_SIZE;
				ppxlcPredMBV += 2*BLOCK_SIZE;
				ppxlcPrevU = ppxlcPrevUBot; 
				ppxlcPrevV = ppxlcPrevVBot; 
			}
		}
		else { // bXSubPxl && bYSubPxl
			iRound++;
			for (iy = 0; iy < BLOCK_SIZE; iy+=2){
				ppxlcPrevUBot = ppxlcPrevU + iFieldStep; //UPln -> pixels (xInt,yInt+1);
				ppxlcPrevVBot = ppxlcPrevV + iFieldStep; //VPln -> pixels (xInt,yInt+1);
				for (ix = 0; ix < BLOCK_SIZE; ix++){
					ppxlcPredMBU [ix] = (ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + 
						ppxlcPrevUBot [ix + 1] + ppxlcPrevUBot [ix] + iRound) >> 2;
					ppxlcPredMBV [ix] = (ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + 
						ppxlcPrevVBot [ix + 1] + ppxlcPrevVBot [ix] + iRound) >> 2;
				}
				ppxlcPredMBU += 2*BLOCK_SIZE;
				ppxlcPredMBV += 2*BLOCK_SIZE;
				ppxlcPrevU = ppxlcPrevUBot; 
				ppxlcPrevV = ppxlcPrevVBot; 
			}
		}
	}
}

// #endif // INTERLACE

Void CVideoObject::motionCompUV (
	PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
	const CVOPU8YUVBA* pvopcRef,
	CoordI x, CoordI y, 
	CoordI xRefUV, CoordI yRefUV,
	Int iRoundingControl,
	CRct *prctMVLimit
)
{
	UInt ix, iy;
	CoordI iTmpX = x + xRefUV;
	CoordI iTmpY = y + yRefUV;
	limitMVRangeToExtendedBBFullPel (iTmpX,iTmpY,prctMVLimit,MB_SIZE);
	xRefUV = iTmpX - x;
	yRefUV = iTmpY - y;

	Int iPxLoc = (((y + yRefUV) >> 1) + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + ((x + xRefUV) >> 1) + EXPANDUV_REF_FRAME;
	const PixelC* ppxlcPrevU = pvopcRef->pixelsU () + iPxLoc;
	const PixelC* ppxlcPrevV = pvopcRef->pixelsV () + iPxLoc;
	if (!(yRefUV & 1)) {
		if (!(xRefUV & 1)) {  //!bXSubPxl && !bYSubPxl
			for (iy = 0; iy < BLOCK_SIZE; iy++) {
				memcpy (ppxlcPredMBU, ppxlcPrevU, BLOCK_SIZE*sizeof(PixelC));
				memcpy (ppxlcPredMBV, ppxlcPrevV, BLOCK_SIZE*sizeof(PixelC));
				ppxlcPrevU += m_iFrameWidthUV;
				ppxlcPrevV += m_iFrameWidthUV;
				ppxlcPredMBU += BLOCK_SIZE;
				ppxlcPredMBV += BLOCK_SIZE;
			}
		}
		else {  //bXSubPxl && !bYSubPxl
			for (iy = 0; iy < BLOCK_SIZE; iy++) {
				for (ix = 0; ix < BLOCK_SIZE; ix++) {
					ppxlcPredMBU [ix] = (ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + 1 - iRoundingControl) >> 1;
					ppxlcPredMBV [ix] = (ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + 1 - iRoundingControl) >> 1;
				}
				ppxlcPrevU += m_iFrameWidthUV;
				ppxlcPrevV += m_iFrameWidthUV;
				ppxlcPredMBU += BLOCK_SIZE;
				ppxlcPredMBV += BLOCK_SIZE;
			}
		}
	}
	else {
		const PixelC* ppxlcPrevUBot; 
		const PixelC* ppxlcPrevVBot; 
		if (!(xRefUV & 1)) {  //!bXSubPxl&& bYSubPxl
			for (iy = 0; iy < BLOCK_SIZE; iy++) {
				ppxlcPrevUBot = ppxlcPrevU + m_iFrameWidthUV;            //UPln -> pixels (xInt,yInt+1);
				ppxlcPrevVBot = ppxlcPrevV + m_iFrameWidthUV;            //VPln -> pixels (xInt,yInt+1);
				for (ix = 0; ix < BLOCK_SIZE; ix++) {
//					ppxlcPredMBU [ix] = (ppxlcPrevU [ix] + ppxlcPrevUBot [ix] + 1) >> 1;
//					ppxlcPredMBV [ix] = (ppxlcPrevV [ix] + ppxlcPrevVBot [ix] + 1) >> 1;
					ppxlcPredMBU [ix] = (ppxlcPrevU [ix] + ppxlcPrevUBot [ix] + 1 - iRoundingControl) >> 1;
					ppxlcPredMBV [ix] = (ppxlcPrevV [ix] + ppxlcPrevVBot [ix] + 1 - iRoundingControl) >> 1;
				}
				ppxlcPredMBU += BLOCK_SIZE;
				ppxlcPredMBV += BLOCK_SIZE;
				ppxlcPrevU = ppxlcPrevUBot; 
				ppxlcPrevV = ppxlcPrevVBot; 
			}
		}
		else { // bXSubPxl && bYSubPxl
			for (iy = 0; iy < BLOCK_SIZE; iy++){
				ppxlcPrevUBot = ppxlcPrevU + m_iFrameWidthUV; //UPln -> pixels (xInt,yInt+1);
				ppxlcPrevVBot = ppxlcPrevV + m_iFrameWidthUV; //VPln -> pixels (xInt,yInt+1);
				for (ix = 0; ix < BLOCK_SIZE; ix++){
/*
					ppxlcPredMBU [ix] = (
						ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + 
						ppxlcPrevUBot [ix + 1] + ppxlcPrevUBot [ix] + 2
					) >> 2;
					ppxlcPredMBV [ix] = (
						ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + 
						ppxlcPrevVBot [ix + 1] + ppxlcPrevVBot [ix] + 2
					) >> 2;
*/
					ppxlcPredMBU [ix] = (
						ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + 
						ppxlcPrevUBot [ix + 1] + ppxlcPrevUBot [ix] + 2 - iRoundingControl
					) >> 2;
					ppxlcPredMBV [ix] = (
						ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + 
						ppxlcPrevVBot [ix + 1] + ppxlcPrevVBot [ix] + 2 - iRoundingControl
					) >> 2;
				}
				ppxlcPredMBU += BLOCK_SIZE;
				ppxlcPredMBV += BLOCK_SIZE;
				ppxlcPrevU = ppxlcPrevUBot; 
				ppxlcPrevV = ppxlcPrevVBot; 
			}
		}
	}
}

UInt gOvrlpPredY [64];

Void CVideoObject::motionCompOverLap (
	PixelC* ppxlcPredMB, 
	const PixelC* ppxlcRefLeftTop,
	const CMotionVector* pmv, // motion vector
	const CMBMode* pmbmd, // macroblk mode	
	Int imbx, // current macroblk index
	Int imby, // current macroblk index
	CoordI x, // current coordinate system
	CoordI y, // current coordinate system
	CRct *prctMVLimit
)
{
	// Overlap Motion Comp use motion vector of current blk and motion vectors of neighboring blks.
	const CMotionVector *pmvC,*pmvT = NULL,*pmvB = NULL,*pmvR = NULL,*pmvL = NULL; // MVs of Cur, Top, Bot, Right and Left Blocks.
	const CMotionVector *pmvCurrMb,*pmvTopMb = NULL;
	const CMotionVector *pmvRightMb = NULL,*pmvLeftMb = NULL; // MVs of Cur, Top, Right and Left MacroBlocks.
	const CMBMode *pmbmdTopMb = NULL, *pmbmdRightMb = NULL, *pmbmdLeftMb = NULL; 
	// MVs of Cur, Top, Right and Left MacroBlocks.
	Bool bIntraT = FALSE, bIntraR = FALSE, bIntraL = FALSE; // flags of 4MV for Cur, Top, Right and Left MacroBlocks.
	Bool bLeftBndry, bRightBndry, bTopBndry;
	bLeftBndry = (imbx == 0);
	bRightBndry = (imbx == m_iNumMBX - 1);
	bTopBndry = (imby == 0);

	pmvCurrMb = pmv;
	// assign the neighboring blk's MVs to pmv[TBRLC]
	if (!bTopBndry) {
		pmbmdTopMb = pmbmd - m_iNumMBX; 
		bIntraT = (pmbmdTopMb->m_dctMd == INTRA || pmbmdTopMb->m_dctMd == INTRAQ);
		pmvTopMb = pmv - m_iNumOfTotalMVPerRow;
	}
	if (!bLeftBndry) {
		pmbmdLeftMb = pmbmd - 1;
		bIntraL = (pmbmdLeftMb->m_dctMd == INTRA || pmbmdLeftMb->m_dctMd == INTRAQ);
		pmvLeftMb = pmv - PVOP_MV_PER_REF_PER_MB;
	}
	if (!bRightBndry) {
		pmbmdRightMb = pmbmd + 1;
		bIntraR = (pmbmdRightMb->m_dctMd == INTRA || pmbmdRightMb->m_dctMd == INTRAQ);
		pmvRightMb = pmv + PVOP_MV_PER_REF_PER_MB;
	}

	UInt i;
	// assign the neighboring blk's MVs to pmv[TBRLC] 
	for (i = 1; i < 5; i++) {
		if (pmbmd->m_rgTranspStatus [i] == ALL)
			continue;
		pmvC = pmvCurrMb + i;
		switch (i) {
			case 1:
				if (pmbmd->m_rgTranspStatus [3] == ALL)
					pmvB = pmvCurrMb + 1;
				else
					pmvB = pmvCurrMb + 3;
				
				if (pmbmd->m_rgTranspStatus [2] == ALL)
					pmvR = pmvCurrMb + 1; 	
				else
					pmvR = pmvCurrMb + 2; 	

				if (bTopBndry || bIntraT || pmbmdTopMb->m_rgTranspStatus [3] == ALL)
					pmvT = pmvCurrMb + 1;
				else
					pmvT = pmvTopMb + 3;

				if (bLeftBndry || bIntraL || pmbmdLeftMb->m_rgTranspStatus [2] == ALL)
					pmvL = pmvCurrMb + 1;
				else
					pmvL = pmvLeftMb + 2;
				break;
			case 2:
				if (pmbmd->m_rgTranspStatus [4] == ALL)
					pmvB = pmvCurrMb + 2;
				else
					pmvB = pmvCurrMb + 4;

				if (pmbmd->m_rgTranspStatus [1] == ALL)
					pmvL = pmvCurrMb + 2;
				else
					pmvL = pmvCurrMb + 1;

				if (bTopBndry || bIntraT || pmbmdTopMb->m_rgTranspStatus [4] == ALL)
					pmvT = pmvCurrMb + 2;
				else
					pmvT = pmvTopMb + 4;      	

				if (bRightBndry || bIntraR || pmbmdRightMb->m_rgTranspStatus [1] == ALL)
					pmvR = pmvCurrMb + 2;
				else
					pmvR = pmvRightMb + 1;
				break;
			case 3:
				if (pmbmd->m_rgTranspStatus [1] == ALL)
					pmvT = pmvCurrMb + 3;  
				else
					pmvT = pmvCurrMb + 1;
				
				pmvB = pmvCurrMb + 3; // use the current mv

				if (pmbmd->m_rgTranspStatus [4] == ALL)
					pmvR = pmvCurrMb + 3;
				else
					pmvR = pmvCurrMb + 4;

				if (bLeftBndry || bIntraL || pmbmdLeftMb->m_rgTranspStatus [4] == ALL)
					pmvL = pmvCurrMb + 3;
				else
					pmvL = pmvLeftMb + 4;
				break;
			case 4:
				if (pmbmd->m_rgTranspStatus [2] == ALL)
					pmvT = pmvCurrMb + 4;    	
				else
					pmvT = pmvCurrMb + 2;
				
				pmvB = pmvCurrMb + 4;

				if (pmbmd->m_rgTranspStatus [3] == ALL)
					pmvL = pmvCurrMb + 4;  	
				else
					pmvL = pmvCurrMb + 3;
				
				if (bRightBndry || bIntraR || pmbmdRightMb->m_rgTranspStatus [3] == ALL)
					pmvR = pmvCurrMb + 4;
				else