vopsedec.cpp

MPEG-4编解码的实现(包括MPEG4视音频编解码)

			delete [] m_rgpmbmAbove [iMB]->rgblkm;
			delete m_rgpmbmAbove [iMB];
			delete [] m_rgpmbmCurr [iMB]->rgblkm;
			delete m_rgpmbmCurr [iMB];
		}
		delete [] m_rgpmbmAbove;
		delete [] m_rgpmbmCurr;
	}
	else {				// For Temporal Scalability	Added by Sharp(1998-02-10)
		m_iBVOPOffsetForPadY = m_iOffsetForPadY;
		m_iBVOPOffsetForPadUV = m_iOffsetForPadUV;
		m_rctBVOPPrevNoExpandY = m_rctPrevNoExpandY;
		m_rctBVOPPrevNoExpandUV = m_rctPrevNoExpandUV;

		m_rctBVOPRefVOPY1 = m_rctRefVOPY1;
		m_rctBVOPRefVOPUV1 = m_rctRefVOPUV1;
	}				// For Temporal Scalability	End	 Sharp(1998-02-10)

    if (m_vopmd.vopPredType != BVOP ||
		(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0)) {
		repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ1);
		repeatPadUV (m_pvopcRefQ1);

		//reset by in RefQ1 so that no left-over from last frame
		if (m_volmd.fAUsage != RECTANGLE)       {
			if (m_volmd.fAUsage == EIGHT_BIT)
				repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsA () + m_iOffsetForPadY, m_pvopcRefQ1);
		}
	}

	// update buffers for temporal scalability	Added by Sharp(1998-02-10)
	if(m_volmd.volType != BASE_LAYER)  updateBuffVOPsEnhc ();

	return TRUE;
}

Int CVideoObjectDecoder::findStartCode(int dontloop)
{
	// ensure byte alignment
	m_pbitstrmIn->flush ();

	Int bUserData;
	do {
		bUserData = 0;
		while(m_pbitstrmIn->peekBits(NUMBITS_START_CODE_PREFIX)!=START_CODE_PREFIX)
		{
			m_pbitstrmIn->getBits(8);
			if(m_pbitstrmIn->eof()==EOF || dontloop != 0)
				return EOF;

		}
		m_pbitstrmIn->getBits(NUMBITS_START_CODE_PREFIX);
		if(m_pbitstrmIn->peekBits(NUMBITS_START_CODE_SUFFIX)==USER_DATA_START_CODE)
			bUserData = 1;
	} while(bUserData);

	return 0;
}

Void CVideoObjectDecoder::decodeVOHead ()
{
	findStartCode();
 	//	Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)(for Skip Session_Start_Code)
 	if( m_pbitstrmIn->peekBits(NUMBITS_START_CODE_SUFFIX)==SESSION_START_CODE){
 		m_pbitstrmIn -> getBits (NUMBITS_START_CODE_SUFFIX);
 		if (findStartCode () == EOF)
 			assert(FALSE);
 	}
 	//	End Toshiba(1998-1-16:DP+RVLC)
	UInt uiVoStartCode = m_pbitstrmIn -> getBits (NUMBITS_VO_START_CODE);
	assert(uiVoStartCode == VO_START_CODE);
	decodeVOBody();
}

Void CVideoObjectDecoder::decodeVOBody ()
{

	m_uiVOId = m_pbitstrmIn -> getBits (NUMBITS_VO_ID);
}

Void CVideoObjectDecoder::decodeVOLHead ()
{
	findStartCode();
	UInt uiVolStartCode = m_pbitstrmIn -> getBits (NUMBITS_VOL_START_CODE);
	assert(uiVolStartCode == VOL_START_CODE);
	decodeVOLBody();
}

Void CVideoObjectDecoder::decodeVOLBody()
{
  int ver_id;

	/* UInt uiVOLId = wmay */m_pbitstrmIn -> getBits (NUMBITS_VOL_ID);
// Begin: modified by Hughes	  4/9/98	  per clause 2.1.7. in N2171 document
	/* Bool bRandom = wmay */m_pbitstrmIn->getBits (1); //VOL_Random_Access
// End: modified by Hughes	  4/9/98
	/* UInt uiOLType = wmay*/m_pbitstrmIn -> getBits(8); // VOL_type_indication
	UInt uiOLI = m_pbitstrmIn -> getBits (1); //VOL_Is_Object_Layer_Identifier, useless flag for now
	if(uiOLI)
	{
	  ver_id = m_pbitstrmIn -> getBits (4); // video_oject_layer_verid
		m_pbitstrmIn -> getBits (3); // video_oject_layer_priority
	} else {
	  ver_id = 1;
	}

	//assert(uiOLI == 0);
	
	UInt uiAspect = m_pbitstrmIn -> getBits (4);
	if(uiAspect==15) // extended PAR
	{
	  /* UInt iParWidth = wmay */ m_pbitstrmIn -> getBits (8);
	  /* UInt iParHeight = wmay */ m_pbitstrmIn -> getBits (8);
	}

	UInt uiMark;
	UInt uiCTP = m_pbitstrmIn -> getBits (1); //VOL_Control_Parameter, useless flag for now
	if(uiCTP)
	{
	  /* UInt uiChromaFormat = wmay */ m_pbitstrmIn -> getBits (2);
	  /* UInt uiLowDelay = wmay */m_pbitstrmIn -> getBits (1);
		UInt uiVBVParams = m_pbitstrmIn -> getBits (1);
		
		if(uiVBVParams)
		{
		  /* UInt uiFirstHalfBitRate = wmay */m_pbitstrmIn -> getBits (15);
			uiMark = m_pbitstrmIn -> getBits (1);
			assert(uiMark==1);
			/* UInt uiLatterHalfBitRate = wmay */ m_pbitstrmIn -> getBits (15);
			uiMark = m_pbitstrmIn -> getBits (1);
			assert(uiMark==1);
			/* UInt uiFirstHalfVbvBufferSize = wmay */m_pbitstrmIn -> getBits (15);
			uiMark = m_pbitstrmIn -> getBits (1);
			assert(uiMark==1);
			/* UInt uiLatterHalfVbvBufferSize = wmay */m_pbitstrmIn -> getBits (3);
			/* UInt uiFirstHalfVbvBufferOccupany = wmay */m_pbitstrmIn -> getBits (11);
			uiMark = m_pbitstrmIn -> getBits (1);
			assert(uiMark==1);
			/* UInt uiLatterHalfVbvBufferOccupany = wmay */m_pbitstrmIn -> getBits (15);
			uiMark = m_pbitstrmIn -> getBits (1);
			assert(uiMark==1);
		}
	}

	//assert(uiCTP == 0);

	UInt uiAUsage = m_pbitstrmIn -> getBits (NUMBITS_VOL_SHAPE);
	uiMark = m_pbitstrmIn -> getBits (1);
	assert(uiMark==1);
	m_volmd.iClockRate = m_pbitstrmIn -> getBits (NUMBITS_TIME_RESOLUTION);
#ifdef DEBUG_OUTPUT
	cout << m_volmd.iClockRate << "\n";
#endif
	uiMark = m_pbitstrmIn -> getBits (1);
	assert(uiMark==1);
	Int iClockRate = m_volmd.iClockRate;
	assert (iClockRate >= 1 && iClockRate < 65536);
	for (m_iNumBitsTimeIncr = 1; m_iNumBitsTimeIncr < NUMBITS_TIME_RESOLUTION; m_iNumBitsTimeIncr++)	{	
		if (iClockRate == 1)			
			break;
		iClockRate = (iClockRate >> 1);
	}

	Bool bFixFrameRate = m_pbitstrmIn -> getBits (1);
	//assert (bFixFrameRate == FALSE);
	if(bFixFrameRate)
	{
	  UInt uiFixedVOPTimeIncrement = m_pbitstrmIn -> getBits (m_iNumBitsTimeIncr);
	  m_volmd.iClockRate = m_volmd.iClockRate / uiFixedVOPTimeIncrement;
		// not used
		//
		//
	}

	if(uiAUsage==2)  // shape-only mode
	{
	  /* UInt uiResyncMarkerDisable = wmay */m_pbitstrmIn -> getBits (1);

		// default to some values - probably not all needed
		m_volmd.bShapeOnly=TRUE;
		m_volmd.fAUsage=ONE_BIT;
		m_volmd.bAdvPredDisable = 0;
		m_volmd.fQuantizer = Q_H263;
		m_volmd.volType = BASE_LAYER;
		m_volmd.bDeblockFilterDisable = TRUE;		
		m_uiSprite = 0;
		m_volmd.bNot8Bit = 0;
		m_volmd.bComplexityEstimationDisable = 1;
		m_volmd.bDataPartitioning = 0;
		m_volmd.bReversibleVlc = FALSE;
		m_volmd.bDeblockFilterDisable = TRUE;
		return;
	}

	m_volmd.bShapeOnly=FALSE;
	if(uiAUsage==3)
		uiAUsage=2;
	m_volmd.fAUsage = (AlphaUsage) uiAUsage;
	if (m_volmd.fAUsage == RECTANGLE) {
		UInt uiMarker = m_pbitstrmIn -> getBits (1);
		//wmay for divx assert(uiMarker==1);
		m_ivolWidth = m_pbitstrmIn -> getBits (NUMBITS_VOP_WIDTH);
		uiMarker  = m_pbitstrmIn -> getBits (1);
		// wmay for divx assert(uiMarker==1);
		m_ivolHeight = m_pbitstrmIn -> getBits (NUMBITS_VOP_HEIGHT);
		uiMarker  = m_pbitstrmIn -> getBits (1);
		// wmay for dixv assert(uiMarker==1);
	}

	m_vopmd.bInterlace = m_pbitstrmIn -> getBits (1); // interlace (was vop flag)
	m_volmd.bAdvPredDisable = m_pbitstrmIn -> getBits (1);  //VOL_obmc_Disable

	// decode sprite info
	// wmay m_uiSprite = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_USAGE);
	m_uiSprite = m_pbitstrmIn->getBits(ver_id == 1 ? 1 : 2);
	if (m_uiSprite == 1) { // sprite information
		Int isprite_hdim = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_HDIM);
		Int iMarker = m_pbitstrmIn -> getBits (MARKER_BIT);
		assert (iMarker == 1);
		Int isprite_vdim = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_VDIM);
		iMarker = m_pbitstrmIn -> getBits (MARKER_BIT);
		assert (iMarker == 1);
		Int isprite_left_edge = (m_pbitstrmIn -> getBits (1) == 0) ?
		    m_pbitstrmIn->getBits (NUMBITS_SPRITE_LEFT_EDGE - 1) : ((Int)m_pbitstrmIn->getBits (NUMBITS_SPRITE_LEFT_EDGE - 1) - (1 << 12));
		assert(isprite_left_edge%2 == 0);
		iMarker = m_pbitstrmIn -> getBits (MARKER_BIT);
		assert (iMarker == 1);
		Int isprite_top_edge = (m_pbitstrmIn -> getBits (1) == 0) ?
		    m_pbitstrmIn->getBits (NUMBITS_SPRITE_TOP_EDGE - 1) : ((Int)m_pbitstrmIn->getBits (NUMBITS_SPRITE_LEFT_EDGE - 1) - (1 << 12));
		assert(isprite_top_edge%2 == 0);
		iMarker = m_pbitstrmIn -> getBits (MARKER_BIT);
		assert (iMarker == 1);
		m_rctSpt.left = isprite_left_edge;
		m_rctSpt.right = isprite_left_edge + isprite_hdim;
		m_rctSpt.top = isprite_top_edge;
		m_rctSpt.bottom = isprite_top_edge + isprite_vdim;
		m_rctSpt.width = isprite_hdim;
        m_rctSptPieceY = m_rctSpt; //initialization; will be overwritten by first vop header
		m_iNumOfPnts = m_pbitstrmIn -> getBits (NUMBITS_NUM_SPRITE_POINTS);
		m_rgstSrcQ = new CSiteD [m_iNumOfPnts];
		m_rgstDstQ = new CSiteD [m_iNumOfPnts];
		m_uiWarpingAccuracy = m_pbitstrmIn -> getBits (NUMBITS_WARPING_ACCURACY);
		/* Bool bLightChange = wmay */m_pbitstrmIn -> getBits (1);

// Begin: modified by Hughes	  4/9/98
		Bool bsptMode = m_pbitstrmIn -> getBits (1);  // Low_latency_sprite_enable
		if (  bsptMode)
			m_sptMode = LOW_LATENCY ;
		else			
			m_sptMode = BASIC_SPRITE ;
// End: modified by Hughes	  4/9/98
	}

	m_volmd.bNot8Bit = (Bool) m_pbitstrmIn -> getBits(1);
	if (m_volmd.bNot8Bit) {
		m_volmd.uiQuantPrecision = (UInt) m_pbitstrmIn -> getBits (4);
		m_volmd.nBits = (UInt) m_pbitstrmIn -> getBits (4);
		assert(m_volmd.nBits>3);
	} else {
		m_volmd.uiQuantPrecision = 5;
		m_volmd.nBits = 8;
	}

	if (m_volmd.fAUsage == EIGHT_BIT)
	{
		m_volmd.bNoGrayQuantUpdate = m_pbitstrmIn -> getBits (1);
		/* UInt uiCompMethod = wmay */m_pbitstrmIn -> getBits (1);
		/* UInt uiLinearComp = wmay */m_pbitstrmIn -> getBits (1);
	}

	m_volmd.fQuantizer = (Quantizer) m_pbitstrmIn -> getBits (1); 
	if (m_volmd.fQuantizer == Q_MPEG) {
		m_volmd.bLoadIntraMatrix = m_pbitstrmIn -> getBits (1);
		if (m_volmd.bLoadIntraMatrix) {
			UInt i = 0;
			Int iElem;
			do {
				iElem = m_pbitstrmIn -> getBits (NUMBITS_QMATRIX);
				m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[i]] = iElem;
			} while (iElem != 0 && ++i < BLOCK_SQUARE_SIZE);
			for (UInt j = i; j < BLOCK_SQUARE_SIZE; j++) {
				m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[j]] = m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[i - 1]];
			}
		}
		else {
			memcpy (m_volmd.rgiIntraQuantizerMatrix, rgiDefaultIntraQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
		}
		m_volmd.bLoadInterMatrix = m_pbitstrmIn -> getBits (1);
		if (m_volmd.bLoadInterMatrix) {
			UInt i = 0;
			Int iElem;
			do {
				iElem = m_pbitstrmIn -> getBits (NUMBITS_QMATRIX);
				m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[i]] = iElem;
			} while (iElem != 0 && ++i < BLOCK_SQUARE_SIZE);
			for (UInt j = i; j < BLOCK_SQUARE_SIZE; j++) {
				m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[j]] = m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[i - 1]];
			}
		}
		else {
			memcpy (m_volmd.rgiInterQuantizerMatrix, rgiDefaultInterQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
		}
		if (m_volmd.fAUsage == EIGHT_BIT)	{
			m_volmd.bLoadIntraMatrixAlpha = m_pbitstrmIn -> getBits (1);
			if (m_volmd.bLoadIntraMatrixAlpha) {
				for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++)	{
					Int iElem = m_pbitstrmIn -> getBits (NUMBITS_QMATRIX);
					if (iElem != 0)
						m_volmd.rgiIntraQuantizerMatrixAlpha [grgiStandardZigzag[i]] = iElem;
					else
						m_volmd.rgiIntraQuantizerMatrixAlpha [i] = m_volmd.rgiIntraQuantizerMatrixAlpha [grgiStandardZigzag[i - 1]];
				}
			}
			else {
#ifdef _FOR_GSSP_
				memcpy (m_volmd.rgiIntraQuantizerMatrixAlpha, rgiDefaultIntraQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
#else
				for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++)
					m_volmd.rgiIntraQuantizerMatrixAlpha [i] = 16;
#endif
			}
			m_volmd.bLoadInterMatrixAlpha = m_pbitstrmIn -> getBits (1);
			if (m_volmd.bLoadInterMatrixAlpha) {
				for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++)	{
					Int iElem = m_pbitstrmIn -> getBits (NUMBITS_QMATRIX);
					if (iElem != 0)
						m_volmd.rgiInterQuantizerMatrixAlpha [grgiStandardZigzag[i]] = iElem;
					else
						m_volmd.rgiInterQuantizerMatrixAlpha [i] = m_volmd.rgiInterQuantizerMatrixAlpha [grgiStandardZigzag[i - 1]];
				}
			}
			else {
#ifdef _FOR_GSSP_
				memcpy (m_volmd.rgiInterQuantizerMatrixAlpha, rgiDefaultInterQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
#else
				for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++)
					m_volmd.rgiInterQuantizerMatrixAlpha [i] = 16;
#endif
			}
		}
	}
	if (ver_id != 1) // wmay
	  m_pbitstrmIn->getBits(1); // wmay vol quarter pixel
	
	// Bool bComplxityEsti = m_pbitstrmIn->getBits (1); //Complexity estimation; don't know how to use it

// START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 15 Jun 1998

	m_volmd.bComplexityEstimationDisable = m_pbitstrmIn -> getBits (1);
	if (! m_volmd.bComplexityEstimationDisable) {

		m_volmd.iEstimationMethod = m_pbitstrmIn -> getBits (2);
		if (m_volmd.iEstimationMethod != 0) {
			fprintf (stderr, "ERROR: Unknown complexity estimation method number %d.\n", m_volmd.iEstimationMethod);
			exit (1);
		}

		m_volmd.bShapeComplexityEstimationDisable = m_pbitstrmIn -> getBits (1);
		if (! m_volmd.bShapeComplexityEstimationDisable) {
			m_volmd.bOpaque = m_pbitstrmIn -> getBits (1);
			m_volmd.bTransparent = m_pbitstrmIn -> getBits (1);
			m_volmd.bIntraCAE = m_pbitstrmIn -> getBits (1);
			m_volmd.bInterCAE = m_pbitstrmIn -> getBits (1);