mbenc.cpp

网络MPEG4IP流媒体开发源代码

		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) {
			codeMBAlphaHeadOfBVOP (pmbmd);
			if (pmbmd -> m_CODAlpha == ALPHA_CODED) {
				sendDCTCoefOfInterMBAlpha (pmbmd);
				//addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA); // delete by Hyundai, ok swinder
			}
			else if(pmbmd -> m_CODAlpha == ALPHA_SKIPPED)
				assignAlphaPredToCurrQ (ppxlcCurrQMBA);
		}
		/*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 && pmbmd -> m_CODAlpha == ALPHA_CODED)
		    addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA);
	}
}

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 ((BlockNum) 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;
		}
	}
// 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 (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 ((BlockNum) 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)
		m_statsMB.nSkipMB++;
	else {
		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");
		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
			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)) {
				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	
	}
}

Void CVideoObjectEncoder::codeMBTextureHeadOfBVOP (const 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)
				return;
		}
		m_pbitstrmOut->putBits (1, 1, "MB_MODB");
		m_statsMB.nBitsMODB++;
		m_statsMB.nSkipMB++;
		if(m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0)
			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 ((BlockNum) 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
			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;
			}
		}
	}
// 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* ppxlcCurrA,
	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) {
		PixelC* ppxlcCurrMBA = m_ppxlcCurrMBA;
		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
)