motest.cpp

此源码是在VC平台下,实现MPEG4编解码的源码

// INTERLACE
#define	BbiasAgainstFrameAve	((MB_SIZE*MB_SIZE)/2 + 1)		// Biases favor modes with fewer MVs
#define BbiasAgainstFieldAve	((MB_SIZE*MB_SIZE)/1 + 1)
#define BbiasAgainstField		((MB_SIZE*MB_SIZE)/2 + 1)
#define	BbiasFavorDirect		((MB_SIZE*MB_SIZE)/2 + 1)

Int CVideoObjectEncoder::motionEstMB_BVOP_Interlaced (
	CoordI x, CoordI y, 
	CMotionVector* pmvForward, CMotionVector* pmvBackward,
	CMBMode* pmbmd,
	const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
	const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY,
	Bool bColocatedMBExist
)
{
	Int iSAD, iSADnobias, iFieldSAD, iSADFrmMB[3];
	MBType mbtype;

	iSADFrmMB[0] = blkmatch16(pmvForward, x, y,x,y, sad16x16At0 (ppxlcRef0MBY),
		ppxlcRef0MBY, m_puciRefQZoom0, m_vopmd.iSearchRangeForward);
	pmvForward->computeTrueMV ();
	iSADFrmMB[1] = blkmatch16(pmvBackward, x, y,x,y, sad16x16At0 (ppxlcRef1MBY),
		ppxlcRef1MBY, m_puciRefQZoom1, m_vopmd.iSearchRangeBackward);
	pmvBackward->computeTrueMV ();
	iSADFrmMB[2] = interpolateAndDiffY(pmvForward, pmvBackward, x, y
		, &m_rctRefVOPY0, &m_rctRefVOPY1);

#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace (iSADFrmMB, 3, "SADFrmMB");
#endif // __TRACE_AND_STATS_

	// Choose best 16x16 mode
	pmbmd->m_bFieldMV = FALSE;
	if (iSADFrmMB[0] < iSADFrmMB[1]) {
		iSAD = iSADFrmMB[0];
		pmbmd->m_mbType = FORWARD;
	} else {
		iSAD = iSADFrmMB[1];
		pmbmd->m_mbType = BACKWARD;
	}
	iSADnobias = iSAD;
	if ((iSADFrmMB[2] + BbiasAgainstFrameAve) < iSAD) {
		iSAD = iSADFrmMB[2] + BbiasAgainstFrameAve;
		iSADnobias = iSADFrmMB[2];
		pmbmd->m_mbType = INTERPOLATE;
	}

		
	if(m_bCodedFutureRef==FALSE)
	{
		iSAD = iSADFrmMB[0];
		pmbmd->m_mbType = FORWARD; // force forward mode
	}
	
	if (m_vopmd.bInterlace) {
		const PixelC *ppxlcFwdHalfPelRef = m_pvopcRefQ0->pixelsY()
			+EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME+ x + y * m_iFrameWidthY; // 1.31.99 changes
		const PixelC *ppxlcBakHalfPelRef = m_pvopcRefQ1->pixelsY()
			+EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME+ x + y * m_iFrameWidthY; // 1.31.99 changes
		Int iSADFldMB[3], iSADFld[8];

		// Choose best fwd top field predictor
		iSADFld[0] = blkmatch16x8 (pmvForward+1, x, y, 0,
			ppxlcRef0MBY, ppxlcFwdHalfPelRef, m_vopmd.iSearchRangeForward);
		pmvForward[1].computeTrueMV();
		iSADFld[1] = blkmatch16x8 (pmvForward+2, x, y, 0,
			ppxlcRef0MBY + m_iFrameWidthY, ppxlcFwdHalfPelRef + m_iFrameWidthY,
			m_vopmd.iSearchRangeForward);
		pmvForward[2].computeTrueMV();
		if (iSADFld[0] <= iSADFld[1]) {
			pmbmd->m_bForwardTop = 0;
			iSADFldMB[0] = iSADFld[0];
		} else {
			pmbmd->m_bForwardTop = 1;
			iSADFldMB[0] = iSADFld[1];
		}

		// Choose best fwd botton field predictor
		iSADFld[2] = blkmatch16x8 (pmvForward+3, x, y, MB_SIZE,
			ppxlcRef0MBY, ppxlcFwdHalfPelRef, m_vopmd.iSearchRangeForward);
		pmvForward[3].computeTrueMV();
		iSADFld[3] = blkmatch16x8 (pmvForward+4, x, y, MB_SIZE,
			ppxlcRef0MBY + m_iFrameWidthY, ppxlcFwdHalfPelRef + m_iFrameWidthY,
			m_vopmd.iSearchRangeForward);
		pmvForward[4].computeTrueMV();
		if (iSADFld[2] < iSADFld[3]) {
			pmbmd->m_bForwardBottom = 0;
			iSADFldMB[0] += iSADFld[2];
		} else {
			pmbmd->m_bForwardBottom = 1;
			iSADFldMB[0] += iSADFld[3];
		}

		
		// Choose best bak top field predictor
		iSADFld[4] = blkmatch16x8 (pmvBackward+1, x, y, 0,
			ppxlcRef1MBY, ppxlcBakHalfPelRef, m_vopmd.iSearchRangeBackward);
		pmvBackward[1].computeTrueMV();
		iSADFld[5] = blkmatch16x8 (pmvBackward+2, x, y, 0,
			ppxlcRef1MBY + m_iFrameWidthY, ppxlcBakHalfPelRef + m_iFrameWidthY,
			m_vopmd.iSearchRangeBackward);
		pmvBackward[2].computeTrueMV();
		if (iSADFld[4] <= iSADFld[5]) {
			pmbmd->m_bBackwardTop = 0;
			iSADFldMB[1] = iSADFld[4];
		} else {
			pmbmd->m_bBackwardTop = 1;
			iSADFldMB[1] = iSADFld[5];
		}

		// Choose best bak bottom field predictor
		iSADFld[6] = blkmatch16x8 (pmvBackward+3, x, y, MB_SIZE,
			ppxlcRef1MBY, ppxlcBakHalfPelRef, m_vopmd.iSearchRangeBackward);
		pmvBackward[3].computeTrueMV();
		iSADFld[7] = blkmatch16x8 (pmvBackward+4, x, y, MB_SIZE,
			ppxlcRef1MBY + m_iFrameWidthY, ppxlcBakHalfPelRef + m_iFrameWidthY,
			m_vopmd.iSearchRangeBackward);
		pmvBackward[4].computeTrueMV();
		if (iSADFld[6] < iSADFld[7]) {
			pmbmd->m_bBackwardBottom = 0;
			iSADFldMB[1] += iSADFld[6];
		} else {
			pmbmd->m_bBackwardBottom = 1;
			iSADFldMB[1] += iSADFld[7];
		}

		// Choose best of forward & backward field prediction
		if (iSADFldMB[0] <= iSADFldMB[1]) {
			iFieldSAD = iSADFldMB[0];
			mbtype = FORWARD;
		} else {
			iFieldSAD = iSADFldMB[1];
			mbtype = BACKWARD;
		}
		iFieldSAD += BbiasAgainstField;
		iSADFldMB[2] = interpolateAndDiffYField(
			pmvForward  + 1 + (int)pmbmd->m_bForwardTop,
			pmvForward  + 3 + (int)pmbmd->m_bForwardBottom,
			pmvBackward + 1 + (int)pmbmd->m_bBackwardTop,
			pmvBackward + 3 + (int)pmbmd->m_bBackwardBottom,
			x, y, pmbmd);
		if ((iSADFldMB[2] + BbiasAgainstFieldAve) < iFieldSAD) {
			iFieldSAD = iSADFldMB[2] + BbiasAgainstFieldAve;
			mbtype = INTERPOLATE;
		}

		if(m_bCodedFutureRef==FALSE) // FORCE FORWARD
		{
			iFieldSAD = iSADFldMB[0];
			mbtype = FORWARD;
		}

		// Field versus Frame prediction
		if (iFieldSAD < iSAD) {
			pmbmd->m_bFieldMV = TRUE;
			pmbmd->m_mbType = mbtype;
			iSAD = iFieldSAD;
			iSADnobias = iFieldSAD - ((mbtype == INTERPOLATE) ? BbiasAgainstFieldAve : BbiasAgainstField);
		}
#ifdef __TRACE_AND_STATS_
		m_pbitstrmOut->trace (iSADFld,   8, "SADFld");
		m_pbitstrmOut->trace (iSADFldMB, 3, "SADFldMB");
#endif // __TRACE_AND_STATS_

	}

#if 1				// #if 0 to temporarily disable direct mode (debug only)
	// Check direct mode
	Int iSADDirect;
	if (bColocatedMBExist && m_volmd.fAUsage == RECTANGLE) {	
		iSADDirect= (pmbmdRef->m_bFieldMV) ?
		directSADField(x, y, pmbmd, pmbmdRef, pmvRef, ppxlcRef0MBY, ppxlcRef1MBY) :
		directSAD     (x, y, pmbmd, pmbmdRef, pmvRef);
		if ((iSADDirect - BbiasFavorDirect) < iSAD) {
			pmbmd->m_mbType = DIRECT;
			pmbmd->m_bFieldMV = pmbmdRef->m_bFieldMV;
			iSADnobias = iSADDirect;
		}
	}
#endif
#ifdef __TRACE_AND_STATS_
	static char *cDirectType[] = {	"FrmDirectSAD", "FldDirectSAD" };
	static char *cWinner[] = { "FrmDirect\n", "FrmAve\n", "FrmBak\n", "FrmFwd\n", "FldDirect\n", "FldAve\n", "FldBak\n", "FldFwd\n" };
	if(bColocatedMBExist)
		m_pbitstrmOut->trace (iSADDirect, cDirectType[pmbmdRef->m_bFieldMV]);
	m_pbitstrmOut->trace (cWinner[(Int)pmbmd->m_mbType + 4*pmbmd->m_bFieldMV]);
#if 0				// Put all MV candidates in trace file
	Int iMV[10];
	iMV[0] = pmvForward[0].m_vctTrueHalfPel.x; iMV[1] = pmvForward[0].m_vctTrueHalfPel.y;
	iMV[2] = pmvForward[1].m_vctTrueHalfPel.x; iMV[3] = pmvForward[1].m_vctTrueHalfPel.y;
	iMV[4] = pmvForward[2].m_vctTrueHalfPel.x; iMV[5] = pmvForward[2].m_vctTrueHalfPel.y;
	iMV[6] = pmvForward[3].m_vctTrueHalfPel.x; iMV[7] = pmvForward[3].m_vctTrueHalfPel.y;
	iMV[8] = pmvForward[4].m_vctTrueHalfPel.x; iMV[9] = pmvForward[4].m_vctTrueHalfPel.y;
	m_pbitstrmOut->trace (iMV, 10, "FwdMV");
	iMV[0] = pmvBackward[0].m_vctTrueHalfPel.x; iMV[1] = pmvBackward[0].m_vctTrueHalfPel.y;
	iMV[2] = pmvBackward[1].m_vctTrueHalfPel.x; iMV[3] = pmvBackward[1].m_vctTrueHalfPel.y;
	iMV[4] = pmvBackward[2].m_vctTrueHalfPel.x; iMV[5] = pmvBackward[2].m_vctTrueHalfPel.y;
	iMV[6] = pmvBackward[3].m_vctTrueHalfPel.x; iMV[7] = pmvBackward[3].m_vctTrueHalfPel.y;
	iMV[8] = pmvBackward[4].m_vctTrueHalfPel.x; iMV[9] = pmvBackward[4].m_vctTrueHalfPel.y;
	m_pbitstrmOut->trace (iMV, 10, "BakMV");
#endif
#endif // __TRACE_AND_STATS_

	pmbmd->m_bhas4MVForward  = FALSE;
	pmbmd->m_bhas4MVBackward = FALSE;
	return iSADnobias;
}

//end of INTERLACED
//INTERLACED
// new changes
Int CVideoObjectEncoder::motionEstMB_BVOP_InterlacedWithShape (
	CoordI x, CoordI y, 
	CMotionVector* pmvForward, CMotionVector* pmvBackward,
	CMBMode* pmbmd,
	const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
	const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY,
	Bool bColocatedMBExist
)
{
	assert (pmbmd->m_rgTranspStatus [0] == PARTIAL);

	Int iSAD, iSADnobias, iFieldSAD, iSADFrmMB[3];
	MBType mbtype;

	iSADFrmMB[0] = blkmatch16WithShape(pmvForward, x, y,x,y, sad16x16At0WithShape (ppxlcRef0MBY,pmbmd),
		ppxlcRef0MBY, m_puciRefQZoom0, pmbmd, m_vopmd.iSearchRangeForward,0);
	pmvForward->computeTrueMV ();
	iSADFrmMB[1] = blkmatch16WithShape(pmvBackward, x, y,x,y, sad16x16At0WithShape (ppxlcRef1MBY,pmbmd),
		ppxlcRef1MBY, m_puciRefQZoom1, pmbmd, m_vopmd.iSearchRangeBackward,1);
	pmvBackward->computeTrueMV ();
	iSADFrmMB[2] = interpolateAndDiffY_WithShape(pmvForward, pmvBackward, x, y
		, &m_rctRefVOPY0, &m_rctRefVOPY1);

#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace (iSADFrmMB, 3, "SADFrmMB");
#endif // __TRACE_AND_STATS_

	// Choose best 16x16 mode
	pmbmd->m_bFieldMV = FALSE;
	if (iSADFrmMB[0] < iSADFrmMB[1]) {
		iSAD = iSADFrmMB[0];
		pmbmd->m_mbType = FORWARD;
	} else {
		iSAD = iSADFrmMB[1];
		pmbmd->m_mbType = BACKWARD;
	}
	iSADnobias = iSAD;
	if ((iSADFrmMB[2] + BbiasAgainstFrameAve) < iSAD) {
		iSAD = iSADFrmMB[2] + BbiasAgainstFrameAve;
		iSADnobias = iSADFrmMB[2];
		pmbmd->m_mbType = INTERPOLATE;
	}

	if(m_bCodedFutureRef==FALSE) // force forward
	{
		iSAD = iSADFrmMB[0];
		pmbmd->m_mbType = FORWARD;
	}
	
	if (m_vopmd.bInterlace) {
		const PixelC *ppxlcFwdHalfPelRef = m_pvopcRefQ0->pixelsY()
			+EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME+ x + y * m_iFrameWidthY; // 1.31.99 changes
		const PixelC *ppxlcBakHalfPelRef = m_pvopcRefQ1->pixelsY()
			+EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME+ x + y * m_iFrameWidthY; // 1.31.99 changes
		Int iSADFldMB[3], iSADFld[8];

		// Choose best fwd top field predictor
		iSADFld[0] = blkmatch16x8WithShape (pmvForward+1, x, y, 0,
			ppxlcRef0MBY, ppxlcFwdHalfPelRef, m_vopmd.iSearchRangeForward,0);
		pmvForward[1].computeTrueMV();
		iSADFld[1] = blkmatch16x8WithShape (pmvForward+2, x, y, 0,
			ppxlcRef0MBY + m_iFrameWidthY, ppxlcFwdHalfPelRef + m_iFrameWidthY,
			m_vopmd.iSearchRangeForward,0);
		pmvForward[2].computeTrueMV();
		if (iSADFld[0] <= iSADFld[1]) {
			pmbmd->m_bForwardTop = 0;
			iSADFldMB[0] = iSADFld[0];
		} else {
			pmbmd->m_bForwardTop = 1;
			iSADFldMB[0] = iSADFld[1];
		}

		// Choose best fwd botton field predictor
		iSADFld[2] = blkmatch16x8WithShape (pmvForward+3, x, y, MB_SIZE,
			ppxlcRef0MBY, ppxlcFwdHalfPelRef, m_vopmd.iSearchRangeForward,0);
		pmvForward[3].computeTrueMV();
		iSADFld[3] = blkmatch16x8WithShape (pmvForward+4, x, y, MB_SIZE,
			ppxlcRef0MBY + m_iFrameWidthY, ppxlcFwdHalfPelRef + m_iFrameWidthY,
			m_vopmd.iSearchRangeForward,0);
		pmvForward[4].computeTrueMV();
		if (iSADFld[2] < iSADFld[3]) {
			pmbmd->m_bForwardBottom = 0;
			iSADFldMB[0] += iSADFld[2];
		} else {
			pmbmd->m_bForwardBottom = 1;
			iSADFldMB[0] += iSADFld[3];
		}

		
		// Choose best bak top field predictor
		iSADFld[4] = blkmatch16x8WithShape (pmvBackward+1, x, y, 0,
			ppxlcRef1MBY, ppxlcBakHalfPelRef, m_vopmd.iSearchRangeBackward,1);
		pmvBackward[1].computeTrueMV();
		iSADFld[5] = blkmatch16x8WithShape (pmvBackward+2, x, y, 0,
			ppxlcRef1MBY + m_iFrameWidthY, ppxlcBakHalfPelRef + m_iFrameWidthY,
			m_vopmd.iSearchRangeBackward,1);
		pmvBackward[2].computeTrueMV();
		if (iSADFld[4] <= iSADFld[5]) {
			pmbmd->m_bBackwardTop = 0;
			iSADFldMB[1] = iSADFld[4];
		} else {
			pmbmd->m_bBackwardTop = 1;
			iSADFldMB[1] = iSADFld[5];
		}

		// Choose best bak bottom field predictor
		iSADFld[6] = blkmatch16x8WithShape (pmvBackward+3, x, y, MB_SIZE,
			ppxlcRef1MBY, ppxlcBakHalfPelRef, m_vopmd.iSearchRangeBackward,1);
		pmvBackward[3].computeTrueMV();
		iSADFld[7] = blkmatch16x8WithShape (pmvBackward+4, x, y, MB_SIZE,
			ppxlcRef1MBY + m_iFrameWidthY, ppxlcBakHalfPelRef + m_iFrameWidthY,
			m_vopmd.iSearchRangeBackward,1);
		pmvBackward[4].computeTrueMV();
		if (iSADFld[6] < iSADFld[7]) {
			pmbmd->m_bBackwardBottom = 0;
			iSADFldMB[1] += iSADFld[6];
		} else {
			pmbmd->m_bBackwardBottom = 1;
			iSADFldMB[1] += iSADFld[7];
		}

		// Choose best of forward & backward field prediction
		if (iSADFldMB[0] <= iSADFldMB[1]) {
			iFieldSAD = iSADFldMB[0];
			mbtype = FORWARD;
		} else {
			iFieldSAD = iSADFldMB[1];
			mbtype = BACKWARD;
		}
		iFieldSAD += BbiasAgainstField;
		iSADFldMB[2] = interpolateAndDiffYField(
			pmvForward  + 1 + (int)pmbmd->m_bForwardTop,
			pmvForward  + 3 + (int)pmbmd->m_bForwardBottom,
			pmvBackward + 1 + (int)pmbmd->m_bBackwardTop,
			pmvBackward + 3 + (int)pmbmd->m_bBackwardBottom,
			x, y, pmbmd);
		if ((iSADFldMB[2] + BbiasAgainstFieldAve) < iFieldSAD) {
			iFieldSAD = iSADFldMB[2] + BbiasAgainstFieldAve;
			mbtype = INTERPOLATE;
		}

		if(m_bCodedFutureRef==FALSE) // force forward
		{
			iFieldSAD = iSADFldMB[0];
			mbtype = FORWARD;
		}

		// Field versus Frame prediction
		if (iFieldSAD < iSAD) {
			pmbmd->m_bFieldMV = TRUE;
			pmbmd->m_mbType = mbtype;
			iSAD = iFieldSAD;
			iSADnobias = iFieldSAD - ((mbtype == INTERPOLATE) ? BbiasAgainstFieldAve : BbiasAgainstField);
		}
#ifdef __TRACE_AND_STATS_
		m_pbitstrmOut->trace (iSADFld,   8, "SADFld");
		m_pbitstrmOut->trace (iSADFldMB, 3, "SADFldMB");
#endif // __TRACE_AND_STATS_