vopmbdec.cpp

网络MPEG4IP流媒体开发源代码

				pmbmd->m_bColocatedMBSkip = (pmbmdRef==NULL ? FALSE : pmbmdRef->m_bSkip);
			else
				pmbmd->m_bColocatedMBSkip = FALSE;
			if (pmbmd->m_bColocatedMBSkip &&
				(m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
			{
				copyFromRefToCurrQ (
					m_pvopcRefQ0,
					x, y, 
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL
				);
				pmbmd->m_bSkip = TRUE;
				memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
				memset (pmvBackward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
				pmbmd->m_mbType = FORWARD; // can be set to FORWARD mode since the result is the same
			}
			else {
				if	(checkResyncMarker())	{
					decodeVideoPacketHeader(iCurrentQP);
					iVideoPacketNumber++;
					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;
				}
				pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;	//mv out of if by wchen to set even when errR is off; always used in mbdec 
				//	End Toshiba(1998-1-16:B-VOP+Error)
				decodeMBTextureHeadOfBVOP (pmbmd, iCurrentQP);
				decodeMVofBVOP (pmv, pmvBackward, pmbmd, iMBX, iMBY, pmvRef, pmbmdRef);
				if (!pmbmd->m_bSkip) {
					decodeTextureInterMB (pmbmd);
// INTERLACE
					if (m_vopmd.bInterlace == TRUE && pmbmd->m_bFieldDCT == TRUE)
						fieldDCTtoFrameI(m_ppxliErrorMBY);
// ~INTERLACE
					motionCompAndAddErrorMB_BVOP (
						pmv, pmvBackward,
						pmbmd, 
						iMBX, iMBY, 
						x, y,
						ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
						&m_rctRefVOPY0,&m_rctRefVOPY1);
				}
				else {
                    if (m_vopmd.bInterlace) {                       // Need to remove this 'if' (Bob Eifrig)
					    assert(pmbmd->m_mbType == DIRECT);
					    pmbmd->m_vctDirectDeltaMV.x = 0; 
						pmbmd->m_vctDirectDeltaMV.y = 0;
					    memset (m_ppxliErrorMBY, 0, MB_SQUARE_SIZE * sizeof(Int));
					    memset (m_ppxliErrorMBU, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
					    memset (m_ppxliErrorMBV, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
					    motionCompAndAddErrorMB_BVOP (
						    pmv, pmvBackward,
						    pmbmd, 
						    iMBX, iMBY, 
						    x, y,
						    ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
						    &m_rctRefVOPY0, &m_rctRefVOPY1);
                    } else {
					    motionCompSkipMB_BVOP (pmbmd, pmv, pmvBackward,
						    x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0, &m_rctRefVOPY1);
                    }
				}
			}

			if(m_bCodedFutureRef!=FALSE)
			{
				pmbmdRef++;
				pmvRef += PVOP_MV_PER_REF_PER_MB;
			}

			pmbmd++;
			pmv         += BVOP_MV_PER_REF_PER_MB;
			pmvBackward += BVOP_MV_PER_REF_PER_MB;
			ppxlcCurrQMBY += MB_SIZE;
			ppxlcCurrQMBU += BLOCK_SIZE;
			ppxlcCurrQMBV += BLOCK_SIZE;
		}
		ppxlcCurrQY += m_iFrameWidthYxMBSize;
		ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
		ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
	}
}

Void CVideoObjectDecoder::decodeBVOP_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* pmvBackward = m_rgmvBackward;
	CMotionVector* pmvBY = m_rgmvBY;
	const CMotionVector* pmvRef;
	const CMBMode* pmbmdRef;

	PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcCurrQ->pixelsBY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQA  = (PixelC*) m_pvopcCurrQ->pixelsA () + m_iStartInRefToCurrRctY;

	// decide prediction direction for shape
	if(m_bCodedFutureRef==FALSE)
		m_vopmd.fShapeBPredDir = B_FORWARD;
	else
	{
		if(m_tFutureRef - m_t >= m_t - m_tPastRef)
			m_vopmd.fShapeBPredDir = B_FORWARD;
		else
			m_vopmd.fShapeBPredDir = B_BACKWARD;
	}

	Int iCurrentQP  = m_vopmd.intStepB;		
	Int iCurrentQPA = m_vopmd.intStepBAlpha;
	//	Added for error resilient mode by Toshiba(1998-1-16:B-VOP+Error)
	Int	iVideoPacketNumber = 0;
	m_iVPMBnum = 0;
	//	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;
		PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
		PixelC* ppxlcCurrQMBA  = ppxlcCurrQA;
		CoordI x = m_rctCurrVOPY.left; 
		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) {
			//	Added for error resilient mode by Toshiba(1998-1-16:B-VOP+Error)
			if	(checkResyncMarker())	{
				decodeVideoPacketHeader(iCurrentQP);
				iVideoPacketNumber++;
				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;
			}
			pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;	//mv out of if by wchen to set even when errR is off; always used in mbdec 
			//	End Toshiba(1998-1-16:B-VOP+Error)
			pmbmd->m_bPadded=FALSE;
			findColocatedMB (iMBX, iMBY, pmbmdRef, pmvRef);
			pmbmd->m_bColocatedMBSkip = (pmbmdRef!=NULL && pmbmdRef->m_bSkip);
			if(m_vopmd.bShapeCodingType)
			{
				ShapeMode shpmdColocatedMB;
				if(m_vopmd.fShapeBPredDir==B_FORWARD)
					shpmdColocatedMB = m_rgshpmd [MIN (MAX (0, iMBX), m_iRefShpNumMBX - 1)
					+ MIN (MAX (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
				else
					shpmdColocatedMB = m_rgmbmdRef [MIN (MAX (0, iMBX), m_iNumMBXRef - 1)
						+ MIN (MAX (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
					
				decodeInterShape (
					m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
					pmbmd, iMBX, iMBY, x, y,
					NULL, pmvBY, m_ppxlcCurrMBBY, ppxlcCurrQMBBY, shpmdColocatedMB);
			} else {
				decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY, ppxlcCurrQMBBY);
			}

			if(m_volmd.bShapeOnly==FALSE)
			{
				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_bColocatedMBSkip &&
					(m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0))) { 
					// don't need to send any bit for this mode except enhn_layer
					copyFromRefToCurrQ (
						m_pvopcRefQ0,
						x, y, 
						ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
						&m_rctRefVOPY0
					);
					if(m_volmd.fAUsage == EIGHT_BIT)
						copyAlphaFromRefToCurrQ(m_pvopcRefQ0, x, y, ppxlcCurrQMBA, &m_rctRefVOPY0);
					pmbmd->m_bSkip = TRUE;
					memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
					memset (pmvBackward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
					pmbmd->m_mbType = FORWARD; // can be set to FORWARD mode since the result is the same
				}
				else {
					if (pmbmd->m_rgTranspStatus [0] != ALL) {
						/*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)*/
						decodeMBTextureHeadOfBVOP (pmbmd, iCurrentQP);
						decodeMVofBVOP (pmv, pmvBackward, pmbmd, iMBX, iMBY, pmvRef, pmbmdRef);
						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
							//motionCompAndAddErrorMB_BVOP ( // delete by Hyundai, ok swinder
							//	pmv, pmvBackward,
							//	pmbmd, 
							//	iMBX, iMBY, 
							//	x, y,
							//	ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
							//	&m_rctRefVOPY0, &m_rctRefVOPY1
							//);
						}
						else {
				// new changes 10/20/98
							if (m_vopmd.bInterlace) {                       
								assert(pmbmd->m_mbType == DIRECT);
								pmbmd->m_vctDirectDeltaMV.x = 0; 
								pmbmd->m_vctDirectDeltaMV.y = 0;
								memset (m_ppxliErrorMBY, 0, MB_SQUARE_SIZE * sizeof(Int));
								memset (m_ppxliErrorMBU, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
								memset (m_ppxliErrorMBV, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
								motionCompAndAddErrorMB_BVOP (
									pmv, pmvBackward,
									pmbmd, 
						    		iMBX, iMBY, 
									x, y,
									ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
									&m_rctRefVOPY0, &m_rctRefVOPY1);
							} else 
				// end of new changes 10/20/98
							{
							//assert(pmbmdRef!=NULL);
							motionCompSkipMB_BVOP (pmbmd, pmv, pmvBackward, x, y,
								ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0, &m_rctRefVOPY1);

							}
						}
						if(m_volmd.fAUsage == EIGHT_BIT)
						{
							decodeMBAlphaHeadOfBVOP(pmbmd, iCurrentQP, iCurrentQPA);
							decodeAlphaInterMB(pmbmd, ppxlcCurrQMBA);

							/* delete by Hyundai, ok swinder
							if (pmbmd->m_CODAlpha!=ALPHA_ALL255)
							{
								motionCompAlphaMB_BVOP(
									pmv, pmvBackward,
									pmbmd, 
									iMBX, iMBY, 
									x, y,
									ppxlcCurrQMBA,
									&m_rctRefVOPY0, &m_rctRefVOPY1
								);

								if(pmbmd->m_CODAlpha==ALPHA_SKIPPED)
									assignAlphaPredToCurrQ (ppxlcCurrQMBA);
								else
									addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA);
							}
							*/
						}
						/*BBM// Added for Boundary by Hyundai(1998-5-9)
						if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
								mergedMacroBlockSplit (pmbmd);
						// End of Hyundai(1998-5-9)*/
						if (!pmbmd->m_bSkip) {
								motionCompAndAddErrorMB_BVOP (
										pmv, pmvBackward,
										pmbmd,
										iMBX, iMBY,
										x, y,
										ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
										&m_rctRefVOPY0, &m_rctRefVOPY1
								);
						}          
						if (m_volmd.fAUsage == EIGHT_BIT) {
								if (pmbmd->m_CODAlpha!=ALPHA_ALL255)
								{  
										motionCompAlphaMB_BVOP(
												pmv, pmvBackward,
												pmbmd,
												iMBX, iMBY,
												x, y,
												ppxlcCurrQMBA,
												&m_rctRefVOPY0, &m_rctRefVOPY1
										);

										if(pmbmd->m_CODAlpha==ALPHA_SKIPPED)
												assignAlphaPredToCurrQ (ppxlcCurrQMBA);
										else
												addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA);
								}
						}
					}
				}
				//padding of bvop is necessary for temporal scalability: bvop in base layer is used for prediction in enhancement layer

				// Added for field based MC padding by Hyundai(1998-5-9)
				if (!m_vopmd.bInterlace) {
					if (pmbmd -> m_rgTranspStatus [0] != ALL) {
						if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
							mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA);
						padNeighborTranspMBs (
							iMBX, iMBY,
							pmbmd,
							ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
						);
					}
					else {
						padCurrAndTopTranspMBFromNeighbor (
							iMBX, iMBY,
							pmbmd,
							ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
						);
					}
				}
				// End of Hyundai(1998-5-9)
			}
			pmbmd++;
			pmv += BVOP_MV_PER_REF_PER_MB;
			pmvBY++;
			pmvBackward += BVOP_MV_PER_REF_PER_MB;
			ppxlcCurrQMBY += MB_SIZE;
			ppxlcCurrQMBU += BLOCK_SIZE;
			ppxlcCurrQMBV += BLOCK_SIZE;
			ppxlcCurrQMBBY += MB_SIZE;
			ppxlcCurrQMBA += MB_SIZE;
		}
		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_pvopcCurrQ);
        // End of Hyundai(1998-5-9)
}