vopses.cpp

完整的RTP RTSP代码库

}

Void CVideoObject::computeVOLConstMembers ()
{
	m_iOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
	m_iOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
	m_rctPrevNoExpandY = m_rctCurrVOPY;
	m_rctPrevNoExpandUV = m_rctCurrVOPUV;
	m_iVOPWidthY = m_rctCurrVOPY.width;
	m_iVOPWidthUV = m_rctCurrVOPUV.width;
	m_iNumMBX = m_iNumMBXRef = m_iVOPWidthY / MB_SIZE; 
	m_iNumMBY = m_iNumMBYRef = m_rctCurrVOPY.height () / MB_SIZE;
	m_iNumMB = m_iNumMBRef = m_iNumMBX * m_iNumMBY;
	m_iNumOfTotalMVPerRow = PVOP_MV_PER_REF_PER_MB * m_iNumMBX;
	setRefStartingPointers ();
	m_pvopcCurrQ->setBoundRct (m_rctCurrVOPY);
	m_pvopcRefQ0->setBoundRct (m_rctRefVOPY0);
	m_pvopcRefQ1->setBoundRct (m_rctRefVOPY1);

	Int iMB, iBlk;
	Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 6+m_volmd.iAuxCompCount*4 : 6;
	m_rgblkmCurrMB = (const BlockMemory *)new BlockMemory [nBlk];

	m_rgpmbmAbove = new MacroBlockMemory* [m_iNumMBX];
	m_rgpmbmCurr  = new MacroBlockMemory* [m_iNumMBX];
	for (iMB = 0; iMB < m_iNumMBX; iMB++)	{
		m_rgpmbmAbove [iMB] = new MacroBlockMemory;
		m_rgpmbmAbove [iMB]->rgblkm = new BlockMemory [nBlk];
		m_rgpmbmCurr  [iMB] = new MacroBlockMemory;
		m_rgpmbmCurr  [iMB]->rgblkm = new BlockMemory [nBlk];
		for (iBlk = 0; iBlk < nBlk; iBlk++)	{
			(m_rgpmbmAbove [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
			(m_rgpmbmCurr  [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
		}
	}
}

Void CVideoObject::computeVOPMembers ()
{
	m_iVOPWidthY = m_rctCurrVOPY.width;
	m_iVOPWidthUV = m_rctCurrVOPUV.width;
	m_iNumMBX = m_iVOPWidthY / MB_SIZE; 
	m_iNumMBY = m_rctCurrVOPY.height () / MB_SIZE;
	m_iNumMB = m_iNumMBX * m_iNumMBY;
	m_iNumOfTotalMVPerRow = PVOP_MV_PER_REF_PER_MB * m_iNumMBX;

	Int iMB, iBlk;
	Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 6+m_volmd.iAuxCompCount*4 : 6;
	m_rgblkmCurrMB = (const BlockMemory *)new BlockMemory [nBlk];

	m_rgpmbmAbove = new MacroBlockMemory* [m_iNumMBX];
	m_rgpmbmCurr  = new MacroBlockMemory* [m_iNumMBX];
	for (iMB = 0; iMB < m_iNumMBX; iMB++)	{
		m_rgpmbmAbove [iMB] = new MacroBlockMemory;
		m_rgpmbmAbove [iMB]->rgblkm = new BlockMemory [nBlk];
		m_rgpmbmCurr  [iMB] = new MacroBlockMemory;
		m_rgpmbmCurr  [iMB]->rgblkm = new BlockMemory [nBlk];
		for (iBlk = 0; iBlk < nBlk; iBlk++)	{
			// BLOCK_SIZE*2-1 is 15 Ints for dc/ac prediction of coefficients
			(m_rgpmbmAbove [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
			(m_rgpmbmCurr  [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
		}
	}
}

Void CVideoObject::repeatPadYOrA (PixelC* ppxlcOldLeft, CVOPU8YUVBA* pvopcRef)
{
	Int iScale	= (m_vopmd.RRVmode.iOnOff == 1) ? (2) : (1);
	Int iExpand = EXPANDY_REFVOP * iScale;

	Int iStride = pvopcRef->whereY ().width;
	Int iOldWidth = (m_volmd.fAUsage == RECTANGLE) ? m_ivolWidth : m_rctPrevNoExpandY.width;
	Int iOldHeight = (m_volmd.fAUsage == RECTANGLE) ? m_ivolHeight : m_rctPrevNoExpandY.height();

	PixelC* ppxlcLeftTop = ppxlcOldLeft - iExpand * iStride - iExpand;
	Int iExpandR = iExpand + MB_SIZE * ((iOldWidth + MB_SIZE - 1)/MB_SIZE) - iOldWidth;
	Int iExpandB = iExpand + MB_SIZE * ((iOldHeight + MB_SIZE - 1)/MB_SIZE) - iOldHeight; // extra is added for non mb-multiple sizes
	Int iNewWidth = iExpand + iOldWidth + iExpandR;

	const PixelC* ppxlcOldRight = ppxlcOldLeft + iOldWidth - 1;
	const PixelC* ppxlcOldTopLn = ppxlcOldLeft - iExpand;

	PixelC* ppxlcNewLeft = (PixelC*) ppxlcOldTopLn;
	PixelC* ppxlcNewRight = (PixelC*) ppxlcOldRight + 1;
	CoordI y;
	Int i;

	for (y = 0; y < iOldHeight; y++) {
		for (i=0; i<iExpand; i++)
			ppxlcNewLeft[i] = *ppxlcOldLeft;
		for (i=0; i<iExpandR; i++)
			ppxlcNewRight[i] = *ppxlcOldRight;

		ppxlcNewLeft += iStride;		
		ppxlcNewRight += iStride;
		ppxlcOldLeft += iStride;
		ppxlcOldRight += iStride;
	}

	const PixelC* ppxlcOldBotLn = ppxlcNewLeft - iStride;
	for (y = 0; y < iExpand; y++) {
		memcpy (ppxlcLeftTop, ppxlcOldTopLn, iNewWidth * sizeof(PixelC));
		ppxlcLeftTop += iStride;
	}
	for (y = 0; y < iExpandB; y++) {	
		memcpy (ppxlcNewLeft, ppxlcOldBotLn, iNewWidth * sizeof(PixelC));
		ppxlcNewLeft += iStride;
	}
}

Void CVideoObject::repeatPadUV (CVOPU8YUVBA* pvopcRef)
{
	Int iScale	= (m_vopmd.RRVmode.iOnOff == 1) ? (2) : (1);
	Int iExpand = EXPANDUV_REFVOP * iScale;
	Int iStride = pvopcRef->whereUV ().width;
	Int iOldWidth = (m_volmd.fAUsage == RECTANGLE) ? m_ivolWidth/2 : m_rctPrevNoExpandUV.width;
	Int iOldHeight = (m_volmd.fAUsage == RECTANGLE) ? m_ivolHeight/2 : m_rctPrevNoExpandUV.height();
	Int iMBSize = MB_SIZE>>1;
	Int iExpandR = iExpand + iMBSize * ((iOldWidth + iMBSize - 1)/iMBSize) - iOldWidth;
	Int iExpandB = iExpand + iMBSize * ((iOldHeight + iMBSize - 1)/iMBSize) - iOldHeight; // extra is added for non mb-multiple sizes
	Int iNewWidth = iExpand + iOldWidth + iExpandR;

	const PixelC* ppxlcOldLeftU = pvopcRef->pixelsU () + m_iOffsetForPadUV; // point to the left-top of bounding box
	const PixelC* ppxlcOldLeftV = pvopcRef->pixelsV () + m_iOffsetForPadUV; // point to the left-top of bounding box

	PixelC* ppxlcLeftTopU = (PixelC*) ppxlcOldLeftU - iExpand * iStride - iExpand;
	PixelC* ppxlcLeftTopV = (PixelC*) ppxlcOldLeftV - iExpand * iStride - iExpand;

		// point to the left top of the expanded bounding box (+- EXPANDY_REFVOP)
	const PixelC* ppxlcOldRightU = ppxlcOldLeftU + iOldWidth - 1;
	const PixelC* ppxlcOldRightV = ppxlcOldLeftV + iOldWidth - 1;
		// point to the right-top of the bounding box

	const PixelC* ppxlcOldTopLnU = ppxlcOldLeftU - iExpand;
	const PixelC* ppxlcOldTopLnV = ppxlcOldLeftV - iExpand;

	PixelC* ppxlcNewLeftU = (PixelC*) ppxlcOldTopLnU;
	PixelC* ppxlcNewLeftV = (PixelC*) ppxlcOldTopLnV;
	PixelC* ppxlcNewRightU = (PixelC*) ppxlcOldRightU + 1;
	PixelC* ppxlcNewRightV = (PixelC*) ppxlcOldRightV + 1;
	
	CoordI y;
	for (y = 0; y < iOldHeight; y++) {
		Int i;
		for (i=0; i<iExpand; i++) {
			ppxlcNewLeftU[i] = *ppxlcOldLeftU;
			ppxlcNewLeftV[i] = *ppxlcOldLeftV;
		}
		for (i=0; i<iExpandR; i++) {
			ppxlcNewRightU[i] = *ppxlcOldRightU;
			ppxlcNewRightV[i] = *ppxlcOldRightV;
		}
		
		ppxlcNewLeftU += iStride;		
		ppxlcNewLeftV += iStride;		
		ppxlcNewRightU += iStride;
		ppxlcNewRightV += iStride;
		ppxlcOldLeftU += iStride;
		ppxlcOldLeftV += iStride;
		ppxlcOldRightU += iStride;
		ppxlcOldRightV += iStride;
	}

	const PixelC* ppxlcOldBotLnU = ppxlcNewLeftU - iStride;
	const PixelC* ppxlcOldBotLnV = ppxlcNewLeftV - iStride;
	for (y = 0; y < iExpand; y++) {
		memcpy (ppxlcLeftTopU, ppxlcOldTopLnU, iNewWidth * sizeof(PixelC));
		memcpy (ppxlcLeftTopV, ppxlcOldTopLnV, iNewWidth * sizeof(PixelC));
		ppxlcLeftTopU += iStride;
		ppxlcLeftTopV += iStride;
	}
	for (y = 0; y < iExpandB; y++) {
		memcpy (ppxlcNewLeftU, ppxlcOldBotLnU, iNewWidth * sizeof(PixelC));
		memcpy (ppxlcNewLeftV, ppxlcOldBotLnV, iNewWidth * sizeof(PixelC));
		ppxlcNewLeftU += iStride;
		ppxlcNewLeftV += iStride;
	}
//	pvopcRef->dump("bar.yuv");
}


Void CVideoObject::saveShapeMode()
{
	// called after reference frame encode/decode
	if(m_rgshpmd == NULL)
	{
		// first time
		m_iRefShpNumMBX = m_iNumMBX;
		m_iRefShpNumMBY = m_iNumMBY;
		m_rgshpmd = new ShapeMode [m_iNumMB];
	}
	else
	{
		// update if changed
		if(m_iRefShpNumMBX!=m_iNumMBXRef || m_iRefShpNumMBY != m_iNumMBYRef)
		{
			delete [] m_rgshpmd;
			m_rgshpmd = new ShapeMode [m_iNumMBRef];
			m_iRefShpNumMBX = m_iNumMBXRef;
			m_iRefShpNumMBY = m_iNumMBYRef;
		}
		// copy shape mode from previous ref to save
		Int i;
		for (i=0; i<m_iNumMBRef; i++ )
			m_rgshpmd[i] = m_rgmbmdRef[i].m_shpmd;
	}
}

//OBSS_SAIT_991015
Void CVideoObject::saveBaseShapeMode()
{
	// called after reference frame encode/decode
	if(m_rgBaseshpmd == NULL){
		// first time
		m_iNumMBBaseXRef = m_iNumMBX;					
		m_iNumMBBaseYRef = m_iNumMBY;					

		// save current shape mode for enhancement layer shape mode coding
		if(m_volmd.volType == BASE_LAYER) {										
			m_rgBaseshpmd = new ShapeMode [m_iNumMB];

			// first time
			m_iRefShpNumMBX = m_iNumMBX;
			m_iRefShpNumMBY = m_iNumMBY;
			
			Int i;
			Int iMBX, iMBY;
			for (iMBY=0, i=0; iMBY<m_iNumMBY; iMBY++ ) {
				for (iMBX=0; iMBX<m_iNumMBX; iMBX++ ) {
					m_rgBaseshpmd[i] = m_rgmbmd[i].m_shpmd;
					i++;
				}
			}
		}
	} else {
		// update if changed
		if(m_volmd.volType == BASE_LAYER) {				
			//for save lower layer shape mode
			if(m_iNumMBBaseXRef!=m_iNumMBX || m_iNumMBBaseYRef != m_iNumMBY){
				delete [] m_rgBaseshpmd;
				m_rgBaseshpmd = new ShapeMode [m_iNumMB];
				m_iNumMBBaseXRef = m_iNumMBX;		
				m_iNumMBBaseYRef = m_iNumMBY;		
			}
			Int i=0;
			Int iMBX, iMBY;
			for (iMBY=0, i=0; iMBY<m_iNumMBY; iMBY++ ){ 
				for (iMBX=0; iMBX<m_iNumMBX; iMBX++ ){
						m_rgBaseshpmd[i] = m_rgmbmd[i].m_shpmd;
						i++;
				}
			}
			m_iNumMBBaseXRef = m_iNumMBX;					
			m_iNumMBBaseYRef = m_iNumMBY;					
			//for save lawer layer shape mode
		}	
	}
}
//~OBSS_SAIT_991015

Void CVideoObject::resetBYPlane ()
{
	if (m_vopmd.vopPredType == PVOP || m_vopmd.vopPredType == IVOP || (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE)) { // GMC
		PixelC* ppxlcBY = (PixelC*) m_pvopcRefQ1->pixelsBY ();
		memset (ppxlcBY, 0, m_pvopcRefQ1->whereY().area() * sizeof(PixelC));
	}
	else {
		PixelC* ppxlcBY = (PixelC*) m_pvopcCurrQ->pixelsBY ();
		memset (ppxlcBY, 0, m_pvopcCurrQ->whereY().area() * sizeof(PixelC));
	}
}

Void CVideoObject::updateAllRefVOPs ()
// perform this after VOP prediction type decided and before encoding
{
	if (m_vopmd.vopPredType != BVOP) {
		m_rctRefVOPY0 = m_rctRefVOPY1;
		swapVOPU8Pointers (m_pvopcRefQ0, m_pvopcRefQ1);
	}
}

// for spatial scalability
Void CVideoObject::updateAllRefVOPs (const CVOPU8YUVBA* pvopcRefBaseLayer)
{
	CVOPU8YUVBA *pvopcUpSampled = NULL;
	//	Int fEnhancementLayer = 0;

	assert (m_volmd.volType == ENHN_LAYER);
//OBSS_SAIT_991015
	pvopcUpSampled = pvopcRefBaseLayer->upsampleForSpatialScalability (
													m_volmd.iver_sampling_factor_m,
													m_volmd.iver_sampling_factor_n,
													m_volmd.ihor_sampling_factor_m,
													m_volmd.ihor_sampling_factor_n,
													m_volmd.iver_sampling_factor_m_shape,
													m_volmd.iver_sampling_factor_n_shape,
													m_volmd.ihor_sampling_factor_m_shape,
													m_volmd.ihor_sampling_factor_n_shape,
													m_volmd.iFrmWidth_SS,				 
													m_volmd.iFrmHeight_SS,				 
													m_volmd.bShapeOnly,					 
													EXPANDY_REF_FRAME,
													EXPANDUV_REF_FRAME);
//~OBSS_SAIT_991015


	if(m_vopmd.vopPredType == PVOP || (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE)) { // GMC
//OBSS_SAIT_991015
		if(m_volmd.fAUsage == RECTANGLE) {
			m_rctRefVOPY0 = m_rctRefVOPY1;	
		}
//OBSSFIX__000323
		else if(m_volmd.bSpatialScalability && m_volmd.iHierarchyType == 0 && m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1){
//			m_rctRefVOPY0 = m_rctRefVOPY1;
			if(pvopcUpSampled->fAUsage() == RECTANGLE)
				m_rctRefVOPY0 = pvopcUpSampled->whereY();
			else{
				CRct tmp;
				tmp = m_rctBase;
				tmp.left = (int)((tmp.left) * (m_volmd.ihor_sampling_factor_n_shape)/(m_volmd.ihor_sampling_factor_m_shape));
				tmp.right = (int)((tmp.right) * (m_volmd.ihor_sampling_factor_n_shape)/(m_volmd.ihor_sampling_factor_m_shape));
				tmp.top = (int)((tmp.top) * (m_volmd.iver_sampling_factor_n_shape)/(m_volmd.iver_sampling_factor_m_shape));
				tmp.bottom = (int)((tmp.bottom) * (m_volmd.iver_sampling_factor_n_shape)/(m_volmd.iver_sampling_factor_m_shape));
				tmp.width = tmp.right - tmp.left ;
				tmp.left -= 32; tmp.right += 32;
				tmp.top -= 32; tmp.bottom += 32;
				tmp.width += 64;
//OBSS_SAIT_FIX000524
				if(!( tmp <= pvopcUpSampled->whereY () )) {
					if(!(tmp.left >= (pvopcUpSampled->whereY ()).left))
						tmp.left = (pvopcUpSampled->whereY ()).left;
					if(!(tmp.top >= (pvopcUpSampled->whereY ()).top))
						tmp.top = (pvopcUpSampled->whereY ()).top;
					if(!(tmp.right <= (pvopcUpSampled->whereY ()).right))
						tmp.right = (pvopcUpSampled->whereY ()).right;
					if(!(tmp.bottom <= (pvopcUpSampled->whereY ()).bottom))
						tmp.bottom = (pvopcUpSampled->whereY ()).bottom;
				}
//~OBSS_SAIT_FIX000524
				m_rctRefVOPY0 = tmp;	// m_rctBase : BASE_LAYER RECT SIZE
			}
		}
//~OBSSFIX__000323
		else if(m_volmd.fAUsage == ONE_BIT) {		
			CRct tmp;
			tmp = m_rctBase;
			tmp.left = (int)((tmp.left) * (m_volmd.ihor_sampling_factor_n_shape)/(m_volmd.ihor_sampling_factor_m_shape));
			tmp.right = (int)((tmp.right) * (m_volmd.ihor_sampling_factor_n_shape)/(m_volmd.ihor_sampling_factor_m_shape));
			tmp.top = (int)((tmp.top) * (m_volmd.iver_sampling_factor_n_shape)/(m_volmd.iver_sampling_factor_m_shape));
			tmp.bottom = (int)((tmp.bottom) * (m_volmd.iver_sampling_factor_n_shape)/(m_volmd.iver_sampling_factor_m_shape));
			tmp.width = tmp.right - tmp.left ;

			tmp.left -= 32; tmp.right += 32;
			tmp.top -= 32; tmp.bottom += 32;
			tmp.width += 64;
//OBSS_SAIT_FIX000524
			if(!( tmp <= pvopcUpSampled->whereY () )) {
				if(!(tmp.left >= (pvopcUpSampled->whereY ()).left))
					tmp.left = (pvopcUpSampled->whereY ()).left;
				if(!(tmp.top >= (pvopcUpSampled->whereY ()).top))
					tmp.top = (pvopcUpSampled->whereY ()).top;
				if(!(tmp.right <= (pvopcUpSampled->whereY ()).right))
					tmp.right = (pvopcUpSampled->whereY ()).right;
				if(!(tmp.bottom <= (pvopcUpSampled->whereY ()).bottom))
					tmp.bottom = (pvopcUpSampled->whereY ()).bottom;
			}
//~OBSS_SAIT_FIX000524
			m_rctRefVOPY0 = tmp;	// m_rctBase : BASE_LAYER RECT SIZE
		}
//~OBSS_SAIT_991015

		swapVOPU8Pointers (m_pvopcRefQ0,pvopcUpSampled);
		m_pvopcRefQ0->setBoundRct(m_rctRefVOPY0);
		delete pvopcUpSampled;
	}
	else if(m_vopmd.vopPredType == BVOP){
		CRct tmp;
//OBSS_SAIT_991015
		if(m_volmd.fAUsage == RECTANGLE) {
			tmp = m_rctRefVOPY0; 
		}
//OBSSFIX_MODE3_02
		else if(m_volmd.bSpatialScalability && m_volmd.iHierarchyType == 0 && m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1){
//			tmp = pvopcUpSampled->whereY();
			if(pvopcUpSampled->fAUsage()==RECTANGLE)
				tmp = pvopcUpSampled->whereY();
			else{
				tmp = m_rctBase;
				tmp.left = (int)((tmp.left) * (m_volmd.ihor_sampling_factor_n_shape)/(m_volmd.ihor_sampling_factor_m_shape));
				tmp.right = (int)((tmp.right) * (m_volmd.ihor_sampling_factor_n_shape)/(m_volmd.ihor_sampling_factor_m_shape));
				tmp.top = (int)((tmp.top) * (m_volmd.iver_sampling_factor_n_shape)/(m_volmd.iver_sampling_factor_m_shape));
				tmp.bottom = (int)((tmp.bottom) * (m_volmd.iver_sampling_factor_n_shape)/(m_volmd.iver_sampling_factor_m_shape));
				tmp.width = tmp.right - tmp.left ;
				tmp.left -= 32; tmp.right += 32;
				tmp.top -= 32; tmp.bottom += 32;
				tmp.width += 64;
//OBSS_SAIT_FIX000524
				if(!( tmp <= pvopcUpSampled->whereY () )) {
					if(!(tmp.left >= (pvopcUpSampled->whereY ()).left))
						tmp.left = (pvopcUpSampled->whereY ()).left;
					if(!(tmp.top >= (pvopcUpSampled->whereY ()).top))
						tmp.top = (pvopcUpSampled->whereY ()).top;
					if(!(tmp.right <= (pvopcUpSampled->whereY ()).right))