sys_decoder_vopmbdec.cpp

完整的RTP RTSP代码库

					
					/* UInt uiGobFrameId = */m_pbitstrmIn -> getBits(2);
					
					/* UInt uiVopQuant= */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++; 
		}
		
		// NEWPRED
		if (m_volmd.bNewpredEnable) {
			g_pNewPredDec->CopyReftoBuf(RefbufY, RefbufU, RefbufV, m_rctRefFrameY, m_rctRefFrameUV);
			bRet = FALSE;
			
			RefpointY = (PixelC*) g_pNewPredDec->m_pchNewPredRefY +
				(EXPANDY_REF_FRAME * m_rctRefFrameY.width);
			RefpointU = (PixelC*) g_pNewPredDec->m_pchNewPredRefU +
				((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width);
			RefpointV = (PixelC*) g_pNewPredDec->m_pchNewPredRefV +
				((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width);
			bRet = g_pNewPredDec->CopyNPtoVM(iVideoPacketNumber, RefpointY, RefpointU, RefpointV);
			
			pRefpointY = (PixelC*) m_pvopcRefQ0->pixelsY () + m_iStartInRefToCurrRctY;
			pRefpointU = (PixelC*) m_pvopcRefQ0->pixelsU () + m_iStartInRefToCurrRctUV;
			pRefpointV = (PixelC*) m_pvopcRefQ0->pixelsV () + m_iStartInRefToCurrRctUV;
			g_pNewPredDec->ChangeRefOfSlice((const PixelC* )pRefpointY,	RefbufY,
				(const PixelC* )pRefpointU,	RefbufU,
				(const PixelC* )pRefpointV,	RefbufV,
				0, 0,	m_rctRefFrameY, m_rctRefFrameUV);
			repeatPadYOrA ((PixelC*) m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ0);
			repeatPadUV (m_pvopcRefQ0);
			
			for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
				for (iMBX = 0; iMBX < m_iNumMBX; iMBX++)	{
					// RRV modification
					(pmbmd + iMBX + m_iNumMBX*iMBY) -> m_iNPSegmentNumber = g_pNewPredDec->GetSliceNum((iMBX *m_iRRVScale),(iMBY *m_iRRVScale));
					//					(pmbmd + iMBX + m_iNumMBX*iMBY) -> m_iNPSegmentNumber = g_pNewPredDec->GetSliceNum(iMBX,iMBY);
					// ~RRV
				}
			}
		}
		// ~NEWPRED
		
		for (iMBY = iMBYstart; iMBY < iMBYstop; iMBY++, y += (MB_SIZE *m_iRRVScale)) {
			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
			skipAnyStuffing();
			if	(checkResyncMarker()) {
				decodeVideoPacketHeader(iCurrentQP);
				iVideoPacketNumber++;
				bRestartDelayedQP = TRUE;
				// NEWPRED
				bRet = FALSE;
				if (m_volmd.bNewpredEnable && (m_volmd.bNewpredSegmentType == 0))
				{ 	
					// RRV modification
					RefpointY = (PixelC*) g_pNewPredDec->m_pchNewPredRefY +
						(EXPANDY_REF_FRAME * m_rctRefFrameY.width) + 
						iMBY * (MB_SIZE *m_iRRVScale) * m_rctRefFrameY.width;
					RefpointU = (PixelC*) g_pNewPredDec->m_pchNewPredRefU +
						((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width) + 
						iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
					RefpointV = (PixelC*) g_pNewPredDec->m_pchNewPredRefV +
						((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width) + 
						iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
					bRet = g_pNewPredDec->CopyNPtoVM(iVideoPacketNumber, RefpointY, RefpointU, RefpointV);
					
					pRefpointY = (PixelC*) m_pvopcRefQ0->pixelsY () + m_iStartInRefToCurrRctY + iMBY * (MB_SIZE *m_iRRVScale) * m_rctRefFrameY.width;
					pRefpointU = (PixelC*) m_pvopcRefQ0->pixelsU () + m_iStartInRefToCurrRctUV + iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
					pRefpointV = (PixelC*) m_pvopcRefQ0->pixelsV () + m_iStartInRefToCurrRctUV + iMBY * (BLOCK_SIZE *m_iRRVScale)* m_rctRefFrameUV.width;
					g_pNewPredDec->ChangeRefOfSlice((const PixelC* )pRefpointY, RefbufY,(const PixelC* )pRefpointU, RefbufU,
						(const PixelC* )pRefpointV, RefbufV, 0, (iMBY *m_iRRVScale),m_rctRefFrameY, m_rctRefFrameUV);
					repeatPadYOrA ((PixelC*) m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ0);
					repeatPadUV (m_pvopcRefQ0);
				}
				// ~NEWPRED
			}

			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 || m_uiSprite == 2) { // GMC
				decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, &bRestartDelayedQP);

				// GMC
				if(!pmbmd -> m_bMCSEL)
					// ~GMC
					decodeMV (pmbmd, pmv, TRUE, bRightBndry, bTopBndry, bZeroMV, 0, iMBY);
				// GMC
				else
				{
					Int iPmvx, iPmvy, iHalfx, iHalfy;
					globalmv (iPmvx, iPmvy, iHalfx, iHalfy,
						0,y,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;
				}
				// ~GMC
			} 
			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;
			// RRV modification
			for (iMBX = iMBXstart; iMBX < iMBXstop; iMBX++, x += (MB_SIZE *m_iRRVScale)) { // [FDS]
				newpred_resync = 0;
				if (m_uiSprite == 0 || m_uiSprite == 2) { // GMC
					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;
					skipAnyStuffing();
					if (checkResyncMarker())	{
						decodeVideoPacketHeader(iCurrentQP);
						iVideoPacketNumber++;
						bRestartDelayedQP = TRUE;
						
						// NEWPRED
						newpred_resync = 1;
						// ~NEWPRED
					}
					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 || m_uiSprite == 2) { // GMC
						decodeMBTextureHeadOfPVOP (pmbmdRight, iCurrentQP, &bRestartDelayedQP);
						// GMC
						if(!pmbmdRight -> m_bMCSEL)
							// ~GMC
							decodeMV (pmbmdRight, pmv + PVOP_MV_PER_REF_PER_MB, bLeftBndry, bRightBndry, bTopBndry, bZeroMV, iMBX+1, iMBY);
						// 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
					}
					// 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 || m_uiSprite == 2) { // GMC
						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, iXRefUV1, iYRefUV1;
							// GMC
							if (!pmbmd->m_bMCSEL)
								// ~GMC
								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,
									&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 
								// ~INTERLACE
								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, 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);
						}
					}
				}
				
				if (newpred_resync) {
					bRet = FALSE;
					if (m_volmd.bNewpredEnable && (m_volmd.bNewpredSegmentType == 0)) {
						RefpointY = (PixelC*) g_pNewPredDec->m_pchNewPredRefY +
							(EXPANDY_REF_FRAME * m_rctRefFrameY.width) + 
							iMBY * (MB_SIZE *m_iRRVScale) * m_rctRefFrameY.width;
						RefpointU = (PixelC*) g_pNewPredDec->m_pchNewPredRefU +
							((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width) + 
							iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
						RefpointV = (PixelC*) g_pNewPredDec->m_pchNewPredRefV +
							((EXPANDY_REF_FRAME/2)*m_rctRefFrameUV.width) + 
							iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
						bRet = g_pNewPredDec->CopyNPtoVM(iVideoPacketNumber, RefpointY, RefpointU, RefpointV);
						
						pRefpointY = (PixelC*) m_pvopcRefQ0->pixelsY () + m_iStartInRefToCurrRctY + iMBY * (MB_SIZE *m_iRRVScale) * m_rctRefFrameY.width;
						pRefpointU = (PixelC*) m_pvopcRefQ0->pixelsU () + m_iStartInRefToCurrRctUV + iMBY * (BLOCK_SIZE *m_iRRVScale) * m_rctRefFrameUV.width;
						pRefpointV = (PixelC*) m_pvopcRefQ0->pixelsV () + m_iStartInRefToCurrRctUV + iMBY * (BLOCK_SIZE *m_iRRVScale)* m_rctRefFrameUV.width;
						g_pNewPredDec->ChangeRefOfSlice((const PixelC* )pRefpointY, RefbufY,(const PixelC* ) pRefpointU, RefbufU,
							(const PixelC* )pRefpointV, RefbufV, ((iMBX+1) *m_iRRVScale), (iMBY*m_iRRVScale),m_rctRefFrameY, m_rctRefFrameUV);
						repeatPadYOrA ((PixelC*) m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ0);
						repeatPadUV (m_pvopcRefQ0);
					}
				}
				pmbmd++;
				pmv += PVOP_MV_PER_REF_PER_MB;
				ppxlcCurrQMBY += (MB_SIZE *m_iRRVScale);
				ppxlcCurrQMBU += (BLOCK_SIZE *m_iRRVScale);
				ppxlcCurrQMBV += (BLOCK_SIZE *m_iRRVScale);
			}
			
			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
	
	skipAnyStuffing();
	
	if(m_vopmd.RRVmode.iRRVOnOff == 1)
	{
		PixelC* ppxlcCurrQY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
		PixelC* ppxlcCurrQU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
		PixelC* ppxlcCurrQV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
		filterCodedPictureForRRV(ppxlcCurrQY, ppxlcCurrQU, ppxlcCurrQV,
			m_iVOPWidthY, m_rctCurrVOPY.height(),
			m_iNumMBX,  m_iNumMBY,