sys_decoder_vopmbdec.cpp

完整的RTP RTSP代码库

							if (!m_volmd.bSadctDisable)
								decodeAlphaIntraMB (pmbmd, iMBX, iMBY, pppxlcCurrQMBA[iAuxComp], iAuxComp, m_ppxlcCurrMBBY);
							else
								decodeAlphaIntraMB (pmbmd, iMBX, iMBY, pppxlcCurrQMBA[iAuxComp], iAuxComp);
						}
						// end HHI						
					}
				}
				else {
					if (!pmbmd->m_bSkip) {
						// HHI Schueuer: sadct
						if (!m_volmd.bSadctDisable)
							decodeTextureInterMB (pmbmd, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
						else
							decodeTextureInterMB (pmbmd);
						// end HHI
						// 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) {
						for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ ) { // MAC (SB) 1-Dec-99
							decodeMBAlphaHeadOfPVOP (pmbmd, iCurrentQP, iCurrentQPA[iAuxComp], iAuxComp);
							// HHI Schueuer
							if (!m_volmd.bSadctDisable)
								decodeAlphaInterMB (pmbmd, pppxlcCurrQMBA[iAuxComp], iAuxComp, m_ppxlcCurrMBBY);
							else
								decodeAlphaInterMB (pmbmd, pppxlcCurrQMBA[iAuxComp], iAuxComp);
							// end HHI						
						}
					}
				}
			}
			// 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) {
					//OBSS_SAIT_991015
					//OBSSFIX_MODE3
                    if(!(m_volmd.bSpatialScalability && m_volmd.iHierarchyType== 0)){       
						//                  if(!(m_volmd.bSpatialScalability)){     
						//~OBSSFIX_MODE3
						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 {
						//OBSSFIX_MODE3
						if(m_volmd.volType == ENHN_LAYER && m_volmd.iEnhnType==1 && m_volmd.iuseRefShape == 1 ){
							shpmdColocatedMB = ALL_OPAQUE;
                            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 
							//~OBSSFIX_MODE3          
							if((m_volmd.volType == BASE_LAYER) || (!(m_volmd.iEnhnType==0 || m_volmd.iuseRefShape ==0) && !m_volmd.bShapeOnly)){		
								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 if(m_volmd.volType == ENHN_LAYER) { // for spatial scalability
								Int index = MIN (MAX (0, ((iMBX+xIndex+1)*m_volmd.ihor_sampling_factor_m_shape/m_volmd.ihor_sampling_factor_n_shape)), (m_iNumMBBaseXRef-1)) +				
									MIN (MAX (0, (iMBY+yIndex)*m_volmd.iver_sampling_factor_m_shape/m_volmd.iver_sampling_factor_n_shape), (m_iNumMBBaseYRef-1)) * m_iNumMBBaseXRef;		
								shpmdColocatedMB = m_rgBaseshpmd [index];
								decodeSIShapePVOP (
									m_pvopcRefQ0,
									pmbmdRight, 
									iMBX + 1, iMBY, 
									x + MB_SIZE, y, 
									pmv + PVOP_MV_PER_REF_PER_MB, pmvBY + 1, 
									m_rgmvBaseBY,
									m_ppxlcRightMBBY,
									ppxlcCurrQMBBY + MB_SIZE, 
									shpmdColocatedMB								
									);
							}
					}
					//~OBSS_SAIT_991015
				}
				else {
					decodeIntraShape (
						pmbmdRight, iMBX + 1, iMBY,
						m_ppxlcRightMBBY,
						ppxlcCurrQMBBY + MB_SIZE
						);
				}
				// End Toshiba(1997-11-14)
				// Changed HHI 2000-04-11
				downSampleBY (m_ppxlcRightMBBY, m_ppxlcRightMBBUV, pmbmdRight);
				if (pmbmdRight->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
					decodeMBTextureHeadOfPVOP (pmbmdRight, iCurrentQP, &bRestartDelayedQP);
					// GMC
					if(!pmbmdRight -> m_bMCSEL)
						// ~GMC
						decodeMVWithShape (pmbmdRight, iMBX + 1, iMBY, pmv + PVOP_MV_PER_REF_PER_MB);
					// GMC
					else
					{
						Int iPmvx, iPmvy, iHalfx, iHalfy;
						globalmv (iPmvx, iPmvy, iHalfx, iHalfy,
							x+16,y,m_vopmd.mvInfoForward.uiRange,
							m_volmd.bQuarterSample);
						CMotionVector* pmvcurr = pmv + PVOP_MV_PER_REF_PER_MB;
						*pmvcurr = CMotionVector (iPmvx, iPmvy);
						pmvcurr -> iHalfX = iHalfx;
						pmvcurr -> iHalfY = iHalfy;
						pmvcurr -> computeTrueMV ();
						pmvcurr -> computeMV ();
						for (UInt i = 1; i < PVOP_MV_PER_REF_PER_MB; i++)
							pmvcurr[i] = *pmvcurr;
					}
					// ~GMC
					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 && !pmbmd->m_bMCSEL)) { // GMC
							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,
									&m_rctRefVOPY0); // added by Y.Suzuki for the extended bounding box support
								motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
									m_pvopcRefQ0, x, y, iXRefUV1, iYRefUV1, pmbmd->m_bForwardBottom,
									&m_rctRefVOPY0); // added by Y.Suzuki for the extended bounding box support
							}
							// GMC
							else if(pmbmd->m_bMCSEL) {
								FindGlobalChromPredForGMC(x,y,m_ppxlcPredMBU,m_ppxlcPredMBV);
							}
							// ~GMC
							else {
								// INTERALCE //end of new changes		
								// GMC
								if (!pmbmd->m_bMCSEL)
									// ~GMC
									mvLookupUVWithShape (pmbmd, pmv, iXRefUV, iYRefUV);
								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 (m_volmd.fAUsage == EIGHT_BIT) {
							for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ ) { // MAC (SB) 1-Dec-99
								if (pmbmd->m_pCODAlpha[iAuxComp]!=ALPHA_ALL255)
								{
									motionCompMB (
										m_ppxlcPredMBA[iAuxComp], m_pvopcRefQ0->pixelsA (iAuxComp),
										pmv, pmbmd, 
										iMBX, iMBY, 
										x, y,
										FALSE, TRUE,
										&m_rctRefVOPY0
										);
									
									if(pmbmd->m_pCODAlpha[iAuxComp]==ALPHA_SKIPPED)
										assignAlphaPredToCurrQ (pppxlcCurrQMBA[iAuxComp],iAuxComp);
									else
										addAlphaErrorAndPredToCurrQ (pppxlcCurrQMBA[iAuxComp],iAuxComp);
								}
							}
						}
					}
					// 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, pppxlcCurrQMBA);
						padNeighborTranspMBs (
							iMBX, iMBY,
							pmbmd,
							ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, pppxlcCurrQMBA
							);
					}
					// 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, pppxlcCurrQMBA
							);
					}
					// 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);
    if(m_volmd.bSpatialScalability && m_volmd.volType == ENHN_LAYER && m_volmd.iHierarchyType==0 &&
		!(m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1) ){ // if SpatialScalability
        delete m_pvopcRefQ0->getPlane (BY_PLANE)->m_pbHorSamplingChk;
        delete m_pvopcRefQ0->getPlane (BY_PLANE)->m_pbVerSamplingChk;
    }
    delete [] pppxlcCurrQMBA;
}

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;
	
	// NEWPRED
	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;
	Bool bRet;
	int newpred_resync;
	// ~NEWPRED
	
	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;
	}
	
	uiGobNumber=0;
	while (uiGobNumber < uiNumberOfGobs) { 
		if (short_video_header) {
			uiGobHeaderEmpty=1;
			if (uiGobNumber != 0) {
				if (checkGOBMarker()) {
					uiGobHeaderEmpty=0;
					m_pbitstrmIn -> flush();
					/* UInt uiGobResyncMarker= */m_pbitstrmIn -> getBits (17);
					uiGobNumber=m_pbitstrmIn -> getBits(5);