motest.cpp

完整的RTP RTSP代码库

			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);
			pmv[i].computeMV (); 
		}
	}
	//end of new changes
// ~INTERLACE
	else {
		pmv [1].computeTrueMV ();
		pmv [2].computeTrueMV ();
		pmv [3].computeTrueMV ();
		pmv [4].computeTrueMV ();
		pmv [1].computeMV ();
		pmv [2].computeMV ();
		pmv [3].computeMV ();
		pmv [4].computeMV ();
		pmbmd -> m_bhas4MVForward = TRUE;
		iSADInter = iSAD8;
	}
// GMC
	pmbmd -> m_bMCSEL = FALSE;
	if(m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE){
		Int iNb = pmbmd->m_rgNumNonTranspPixels [0] ;
		Int iMSADG = 4096*256;
		PixelC* ppxlcRefforgme = (PixelC*) m_pvopcRefQ0->pixelsY () ;
		iMSADG = globalme (x,y,ppxlcRefforgme);
#ifdef __TRACE_AND_STATS_
		m_pbitstrmOut->trace (iMSADG, "MB_GMC");
#endif // __TRACE_AND_STATS_
		Int ioffset, iQP=m_uiGMCQP; // GMC_V2 *m_rgiQPpred;
		if(pmbmd -> m_bhas4MVForward == TRUE)
			ioffset = iQP*iNb/16;
			//ioffset = iQP*iNb/24;
		else
		{
			if(pmbmd -> m_bFieldMV == TRUE)
			{
				ioffset = iQP*iNb/32;
			}else{
				if(pmv->m_vctTrueHalfPel.x == 0 && pmv->m_vctTrueHalfPel.y == 0)
					ioffset = iFavor16x16*2;
				else
					ioffset = iQP*iNb/64;
			}
		}
		if((iMSADG - ioffset) <= iSADInter)
		{
			iSADInter = iMSADG;
			pmbmd -> m_dctMd = INTER;
			pmbmd -> m_bFieldMV = FALSE;
			pmbmd -> m_bhas4MVForward = FALSE;
			pmbmd -> m_bMCSEL = TRUE;
			Int iPmvx, iPmvy, iHalfx, iHalfy;
			globalmv (iPmvx, iPmvy, iHalfx, iHalfy,
				x,y,m_vopmd.mvInfoForward.uiRange,m_volmd.bQuarterSample);
			*pmv = CMotionVector (iPmvx, iPmvy);
			pmv -> iHalfX = iHalfx;
			pmv -> iHalfY = iHalfy;
			pmv -> computeTrueMV ();
			pmv -> computeMV ();
			for (UInt i = 1; i < PVOP_MV_PER_REF_PER_MB; i++)
				pmv[i] = *pmv;
		}
		else
		{
			pmbmd -> m_bMCSEL = FALSE;
		}
	}
// ~GMC
/* NBIT: change
	if (iSumDev < (iSADInter - (pmbmd->m_rgNumNonTranspPixels [0] << 1))) {
*/
// GMC
	Int iIntraOffset;
	if(m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE)
		iIntraOffset = iFavorInter;
		//iIntraOffset = iFavorInter/2;
	else
		iIntraOffset = iFavorInter;
// ~GMC
	if (iSumDev < (iSADInter - iIntraOffset)) { // GMC
		pmbmd -> m_bSkip = FALSE;
		pmbmd -> m_dctMd = INTRA;
// new changes
		pmbmd -> m_bFieldMV = FALSE;
// GMC
		pmbmd -> m_bMCSEL = FALSE;
// ~GMC
		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
// GMC
			&& pmbmd -> m_bMCSEL == FALSE
// ~GMC
			&& 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
)
{
  //for QuarterPel mwi 21JUL98
    const CMotionVector* pmvRefBlk = pmvRef;
    CMotionVector* pmvDirectForward = rgmvDirectForward;
    CMotionVector* pmvDirectBack = rgmvDirectBack;
    //~for QuarterPel mwi 21JUL98

 	Int iInitSAD = sad16x16At0 (ppxlcRef0MBY) + FAVORZERO;
	Int iSADForward = blkmatch16 (pmvForward, x, y, x, y, iInitSAD, ppxlcRef0MBY, m_puciRefQZoom0, m_vopmd.iSearchRangeForward, m_volmd.bQuarterSample);
	pmvForward->computeTrueMV ();
	pmvForward->computeMV ();

	Int iSADDirect = 1000000000;
	CVector vctRefScaled;
	// TPS FIX

	// QuarterPel mwi 21JUL98
	// 	if (bColocatedMBExist && pmbmdRef->m_bhas4MVForward == FALSE &&
	// 		(m_volmd.volType != ENHN_LAYER || ( m_vopmd.iRefSelectCode != 1 && m_vopmd.iRefSelectCode != 2))) {
	if (bColocatedMBExist &&
      (m_volmd.volType != ENHN_LAYER || ( m_vopmd.iRefSelectCode != 1 && m_vopmd.iRefSelectCode != 2))) {
	  iSADDirect = directSAD(x, y, pmbmd, pmbmdRef, pmvRef);
	  Int iPartInterval = m_t - m_tPastRef;	
	  Int iFullInterval = m_tFutureRef - m_tPastRef;
	  for (Int iBlkNo=1; iBlkNo<=4; iBlkNo++) {
	    pmvDirectForward++;
	    pmvDirectBack++;
	    pmvRefBlk++;
	        
	    vctRefScaled = pmvRefBlk->trueMVHalfPel () * iPartInterval;        
	    vctRefScaled.x /= iFullInterval;
	    vctRefScaled.y /= iFullInterval;
	    //set up forward vector; 
	    pmvDirectForward->m_vctTrueHalfPel.x = vctRefScaled.x + pmbmd->m_vctDirectDeltaMV.x;
	    pmvDirectForward->m_vctTrueHalfPel.y = vctRefScaled.y + pmbmd->m_vctDirectDeltaMV.y;
	    pmvDirectForward->computeMV ();
	    //set up backward vector
	    backwardMVFromForwardMV (rgmvDirectBack [iBlkNo], rgmvDirectForward [iBlkNo], *pmvRefBlk, pmbmd->m_vctDirectDeltaMV);
	  }

// GMC
		if(pmbmdRef->m_bMCSEL)
			iSADDirect -= FAVORZERO;
		else
		if (pmbmd->m_vctDirectDeltaMV.x == 0 && pmbmd->m_vctDirectDeltaMV.y == 0)
        		iSADDirect -= FAVORZERO;
	}
// ~GMC

	  //		Int iPartInterval = m_t - m_tPastRef;		//initialize at MVDB = 0
	  //vctRefScaled = pmvRef->trueMVHalfPel () * iPartInterval;
	  //Int iFullInterval = m_tFutureRef - m_tPastRef;

		//        //for QuarterPel mwi 21JUL98
		//        iSADDirect = 0;      
		//        Int iBlkNo;
		//        for (iBlkNo=1; iBlkNo<=4; iBlkNo++) {
		//          pmvDirectForward++;
		//          pmvDirectBack++;
		//          pmvRefBlk++;
		//        
		//          vctRefScaled = pmvRefBlk->trueMVHalfPel () * iPartInterval;        
		//          vctRefScaled.x /= iFullInterval;
		//          vctRefScaled.y /= iFullInterval;
		//          //set up initial forward vector; 
		//          pmvDirectForward->m_vctTrueHalfPel.x = vctRefScaled.x; //trueHalfPel!!
		//          pmvDirectForward->m_vctTrueHalfPel.y = vctRefScaled.y;
		//          pmvDirectForward->computeMV ();
		//          //set up initial backward vector
		//          pmbmd->m_vctDirectDeltaMV = pmvDirectForward->m_vctTrueHalfPel - vctRefScaled; //
		//          backwardMVFromForwardMV (rgmvDirectBack [iBlkNo], rgmvDirectForward [iBlkNo], *pmvRefBlk, pmbmd->m_vctDirectDeltaMV);
		//          //compute initial sad
		//          iSADDirect += interpolateAndDiffY8 (rgmvDirectForward, rgmvDirectBack, x, y, iBlkNo,
		//                                              &m_rctRefVOPY0, &m_rctRefVOPY1) - FAVORZERO;
		//        }
        // 		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
        // 		iSADDirect = blkmatch16 (rgmvDirectForward, iXInit, iYInit, x, y, iSADDirect, ppxlcInitRefMBY,
        // 	       	m_puciRefQZoom0, m_vopmd.iDirectModeRadius, m_volmd.bQuarterSample) - FAVOR_DIRECT;
        // 		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);
        // // GMC
        // 		if(pmbmdRef->m_bMCSEL)
        // 			iSADDirect -= FAVORZERO;
        // 		else
        // // ~GMC
        // 		if (pmbmd->m_vctDirectDeltaMV.x == 0 && pmbmd->m_vctDirectDeltaMV.y == 0)
        // 			iSADDirect -= FAVORZERO;

        // ~for QuarterPel mwi 21JUL98
	
	
	iInitSAD = sad16x16At0 (ppxlcRef1MBY) + FAVORZERO;
	Int iSADBackward = blkmatch16 (pmvBackward, x, y, x, y, iInitSAD, ppxlcRef1MBY, m_puciRefQZoom1, m_vopmd.iSearchRangeBackward, m_volmd.bQuarterSample);
	pmvBackward->computeTrueMV ();
	pmvBackward->computeMV ();
	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];
		for (iBlk = 0; iBlk <= 4; iBlk++) {
		  pmvForward [iBlk] = rgmvDirectForward [iBlk];
		  pmvBackward [iBlk] = rgmvDirectBack [iBlk];
		}
	}
	else if (iSADMin == iSADForward) {
		pmbmd->m_mbType = FORWARD;
		for (iBlk = 1; iBlk <= 4; iBlk++)
			pmvForward [iBlk] = pmvForward [0];
	}
	else if (iSADMin == iSADBackward) {
		pmbmd->m_mbType = BACKWARD;
		for (iBlk = 1; iBlk <= 4; iBlk++)
			pmvBackward [iBlk] = pmvBackward [0];
	}
	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, m_volmd.bQuarterSample);

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

	iInitSAD = sad16x16At0 (ppxlcRef1MBY);
	Int iSADBackward = iInitSAD;
	*pmvBackward = CMotionVector (0,0);
	pmvBackward->computeTrueMV ();
	pmvBackward->computeMV ();
	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;
		for (iBlk = 1; iBlk <= 4; iBlk++)
			pmvForward [iBlk] = pmvForward [0];
	}
	else if (iSADMin == iSADBackward) {
		pmbmd->m_mbType = BACKWARD;
		for (iBlk = 1; iBlk <= 4; iBlk++)
			pmvBackward [iBlk] = pmvBackward [0];
	}
	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, m_volmd.bQuarterSample,0);
	pmvForward->computeTrueMV ();
	pmvForward->computeMV ();
	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 ();
		rgmvDirectForward->computeMV ();
		//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