sys_encoder_sesenc.cpp

完整的RTP RTSP代码库

			m_rgvolmd [iLayer][iVO].bIntraBlocks = pArgs->rgbIntraBlocks [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bInterBlocks = pArgs->rgbInterBlocks [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bInter4vBlocks = pArgs->rgbInter4vBlocks [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bNotCodedBlocks = pArgs->rgbNotCodedBlocks [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bDCTCoefs = pArgs->rgbDCTCoefs [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bDCTLines = pArgs->rgbDCTLines [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bVLCSymbols = pArgs->rgbVLCSymbols [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bVLCBits = pArgs->rgbVLCBits [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bAPM = pArgs->rgbAPM [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bNPM = pArgs->rgbNPM [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bInterpolateMCQ = pArgs->rgbInterpolateMCQ [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bForwBackMCQ = pArgs->rgbForwBackMCQ [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bHalfpel2 = pArgs->rgbHalfpel2 [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bHalfpel4 = pArgs->rgbHalfpel4 [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bSadct = pArgs->rgbSadct [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bQuarterpel = pArgs->rgbQuarterpel [iLayer][iVO];
			// START: Complexity Estimation syntax support - Update version 2 - Massimo Ravasi (EPFL) - 11 Nov 1999
			// redundant flags to avoid start code emulation
			m_rgvolmd [iLayer][iVO].bShapeComplexityEstimationDisable = ! (
				   m_rgvolmd [iLayer][iVO].bOpaque
				|| m_rgvolmd [iLayer][iVO].bTransparent
				|| m_rgvolmd [iLayer][iVO].bIntraCAE
				|| m_rgvolmd [iLayer][iVO].bInterCAE
				|| m_rgvolmd [iLayer][iVO].bNoUpdate
				|| m_rgvolmd [iLayer][iVO].bUpsampling);
			m_rgvolmd [iLayer][iVO].bTextureComplexityEstimationSet1Disable = ! (
				   m_rgvolmd [iLayer][iVO].bIntraBlocks
				|| m_rgvolmd [iLayer][iVO].bInterBlocks
				|| m_rgvolmd [iLayer][iVO].bInter4vBlocks
				|| m_rgvolmd [iLayer][iVO].bNotCodedBlocks);
			m_rgvolmd [iLayer][iVO].bTextureComplexityEstimationSet2Disable = ! (
				   m_rgvolmd [iLayer][iVO].bDCTCoefs
				|| m_rgvolmd [iLayer][iVO].bDCTLines
				|| m_rgvolmd [iLayer][iVO].bVLCSymbols
				|| m_rgvolmd [iLayer][iVO].bVLCBits);
			m_rgvolmd [iLayer][iVO].bMotionCompensationComplexityDisable = ! (
				   m_rgvolmd [iLayer][iVO].bAPM
				|| m_rgvolmd [iLayer][iVO].bNPM
				|| m_rgvolmd [iLayer][iVO].bInterpolateMCQ
				|| m_rgvolmd [iLayer][iVO].bForwBackMCQ
				|| m_rgvolmd [iLayer][iVO].bHalfpel2
				|| m_rgvolmd [iLayer][iVO].bHalfpel4);
			m_rgvolmd [iLayer][iVO].bVersion2ComplexityEstimationDisable = ! (
				   m_rgvolmd [iLayer][iVO].bSadct
				|| m_rgvolmd [iLayer][iVO].bQuarterpel);
			// END: Complexity Estimation syntax support - Update version 2
			// END: Complexity Estimation syntax support

			m_rgvolmd [iLayer][iVO].bAllowSkippedPMBs = pArgs->rgbAllowSkippedPMBs [iVO];


			// HHI Schueuer for sadct
			m_rgvolmd [iLayer][iVO].bSadctDisable		= pArgs->rgbSadctDisable [iLayer][iVO];
			// end

			m_rgvolmd [iLayer][iVO].uiProfileAndLevel	= pArgs->uiProfileAndLevel;
			m_rgvolmd [iLayer][iVO].bCodeSequenceHead	= pArgs->bCodeSequenceHead;

			// START: Vol Control Parameters
			if(pArgs->rguiVolControlParameters[0]!=NULL)
			{
				m_rgvolmd [iLayer][iVO].uiVolControlParameters = pArgs->rguiVolControlParameters [iLayer][iVO];
				m_rgvolmd [iLayer][iVO].uiChromaFormat = pArgs->rguiChromaFormat [iLayer][iVO];
				m_rgvolmd [iLayer][iVO].uiLowDelay = pArgs->rguiLowDelay [iLayer][iVO];
				m_rgvolmd [iLayer][iVO].uiVBVParams = pArgs->rguiVBVParams [iLayer][iVO];
				m_rgvolmd [iLayer][iVO].uiBitRate = pArgs->rguiBitRate [iLayer][iVO];
				m_rgvolmd [iLayer][iVO].uiVbvBufferSize = pArgs->rguiVbvBufferSize [iLayer][iVO];
				m_rgvolmd [iLayer][iVO].uiVbvBufferOccupany = pArgs->rguiVbvBufferOccupany [iLayer][iVO];
			}
			else
				m_rgvolmd [iLayer][iVO].uiVolControlParameters = 0;
			// END: Vol Control Parameters
			m_rgvolmd [iLayer][iVO].bRoundingControlDisable	= (iLayer== BASE_LAYER) ? pArgs->rgbRoundingControlDisable[iVO] : 0;
			m_rgvolmd [iLayer][iVO].iInitialRoundingType = (iLayer== BASE_LAYER) ? pArgs->rgiInitialRoundingType[iVO] : 0;
			m_rgvolmd [iLayer][iVO].bVPBitTh		= pArgs->rgbVPBitTh[iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bDataPartitioning = pArgs->rgbDataPartitioning [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bReversibleVlc  = pArgs->rgbReversibleVlc [iLayer][iVO];
//RESYNC_MARKER_FIX
			m_rgvolmd [iLayer][iVO].bResyncMarkerDisable = pArgs->rgbResyncMarkerDisable [iLayer][iVO];
//~RESYNC_MARKER_FIX
// RRV insertion
			m_rgvopmd [iLayer][iVO].RRVmode = pArgs->RRVmode[iLayer][iVO];
			m_rgvolmd [iLayer][iVO].breduced_resolution_vop_enable
				= pArgs->RRVmode[iLayer][iVO].iOnOff;
// ~RRV
			m_rgvolmd [iLayer][iVO].fQuantizer		= pArgs->rgfQuant [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bNoGrayQuantUpdate 
													= pArgs->rgbNoAlphaQuantUpdate [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].dFrameHz		= pArgs->rgdFrameFrequency [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].iMVRadiusPerFrameAwayFromRef = pArgs->rguiSearchRange [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].iSearchRangeForward	= pArgs->rguiSearchRange [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].iSearchRangeBackward= pArgs->rguiSearchRange [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].intStepI		= pArgs->rgiStepI [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].intStep			= pArgs->rgiStepP [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].intStepB		= pArgs->rgiStepB [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].intStepIAlpha[0]	= pArgs->rgiStepIAlpha [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].intStepPAlpha[0]	= pArgs->rgiStepPAlpha [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].intStepBAlpha[0]	= pArgs->rgiStepBAlpha [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].iIntraDcSwitchThr 
													= pArgs->rgiIntraDCSwitchingThr [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].bInterlace		= pArgs->rgbInterlacedCoding [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].bTopFieldFirst	= pArgs->rgbTopFieldFirst [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].bAlternateScan	= pArgs->rgbAlternateScan [iLayer][iVO];
			m_rgvopmd [iLayer][iVO].iDirectModeRadius = pArgs->rgiDirectModeRadius [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bLoadIntraMatrix= pArgs->rgbLoadIntraMatrix [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bLoadInterMatrix= pArgs->rgbLoadInterMatrix [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bLoadIntraMatrixAlpha 
													= pArgs->rgbLoadIntraMatrixAlpha [iLayer][iVO];
			m_rgvolmd [iLayer][iVO].bLoadInterMatrixAlpha 
													= pArgs->rgbLoadInterMatrixAlpha [iLayer][iVO];
			memcpy (m_rgvolmd [iLayer][iVO].rgiIntraQuantizerMatrix,		pArgs->rgppiIntraQuantizerMatrix [iLayer][iVO], BLOCK_SQUARE_SIZE * sizeof (Int));
			memcpy (m_rgvolmd [iLayer][iVO].rgiInterQuantizerMatrix,		pArgs->rgppiInterQuantizerMatrix [iLayer][iVO], BLOCK_SQUARE_SIZE * sizeof (Int));
			memcpy (m_rgvolmd [iLayer][iVO].rgiIntraQuantizerMatrixAlpha[0],	pArgs->rgppiIntraQuantizerMatrixAlpha [iLayer][iVO], BLOCK_SQUARE_SIZE * sizeof (Int));
			memcpy (m_rgvolmd [iLayer][iVO].rgiInterQuantizerMatrixAlpha[0],	pArgs->rgppiInterQuantizerMatrixAlpha [iLayer][iVO], BLOCK_SQUARE_SIZE * sizeof (Int));

			m_rgvolmd [iLayer][iVO].bDeblockFilterDisable 
													= pArgs->rgbDeblockFilterDisable [iVO];
			m_rgvolmd [iLayer][iVO].iBbetweenP	= pArgs->rgiNumOfBbetweenPVOP [iVO];
			m_rgvolmd [iLayer][iVO].iPbetweenI	= pArgs->rgiNumOfPbetweenIVOP [iVO];
			m_rgvolmd [iLayer][iVO].iGOVperiod = pArgs->rgiGOVperiod [iVO]; // count of o/p frames between govs
			// set up temporal sampling rate and clock rate from source frame rate.
			m_rgvolmd [iLayer][iVO].iTemporalRate	= pArgs->rgiTemporalRate [iVO]; // frames to skip
			Double dFrameHz = m_rgvolmd [iLayer][iVO].dFrameHz;
			// this code copes with e.g. 12.5 fps and 29.97 fps by multiplying up the ticks per second
			// count appropriately
			Int iClockRate = (int)dFrameHz;
			if(dFrameHz != (double)iClockRate)
			{
				iClockRate = (int)(dFrameHz * 10.0);
				if(dFrameHz * 10.0 != (double)iClockRate)
					iClockRate = (int)(dFrameHz * 100.0);	 // not much point going to 1000*
			}
			m_rgvolmd [iLayer][iVO].iClockRate = iClockRate;

			m_rgvolmd [iLayer][iVO].bDumpMB			= pArgs->rgbDumpMB [iVO];
			m_rgvolmd [iLayer][iVO].bTrace			= pArgs->rgbTrace [iVO];
			m_rgvolmd [iLayer][iVO].bTemporalScalability = FALSE;
			m_rgvolmd [iLayer][iVO].bSpatialScalability = m_rgbSpatialScalability[iVO];		//OBSS_SAIT_991015 //OBSS
			m_rgvolmd [iLayer][iVO].iHierarchyType = 0;										//OBSSFIX_V2-8
			if(m_rgvolmd[iLayer][iVO].volType == ENHN_LAYER && m_rgbSpatialScalability [iVO] && pArgs->rgiTemporalRate[iVO] == pArgs->rgiEnhcTemporalRate[iVO]){
				// modified by Sharp (98/02/09)
//#ifdef _Scalable_SONY_
				m_rgvolmd[iLayer][iVO].iHierarchyType = 0; //iHierarchyType 0 means spatial scalability
//#endif _Scalable_SONY_
				m_rgvolmd[iLayer][iVO].iEnhnType = 0; // Spatial Scalable Enhancement layer shuold be set to Rectangular shape
				m_rgvolmd[iLayer][iVO].iSpatialOption = pArgs->iSpatialOption; // This Option is for Spatial Scalable
				m_rgvolmd[iLayer][iVO].iver_sampling_factor_n = pArgs->uiVer_sampling_n;
				m_rgvolmd[iLayer][iVO].iver_sampling_factor_m = pArgs->uiVer_sampling_m;
				m_rgvolmd[iLayer][iVO].ihor_sampling_factor_n = pArgs->uiHor_sampling_n;
				m_rgvolmd[iLayer][iVO].ihor_sampling_factor_m = pArgs->uiHor_sampling_m;
//OBSS_SAIT_991015
				m_rgvolmd[iLayer][iVO].iEnhnTypeSpatial = 0;		//for OBSS partial enhancement mode
				m_rgvolmd[iLayer][iVO].iFrmWidth_SS = pArgs->uiFrameWidth_SS;
				m_rgvolmd[iLayer][iVO].iFrmHeight_SS = pArgs->uiFrameHeight_SS;
//OBSSFIX_MODE3
				if(iLayer == ENHN_LAYER && m_rgvolmd[0][iVO].fAUsage == RECTANGLE &&
					m_rgvolmd[iLayer][iVO].iHierarchyType == 0 && pArgs->rgiEnhancementTypeSpatial[iVO] != 0){
					m_rgvolmd[iLayer][iVO].iEnhnType = pArgs->rgiEnhancementTypeSpatial[iVO]; //for OBSS partial enhancement mode
					m_rgvolmd[iLayer][iVO].iEnhnTypeSpatial = pArgs->rgiEnhancementTypeSpatial[iVO]; //for OBSS partial enhancement mode
					m_rgvolmd[iLayer][iVO].fAUsage   = ONE_BIT;
				}
//~OBSSFIX_MODE3
				if(	m_rgvolmd [iLayer][iVO].fAUsage	== ONE_BIT && m_rgvolmd[iLayer][iVO].iHierarchyType ==0 ) {
					//for OBSS partial enhancement mode
//OBSSFIX_MODE3
					m_rgvolmd[iLayer][iVO].iEnhnTypeSpatial = pArgs->rgiEnhancementTypeSpatial [iVO];
					m_rgvolmd[iLayer][iVO].iEnhnType = pArgs->rgiEnhancementTypeSpatial [iVO]; 
//~OBSSFIX_MODE3
					m_rgvolmd[iLayer][iVO].iuseRefShape = pArgs->uiUse_ref_shape; 
					m_rgvolmd[iLayer][iVO].iuseRefTexture = pArgs->uiUse_ref_texture; 
					m_rgvolmd[iLayer][iVO].iver_sampling_factor_n_shape = pArgs->uiVer_sampling_n_shape;
					m_rgvolmd[iLayer][iVO].iver_sampling_factor_m_shape = pArgs->uiVer_sampling_m_shape;
					m_rgvolmd[iLayer][iVO].ihor_sampling_factor_n_shape = pArgs->uiHor_sampling_n_shape;
					m_rgvolmd[iLayer][iVO].ihor_sampling_factor_m_shape = pArgs->uiHor_sampling_m_shape;
				}
//~OBSS_SAIT_991015
			} 
// begin: added by Sharp (98/2/12)
			else if (m_rgbSpatialScalability [iVO] && pArgs->rgiTemporalRate[iVO] != pArgs->rgiEnhcTemporalRate[iVO]){
				m_rgvolmd [iLayer][iVO].bTemporalScalability = TRUE;
//#ifdef _Scalable_SONY_
				m_rgvolmd[iLayer][iVO].iHierarchyType = 1; //iHierarchyType 1 means temporal scalability
//#endif _Scalable_SONY_
				m_rgvolmd [iLayer][iVO].iEnhnType	= pArgs->rgiEnhancementType [iVO];
				if ( pArgs->rgiEnhancementType[iVO] != 0 ) // modified by Sharp (98/3/24)
					m_rgvolmd [BASE_LAYER][iVO].fAUsage = RECTANGLE;
				if ( iLayer == ENHN_LAYER ) {
					m_rgvolmd [ENHN_LAYER][iVO].iTemporalRate	= pArgs->rgiEnhcTemporalRate [iVO];
					Double dFrameHz = m_rgvolmd [ENHN_LAYER][iVO].dFrameHz;
					// this code copes with e.g. 12.5 fps and 29.97 fps by multiplying up the ticks per second
					// count appropriately
					Int iClockRate = (int)dFrameHz;
					if(dFrameHz != (double)iClockRate)
					{
						iClockRate = (int)(dFrameHz * 10.0);
						if(dFrameHz * 10.0 != (double)iClockRate)
							iClockRate = (int)(dFrameHz * 100.0);	 // not much point going to 1000*
					}
					m_rgvolmd [ENHN_LAYER][iVO].iClockRate = iClockRate;
				}
				m_rgvolmd[iLayer][iVO].iver_sampling_factor_n = 1;
				m_rgvolmd[iLayer][iVO].iver_sampling_factor_m = 1;
				m_rgvolmd[iLayer][iVO].ihor_sampling_factor_n = 1;
				m_rgvolmd[iLayer][iVO].ihor_sampling_factor_m = 1;
			}
// end: added by Sharp (98/2/12)
			else {
				m_rgvolmd[iLayer][iVO].iver_sampling_factor_n = 1;
				m_rgvolmd[iLayer][iVO].iver_sampling_factor_m = 1;
				m_rgvolmd[iLayer][iVO].ihor_sampling_factor_n = 1;
				m_rgvolmd[iLayer][iVO].ihor_sampling_factor_m = 1;
			}
		}
	}
	static Char pchYUV [100], pchSeg [100];
	// check whether there are data for separate layers
	sprintf (pchYUV, ROOT_YUVFILE, m_pchBmpFiles, m_pchPrefix);
	sprintf (pchSeg, ROOT_SEGFILE, m_pchBmpFiles, m_pchPrefix);
	m_bTexturePerVOP = !fileExistence (pchYUV);
	m_bAlphaPerVOP = !fileExistence (pchSeg);
	m_bPrevObjectExists = FALSE; // added by Sharp (98/2/13)

	// sprite info
	m_ppstSrc = new CSiteD* [m_iNumVO];
	m_pppstDst = new CSiteD** [m_iNumVO];
	for (iVO = 0; iVO < m_iNumVO; iVO++) {
		m_ppstSrc [iVO] = (m_rgNumOfPnts [iVO] > 0) ? new CSiteD [m_rgNumOfPnts [iVO]] : NULL;
		m_pppstDst [iVO] = new CSiteD* [m_iNumFrame];
		for (Int ifr = 0; ifr < m_iNumFrame; ifr++) {
			m_pppstDst [iVO] [ifr] = 
				(m_rgNumOfPnts [iVO] > 0) ? new CSiteD [m_rgNumOfPnts [iVO]] : 
				NULL;
		}
	}
	for (iVO = m_iFirstVO; iVO <= m_iLastVO; iVO++)
		if (m_rguiSpriteUsage[iVO - m_iFirstVO] == 1 && m_rgNumOfPnts [iVO - m_iFirstVO] > 0) // GMC
				readPntFile (iVO);

    m_SptMode =	pArgs->pSpriteMode[0];
	m_rgiMVFileUsage = pArgs->rgiMVFileUsage;
	m_pchMVFileName  = pArgs->pchMVFileName;
}

Void CSessionEncoder::encode ()
{
	FILE* pfYuvSrc = NULL;
	FILE* pfYuvSrcSpatialEnhn = NULL;
	FILE* pfSegSrc = NULL;
	FILE* rgpfReconYUV [2];
	FILE* rgpfReconSeg [2];
	Int iVO;
	UInt iVOrelative = 0;
//OBSS_SAIT_991015
	FILE* pfSegSrcSpatialEnhn = NULL;	
	static CRct pBase_stack_rctBase;
	static ShapeMode* pBase_stack_Baseshpmd = NULL;
	static CMotionVector* pBase_stack_mvBaseBY = NULL;	
	static ShapeMode* pBase_tmp_Baseshpmd = NULL;
	static CMotionVector* pBase_tmp_mvBaseBY = NULL;	
	static Int iBase_stack_x, iBase_stack_y;
//~OBSS_SAIT_991015

// begin: added by Sharp (98/2/12)
	Bool bTemporalScalability = m_rgvolmd[BASE_LAYER][0].bTemporalScalability;
//	Bool bTemporalScalability = TRUE;

	// for a buffer management of temporal scalability
	CEnhcBufferEncoder* pBufP1 = NULL;
	CEnhcBufferEncoder* pBufP2 = NULL;
	CEnhcBufferEncoder* pBufB1 = NULL;
	CEnhcBufferEncoder* pBufB2 = NULL;
	CEnhcBufferEncoder* pBufE = NULL;

	// for backward/forward shape
	Void set_modes(VOLMode* volmd, VOPMode* vopmd);
	VOLMode* volmd_backShape = NULL;
	VOLMode* volmd_forwShape = NULL;
	VOPMode* vopmd_backShape = NULL;
	VOPMode* vopmd_forwShape = NULL;

	if ( bTemporalScalability ){
		pBufP1 = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
		pBufP2 = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
		pBufB1 = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
		pBufB2 = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
		pBufE  = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());

		volmd_backShape = new VOLMode;
		volmd_forwShape = new VOLMode;
		vopmd_backShape = new VOPMode;
		vopmd_forwShape = new VOPMode;
		set_modes(volmd_backShape, vopmd_backShape);
		set_modes(volmd_forwShape, vopmd_forwShape);
	}
// end: added by Sharp (98/2/12)
	FILE** ppfAuxSrc = NULL;
	FILE** rgpfReconAux[2];
	rgpfReconAux[0] = rgpfReconAux[1] = NULL;