mbenc.cpp

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

	}
}

Void CVideoObjectEncoder::encodePVOPMB (
	PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
// RRV modification
	CMBMode* pmbmd, const CMotionVector* pmv, const CMotionVector* pmv_RRV,
//	CMBMode* pmbmd, const CMotionVector* pmv,
// ~RRV
	Int iMBX, Int iMBY,
	CoordI x, CoordI y
)
{
	// For Sprite update macroblock there is no motion compensation 
	if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
		if ( m_bSptMB_NOT_HOLE ) {
			m_iNumSptMB++ ;	   	 
			CopyCurrQToPred(ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
			computeTextureError ();
			Bool bSkip = pmbmd->m_bhas4MVForward ? (pmv [1].isZero () && pmv [2].isZero () && pmv [3].isZero () && pmv [4].isZero ())
											 : pmv->isZero ();
			quantizeTextureInterMB (pmbmd, pmv, NULL, bSkip); // decide COD here
			codeMBTextureHeadOfPVOP (pmbmd);
			if (!pmbmd -> m_bSkip) {
				sendDCTCoefOfInterMBTexture (pmbmd);
				addErrorAndPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
			}
		}
		else {
			pmbmd -> m_bSkip = TRUE;
			codeMBTextureHeadOfPVOP (pmbmd);
		}
		return;
	}

	if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
		pmbmd->m_bSkip = FALSE;			//in case use by direct mode in the future
// RRV insertion
		if(m_vopmd.RRVmode.iRRVOnOff == 1)
		{
			DownSamplingTextureForRRV(m_ppxlcCurrMBY,
									  m_ppxlcCurrMBY,
									  (MB_SIZE *m_iRRVScale),
									  (MB_SIZE *m_iRRVScale));
			DownSamplingTextureForRRV(m_ppxlcCurrMBU,
									  m_ppxlcCurrMBU,
									  (BLOCK_SIZE* m_iRRVScale),
									  (BLOCK_SIZE* m_iRRVScale));
			DownSamplingTextureForRRV(m_ppxlcCurrMBV,
									  m_ppxlcCurrMBV,
									  (BLOCK_SIZE* m_iRRVScale),
									  (BLOCK_SIZE* m_iRRVScale));
		}
// ~RRV	
		quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL);
// RRV insertion
		if(m_vopmd.RRVmode.iRRVOnOff == 1)
		{
			UpSamplingTextureForRRV(ppxlcRefMBY, ppxlcRefMBY,
									MB_SIZE, MB_SIZE,
									m_iFrameWidthY);
			UpSamplingTextureForRRV(ppxlcRefMBU, ppxlcRefMBU,
									BLOCK_SIZE, BLOCK_SIZE,
									m_iFrameWidthUV);
			UpSamplingTextureForRRV(ppxlcRefMBV, ppxlcRefMBV,
									BLOCK_SIZE, BLOCK_SIZE,
									m_iFrameWidthUV);
		}
// ~RRV
		codeMBTextureHeadOfPVOP (pmbmd);
		sendDCTCoefOfIntraMBTexture (pmbmd);
	}
	else {
		CoordI xRefUV, yRefUV, xRefUV1, yRefUV1;
// GMC
	   if(pmbmd->m_bMCSEL) {
		FindGlobalChromPredForGMC(x,y,m_ppxlcPredMBU,m_ppxlcPredMBV);
	   }else{
// ~GMC
// RRV modification
		if(m_vopmd.RRVmode.iRRVOnOff == 1)
		{
		    mvLookupUV(pmbmd, pmv_RRV, xRefUV, yRefUV, xRefUV1, yRefUV1);
		}
		else
		{
			mvLookupUV(pmbmd, pmv, xRefUV, yRefUV, xRefUV1, yRefUV1);
		}
//		mvLookupUV (pmbmd, pmv, xRefUV, yRefUV, xRefUV1, yRefUV1);
// ~RRV		
// INTERLACE
		// pmbmd->m_rgTranspStatus[0] = NONE;			// This a rectangular VOP 
		if(pmbmd->m_bFieldMV) {
			motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV,
				m_pvopcRefQ0, x, y, xRefUV, yRefUV, pmbmd->m_bForwardTop,
				&m_rctRefVOPY0); // added by Y.Suzuki for the extended bounding box support
			motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
				m_pvopcRefQ0, x, y, xRefUV1, yRefUV1, pmbmd->m_bForwardBottom,
				&m_rctRefVOPY0); // added by Y.Suzuki for the extended bounding box support
		}
		else 
// ~INTERLACE
			motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
				xRefUV, yRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
// GMC
	   }
// ~GMC
// RRV modification     
		if(m_vopmd.RRVmode.iRRVOnOff == 1)
		{
			motionCompMBYEnc(pmv_RRV, pmbmd, iMBX, iMBY,
							  x, y, &m_rctRefVOPY0);
		}
		else
		{
			motionCompMBYEnc(pmv, pmbmd, iMBX, iMBY, x, y, &m_rctRefVOPY0);
		}
//		motionCompMBYEnc (pmv, pmbmd, iMBX, iMBY, x, y, &m_rctRefVOPY0);
// ~RRV
		computeTextureError ();
// RRV insertion
		if(m_vopmd.RRVmode.iRRVOnOff == 1)
		{
			DownSamplingTextureForRRV(m_ppxliErrorMBY, m_ppxliErrorMBY, 
									  (MB_SIZE *m_iRRVScale),
									  (MB_SIZE *m_iRRVScale));
			DownSamplingTextureForRRV(m_ppxliErrorMBU, m_ppxliErrorMBU,
									  (BLOCK_SIZE *m_iRRVScale),
									  (BLOCK_SIZE *m_iRRVScale));
			DownSamplingTextureForRRV(m_ppxliErrorMBV, m_ppxliErrorMBV,
									  (BLOCK_SIZE *m_iRRVScale),
									  (BLOCK_SIZE *m_iRRVScale));
		}
// ~RRV
		Bool bSkip = pmbmd->m_bhas4MVForward ? (pmv [1].isZero () && pmv [2].isZero () && pmv [3].isZero () && pmv [4].isZero ())
            : (!pmbmd->m_bFieldMV && pmv->isZero());
// GMC
		if(pmbmd -> m_bMCSEL)
			bSkip= TRUE;
// ~GMC
		if(!m_volmd.bAllowSkippedPMBs)
			bSkip = FALSE;

		quantizeTextureInterMB (pmbmd, pmv, NULL, bSkip); // decide COD here
// RRV insertion
		if(m_vopmd.RRVmode.iRRVOnOff == 1)
		{
			UpSamplingTextureForRRV(m_ppxliErrorMBY,m_ppxliErrorMBY,
									MB_SIZE, MB_SIZE, 
									(MB_SIZE *m_iRRVScale));
			UpSamplingTextureForRRV(m_ppxliErrorMBU, m_ppxliErrorMBU,
									BLOCK_SIZE, BLOCK_SIZE,
									BLOCK_SIZE *(m_iRRVScale));
			UpSamplingTextureForRRV(m_ppxliErrorMBV, m_ppxliErrorMBV,
									BLOCK_SIZE, BLOCK_SIZE, 
									BLOCK_SIZE *(m_iRRVScale));
		}
// ~RRV
// GMC
		if((m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE))
			if(pmbmd -> m_bSkip && !pmbmd -> m_bMCSEL)
				pmbmd -> m_bSkip = FALSE;
// ~GMC
		codeMBTextureHeadOfPVOP (pmbmd);
		if (!(pmbmd -> m_bSkip && !pmbmd -> m_bMCSEL)) { // GMC
			if(!(m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3))
// GMC
			   if(!pmbmd -> m_bMCSEL)
// ~GMC
				m_statsMB.nBitsMV += encodeMVVP (pmv, pmbmd, iMBX, iMBY);
// GMC
		   if (pmbmd -> m_bSkip) {
		   	assignPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
		   }else{
// ~GMC
			sendDCTCoefOfInterMBTexture (pmbmd);
			addErrorAndPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
// GMC
		   }
// ~GMC
		}
		else {
			assignPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
		}
	}
}


Void CVideoObjectEncoder::encodeBVOPMB (
	PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
	CMBMode* pmbmd, const CMotionVector* pmv, const CMotionVector* pmvBackward,
	const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
	Int iMBX, Int iMBY,
	CoordI x, CoordI y
)
{
	motionCompAndDiff_BVOP_MB (pmv, pmvBackward, pmbmd, x, y, &m_rctRefVOPY0, &m_rctRefVOPY1);
	Bool bSkip;
	if (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0 &&
	    pmbmd->m_mbType == FORWARD)
		bSkip = (pmv->m_vctTrueHalfPel.x ==0 && pmv->m_vctTrueHalfPel.y == 0);
	else if (pmbmd->m_mbType == DIRECT)
		bSkip = (pmbmd->m_vctDirectDeltaMV.x ==0 && pmbmd->m_vctDirectDeltaMV.y == 0);
	else 
		bSkip = FALSE;
	quantizeTextureInterMB (pmbmd, pmv, NULL, bSkip); // decide COD here; skip not allowed in non-direct mode
	codeMBTextureHeadOfBVOP (pmbmd);
	if (!pmbmd->m_bSkip) {
		m_statsMB.nBitsMV += encodeMVofBVOP (pmv, pmvBackward, pmbmd, iMBX, iMBY, pmvRef, pmbmdRef);
		sendDCTCoefOfInterMBTexture (pmbmd);
		addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
	}
	else
		assignPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
}

// HHI Schueuer: added  const PixelC *ppxlcCurrMBBY, const PixelC *ppxlcCurrMBBUV for sadct
Void CVideoObjectEncoder::encodeBVOPMB_WithShape (
	PixelC* ppxlcCurrQMBY,
  PixelC* ppxlcCurrQMBU,
  PixelC* ppxlcCurrQMBV, 
  PixelC** pppxlcCurrQMBA,
  PixelC* ppxlcCurrQBY,
	CMBMode* pmbmd,
  const CMotionVector* pmv,
  const CMotionVector* pmvBackward, 
	CMotionVector* pmvBY,
  ShapeMode shpmdColocatedMB,
	const CMBMode* pmbmdRef,
  const CMotionVector* pmvRef,
	Int iMBX,
  Int iMBY,
	CoordI x, 
  CoordI y, 
  Int &iQPPrev,
  Int &iQPPrevAlpha,
	Int index,	//OBSS_SAIT_991015 //for OBSS
	const PixelC *ppxlcCurrMBBY,
  const PixelC *ppxlcCurrMBBUV
)
{
	pmbmd->m_stepSize = iQPPrev;

	if(!m_volmd.bNoGrayQuantUpdate)
	{
		iQPPrevAlpha = (iQPPrev * m_vopmd.intStepBAlpha[0]) / m_vopmd.intStepB;
		if(iQPPrevAlpha<1)
			iQPPrevAlpha=1;
	}
	pmbmd->m_stepSizeAlpha = iQPPrevAlpha;
//OBSS_SAIT_991015
	if(!(m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0)) 		
		m_statsMB.nBitsShape += codeInterShape (
			ppxlcCurrQBY, m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
			pmbmd, shpmdColocatedMB, NULL, pmvBY, x, y, iMBX, iMBY);
	 
	else{	//for spatial scalability in shape
		if((m_volmd.volType == BASE_LAYER) || (!(m_volmd.iEnhnType==0 || m_volmd.iuseRefShape ==0) && !m_volmd.bShapeOnly) )
			m_statsMB.nBitsShape += codeInterShape (
				ppxlcCurrQBY, m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
				pmbmd, shpmdColocatedMB, NULL, pmvBY, x, y, iMBX, iMBY);
		else if(m_volmd.volType == ENHN_LAYER){			
			m_statsMB.nBitsShape += codeSIShapeBVOP(		
				ppxlcCurrQBY,
				m_pvopcRefQ0,		//previous VOP
				m_pvopcRefQ1,		//reference layer VOP
				pmbmd, shpmdColocatedMB, NULL, pmvBY, m_rgmvBaseBY+index, x, y, iMBX, iMBY);
		}
	}
//OBSS_SAIT_991015

	downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
	decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // change pmbmd to inter if all transparent
	/*BBM// Added for Boundary by Hyundai(1998-5-9)
	if (m_vopmd.bInterlace) initMergedMode (pmbmd);
	// End of Hyundai(1998-5-9)*/
	if(m_volmd.bShapeOnly==FALSE) {	//OBSS_SAIT_991015	//for shape_only spatial scalability
		if (pmbmd->m_rgTranspStatus [0] != ALL) {
			if (pmbmd->m_rgTranspStatus [0] == PARTIAL)
				motionCompAndDiff_BVOP_MB_WithShape (pmv, pmvBackward, pmbmd, x, y, &m_rctRefVOPY0, &m_rctRefVOPY1);
			else
				motionCompAndDiff_BVOP_MB (pmv, pmvBackward, pmbmd, x, y, &m_rctRefVOPY0, &m_rctRefVOPY1);
			Bool bSkip = FALSE;
		//OBSS_SAIT_991015 //_SONY_SS_  //In the case of Foward && MV=0 for spatial scalable, Skip mode shuld be selected. 
			if (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0 &&
				pmbmd->m_mbType == FORWARD)
				bSkip = (pmv->m_vctTrueHalfPel.x ==0 && pmv->m_vctTrueHalfPel.y == 0);
			else if (pmbmd->m_mbType == DIRECT)	{
				if(pmvRef == NULL)	//just to be safe
					pmbmd->m_vctDirectDeltaMV = pmv->m_vctTrueHalfPel;
				bSkip = (pmbmd->m_vctDirectDeltaMV.x == 0) && (pmbmd->m_vctDirectDeltaMV.y == 0);
			}
		//~OBSS_SAIT_991015
			if(m_volmd.fAUsage == EIGHT_BIT)
				motionCompAndDiffAlpha_BVOP_MB (
					pmv,
					pmvBackward, 
					pmbmd, 
					x, y,
					&m_rctRefVOPY0, &m_rctRefVOPY1
				);
			/*BBM// Added for Boundary by Hyundai(1998-5-9)
			if (m_vopmd.bInterlace && pmbmd -> m_rgTranspStatus [0] == PARTIAL)
							boundaryMacroBlockMerge (pmbmd);
			// End of Hyundai(1998-5-9)*/
			// HHI Schueuer: sadct
			if (!m_volmd.bSadctDisable)
				deriveSADCTRowLengths (m_rgiCurrMBCoeffWidth, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd->m_rgTranspStatus);
			if (!m_volmd.bSadctDisable)
				quantizeTextureInterMB (pmbmd, pmv, pppxlcCurrQMBA, bSkip, ppxlcCurrMBBY, ppxlcCurrMBBUV); // decide COD here; skip not allowed in non-direct mode
			else
				quantizeTextureInterMB (pmbmd, pmv, pppxlcCurrQMBA, bSkip); // decide COD here; skip not allowed in non-direct mode
			// end HHI		
			codeMBTextureHeadOfBVOP (pmbmd);
			if (!pmbmd -> m_bSkip) {
				m_statsMB.nBitsMV += encodeMVofBVOP (pmv, pmvBackward, pmbmd,
					iMBX, iMBY, pmvRef, pmbmdRef);	// need to see the MB type to decide what MV to be sent
				sendDCTCoefOfInterMBTexture (pmbmd);
				//addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV); // delete by Hyundai, ok swinder
			}
			else
				assignPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
			if (m_volmd.fAUsage == EIGHT_BIT) {
        for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
          codeMBAlphaHeadOfBVOP (pmbmd, iAuxComp );
          if (pmbmd -> m_pCODAlpha[iAuxComp] == ALPHA_CODED) {
            sendDCTCoefOfInterMBAlpha (pmbmd, iAuxComp );
          }
          else if(pmbmd -> m_pCODAlpha[iAuxComp] == ALPHA_SKIPPED)
            assignAlphaPredToCurrQ (pppxlcCurrQMBA[iAuxComp],iAuxComp);
        }
			}
			/*BBM// Added for Boundary by Hyundai(1998-5-9)
					if (m_vopmd.bInterlace && pmbmd -> m_bMerged[0])
							mergedMacroBlockSplit (pmbmd);
			// End of Hyundai(1998-5-9)*/
			if (!pmbmd -> m_bSkip)
				addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
      if (m_volmd.fAUsage == EIGHT_BIT) {
        for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
          if (pmbmd -> m_pCODAlpha[iAuxComp] == ALPHA_CODED)
            addAlphaErrorAndPredToCurrQ (pppxlcCurrQMBA[iAuxComp],iAuxComp);
        }
      }
		}
	}		//OBSS_SAIT_991015	//for BSO of OBSS
}

Void CVideoObjectEncoder::codeMBTextureHeadOfIVOP (const CMBMode* pmbmd)
{
	UInt CBPC = (pmbmd->getCodedBlockPattern (U_BLOCK) << 1)
				| pmbmd->getCodedBlockPattern (V_BLOCK);	
														//per defintion of H.263's CBPC 
	assert (CBPC >= 0 && CBPC <= 3);
	Int CBPY = 0;
	UInt cNonTrnspBlk = 0, iBlk;
	for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++) {
		if (pmbmd->m_rgTranspStatus [iBlk] != ALL)	
			cNonTrnspBlk++;
	}
	UInt iBitPos = 1;
	for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++)	{
		if (pmbmd->m_rgTranspStatus [iBlk] != ALL)	{
			CBPY |= pmbmd->getCodedBlockPattern (iBlk) << (cNonTrnspBlk - iBitPos);
			iBitPos++;
		}
	}
	assert (CBPY >= 0 && CBPY <= 15);								//per defintion of H.263's CBPY 

	Int iSymbol = 4 * pmbmd->m_dctMd + CBPC;
	assert (iSymbol >= 0 && iSymbol <= 7);			//send MCBPC
#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace (iSymbol, "MB_MCBPC");