vopses.cpp

网络MPEG4IP流媒体开发源代码

			(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)
{
	PixelC* ppxlcLeftTop = ppxlcOldLeft - EXPANDY_REFVOP * m_iFrameWidthY - EXPANDY_REFVOP;
		// point to the left top of the expanded bounding box (+- EXPANDY_REFVOP)
	const PixelC* ppxlcOldRight = ppxlcOldLeft + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth:m_rctPrevNoExpandY.width) - 1; // modified by Sharp (99/1/14)
		// point to the right-top of the bounding box
	const PixelC* ppxlcOldTopLn = ppxlcOldLeft - EXPANDY_REFVOP;
		// point to the (left, top) - EXPANDY_REFVOP
	PixelC* ppxlcNewLeft = (PixelC*) ppxlcOldTopLn;
	PixelC* ppxlcNewRight = (PixelC*) ppxlcOldRight + 1;
	CoordI y;

	// begin:  modified by Sharp (99/1/14)
	Int PrevNoExpandY_height = (m_volmd.fAUsage == RECTANGLE)?m_ivolHeight:m_rctPrevNoExpandY.height ();
	for (y = 0; y < PrevNoExpandY_height; y++) { // x-direction interpolation
	// end: modified by Sharp
		for (Int i=0; i<EXPANDY_REFVOP; i++) {
			ppxlcNewLeft[i] = *ppxlcOldLeft;
			ppxlcNewRight[i] = *ppxlcOldRight;
		}
		ppxlcNewLeft += pvopcRef->whereY ().width;		
		ppxlcNewRight += pvopcRef->whereY ().width;
		ppxlcOldLeft += pvopcRef->whereY ().width;
		ppxlcOldRight += pvopcRef->whereY ().width;
	}
	/* commented out due to fact of no field padding now
	// Added for field based unrestricted MC padding by Hyundai(1998-5-9)
        if (m_vopmd.bInterlace) {      
		Int 	iUnit = sizeof (PixelC); 
                Int     width = pvopcRef->whereY ().width;
                Int     iFieldSkip = 2*width;
                Int     iPadArea = (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*iUnit;
                const PixelC
                        *ppxlcSrcTopFieldLn1 = ppxlcOldTopLn,
                        *ppxlcSrcTopFieldLn2 = ppxlcNewLeft  - iFieldSkip,
                        *ppxlcSrcBotFieldLn1 = ppxlcOldTopLn + width,
                        *ppxlcSrcBotFieldLn2 = ppxlcNewLeft  - width;
                PixelC  *ppxlcDstTopFieldLn1 = ppxlcLeftTop,
                        *ppxlcDstTopFieldLn2 = ppxlcNewLeft,
                        *ppxlcDstBotFieldLn1 = ppxlcLeftTop + width,
                        *ppxlcDstBotFieldLn2 = ppxlcNewLeft + width;
                for (y = 0; y < EXPANDY_REFVOP/2; y++) {
                        memcpy (ppxlcDstTopFieldLn1, ppxlcSrcTopFieldLn1, iPadArea);
                        memcpy (ppxlcDstTopFieldLn2, ppxlcSrcTopFieldLn2, iPadArea);
                        memcpy (ppxlcDstBotFieldLn1, ppxlcSrcBotFieldLn1, iPadArea);
                        memcpy (ppxlcDstBotFieldLn2, ppxlcSrcBotFieldLn2, iPadArea);
                        ppxlcDstTopFieldLn1 += iFieldSkip;
                        ppxlcDstTopFieldLn2 += iFieldSkip;
                        ppxlcDstBotFieldLn1 += iFieldSkip;
                        ppxlcDstBotFieldLn2 += iFieldSkip;
                }
                return;
        }
	// End of Hyundai(1998-5-9)
	*/

	const PixelC* ppxlcOldBotLn = ppxlcNewLeft - pvopcRef->whereY ().width;
	for (y = 0; y < EXPANDY_REFVOP; y++) {
		memcpy (ppxlcLeftTop, ppxlcOldTopLn, (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*sizeof(PixelC));
		memcpy (ppxlcNewLeft, ppxlcOldBotLn, (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*sizeof(PixelC));
		ppxlcNewLeft += pvopcRef->whereY ().width;
		ppxlcLeftTop += pvopcRef->whereY ().width;
	}
}

Void CVideoObject::repeatPadUV (CVOPU8YUVBA* pvopcRef)
{
	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 - EXPANDUV_REFVOP * m_iFrameWidthUV - EXPANDUV_REFVOP;
	PixelC* ppxlcLeftTopV = (PixelC*) ppxlcOldLeftV - EXPANDUV_REFVOP * m_iFrameWidthUV - EXPANDUV_REFVOP;
		// point to the left top of the expanded bounding box (+- EXPANDY_REFVOP)
	const PixelC* ppxlcOldRightU = ppxlcOldLeftU + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth/2:m_rctPrevNoExpandUV.width) - 1; // modified by Sharp (99/1/14)
	const PixelC* ppxlcOldRightV = ppxlcOldLeftV + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth/2:m_rctPrevNoExpandUV.width) - 1; // modified by Sharp (99/1/14)
		// point to the right-top of the bounding box
	const PixelC* ppxlcOldTopLnU = ppxlcOldLeftU - EXPANDUV_REFVOP;
	const PixelC* ppxlcOldTopLnV = ppxlcOldLeftV - EXPANDUV_REFVOP;
		// point to the (left, top) - EXPANDY_REFVOP
	PixelC* ppxlcNewLeftU = (PixelC*) ppxlcOldTopLnU;
	PixelC* ppxlcNewLeftV = (PixelC*) ppxlcOldTopLnV;
	PixelC* ppxlcNewRightU = (PixelC*) ppxlcOldRightU + 1;
	PixelC* ppxlcNewRightV = (PixelC*) ppxlcOldRightV + 1;
	
	CoordI y;
	// begin:  modified by Sharp (99/1/14)
	Int PrevNoExpandUV_height = (m_volmd.fAUsage == RECTANGLE)?m_ivolHeight/2:m_rctPrevNoExpandUV.height ();
	for (y = 0; y < PrevNoExpandUV_height; y++) { // x-direction interpolation
	// end:  modified by Sharp (99/1/14)
		for (Int i=0; i<EXPANDUV_REFVOP; i++) {
			ppxlcNewLeftU[i] = *ppxlcOldLeftU;
			ppxlcNewLeftV[i] = *ppxlcOldLeftV;
			ppxlcNewRightU[i] = *ppxlcOldRightU;
			ppxlcNewRightV[i] = *ppxlcOldRightV;
		}
		
		ppxlcNewLeftU += pvopcRef->whereUV ().width;		
		ppxlcNewLeftV += pvopcRef->whereUV ().width;		
		ppxlcNewRightU += pvopcRef->whereUV ().width;
		ppxlcNewRightV += pvopcRef->whereUV ().width;
		ppxlcOldLeftU += pvopcRef->whereUV ().width;
		ppxlcOldLeftV += pvopcRef->whereUV ().width;
		ppxlcOldRightU += pvopcRef->whereUV ().width;
		ppxlcOldRightV += pvopcRef->whereUV ().width;
	}
	/* no longer any field based padding
	// Added for field based unrestricted MC padding by Hyundai(1998-5-9)
        if (m_vopmd.bInterlace) {
		Int	iUnit = sizeof(PixelC);
                Int     width = pvopcRef->whereUV ().width;
                Int     iFieldSkip = 2*width;
                Int     iPadArea = (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*iUnit;
                const PixelC 
                        *ppxlcSrcTopFieldLn1U = ppxlcOldTopLnU,
                        *ppxlcSrcTopFieldLn2U = ppxlcNewLeftU  - iFieldSkip,
                        *ppxlcSrcBotFieldLn1U = ppxlcOldTopLnU + width,
                        *ppxlcSrcBotFieldLn2U = ppxlcNewLeftU  - width,
                        *ppxlcSrcTopFieldLn1V = ppxlcOldTopLnV,
                        *ppxlcSrcTopFieldLn2V = ppxlcNewLeftV  - iFieldSkip,
                        *ppxlcSrcBotFieldLn1V = ppxlcOldTopLnV + width,
                        *ppxlcSrcBotFieldLn2V = ppxlcNewLeftV  - width;
                PixelC  *ppxlcDstTopFieldLn1U = ppxlcLeftTopU,
                        *ppxlcDstTopFieldLn2U = ppxlcNewLeftU,
                        *ppxlcDstBotFieldLn1U = ppxlcLeftTopU + width,
                        *ppxlcDstBotFieldLn2U = ppxlcNewLeftU + width,
                        *ppxlcDstTopFieldLn1V = ppxlcLeftTopV,
                        *ppxlcDstTopFieldLn2V = ppxlcNewLeftV,
                        *ppxlcDstBotFieldLn1V = ppxlcLeftTopV + width,
                        *ppxlcDstBotFieldLn2V = ppxlcNewLeftV + width;
                for (y = 0; y < EXPANDUV_REFVOP/2; y++) {
                        memcpy (ppxlcDstTopFieldLn1U, ppxlcSrcTopFieldLn1U, iPadArea);
                        memcpy (ppxlcDstTopFieldLn2U, ppxlcSrcTopFieldLn2U, iPadArea);
                        memcpy (ppxlcDstBotFieldLn1U, ppxlcSrcBotFieldLn1U, iPadArea);
                        memcpy (ppxlcDstBotFieldLn2U, ppxlcSrcBotFieldLn2U, iPadArea);
                        memcpy (ppxlcDstTopFieldLn1V, ppxlcSrcTopFieldLn1V, iPadArea);
                        memcpy (ppxlcDstTopFieldLn2V, ppxlcSrcTopFieldLn2V, iPadArea);
                        memcpy (ppxlcDstBotFieldLn1V, ppxlcSrcBotFieldLn1V, iPadArea);
                        memcpy (ppxlcDstBotFieldLn2V, ppxlcSrcBotFieldLn2V, iPadArea);
                        ppxlcDstTopFieldLn1U += iFieldSkip;
                        ppxlcDstTopFieldLn2U += iFieldSkip;
                        ppxlcDstBotFieldLn1U += iFieldSkip;
                        ppxlcDstBotFieldLn2U += iFieldSkip;
                        ppxlcDstTopFieldLn1V += iFieldSkip;
                        ppxlcDstTopFieldLn2V += iFieldSkip;
                        ppxlcDstBotFieldLn1V += iFieldSkip;
                        ppxlcDstBotFieldLn2V += iFieldSkip;
                }
                return;
        }
	// End of Hyundai(1998-5-9)
	*/

	const PixelC* ppxlcOldBotLnU = ppxlcNewLeftU - pvopcRef->whereUV ().width;
	const PixelC* ppxlcOldBotLnV = ppxlcNewLeftV - pvopcRef->whereUV ().width;
	for (y = 0; y < EXPANDUV_REFVOP; y++) {
		memcpy (ppxlcLeftTopU, ppxlcOldTopLnU, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
		memcpy (ppxlcLeftTopV, ppxlcOldTopLnV, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
		memcpy (ppxlcNewLeftU, ppxlcOldBotLnU, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
		memcpy (ppxlcNewLeftV, ppxlcOldBotLnV, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
		ppxlcNewLeftU += pvopcRef->whereUV ().width;
		ppxlcNewLeftV += pvopcRef->whereUV ().width;
		ppxlcLeftTopU += pvopcRef->whereUV ().width;
		ppxlcLeftTopV += pvopcRef->whereUV ().width;
	}
}

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

Void CVideoObject::resetBYPlane ()
{
	if (m_vopmd.vopPredType == PVOP || m_vopmd.vopPredType == IVOP) {
		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);

	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,
													EXPANDY_REF_FRAME,
													EXPANDUV_REF_FRAME);
	if(m_vopmd.vopPredType == PVOP) {
		m_rctRefVOPY0 = m_rctRefVOPY1;
		swapVOPU8Pointers (m_pvopcRefQ0,pvopcUpSampled);
		m_pvopcRefQ0->setBoundRct(m_rctRefVOPY0);
		delete pvopcUpSampled;
	}
	else if(m_vopmd.vopPredType == BVOP){
		CRct tmp;
		tmp = m_rctRefVOPY0;
		m_rctRefVOPY0 = m_rctRefVOPY1;
		m_rctRefVOPY1 = tmp;
		swapVOPU8Pointers (m_pvopcRefQ0,m_pvopcRefQ1);
		swapVOPU8Pointers (m_pvopcRefQ1,pvopcUpSampled);
		m_pvopcRefQ0->setBoundRct(m_rctRefVOPY0);
		m_pvopcRefQ1->setBoundRct(m_rctRefVOPY1);
		delete pvopcUpSampled;
	}
}

Void CVideoObject::swapVOPU8Pointers (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1)
{
	CVOPU8YUVBA* pvopcTmp = pvopc0;
	pvopc0 = pvopc1;
	pvopc1 = pvopcTmp;
}

Void CVideoObject::swapVOPIntPointers (CVOPIntYUVBA*& pvopi0, CVOPIntYUVBA*& pvopi1)
{
	CVOPIntYUVBA* pvopiTmp = pvopi0;
	pvopi0 = pvopi1;
	pvopi1 = pvopiTmp;
}

Void CVideoObject::setRefStartingPointers ()
{
	m_iStartInRefToCurrRctY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
	m_iStartInRefToCurrRctUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
}

const CVOPU8YUVBA* CVideoObject::pvopcReconCurr () const
{
	if (m_vopmd.vopPredType == SPRITE && m_iNumOfPnts > 0)
		return m_pvopcCurrQ;
	else if (m_vopmd.vopPredType == SPRITE && m_iNumOfPnts == 0) {
		if (m_sptMode != BASIC_SPRITE) 
			return m_pvopcSptQ;
		else 
			return m_pvopcRefQ1;
	}
	else if ((m_vopmd.vopPredType == BVOP && m_volmd.volType == BASE_LAYER) 
			 ||(m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode != 0))
		return m_pvopcCurrQ;
	else
		return m_pvopcRefQ1;
}
////////// 97/12/22 start
Void CVideoObject::compute_bfShapeMembers ()
{
	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 = 5 * m_iNumMBX;
//  wchen: changed to const as discussed with Bob.
	m_iNumOfTotalMVPerRow = PVOP_MV_PER_REF_PER_MB * m_iNumMBX;
}

Void CVideoObject::copyVOPU8YUVBA(CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1)
{
	delete pvopc0;  pvopc0 = NULL;
	pvopc0 = new CVOPU8YUVBA (*pvopc1);	/* i.e. pvopc0 = pvopc1; */
}

Void CVideoObject::copyVOPU8YUVBA(CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1, CVOPU8YUVBA*& pvopc2)
{
	delete pvopc0;  pvopc0 = NULL;
	pvopc0 = (pvopc1 != NULL) ?
		new CVOPU8YUVBA (*pvopc1) : new CVOPU8YUVBA (*pvopc2);
}
///// 97/12/22 end

Void dumpNonCodedFrame(FILE* pfYUV, FILE* pfSeg, CRct& rct, UInt nBits)
{
	Int iW = rct.width;
	Int iH = rct.height();
	Int i;
	PixelC pxlcVal = 1<<(nBits-1);

	PixelC *ppxlcPix = new PixelC [iW];

	pxlcmemset(ppxlcPix, pxlcVal, iW);
	for(i=0; i<iH; i++) // Y
		fwrite(ppxlcPix, sizeof(PixelC), iW, pfYUV);
	for(i=0; i<iH; i++) // UV
		fwrite(ppxlcPix, sizeof(PixelC), iW>>1, pfYUV);
	if(pfSeg!=NULL)
	{
		pxlcmemset(ppxlcPix, 0, iW);
		for(i=0; i<iH; i++) // A
			fwrite(ppxlcPix, sizeof(PixelC), iW, pfSeg);
	}

	delete ppxlcPix;
}


/*BBM// Added for Boundary by Hyundai(1998-5-9)

Void CVideoObject::boundaryMacroBlockMerge (CMBMode* pmbmd)
{
        if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[2]) == PARTIAL) {
                pmbmd->m_bMerged[1] = checkMergedStatus (7, 8, 7, 0);
                if (pmbmd->m_bMerged[1]) {
                        pmbmd->m_rgTranspStatusBBM[2] = ALL;
                        overlayBlocks (7, 8, 7, 0, pmbmd->m_dctMd);