mbenc.cpp

完整的RTP RTSP代码库

		if(iBlk >=(Int) A_BLOCK1)
			iCoefToStart = pmbmd->m_bCodeDcAsAcAlpha==TRUE ? 0 : 1;
		
		for (i = iCoefToStart; i < BLOCK_SQUARE_SIZE; i++) {
			if (rgiCoefQ [i] != 0)	{
				bCoded = TRUE;
				break;
			}
		}
		pmbmd->setCodedBlockPattern ( iBlk, bCoded);
	}
}

// HHI Schueuer: added const PixelC *ppxlcCurrMBBY, const PixelC *ppxlcCurrMBBUV 
Void CVideoObjectEncoder::quantizeTextureInterMB (CMBMode* pmbmd, 
                                                  const CMotionVector* pmv, 
                                                  PixelC **pppxlcCurrQMBA,
                                                  Bool bSkip,
                                                  const PixelC *ppxlcCurrMBBY,
                                                  const PixelC *ppxlcCurrMBBUV)	//bSkip: tested mv is zero
{
	// in case of qp changes, the dct is done with the new qp, and if the status is skip
	// then we keep this as a skip mb, but do not actually use the new qp, since it cannot
	// be sent - swinder
	assert (pmbmd != NULL);
	assert (pmbmd -> m_dctMd == INTER || pmbmd -> m_dctMd == INTERQ);
	assert (pmbmd->m_rgTranspStatus [0] != ALL);
	Int iQP = pmbmd->m_stepSize; // new (including dquant)
	
	if ((pmbmd->m_rgTranspStatus [0] == NONE) && (m_vopmd.bInterlace == TRUE)) {
		pmbmd->m_bFieldDCT = FrameFieldDCTDecideI(m_ppxliErrorMBY);
		m_statsMB.nFieldDCTMB += (Int) pmbmd->m_bFieldDCT;
	}
	else
		pmbmd->m_bFieldDCT = 0;
	Bool bMBCoded = FALSE;
	
	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;
		Int i, iThresh = 256 - iQPA;
		
		for(Int 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;
				}
			}
		}
	}
	
	// Bool bSkip = pmbmd->m_bhas4MVForward ? (bSkipAllowed && pmv [1].isZero () && pmv [2].isZero () && pmv [3].isZero () && pmv [4].isZero ())
	//										 : bSkipAllowed && pmv->isZero ();
	// the above is actually already passed into this function
	Int* rgiBlkCurrQ = m_ppxliErrorMBY;
	Int* rgiCoefQ;
	Int iWidthCurrQ;
	
	Bool* pbSkipAlpha = new Bool [m_volmd.iAuxCompCount];
	for(; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ )
		pbSkipAlpha[iAuxComp] = TRUE;
	
	// HHI Schueuer: sadct
	const PixelC* rgchBlkShape = NULL;
	// end HHI
	
	Bool bAlphaQPReset = FALSE;
	Bool bCBPY = FALSE;
	for (UInt iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) pmbmd->blkEnd(); iBlk++) { 
		if (iBlk < (UInt) U_BLOCK || iBlk> (UInt) V_BLOCK) {
			
			if (iBlk>=A_BLOCK1 && pmbmd->m_rgTranspStatus [((iBlk-7)%4)+1] == ALL) // MAC patch
				continue;
			else if (iBlk<A_BLOCK1 && pmbmd -> m_rgTranspStatus [iBlk % 6] == ALL) // %6 hack!!
				continue;
			
			switch (iBlk) 
			{
			case (Y_BLOCK1): 
				rgiBlkCurrQ = m_ppxliErrorMBY;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY : NULL;
				break;
			case (Y_BLOCK2): 
				rgiBlkCurrQ = m_ppxliErrorMBY + BLOCK_SIZE;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE: NULL;
				break;
			case (Y_BLOCK3): 
				rgiBlkCurrQ = m_ppxliErrorMBY + MB_SIZE * BLOCK_SIZE;
				rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE : NULL;
				break;
			case (Y_BLOCK4): 
				rgiBlkCurrQ = m_ppxliErrorMBY + 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) {
				Int iBlkA = (iBlk-7)&0x3;
				iAuxComp  = iBlkA/4;
				
				rgiBlkCurrQ = m_ppxliErrorMBA[iAuxComp];
				
				switch (iBlkA) {
				case 0: rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[1] == PARTIAL) ? ppxlcCurrMBBY : NULL;
					break;
				case 1: rgiBlkCurrQ += BLOCK_SIZE;
					rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[2] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE: NULL;
					break;
				case 2: rgiBlkCurrQ += MB_SIZE * BLOCK_SIZE;
					rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[3] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE : NULL;
					break;
				case 3: rgiBlkCurrQ += MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
					rgchBlkShape = (ppxlcCurrMBBY && pmbmd -> m_rgTranspStatus[4] == PARTIAL) ? ppxlcCurrMBBY + BLOCK_SIZE*MB_SIZE + BLOCK_SIZE : NULL;
					break;
				}
			}
			//~MAC
			
			iWidthCurrQ = MB_SIZE;
		}
		else {
			iWidthCurrQ = BLOCK_SIZE;
			rgiBlkCurrQ = (iBlk == U_BLOCK) ? m_ppxliErrorMBU: m_ppxliErrorMBV;
			rgchBlkShape = (ppxlcCurrMBBUV && pmbmd -> m_rgTranspStatus[iBlk] == PARTIAL) ? ppxlcCurrMBBUV : NULL;
		}
		
		rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
		if(iBlk>=A_BLOCK1 && !bAlphaQPReset)
		{
			if(bSkip || m_vopmd.vopPredType == BVOP && !bCBPY)
			{
				// if found that texture is not coded, then must cancel qp updates and recalculate quantiser for alpha
				// because alpha may still be coded but we cant change alpha qp if alpha qp is slaved to texture qp
				// in bvops, cbpy=0 also prevents qp updates, but not in pvops
				cancelQPUpdate(pmbmd);
				iQPA = pmbmd->m_stepSizeAlpha;

				bAlphaQPReset = TRUE;
			}
		}

		if(iBlk>=A_BLOCK1)
			quantizeTextureInterBlock (rgiBlkCurrQ, iWidthCurrQ, rgiCoefQ, iQPA, TRUE, rgchBlkShape, ((iBlk<U_BLOCK) || (iBlk >V_BLOCK)) ? MB_SIZE : BLOCK_SIZE, iBlk); // HHI Schueuer
		else
			quantizeTextureInterBlock (rgiBlkCurrQ, iWidthCurrQ, rgiCoefQ, iQP, FALSE, rgchBlkShape, (iBlk<U_BLOCK) ? MB_SIZE : BLOCK_SIZE, iBlk);
		// end
		Bool bCoded = FALSE;
		UInt i;
		for (i = 0; i < BLOCK_SQUARE_SIZE; i++) {
			if (rgiCoefQ [i] != 0)	{
				bCoded = TRUE;
				bMBCoded = TRUE;
				break;
			}
		}
		if(iBlk<A_BLOCK1)
			bSkip = bSkip & !bCoded;
		else 
			pbSkipAlpha[(iBlk-7)/4] = pbSkipAlpha[(iBlk-7)/4] & !bCoded;
		
		if(iBlk <= A_BLOCK1)
		{
			bCBPY |= bCoded;
		}
		pmbmd->setCodedBlockPattern (iBlk, bCoded);
	}
	
	pmbmd->m_bSkip = bSkip; 
	
	if(m_volmd.fAUsage == EIGHT_BIT)
	{ 
		for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 30-Nov-99
			if(pbSkipAlpha[iAuxComp] == TRUE)
				pmbmd->m_pCODAlpha[iAuxComp] = ALPHA_SKIPPED;
			else if(pmbmd->m_pCODAlpha[iAuxComp] == ALPHA_ALL255)
			{
				PixelC *ppxlc = pppxlcCurrQMBA[iAuxComp];
				Int i;
				for(i = 0; i<MB_SIZE; i++, ppxlc += m_iFrameWidthY)
					pxlcmemset(ppxlc, 255, MB_SIZE);
			}
		}
	}
	
	delete [] pbSkipAlpha;
	
	// INTERLACE
	if ((pmbmd->m_rgTranspStatus [0] == NONE)
		&&(m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE) 
		&& (bMBCoded == TRUE))
		fieldDCTtoFrameI(m_ppxliErrorMBY);
	// ~INTERLACE
}

//OBSS_SAIT_991015
Bool CVideoObjectEncoder::quantizeTextureMBBackwardCheck (CMBMode* pmbmd, 
														  PixelC *ppxlcCurrMBY,
														  PixelC *ppxlcCurrMBBY,
														  const PixelC *ppxlcRef1MBY)
														  
{
	Int bSkip = TRUE;
	Int *ppxliErrorMBY;
	ppxliErrorMBY = new Int [MB_SIZE*MB_SIZE];
	pmbmd->m_stepSize = m_vopmd.intStepB;
	
	Int iQP = pmbmd->m_stepSize;
	
	Int iBlkEnd = Y_BLOCK4;
	
	for(int i=0;i<MB_SIZE;i++){
		for(int j=0;j<MB_SIZE;j++){
			if(*(ppxlcCurrMBBY+i*MB_SIZE+j) == transpValue)
				*(ppxliErrorMBY+i*MB_SIZE+j) = 0;
			else
				*(ppxliErrorMBY+i*MB_SIZE+j) = *(ppxlcCurrMBY +i*MB_SIZE+j) - *(ppxlcRef1MBY +i*448+j);
		}
	}
	Int* rgiBlkCurrQ = ppxliErrorMBY;
	Int* rgiCoefQ;
	Int iWidthCurrQ;
	for (UInt iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt)iBlkEnd; iBlk++) { 
		if (pmbmd -> m_rgTranspStatus [iBlk % 6] == ALL) 
			continue;		
		switch (iBlk) 
		{
		case (Y_BLOCK1): 
			rgiBlkCurrQ = ppxliErrorMBY;
			break;
		case (Y_BLOCK2): 
			rgiBlkCurrQ = ppxliErrorMBY + BLOCK_SIZE;
			break;
		case (Y_BLOCK3): 
			rgiBlkCurrQ = ppxliErrorMBY + MB_SIZE * BLOCK_SIZE;
			break;
		case (Y_BLOCK4): 
			rgiBlkCurrQ = ppxliErrorMBY + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
			break;
		}
		iWidthCurrQ = MB_SIZE;
		rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
		quantizeTextureInterBlock (rgiBlkCurrQ, iWidthCurrQ, rgiCoefQ, iQP, FALSE, NULL, (iBlk<U_BLOCK) ? MB_SIZE : BLOCK_SIZE, iBlk);
		Bool bCoded = FALSE;
		UInt i;
		for (i = 0; i < BLOCK_SQUARE_SIZE; i++) {
			if (rgiCoefQ [i] != 0)	{
				bCoded = TRUE;
				break;
			}
		}
		bSkip = bSkip & !bCoded;
	}
	
	return (bSkip);
}
//~OBSS_SAIT_991015

Void CVideoObjectEncoder::sendDCTCoefOfInterMBTexture (const CMBMode* pmbmd) 
{
	assert (pmbmd != NULL);
	assert (pmbmd -> m_dctMd == INTER || pmbmd -> m_dctMd == INTERQ);
	assert (pmbmd -> m_rgTranspStatus [0] != ALL);
	
	Int* scan = grgiStandardZigzag;  // HHI Schueuer
	UInt nBits, iBlk = 0;
	for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
#ifdef __TRACE_AND_STATS_
		m_pbitstrmOut->trace (iBlk, "BLK_NO");
#endif // __TRACE_AND_STATS_
		if (iBlk < U_BLOCK)
			if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) continue;
			if (pmbmd->getCodedBlockPattern (iBlk))	{
				Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
#ifdef __TRACE_AND_STATS_
				m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
#endif // __TRACE_AND_STATS_
				// Modified for data partitioning mode by Toshiba(1998-1-16)
				if(m_volmd.bDataPartitioning && m_volmd.bReversibleVlc && m_vopmd.vopPredType != BVOP) {
					// HHI Schueuer: modified scan for sadcdt
					if (!m_volmd.bSadctDisable)
						scan = m_pscanSelector->select(scan, (pmbmd->m_rgTranspStatus[0] == PARTIAL), iBlk);
					// nBits = sendTCOEFInterRVLC (rgiCoefQ, 0, grgiStandardZigzag, TRUE);
					nBits = sendTCOEFInterRVLC (rgiCoefQ, 0, scan, TRUE);
					// end HHI
				}				
				else {
					// HHI Schueuer: modified scan for sadct
					// nBits = sendTCOEFInter (rgiCoefQ, 0,
					// m_vopmd.bAlternateScan ? grgiVerticalZigzag : grgiStandardZigzag);
					scan = (m_vopmd.bAlternateScan) ? grgiVerticalZigzag : grgiStandardZigzag;
					if (!m_volmd.bSadctDisable) 
						scan = m_pscanSelector->select(scan, (pmbmd->m_rgTranspStatus[0] == PARTIAL), iBlk);
					nBits = sendTCOEFInter (rgiCoefQ, 0, scan );
					// end HHI
				}
				// End Toshiba(1998-1-16)
				switch (iBlk) {
				case U_BLOCK: 
					m_statsMB.nBitsCr += nBits;
					break;
				case V_BLOCK: 
					m_statsMB.nBitsCb += nBits;
					break;
				default:
					m_statsMB.nBitsY += nBits;
				}
			}
	}	
}

Void CVideoObjectEncoder::sendDCTCoefOfIntraMBTexture (const CMBMode* pmbmd) 
{
	assert (pmbmd != NULL);
	assert (pmbmd -> m_dctMd == INTRA || pmbmd -> m_dctMd == INTRAQ);
	assert (pmbmd->m_rgTranspStatus [0] != ALL);
	
	UInt iBlk = 0;
	for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
		UInt nBits = 0;
#ifdef __TRACE_AND_STATS_
		m_pbitstrmOut->trace (iBlk, "BLK_NO");
#endif // __TRACE_AND_STATS_
		if (iBlk < U_BLOCK)
			if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) continue;
			Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
#ifdef __TRACE_AND_STATS_
			m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
#endif // __TRACE_AND_STATS_
			Int iCoefStart = 0;
			if (pmbmd->m_bCodeDcAsAc != TRUE)	{
				iCoefStart = 1;
				nBits = sendIntraDC (rgiCoefQ, iBlk);
			}
			if (pmbmd->getCodedBlockPattern (iBlk))	{
				Int* rgiZigzag = grgiStandardZigzag;
				if (m_vopmd.bAlternateScan)
					rgiZigzag = grgiVerticalZigzag;
				else if (pmbmd->m_bACPrediction)	
					rgiZigzag = (pmbmd->m_preddir [iBlk - 1] == HORIZONTAL) ? grgiVerticalZigzag : grgiHorizontalZigzag;
				// HHI Schueuer: modified scan for sadct
				if (!m_volmd.bSadctDisable)
					rgiZigzag = m_pscanSelector->select(rgiZigzag, (pmbmd->m_rgTranspStatus[0] == PARTIAL), iBlk); 
				// end HHI
				// Modified for data partitioning mode by Toshiba(1998-1-16)
				if(m_volmd.bDataPartitioning && m_volmd.bReversibleVlc && m_vopmd.vopPredType != BVOP)
					nBits += sendTCOEFIntraRVLC (rgiCoefQ, iCoefStart, rgiZigzag, TRUE);
				else
					nBits += sendTCOEFIntra (rgiCoefQ, iCoefStart, rgiZigzag);
				// End Toshiba(1998-1-16)
			}
			switch (iBlk) {
			case U_BLOCK: 
				m_statsMB.nBitsCr += nBits;
				break;
			case V_BLOCK: 
				m_statsMB.nBitsCb += nBits;
				break;
			default:
				m_statsMB.nBitsY += nBits;
			}
	}	
}

UInt CVideoObjectEncoder::sumAbsCurrMB ()
{
	PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
	UInt uisumAbs = 0;
	Int ic;
	for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
		uisumAbs += ppxlcCurrMBY [ic];
	}
	return uisumAbs;
}

Void CVideoObjectEncoder::codeMBAlphaHeadOfIVOP (const CMBMode* pmbmd, Int iAuxComp)
{
	// get CBPA
	Int CBPA = 0;
	UInt cNonTrnspBlk = 0, iBlk;
	
	for (iBlk = (UInt) A_BLOCK1