vopmbdec.cpp

网络MPEG4IP流媒体开发源代码

		// dx_in_gob = ;
		// dy_in_gob = ;
	}

	Bool bRestartDelayedQP = TRUE; // decodeMBTextureHeadOfIVOP sets this to false

	uiGobNumber=0;
	lastbits =  m_pbitstrmIn->get_used_bits();
	while (uiGobNumber < uiNumberOfGobs) { 
		if (short_video_header) {
			uiGobHeaderEmpty=1;
			if (uiGobNumber != 0) {
				if (m_pbitstrmIn->peekBits(17)==1) {
					uiGobHeaderEmpty=0;
					/* UInt uiGobResyncMarker= wmay */m_pbitstrmIn -> getBits (17);
					uiGobNumber=m_pbitstrmIn -> getBits(5);
					/* UInt uiGobFrameId = wmay */ m_pbitstrmIn -> getBits(2);
					/* UInt uiVopQuant= wmay */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;
	// Begin: modified by Hughes	  4/9/98
	//		if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
			if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP) {
	// end:  modified by Hughes	  4/9/98
				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;

				if	(checkResyncMarker())	{
					decodeVideoPacketHeader(iCurrentQP);
					iVideoPacketNumber++;
					bRestartDelayedQP = TRUE;
				}
#if 0
				{
				uint32_t temp = m_pbitstrmIn->get_used_bits();
			//printf("Macroblock %d %d %x - bits since last %d total %d\n", iMBY, iMBX, m_pbitstrmIn->peekBits(32),	
			       temp - lastbits, temp);
			lastbits = temp;
				}
			if (iMBY == 3 && iMBX == 5) {
			  printf("This is the breakpoint\n");
			  m_pbitstrmIn->start_dump();
			}
#endif
				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;
				ppxlcRefMBU += BLOCK_SIZE;
				ppxlcRefMBV += BLOCK_SIZE;
	// Begin: modified by Hughes	  4/9/98
	//			if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP)
				if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP)  // get the hole status for the next MB
	// end:  modified by Hughes	  4/9/98
					bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(iMBX+1, iMBY, pmbmd);	 			
				else
					bSptMB_NOT_HOLE= TRUE;
			}
			MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
			m_rgpmbmAbove = m_rgpmbmCurr;
			
	// dshu: [v071] begin of modification	   1/18/98
	// Begin: modified by Hughes	  4/9/98
	// 		if  (m_uiSprite == 1)
 			if  (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE)
	// end:  modified by Hughes	  4/9/98
				SaveMBmCurrRow (iMBY, m_rgpmbmCurr);		 //	  save current row pointed by *m_rgpmbmCurr 
	// dshu: [v071] end of modification

			m_rgpmbmCurr  = ppmbmTemp;
			ppxlcRefY += m_iFrameWidthYxMBSize;
			ppxlcRefU += m_iFrameWidthUVxBlkSize;
			ppxlcRefV += m_iFrameWidthUVxBlkSize;
	// dshu: [v071] begin of modification	   1/18/98	move these statements up
	//		if  (m_uiSprite == 1)
	//			SaveMBmCurrRow (iMBY, m_rgpmbmCurr);		 //	  save current row pointed by *m_rgpmbmCurr 
	// dshu: [v071] end of modification
		}
	} // KPN Terminate while loop Gob layer [FDS]
}

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;

	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;
	
	Int iCurrentQP  = m_vopmd.intStep;	
	Int iCurrentQPA = m_vopmd.intStepPAlpha;	
	//	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) {
			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 {
			decodeIntraShape (pmbmd, 0, iMBY, m_ppxlcCurrMBBY,
				ppxlcCurrQMBBY);
		}
		// End Toshiba(1997-11-14)
		downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
		/*BBM// Added for Boundary by Hyundai(1998-5-9)
		if (m_vopmd.bInterlace) initMergedMode (pmbmd);
		// End of Hyundai(1998-5-9)*/
		if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
			/*BBM// Added for Boundary by Hyundai(1998-5-9)
            if (m_vopmd.bInterlace && pmbmd->m_rgTranspStatus [0] == PARTIAL)
                    isBoundaryMacroBlockMerged (pmbmd);
			// End of Hyundai(1998-5-9)*/
			decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
			/*BBM// Added for Boundary by Hyundai(1998-5-9)
                        if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
                                swapTransparentModes (pmbmd, BBS);
			// End of Hyundai(1998-5-9)*/
			decodeMVWithShape (pmbmd, 0, iMBY, pmv);
			if(pmbmd->m_bhas4MVForward)
				padMotionVectors(pmbmd,pmv);
		}
		CoordI x = m_rctCurrVOPY.left;
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
			pmbmd->m_bPadded = FALSE;
			if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
				/*BBM// Added for Boundary by Hyundai(1998-5-9)
                if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
                    swapTransparentModes (pmbmd, BBM);
				// End of Hyundai(1998-5-9)*/
				if ((pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) && !pmbmd->m_bSkip) {
					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) {
						decodeMBAlphaHeadOfPVOP (pmbmd, iCurrentQP, iCurrentQPA);
						decodeAlphaIntraMB (pmbmd, iMBX, iMBY, ppxlcCurrQMBA);
					}
				}
				else {
					if (!pmbmd->m_bSkip) {
						decodeTextureInterMB (pmbmd);
// INTERLACE
					//new changes
					if ((pmbmd->m_rgTranspStatus [0] == NONE) && 
						(m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
						fieldDCTtoFrameI(m_ppxliErrorMBY);
			//end of new changes
// ~INTERLACE
					}
					if (m_volmd.fAUsage == EIGHT_BIT) {
						decodeMBAlphaHeadOfPVOP (pmbmd, iCurrentQP, iCurrentQPA);
						decodeAlphaInterMB (pmbmd, ppxlcCurrQMBA);
					}
				}
				/*BBM// Added for Boundary by Hyundai(1998-5-9)
                if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
                        mergedMacroBlockSplit (pmbmd, ppxlcCurrQMBY, ppxlcCurrQMBA);
				// End of Hyundai(1998-5-9)*/
			}
			// decode shape, overhead, and MV for the right MB
			if (iMBX != m_iNumMBX - 1) {
				CMBMode* pmbmdRight = pmbmd + 1;
				//	Added for error resilient mode by Toshiba(1997-11-14)
				if (checkResyncMarker())	{
					decodeVideoPacketHeader(iCurrentQP);
					iVideoPacketNumber++;
					bRestartDelayedQP = TRUE;
				}
				pmbmdRight->m_iVideoPacketNumber = iVideoPacketNumber;
				//	End Toshiba(1997-11-14)
				// Modified for error resilient mode by Toshiba(1997-11-14)
				if(m_vopmd.bShapeCodingType) {
					shpmdColocatedMB = m_rgmbmdRef [
						MIN (MAX (0, iMBX+1), m_iNumMBXRef-1) + 
 						MIN (MAX (0, iMBY), m_iNumMBYRef-1) * m_iNumMBXRef
					].m_shpmd;
					decodeInterShape (
						m_pvopcRefQ0,
						pmbmdRight, 
						iMBX + 1, iMBY, 
						x + MB_SIZE, y, 
						pmv + PVOP_MV_PER_REF_PER_MB, pmvBY + 1, 
						m_ppxlcRightMBBY,
						ppxlcCurrQMBBY + MB_SIZE, 
						shpmdColocatedMB
					);
				}
				else {
					decodeIntraShape (
						pmbmdRight, iMBX + 1, iMBY,
						m_ppxlcRightMBBY,
						ppxlcCurrQMBBY + MB_SIZE
					);
				}
				// End Toshiba(1997-11-14)
				downSampleBY (m_ppxlcRightMBBY, m_ppxlcRightMBBUV);
				/*BBM// Added for Boundary by Hyundai(1998-5-9)
				if (m_vopmd.bInterlace) initMergedMode (pmbmdRight); 
				// End of Hyundai(1998-5-9)*/
				if (pmbmdRight->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
					/*BBM// Added for Boundary by Hyundai(1998-5-9)	
                    if (m_vopmd.bInterlace && pmbmdRight->m_rgTranspStatus [0] == PARTIAL)
                            isBoundaryMacroBlockMerged (pmbmdRight, m_ppxlcRightMBBY);
					// End of Hyundai(1998-5-9)*/
					decodeMBTextureHeadOfPVOP (pmbmdRight, iCurrentQP, bRestartDelayedQP);
					/*BBM// Added for Boundary by Hyundai(1998-5-9)
                    if (m_vopmd.bInterlace && pmbmdRight->m_bMerged[0])
                            swapTransparentModes (pmbmdRight, BBS);
					// End of Hyundai(1998-5-9)*/
					decodeMVWithShape (pmbmdRight, iMBX + 1, iMBY, pmv + PVOP_MV_PER_REF_PER_MB);
					if(pmbmdRight->m_bhas4MVForward)
						padMotionVectors (pmbmdRight,pmv + PVOP_MV_PER_REF_PER_MB);
				}
			}

			if(m_volmd.bShapeOnly==FALSE) {
				if (pmbmd->m_rgTranspStatus [0] != ALL) {
					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) {
							CoordI iXRefUV, iYRefUV;
// INTERLACE //new changes
							if(pmbmd->m_bFieldMV) {
								CoordI iXRefUV1, iYRefUV1;
								mvLookupUV (pmbmd, pmv, iXRefUV, iYRefUV, iXRefUV1, iYRefUV1);
							    motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
								    iXRefUV, iYRefUV, pmbmd->m_bForwardTop);
							    motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
								    m_pvopcRefQ0, x, y, iXRefUV1, iYRefUV1, pmbmd->m_bForwardBottom);
						    }
							else {
// INTERALCE //end of new changes		
							mvLookupUVWithShape (pmbmd, pmv, iXRefUV, iYRefUV);
							motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
								x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
							}
							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 (m_volmd.fAUsage == EIGHT_BIT
							&& pmbmd->m_CODAlpha!=ALPHA_ALL255)
						{
			 				motionCompMB (
								m_ppxlcPredMBA, m_pvopcRefQ0->pixelsA (),
								pmv, pmbmd, 
								iMBX, iMBY, 
								x, y,
								FALSE, TRUE,
								&m_rctRefVOPY0
							);

							if(pmbmd->m_CODAlpha==ALPHA_SKIPPED)
								assignAlphaPredToCurrQ (ppxlcCurrQMBA);
							else
								addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA);