vopmbenc.cpp

《Visual C++小波变换技术与工程实践》靳济芳编著的光盘程序。

	CMotionVector* pmv = m_rgmv;
	CMotionVector* pmvBackward = m_rgmvBackward;
	const CMBMode* pmbmdRef = m_rgmbmdRef;			//MB mode in ref frame for direct mode
	const CMotionVector* pmvRef = m_rgmvRef;		//MV in ref frame for direct mode
	PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
	
	PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
	PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
	PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();

	// MB rate control
	Int iIndexofQ = 0;
	Int rgiQ [4] = {-2, 0, 0, 2};
	// -----
	
	Int iQPPrev = m_vopmd.intStepB;
	Int iMBX, iMBY, iMB = 0;
	Int iMaxQP = (1<<m_volmd.uiQuantPrecision)-1; // NBIT
	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
		PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
		PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
		PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
		PixelC* ppxlcOrigMBY = ppxlcOrigY;
		PixelC* ppxlcOrigMBU = ppxlcOrigU;
		PixelC* ppxlcOrigMBV = ppxlcOrigV;
		CoordI x = 0;
		m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
		m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
		m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
		m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE, iMB++)	{
#ifdef __TRACE_AND_STATS_
			m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
			// shape quantization part
			m_statsMB.reset ();
#endif // __TRACE_AND_STATS_

			pmbmd->m_intStepDelta = 0;
			// MB rate control
			if (m_uiRateControl>=RC_TM5) {
				int k = m_tm5rc.tm5rc_calc_mquant(iMB, m_statsVOP.total());
				// special case for BVOP copied from MoMuSys
				if (k > iQPPrev) {
					if (iQPPrev+2 <= iMaxQP) pmbmd->m_intStepDelta = 2;
				} else if (k < iQPPrev) {
					if (iQPPrev-2 > 0) pmbmd->m_intStepDelta = -2;
				}
			}
#ifdef _MBQP_CHANGE_
			if (!(pmbmd->m_bColocatedMBSkip && !(pmbmd->m_bColocatedMCSEL)) && pmbmd->m_mbType != DIRECT) { // GMC
				iIndexofQ = (iIndexofQ + 1) % 4;
				pmbmd->m_dctMd = INTERQ;
				pmbmd->m_intStepDelta = rgiQ [iIndexofQ];
				Int iQuantMax = (1<<m_volmd.uiQuantPrecision) - 1;
				if ((iQPPrev + pmbmd->m_intStepDelta) > iQuantMax)
					pmbmd->m_intStepDelta = 0;
				if ((iQPPrev + pmbmd->m_intStepDelta) <= 0)
					pmbmd->m_intStepDelta = 0;
			}
			// -----
#endif //_MBQP_CHANGE_

			pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
/* NBIT: change 31 to iMaxQP
			assert (pmbmd->m_stepSize <= 31 && pmbmd->m_stepSize > 0);
*/
			assert (pmbmd->m_stepSize <= iMaxQP && pmbmd->m_stepSize > 0);

			if ( m_volmd.bVPBitTh >= 0) {
				Int iCounter = m_pbitstrmOut -> getCounter();
				if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
					// reset DQ to use QP in VP header
					pmbmd->m_intStepDelta = 0;
					if (pmbmd ->m_dctMd == INTERQ)
						pmbmd->m_dctMd = INTER;
					iQPPrev = pmbmd->m_stepSize;

					codeVideoPacketHeader (iMBX, iMBY, pmbmd->m_stepSize);	// video packet header
					m_iVPCounter = iCounter;
					//reset MV predictor
					m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
					m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
					m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
					m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;

				}
			}

			if ((pmbmd->m_bColocatedMBSkip && !(pmbmd->m_bColocatedMBMCSEL)) && // GMC
			(m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
			{ // don't need to send any bit for this mode
				copyFromRefToCurrQ (
					m_pvopcRefQ0,
					x, y, 
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL
				);
			}
			else {
				copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
				encodeBVOPMB (
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
					pmbmd, pmv, pmvBackward,
					pmbmdRef, pmvRef,
					iMBX, iMBY,
					x, y
				);
				if (pmbmd->getCodedBlockPattern (U_BLOCK) ||
					pmbmd->getCodedBlockPattern (V_BLOCK) ||
					pmbmd->getCodedBlockPattern (Y_BLOCK1) ||
					pmbmd->getCodedBlockPattern (Y_BLOCK2) ||
					pmbmd->getCodedBlockPattern (Y_BLOCK3) ||
					pmbmd->getCodedBlockPattern (Y_BLOCK4))
					iQPPrev = pmbmd->m_stepSize;
			}

			pmbmd++;
			pmv         += BVOP_MV_PER_REF_PER_MB;
			pmvBackward += BVOP_MV_PER_REF_PER_MB;
			pmvRef      += PVOP_MV_PER_REF_PER_MB;
			pmbmdRef++;
			m_statsVOP += m_statsMB;
			ppxlcCurrQMBY += MB_SIZE;
			ppxlcCurrQMBU += BLOCK_SIZE;
			ppxlcCurrQMBV += BLOCK_SIZE;
			ppxlcOrigMBY += MB_SIZE;
			ppxlcOrigMBU += BLOCK_SIZE;
			ppxlcOrigMBV += BLOCK_SIZE;
		}
		ppxlcCurrQY += m_iFrameWidthYxMBSize;
		ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
		ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
		
		ppxlcOrigY += m_iFrameWidthYxMBSize;
		ppxlcOrigU += m_iFrameWidthUVxBlkSize;
		ppxlcOrigV += m_iFrameWidthUVxBlkSize;
	}
}

Void CVideoObjectEncoder::encodeNSForBVOP_WithShape ()
{
	motionEstBVOP_WithShape ();

	// decide prediction direction for shape
//OBSSFIX_MODE3
  if(m_volmd.volType == ENHN_LAYER && m_volmd.bSpatialScalability && m_volmd.iHierarchyType == 0 &&
    m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1){
    m_vopmd.fShapeBPredDir = B_FORWARD;
  } else
//~OBSSFIX_MODE3
	if(m_bCodedFutureRef==FALSE)
		m_vopmd.fShapeBPredDir = B_FORWARD;
	else
	{
		if(m_tFutureRef - m_t >= m_t - m_tPastRef)
			m_vopmd.fShapeBPredDir = B_FORWARD;
		else
			m_vopmd.fShapeBPredDir = B_BACKWARD;
	}

	Int iQPPrev = m_vopmd.intStepB;
	Int iQPPrevAlpha = m_vopmd.intStepBAlpha[0];
	if (m_uiRateControl>=RC_TM5) iQPPrev = m_tm5rc.tm5rc_start_mb();

	CoordI y = m_rctCurrVOPY.top; 
	CMBMode*	   pmbmd = m_rgmbmd;
	// Added for field based MC padding by Hyundai(1998-5-9)
	CMBMode* field_pmbmd = m_rgmbmd;
	// End of Hyundai(1998-5-9)

	CMotionVector* pmv = m_rgmv;
	CMotionVector* pmvBackward = m_rgmvBackward;
	CMotionVector* pmvBY = m_rgmvBY;

//OBSS_SAIT_991015
	if(m_volmd.volType == BASE_LAYER && m_volmd.bSpatialScalability) {
		m_rgmvBaseBY = m_rgmvBY;
		m_rctBase = m_rctCurrVOPY;
	}
	Int xIndex, yIndex;
	xIndex = yIndex = 0;
//OBSSFIX_MODE3
    if( m_volmd.volType == ENHN_LAYER && (m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0) &&
	  !(m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1)) {
//	if(m_volmd.volType == ENHN_LAYER && (m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0)) {
//~OBSSFIX_MODE3
		xIndex = (m_rctCurrVOPY.left - (m_rctBase.left*	m_volmd.ihor_sampling_factor_n_shape/m_volmd.ihor_sampling_factor_m_shape));			
		yIndex = (m_rctCurrVOPY.top - (m_rctBase.top*m_volmd.iver_sampling_factor_n_shape/m_volmd.iver_sampling_factor_m_shape));			
		xIndex /= MB_SIZE;
		yIndex /= MB_SIZE;
	}
//~OBSS_SAIT_991015

	PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcCurrQ->pixelsBY () + m_iStartInRefToCurrRctY;
	PixelC **pppxlcCurrQA, **pppxlcOrigA;
	
	PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
	PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
	PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
	PixelC* ppxlcOrigBY = (PixelC*) m_pvopcOrig->pixelsBoundBY ();

// MAC (SB) 26-Nov-99
  PixelC** pppxlcCurrQMBA;
  const PixelC** pppxlcOrigMBA;
	if (m_volmd.fAUsage == EIGHT_BIT) {
    pppxlcCurrQA   = new PixelC* [m_volmd.iAuxCompCount];
    pppxlcOrigA    = new PixelC* [m_volmd.iAuxCompCount];
    pppxlcCurrQMBA = new PixelC* [m_volmd.iAuxCompCount];
    pppxlcOrigMBA  = new const PixelC* [m_volmd.iAuxCompCount];
    for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
		  pppxlcCurrQA[iAuxComp] = (PixelC*) m_pvopcCurrQ->pixelsA (iAuxComp) + m_iStartInRefToCurrRctY;
		  pppxlcOrigA[iAuxComp]  = (PixelC*) m_pvopcOrig->pixelsBoundA (iAuxComp);
    }
	}
//~MAC

	Int iMBX, iMBY, iMB = 0;
	const CMBMode* pmbmdRef;
	const CMotionVector* pmvRef;
	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
		PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
		PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
		PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
		PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
		//PixelC* ppxlcCurrQMBA = ppxlcCurrQA;
		PixelC* ppxlcOrigMBY = ppxlcOrigY;
		PixelC* ppxlcOrigMBU = ppxlcOrigU;
		PixelC* ppxlcOrigMBV = ppxlcOrigV;
		PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
		//PixelC* ppxlcOrigMBA = ppxlcOrigA;
	  if (m_volmd.fAUsage == EIGHT_BIT) {
      for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
	  	  pppxlcCurrQMBA[iAuxComp] = pppxlcCurrQA[iAuxComp];
		    pppxlcOrigMBA[iAuxComp]  = pppxlcOrigA[iAuxComp];
      }
	  }

		CoordI x = m_rctCurrVOPY.left;
		m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
		m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
		m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
		m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
		Int iMaxQP = (1<<m_volmd.uiQuantPrecision)-1; // NBIT
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE, iMB++)	{
			pmbmd->m_intStepDelta = 0;	//sharp added this
			pmbmd->m_bPadded=FALSE;
			// shape quantization part
			m_statsMB.reset ();

// Modified for error resilience mode by Toshiba(1998-1-16)
			pmbmd->m_stepSize = m_vopmd.intStepB;
			// MB rate control  -- should this be here??????
			if (m_uiRateControl>=RC_TM5) {
				int k = m_tm5rc.tm5rc_calc_mquant(iMB, m_statsVOP.total());
				// special case for BVOP copied from MoMuSys
				if (k > iQPPrev) {
					if (iQPPrev+2 <= iMaxQP) pmbmd->m_intStepDelta = 2;
				} else if (k < iQPPrev) {
					if (iQPPrev-2 > 0) pmbmd->m_intStepDelta = -2;
				}
			}
			if ( m_volmd.bVPBitTh >= 0) {
				Int iCounter = m_pbitstrmOut -> getCounter();
				if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
//					// reset DQ to use QP in VP header
//					pmbmd->m_intStepDelta = 0;
//					if (pmbmd ->m_dctMd == INTERQ)
//						pmbmd->m_dctMd = INTER;
//					iQPPrev = pmbmd->m_stepSize;

					codeVideoPacketHeader (iMBX, iMBY, pmbmd->m_stepSize);	// video packet header
					m_iVPCounter = iCounter;
					//reset MV predictor
					m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
					m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
					m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
					m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
				}
			}
// End Toshiba(1998-1-16)

			findColocatedMB (iMBX, iMBY,  pmbmdRef, pmvRef);

			ShapeMode shpmdColocatedMB;
//OBSS_SAIT_991015
			if(!(m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0)){		
				if(m_vopmd.fShapeBPredDir==B_FORWARD)
					shpmdColocatedMB = m_rgshpmd [min (max (0, iMBX), m_iRefShpNumMBX - 1) 
						+ min (max (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
				else
					shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
						+ min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
			}
			else {
//OBSSFIX_MODE3
				if(m_volmd.volType == BASE_LAYER){                      
					if(m_vopmd.fShapeBPredDir==B_FORWARD)
						shpmdColocatedMB = m_rgshpmd [min (max (0, iMBX), m_iRefShpNumMBX - 1) 
                                                     + min (max (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
					else
						shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
                                                       + min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
				}
                else if (m_volmd.volType == ENHN_LAYER){
					if(m_volmd.iEnhnType!=0 &&m_volmd.iuseRefShape ==1){
						shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
                                                       + min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
					}else{
						Int index = min (max (0, (iMBX+xIndex)*m_volmd.ihor_sampling_factor_m_shape/m_volmd.ihor_sampling_factor_n_shape), (m_iNumMBBaseXRef-1)) + min (max (0, (iMBY+yIndex)*m_volmd.iver_sampling_factor_m_shape/m_volmd.iver_sampling_factor_n_shape), (m_iNumMBBaseYRef-1)) * (m_iNumMBBaseXRef);                       
						shpmdColocatedMB = m_rgBaseshpmd [index];
					}
				}

//				if((m_volmd.volType == BASE_LAYER) || (!(m_volmd.iEnhnType==0 || m_volmd.iuseRefShape ==0) && !m_volmd.bShapeOnly) ){			
//					if(m_vopmd.fShapeBPredDir==B_FORWARD)
//						shpmdColocatedMB = m_rgshpmd [min (max (0, iMBX), m_iRefShpNumMBX - 1) 
//							+ min (max (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
//					else
//						shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
//							+ min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
//				}
//				else if (m_volmd.volType == ENHN_LAYER){
//						Int index = min (max (0, (iMBX+xIndex)*m_volmd.ihor_sampling_factor_m_shape/m_volmd.ihor_sampling_factor_n_shape), (m_iNumMBBaseXRef-1)) + min (max (0, (iMBY+yIndex)*m_volmd.iver_sampling_factor_m_shape/m_volmd.iver_sampling_factor_n_shape), (m_iNumMBBaseYRef-1)) * (m_iNumMBBaseXRef);			
//						shpmdColocatedMB = m_rgBaseshpmd [index];
//				}
//~OBSS_SAIT_991015
			}

			if ((pmbmd->m_bColocatedMBSkip && !(pmbmd->m_bColocatedMBMCSEL)) && // GMC
			(m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
			{ // don't need to send any bit for this mode
				copyToCurrBuffJustShape( ppxlcOrigMBBY, m_iFrameWidthY );
				m_statsMB.nBitsShape += codeInterShape (
					ppxlcCurrQMBBY,
					m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
					pmbmd, shpmdColocatedMB,
					NULL, pmvBY,
					x, y, 
					iMBX, iMBY
				);
				downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMB