errdec.cpp

完整的RTP RTSP代码库

	m_iVPMBnum = 0;
	Bool bLeftBndry;
	Bool bRightBndry;
	Bool bTopBndry;

	m_piMCBPC = new Int[m_iNumMBX*m_iNumMBY+1];
	Int*	piMCBPC = m_piMCBPC;
	m_piIntraDC = new Int[m_iNumMBX*m_iNumMBY*V_BLOCK];
	Int*	piIntraDC = m_piIntraDC;

	Int	i;
	Int	mbn = 0, mbnFirst = 0;

	CoordI x = 0;
	CoordI y = 0;
	PixelC* ppxlcCurrQMBY = NULL;
	PixelC* ppxlcCurrQMBU = NULL;
	PixelC* ppxlcCurrQMBV = NULL;

	Bool bMBBackup = FALSE;
	CMBMode* pmbmdBackup = NULL;
	Int iMBXBackup  = 0, iMBYBackup = 0;
	CMotionVector* pmvBackup = NULL;
	PixelC* ppxlcCurrQMBYBackup = NULL;
	PixelC* ppxlcCurrQMBUBackup = NULL;
	PixelC* ppxlcCurrQMBVBackup = NULL;

	Bool bRestartDelayedQP = TRUE;

	Bool bRet;
	const PixelC* RefbufY = m_pvopcRefQ0-> pixelsY ();
	const PixelC* RefbufU = m_pvopcRefQ0-> pixelsU ();
	const PixelC* RefbufV = m_pvopcRefQ0-> pixelsV ();
	PixelC *RefpointY, *RefpointU, *RefpointV;
	PixelC *pRefpointY, *pRefpointU, *pRefpointV;

	if (m_volmd.bNewpredEnable) {
		// temporarily store present reference picture
		g_pNewPredDec->CopyReftoBuf(RefbufY, RefbufU, RefbufV, m_rctRefFrameY, m_rctRefFrameUV);
		bRet = FALSE;

		iMBX = mbn % m_iNumMBX;
		iMBY = mbn / m_iNumMBX;

		// copy picture from NEWPRED reference picture memory
		RefpointY = (PixelC*) g_pNewPredDec->m_pchNewPredRefY +
				(EXPANDY_REF_FRAME * m_rctRefFrameY.width);
		RefpointU = (PixelC*) g_pNewPredDec->m_pchNewPredRefU +
				((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width);
		RefpointV = (PixelC*) g_pNewPredDec->m_pchNewPredRefV +
				((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width);
		bRet = g_pNewPredDec->CopyNPtoVM(iVideoPacketNumber, RefpointY, RefpointU, RefpointV);

		// padding around VP
		pRefpointY = (PixelC*) m_pvopcRefQ0->pixelsY () + m_iStartInRefToCurrRctY;
		pRefpointU = (PixelC*) m_pvopcRefQ0->pixelsU () + m_iStartInRefToCurrRctUV;
		pRefpointV = (PixelC*) m_pvopcRefQ0->pixelsV () + m_iStartInRefToCurrRctUV;
// RRV modification
		g_pNewPredDec->ChangeRefOfSlice((const PixelC* )pRefpointY, RefbufY,(const PixelC* )pRefpointU, RefbufU,
			(const PixelC* )pRefpointV, RefbufV, (iMBX *m_iRRVScale), (iMBY *m_iRRVScale),m_rctRefFrameY, m_rctRefFrameUV);
//		g_pNewPredDec->ChangeRefOfSlice((const PixelC* )pRefpointY, RefbufY,(const PixelC* )pRefpointU, RefbufU,
//			(const PixelC* )pRefpointV, RefbufV, iMBX, iMBY,m_rctRefFrameY, m_rctRefFrameUV);
// ~RRV
		repeatPadYOrA ((PixelC*) m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ0);
		repeatPadUV (m_pvopcRefQ0);

		for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) { // count slice number
			for (iMBX = 0; iMBX < m_iNumMBX; iMBX++)	{
// RRV modification
				(pmbmd + iMBX + m_iNumMBX*iMBY) -> m_iNPSegmentNumber = g_pNewPredDec->GetSliceNum((iMBX *m_iRRVScale),(iMBY *m_iRRVScale));
//				(pmbmd + iMBX + m_iNumMBX*iMBY) -> m_iNPSegmentNumber = g_pNewPredDec->GetSliceNum(iMBX,iMBY);
// ~RRV
			}
		}

	}
// ~NEWPRED

	do{
		CMBMode* pmbmdFirst = pmbmd;
		CMotionVector* pmvFirst = pmv;
		Int* piMCBPCFirst = piMCBPC;
		Int* piIntraDCFirst = piIntraDC;
		mbnFirst = mbn;

		if( checkResyncMarker() ){
			decodeVideoPacketHeader(iCurrentQP);
			iVideoPacketNumber++;
			bRestartDelayedQP = TRUE;
		}

		do{
			pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
			iMBX = mbn % m_iNumMBX;
			iMBY = mbn / m_iNumMBX;

			Bool bStuffing = decodeMBTextureModeOfPVOP_DataPartitioning(pmbmd, piMCBPC);
			if(bStuffing)
			{
				if ( checkMotionMarker() )
					break;
				continue;
			}

			if(iMBX == 0) {
				bLeftBndry = TRUE;
			} else {
				bLeftBndry = !((pmbmd - 1) -> m_iVideoPacketNumber == pmbmd -> m_iVideoPacketNumber);
			}
			if(iMBY == 0) {
				bTopBndry = TRUE;
			} else {
				bTopBndry = !((pmbmd - m_iNumMBX) -> m_iVideoPacketNumber == pmbmd -> m_iVideoPacketNumber);
			}
			if((iMBX == m_iNumMBX - 1) || (iMBY == 0)) {
				bRightBndry = TRUE;
			} else {
				bRightBndry = !((pmbmd - m_iNumMBX + 1) -> m_iVideoPacketNumber == pmbmd -> m_iVideoPacketNumber);
			}
// GMC
			if(!pmbmd -> m_bMCSEL)
// ~GMC
				decodeMV (pmbmd, pmv, bLeftBndry, bRightBndry, bTopBndry, FALSE, iMBX, iMBY);
// GMC
			else
			{
				Int iPmvx, iPmvy, iHalfx, iHalfy;
				globalmv (iPmvx, iPmvy, iHalfx, iHalfy,
					iMBX*MB_SIZE,iMBY*MB_SIZE,
					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(bMBBackup){
				if (pmbmdBackup->m_dctMd == INTER || pmbmdBackup->m_dctMd == INTERQ) {
					motionCompMB (
						m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
						pmvBackup, pmbmdBackup, 
						iMBXBackup, iMBYBackup, 
						x, y,
						pmbmdBackup->m_bSkip, FALSE,
						&m_rctRefVOPY0
					);
					if (!(pmbmdBackup->m_bSkip && !pmbmdBackup->m_bMCSEL)) { // GMC
						CoordI iXRefUV, iYRefUV, iXRefUV1, iYRefUV1;
// GMC
					    if (!pmbmdBackup->m_bMCSEL)
// ~GMC
						mvLookupUV (pmbmdBackup, pmvBackup, iXRefUV, iYRefUV, iXRefUV1, iYRefUV1);
// GMC
					    if(pmbmdBackup->m_bMCSEL) {
							FindGlobalChromPredForGMC(x,y,m_ppxlcPredMBU,m_ppxlcPredMBV);
						} 
						else
// ~GMC
							motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl, &m_rctRefVOPY0);
// GMC
					    if (pmbmdBackup->m_bSkip)
							assignPredToCurrQ (ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup);
					    else
// ~GMC
							addErrorAndPredToCurrQ (ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup);
					}
					else {
						if (m_volmd.bAdvPredDisable)
	
							copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, NULL);
						else
							copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, NULL);
					}
				}
				bMBBackup = FALSE;

// NEWPRED
				if (m_volmd.bNewpredEnable && (m_volmd.bNewpredSegmentType == 0)) {				
					bRet = FALSE;
					// copy picture from NEWPRED reference picture memory
// RRV modification
					RefpointY = (PixelC*) g_pNewPredDec->m_pchNewPredRefY +
				  		(EXPANDY_REF_FRAME * m_rctRefFrameY.width) + 
				  		iMBY * (MB_SIZE *m_iRRVScale)* m_rctRefFrameY.width;
					RefpointU = (PixelC*) g_pNewPredDec->m_pchNewPredRefU +
				  		((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width) + 
					 	iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
					RefpointV = (PixelC*) g_pNewPredDec->m_pchNewPredRefV +
				 		((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width) + 
				 		iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
					bRet = g_pNewPredDec->CopyNPtoVM(iVideoPacketNumber, RefpointY, RefpointU, RefpointV);

					pRefpointY = (PixelC*) m_pvopcRefQ0->pixelsY () + m_iStartInRefToCurrRctY + iMBY * (MB_SIZE *m_iRRVScale) * m_rctRefFrameY.width;
					pRefpointU = (PixelC*) m_pvopcRefQ0->pixelsU () + m_iStartInRefToCurrRctUV + iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
					pRefpointV = (PixelC*) m_pvopcRefQ0->pixelsV () + m_iStartInRefToCurrRctUV + iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
					// padding around VP
					g_pNewPredDec->ChangeRefOfSlice((const PixelC* )pRefpointY, RefbufY,(const PixelC* )pRefpointU, RefbufU,
				  		(const PixelC* )pRefpointV, RefbufV, (iMBX *m_iRRVScale), (iMBY *m_iRRVScale), m_rctRefFrameY, m_rctRefFrameUV);
					repeatPadYOrA ((PixelC*) m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ0);
					repeatPadUV (m_pvopcRefQ0);
				}		
// ~NEWPRED
			}

			pmbmd++;
			pmv += PVOP_MV_PER_REF_PER_MB;
			mbn++;
			piMCBPC++;
			assert(mbn<=(m_iNumMBX*m_iNumMBY));
		} while( !checkMotionMarker() );
		m_pbitstrmIn -> getBits (NUMBITS_DP_MOTION_MARKER);

		pmbmd = pmbmdFirst;
		piMCBPC = piMCBPCFirst;
		piIntraDC = piIntraDCFirst;
		//printf("#");
		for(i=mbnFirst;i<mbn;i++) {
			decodeMBTextureHeadOfPVOP_DataPartitioning (pmbmd, iCurrentQP, piMCBPC, piIntraDC, &bRestartDelayedQP);
			//if(pmbmd->m_bSkip)
			//	printf("(Skip)");
			//else
			//	printf("(%d:%d:%d)", *piMCBPC, pmbmd->m_bCodeDcAsAc, pmbmd->m_stepSize);
			pmbmd++;
			piMCBPC++;
			piIntraDC += V_BLOCK;
		}

		pmbmd = pmbmdFirst;
		pmv = pmvFirst;
		piIntraDC = piIntraDCFirst;

		for(i=mbnFirst;i<mbn;i++) {
			iMBX = i % m_iNumMBX;
			iMBY = i / m_iNumMBX;
			if(iMBX == 0 ) {
				ppxlcCurrQMBY = ppxlcCurrQY;
				ppxlcCurrQMBU = ppxlcCurrQU;
				ppxlcCurrQMBV = ppxlcCurrQV;
				x = 0;
// RRV modification
				if(iMBY != 0)	y += (MB_SIZE *m_iRRVScale);
//				if(iMBY != 0)	y += MB_SIZE;
// ~RRV
			} else {
// RRV modification
				x += (MB_SIZE *m_iRRVScale);
//				x += MB_SIZE;
// ~RRV
			}

			if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)
				decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, piIntraDC);
			else {
				if (!pmbmd->m_bSkip)
					decodeTextureInterMB (pmbmd);
			}

			if(i==mbn-1){
				bMBBackup = TRUE;
				pmbmdBackup = pmbmd;
				pmvBackup = pmv;
				iMBXBackup = iMBX;
				iMBYBackup = iMBY;
				ppxlcCurrQMBYBackup = ppxlcCurrQMBY;
				ppxlcCurrQMBUBackup = ppxlcCurrQMBU;
				ppxlcCurrQMBVBackup = ppxlcCurrQMBV;
			}

			if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) {
				motionCompMB (
					m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
					pmv, pmbmd, 
					iMBX, iMBY, 
					x, y,
					pmbmd->m_bSkip, FALSE,
					&m_rctRefVOPY0
				);
				if (!(pmbmd->m_bSkip && !pmbmd->m_bMCSEL)) { // GMC
					CoordI iXRefUV, iYRefUV, iXRefUV1, iYRefUV1;
// GMC
				   if(!pmbmd->m_bMCSEL)
// ~GMC
					mvLookupUV (pmbmd, pmv, iXRefUV, iYRefUV, iXRefUV1, iYRefUV1);
// GMC
				   if(pmbmd->m_bMCSEL){
					FindGlobalChromPredForGMC(x,y,m_ppxlcPredMBU,m_ppxlcPredMBV);
				   }else
// ~GMC
					motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl, &m_rctRefVOPY0);
// GMC
				   if(pmbmd->m_bSkip)
					assignPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
				   else
// ~GMC
					addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
				}
				else {
					if (m_volmd.bAdvPredDisable)

						copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL);
					else
						copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL);
				}
			}

			pmbmd++;
			pmv += PVOP_MV_PER_REF_PER_MB;
			piIntraDC += V_BLOCK;
// RRV modification
			ppxlcCurrQMBY += (MB_SIZE *m_iRRVScale);
			ppxlcCurrQMBU += (BLOCK_SIZE *m_iRRVScale);
			ppxlcCurrQMBV += (BLOCK_SIZE *m_iRRVScale);
//			ppxlcCurrQMBY += MB_SIZE;
//			ppxlcCurrQMBU += BLOCK_SIZE;
//			ppxlcCurrQMBV += BLOCK_SIZE;
// ~RRV
			if(iMBX == m_iNumMBX - 1) {
				MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
				m_rgpmbmAbove = m_rgpmbmCurr;
				m_rgpmbmCurr  = ppmbmTemp;
				ppxlcCurrQY += m_iFrameWidthYxMBSize;
				ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
				ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
			}
		}
	} while( checkResyncMarker() );
	delete m_piIntraDC;
	delete m_piMCBPC;

// 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 i;
		Int noStore_vop_id;	// stored Vop_id

		// store decoded picture in  NEWPRED reference picture memory
		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 decoded picutre to reference picture memory because of output ording
		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);
	}
// ~NEWPRED

}

Void CVideoObjectDecoder::decodeIVOP_WithShape_DataPartitioning ()	
{
	//assert (m_volmd.nBits==8);
	assert (m_volmd.fAUsage!=EIGHT_BIT);
	//in case the IVOP is used as an ref for direct mode
	memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));

	Int iMBX, iMBY;
	CMBMode* pmbmd = m_rgmbmd;

	PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
//	PixelC* ppxlcRefA  = (PixelC*) m_pvopcRefQ1->pixelsA (0) + m_iStartInRefToCurrRctY;
	PixelC* ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;

	Int iCurrentQP  = m_vopmd.intStepI;	
	Int	iVideoPacketNumber = 0;
	m_iVPMBnum = 0;
	m_piMCBPC = new Int[m_iNumMBX*m_iNumMBY];
	Int*	piMCBPC = m_piMCBPC;
	m_piIntraDC = new Int[m_iNumMBX*m_iNumMBY*V_BLOCK];
	Int*	piIntraDC = m_piIntraDC;

	Bool bRestartDelayedQP = TRUE;
	Int	i;
	Int mbn = 0, mbnFirst = 0;

	PixelC* ppxlcRefMBBY = NULL;
	PixelC* ppxlcRefMBBUV;
	PixelC* ppxlcRefMBY = NULL;
	PixelC* ppxlcRefMBU = NULL;
	PixelC* ppxlcRefMBV = NULL;
	//PixelC* ppxlcRefMBA;
	do	{
		if( checkResyncMarker() )	{
			decodeVideoPacketHeader(iCurrentQP);
			iVideoPacketNumber++;
			bRestartDelayedQP = TRUE;
		}

		CMBMode* pmbmdFirst = pmbmd;
		Int* piMCBPCFirst = piMCBPC;
		Int* piIntraDCFirst = piIntraDC;
		mbnFirst = mbn;

		do{
			iMBX = mbn % m_iNumMBX;
			iMBY = mbn / m_iNumMBX;
			if(iMBX == 0 ) {
				ppxlcRefMBBY = ppxlcRefBY;
				ppxlcRefMBBUV = ppxlcRefBUV;
			}

			pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;

			decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY, ppxlcRefMBBY);
			// Changed HHI 2000-04-11
			downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd); // downsample original BY now for LPE padding (using original shape)
			if(m_volmd.bShapeOnly==FALSE)
			{
				pmbmd->m_bPadded=FALSE;
				if (pmbmd->m_rgTranspStatus [0] != ALL) {
					*piMCBPC = m_pentrdecSet->m_pentrdecMCBPCintra->decodeSymbol ();
					assert (*piMCBPC >= 0 && *piMCBPC <= 8);
					while (*piMCBPC == 8) {
						*piMCBPC = m_pentrdecSet->m_pentrdecMCBPCintra->decodeSymbol ();
					};

					pmbmd->m_dctMd = INTRA;
					if (*piMCBPC > 3)
						pmbmd->m_dctMd = INTRAQ;
					decodeMBTextureDCOfIVOP_DataPartitioning (pmbmd, iCurrentQP, piIntraDC, &bRestartDelayedQP);
				}
			}
			else	{
				assert(FALSE);
			}
			pmbmd++;
			mbn++;
			piMCBPC++;
			piIntraDC+=V_BLOCK;
			ppxlcRefMBBY += MB_SIZE;
			ppxlcRefMBBUV += BLOCK_SIZE;
			if(iMBX == m_iNumMBX - 1) {
				ppxlcRefBY += m_iFrameWidthYxMBSize;
				ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
			}
		} while( !checkDCMarker() );
		m_pbitstrmIn -> getBits (NUMBITS_DP_DC_MARKER);

		pmbmd = pmbmdFirst;
		piMCBPC = piMCBPCFirst;
		for(i=mbnFirst;i<mbn;i++) {