mbenc.cpp

完整的RTP RTSP代码库

		ppxlcCurrMBU += (BLOCK_SIZE *m_iRRVScale);	ppxlcCurrU += iWidthUV;
		ppxlcCurrMBV += (BLOCK_SIZE *m_iRRVScale);	ppxlcCurrV += iWidthUV;
		
		memcpy (ppxlcCurrMBY, ppxlcCurrY,
			(MB_SIZE *sizeof(PixelC) *m_iRRVScale));	// two rows for Y
		ppxlcCurrMBY += (MB_SIZE *m_iRRVScale); ppxlcCurrY += iWidthY;
		//	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));
		//		ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
		//		ppxlcCurrMBU += BLOCK_SIZE; ppxlcCurrU += iWidthUV;
		//		ppxlcCurrMBV += BLOCK_SIZE;	ppxlcCurrV += iWidthUV;
		//
		//		memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC)); // two rows for Y
		//		ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
		// ~RRV
	}
}

// compute error signal

Void CVideoObjectEncoder::computeTextureError ()
{
	CoordI ix;
	// RRV insertion
	Int	iTmp	= (m_iRRVScale *m_iRRVScale);
	// ~RRV
	// Y
	// RRV modification
	for (ix = 0; ix < (MB_SQUARE_SIZE *iTmp); ix++)
		//	for (ix = 0; ix < MB_SQUARE_SIZE; ix++)
		// ~RRV
		m_ppxliErrorMBY [ix] = m_ppxlcCurrMBY [ix] - m_ppxlcPredMBY [ix];
	
	// UV
	// RRV modification
	for (ix = 0; ix < (BLOCK_SQUARE_SIZE *iTmp); ix++) {
		//	for (ix = 0; ix < BLOCK_SQUARE_SIZE; ix++) {
		// ~RRV
		m_ppxliErrorMBU [ix] = m_ppxlcCurrMBU [ix] - m_ppxlcPredMBU [ix];
		m_ppxliErrorMBV [ix] = m_ppxlcCurrMBV [ix] - m_ppxlcPredMBV [ix];
	}
	
	// Alpha
	if(m_volmd.fAUsage==EIGHT_BIT) {
		for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
			
			for (ix = 0; ix < (MB_SQUARE_SIZE *iTmp); ix++)
				m_ppxliErrorMBA[iAuxComp][ix] = m_ppxlcCurrMBA[iAuxComp][ix] - m_ppxlcPredMBA[iAuxComp][ix];
		}
	}
}

Void CVideoObjectEncoder::computeTextureErrorWithShape ()
{
	CoordI ix;
	// Y
	for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
		if (m_ppxlcCurrMBBY [ix] == transpValue)
			m_ppxliErrorMBY [ix] = 0; // zero padding
		else
			m_ppxliErrorMBY [ix] = m_ppxlcCurrMBY [ix] - m_ppxlcPredMBY [ix];
	}
	
	// UV
	for (ix = 0; ix < BLOCK_SQUARE_SIZE; ix++) {
		if (m_ppxlcCurrMBBUV [ix] == transpValue)
			m_ppxliErrorMBU [ix] = m_ppxliErrorMBV [ix] = 0;
		else {
			m_ppxliErrorMBU [ix] = m_ppxlcCurrMBU [ix] - m_ppxlcPredMBU [ix];
			m_ppxliErrorMBV [ix] = m_ppxlcCurrMBV [ix] - m_ppxlcPredMBV [ix];
		}
	}
	
	if(m_volmd.fAUsage==EIGHT_BIT) {
		for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
			for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
				if (m_ppxlcCurrMBBY [ix] == transpValue)
					m_ppxliErrorMBA[iAuxComp] [ix] = 0; // zero padding
				else
					m_ppxliErrorMBA[iAuxComp] [ix] = m_ppxlcCurrMBA[iAuxComp] [ix] - m_ppxlcPredMBA[iAuxComp] [ix];
			}
		}
	}
}

Void CVideoObjectEncoder::computeAlphaError ()
{
	CoordI ix;
	
	for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
		for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
			if (m_ppxlcCurrMBBY [ix] == transpValue)
				m_ppxliErrorMBA[iAuxComp] [ix] = 0; // zero padding
			else
				m_ppxliErrorMBA[iAuxComp] [ix] = m_ppxlcCurrMBA[iAuxComp] [ix] - m_ppxlcPredMBA[iAuxComp] [ix];
		}
	}
}

// HHI Schueuer: added const PixelC *ppxlcCurrMBBY, const PixelC *ppxlcCurrMBBUV for sadct
Void CVideoObjectEncoder::quantizeTextureIntraMB (	
												  Int imbX,
												  Int imbY,
												  CMBMode* pmbmd, 
												  PixelC* ppxlcCurrQMBY,
												  PixelC* ppxlcCurrQMBU,
												  PixelC* ppxlcCurrQMBV,
												  PixelC** pppxlcCurrQMBA,
												  const PixelC *ppxlcCurrMBBY,
												  const PixelC *ppxlcCurrMBBUV
												  )
{
	assert (pmbmd != NULL);
	assert (pmbmd -> m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ);
	assert (pmbmd -> m_rgTranspStatus [0] != ALL);
	
	pmbmd->m_bSkip = FALSE;		// for direct mode reference 
	
	Int iQP = pmbmd->m_stepSize;

#ifdef __TRACE_AND_STATS_
	m_statsMB.nQMB++;
	m_statsMB.nQp += iQP;
#endif // __TRACE_AND_STATS_
	
	Int iDcScalerY, iDcScalerC, iDcScalerA = 0;
	if (iQP <= 4)
	{
		iDcScalerY = 8;
		iDcScalerC = 8;
	}
	else if (iQP >= 5 && iQP <= 8)
	{
		iDcScalerY = 2 * iQP;
		iDcScalerC = (iQP + 13) / 2;
	}
	else if (iQP >= 9 && iQP <= 24)
	{
		iDcScalerY = iQP + 8;
		iDcScalerC = (iQP + 13) / 2;
	}
	else
	{
		iDcScalerY = 2 * iQP - 16;
		iDcScalerC = iQP - 6;
	}
	
	Int iQPA = 0;
	
	Int iAuxComp;
	for(iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) // MAC (SB) 29-Nov-99
		pmbmd->m_pCODAlpha[iAuxComp] = ALPHA_CODED;
	
	if(m_volmd.fAUsage == EIGHT_BIT)
	{
		iQPA = pmbmd->m_stepSizeAlpha;
		
		if (iQPA <= 4)
			iDcScalerA = 8;
		else if (iQPA >= 5 && iQPA <= 8)
			iDcScalerA = 2 * iQPA;
		else if (iQPA >= 9 && iQPA <= 24)
			iDcScalerA = iQPA + 8;
		else
			iDcScalerA = 2 * iQPA - 16;
		
		if(pmbmd->m_rgTranspStatus [0] == NONE)
		{
			// need to test gray alpha vals
			// CODA = 1 if all==255, can't use TranspStatus, has to be 255
			Int i;
			Int iThresh = 256 - iQPA;
			
			Int iAuxComp;
			for(iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 29-Nov-99
				
				pmbmd->m_pCODAlpha[iAuxComp] = ALPHA_ALL255;
				for(i = 0; i<MB_SQUARE_SIZE; i++) {
					if(m_ppxlcCurrMBA[iAuxComp][i]<=iThresh)
					{
						pmbmd->m_pCODAlpha[iAuxComp] = ALPHA_CODED;
						break;
					}
				}
				if(pmbmd->m_pCODAlpha[iAuxComp] == ALPHA_ALL255)
				{
					pxlcmemset(m_ppxlcCurrMBA[iAuxComp], 255, MB_SQUARE_SIZE);
					PixelC *ppxlc = pppxlcCurrQMBA[iAuxComp];
					for(i = 0; i<MB_SIZE; i++, ppxlc += m_iFrameWidthY)
						pxlcmemset(ppxlc, 255, MB_SIZE);
				}        
			}
		}	
	}
	
	Int iCoefToStart;
	if(pmbmd->m_bCodeDcAsAc)
		iCoefToStart = 0;
	else
		iCoefToStart = 1;

	//for intra pred
	MacroBlockMemory* pmbmLeft = NULL;
	MacroBlockMemory* pmbmTop = NULL;
	MacroBlockMemory* pmbmLeftTop = NULL;
	CMBMode* pmbmdLeft = NULL;
	CMBMode* pmbmdTop = NULL;
	CMBMode* pmbmdLeftTop = NULL;											 
	Int iMBnum = imbY * m_iNumMBX + imbX;
	if (!bVPNoTop(iMBnum))	{
		pmbmTop  = m_rgpmbmAbove [imbX];
		pmbmdTop = pmbmd - m_iNumMBX;
	}
	if (!bVPNoLeft(iMBnum, imbX))	{
		pmbmLeft  = m_rgpmbmCurr [imbX - 1];
		pmbmdLeft = pmbmd -  1;
	}
	if (!bVPNoLeftTop(iMBnum, imbX))	{
		pmbmLeftTop  = m_rgpmbmAbove [imbX - 1];
		pmbmdLeftTop = pmbmd - m_iNumMBX - 1;
	}
	
	// INTERLACE
	if((pmbmd->m_rgTranspStatus [0] == NONE)&&(m_vopmd.bInterlace == TRUE) ) {
		pmbmd->m_bFieldDCT = FrameFieldDCTDecideC(m_ppxlcCurrMBY);
		m_statsMB.nFieldDCTMB += (Int) pmbmd->m_bFieldDCT;
	}
	else
		pmbmd->m_bFieldDCT = 0;
	
	// ~INTERLACE
	
	PixelC* rgchBlkDst = NULL;
	PixelC* rgchBlkSrc = NULL;
	Int iWidthDst, iWidthSrc;
	Int iDcScaler;
	Int* rgiCoefQ;
	Int iSumErr = 0; //sum of error to determine intra ac prediction
	Int iBlk;
	//	Int iBlkEnd;
	//	if(m_volmd.fAUsage == EIGHT_BIT)
	//		iBlkEnd = A_BLOCK4;
	//	else
	//		iBlkEnd = V_BLOCK;
	
	// HHI Schueuer: for sadct, see also the cond. assignments inside the next switch stmt.
	const PixelC* rgchBlkShape = NULL;
	// end
	
	for (iBlk = (Int) Y_BLOCK1; iBlk <= (Int)pmbmd->blkEnd(); iBlk++) { // + 1 is because of the indexing
		if (iBlk < (Int) U_BLOCK || iBlk > (Int) V_BLOCK) {
			if(iBlk>=A_BLOCK1 && ((iBlk-7)%4)==0)
				iSumErr = 0; // start again for alpha planes
			if (iBlk>=A_BLOCK1 && pmbmd->m_rgTranspStatus [((iBlk-7)%4)+1] == ALL)
				continue;
			else if (iBlk<A_BLOCK1 && pmbmd -> m_rgTranspStatus [iBlk % 6] == ALL) // %6 hack!!
				continue;
			
			
			switch (iBlk) 
			{
			case (Y_BLOCK1): 
				rgchBlkDst = ppxlcCurrQMBY;
				rgchBlkSrc = m_ppxlcCurrMBY;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY : NULL;
				break;
			case (Y_BLOCK2): 
				rgchBlkDst = ppxlcCurrQMBY + BLOCK_SIZE;
				rgchBlkSrc = m_ppxlcCurrMBY + BLOCK_SIZE;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE : NULL;
				break;
			case (Y_BLOCK3): 
				// RRV modification
				rgchBlkDst = ppxlcCurrQMBY + (m_iFrameWidthYxBlkSize /m_iRRVScale);
				//				rgchBlkDst = ppxlcCurrQMBY + m_iFrameWidthYxBlkSize;
				// ~RRV
				rgchBlkSrc = m_ppxlcCurrMBY + MB_SIZE * BLOCK_SIZE;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE : NULL;
				break;
			case (Y_BLOCK4): 
				// RRV modification
				rgchBlkDst = ppxlcCurrQMBY + (m_iFrameWidthYxBlkSize /m_iRRVScale) + BLOCK_SIZE;
				//				rgchBlkDst = ppxlcCurrQMBY + m_iFrameWidthYxBlkSize + BLOCK_SIZE;
				// ~RRV
				rgchBlkSrc = m_ppxlcCurrMBY + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE + BLOCK_SIZE : NULL;
				break;
			}
			
			// MAC (SB) 29-Nov-99
			if (iBlk>=A_BLOCK1) { // alpha blocks
				Int iABlk = ((iBlk-7)&0x3);
				iAuxComp = (iBlk-7)/4;
				iABlk++;
				
				rgchBlkDst = pppxlcCurrQMBA[iAuxComp];
				rgchBlkSrc = m_ppxlcCurrMBA[iAuxComp];
				
				switch (iABlk) {
				case 1: rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[1] == PARTIAL) ? ppxlcCurrMBBY : NULL;
					break;
				case 2: rgchBlkDst += BLOCK_SIZE;
					rgchBlkSrc += BLOCK_SIZE;
					rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[2] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE : NULL;        
					break;
				case 3: rgchBlkDst += m_iFrameWidthYxBlkSize;
					rgchBlkSrc += MB_SIZE * BLOCK_SIZE;
					rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[3] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE : NULL;
					break;
				case 4: rgchBlkDst += m_iFrameWidthYxBlkSize + BLOCK_SIZE;
					rgchBlkSrc += MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
					rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[4] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE + BLOCK_SIZE : NULL;
					break;
				}
			}
			//~MAC
			
			iWidthDst = m_iFrameWidthY;
			iWidthSrc = MB_SIZE;
			if(iBlk<=V_BLOCK)
				iDcScaler = iDcScalerY;
			else
				iDcScaler = iDcScalerA;
		}
		else {
			iWidthDst = m_iFrameWidthUV;
			iWidthSrc = BLOCK_SIZE;
			rgchBlkDst = (iBlk == U_BLOCK) ? ppxlcCurrQMBU: ppxlcCurrQMBV;
			rgchBlkSrc = (iBlk == U_BLOCK) ? m_ppxlcCurrMBU: m_ppxlcCurrMBV;
			// HHI: for sadct
			rgchBlkShape = (ppxlcCurrMBBUV && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBUV : NULL;
			iDcScaler = iDcScalerC;
		}
		
		if (m_volmd.nBits<=8) { // NBIT: not always valid when nBits>8
			assert(iDcScaler > 0 && iDcScaler < 128);
		}
		
		rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
		iSumErr += quantizeIntraBlockTexture (
			rgchBlkSrc,
			iWidthSrc,
			rgchBlkDst,
			iWidthDst,
			rgiCoefQ, 
			(iBlk<=V_BLOCK ? iQP : iQPA), 
			iDcScaler,
			iBlk,	//from here til last
			pmbmLeft, 
			pmbmTop, 
			pmbmLeftTop, 
			m_rgpmbmCurr [imbX],
			pmbmdLeft, 
			pmbmdTop, 
			pmbmdLeftTop, 
			pmbmd,
			rgchBlkShape, ((iBlk<U_BLOCK) || (iBlk > V_BLOCK)) ? MB_SIZE : BLOCK_SIZE,	// HHI
			iAuxComp
			); //all for intra-pred
		if(iBlk>=A_BLOCK1)
			pmbmd->m_pbACPredictionAlpha[iAuxComp]	= (pmbmd->m_pCODAlpha[iAuxComp] == ALPHA_CODED && iSumErr >= 0);
		else
			pmbmd->m_bACPrediction =(iSumErr >= 0);
	}
	
	// INTERLACE
	if ((pmbmd->m_rgTranspStatus [0] == NONE) && (m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
		fieldDCTtoFrameC(ppxlcCurrQMBY);
	// ~INTERLACE
	
	for (iBlk = (UInt) Y_BLOCK1; iBlk <= (Int)pmbmd->blkEnd(); iBlk++) { // + 1 is because of the indexing
		Int iBlkMap;
		if (iBlk>=A_BLOCK1) // alpha blocks
			iBlkMap = ((iBlk-7)&0x3)+1;
		else
			iBlkMap = iBlk;
		if (pmbmd->m_rgTranspStatus [iBlkMap % 6] == ALL) { // hack %6 ok if [6]==[0]
			pmbmd->setCodedBlockPattern (iBlk, FALSE);
			continue;
		}
		rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
		if (iBlk < (Int) U_BLOCK) 
			iDcScaler = iDcScalerY; //m_rgiDcScalerY [iQP];
		else if(iBlk < (Int) A_BLOCK1)
			iDcScaler = iDcScalerC; //m_rgiDcScalerC [iQP];
		else
			iDcScaler = iDcScalerA;
		
		intraPred ( iBlk, pmbmd, rgiCoefQ,
			(iBlk<=V_BLOCK ? iQP : iQPA), iDcScaler, m_rgblkmCurrMB [iBlk - 1],
			m_rgiQPpred [iBlk - 1]);
		Bool bCoded = FALSE;
		UInt i;