mbenc.cpp

完整的RTP RTSP代码库

		}
	}
	// INTERLACE
	if(m_vopmd.bInterlace==TRUE) {
		m_pbitstrmOut->putBits (pmbmd->m_bFieldDCT, 1, "DCT_TYPE"); // send dct_type
		m_statsMB.nBitsInterlace += 1;
	}
	// ~INTERLACE
}

Void CVideoObjectEncoder::codeMBTextureHeadOfPVOP (CMBMode* pmbmd, Bool *pbRestart)
{
	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 
	m_pbitstrmOut->putBits (pmbmd->m_bSkip, 1, "MB_Skip");
	m_statsMB.nBitsCOD++;

	if (pmbmd->m_bSkip)
	{
		// prevent delta qp from being used
		cancelQPUpdate(pmbmd);
		
		m_statsMB.nSkipMB++;
		// GMC
		if((m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE))
			m_statsMB.nMCSELMB++;
		// ~GMC
	}
	else {
#ifdef __TRACE_AND_STATS_
	m_statsMB.nQMB++;
	m_statsMB.nQp += pmbmd->m_stepSize;
#endif // __TRACE_AND_STATS_

		Int iMBtype;								//per H.263's MBtype
		if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)
			iMBtype = pmbmd->m_dctMd + 3;
		else
			iMBtype = (pmbmd -> m_dctMd - 2) | pmbmd -> m_bhas4MVForward << 1;
		assert (iMBtype >= 0 && iMBtype <= 4);
#ifdef __TRACE_AND_STATS_
		m_pbitstrmOut->trace (iMBtype, "MB_MBtype");
		m_pbitstrmOut->trace (CBPC, "MB_CBPC");
#endif // __TRACE_AND_STATS_
		m_statsMB.nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCinter->encodeSymbol (iMBtype * 4 + CBPC, "MCBPC");
		// GMC
		if((pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) && (pmbmd -> m_bhas4MVForward == FALSE) && (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE))
		{
			m_pbitstrmOut->putBits (pmbmd->m_bMCSEL, 1, "MCSEL");
			m_statsMB.nBitsMCSEL++;
		}
		// ~GMC
		if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)	{
			m_pbitstrmOut->putBits (pmbmd->m_bACPrediction, 1, "MB_ACPRED");
			m_statsMB.nBitsIntraPred++;
#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);
			}
			m_statsMB.nIntraMB++;
		}
		else {
#ifdef __TRACE_AND_STATS_
			m_pbitstrmOut->trace (cNonTrnspBlk, "MB_NumNonTranspBlks");
			m_pbitstrmOut->trace (CBPY, "MB_CBPY (P-style)");
#endif // __TRACE_AND_STATS_
			switch (cNonTrnspBlk) {
			case 1:
				m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (1 - CBPY, "MB_CBPY");
				break;
			case 2:
				m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (3 - CBPY, "MB_CBPY");
				break;
			case 3:
				m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (7 - CBPY, "MB_CBPY");
				break;
			case 4:
				m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (15 - CBPY, "MB_CBPY");
				break;
			default:
				assert (FALSE);
			}
			if(pmbmd ->m_bhas4MVForward)
				m_statsMB.nInter4VMB++;
			// INTERLACE
			else if (pmbmd-> m_bFieldMV)
				m_statsMB.nFieldForwardMB++;
			// ~INTERLACE
			// GMC
			else if (pmbmd-> m_bMCSEL)
				m_statsMB.nMCSELMB++;
			// ~GMC
			else
				m_statsMB.nInterMB++;
		}
		if (pmbmd->m_dctMd == INTERQ || 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;
			}
		}
		// INTERLACE
		if (m_vopmd.bInterlace == TRUE) {
			if((pmbmd->m_dctMd == INTRA) || (pmbmd->m_dctMd == INTRAQ) || (CBPC || CBPY)) {
				m_pbitstrmOut->putBits (pmbmd->m_bFieldDCT, 1, "DCT_Type");
				m_statsMB.nBitsInterlace += 1;
			}
			if((pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ )&&(pmbmd -> m_bhas4MVForward == FALSE)&&(pmbmd -> m_bMCSEL==FALSE)) { // GMC
				m_pbitstrmOut->putBits (pmbmd->m_bFieldMV, 1, "Field_Prediction");
				m_statsMB.nBitsInterlace += 1;
				if(pmbmd->m_bFieldMV) {
					m_pbitstrmOut->putBits (pmbmd->m_bForwardTop, 1, "Forward_Top_Field_Ref");
					m_pbitstrmOut->putBits (pmbmd->m_bForwardBottom, 1, "Forward_Bot_Field_Ref");
					m_statsMB.nBitsInterlace += 2;
				}
			}
		}
		// ~INTERLACE	
	}

	setDCVLCMode(pmbmd, pbRestart);
}

Void CVideoObjectEncoder::codeMBTextureHeadOfBVOP (CMBMode* pmbmd)
{
	U8 uchCBPB = 0;
	if (pmbmd->m_bSkip) {
		if (m_volmd.volType == BASE_LAYER)	{
			assert (pmbmd -> m_rgTranspStatus [0] != ALL);
			if (pmbmd->m_bColocatedMBSkip && !(pmbmd->m_bColocatedMBMCSEL)) // GMC
			{
				cancelQPUpdate(pmbmd);
				return;
			}
		}
		m_pbitstrmOut->putBits (1, 1, "MB_MODB");
		m_statsMB.nBitsMODB++;
		m_statsMB.nSkipMB++;
		if(m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0)
		{
			cancelQPUpdate(pmbmd);
			return;
		}
	}
	else {
		Int iCBPC = (pmbmd->getCodedBlockPattern (U_BLOCK) << 1) | 
			pmbmd->getCodedBlockPattern (V_BLOCK);			//per defintion of H.263's CBPC 														
		assert (iCBPC >= 0 && iCBPC <= 3);
		Int iCBPY = 0;
		Int iNumNonTrnspBlk = 0, iBlk;
		for (iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++) 
			iNumNonTrnspBlk += (pmbmd->m_rgTranspStatus [iBlk] != ALL);
		Int iBitPos = 1;
		for (iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++)	{
			if (pmbmd->m_rgTranspStatus [iBlk] != ALL)	{
				iCBPY |= pmbmd->getCodedBlockPattern (iBlk) << (iNumNonTrnspBlk - iBitPos);
				iBitPos++;
			}
		}
		assert (iCBPY >= 0 && iCBPY <= 15);								//per defintion of H.263's CBPY 
		uchCBPB = (iCBPY << 2 | iCBPC) & 0x3F;
		
		if (uchCBPB == 0)	{
			m_pbitstrmOut->putBits (1, 2, "MB_MODB");
			m_statsMB.nBitsMODB += 2;
			if (m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode != 0))
				m_statsMB.nBitsMBTYPE += m_pentrencSet->m_pentrencMbTypeBVOP->encodeSymbol (pmbmd->m_mbType, "MB_TYPE");
			else {
				Int iMbtypeBits =0;
				if(pmbmd->m_mbType == FORWARD)			iMbtypeBits = 1;
				else if(pmbmd->m_mbType == INTERPOLATE)	iMbtypeBits = 2;
				else if(pmbmd->m_mbType == BACKWARD)	iMbtypeBits = 3;
				Int iMbtypeValue = 1;
				m_statsMB.nBitsMBTYPE += iMbtypeBits;
				m_pbitstrmOut->putBits (iMbtypeValue, iMbtypeBits, "MB_TYPE");				
			}
		}
		else	{
			m_pbitstrmOut->putBits (0, 2,"MB_MODB");
			m_statsMB.nBitsMODB += 2;
			//m_stat.nBitsMBTYPE += m_pentrencMbTypeBVOP->encodeSymbol (pmbmd->m_mbType, "MB_TYPE");
			if (m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode != 0))
				m_statsMB.nBitsMBTYPE += m_pentrencSet->m_pentrencMbTypeBVOP->encodeSymbol (pmbmd->m_mbType, "MB_TYPE");
			else {
				Int iMbtypeBits =0;
				if(pmbmd->m_mbType == FORWARD)			iMbtypeBits = 1;
				else if(pmbmd->m_mbType == INTERPOLATE)	iMbtypeBits = 2;
				else if(pmbmd->m_mbType == BACKWARD)	iMbtypeBits = 3;
				Int iMbtypeValue = 1;
				m_statsMB.nBitsMBTYPE += iMbtypeBits;
				m_pbitstrmOut->putBits (iMbtypeValue, iMbtypeBits, "MB_TYPE");
			}
			m_pbitstrmOut -> putBits (uchCBPB, iNumNonTrnspBlk + 2, "MB_CBPB");
			m_statsMB.nBitsCBPB += iNumNonTrnspBlk + 2;
		}	
		switch (pmbmd->m_mbType) {
		case FORWARD:
			m_statsMB.nForwardMB++;
			break;
		case BACKWARD:
			m_statsMB.nBackwardMB++;
			break;
		case DIRECT:
			m_statsMB.nDirectMB++;
			break;
		case INTERPOLATE:
			m_statsMB.nInterpolateMB++;
			break;
		default:
			assert (FALSE);
		}
	}
	if (pmbmd->m_mbType != DIRECT)	{
		if (uchCBPB != 0)		{	//no need to send when MODB = 10
#ifdef __TRACE_AND_STATS_
	m_statsMB.nQMB++;
	m_statsMB.nQp += pmbmd->m_stepSize;
#endif // __TRACE_AND_STATS_
			Int DQUANT = pmbmd->m_intStepDelta;			//send DQUANT
			assert (DQUANT == -2 || DQUANT == 2 || DQUANT == 0);
			if (DQUANT == 0)	{
				m_pbitstrmOut->putBits ((Int) 0, (UInt) 1, "MB_DQUANT");
				m_statsMB.nBitsDQUANT += 1;
			}
			else {
				if (DQUANT == 2)	
					m_pbitstrmOut->putBits (3, 2, "MB_DQUANT");
				else 
					m_pbitstrmOut->putBits (2, 2, "MB_DQUANT");
				m_statsMB.nBitsDQUANT += 2;
			}
		}
		else
			cancelQPUpdate(pmbmd);
	}
	else
		cancelQPUpdate(pmbmd);

	// INTERLACE
	if (pmbmd->m_bSkip) {
		if (m_vopmd.bInterlace && (pmbmd->m_mbType == DIRECT) && pmbmd->m_bFieldMV)
			m_statsMB.nFieldDirectMB++;
	} else if (m_vopmd.bInterlace) {
		if (uchCBPB) {
			m_pbitstrmOut->putBits((Int) pmbmd->m_bFieldDCT, 1, "DCT_TYPE");
			m_statsMB.nBitsInterlace++;
		}
		if (pmbmd->m_bFieldMV) {
			switch (pmbmd->m_mbType) {
				
			case FORWARD:
				m_pbitstrmOut->putBits(1, 1, "FIELD_PREDICTION");
				m_pbitstrmOut->putBits((Int)pmbmd->m_bForwardTop,    1, "FORWARD_TOP_FIELD_REFERENCE");
				m_pbitstrmOut->putBits((Int)pmbmd->m_bForwardBottom, 1, "FORWARD_BOTTOM_FIELD_REFERENCE");
				m_statsMB.nFieldForwardMB++;
				m_statsMB.nBitsInterlace += 3;
				break;
				
			case BACKWARD:
				m_pbitstrmOut->putBits(1, 1, "FIELD_PREDICTION");
				m_pbitstrmOut->putBits((Int)pmbmd->m_bBackwardTop,    1, "BACKWARD_TOP_FIELD_REFERENCE");
				m_pbitstrmOut->putBits((Int)pmbmd->m_bBackwardBottom, 1, "BACKWARD_BOTTOM_FIELD_REFERENCE");
				m_statsMB.nFieldBackwardMB++;
				m_statsMB.nBitsInterlace += 3;
				break;
				
			case INTERPOLATE:
				m_pbitstrmOut->putBits(1, 1, "FIELD_PREDICTION");
				m_pbitstrmOut->putBits((Int)pmbmd->m_bForwardTop,     1, "FORWARD_TOP_FIELD_REFERENCE");
				m_pbitstrmOut->putBits((Int)pmbmd->m_bForwardBottom,  1, "FORWARD_BOTTOM_FIELD_REFERENCE");
				m_pbitstrmOut->putBits((Int)pmbmd->m_bBackwardTop,    1, "BACKWARD_TOP_FIELD_REFERENCE");
				m_pbitstrmOut->putBits((Int)pmbmd->m_bBackwardBottom, 1, "BACKWARD_BOTTOM_FIELD_REFERENCE");
				m_statsMB.nFieldInterpolateMB++;
				m_statsMB.nBitsInterlace += 5;
				break;
				
			case DIRECT:
				m_statsMB.nFieldDirectMB++;
				break;
			}
		} else if (pmbmd->m_mbType != DIRECT) {
			m_pbitstrmOut->putBits(0, 1, "FIELD_PREDICTION");
			m_statsMB.nBitsInterlace++;
		}
	}
	// ~INTERLACE
}

Void CVideoObjectEncoder::copyToCurrBuffWithShape (
												   const PixelC* ppxlcCurrY, const PixelC* ppxlcCurrU, const PixelC* ppxlcCurrV,
												   const PixelC* ppxlcCurrBY, const PixelC** pppxlcCurrA,
												   Int iWidthY, Int iWidthUV
												   )
{
	PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
	PixelC* ppxlcCurrMBU = m_ppxlcCurrMBU;
	PixelC* ppxlcCurrMBV = m_ppxlcCurrMBV;
	PixelC* ppxlcCurrMBBY = m_ppxlcCurrMBBY;
	Int ic;
	for (ic = 0; ic < BLOCK_SIZE; ic++) {
		memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC)); 
		memcpy (ppxlcCurrMBU, ppxlcCurrU, BLOCK_SIZE*sizeof(PixelC));
		memcpy (ppxlcCurrMBV, ppxlcCurrV, BLOCK_SIZE*sizeof(PixelC));
		memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
		ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
		ppxlcCurrMBU += BLOCK_SIZE; ppxlcCurrU += iWidthUV;
		ppxlcCurrMBV += BLOCK_SIZE;	ppxlcCurrV += iWidthUV;
		ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
		
		memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC)); // two rows for Y
		memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
		ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
		ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
	}
	if (m_volmd.fAUsage == EIGHT_BIT) {
		for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
			PixelC* ppxlcCurrMBA = m_ppxlcCurrMBA[iAuxComp];
			const PixelC* ppxlcCurrA   = pppxlcCurrA[iAuxComp];
			for (ic = 0; ic < MB_SIZE; ic++) {
				memcpy (ppxlcCurrMBA, ppxlcCurrA, MB_SIZE*sizeof(PixelC));
				ppxlcCurrMBA += MB_SIZE; 
				ppxlcCurrA += iWidthY;
			}
		}
	}
}

Void CVideoObjectEncoder::copyToCurrBuffJustShape(const PixelC* ppxlcCurrBY,
												  Int iWidthY)
{
	PixelC* ppxlcCurrMBBY = m_ppxlcCurrMBBY;
	Int ic;
	for (ic = 0; ic < BLOCK_SIZE; ic++) {
		memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
		ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
		memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
		ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
	}
}

Void CVideoObjectEncoder::copyToCurrBuff (
										  const PixelC* ppxlcCurrY, const PixelC* ppxlcCurrU, const PixelC* ppxlcCurrV,
										  Int iWidthY, Int iWidthUV
										  )
{
	PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
	PixelC* ppxlcCurrMBU = m_ppxlcCurrMBU;
	PixelC* ppxlcCurrMBV = m_ppxlcCurrMBV;
	Int ic;
	// RRV modification
	for (ic = 0; ic < (BLOCK_SIZE *m_iRRVScale); ic++) {
		memcpy (ppxlcCurrMBY, ppxlcCurrY,
			(MB_SIZE *sizeof(PixelC) *m_iRRVScale));
		memcpy (ppxlcCurrMBU, ppxlcCurrU,
			(BLOCK_SIZE *sizeof(PixelC) *m_iRRVScale));
		memcpy (ppxlcCurrMBV, ppxlcCurrV,
			(BLOCK_SIZE* sizeof(PixelC) *m_iRRVScale));
		ppxlcCurrMBY += (MB_SIZE *m_iRRVScale);		ppxlcCurrY += iWidthY;