vopmbdec.cpp

网络MPEG4IP流媒体开发源代码

						}

					}
					// Added for field based MC padding by Hyundai(1998-5-9)
                                        if (!m_vopmd.bInterlace) {
						if (pmbmd->m_rgTranspStatus [0] == PARTIAL)
							mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA);
						padNeighborTranspMBs (
							iMBX, iMBY,
							pmbmd,
							ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
						);
					}
					// End of Hyundai(1998-5-9)
				}
				else {
					// Added for field based MC padding by Hyundai(1998-5-9) 
                                        if (!m_vopmd.bInterlace) {
						padCurrAndTopTranspMBFromNeighbor (
							iMBX, iMBY,
							pmbmd,
							ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
						);
					}
					// End of Hyundai(1998-5-9)
				}
			}
			if (iMBX != m_iNumMBX - 1)
				swapCurrAndRightMBForShape ();

			pmbmd++;
			pmv += PVOP_MV_PER_REF_PER_MB;
			pmvBY++;
			ppxlcCurrQMBY += MB_SIZE;
			ppxlcCurrQMBU += BLOCK_SIZE;
			ppxlcCurrQMBV += BLOCK_SIZE;
			ppxlcCurrQMBBY += MB_SIZE;
			ppxlcCurrQMBA += MB_SIZE;
		}
		MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
		m_rgpmbmAbove = m_rgpmbmCurr;
		m_rgpmbmCurr  = ppmbmTemp;

		ppxlcCurrQY  += m_iFrameWidthYxMBSize;
		ppxlcCurrQU  += m_iFrameWidthUVxBlkSize;
		ppxlcCurrQV  += m_iFrameWidthUVxBlkSize;
		ppxlcCurrQBY += m_iFrameWidthYxMBSize;
		ppxlcCurrQA  += m_iFrameWidthYxMBSize;
	}
        // Added for field based MC padding by Hyundai(1998-5-9)
        if (m_vopmd.bInterlace && m_volmd.bShapeOnly == FALSE)
                fieldBasedMCPadding (field_pmbmd, m_pvopcRefQ1);
        // End of Hyundai(1998-5-9)
}

Void CVideoObjectDecoder::decodePVOP ()
{
	Int iMBX, iMBY;
	CoordI y = 0; 
	Int iMBXstart, iMBXstop, iMBYstart, iMBYstop; // added by KPN [FDS]
	UInt uiNumberOfGobs;
	Bool bFirstGobRow;
	CMBMode* pmbmd = m_rgmbmd;
	CMotionVector* pmv = m_rgmv;
	PixelC* ppxlcCurrQY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
	// sprite update piece uses binary mask of the object piece
	PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY; 

	Int iCurrentQP  = m_vopmd.intStep;
	Int	iVideoPacketNumber = 0;
	//	Added for error resilient mode by Toshiba(1997-11-14)
	m_iVPMBnum = 0;
	//	End Toshiba(1997-11-14)
	Bool bLeftBndry;
	Bool bRightBndry;
	Bool bTopBndry;
	Bool bZeroMV = (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3) ? TRUE : FALSE;
	
	bFirstGobRow=FALSE;

	Bool bRestartDelayedQP = TRUE;

	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;
		//uiNumMacroblocksInGob=8;
		// dx_in_gob = ;
		// dy_in_gob = ;
	}
	
	uiGobNumber=0;
	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); 
				
					bFirstGobRow=TRUE; 
					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++, y += MB_SIZE) {
			PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
			PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
			PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
			//	  In a given Sprite update piece, Check whether current macroblock is not a hole and should be coded ?
			PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
			Bool  bSptMB_NOT_HOLE= TRUE;
			if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) 
				bSptMB_NOT_HOLE = SptUpdateMB_NOT_HOLE(0, iMBY, pmbmd); 

			//	Added for error resilience mode By Toshiba
			if	(iMBY != 0)	{
				if	(checkResyncMarker()) {
					decodeVideoPacketHeader(iCurrentQP);
					iVideoPacketNumber++;
					bRestartDelayedQP = TRUE;
				}
			}
			pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
			if (iMBY==0)	{
				bRightBndry = TRUE;
				bTopBndry = TRUE;
			}
			else	{
				bRightBndry = !((pmbmd - m_iNumMBX + 1) -> m_iVideoPacketNumber == pmbmd->m_iVideoPacketNumber);
				bTopBndry = !((pmbmd - m_iNumMBX) -> m_iVideoPacketNumber == pmbmd->m_iVideoPacketNumber);
			}
			if (bFirstGobRow) // Added by KPN
			{
				bTopBndry=TRUE;
				bRightBndry=TRUE;
			}

			// only RECTANGLE or non-transparent MB  will be decoded  for the update piece
			if (m_uiSprite == 0) {
				decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
				decodeMV (pmbmd, pmv, TRUE, bRightBndry, bTopBndry, bZeroMV, 0, iMBY);
			} 
			else if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
				if (m_volmd.fAUsage != RECTANGLE) {
					if (pmbmd -> m_rgTranspStatus [0] != ALL)
						decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
				}
				else
					decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
			} 

			CoordI x = 0;
			for (iMBX = iMBXstart; iMBX < iMBXstop; iMBX++, x += MB_SIZE) { // [FDS]

				if (m_uiSprite == 0) {
					if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
						decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
						if ((m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
							fieldDCTtoFrameC(ppxlcCurrQMBY);
					} else {
						if (!pmbmd->m_bSkip) {
							decodeTextureInterMB (pmbmd);
							if ((m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
								fieldDCTtoFrameI(m_ppxliErrorMBY);
						}
					}
				}
				// only non-transparent MB and COD == 0 will be decoded
				else if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP)
					// sprite update piece use P_VOP syntax with no MV
				{
					pmv -> setToZero ();  
					pmbmd->m_bhas4MVForward = FALSE ;  
					pmbmd -> m_dctMd = INTER ;			
					if ((pmbmd -> m_rgTranspStatus [0] != ALL) && (!pmbmd->m_bSkip))
						decodeTextureInterMB (pmbmd);
				}

				if (iMBX != m_iNumMBX - 1) {				
					CMBMode* pmbmdRight = pmbmd + 1;
					if (checkResyncMarker())	{
						decodeVideoPacketHeader(iCurrentQP);
						iVideoPacketNumber++;
						bRestartDelayedQP = TRUE;
					}
					pmbmdRight->m_iVideoPacketNumber = iVideoPacketNumber;
					if (iMBY == 0 || bFirstGobRow==TRUE)	{  // [FDS]
						bLeftBndry = !(pmbmd -> m_iVideoPacketNumber == pmbmdRight -> m_iVideoPacketNumber);
						bRightBndry = TRUE;
						bTopBndry = TRUE;
					}
					else	{
						bLeftBndry =  !(pmbmd -> m_iVideoPacketNumber == pmbmdRight -> m_iVideoPacketNumber);
						if ((iMBX + 1) == m_iNumMBX - 1)
							bRightBndry = TRUE;
						else
							bRightBndry = !((pmbmdRight - m_iNumMBX + 1) -> m_iVideoPacketNumber == pmbmdRight->m_iVideoPacketNumber);
						bTopBndry = !((pmbmdRight - m_iNumMBX) -> m_iVideoPacketNumber == pmbmdRight->m_iVideoPacketNumber);
					}
					if (m_uiSprite == 0)	{
						decodeMBTextureHeadOfPVOP (pmbmdRight, iCurrentQP, bRestartDelayedQP);
						decodeMV (pmbmdRight, pmv + PVOP_MV_PER_REF_PER_MB, bLeftBndry, bRightBndry, bTopBndry, bZeroMV, iMBX+1, iMBY);
					}
					// sprite update piece use P_VOP syntax with no MV
					else if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) 	
					{
						bSptMB_NOT_HOLE = SptUpdateMB_NOT_HOLE(iMBX+1, iMBY, pmbmdRight);
						ppxlcCurrQMBBY += MB_SIZE;
						if (pmbmdRight -> m_rgTranspStatus [0] != ALL)
							decodeMBTextureHeadOfPVOP (pmbmdRight, iCurrentQP, bRestartDelayedQP);
					}
				}
				if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) {
					if (m_uiSprite == 0)	{
						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, iXRefUV1, iYRefUV1;
							mvLookupUV (pmbmd, pmv, iXRefUV, iYRefUV, iXRefUV1, iYRefUV1);
	// INTERLACE
							if(pmbmd->m_bFieldMV) {
								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 
	// ~INTERLACE
								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, NULL);
							else
								copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL);
						}
					} // end else from "if ( m_vopmd.SpriteXmitMode != STOP)" 
					// sprite update piece use P_VOP syntax with no motionCompMB
					else if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) 	
					{
						CopyCurrQToPred(ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
						if ((!pmbmd->m_bSkip) && (pmbmd -> m_rgTranspStatus [0] != ALL)) {
							addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
						}
					}
				}
				pmbmd++;
				pmv += PVOP_MV_PER_REF_PER_MB;
				ppxlcCurrQMBY += MB_SIZE;
				ppxlcCurrQMBU += BLOCK_SIZE;
				ppxlcCurrQMBV += BLOCK_SIZE;
			}
			MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
			m_rgpmbmAbove = m_rgpmbmCurr;
			m_rgpmbmCurr  = ppmbmTemp;
			ppxlcCurrQY += m_iFrameWidthYxMBSize;
			ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
			ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
			ppxlcCurrQBY += m_iFrameWidthYxMBSize;
			bFirstGobRow=FALSE; // KPN
		}
	} // Terminate while loop
}

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))