sys_encoder_errenc.cpp

完整的RTP RTSP代码库

#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 = iCoefQ_DP [iMBnum][iBlk - 1];
#ifdef __TRACE_AND_STATS_
					m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
#endif // __TRACE_AND_STATS_

					if (!m_volmd.bSadctDisable) 
						scan = m_pscanSelector->select_DP (scan, (pmbmd->m_rgTranspStatus[0] == PARTIAL), iBlk, iRowLength_DP[iMBnum]);

					if( m_volmd.bReversibleVlc == TRUE )
						nBits = sendTCOEFInterRVLC (rgiCoefQ, 0, scan, FALSE);
					else
						nBits = sendTCOEFInter (rgiCoefQ, 0, scan);

					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 );
	if(!(m_volmd.fAUsage == ONE_BIT && m_volmd.bShapeOnly == FALSE ))
		fatal_error("Grayscale alpha mode cannot be used with data partitioning");
	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;

	Int iMB = 0;

	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++, iMB++) {
#ifdef __TRACE_AND_STATS_
			m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
#endif // __TRACE_AND_STATS_

			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 
			pmbmd->m_bMCSEL = FALSE; //reset for direct mode
			pmbmd->m_bPadded = FALSE;
			pmbmd->m_dctMd = INTRA;

			// MB level rate control section
			// here is where we calculate the delta QP
			if (m_uiRateControl>=RC_TM5) {
				// TM5 rate control
				updateQP(pmbmd, iQPPrev, m_tm5rc.tm5rc_calc_mquant(iMB, m_statsVOP.total())	);
			}
			else
			{
#ifdef _MBQP_CHANGE_
				Int iDQuant = (rand() % 5) - 2;
				updateQP(pmbmd, iQPPrev, iQPPrev + iDQuant);
#else
				// no change in step size, but still need to call...
				updateQP(pmbmd, iQPPrev, iQPPrev);
#endif //_MBQP_CHANGE_
			}

			copyToCurrBuffWithShape (
				ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, 
				ppxlcOrigMBBY, NULL,
				m_iFrameWidthY, m_iFrameWidthUV
			);

			decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY);
			downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd); // downsample original BY now for LPE padding (using original shape)
			if (pmbmd -> m_rgTranspStatus [0] == PARTIAL) {
				LPEPadding (pmbmd);
				m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, iMBX, iMBY);
				decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // need to modify it a little (NONE block won't change)
				downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd);
			}
			else
				m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, iMBX, iMBY);

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

			if (pmbmd -> m_rgTranspStatus [0] != ALL) {
				if (!m_volmd.bSadctDisable) 
					deriveSADCTRowLengths (m_rgiCurrMBCoeffWidth, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd->m_rgTranspStatus);

				setDCVLCMode(pmbmd, &bRestartDelayedQP);

				// 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 {
				cancelQPUpdate(pmbmd);

				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++)
					iRowLength_DP[iVPlastMBnum][iBlk] = 0;

				if(pmbmd -> m_rgTranspStatus [0] != ALL) { 
					for (iBlk = Y_BLOCK1; iBlk <= A_BLOCK4; iBlk++) {
						iRowLength_DP [iVPlastMBnum][iBlk] = new Int [BLOCK_SIZE];
						for ( Int t = 0; t < BLOCK_SIZE; t++)
							iRowLength_DP [iVPlastMBnum][iBlk][t] = m_rgiCurrMBCoeffWidth[iBlk][t];
					}
				}
			}
			// end HHI

			iQPPrev = pmbmd->m_stepSize;

			ppxlcOrigMBBY += MB_SIZE;
			pmbmd++;
#ifdef __TRACE_AND_STATS_
			m_statsVOP   += m_statsMB;
#endif // __TRACE_AND_STATS_
			ppxlcRefMBY  += MB_SIZE;
			ppxlcRefMBU  += BLOCK_SIZE;
			ppxlcRefMBV  += BLOCK_SIZE;
			ppxlcRefMBBY += MB_SIZE;
			ppxlcRefMBBUV += BLOCK_SIZE;
			ppxlcOrigMBY += MB_SIZE;
			ppxlcOrigMBU += BLOCK_SIZE;
			ppxlcOrigMBV += BLOCK_SIZE;

			iVPtotal = (int) m_statsVOP.total() - iVPCounter;
			if( iVPtotal > m_volmd.bVPBitTh || iVPlastMBnum == m_iNumMB-1 /* last MB in a VOP */) {
				// Set to output bitstream
				m_pbitstrmOut->SetDontSendBits(FALSE);
				// encode video packet
				iVPCounter = m_statsVOP.total();
				m_statsVP.reset();
				if( m_iVPMBnum > 0 )
				{
					m_statsVP.nBitsHead = codeVideoPacketHeader (m_rgmbmd[m_iVPMBnum].m_stepSize - m_rgmbmd[m_iVPMBnum].m_intStepDelta);	
				}

				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;

				// 09/19/99 HHI Schueuer: added for sadct
				if (!m_volmd.bSadctDisable) 
					DataPartitioningTextureCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP, iRowLength_DP);
				else
					DataPartitioningTextureCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);

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

				m_iVPMBnum = iVPlastMBnum + 1;
			}
		}
		
		MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
		m_rgpmbmAbove = m_rgpmbmCurr;
		m_rgpmbmCurr  = ppmbmTemp;
		ppxlcRefY  += m_iFrameWidthYxMBSize;
		ppxlcRefU  += m_iFrameWidthUVxBlkSize;
		ppxlcRefV  += m_iFrameWidthUVxBlkSize;
		ppxlcRefBY += m_iFrameWidthYxMBSize;
		ppxlcRefBUV += m_iFrameWidthUVxBlkSize;

		ppxlcOrigY += m_iFrameWidthYxMBSize;
		ppxlcOrigBY += m_iFrameWidthYxMBSize;
		ppxlcOrigU += m_iFrameWidthUVxBlkSize;
		ppxlcOrigV += m_iFrameWidthUVxBlkSize;
	}

	// delete CoefQ_DP
	for(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;

	// 09/17/99 HHI  Schueuer: delete iRowLength _DP sadct
	if (!m_volmd.bSadctDisable) {
		for (Int iMB = 0; iMB < m_iNumMB; iMB++) {
			for (Int iBlk = 0; iBlk < 11; iBlk++) 
				delete [] iRowLength_DP[iMB][iBlk];
			delete [] iRowLength_DP[iMB];
		}
		delete [] iRowLength_DP;
	}
	else {
		delete []iRowLength_DP;
	}
	// end HHI;

	// restore normal output stream
	m_pbitstrmShapeMBOut = m_pbitstrmOut;

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

Void CVideoObjectEncoder::encodeNSForPVOP_WithShape_DP ()
{
	assert( m_volmd.bDataPartitioning );
	assert( m_vopmd.vopPredType==PVOP || (m_uiSprite == 2 && m_vopmd.vopPredType==SPRITE) ); // GMC
	if(!(m_volmd.fAUsage == ONE_BIT && m_volmd.bShapeOnly == FALSE ))
		fatal_error("Grayscale alpha mode cannot be used with data partitioning");
	assert(m_volmd.nBits==8);

	Int iMBX, iMBY;

	motionEstPVOP_WithShape ();

	UInt newQStep = m_vopmd.intStep; // for frame based rate control
	// vopmd.intStep is updated at bottom of this function

	// Rate Control
	if (m_uiRateControl==RC_MPEG4) {
		Double Ec = m_iMAD / (Double) (m_iNumMBY * m_iNumMBX * 16 * 16 * m_iRRVScale *m_iRRVScale);
		m_statRC.setMad (Ec);
		// calculate for next frame (should be this frame, but its too late to send vop qp!)
		newQStep = m_statRC.updateQuanStepsize (m_vopmd.intStep);
		// this is not the correct way to use rate control
		m_statRC.setQc (m_vopmd.intStep);
	}

	CoordI y = m_rctCurrVOPY.top; 
	CMBMode* pmbmd = m_rgmbmd;
	Int iQPPrev = m_vopmd.intStep;
	CMotionVector* pmv = m_rgmv;
	CMotionVector* pmvBY = m_rgmvBY;

	Int iVPCounter = m_statsVOP.total();
	Int iVPtotal;
	m_iVPMBnum = 0;
	CStatistics m_statsVP(0);
	// DCT coefficient buffer for Data Partitioning mode