mcdec.cpp

网络MPEG4IP流媒体开发源代码

				prctMVLimitForward, prctMVLimitBackward, 1);
		}
// ~INTERLACE 02-19-99
		else {
			const CMotionVector* pmv8 = pmvForward;
			for (iBlk = 0; iBlk < 4; iBlk++)	{
				pmv8++;
				if (pmbmd->m_rgTranspStatus [iBlk + 1] != ALL)
					motionComp (
						m_ppxlcPredMBA + rgiBlkOffsetPixel [iBlk], 
						m_pvopcRefQ0->pixelsA (),
						BLOCK_SIZE, 
						(x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
						(y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
						0,
						prctMVLimitForward
					);
			}
		}
		if (!pmbmd->m_bhas4MVBackward && !pmbmd -> m_bFieldMV)	//12.22.98	
			motionComp (
				m_ppxlcPredMBBackA,
				m_pvopcRefQ1->pixelsA (),
				MB_SIZE, // either MB or BLOCK size
				x * 2 + pmvBackward->trueMVHalfPel ().x, 
				y * 2 + pmvBackward->trueMVHalfPel ().y,
				0,
				prctMVLimitBackward
			);
// INTERLACE  12.22.98 with new change 02-19-99

		else if (pmbmd -> m_bFieldMV && (pmbmd->m_mbType == INTERPOLATE)) {
			const CMotionVector* pmvTop = pmvBackward + 1 + pmbmd->m_bBackwardTop;
			motionCompYField(m_ppxlcPredMBBackA,
				m_pvopcRefQ1->pixelsA () + pmbmd->m_bBackwardTop * m_iFrameWidthY,
				2*x + pmvTop->trueMVHalfPel ().x, 2*y + pmvTop->trueMVHalfPel ().y);

			const CMotionVector* pmvBottom = pmvBackward + 3 + pmbmd->m_bBackwardBottom;
			motionCompYField(m_ppxlcPredMBBackA + MB_SIZE,
				m_pvopcRefQ1->pixelsA () + pmbmd->m_bBackwardBottom * m_iFrameWidthY,
				2*x + pmvBottom->trueMVHalfPel ().x, 2*y + pmvBottom->trueMVHalfPel ().y);
			}
		else if (((pmbmd -> m_bFieldMV)==0) || (pmbmd->m_mbType != DIRECT)) {
//		else {
// ~INTERLACE 12.22.98 with new change 02-19-99
			const CMotionVector* pmv8 = pmvBackward;
			for (iBlk = 0; iBlk < 4; iBlk++)	{
				pmv8++;
				if (pmbmd->m_rgTranspStatus [iBlk + 1] != ALL)
					motionComp (
						m_ppxlcPredMBBackA + rgiBlkOffsetPixel [iBlk], 
						m_pvopcRefQ1->pixelsA (),
						BLOCK_SIZE, 
						(x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
						(y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
						0,
						prctMVLimitBackward
					);
			}
		}

		// average predictions
		Int i;
		for(i = 0; i<MB_SQUARE_SIZE; i++)
			m_ppxlcPredMBA[i] = (m_ppxlcPredMBA[i] + m_ppxlcPredMBBackA[i] + 1)>>1;
	}
	else { 
		const CMotionVector* pmv;
		const PixelC* ppxlcRef; // point to left-top of the reference VOP
		CRct *prctMVLimit;
		Int itmpref1,itmpref2; // 12.22.98
		if (pmbmd->m_mbType == FORWARD) {
			pmv = pmvForward;
			ppxlcRef = m_pvopcRefQ0->pixelsA (); // point to left-top of the reference VOP
			prctMVLimit = prctMVLimitForward;
			itmpref1=pmbmd->m_bForwardTop; // 12.22.98
			itmpref2=pmbmd->m_bForwardBottom; // 12.22.98
		}
		else {
			pmv = pmvBackward;
			ppxlcRef = m_pvopcRefQ1->pixelsA (); // point to left-top of the reference VOP
			prctMVLimit = prctMVLimitBackward;
			itmpref1=pmbmd->m_bBackwardTop;  // 12.22.98
			itmpref2=pmbmd->m_bBackwardBottom;  // 12.22.98
		}
// INTERLACE  12.22.98
		if (pmbmd -> m_bFieldMV) {
			const CMotionVector* pmvTop = pmv + 1 + itmpref1;
			motionCompYField(m_ppxlcPredMBA,
				ppxlcRef + itmpref1 * m_iFrameWidthY,
				2*x + pmvTop->trueMVHalfPel ().x, 2*y + pmvTop->trueMVHalfPel ().y);

			const CMotionVector* pmvBottom = pmv + 3 + itmpref2;
			motionCompYField(m_ppxlcPredMBA + MB_SIZE,
				ppxlcRef + itmpref2 * m_iFrameWidthY,
				2*x + pmvBottom->trueMVHalfPel ().x, 2*y + pmvBottom->trueMVHalfPel ().y);
			}
		else
// ~INTERLACE 12.22.98			
		motionComp (
			m_ppxlcPredMBA,
			ppxlcRef,
			MB_SIZE, // MB size
			x * 2 + pmv->trueMVHalfPel ().x, 
			y * 2 + pmv->trueMVHalfPel ().y,
			0,
			prctMVLimit
		);
	}
}

Void CVideoObjectDecoder::copyFromRefToCurrQ_BVOP (
	const CMBMode* pmbmd,
	CoordI x, CoordI y, 
	PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
)
{
	if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE) { // Y is done when doing motion estimation
		motionComp (
			m_ppxlcPredMBY,
			m_pvopcRefQ0->pixelsY (),
			MB_SIZE, // either MB or BLOCK size
			x * 2, 
			y * 2,
			m_vopmd.iRoundingControl,
			prctMVLimitForward
		);
		motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
			x, y, 0, 0, 0,prctMVLimitForward);
		
		motionComp (
			m_ppxlcPredMBBackY,
			m_pvopcRefQ1->pixelsY (),
			MB_SIZE, // either MB or BLOCK size
			x * 2, 
			y * 2,
			m_vopmd.iRoundingControl,
			prctMVLimitBackward
		);
		motionCompUV (m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1,
			x, y, 0, 0, 0, prctMVLimitBackward);
		averagePredAndAssignToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
	}
	else { 
		const CVOPU8YUVBA* pvopcRef; // point to left-top of the reference VOP
		CRct *prctMVLimit;
		if (pmbmd->m_mbType == FORWARD){
			pvopcRef = m_pvopcRefQ0;
			prctMVLimit = prctMVLimitForward;
		}
		else {
			pvopcRef = m_pvopcRefQ1;
			prctMVLimit = prctMVLimitBackward;
		}
		copyFromRefToCurrQ (pvopcRef, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, prctMVLimit);
	}
}

Void CVideoObjectDecoder::motionCompSkipMB_BVOP (
	const CMBMode* pmbmd, const CMotionVector* pmvForward, const CMotionVector* pmvBackward,
	CoordI x, CoordI y, 
	PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
	CRct *prctMVLimitForward,CRct *prctMVLimitBackward
)
{
	Int iBlk;
	if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE) {
		if (pmbmd->m_bhas4MVForward != TRUE)
			motionComp (
				m_ppxlcPredMBY,
				m_pvopcRefQ0->pixelsY (),
				MB_SIZE, // either MB or BLOCK size
				x * 2 + pmvForward->trueMVHalfPel ().x, 
				y * 2 + pmvForward->trueMVHalfPel ().y,
				m_vopmd.iRoundingControl,
				prctMVLimitForward
			);
		else {
			const CMotionVector* pmv8 = pmvForward;
			for (iBlk = 0; iBlk < 4; iBlk++)	{
				pmv8++;
				if (pmbmd->m_rgTranspStatus [iBlk + 1] != ALL)
					motionComp (
						m_ppxlcPredMBY + rgiBlkOffsetPixel [iBlk], 
						m_pvopcRefQ0->pixelsY (),
						BLOCK_SIZE, 
						(x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
						(y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
						m_vopmd.iRoundingControl,
						prctMVLimitForward
					);
			}
		}
		CoordI xRefUVForward, yRefUVForward;
		mvLookupUVWithShape (pmbmd, pmvForward, xRefUVForward, yRefUVForward);
		motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y, xRefUVForward, yRefUVForward, 0, prctMVLimitForward);

		if (pmbmd->m_bhas4MVBackward != TRUE)		
			motionComp (
				m_ppxlcPredMBBackY,
				m_pvopcRefQ1->pixelsY (),
				MB_SIZE, // either MB or BLOCK size
				x * 2 + pmvBackward->trueMVHalfPel ().x, 
				y * 2 + pmvBackward->trueMVHalfPel ().y,
				m_vopmd.iRoundingControl,
				prctMVLimitBackward
			);
		else {
			const CMotionVector* pmv8 = pmvBackward;
			for (iBlk = 0; iBlk < 4; iBlk++)	{
				pmv8++;
				if (pmbmd->m_rgTranspStatus [iBlk + 1] != ALL)
					motionComp (
						m_ppxlcPredMBBackY + rgiBlkOffsetPixel [iBlk], 
						m_pvopcRefQ1->pixelsY (),
						BLOCK_SIZE, 
						(x + rgiBlkOffsetX [iBlk]) * 2 + pmv8->trueMVHalfPel ().x, 
						(y + rgiBlkOffsetY [iBlk]) * 2 + pmv8->trueMVHalfPel ().y,
						m_vopmd.iRoundingControl,
						prctMVLimitBackward
					);
			}
		}
		CoordI xRefUVBackward, yRefUVBackward;
		mvLookupUVWithShape (pmbmd, pmvBackward, xRefUVBackward, yRefUVBackward);
		motionCompUV (m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y, xRefUVBackward, yRefUVBackward, 0, prctMVLimitBackward);
		averagePredAndAssignToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
	}
	else { 
		const CVOPU8YUVBA* pvopcRef; // point to left-top of the reference VOP
		CRct *prctMVLimit;
		if (pmbmd->m_mbType == FORWARD){
			pvopcRef = m_pvopcRefQ0;
			prctMVLimit = prctMVLimitForward;
		}
		else {
			pvopcRef = m_pvopcRefQ1;
			prctMVLimit = prctMVLimitBackward;
		}
		copyFromRefToCurrQ (pvopcRef, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, prctMVLimit);
	}
}