errenc.cpp

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

	Int iVideoPacketNumber	= 0;
// ~RRV_2
	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];

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

	Bool bRestartDelayedQP = TRUE;

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

			m_statsMB.reset ();

			// MB rate control
			//pmbmd->m_intStepDelta = 0;
			//iIndexofQ = (iIndexofQ + 1) % 4;
			//pmbmd->m_intStepDelta = rgiQ [iIndexofQ];
			// -----

// bug fix by toshiba 98-9-24 start
			pmbmd->m_bSkip = FALSE;			//reset for direct mode
// bug fix by toshiba 98-9-24 end
// GMC
			pmbmd -> m_bMCSEL = FALSE;			//reset for direct mode
// ~GMC
			pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;

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

			iQPPrev = pmbmd->m_stepSize;
			if (pmbmd->m_intStepDelta == 0)
				pmbmd->m_dctMd = INTRA;
			else
				pmbmd->m_dctMd = INTRAQ;

// RRV_2 insertion
			pmbmd->m_iVideoPacketNumber	= iVideoPacketNumber;
// ~RRV_2
			copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
// RRV insertion
			if(m_vopmd.RRVmode.iRRVOnOff == 1)
			{
				DownSamplingTextureForRRV(m_ppxlcCurrMBY,
										  m_ppxlcCurrMBY,
										  (MB_SIZE *m_iRRVScale),
										  (MB_SIZE *m_iRRVScale));
			    DownSamplingTextureForRRV(m_ppxlcCurrMBU,
										  m_ppxlcCurrMBU,
										  (BLOCK_SIZE* m_iRRVScale),
										  (BLOCK_SIZE* m_iRRVScale));
			    DownSamplingTextureForRRV(m_ppxlcCurrMBV,
										  m_ppxlcCurrMBV,
										  (BLOCK_SIZE* m_iRRVScale),
										  (BLOCK_SIZE* m_iRRVScale));
			}

// ~RRV	
			quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL);
// RRV insertion
			if(m_vopmd.RRVmode.iRRVOnOff == 1)
			{
			    UpSamplingTextureForRRV(ppxlcRefMBY, ppxlcRefMBY,
										MB_SIZE, MB_SIZE,
										m_iFrameWidthY);
			    UpSamplingTextureForRRV(ppxlcRefMBU, ppxlcRefMBU,
										BLOCK_SIZE, BLOCK_SIZE,
										m_iFrameWidthUV);
			    UpSamplingTextureForRRV(ppxlcRefMBV, ppxlcRefMBV,
										BLOCK_SIZE, BLOCK_SIZE,
										m_iFrameWidthUV);
			}
// ~RRV
			codeMBTextureHeadOfIVOP (pmbmd);
			sendDCTCoefOfIntraMBTexture (pmbmd);

			Int iVPlastMBnum = iMBY * m_iNumMBX + iMBX;

			// 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];
			}

			pmbmd++;
#ifdef __TRACE_AND_STATS_
			m_statsVOP   += m_statsMB;
#endif // __TRACE_AND_STATS_
// RRV modification
			ppxlcRefMBY  += (MB_SIZE *m_iRRVScale);
			ppxlcRefMBU  += (BLOCK_SIZE *m_iRRVScale);
			ppxlcRefMBV  += (BLOCK_SIZE *m_iRRVScale);
			ppxlcOrigMBY += (MB_SIZE *m_iRRVScale);
			ppxlcOrigMBU += (BLOCK_SIZE *m_iRRVScale);
			ppxlcOrigMBV += (BLOCK_SIZE *m_iRRVScale);
//			ppxlcRefMBY  += MB_SIZE;
//			ppxlcRefMBU  += BLOCK_SIZE;
//			ppxlcRefMBV  += BLOCK_SIZE;
//			ppxlcOrigMBY += MB_SIZE;
//			ppxlcOrigMBU += BLOCK_SIZE;
//			ppxlcOrigMBV += BLOCK_SIZE;
// ~RRV

			iVPtotal = (int) m_statsVOP.total() - iVPCounter;

// RRV insertion
			iCurrMBPos	= (m_iRRVScale == 2) ? (2 *iMBX +1 +(2 *iMBY +1) *(2 *m_iNumMBX)) : ((iMBY *m_iNumMBX) +iMBX);
// ~RRV			

// NEWPRED
			if( ((m_volmd.bNewpredEnable) && (m_volmd.bNewpredSegmentType == 0)) ?
// RRV modification
				(iCurrMBPos == g_pNewPredEnc->SliceTailMBA((iMBX *m_iRRVScale), (iMBY *m_iRRVScale))) : ( iVPtotal > m_volmd.bVPBitTh || iVPlastMBnum == m_iNumMB-1) ){
//				(iMBY*m_iNumMBX+iMBX==g_pNewPredEnc->SliceTailMBA(iMBX, iMBY)) : ( iVPtotal > m_volmd.bVPBitTh || iVPlastMBnum == m_iNumMB-1) ){
// ~RRV modification
//			if( iVPtotal > m_volmd.bVPBitTh || iVPlastMBnum == m_iNumMB-1 /* last MB in a VOP */){
// ~NEWPRED
				// Set to output bitstream
				m_pbitstrmOut->SetDontSendBits(FALSE);
				// encode video packet
				iVPCounter = m_statsVOP.total();
				m_statsVP.reset();
// RRV_2 insertion
				iVideoPacketNumber ++;
// ~RRV_2
				if( m_iVPMBnum > 0 )
				{
					m_statsVP.nBitsHead = codeVideoPacketHeader (m_rgmbmd[m_iVPMBnum].m_stepSize);
					bRestartDelayedQP = TRUE;
				}

				DataPartitioningMotionCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);

				m_pbitstrmOut -> putBits (DC_MARKER, NUMBITS_DP_DC_MARKER, "DC_marker");
				m_statsVP.nBitsHead += NUMBITS_DP_DC_MARKER;

				DataPartitioningTextureCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);

				//assert( iVPtotal + m_statsVP.nBitsHead == (int) m_statsVP.total() );

				m_iVPMBnum = iVPlastMBnum + 1;

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

		}
		
		MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
		m_rgpmbmAbove = m_rgpmbmCurr;
		m_rgpmbmCurr  = ppmbmTemp;
		ppxlcRefY  += m_iFrameWidthYxMBSize;
		ppxlcRefU  += m_iFrameWidthUVxBlkSize;
		ppxlcRefV  += m_iFrameWidthUVxBlkSize;
		
		ppxlcOrigY += m_iFrameWidthYxMBSize;
		ppxlcOrigU += m_iFrameWidthUVxBlkSize;
		ppxlcOrigV += m_iFrameWidthUVxBlkSize;
	}

// RRV insertion
	if(m_vopmd.RRVmode.iRRVOnOff == 1)
	{
          ppxlcRefY	= (PixelC*) m_pvopcRefQ1->pixelsY () 
			  + m_iStartInRefToCurrRctY;
          ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU ()
			  + m_iStartInRefToCurrRctUV;
          ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV ()
			  + m_iStartInRefToCurrRctUV;
          filterCodedPictureForRRV(ppxlcRefY, ppxlcRefU, ppxlcRefV,
								   m_ivolWidth, m_ivolHeight,
								   m_iNumMBX,
								   m_iNumMBY,
								   m_iFrameWidthY, m_iFrameWidthUV);
      }
// ~RRV
	// delete CoefQ_DP
	for( Int iMB = 0; iMB < m_iNumMB; iMB++ )  {
		for (Int iBlk = 0; iBlk < 6; iBlk++) {
			delete [] iCoefQ_DP [iMB] [iBlk];
		}
		delete [] iCoefQ_DP[iMB];
	}
	delete [] iCoefQ_DP;

	// Set to output bitstream
	m_pbitstrmOut->SetDontSendBits(FALSE);
}


Void CVideoObjectEncoder::DataPartitioningMotionCoding(Int iVPMBnum, Int iVPlastMBnum, CStatistics* m_statsVP, Int*** iCoefQ_DP)
{
	assert( m_volmd.bDataPartitioning );

	Int	iMBnum;
	CMBMode* pmbmd;
	CMotionVector* pmv = m_rgmv;
	Int iMBX, iMBY;

	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) {
		iMBX = iMBnum % m_iNumMBX;
		iMBY = iMBnum / m_iNumMBX;
#ifdef __TRACE_AND_STATS_
		m_pbitstrmOut->trace (CSite (iMBX, iMBY), "Motion_MB_X_Y");
#endif // __TRACE_AND_STATS_
		if( m_volmd.fAUsage != RECTANGLE ) {
			m_statsVP->nBitsShape += dumpCachedShapeBits_DP(iMBnum);
		}
		
		if (pmbmd -> m_rgTranspStatus [0] != ALL) {
			if( m_vopmd.vopPredType==PVOP || (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE)) { // GMC
				m_pbitstrmOut->putBits (pmbmd->m_bSkip, 1, "MB_Skip");
				m_statsVP->nBitsCOD++;
// GMC
			if(m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE && pmbmd->m_bSkip == TRUE)
				m_statsVP->nMCSELMB++;
// ~GMC
			}

			if (!pmbmd->m_bSkip) {
				UInt CBPC = (pmbmd->getCodedBlockPattern (U_BLOCK) << 1)
							| pmbmd->getCodedBlockPattern (V_BLOCK);	
														//per defintion of H.263's CBPC 
				assert (CBPC >= 0 && CBPC <= 3);

				Int iMBtype;								//per H.263's MBtype
				Int iSymbol;
				switch( m_vopmd.vopPredType ) {
				case PVOP:
					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_statsVP->nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCinter->encodeSymbol (iMBtype * 4 + CBPC, "MCBPC");
					break;
// GMC
				case SPRITE:
					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_statsVP->nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCinter->encodeSymbol (iMBtype * 4 + CBPC, "MCBPC");
					if((pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) && (pmbmd -> m_bhas4MVForward == FALSE)){
						m_pbitstrmOut->putBits (pmbmd->m_bMCSEL, 1, "MCSEL");
						m_statsVP->nMCSELMB ++;
						m_statsVP->nBitsMCSEL ++;
					}
					break;
// ~GMC
				case IVOP:
					iSymbol = 4 * pmbmd->m_dctMd + CBPC;
					assert (iSymbol >= 0 && iSymbol <= 7);			//send MCBPC
#ifdef __TRACE_AND_STATS_
					m_pbitstrmOut->trace (CBPC, "MB_CBPC");
#endif // __TRACE_AND_STATS_
					m_statsVP->nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCintra->encodeSymbol (iSymbol, "MB_MCBPC");
					break;
				default:
					assert(FALSE);
				}

				if ( m_vopmd.vopPredType == IVOP ) {
					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_statsVP->nBitsDQUANT += 2;
						}
					}				 
		
					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 = iCoefQ_DP [iMBnum][iBlk - 1];
#ifdef __TRACE_AND_STATS_
						m_pbitstrmOut->trace (rgiCoefQ[0], "IntraDC");
#endif // __TRACE_AND_STATS_
						if (pmbmd->m_bCodeDcAsAc != TRUE)	{
							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;
						}
					}
				}

				if (pmbmd->m_dctMd != INTRA && pmbmd->m_dctMd != INTRAQ && !(m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE && pmbmd -> m_bMCSEL)) { // GMC
					if( m_volmd.fAUsage == RECTANGLE )
						m_statsVP->nBitsMV += encodeMVVP (pmv, pmbmd, iMBX, iMBY);
					else
						m_statsVP->nBitsMV += encodeMVWithShape (pmv, pmbmd, iMBX, iMBY);
				}
			}
		}
	}
}

// HHI Schueuer: added Int*** iRowLength_DP for sadct
Void CVideoObjectEncoder::DataPartitioningTextureCoding(Int iVPMBnum, Int iVPlastMBnum, CStatistics* m_statsVP, Int*** iCoefQ_DP, Int*** iRowLength_DP)
{
	assert( m_volmd.bDataPartitioning );

	Int	iMBnum;
	CMBMode* pmbmd;
	CMotionVector* pmv = m_rgmv;
	Int iMBX, iMBY;

	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), "TextureHeader_MB_X_Y");
#endif // __TRACE_AND_STATS_
		Int CBPY = 0;
		UInt cNonTrnspBlk = 0, iBlk;
		for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++) {