sys_decoder_vopmbdec.cpp

完整的RTP RTSP代码库

			m_pvopcRefQ0->whereY ().width,
			m_pvopcRefQ0->whereUV ().width);
	}
	
	if (m_volmd.bNewpredEnable) {
		Int i;
		Int noStore_vop_id;
		
		g_pNewPredDec->SetQBuf( m_pvopcRefQ0, m_pvopcRefQ1 );
		for (i=0; i < g_pNewPredDec->m_iNumSlice; i++ ) {
			noStore_vop_id = g_pNewPredDec->make_next_decbuf(g_pNewPredDec->m_pNewPredControl, 
				g_pNewPredDec->GetCurrentVOP_id(), i);
		}
		
		// copy previous picture to reference picture memory because of output ordering
		for( int iSlice = 0; iSlice < g_pNewPredDec->m_iNumSlice; iSlice++ ) {
			int		iMBY = g_pNewPredDec->NowMBA(iSlice)/((g_pNewPredDec->getwidth())/MB_SIZE);
			PixelC* RefpointY = (PixelC*) m_pvopcRefQ0->pixelsY () + (m_iStartInRefToCurrRctY-EXPANDY_REF_FRAME) + iMBY * MB_SIZE * m_rctRefFrameY.width;
			PixelC* RefpointU = (PixelC*) m_pvopcRefQ0->pixelsU () + (m_iStartInRefToCurrRctUV-EXPANDUV_REF_FRAME) + iMBY * BLOCK_SIZE * m_rctRefFrameUV.width;
			PixelC* RefpointV = (PixelC*) m_pvopcRefQ0->pixelsV () + (m_iStartInRefToCurrRctUV-EXPANDUV_REF_FRAME) + iMBY * BLOCK_SIZE * m_rctRefFrameUV.width;
			g_pNewPredDec->CopyNPtoPrev(iSlice, RefpointY, RefpointU, RefpointV);	
		}
		repeatPadYOrA ((PixelC*) m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ0);
		repeatPadUV (m_pvopcRefQ0);
	}
}

Void CVideoObjectDecoder::decodeBVOP ()
{
	Int iMBX, iMBY;
	CoordI y = 0; 
	CMBMode* pmbmd = m_rgmbmd;
	CMBMode* pmbmdRef = m_rgmbmdRef;
	CMotionVector* pmv = m_rgmv;
	CMotionVector* pmvRef = m_rgmvRef;
	CMotionVector* pmvBackward = m_rgmvBackward;
	PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
	
	Int iCurrentQP  = m_vopmd.intStepB;
	//	Added for error resilient mode by Toshiba(1998-1-16:B-VOP+Error)
	Int	iVideoPacketNumber = 0;
	m_iVPMBnum = 0;
	
	if(m_bCodedFutureRef==FALSE)
	{
		pmbmdRef = NULL;
		pmvRef = NULL;
	}
	
	//	End Toshiba(1998-1-16:B-VOP+Error)
	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
		PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
		PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
		PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
		CoordI x = 0;
		m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
		m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
		m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
		m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
			if(!(m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0))
				pmbmd->m_bColocatedMBSkip = (pmbmdRef==NULL ? FALSE : pmbmdRef->m_bSkip);
			else
				pmbmd->m_bColocatedMBSkip = FALSE;
			// GMC
			if(!(m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0))
				pmbmd->m_bColocatedMBMCSEL = (pmbmdRef==NULL ? FALSE : pmbmdRef->m_bMCSEL); // GMC_V2
			else
				pmbmd->m_bColocatedMBMCSEL = FALSE;
			// ~GMC
			if ((pmbmd->m_bColocatedMBSkip  && !(pmbmd->m_bColocatedMBMCSEL)) && // GMC
				(m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
			{
				copyFromRefToCurrQ (
					m_pvopcRefQ0,
					x, y, 
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL
					);
				pmbmd->m_bSkip = TRUE;
				memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
				memset (pmvBackward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
				pmbmd->m_mbType = FORWARD; // can be set to FORWARD mode since the result is the same
			}
			else {
				if	(checkResyncMarker())	{
					decodeVideoPacketHeader(iCurrentQP);
					iVideoPacketNumber++;
					m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
					m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
					m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
					m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
				}
				pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;	//mv out of if by wchen to set even when errR is off; always used in mbdec 
				//	End Toshiba(1998-1-16:B-VOP+Error)
				decodeMBTextureHeadOfBVOP (pmbmd, iCurrentQP);
				decodeMVofBVOP (pmv, pmvBackward, pmbmd, iMBX, iMBY, pmvRef, pmbmdRef);
				if (!pmbmd->m_bSkip) {
					decodeTextureInterMB (pmbmd);
					// INTERLACE
					if (m_vopmd.bInterlace == TRUE && pmbmd->m_bFieldDCT == TRUE)
						fieldDCTtoFrameI(m_ppxliErrorMBY);
					// ~INTERLACE
					motionCompAndAddErrorMB_BVOP (
						pmv, pmvBackward,
						pmbmd, 
						iMBX, iMBY, 
						x, y,
						ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
						&m_rctRefVOPY0,&m_rctRefVOPY1);
				}
				else {
                    if (m_vopmd.bInterlace) {                       // Need to remove this 'if' (Bob Eifrig)
						assert(pmbmd->m_mbType == DIRECT);
						pmbmd->m_vctDirectDeltaMV.x = 0; 
						pmbmd->m_vctDirectDeltaMV.y = 0;
						memset (m_ppxliErrorMBY, 0, MB_SQUARE_SIZE * sizeof(Int));
						memset (m_ppxliErrorMBU, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
						memset (m_ppxliErrorMBV, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
						motionCompAndAddErrorMB_BVOP (
							pmv, pmvBackward,
							pmbmd, 
							iMBX, iMBY, 
							x, y,
							ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
							&m_rctRefVOPY0, &m_rctRefVOPY1);
                    } else {
						motionCompSkipMB_BVOP (pmbmd, pmv, pmvBackward,
							x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0, &m_rctRefVOPY1);
                    }
				}
			}
			
			if(m_bCodedFutureRef!=FALSE)
			{
				pmbmdRef++;
				pmvRef += PVOP_MV_PER_REF_PER_MB;
			}
			
			pmbmd++;
			pmv         += BVOP_MV_PER_REF_PER_MB;
			pmvBackward += BVOP_MV_PER_REF_PER_MB;
			ppxlcCurrQMBY += MB_SIZE;
			ppxlcCurrQMBU += BLOCK_SIZE;
			ppxlcCurrQMBV += BLOCK_SIZE;
		}
		ppxlcCurrQY += m_iFrameWidthYxMBSize;
		ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
		ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
	}
	if(m_volmd.bSpatialScalability && m_volmd.volType == ENHN_LAYER && m_volmd.fAUsage==ONE_BIT) {	// if SpatialScalability
		delete m_pvopcRefQ0->getPlane (BY_PLANE)->m_pbHorSamplingChk;
		delete m_pvopcRefQ0->getPlane (BY_PLANE)->m_pbVerSamplingChk;
	}
}

Void CVideoObjectDecoder::decodeBVOP_WithShape ()
{
	Int iMBX, iMBY;
	CoordI y = m_rctCurrVOPY.top; 
	CMBMode* pmbmd = m_rgmbmd;
    CMBMode* field_pmbmd = m_rgmbmd;
	CMotionVector* pmv = m_rgmv;
	CMotionVector* pmvBackward = m_rgmvBackward;
	CMotionVector* pmvBY = m_rgmvBY;
	if(m_volmd.volType == BASE_LAYER)  {	
		m_rgmvBaseBY = m_rgmvBY;
		m_rctBase = m_rctCurrVOPY;
	}
	Int xIndex, yIndex;
	xIndex = yIndex = 0;
	if(m_volmd.volType == ENHN_LAYER && m_volmd.bSpatialScalability) {
		xIndex = m_rctCurrVOPY.left - (m_rctBase.left*m_volmd.ihor_sampling_factor_n_shape/m_volmd.ihor_sampling_factor_m_shape);		
		yIndex = m_rctCurrVOPY.top - (m_rctBase.top*m_volmd.iver_sampling_factor_n_shape/m_volmd.iver_sampling_factor_m_shape);			
		xIndex /= MB_SIZE;
		yIndex /= MB_SIZE;
	}
	const CMotionVector* pmvRef;
	const CMBMode* pmbmdRef;
	
	PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcCurrQ->pixelsBY () + m_iStartInRefToCurrRctY;
	PixelC** pppxlcCurrQMBA = new PixelC* [m_volmd.iAuxCompCount];
	
	// decide prediction direction for shape
    if(m_bCodedFutureRef==FALSE){
		m_vopmd.fShapeBPredDir = B_FORWARD;
	}
    else if (m_volmd.volType == ENHN_LAYER && m_volmd.iHierarchyType == 0 && m_volmd.bSpatialScalability == 1 &&
		m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1){
        m_vopmd.fShapeBPredDir = B_FORWARD;
    }
    else{
		if(m_tFutureRef - m_t >= m_t - m_tPastRef)
			m_vopmd.fShapeBPredDir = B_FORWARD;
		else
			m_vopmd.fShapeBPredDir = B_BACKWARD;
	}
	
	Int iCurrentQP  = m_vopmd.intStepB;		
	Int iCurrentQPA[MAX_MAC];
	for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ )
		iCurrentQPA[iAuxComp] = m_vopmd.intStepBAlpha[iAuxComp];
	Int	iVideoPacketNumber = 0;
	m_iVPMBnum = 0;
	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
		PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
		PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
		PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
		PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
		CoordI x = m_rctCurrVOPY.left; 
		m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
		m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
		m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
		m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
		
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
			
			for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ ) { // MAC (SB) 1-Dec-99
				pppxlcCurrQMBA[iAuxComp] = (PixelC*) m_pvopcCurrQ->pixelsA (iAuxComp) + m_iStartInRefToCurrRctY
					+ iMBY*m_iFrameWidthYxMBSize + iMBX*MB_SIZE;
			}
			
			if	(checkResyncMarker())	{
				decodeVideoPacketHeader(iCurrentQP);
				iVideoPacketNumber++;
				m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
				m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
				m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
				m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
			}
			pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;	//mv out of if by wchen to set even when errR is off; always used in mbdec 
			pmbmd->m_bPadded=FALSE;
			findColocatedMB (iMBX, iMBY, pmbmdRef, pmvRef);
			pmbmd->m_bColocatedMBSkip = (pmbmdRef!=NULL && pmbmdRef->m_bSkip);
			pmbmd->m_bColocatedMBMCSEL = (pmbmdRef!=NULL && pmbmdRef->m_bMCSEL);
			if(m_vopmd.bShapeCodingType)
			{
				ShapeMode shpmdColocatedMB;
				if(!(m_volmd.bSpatialScalability)){	
					if(m_vopmd.fShapeBPredDir==B_FORWARD)
						shpmdColocatedMB = m_rgshpmd [MIN (MAX (0, iMBX), m_iRefShpNumMBX - 1)
						+ MIN (MAX (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
					else
						shpmdColocatedMB = m_rgmbmdRef [MIN (MAX (0, iMBX), m_iNumMBXRef - 1)
						+ MIN (MAX (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
					decodeInterShape (
						m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
						pmbmd, iMBX, iMBY, x, y,
						NULL, pmvBY, m_ppxlcCurrMBBY, ppxlcCurrQMBBY, shpmdColocatedMB);
				}
				else {
					if((m_volmd.volType == BASE_LAYER) || (!(m_volmd.iEnhnType==0 || m_volmd.iuseRefShape ==0) && !m_volmd.bShapeOnly) ){
						if(m_volmd.iEnhnType!=0 &&m_volmd.iuseRefShape ==1){
							shpmdColocatedMB = m_rgmbmdRef [ MIN (MAX (0, iMBX), m_iNumMBXRef - 1)+
								MIN (MAX (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
                        }else
							if(m_vopmd.fShapeBPredDir==B_FORWARD)
#ifndef min
#define min MIN
#endif
#ifndef max
#define max MAX
#endif
								shpmdColocatedMB = m_rgshpmd [MIN (MAX (0, iMBX), m_iRefShpNumMBX - 1)
								+ min (max (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
							else
								shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
								+ min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
							decodeInterShape (
								m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
								pmbmd, iMBX, iMBY, x, y,
								NULL, pmvBY, m_ppxlcCurrMBBY, ppxlcCurrQMBBY, shpmdColocatedMB);
					}
					else if(m_volmd.volType == ENHN_LAYER) { // for spatial scalability
						Int index = min (	max (0, (iMBX+xIndex)*m_volmd.ihor_sampling_factor_m_shape/m_volmd.ihor_sampling_factor_n_shape),			
							((m_iNumMBBaseXRef-1))	) 
							+ min (	max (0, (iMBY+yIndex)*m_volmd.iver_sampling_factor_m_shape/m_volmd.iver_sampling_factor_n_shape),			
							(m_iNumMBBaseYRef-1)  ) * (m_iNumMBBaseXRef);
						shpmdColocatedMB = m_rgBaseshpmd [index];
						
						decodeSIShapeBVOP (
							m_pvopcRefQ0,	//previous VOP
							m_pvopcRefQ1,	//lower reference layer
							pmbmd, iMBX, iMBY, x, y,
							NULL, pmvBY, (m_rgmvBaseBY+index), m_ppxlcCurrMBBY, ppxlcCurrQMBBY, shpmdColocatedMB);
					}
				}
			} else {
				decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY, ppxlcCurrQMBBY);
			}
			
			if(m_volmd.bShapeOnly==FALSE)
			{
				downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd);
				if ((pmbmd->m_bColocatedMBSkip && !(pmbmd->m_bColocatedMBMCSEL)) && // GMC
					(m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0))) { 
					// don't need to send any bit for this mode except enhn_layer
					copyFromRefToCurrQ (
						m_pvopcRefQ0,
						x, y, 
						ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
						&m_rctRefVOPY0
						);
					if(m_volmd.fAUsage == EIGHT_BIT) {
						copyAlphaFromRefToCurrQ(m_pvopcRefQ0, x, y, pppxlcCurrQMBA, &m_rctRefVOPY0);
					}
					pmbmd->m_bSkip = TRUE;
					memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
					memset (pmvBackward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
					pmbmd->m_mbType = FORWARD; // can be set to FORWARD mode since the result is the same
				}
				else {
					if (pmbmd->m_rgTranspStatus [0] != ALL) {
						if (!m_volmd.bSadctDisable)
							deriveSADCTRowLengths(m_rgiCurrMBCoeffWidth, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd ->m_rgTranspStatus);
						decodeMBTextureHeadOfBVOP (pmbmd, iCurrentQP);
						decodeMVofBVOP (pmv, pmvBackward, pmbmd, iMBX, iMBY, pmvRef, pmbmdRef);
						if (!pmbmd->m_bSkip) {
							if (!m_volmd.bSadctDisable)
								decodeTextureInterMB (pmbmd, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);    
							else
								decodeTextureInterMB (pmbmd);
							if ((pmbmd->m_rgTranspStatus [0] == NONE) && 
								(m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
								fieldDCTtoFrameI(m_ppxliErrorMBY);
						}
						else {
							if (m_vopmd.bInterlace) {                       
								assert(pmbmd->m_mbType == DIRECT);
								pmbmd->m_vctDirectDeltaMV.x = 0; 
								pmbmd->m_vctDirectDeltaMV.y = 0;
								memset (m_ppxliErrorMBY, 0, MB_SQUARE_SIZE * sizeof(Int));
								memset (m_ppxliErrorMBU, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
								memset (m_ppxliErrorMBV, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
								motionCompAndAddErrorMB_BVOP (
									pmv, pmvBackward,
									pmbmd, 
									iMBX, iMBY, 
									x, y,
									ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
									&m_rctRefVOPY0, &m_rctRefVOPY1);
							} else 
							{
								motionCompSkipMB_