sys_decoder_vopmbdec.cpp

完整的RTP RTSP代码库

	pmbmd->m_bFieldDCT = 0;
	
	Int iCurrentQP  = m_vopmd.intStepI;		
	Int	iVideoPacketNumber = 0; 			//	added for error resilience mode by Toshiba
	m_iVPMBnum = 0;	//	Added for error resilient mode by Toshiba(1997-11-14)
	
	if (!short_video_header) { 
		uiNumberOfGobs = 1;
		iMBXstart=0; 
		iMBXstop= m_iNumMBX;
		iMBYstart=0;
		iMBYstop= m_iNumMBY;
	}
	else { // short_header
		uiNumberOfGobs = uiNumGobsInVop;
		iMBXstart=0; 
		iMBXstop= 0;
		iMBYstart=0;
		iMBYstop= 0;
	}
	
	Bool bRestartDelayedQP = TRUE; // decodeMBTextureHeadOfIVOP sets this to false
	
	uiGobNumber=0;
	while (uiGobNumber < uiNumberOfGobs) { 
		if (short_video_header) {
			uiGobHeaderEmpty=1;
			if (uiGobNumber != 0) {
				skipAnyStuffing();
				if (checkGOBMarker()) {
					uiGobHeaderEmpty=0;
					m_pbitstrmIn -> flush();
					/*UInt uiGobResyncMarker= */m_pbitstrmIn -> getBits (17);
					uiGobNumber=m_pbitstrmIn -> getBits(5);
					/* UInt uiGobFrameId = */m_pbitstrmIn -> getBits(2);
					/* UInt uiVopQuant= */m_pbitstrmIn -> getBits(5); 
					uiGobNumber++; 
				} else {
					uiGobNumber++;
				}
			} else {
				uiGobNumber++;
			}
			
			iMBXstart=0; 
			iMBXstop= m_ivolWidth/16;
			iMBYstart=(uiGobNumber*(m_ivolHeight/16)/uiNumberOfGobs)-1;
			iMBYstop= iMBYstart+(m_ivolHeight/16)/uiNumberOfGobs;
		} else {
			uiGobNumber++; 
		}
		
		for (iMBY = iMBYstart; iMBY < iMBYstop; iMBY++) { // [FDS]
			PixelC* ppxlcRefMBY = ppxlcRefY;
			PixelC* ppxlcRefMBU = ppxlcRefU;
			PixelC* ppxlcRefMBV = ppxlcRefV;
			
			Bool  bSptMB_NOT_HOLE= TRUE;
			if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP) {
				
				bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(0, iMBY, pmbmd);		 
				RestoreMBmCurrRow (iMBY, m_rgpmbmCurr);  // restore current row pointed by *m_rgpmbmCurr
			}
			
			for (iMBX = iMBXstart; iMBX < iMBXstop; iMBX++) {	
				
				m_bSptMB_NOT_HOLE	 = 	bSptMB_NOT_HOLE;	
				if (!m_bSptMB_NOT_HOLE ) 	// current Sprite macroblock is not a hole and should be decoded			
					goto END_OF_DECODING2;
				
				skipAnyStuffing();
				if	(checkResyncMarker())	{
					decodeVideoPacketHeader(iCurrentQP);
					iVideoPacketNumber++;
					bRestartDelayedQP = TRUE;
					
					// NEWPRED
					if (m_volmd.bNewpredEnable && (m_volmd.bNewpredSegmentType == 0))
						// RRV modification
						sprintf(pSlicePoint, "%s,%d",pSlicePoint, (iMBY *m_iRRVScale)*(m_iNumMBX *m_iRRVScale)+(iMBX *m_iRRVScale));
					//						sprintf(pSlicePoint, "%s,%d",pSlicePoint, iMBY*m_iNumMBX+iMBX);
					// ~RRV
					else
						pSlicePoint[0] = '1';
					// ~NEWPRED
				}
				pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;	//mv out of if by wchen to set even when errR is off; always used in mbdec 
				decodeMBTextureHeadOfIVOP (pmbmd, iCurrentQP, &bRestartDelayedQP);
				decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
				// INTERLACE
				if ((m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
					fieldDCTtoFrameC(ppxlcRefMBY);
				// ~INTERLACE
				
END_OF_DECODING2:
				pmbmd++;
				ppxlcRefMBY += (MB_SIZE *m_iRRVScale);
				ppxlcRefMBU += (BLOCK_SIZE *m_iRRVScale);
				ppxlcRefMBV += (BLOCK_SIZE *m_iRRVScale);
				
				if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP)  // get the hole status for the next MB
					
					bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(iMBX+1, iMBY, pmbmd);	 			
				else
					bSptMB_NOT_HOLE= TRUE;
			}
			
			// May.25 2000 for MB stuffing decoding on the last MB
			if	(checkStartCode()) { // this MB contains only MCBPC stuffing
				break;
			}
			// ~May.25 2000 for MB stuffing decoding on the last MB
			
			MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
			m_rgpmbmAbove = m_rgpmbmCurr;
			
			if  (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE)
				SaveMBmCurrRow (iMBY, m_rgpmbmCurr);		 //	  save current row pointed by *m_rgpmbmCurr 
			
			m_rgpmbmCurr  = ppmbmTemp;
			ppxlcRefY += m_iFrameWidthYxMBSize;
			ppxlcRefU += m_iFrameWidthUVxBlkSize;
			ppxlcRefV += m_iFrameWidthUVxBlkSize;
		}
	} // KPN Terminate while loop Gob layer [FDS]
	
	skipAnyStuffing();
	
	// RRV insertion
	if(m_vopmd.RRVmode.iRRVOnOff == 1)
	{
		PixelC* ppxlcCurrQY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
		PixelC* ppxlcCurrQU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
		PixelC* ppxlcCurrQV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
		filterCodedPictureForRRV(ppxlcCurrQY, ppxlcCurrQU, ppxlcCurrQV,
			m_iVOPWidthY, m_rctCurrVOPY.height(),
			m_iNumMBX,  m_iNumMBY,
			m_pvopcRefQ0->whereY ().width,
			m_pvopcRefQ0->whereUV ().width);
	}
	
	// ~RRV
	// NEWPRED
	if (m_volmd.bNewpredEnable) {
		int iCurrentVOP_id = g_pNewPredDec->GetCurrentVOP_id();
		if (g_pNewPredDec != NULL) delete g_pNewPredDec;
		g_pNewPredDec = new CNewPredDecoder();
		g_pNewPredDec->SetObject(
			m_iNumBitsTimeIncr,
			m_iNumMBX*(MB_SIZE *m_iRRVScale),
			m_iNumMBY*(MB_SIZE *m_iRRVScale),
			pSlicePoint,
			m_volmd.bNewpredSegmentType,
			m_volmd.fAUsage,
			m_volmd.bShapeOnly,
			m_pvopcRefQ0,
			m_pvopcRefQ1,
			m_rctRefFrameY,
			m_rctRefFrameUV
			);
		g_pNewPredDec->ResetObject(iCurrentVOP_id);
		
		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);
		}
	}
	// ~NEWPRED
}

Void CVideoObjectDecoder::decodePVOP_WithShape ()
{
	Int iMBX, iMBY;
	CoordI y = m_rctCurrVOPY.top; 
	CMBMode* pmbmd = m_rgmbmd;
	// Added for field based MC padding by Hyundai(1998-5-9)
    CMBMode* field_pmbmd = m_rgmbmd;
	// End of Hyundai(1998-5-9)
	CMotionVector* pmv = m_rgmv;
	CMotionVector* pmvBY = m_rgmvBY;
	
	//OBSS_SAIT_991015
	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;
	}
	//~OBSS_SAIT_991015
	
	PixelC* ppxlcCurrQY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
	//	PixelC* ppxlcCurrQA  = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
	PixelC** pppxlcCurrQMBA = new PixelC* [m_volmd.iAuxCompCount];  // MAC (SB) 1-Dec-99
	
	Int iCurrentQP  = m_vopmd.intStep;	
	Int iCurrentQPA[MAX_MAC];
	for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ )  // MAC (SB) 2-Dec-99
		iCurrentQPA[iAuxComp] = m_vopmd.intStepPAlpha[iAuxComp];	
	//	Added for error resilient mode by Toshiba(1997-11-14)
	Int	iVideoPacketNumber = 0; 			//	added for error resilience mode by Toshiba
	m_iVPMBnum = 0;
	
	Bool bRestartDelayedQP = TRUE;
	
	//	End Toshiba(1997-11-14)
	
	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
		PixelC* ppxlcCurrQMBY  = ppxlcCurrQY;
		PixelC* ppxlcCurrQMBU  = ppxlcCurrQU;
		PixelC* ppxlcCurrQMBV  = ppxlcCurrQV;
		PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
		//		PixelC* ppxlcCurrQMBA  = ppxlcCurrQA;
		//	Added for error resilient mode by Toshiba(1997-11-14)
		if	(iMBY != 0)	{
			if	(checkResyncMarker()) {
				decodeVideoPacketHeader(iCurrentQP);
				iVideoPacketNumber++;
				bRestartDelayedQP = TRUE;
			}
		}
		pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
		//	End Toshiba(1997-11-14)
		// Modified for error resilient mode by Toshiba(1997-11-14)
		ShapeMode shpmdColocatedMB;
		if(m_vopmd.bShapeCodingType) {
			//OBSS_SAIT_991015
			//OBSSFIX_MODE3
            if(!(m_volmd.bSpatialScalability && m_volmd.iHierarchyType == 0)){
				//			if(!(m_volmd.bSpatialScalability)){
				//~OBSSFIX_MODE3
				shpmdColocatedMB = m_rgmbmdRef [
					MIN (iMBY, m_iNumMBYRef-1) * m_iNumMBXRef
					].m_shpmd;
				decodeInterShape (m_pvopcRefQ0, pmbmd, 0, iMBY,
					m_rctCurrVOPY.left, y, pmv, pmvBY,
					m_ppxlcCurrMBBY, ppxlcCurrQMBBY,
					shpmdColocatedMB);
			}
			else {
				//OBSSFIX_MODE3
				if(m_volmd.volType == ENHN_LAYER && m_volmd.iEnhnType==1 && m_volmd.iuseRefShape == 1 ){
					shpmdColocatedMB = ALL_OPAQUE;
					pmv->setToZero();		
					pmvBY->setToZero();		
                    decodeInterShape(m_pvopcRefQ0, pmbmd, 0, iMBY,
						m_rctCurrVOPY.left, y, pmv, pmvBY,
						m_ppxlcCurrMBBY, ppxlcCurrQMBBY,
						shpmdColocatedMB);
				} else 
					//~OBSSFIX_MODE3
					if((m_volmd.volType == BASE_LAYER) || (!(m_volmd.iEnhnType==0 || m_volmd.iuseRefShape ==0) && !m_volmd.bShapeOnly) ){			
						shpmdColocatedMB = m_rgmbmdRef [
							MIN (iMBY, m_iNumMBYRef-1) * m_iNumMBXRef
							].m_shpmd;
						decodeInterShape (m_pvopcRefQ0, pmbmd, 0, iMBY,
							m_rctCurrVOPY.left, y, pmv, pmvBY,
							m_ppxlcCurrMBBY, ppxlcCurrQMBBY,
							shpmdColocatedMB);
					}
					else if(m_volmd.volType == ENHN_LAYER) { // for spatial scalability
						Int index = 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];
						decodeSIShapePVOP (m_pvopcRefQ0, pmbmd, 0, iMBY,
							m_rctCurrVOPY.left, y, pmv, pmvBY, (m_rgmvBaseBY+index), 
							m_ppxlcCurrMBBY, ppxlcCurrQMBBY,
							shpmdColocatedMB);
					}
			}
			//~OBSS_SAIT_991015		
		}
		else {
			decodeIntraShape (pmbmd, 0, iMBY, m_ppxlcCurrMBBY,
				ppxlcCurrQMBBY);
		}
		// End Toshiba(1997-11-14)
		// Changed HHI 2000-04-11
		downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd);
		if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
			decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, &bRestartDelayedQP);
			// GMC
			if(!pmbmd -> m_bMCSEL)
				// ~GMC
				decodeMVWithShape (pmbmd, 0, iMBY, pmv);
			// GMC
			else
			{
				Int iPmvx, iPmvy, iHalfx, iHalfy;
				globalmv (iPmvx, iPmvy, iHalfx, iHalfy,
					m_rctCurrVOPY.left,y,
					m_vopmd.mvInfoForward.uiRange,
					m_volmd.bQuarterSample);
				CVector vctOrg;
				vctOrg.x = iPmvx*2 + iHalfx;
				vctOrg.y = iPmvy*2 + iHalfy;
				*pmv= CMotionVector (iPmvx, iPmvy);
				pmv -> iHalfX = iHalfx;
				pmv -> iHalfY = iHalfy;
				pmv -> computeTrueMV ();
				pmv -> computeMV ();
				for (UInt i = 1; i < PVOP_MV_PER_REF_PER_MB; i++)
					pmv[i] = *pmv;
			}
			// ~GMC
			if(pmbmd->m_bhas4MVForward)
				padMotionVectors(pmbmd,pmv);
		}
		CoordI x = m_rctCurrVOPY.left;
		
		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_pvopcRefQ1->pixelsA (iAuxComp) + m_iStartInRefToCurrRctY)
					+ iMBY*m_iFrameWidthYxMBSize + iMBX*MB_SIZE;
			}	
			
			pmbmd->m_bPadded = FALSE;
			if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
				// HHI Schueuer sadct support		
				if (!m_volmd.bSadctDisable)
					deriveSADCTRowLengths(m_rgiCurrMBCoeffWidth, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd ->m_rgTranspStatus);
				// end HHI   
				if ((pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) && !pmbmd->m_bSkip) {
					// HHI Schueuer: sadct
					if (!m_volmd.bSadctDisable)
						decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
					else
						decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
					// end HHI
					// decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
					// INTERLACE
					//new changes
					if ((pmbmd->m_rgTranspStatus [0] == NONE) && 
						(m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
						fieldDCTtoFrameC(ppxlcCurrQMBY);
					//end of new changes
					// ~INTERLACE
					if (m_volmd.fAUsage == EIGHT_BIT) {
						for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ ) { // MAC (SB) 1-Dec-99
							decodeMBAlphaHeadOfPVOP (pmbmd, iCurrentQP, iCurrentQPA[iAuxComp], iAuxComp);
							// HHI Schueuer