errenc.cpp

《Visual C++小波变换技术与工程实践》靳济芳编著的光盘程序。

			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 
		if (m_volmd.fAUsage == RECTANGLE)
			assert (cNonTrnspBlk==4); // Only all opaque is only supportedin DP mode at present

		if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)	{
			m_pbitstrmOut->putBits (pmbmd->m_bACPrediction, 1, "MB_ACPRED");
			m_statsVP->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_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (CBPY, "MB_CBPY1");
				break;
			case 2:
				m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (CBPY, "MB_CBPY2");
				break;
			case 3:
				m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (CBPY, "MB_CBPY3");
				break;
			case 4:
				m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (CBPY, "MB_CBPY");
				break;
			default:
				assert (FALSE);
			}
			m_statsVP->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_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (1 - CBPY, "MB_CBPY1");
				break;
			case 2:
				m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (3 - CBPY, "MB_CBPY2");
				break;
			case 3:
				m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (7 - CBPY, "MB_CBPY3");
				break;
			case 4:
				m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (15 - CBPY, "MB_CBPY");
				break;
			default:
				assert (FALSE);
			}
		}

		if ( m_vopmd.vopPredType != IVOP &&
				(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_statsVP->nBitsDQUANT += 2;
			}
		}				 
		
		if (m_vopmd.vopPredType	!= IVOP &&
				(pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ))	{
			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];
				Int* rgiCoefQ = iCoefQ_DP [iMBnum][iBlk - 1];
#ifdef __TRACE_AND_STATS_
////				m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
				m_pbitstrmOut->trace (rgiCoefQ[0], "IntraDC");
#endif // __TRACE_AND_STATS_
////				Int iCoefStart = 0;
				if (pmbmd->m_bCodeDcAsAc != TRUE)	{
////					iCoefStart = 1;
					nBits = sendIntraDC (rgiCoefQ, iBlk);
				}
				switch (iBlk) {
				case U_BLOCK: 
					m_statsVP->nBitsCr += nBits;
					break;
				case V_BLOCK: 
					m_statsVP->nBitsCb += nBits;
					break;
				default:
					m_statsVP->nBitsY += nBits;
				}
			}	
		}
	}

	for(iMBnum = iVPMBnum, pmbmd = m_rgmbmd+iVPMBnum, pmv = m_rgmv+iVPMBnum*PVOP_MV_PER_REF_PER_MB;
			iMBnum <= iVPlastMBnum; iMBnum++, pmbmd++, pmv+=PVOP_MV_PER_REF_PER_MB) {
		if (pmbmd->m_bSkip || pmbmd -> m_rgTranspStatus [0] == ALL)
			continue;

		iMBX = iMBnum % m_iNumMBX;
		iMBY = iMBnum / m_iNumMBX;
#ifdef __TRACE_AND_STATS_
		m_pbitstrmOut->trace (CSite (iMBX, iMBY), "TextureTcoef_MB_X_Y");
#endif // __TRACE_AND_STATS_
		if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)	{
			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];
				Int* rgiCoefQ = iCoefQ_DP [iMBnum][iBlk - 1];
#ifdef __TRACE_AND_STATS_
				m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
#endif // __TRACE_AND_STATS_
				Int iCoefStart;
				if (pmbmd->m_bCodeDcAsAc != TRUE)	{
					iCoefStart = 1;
				} else {
					iCoefStart = 0;
				}
				if (pmbmd->getCodedBlockPattern (iBlk))	{
					Int* rgiZigzag = grgiStandardZigzag;
					if (pmbmd->m_bACPrediction)	
						rgiZigzag = (pmbmd->m_preddir [iBlk - 1] == HORIZONTAL) ? grgiVerticalZigzag : grgiHorizontalZigzag;
					// 09/19/99 HHI Schueuer: added for sadct
					if (!m_volmd.bSadctDisable)
						rgiZigzag = m_pscanSelector->select_DP (rgiZigzag, (pmbmd->m_rgTranspStatus[0] == PARTIAL), iBlk, iRowLength_DP[iMBnum]);
					// end HHI
					if( m_volmd.bReversibleVlc == TRUE )
						nBits += sendTCOEFIntraRVLC (rgiCoefQ, iCoefStart, rgiZigzag, FALSE);
					else
						nBits += sendTCOEFIntra (rgiCoefQ, iCoefStart, rgiZigzag);
				}
				switch (iBlk) {
				case U_BLOCK: 
					m_statsVP->nBitsCr += nBits;
					break;
				case V_BLOCK: 
					m_statsVP->nBitsCb += nBits;
					break;
				default:
					m_statsVP->nBitsY += nBits;
				}
			}	
		} else {
			UInt nBits, iBlk = 0;
			// 09/19/99 HHI Schueuer
			Int* scan = grgiStandardZigzag;
			// end HHI
			for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
				// 09/19/99 HHI Schueuer
				scan = grgiStandardZigzag;
				// end HHI
#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];
					Int* rgiCoefQ = iCoefQ_DP [iMBnum][iBlk - 1];
#ifdef __TRACE_AND_STATS_
					m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
#endif // __TRACE_AND_STATS_
					// 09/19/99 HHI Schueuer: added for sadct
					if (!m_volmd.bSadctDisable) 
						scan = m_pscanSelector->select_DP (scan, (pmbmd->m_rgTranspStatus[0] == PARTIAL), iBlk, iRowLength_DP[iMBnum]);
					// end HHI
					if( m_volmd.bReversibleVlc == TRUE )
						// 09/19/99 HHI Schueuer: sadct
						// nBits = sendTCOEFInterRVLC (rgiCoefQ, 0, grgiStandardZigzag, FALSE);
						nBits = sendTCOEFInterRVLC (rgiCoefQ, 0, scan, FALSE);
					else
						// nBits = sendTCOEFInter (rgiCoefQ, 0, grgiStandardZigzag);
						nBits = sendTCOEFInter (rgiCoefQ, 0, scan);
					// end HHI 
					switch (iBlk) {
					case U_BLOCK: 
						m_statsVP->nBitsCr += nBits;
						break;
					case V_BLOCK: 
						m_statsVP->nBitsCb += nBits;
						break;
					default:
						m_statsVP->nBitsY += nBits;
					}
				}
			}	
		}
	}
}


Void CVideoObjectEncoder::encodeNSForIVOP_WithShape_DP ()
{
	assert( m_volmd.bDataPartitioning );
	assert( m_vopmd.vopPredType==IVOP );
	assert( m_volmd.fAUsage == ONE_BIT && m_volmd.bShapeOnly == FALSE );
	assert(m_volmd.nBits==8);

	//in case the IVOP is used as an ref for direct mode
	memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
//#ifdef __SHARP_FIX_
	memset (m_rgmvBY, 0, m_iNumMB * sizeof (CMotionVector));
//#endif

	Int iMBX, iMBY;
	CMBMode* pmbmd = m_rgmbmd;
	Int iQPPrev = m_vopmd.intStepI;	//initialization

	Int iVPCounter = m_statsVOP.total();
	Int iVPtotal;
	m_iVPMBnum = 0;
	CStatistics m_statsVP(0);
	// DCT coefficient buffer for Data Partitioning mode
	Int*** iCoefQ_DP = new Int** [m_iNumMB];

	// 09/17/99 HHI  Schueuer: buffer for rowlength needed by sadct
	Int*** iRowLength_DP;
	if (!m_volmd.bSadctDisable) 
		iRowLength_DP =  new Int** [m_iNumMB];
	else
		iRowLength_DP = NULL;
	// end HHI

	// Set not to output but count bitstream
//	m_pbitstrmOut->SetDontSendBits(TRUE);

	PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;

	PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
	PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
	PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
	PixelC* ppxlcOrigBY = (PixelC*) m_pvopcOrig->pixelsBoundBY ();

	Bool bRestartDelayedQP = TRUE;

	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
		PixelC*  ppxlcRefMBY  = ppxlcRefY;
		PixelC*  ppxlcRefMBU  = ppxlcRefU;
		PixelC*  ppxlcRefMBV  = ppxlcRefV;
		PixelC*  ppxlcRefMBBY = ppxlcRefBY;
		PixelC*  ppxlcRefMBBUV = ppxlcRefBUV;
		PixelC*  ppxlcOrigMBY = ppxlcOrigY;
		PixelC*  ppxlcOrigMBU = ppxlcOrigU;
		PixelC*  ppxlcOrigMBV = ppxlcOrigV;
		PixelC*  ppxlcOrigMBBY = ppxlcOrigBY;
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
#ifdef __TRACE_AND_STATS_
			m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
#endif // __TRACE_AND_STATS_
			pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;

			if(bRestartDelayedQP)
				pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
			else
				pmbmd->m_stepSizeDelayed = iQPPrev;

			Int iVPlastMBnum = iMBY * m_iNumMBX + iMBX;

			// shape bitstream is set to shape cache
			m_pbitstrmShapeMBOut = m_pbitstrmShape_DP[iVPlastMBnum];
			m_statsMB.reset ();

			pmbmd->m_bSkip = FALSE;	//reset for direct mode 
// GMC
			pmbmd -> m_bMCSEL = FALSE; //reset for direct mode
// ~GMC
			pmbmd->m_bPadded=FALSE;
			copyToCurrBuffWithShape (
				ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, 
				ppxlcOrigMBBY, NULL,
				m_iFrameWidthY, m_iFrameWidthUV
			);
			downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
			decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY);
			if (pmbmd -> m_rgTranspStatus [0] == PARTIAL) {
				LPEPadding (pmbmd);
				m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, iMBX, iMBY);
				downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
				decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // need to modify it a little (NONE block won't change)
			}
			else
				m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, iMBX, iMBY);
			if(m_volmd.bShapeOnly == FALSE) {
//				// Set not to output but count bitstream
				m_pbitstrmOut->SetDontSendBits(TRUE);

				if (pmbmd -> m_rgTranspStatus [0] != ALL) {
					pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
					bRestartDelayedQP = FALSE;
					// 09/17/99 HHI  Schueuer: sadct
					if (!m_volmd.bSadctDisable) 
						deriveSADCTRowLengths (m_rgiCurrMBCoeffWidth, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd->m_rgTranspStatus);
					// end HHI

					Int iQuantMax = (1<<m_volmd.uiQuantPrecision) - 1;
					assert (pmbmd->m_stepSize <= iQuantMax && pmbmd->m_stepSize > 0);
					iQPPrev = pmbmd->m_stepSize;
					if (pmbmd->m_intStepDelta == 0)
						pmbmd->m_dctMd = INTRA;
					else
						pmbmd->m_dctMd = INTRAQ;
					// 09/17/99 HHI Schueuer
					if (!m_volmd.bSadctDisable)  
						quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
					else
						quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL);
					// end HHI
					codeMBTextureHeadOfIVOP (pmbmd);
					sendDCTCoefOfIntraMBTexture (pmbmd);
	
					// MC padding
					if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
						mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL);
					padNeighborTranspMBs (
						iMBX, iMBY,
						pmbmd,
						ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL
					);
				}
				else {
					padCurrAndTopTranspMBFromNeighbor (
						iMBX, iMBY,
						pmbmd,
						ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL
					);
				}
//				// Set to output bitstream
				m_pbitstrmOut->SetDontSendBits(FALSE);
			}

			// copy DCT coefficient to buffer
			iCoefQ_DP[iVPlastMBnum] = new Int* [6];
			Int iBlk;
			for (iBlk = 0; iBlk < 6; iBlk++) {
				iCoefQ_DP [iVPlastMBnum] [iBlk] = new Int [BLOCK_SQUARE_SIZE];

				for( Int t = 0; t < BLOCK_SQUARE_SIZE; t++ )
					iCoefQ_DP[iVPlastMBnum][iBlk][t] = m_rgpiCoefQ[iBlk][t];
			}

			// 09/17/99 HHI  Schueuer: copy rowlength for sadct
			if (!m_volmd.bSadctDisable) {
				iRowLength_DP[iVPlastMBnum] = new Int* [11];
				Int iBlk;
				for (iBlk = ALL_Y_BLOCKS; iBlk < ALL_A_BLOCKS; iBlk++)