errdec.cpp

完整的RTP RTSP代码库

			if (pmbmd->m_rgTranspStatus [0] != ALL)
				decodeMBTextureHeadOfIVOP_DataPartitioning (pmbmd, piMCBPC);
			pmbmd++;
			piMCBPC++;
		}

		pmbmd = pmbmdFirst;
		piIntraDC = piIntraDCFirst;
		ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY + (mbnFirst/m_iNumMBX)*m_iFrameWidthYxMBSize;
		ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV + (mbnFirst/m_iNumMBX)*m_iFrameWidthUVxBlkSize;
		ppxlcRefMBBY = ppxlcRefBY + (mbnFirst%m_iNumMBX)*MB_SIZE;
		ppxlcRefMBBUV = ppxlcRefBUV + (mbnFirst%m_iNumMBX)*BLOCK_SIZE;
		for(i=mbnFirst;i<mbn;i++) {
			pmbmd->m_bPadded = FALSE;
			iMBX = i % m_iNumMBX;
			iMBY = i / m_iNumMBX;
			if(iMBX == 0 ) {
				ppxlcRefMBY = ppxlcRefY;
				ppxlcRefMBU = ppxlcRefU;
				ppxlcRefMBV = ppxlcRefV;
//				ppxlcRefMBA  = ppxlcRefA;
				ppxlcRefMBBY = ppxlcRefBY;
				ppxlcRefMBBUV = ppxlcRefBUV;
			}

			copyRefShapeToMb(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 (pmbmd->m_rgTranspStatus [0] != ALL) {
				// 09/16/99 HHI Schueuer: added for sadct
				if (!m_volmd.bSadctDisable)
					deriveSADCTRowLengths(m_rgiCurrMBCoeffWidth, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd ->m_rgTranspStatus);
				// end HHI
				// 09/16/99 HHI Schueuer: added for sadct
				if (!m_volmd.bSadctDisable)
					decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, piIntraDC, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
				else
					// end HHI 
					decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, piIntraDC); 

				// MC padding
				if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
					mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL/*ppxlcRefMBA*/);
				padNeighborTranspMBs (
					iMBX, iMBY,
					pmbmd,
					ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL /*ppxlcRefMBA*/
				);
			}
			else {
				padCurrAndTopTranspMBFromNeighbor (
					iMBX, iMBY,
					pmbmd,
					ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL /*ppxlcRefMBA*/
				);
			}

//			ppxlcRefMBA += MB_SIZE;
			ppxlcRefMBBY += MB_SIZE;
			ppxlcRefMBBUV += BLOCK_SIZE;
			pmbmd++;
			piIntraDC += V_BLOCK;
			ppxlcRefMBY += MB_SIZE;
			ppxlcRefMBU += BLOCK_SIZE;
			ppxlcRefMBV += BLOCK_SIZE;
			if(iMBX == m_iNumMBX - 1) {
				MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
				m_rgpmbmAbove = m_rgpmbmCurr;
				m_rgpmbmCurr  = ppmbmTemp;
				ppxlcRefY += m_iFrameWidthYxMBSize;
				ppxlcRefU += m_iFrameWidthUVxBlkSize;
				ppxlcRefV += m_iFrameWidthUVxBlkSize;
//				ppxlcRefA += m_iFrameWidthYxMBSize;
				ppxlcRefBY += m_iFrameWidthYxMBSize;
				ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
			}
		}
	} while( checkResyncMarker() );

	delete m_piMCBPC;
	delete m_piIntraDC;
}

Void CVideoObjectDecoder::decodePVOP_WithShape_DataPartitioning ()
{
	//assert (m_volmd.nBits==8);
	assert (m_volmd.fAUsage!=EIGHT_BIT);
	Int iMBX, iMBY;
	CoordI y = m_rctCurrVOPY.top; 
	CoordI x = m_rctCurrVOPY.left;
	CoordI y_s = m_rctCurrVOPY.top; 
	CoordI x_s = m_rctCurrVOPY.left;
	CMBMode* pmbmd = m_rgmbmd;
	CMotionVector* pmv = m_rgmv;
	CMotionVector* pmvBY = m_rgmvBY;
	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* ppxlcCurrQBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
	
	Int iCurrentQP  = m_vopmd.intStep;	
	Int	iVideoPacketNumber = 0; 			//	added for error resilience mode by Toshiba
	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;

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

	PixelC* ppxlcCurrQMBY = NULL;
	PixelC* ppxlcCurrQMBU = NULL;
	PixelC* ppxlcCurrQMBV = NULL;
	PixelC* ppxlcCurrQMBBY = NULL;
	PixelC* ppxlcCurrQMBBUV;
	//PixelC* ppxlcCurrQMBA;

	Bool bMBBackup = FALSE;
	CMBMode* pmbmdBackup = NULL;
	Int iMBXBackup = 0, iMBYBackup = 0;
	CMotionVector* pmvBackup = NULL;
	PixelC* ppxlcCurrQMBYBackup = NULL;
	PixelC* ppxlcCurrQMBUBackup = NULL;
	PixelC* ppxlcCurrQMBVBackup = NULL;
	PixelC* ppxlcCurrQMBBYBackup = NULL;
	PixelC* ppxlcCurrQMBBUVBackup;
	//PixelC* ppxlcCurrQMBABackup;
	Bool bPaddedLBackup = FALSE;
	Bool bPaddedTBackup = FALSE;

	Bool bRestartDelayedQP = TRUE;

	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;
			if(iMBX == 0 ) {
				ppxlcCurrQMBBY = ppxlcCurrQBY;
				ppxlcCurrQMBBUV = ppxlcCurrQBUV;
				x_s = m_rctCurrVOPY.left;
				if(iMBY != 0)	y_s += MB_SIZE;
			} else {
				x_s += MB_SIZE;
			}

			ShapeMode shpmdColocatedMB;
			if(m_vopmd.bShapeCodingType) {
				shpmdColocatedMB = m_rgmbmdRef [
					MIN (MAX (0, iMBX), m_iNumMBXRef - 1) + 
 					MIN (MAX (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef
				].m_shpmd;
				decodeInterShape (
					m_pvopcRefQ0,
					pmbmd, 
					iMBX, iMBY, 
					x_s, y_s, 
					pmv, pmvBY, 
					m_ppxlcCurrMBBY, ppxlcCurrQMBBY,
					shpmdColocatedMB
				);
			}
			else	{
				decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY,
					ppxlcCurrQMBBY);
			}

			downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd);

			if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
				Bool bStuffing;
				do {
					bStuffing = decodeMBTextureModeOfPVOP_DataPartitioning(pmbmd, piMCBPC);
				} while(bStuffing);

				if(!pmbmd -> m_bMCSEL)
					decodeMVWithShape (pmbmd, iMBX, iMBY, pmv);
				else
				{
					Int iPmvx, iPmvy, iHalfx, iHalfy;
					globalmv (iPmvx, iPmvy, iHalfx, iHalfy,
						m_rctCurrVOPY.left+iMBX*MB_SIZE,
						m_rctCurrVOPY.top+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;
				}
				if(pmbmd->m_bhas4MVForward)
					padMotionVectors(pmbmd,pmv);
			}

			if(bMBBackup){
				copyRefShapeToMb(m_ppxlcCurrMBBY, ppxlcCurrQMBBYBackup);
				// Changed HHI 2000-04-11
				downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmdBackup); // downsample original BY now for LPE padding (using original shape)
				pmbmdBackup->m_bPadded = FALSE;
				if(iMBXBackup > 0) (pmbmdBackup-1)->m_bPadded = bPaddedLBackup;
				if(iMBYBackup > 0) (pmbmdBackup-m_iNumMBX)->m_bPadded = bPaddedTBackup;
				if (pmbmdBackup->m_rgTranspStatus [0] != ALL) {
					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;
// GMC
						   if (!pmbmdBackup->m_bMCSEL)
// ~GMC
							mvLookupUVWithShape (pmbmdBackup, pmvBackup, iXRefUV, iYRefUV);
// 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, &m_rctRefVOPY0);
							else
								copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, &m_rctRefVOPY0);
						}
					}

					if (pmbmdBackup->m_rgTranspStatus [0] == PARTIAL)
						mcPadCurrMB (ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, NULL/*ppxlcCurrQMBABackup*/);
					padNeighborTranspMBs (
						iMBXBackup, iMBYBackup,
						pmbmdBackup,
						ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, NULL /*ppxlcCurrQMBABackup*/
					);
				}
				else {
					padCurrAndTopTranspMBFromNeighbor (
						iMBXBackup, iMBYBackup,
						pmbmdBackup,
						ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, NULL/*ppxlcCurrQMBABackup*/
					);
				}

				bMBBackup = FALSE;
			}

			pmbmd++;
			pmv += PVOP_MV_PER_REF_PER_MB;
			pmvBY++;
			mbn++;
			piMCBPC++;
			ppxlcCurrQMBBY += MB_SIZE;
			ppxlcCurrQMBBUV += BLOCK_SIZE;
			if(iMBX == m_iNumMBX - 1) {
				ppxlcCurrQBY += m_iFrameWidthYxMBSize;
				ppxlcCurrQBUV += m_iFrameWidthUVxBlkSize;
			}
			assert(mbn<=(m_iNumMBX*m_iNumMBY));
		} while( !checkMotionMarker() );
		m_pbitstrmIn -> getBits (NUMBITS_DP_MOTION_MARKER);

		pmbmd = pmbmdFirst;
		piMCBPC = piMCBPCFirst;
		piIntraDC = piIntraDCFirst;
		for(i=mbnFirst;i<mbn;i++) {
			if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
				decodeMBTextureHeadOfPVOP_DataPartitioning (pmbmd, iCurrentQP, piMCBPC, piIntraDC, &bRestartDelayedQP);
			}
			pmbmd++;
			piMCBPC++;
			piIntraDC += V_BLOCK;
		}

		pmbmd = pmbmdFirst;
		pmv = pmvFirst;
		piIntraDC = piIntraDCFirst;
		ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY + (mbnFirst/m_iNumMBX)*m_iFrameWidthYxMBSize;
		ppxlcCurrQBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV + (mbnFirst/m_iNumMBX)*m_iFrameWidthUVxBlkSize;
		ppxlcCurrQMBBY = ppxlcCurrQBY + (mbnFirst%m_iNumMBX)*MB_SIZE;
		ppxlcCurrQMBBUV = ppxlcCurrQBUV + (mbnFirst%m_iNumMBX)*BLOCK_SIZE;

		for(i=mbnFirst;i<mbn;i++) {
			pmbmd->m_bPadded = FALSE;
			iMBX = i % m_iNumMBX;
			iMBY = i / m_iNumMBX;
			if(iMBX == 0 ) {
				ppxlcCurrQMBY = ppxlcCurrQY;
				ppxlcCurrQMBU = ppxlcCurrQU;
				ppxlcCurrQMBV = ppxlcCurrQV;
				ppxlcCurrQMBBY = ppxlcCurrQBY;
//				ppxlcCurrQMBA  = ppxlcCurrQA;
				ppxlcCurrQMBBUV = ppxlcCurrQBUV;
				x = m_rctCurrVOPY.left;
				if(iMBY != 0)	y += MB_SIZE;
			} else {
				x += MB_SIZE;
			}

			copyRefShapeToMb(m_ppxlcCurrMBBY, ppxlcCurrQMBBY);
			// Changed HHI 2000-04-11
			downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd); // downsample original BY now for LPE padding (using original shape)

			if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
				// 09/16/99 HHI Schueuer: added for sadct
				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){
					// 09/16/99 HHI Schueuer: inserted for sadct
					if (!m_volmd.bSadctDisable)
						decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, piIntraDC, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
					else
						decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, piIntraDC);
				}
				// end HHI
				else {
					if (!pmbmd->m_bSkip){
						// 09/16/99 HHI Schueuer: inserted for sadct
						if (!m_volmd.bSadctDisable)
							decodeTextureInterMB (pmbmd, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
						else
						// end HHI 		
							decodeTextureInterMB (pmbmd);
					}
				}
			}

			if(i==mbn-1){
				bMBBackup = TRUE;
				pmbmdBackup = pmbmd;
				pmvBackup = pmv;
				iMBXBackup = iMBX;
				iMBYBackup = iMBY;
				ppxlcCurrQMBYBackup = ppxlcCurrQMBY;
				ppxlcCurrQMBUBackup = ppxlcCurrQMBU;
				ppxlcCurrQMBVBackup = ppxlcCurrQMBV;
				ppxlcCurrQMBBYBackup = ppxlcCurrQMBBY;
				ppxlcCurrQMBBUVBackup = ppxlcCurrQMBBUV;
				//ppxlcCurrQMBABackup = ppxlcCurrQMBA;
				bPaddedLBackup = (pmbmdBackup-1)->m_bPadded;
				bPaddedTBackup = (pmbmdBackup-m_iNumMBX)->m_bPadded;
			}

			if (pmbmd->m_rgTranspStatus [0] != ALL) {
				if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) {
					//	Addded for data partitioning mode by Toshiba(1997-11-26:DP+RVLC)
		 			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;
// GMC
					   if(!pmbmd->m_bMCSEL)
// ~GMC
						mvLookupUVWithShape (pmbmd, pmv, iXRefUV, iYRefUV);
// 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, &m_rctRefVOPY0);
						else
							copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0);
					}
				}
				if (pmbmd->m_rgTranspStatus [0] == PARTIAL)
					mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL/*ppxlcCurrQMBA*/);
				padNeighborTranspMBs (
					iMBX, iMBY,
					pmbmd,
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL /*ppxlcCurrQMBA*/
				);
			}
			else {
				padCurrAndTopTranspMBFromNeighbor (
					iMBX, iMBY,
					pmbmd,
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL /*ppxlcCurrQMBA*/
				);
			}

			pmbmd++;
			pmv += PVOP_MV_PER_REF_PER_MB;
			piIntraDC += V_BLOCK;
			ppxlcCurrQMBY += MB_SIZE;
			ppxlcCurrQMBU += BLOCK_SIZE;
			ppxlcCurrQMBV += BLOCK_SIZE;
			ppxlcCurrQMBBY += MB_SIZE;
			ppxlcCurrQMBBUV += BLOCK_SIZE;
			//ppxlcCurrQMBA += MB_SIZE;

			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;
				ppxlcCurrQBY += m_iFrameWidthYxMBSize;
				ppxlcCurrQBUV += m_iFrameWidthYxBlkSize;
//				ppxlcCurrQA  += m_iFrameWidthYxMBSize;
			}
		}
	} while( checkResyncMarker() );

	delete m_piIntraDC;
	delete m_piMCBPC;
}

// End Toshiba

Void CVideoObjectDecoder::decodeMBTextureDCOfIVOP_DataPartitioning (CMBMode* pmbmd, Int& iCurrentQP,
																	Int* piIntraDC, Bool *pbRestart)
{
	Int iBlk = 0;
	
	pmbmd->m_intStepDelta = 0;
	pmbmd->m_bSkip = FALSE;