sys_decoder_vopmbdec.cpp

完整的RTP RTSP代码库

/*************************************************************************

	This software module was originally developed by 
  
	Ming-Chieh Lee ([e-mail]), Microsoft Corporation
	Wei-ge Chen ([e-mail]), Microsoft Corporation
	Bruce Lin ([e-mail]), Microsoft Corporation
	Chuang Gu ([e-mail]), Microsoft Corporation
	Simon Winder ([e-mail]), Microsoft Corporation
	(date: March, 1996)
		
	and edited by
	Yoshihiro Kikuchi (TOSHIBA CORPORATION)
	Takeshi Nagai (TOSHIBA CORPORATION)
	Toshiaki Watanabe (TOSHIBA CORPORATION)
	Noboru Yamaguchi (TOSHIBA CORPORATION)
	  
	and also edited by
	David B. Shu ([e-mail]), Hughes Electronics/HRL Laboratories

	and edited by
	Xuemin Chen ([e-mail]), General Instrument Corp.

	and also edited by
	Dick van Smirren ([e-mail]), KPN Research
	Cor Quist ([e-mail]), KPN Research
	(date: July, 1998)

	and also edited by
	Yoshinori Suzuki (Hitachi, Ltd.)

	and also edited by
	Hideaki Kimata (NTT)

	and also edited by
	Fujitsu Laboratories Ltd. (contact: Eishi Morimatsu)

	and also edited by 
	Takefumi Nagumo ([e-mail]) Sony Corporation
	Sehoon Son ([e-mail]) Samsung AIT

	in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
	This software module is an implementation of a part of one or more MPEG-4 Video tools 
	as specified by the MPEG-4 Video. 
	ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
	thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
	Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
	The original developer of this software module and his/her company, 
	the subsequent editors and their companies, 
	and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
	Copyright is not released for non MPEG-4 Video conforming products. 
	Microsoft retains full right to use the code for his/her own purpose, 
	assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
	This copyright notice must be included in all copies or derivative works. 

	Copyright (c) 1996, 1997.

	Module Name:

	vopmbDec.cpp

	Abstract:

	Decoder for VOP composed of MB's

	Revision History:

	Nov. 26 , 1997: modified for error resilient by Toshiba

	Nov. 30 , 1997: modified for Spatial Scalable by Takefumi Nagumo
	([e-mail]) SONY Corporation 
	Dec 20, 1997:	Interlaced tools added by GI
	X. Chen ([e-mail]), B. Eifrig ([e-mail])
	May. 9   1998:  add boundary by Hyundai Electronics 
	Cheol-Soo Park ([e-mail]) 
	May. 9   1998:  add field based MC padding by Hyundai Electronics 
	Cheol-Soo Park ([e-mail]) 
	Feb.24   1999:  GMC added by Y. Suzuki (Hitachi, Ltd.) 
	Aug.24, 1999 : NEWPRED added by Hideaki Kimata (NTT) 
	Sep.06	1999 : RRV added by Eishi Morimatsu (Fujitsu Laboratories Ltd.) 
	Feb.01	2000 : Bug fixed OBSS by Takefumi Nagumo (SONY)
	May.25  2000 : MB stuffing decoding on the last MB by Hideaki Kimata (NTT)
									  
*************************************************************************/

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

#include "typeapi.h"
#include "mode.hpp"
#include "codehead.h"
#include "bitstrm.hpp"
#include "entropy.hpp"
#include "huffman.hpp"
#include "global.hpp"
#include "vopses.hpp"
#include "vopsedec.hpp"

// NEWPRED
#include "newpred.hpp"
// ~NEWPRED

#ifdef __MFC_
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif
#define new DEBUG_NEW				   
#endif // __MFC_

Bool CVideoObjectDecoder::checkGOBMarker()
{
  Int iBitsLeft; // = 8 - (m_pbitstrmIn->getCounter() & 7);
  m_pbitstrmIn->peekBitsTillByteAlign(iBitsLeft);
	if(iBitsLeft==8)
		iBitsLeft = 0;
	UInt uiGOBMarker = m_pbitstrmIn->peekBits (17 + iBitsLeft);
	uiGOBMarker &= ((1 << 17) - 1);
	return (uiGOBMarker == 1);
}

Void CVideoObjectDecoder::decodeVOP ()	
{
	if (m_volmd.fAUsage != RECTANGLE) {
		if(m_volmd.bDataPartitioning && !m_volmd.bShapeOnly){
			if (m_vopmd.vopPredType == PVOP || (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE))
				decodePVOP_WithShape_DataPartitioning ();
			else if (m_vopmd.vopPredType == IVOP)
				decodeIVOP_WithShape_DataPartitioning ();
			else
				decodeBVOP_WithShape ();
		}
		else {
			if (m_vopmd.vopPredType == PVOP || (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE))
			{
				if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP)
					decodePVOP ();
				else
					decodePVOP_WithShape ();
			}
			else if (m_vopmd.vopPredType == IVOP)
				decodeIVOP_WithShape ();
			else
				decodeBVOP_WithShape ();
		}
	}
	else {
		if(m_volmd.bDataPartitioning){
			if (m_vopmd.vopPredType == PVOP || (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE))
				decodePVOP_DataPartitioning ();
			else if (m_vopmd.vopPredType == IVOP)
				decodeIVOP_DataPartitioning ();
			else
				decodeBVOP ();
		}
		else {
			if (m_vopmd.vopPredType == PVOP || (m_uiSprite == 2 && m_vopmd.vopPredType == SPRITE))
				decodePVOP ();
			else if (m_vopmd.vopPredType == IVOP)
				decodeIVOP ();
			else
				decodeBVOP ();
		}
	}
}

Void CVideoObjectDecoder::decodeIVOP_WithShape ()	
{
	//in case the IVOP is used as an ref for direct mode
	memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
	
	Int iMBX, iMBY;
	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)
	
	PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
	//	PixelC* ppxlcRefA  = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
	
	pmbmd->m_bFieldDCT=0;	// new changes by X. Chen
	
	Int iCurrentQP  = m_vopmd.intStepI;	
	Int iCurrentQPA[MAX_MAC];
	for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ ) // MAC (SB) 2-Dec-99
		iCurrentQPA[iAuxComp] = m_vopmd.intStepIAlpha[iAuxComp];	
	//	Added for error resilient mode by Toshiba(1997-11-14)
	Int	iVideoPacketNumber = 0;
	m_iVPMBnum = 0;
	Bool bRestartDelayedQP = TRUE;
	
	PixelC** pppxlcRefMBA  = new PixelC* [m_volmd.iAuxCompCount];
	
	for(Int i=0; i<m_iNumMB; i++) {
		m_rgmvBaseBY[i].iMVX = 0; // for shape
		m_rgmvBaseBY[i].iMVY = 0; // for shape
		m_rgmvBaseBY[i].iHalfX = 0; // for shape
		m_rgmvBaseBY[i].iHalfY = 0; // for shape
	}
	if(m_volmd.volType == BASE_LAYER) 									
		m_rctBase = m_rctCurrVOPY;
	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
		PixelC* ppxlcRefMBY  = ppxlcRefY;
		PixelC* ppxlcRefMBU  = ppxlcRefU;
		PixelC* ppxlcRefMBV  = ppxlcRefV;
		PixelC* ppxlcRefMBBY = ppxlcRefBY;
		PixelC* ppxlcRefMBBUV = ppxlcRefBUV;
		
		Bool  bSptMB_NOT_HOLE= TRUE;
		if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP) {
			bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(0, iMBY, pmbmd);		 
			RestoreMBmCurrRow (iMBY, m_rgpmbmCurr);  // restore current row pointed by *m_rgpmbmCurr
		}
		
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
			
			for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ ) { // MAC (SB) 1-Dec-99
				pppxlcRefMBA[iAuxComp] = ((PixelC*)m_pvopcRefQ1->pixelsA (iAuxComp) + m_iStartInRefToCurrRctY)
					+ iMBY*m_iFrameWidthYxMBSize + iMBX*MB_SIZE;
			}
			
			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_DECODING1;
			
			//	Added for error resilient mode by Toshiba(1997-11-14)
			if	(checkResyncMarker())	{
				decodeVideoPacketHeader(iCurrentQP);
				iVideoPacketNumber++;
				bRestartDelayedQP = TRUE;
				//printf("VP");
			}
			pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;

			decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY, ppxlcRefMBBY);

			downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd); // downsample original BY now for LPE padding (using original shape)
			if(m_volmd.bShapeOnly==FALSE)
			{
				pmbmd->m_bPadded=FALSE;
				if (pmbmd->m_rgTranspStatus [0] != ALL) {
					if (!m_volmd.bSadctDisable)
						deriveSADCTRowLengths(m_rgiCurrMBCoeffWidth, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd ->m_rgTranspStatus);

					decodeMBTextureHeadOfIVOP (pmbmd, iCurrentQP, &bRestartDelayedQP);

					if (!m_volmd.bSadctDisable)
						decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
					else
						decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);

					if ((pmbmd->m_rgTranspStatus [0] == NONE) && 
						(m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
						fieldDCTtoFrameC(ppxlcRefMBY);

					if (m_volmd.fAUsage == EIGHT_BIT) {
						for(Int iAuxComp=0; iAuxComp<m_volmd.iAuxCompCount; iAuxComp++ ) { // MAC (SB) 1-Dec-99
							decodeMBAlphaHeadOfIVOP (pmbmd, iCurrentQP, iCurrentQPA[iAuxComp], m_vopmd.intStepI, m_vopmd.intStepIAlpha[iAuxComp], iAuxComp);

							if (!m_volmd.bSadctDisable)
								decodeAlphaIntraMB (pmbmd, iMBX, iMBY, pppxlcRefMBA[iAuxComp], iAuxComp, m_ppxlcCurrMBBY);
							else
								decodeAlphaIntraMB (pmbmd, iMBX, iMBY, pppxlcRefMBA[iAuxComp], iAuxComp );					
						}
					}
					if (m_uiSprite == 0 || m_uiSprite == 2 ||  m_sptMode == BASIC_SPRITE)         { //   delay the padding until ready for sprite warping // GMC
						if (!m_vopmd.bInterlace) {
							if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
								mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, pppxlcRefMBA);
							padNeighborTranspMBs (
								iMBX, iMBY,
								pmbmd,
								ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, pppxlcRefMBA
								);
						}
					}
				}
				else {
					if (m_uiSprite == 0 || m_uiSprite == 2 || m_sptMode == BASIC_SPRITE) //  delay the padding until ready for sprite warping // GMC
						if (!m_vopmd.bInterlace) {
							padCurrAndTopTranspMBFromNeighbor (
								iMBX, iMBY,
								pmbmd,
								ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, pppxlcRefMBA
								);
						}
				}
			}
			
END_OF_DECODING1:
			//	ppxlcRefMBA += MB_SIZE;
			ppxlcRefMBBY += MB_SIZE;
			ppxlcRefMBBUV += BLOCK_SIZE;
			pmbmd++;
			ppxlcRefMBY += MB_SIZE;
			ppxlcRefMBU += BLOCK_SIZE;
			ppxlcRefMBV += BLOCK_SIZE;
			
			if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP)
				bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(iMBX+1, iMBY, pmbmd);	 			
			else
				bSptMB_NOT_HOLE= TRUE;
		}
		MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
		m_rgpmbmAbove = m_rgpmbmCurr;
		
		if  (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE)
			SaveMBmCurrRow (iMBY, m_rgpmbmCurr);		 //	  save current row pointed by *m_rgpmbmCurr 
		
		m_rgpmbmCurr  = ppmbmTemp;
		ppxlcRefY += m_iFrameWidthYxMBSize;
		ppxlcRefU += m_iFrameWidthUVxBlkSize;
		ppxlcRefV += m_iFrameWidthUVxBlkSize;
		ppxlcRefBY += m_iFrameWidthYxMBSize;
		//		ppxlcRefA += m_iFrameWidthYxMBSize;
		ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
	}
	// 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)
	
	delete [] pppxlcRefMBA;
}

Void CVideoObjectDecoder::decodeIVOP ()	
{
	// NEWPRED
	char	pSlicePoint[128];
	pSlicePoint[0] = '0';
	pSlicePoint[1] = '0'; //NULL;
	// ~NEWPRED
	
	//in case the IVOP is used as an ref for direct mode
	memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
	
	//	Int macrotellertje=0;  // [FDS]
	
	Int iMBX, iMBY;
	Int iMBXstart, iMBXstop, iMBYstart, iMBYstop; // Added by KPN for short headers
	UInt uiNumberOfGobs; // Added by KPN
	UInt uiGobNumber; // Added by KPN
	CMBMode* pmbmd = m_rgmbmd;
	pmbmd->m_stepSize = m_vopmd.intStepI;
	PixelC* ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;