motest.cpp

网络MPEG4IP流媒体开发源代码

	ppxlcCodedBlkBY += BLOCK_SIZE;

#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
#endif // __TRACE_AND_STATS_
	
	iSAD8 += 
		(pmbmd->m_rgTranspStatus [4] == PARTIAL) ? blockmatch8WithShape (ppxlcCodedBlkY, ppxlcCodedBlkBY, pmv8, blkX, blkY, pmv, m_vopmd.iSearchRangeForward,0) :
		(pmbmd->m_rgTranspStatus [4] == NONE)	? blockmatch8 (ppxlcCodedBlkY, pmv8, blkX, blkY, pmv, m_vopmd.iSearchRangeForward) : 0;
#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
#endif // __TRACE_AND_STATS_

	// begin added by Sharp (98/9/10) prevents inter4v with one transp block
	if (( pmbmd->m_rgTranspStatus [1] != ALL && pmbmd->m_rgTranspStatus [2] == ALL
		&& pmbmd->m_rgTranspStatus [3] == ALL && pmbmd->m_rgTranspStatus [4] == ALL	)||
		( pmbmd->m_rgTranspStatus [1] == ALL && pmbmd->m_rgTranspStatus [2] != ALL
		&& pmbmd->m_rgTranspStatus [3] == ALL && pmbmd->m_rgTranspStatus [4] == ALL	)||
		( pmbmd->m_rgTranspStatus [1] == ALL && pmbmd->m_rgTranspStatus [2] == ALL
		&& pmbmd->m_rgTranspStatus [3] != ALL && pmbmd->m_rgTranspStatus [4] == ALL	)||
		( pmbmd->m_rgTranspStatus [1] == ALL && pmbmd->m_rgTranspStatus [2] == ALL
		&& pmbmd->m_rgTranspStatus [3] == ALL && pmbmd->m_rgTranspStatus [4] != ALL ))
		iSAD8 = 256 * 4096;
	// end added by Sharp (98/9/10)

#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
#endif // __TRACE_AND_STATS_

	/* NBIT: change
	if ((iSADInter - ((pmbmd->m_rgNumNonTranspPixels [0] >> 1) + 1)) <= iSAD8) {
*/
// new changes
	iSADInter -= iFavor16x16;
	iSAD16x8 -= FAVOR_FIELD;
	if ((iSADInter <= iSAD8)&&(iSADInter <= iSAD16x8)) {
		iSADInter += iFavor16x16;
// end of new changes
		pmbmd -> m_bhas4MVForward = FALSE;
		pmv -> computeTrueMV (); // compute here instead of blkmatch to save computation
		for (UInt i = 1; i < PVOP_MV_PER_REF_PER_MB; i++) // didn't increment the last pmv
			pmv [i] = *pmv;
	}
// INTERLACE
	// new changes
	else if (iSAD16x8 <= iSAD8) { // Field-based
		pmbmd -> m_bhas4MVForward = FALSE;
		pmbmd -> m_bFieldMV = TRUE;
		Int iTempX1, iTempY1, iTempX2, iTempY2;
		if(pmbmd->m_bForwardTop) {
			pmv [6].computeTrueMV ();
			iTempX1 = pmv[6].m_vctTrueHalfPel.x;
			iTempY1 = pmv[6].m_vctTrueHalfPel.y;
		}
		else {
			pmv [5].computeTrueMV ();
			iTempX1 = pmv[5].m_vctTrueHalfPel.x;
			iTempY1 = pmv[5].m_vctTrueHalfPel.y;
		}
		if(pmbmd->m_bForwardBottom) {
			pmv [8].computeTrueMV ();
			iTempX2 = pmv[8].m_vctTrueHalfPel.x;
			iTempY2 = pmv[8].m_vctTrueHalfPel.y;
		}
		else {
			pmv [7].computeTrueMV ();
			iTempX2 = pmv[7].m_vctTrueHalfPel.x;
			iTempY2 = pmv[7].m_vctTrueHalfPel.y;
		}
		iSADInter = iSAD16x8 + FAVOR_FIELD;
		Int iTemp;
		for (UInt i = 1; i < 5; i++) {
			iTemp = iTempX1 + iTempX2;
			pmv [i].m_vctTrueHalfPel.x = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
			iTemp = iTempY1 + iTempY2;
			pmv [i].m_vctTrueHalfPel.y = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
		}
	}
	//end of new changes
// ~INTERLACE
	else {
		pmv [1].computeTrueMV ();
		pmv [2].computeTrueMV ();
		pmv [3].computeTrueMV ();
		pmv [4].computeTrueMV ();
		pmbmd -> m_bhas4MVForward = TRUE;
		iSADInter = iSAD8;
	}
/* NBIT: change
	if (iSumDev < (iSADInter - (pmbmd->m_rgNumNonTranspPixels [0] << 1))) {
*/
	if (iSumDev < (iSADInter - iFavorInter)) {
		pmbmd -> m_bSkip = FALSE;
		pmbmd -> m_dctMd = INTRA;
// new changes
		pmbmd -> m_bFieldMV = FALSE;
		memset (pmv, 0, PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
		return ((m_uiRateControl==RC_MPEG4) ? sumAbsCurrMB () : 0);
	}
	else {
		pmbmd -> m_dctMd = INTER;
// new changes
		if (pmbmd->m_bhas4MVForward == FALSE
			&& pmbmd -> m_bFieldMV == FALSE
			&& pmv->m_vctTrueHalfPel.x == 0 && pmv->m_vctTrueHalfPel.y == 0)
			return (iSADInter + iFavorZero);
		else 
			return iSADInter;
	}
}

CMotionVector rgmvDirectBack [5];
CMotionVector rgmvDirectForward [5];

Int CVideoObjectEncoder::motionEstMB_BVOP (
	CoordI x, CoordI y, 
	CMotionVector* pmvForward, CMotionVector* pmvBackward,
	CMBMode* pmbmd,
	const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
	const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY,
	Bool bColocatedMBExist
)
{
	//printf("(%d,%d)\n", x, y);
	Int iInitSAD = sad16x16At0 (ppxlcRef0MBY) + FAVORZERO;
	Int iSADForward = blkmatch16 (pmvForward, x, y, x, y, iInitSAD, ppxlcRef0MBY, m_puciRefQZoom0, m_vopmd.iSearchRangeForward);
	pmvForward->computeTrueMV ();

	Int iSADDirect = 1000000000;
	CVector vctRefScaled;
	// TPS FIX
	if (bColocatedMBExist && pmbmdRef->m_bhas4MVForward == FALSE &&
		(m_volmd.volType != ENHN_LAYER || ( m_vopmd.iRefSelectCode != 1 && m_vopmd.iRefSelectCode != 2))) {
		Int iPartInterval = m_t - m_tPastRef;		//initialize at MVDB = 0
		vctRefScaled = pmvRef->trueMVHalfPel () * iPartInterval;
		Int iFullInterval = m_tFutureRef - m_tPastRef;
		vctRefScaled.x /= iFullInterval;				//truncation as per vm
		vctRefScaled.y /= iFullInterval;				//truncation as per vm
		//set up initial forward vector; 
		rgmvDirectForward->iMVX = vctRefScaled.x / 2;
		rgmvDirectForward->iMVY = vctRefScaled.y / 2;
		rgmvDirectForward->iHalfX = 0;
		rgmvDirectForward->iHalfY = 0;
		rgmvDirectForward->computeTrueMV ();
		//set up initial backward vector
		pmbmd->m_vctDirectDeltaMV = rgmvDirectForward->m_vctTrueHalfPel - vctRefScaled;	//mvdb not necessaryly 0 due to truncation of half pel 
		backwardMVFromForwardMV (rgmvDirectBack [0], rgmvDirectForward [0], *pmvRef, pmbmd->m_vctDirectDeltaMV);
		//compute initial sad
		iSADDirect = interpolateAndDiffY (rgmvDirectForward, rgmvDirectBack, x, y,
			&m_rctRefVOPY0, &m_rctRefVOPY1) - FAVORZERO;
		//set up inital position in ref frame
		Int iXInit = x + rgmvDirectForward->iMVX;
		Int iYInit = y + rgmvDirectForward->iMVY;
		const PixelC* ppxlcInitRefMBY = m_pvopcRefQ0->pixelsY () + m_rctRefFrameY.offset (iXInit, iYInit);
		//compute forward mv and sad; to be continue in iSADMin==iSADDirect
		Int isave = m_iMVFileUsage;                       // 04/28/99 david ruhoff
		if (!m_volmd.bOriginalForME) m_iMVFileUsage = 0;  // 04/28/99  must not use mv file based on reconstructed vop
		iSADDirect = blkmatch16 (rgmvDirectForward, iXInit, iYInit, x, y, iSADDirect, ppxlcInitRefMBY,
	       	m_puciRefQZoom0, m_vopmd.iDirectModeRadius) - FAVOR_DIRECT;
		m_iMVFileUsage = isave;                           // 04/28/99 
		rgmvDirectForward->computeTrueMV ();
		pmbmd->m_vctDirectDeltaMV = rgmvDirectForward->m_vctTrueHalfPel - vctRefScaled;
		backwardMVFromForwardMV (rgmvDirectBack [0], rgmvDirectForward [0], *pmvRef, 
								 pmbmd->m_vctDirectDeltaMV);
		iSADDirect = interpolateAndDiffY (rgmvDirectForward, rgmvDirectBack, x, y,
										  &m_rctRefVOPY0, &m_rctRefVOPY1);
		if (pmbmd->m_vctDirectDeltaMV.x == 0 && pmbmd->m_vctDirectDeltaMV.y == 0)
			iSADDirect -= FAVORZERO;
	}

	iInitSAD = sad16x16At0 (ppxlcRef1MBY) + FAVORZERO;
	Int iSADBackward = blkmatch16 (pmvBackward, x, y, x, y, iInitSAD, ppxlcRef1MBY, m_puciRefQZoom1, m_vopmd.iSearchRangeBackward);
	pmvBackward->computeTrueMV ();
	Int iSADInterpolate = interpolateAndDiffY (
		pmvForward, pmvBackward,
		x, y, &m_rctRefVOPY0, &m_rctRefVOPY1
	);

	Int iSADMin = minimum (iSADDirect, iSADForward, iSADBackward, iSADInterpolate);
	
	if(m_bCodedFutureRef==FALSE)
		iSADMin = iSADForward; // force forward mode
	
	Int iBlk;
	if (iSADMin == iSADDirect) {
		pmbmd->m_mbType = DIRECT;
		//compute backward mv
		pmvForward [0]  = rgmvDirectForward  [0];
		pmvBackward [0] = rgmvDirectBack [0];
	}
	else if (iSADMin == iSADForward) {
		pmbmd->m_mbType = FORWARD;
	}
	else if (iSADMin == iSADBackward) {
		pmbmd->m_mbType = BACKWARD;
	}
	else {
		pmbmd->m_mbType = INTERPOLATE;
	}

	for (iBlk = 1; iBlk <= 4; iBlk++) {
		pmvForward [iBlk] = pmvForward [0];
		pmvBackward [iBlk] = pmvBackward [0];
	}

	return iSADMin;
}

// for spatial scalability only
Int CVideoObjectEncoder::motionEstMB_BVOP (
	CoordI x, CoordI y, 
	CMotionVector* pmvForward, CMotionVector* pmvBackward,
	CMBMode* pmbmd,
	const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY
)
{
	Int iInitSAD = sad16x16At0 (ppxlcRef0MBY);
	Int iSADForward = blkmatch16 (pmvForward, x, y,x,y, iInitSAD, ppxlcRef0MBY, m_puciRefQZoom0, m_vopmd.iSearchRangeForward);

	pmvForward->computeTrueMV ();
	//Int iSADDirect = 1000000000;

	iInitSAD = sad16x16At0 (ppxlcRef1MBY);
	Int iSADBackward = iInitSAD;
	*pmvBackward = CMotionVector (0,0);
	pmvBackward->computeTrueMV ();
	Int iSADInterpolate = interpolateAndDiffY (pmvForward, pmvBackward, x, y,
			&m_rctRefVOPY0, &m_rctRefVOPY1);

	Int iSADMin=0;
	if(iSADForward <= iSADBackward && iSADForward <= iSADInterpolate)
		iSADMin = iSADForward;
	else if (iSADBackward <= iSADInterpolate)
		iSADMin = iSADBackward;
	else
		iSADMin = iSADInterpolate;
	Int iBlk;
	if (iSADMin == iSADForward) {
		pmbmd->m_mbType = FORWARD;
	}
	else if (iSADMin == iSADBackward) {
		pmbmd->m_mbType = BACKWARD;
	}
	else {
		pmbmd->m_mbType = INTERPOLATE;
	}

	for (iBlk = 1; iBlk <= 4; iBlk++) {
		pmvForward [iBlk] = pmvForward [0];
		pmvBackward [iBlk] = pmvBackward [0];
	}
	return iSADMin;
}

Int CVideoObjectEncoder::motionEstMB_BVOP_WithShape (
	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 iInitSAD = sad16x16At0WithShape (ppxlcRef0MBY, pmbmd);	//shouldn't favor 0 mv inside this function
	Int iSADForward = blkmatch16WithShape (pmvForward, x, y, x, y, iInitSAD, ppxlcRef0MBY,
        m_puciRefQZoom0, pmbmd, m_vopmd.iSearchRangeForward,0);
	pmvForward->computeTrueMV ();
	Int iSADDirect = 1000000000;
	CVector vctRefScaled;
	if (bColocatedMBExist && pmbmdRef->m_bhas4MVForward == FALSE && 
		(m_volmd.volType != ENHN_LAYER || ( m_vopmd.iRefSelectCode != 1 && m_vopmd.iRefSelectCode != 2))) {
		Int iPartInterval = m_t - m_tPastRef;		//initialize at MVDB = 0
		vctRefScaled = pmvRef->trueMVHalfPel () * iPartInterval;
		Int iFullInterval = m_tFutureRef - m_tPastRef;
		vctRefScaled.x /= iFullInterval;						//truncation as per vm
		vctRefScaled.y /= iFullInterval;						//truncation as per vm
		//set up initial forward vector; 
		rgmvDirectForward->iMVX = vctRefScaled.x / 2;
		rgmvDirectForward->iMVY = vctRefScaled.y / 2;
		rgmvDirectForward->iHalfX = 0;
		rgmvDirectForward->iHalfY = 0;
		rgmvDirectForward->computeTrueMV ();
		//set up initial backward vector
		pmbmd->m_vctDirectDeltaMV = rgmvDirectForward->m_vctTrueHalfPel - vctRefScaled;	//mvdb not necessaryly 0 due to truncation of half pel 
		backwardMVFromForwardMV (rgmvDirectBack [0], rgmvDirectForward [0], *pmvRef, pmbmd->m_vctDirectDeltaMV);
		//compute initial sad
		iSADDirect = interpolateAndDiffY_WithShape (rgmvDirectForward, rgmvDirectBack, x, y,
			&m_rctRefVOPY0, &m_rctRefVOPY1) - FAVORZERO;;
		//set up inital position in ref frame
		Int iXInit = x + rgmvDirectForward->iMVX;
		Int iYInit = y + rgmvDirectForward->iMVY;
		const PixelC* ppxlcInitRefMBY = m_pvopcRefQ0->pixelsY () + m_rctRefFrameY.offset (iXInit, iYInit);
		//compute forward mv and sad; to be continue in iSADMin==iSADDirect
		Int isave = m_iMVFileUsage;                       // 04/28/99 david ruhoff
		if (!m_volmd.bOriginalForME) m_iMVFileUsage = 0;  // 04/28/99  must not use mv file based on reconstructed vop
		iSADDirect = blkmatch16WithShape  (rgmvDirectForward, iXInit, iYInit, x, y, iSADDirect, ppxlcInitRefMBY,
	        m_puciRefQZoom0, pmbmd, m_vopmd.iDirectModeRadius,0) - FAVOR_DIRECT;
		m_iMVFileUsage = isave;                           // 04/28/99 
		rgmvDirectForward->computeTrueMV ();
		pmbmd->m_vctDirectDeltaMV = rgmvDirectForward->m_vctTrueHalfPel - vctRefScaled;
		backwardMVFromForwardMV (rgmvDirectBack [0], rgmvDirectForward [0], *pmvRef, 
								 pmbmd->m_vctDirectDeltaMV);
		iSADDirect = interpolateAndDiffY (rgmvDirectForward, rgmvDirectBack, x, y,
										  &m_rctRefVOPY0, &m_rctRefVOPY1);
		if (pmbmd->m_vctDirectDeltaMV.x == 0 && pmbmd->m_vctDirectDeltaMV.y == 0)
			iSADDirect -= FAVORZERO;
	}


	iInitSAD = sad16x16At0WithShape (ppxlcRef1MBY, pmbmd);//shouldn't favor 0 mv inside this function
	Int iSADBackward = blkmatch16WithShape (pmvBackward, x, y, x, y, iInitSAD, ppxlcRef1MBY,
		m_puciRefQZoom1, pmbmd, m_vopmd.iSearchRangeBackward,1);
	pmvBackward->computeTrueMV ();
	Int iSADInterpolate = interpolateAndDiffY_WithShape (
		pmvForward, pmvBackward,
		x, y, &m_rctRefVOPY0, &m_rctRefVOPY1
	);

	Int iSADMin = minimum (iSADDirect, iSADForward, iSADBackward, iSADInterpolate);
	Int iBlk;
	
	if(m_bCodedFutureRef==FALSE)
		iSADMin = iSADForward; // force forward mode
	
	if (iSADMin == iSADDirect) {
		pmbmd->m_mbType = DIRECT;
		//compute backward mv
		pmvForward [0] = rgmvDirectForward [0];
		pmvBackward [0] = rgmvDirectBack [0];
	}
	else if (iSADMin == iSADForward) {
		pmbmd->m_mbType = FORWARD;
	}
	else if (iSADMin == iSADBackward) {
		pmbmd->m_mbType = BACKWARD;
	}
	else {
		pmbmd->m_mbType = INTERPOLATE;
	}
	for (iBlk = 1; iBlk <= 4; iBlk++) {
		pmvForward [iBlk] = pmvForward [0];
		pmvBackward [iBlk] = pmvBackward [0];
	}
	return iSADMin;
}

// 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;