mbenc.cpp

完整的RTP RTSP代码库

{
	// 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, pbRestart);
			if (!pmbmd -> m_bSkip) {
				sendDCTCoefOfInterMBTexture (pmbmd);
				addErrorAndPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
			}
		}
		else {
			pmbmd -> m_bSkip = TRUE;
			codeMBTextureHeadOfPVOP (pmbmd, pbRestart);
		}

		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	
		// vlc mode needs to be set up provisionally before quantisation
		// to ensure that the correct cbp is generated if using ac coefs
		// however codembtextureheadofpvop also calls the function, so we
		// save the restart value to avoid problems on the second call
		Bool bTemp = *pbRestart;
		setDCVLCMode(pmbmd, pbRestart);
		*pbRestart = bTemp;
		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, pbRestart);
		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

		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);
		}

		computeTextureError ();

		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));
		}

		Bool bSkip = pmbmd->m_bhas4MVForward ? (pmv [1].isZero () && pmv [2].isZero () && pmv [3].isZero () && pmv [4].isZero ())
            : (!pmbmd->m_bFieldMV && pmv->isZero());

		if(pmbmd -> m_bMCSEL)
			bSkip= TRUE;

		if(!m_volmd.bAllowSkippedPMBs)
			bSkip = FALSE;
		
		quantizeTextureInterMB (pmbmd, pmv, NULL, bSkip); // decide COD here

		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));
		}

		if((m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE))
			if(pmbmd -> m_bSkip && !pmbmd -> m_bMCSEL)
				pmbmd -> m_bSkip = FALSE;

		codeMBTextureHeadOfPVOP (pmbmd, pbRestart);
		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 index,	//OBSS_SAIT_991015 //for OBSS
												  const PixelC *ppxlcCurrMBBY,
												  const PixelC *ppxlcCurrMBBUV
												  )
{
	//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
	
	//Changed HHI 2000-04-11
	decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // change pmbmd to inter if all transparent
	downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd);

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

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

			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);
				}
			}
		}
		else
			// all transparent case
			cancelQPUpdate(pmbmd);

	}		//OBSS_SAIT_991015	//for BSO of OBSS
}

Void CVideoObjectEncoder::codeMBTextureHeadOfIVOP (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");
#endif // __TRACE_AND_STATS_
	m_statsMB.nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCintra->encodeSymbol (iSymbol, "MB_MCBPC");
	//fprintf(stderr,"MCBPC = %d\n",iSymbol);
	
	m_pbitstrmOut->putBits (pmbmd->m_bACPrediction, 1, "MB_ACPRED");
	m_statsMB.nBitsIntraPred++;
	//fprintf(stderr,"ACPred = %d\n",pmbmd->m_bACPrediction);
	
#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut->trace (cNonTrnspBlk, "MB_NumNonTranspBlks");
	m_pbitstrmOut->trace (CBPY, "MB_CBPY (I-style)");
#endif // __TRACE_AND_STATS_
	switch (cNonTrnspBlk) {
	case 1:
		m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (CBPY, "MB_CBPY");
		break;
	case 2:
		m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (CBPY, "MB_CBPY");
		break;
	case 3:
		m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (CBPY, "MB_CBPY");
		break;
	case 4:
		m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (CBPY, "MB_CBPY");
		break;
	default:
		assert (FALSE);
	}
	//fprintf(stderr,"CBPY = %d\n",CBPY);
	m_statsMB.nIntraMB++;
	if (pmbmd->m_dctMd == INTRAQ)	{
		Int DQUANT = pmbmd->m_intStepDelta;			//send DQUANT
		assert (DQUANT >= -2 && DQUANT <= 2);
		if (DQUANT != 0)	{	
			if (sign (DQUANT) == 1)
				m_pbitstrmOut->putBits (DQUANT + 1, 2, "MB_DQUANT");
			else
				m_pbitstrmOut->putBits (-1 - DQUANT, 2, "MB_DQUANT");
			m_statsMB.nBitsDQUANT += 2;