vopsedec.cpp

网络MPEG4IP流媒体开发源代码

			if (m_vopmd.iVLCSymbols == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'vlc_symbols' complexity estimation.\n");
					exit (1);
				}
		}
		if (m_volmd.bVLCBits) {
			printf ("dcecs_vlc_bits = %d\n", m_vopmd.iVLCBits = m_pbitstrmIn -> getBits (4));
			if (m_vopmd.iVLCBits == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'vlc_bits' complexity estimation.\n");
					exit (1);
				}
		}

		if (m_vopmd.vopPredType == PVOP ||
			m_vopmd.vopPredType == BVOP ||
			m_vopmd.vopPredType == SPRITE) {

			if (m_volmd.bInterBlocks) {
				printf ("dcecs_inter_blocks = %d\n", m_vopmd.iInterBlocks = m_pbitstrmIn -> getBits (8));
				if (m_vopmd.iInterBlocks == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'inter_blocks' complexity estimation.\n");
					exit (1);
				}
			}
			if (m_volmd.bInter4vBlocks) {
				printf ("dcecs_inter4v_blocks = %d\n", m_vopmd.iInter4vBlocks = m_pbitstrmIn -> getBits (8));
				if (m_vopmd.iInter4vBlocks == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'inter4v_blocks' complexity estimation.\n");
					exit (1);
				}
			}
			if (m_volmd.bAPM) {
				printf ("dcecs_apm = %d\n", m_vopmd.iAPM = m_pbitstrmIn -> getBits (8));
				if (m_vopmd.iAPM == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'apm' complexity estimation.\n");
					exit (1);
				}
			}
			if (m_volmd.bNPM) {
				printf ("dcecs_npm = %d\n", m_vopmd.iNPM = m_pbitstrmIn -> getBits (8));
				if (m_vopmd.iNPM == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'npm' complexity estimation.\n");
					exit (1);
				}
			}
			if (m_volmd.bForwBackMCQ) {
				printf ("dcecs_forw_back_mc_q = %d\n", m_vopmd.iForwBackMCQ = m_pbitstrmIn -> getBits (8));
				if (m_vopmd.iForwBackMCQ == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'forw_back_mc_q' complexity estimation.\n");
					exit (1);
				}
			}
			if (m_volmd.bHalfpel2) {
				printf ("dcecs_halfpel2 = %d\n", m_vopmd.iHalfpel2 = m_pbitstrmIn -> getBits (8));
				if (m_vopmd.iHalfpel2 == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'halfpel2' complexity estimation.\n");
					exit (1);
				}
			}
			if (m_volmd.bHalfpel4) {
				printf ("dcecs_halfpel4 = %d\n", m_vopmd.iHalfpel4 = m_pbitstrmIn -> getBits (8));
				if (m_vopmd.iHalfpel4 == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'halfpel4' complexity estimation.\n");
					exit (1);
				}
			}
		}
		if (m_vopmd.vopPredType == BVOP ||
			m_vopmd.vopPredType == SPRITE) {

			if (m_volmd.bInterpolateMCQ) {
				printf ("dcecs_interpolate_mc_q = %d\n", m_vopmd.iInterpolateMCQ = m_pbitstrmIn -> getBits (8));
				if (m_vopmd.iInterpolateMCQ == 0) {
					fprintf (stderr, "ERROR: Illegal null value for 'interpolate_mc_q' complexity estimation.\n");
					exit (1);
				}
			}
		}
	}
	// END: Complexity Estimation syntax support

	if(m_volmd.bShapeOnly==TRUE)
	{
		m_vopmd.intStep = 10; // probably not needed 
		m_vopmd.intStepI = 10;
		m_vopmd.intStepB = 10;
		m_vopmd.mvInfoForward.uiFCode = m_vopmd.mvInfoBackward.uiFCode = 1;	//	Modified error resilient mode by Toshiba (1998-1-16)
		m_vopmd.bInterlace = FALSE;	//wchen: temporary solution
		return TRUE;
	}
	m_vopmd.iIntraDcSwitchThr = m_pbitstrmIn->getBits (3);

// INTERLACE
	if (m_vopmd.bInterlace) {
		m_vopmd.bTopFieldFirst = m_pbitstrmIn -> getBits (1);
        m_vopmd.bAlternateScan = m_pbitstrmIn -> getBits (1);
		assert(m_volmd.volType == BASE_LAYER);
	} else
// ~INTERLACE
    {
        m_vopmd.bAlternateScan = FALSE;
    }

	if (m_vopmd.vopPredType == IVOP)	{ 
		m_vopmd.intStepI = m_vopmd.intStep = m_pbitstrmIn -> getBits (m_volmd.uiQuantPrecision);	//also assign intStep to be safe
		m_vopmd.mvInfoForward.uiFCode = m_vopmd.mvInfoBackward.uiFCode = 1;		//	Modified error resilient mode by Toshiba(1998-1-16)
		if(m_volmd.fAUsage == EIGHT_BIT)
			m_vopmd.intStepIAlpha = m_pbitstrmIn -> getBits (NUMBITS_VOP_ALPHA_QUANTIZER);
	}
	else if (m_vopmd.vopPredType == PVOP) {
		m_vopmd.intStep = m_pbitstrmIn -> getBits (m_volmd.uiQuantPrecision);
		if(m_volmd.fAUsage == EIGHT_BIT)
			m_vopmd.intStepPAlpha = m_pbitstrmIn -> getBits (NUMBITS_VOP_ALPHA_QUANTIZER);

		m_vopmd.mvInfoForward.uiFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
		m_vopmd.mvInfoForward.uiScaleFactor = 1 << (m_vopmd.mvInfoForward.uiFCode - 1);
		m_vopmd.mvInfoForward.uiRange = 16 << m_vopmd.mvInfoForward.uiFCode;
		//	Added for error resilient mode by Toshiba(1998-1-16)
		m_vopmd.mvInfoBackward.uiFCode = 1;
		//	End Toshiba(1998-1-16)
	}
	else if (m_vopmd.vopPredType == BVOP) {
		m_vopmd.intStepB = m_vopmd.intStep = m_pbitstrmIn -> getBits (m_volmd.uiQuantPrecision); //also assign intStep to be safe

		if(m_volmd.fAUsage == EIGHT_BIT)
			m_vopmd.intStepBAlpha = m_pbitstrmIn -> getBits (NUMBITS_VOP_ALPHA_QUANTIZER);
		
		m_vopmd.mvInfoForward.uiFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
		m_vopmd.mvInfoForward.uiScaleFactor = 1 << (m_vopmd.mvInfoForward.uiFCode - 1);
		m_vopmd.mvInfoForward.uiRange = 16 << m_vopmd.mvInfoForward.uiFCode;
		m_vopmd.mvInfoBackward.uiFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
		m_vopmd.mvInfoBackward.uiScaleFactor = 1 << (m_vopmd.mvInfoBackward.uiFCode - 1);
		m_vopmd.mvInfoBackward.uiRange = 16 << m_vopmd.mvInfoBackward.uiFCode;
	}
	//	Added for error resilient mode by Toshiba(1997-11-14)
	m_vopmd.bShapeCodingType = 1;
	if ( m_volmd.volType == BASE_LAYER ) // added by Sharp (98/4/13)
        if (m_volmd.fAUsage != RECTANGLE && m_vopmd.vopPredType != IVOP
				&& m_uiSprite != 1)
		{	
			m_vopmd.bShapeCodingType = m_pbitstrmIn -> getBits (1);
        }
	// End Toshiba(1997-11-14)
	if(m_volmd.volType == ENHN_LAYER) {					//sony
		if( m_volmd.iEnhnType == 1 ){
			m_vopmd.iLoadBakShape = m_pbitstrmIn -> getBits (1); // load_backward_shape
			if(m_vopmd.iLoadBakShape){
				CVOPU8YUVBA* pvopcCurr = new CVOPU8YUVBA (*(rgpbfShape [0]->pvopcReconCurr()));
				copyVOPU8YUVBA(rgpbfShape [1]->m_pvopcRefQ1, pvopcCurr);
					// previous backward shape is saved to current forward shape
				rgpbfShape [1]->m_rctCurrVOPY.left   = rgpbfShape [0]->m_rctCurrVOPY.left;
				rgpbfShape [1]->m_rctCurrVOPY.right  = rgpbfShape [0]->m_rctCurrVOPY.right;
				rgpbfShape [1]->m_rctCurrVOPY.top    = rgpbfShape [0]->m_rctCurrVOPY.top;
				rgpbfShape [1]->m_rctCurrVOPY.bottom = rgpbfShape [0]->m_rctCurrVOPY.bottom;

				Int width = m_pbitstrmIn -> getBits (NUMBITS_VOP_WIDTH); assert (width % MB_SIZE == 0); // has to be multiples of MB_SIZE
				UInt uiMark = m_pbitstrmIn -> getBits (1);
				assert (uiMark == 1);
				Int height = m_pbitstrmIn -> getBits (NUMBITS_VOP_HEIGHT); assert (height % MB_SIZE == 0); // has to be multiples of MB_SIZE
				uiMark = m_pbitstrmIn -> getBits (1);
				assert (uiMark == 1);
				width = ((width+15)>>4)<<4; // not needed if the asserts are present
				height = ((height+15)>>4)<<4;
				Int iSign = (m_pbitstrmIn -> getBits (1) == 1)? -1 : 1;
				Int left = iSign * m_pbitstrmIn -> getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1);
				Int marker = m_pbitstrmIn -> getBits (1); // marker bit
				iSign = (m_pbitstrmIn -> getBits (1) == 1)? -1 : 1;
				Int top = iSign * m_pbitstrmIn -> getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1);
			
				rgpbfShape[0]->m_rctCurrVOPY = CRct (left, top, left + width, top + height);
				rgpbfShape[0]->m_rctCurrVOPUV = rgpbfShape[0]->m_rctCurrVOPY.downSampleBy2 ();

				// decode backward shape
				rgpbfShape[0]->setRefStartingPointers ();
				rgpbfShape[0]->compute_bfShapeMembers (); // clear m_pvopcRefQ1
				rgpbfShape[0]->resetBYPlane ();// clear BY of RefQ1 (katata)
				rgpbfShape[0]->m_volmd.bShapeOnly = TRUE;
				rgpbfShape[0]->m_volmd.bNoCrChange = m_volmd.bNoCrChange; // set CR change disable(Oct. 9 1997)
				rgpbfShape[0]->m_vopmd.bInterlace = FALSE;
				rgpbfShape[0]->decodeIVOP_WithShape ();

				m_vopmd.iLoadForShape = m_pbitstrmIn -> getBits (1); // load_forward_shape
				if(m_vopmd.iLoadForShape){
					width = m_pbitstrmIn -> getBits (NUMBITS_VOP_WIDTH); assert (width % MB_SIZE == 0); // has to be multiples of MB_SIZE
					uiMark = m_pbitstrmIn -> getBits (1);
					assert (uiMark == 1);
					height = m_pbitstrmIn -> getBits (NUMBITS_VOP_HEIGHT); assert (height % MB_SIZE == 0); // has to be multiples of MB_SIZE
					uiMark = m_pbitstrmIn -> getBits (1);
					assert (uiMark == 1);
					width = ((width+15)>>4)<<4; // not needed if the asserts are present
					height = ((height+15)>>4)<<4;
					iSign = (m_pbitstrmIn -> getBits (1) == 1)? -1 : 1;
					left = iSign * m_pbitstrmIn -> getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1);
					marker = m_pbitstrmIn -> getBits (1); // marker bit
					iSign = (m_pbitstrmIn -> getBits (1) == 1)? -1 : 1;
					top = iSign * m_pbitstrmIn -> getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1);
		
					rgpbfShape[1]->m_rctCurrVOPY = CRct (left, top, left + width, top + height);
					rgpbfShape[1]->m_rctCurrVOPUV = rgpbfShape[1]->m_rctCurrVOPY.downSampleBy2 ();

					// decode forward shape
					rgpbfShape[1]->setRefStartingPointers ();
					rgpbfShape[1]->compute_bfShapeMembers (); // clear m_pvopcRefQ1
					rgpbfShape[1]->resetBYPlane ();// clear BY of RefQ1 (katata)
					rgpbfShape[1]->m_volmd.bShapeOnly = TRUE;
					rgpbfShape[1]->m_volmd.bNoCrChange = m_volmd.bNoCrChange; // set CR change disable(Oct. 9 1997)
					rgpbfShape[1]->m_vopmd.bInterlace = FALSE;
					rgpbfShape[1]->decodeIVOP_WithShape ();
				}
			} // end of "if(m_vopmd.iLoadBakShape)"
			else
				m_vopmd.iLoadForShape = 0; // no forward shape when backward shape is not decoded
		}
		else {
			m_vopmd.iLoadForShape = 0;
			m_vopmd.iLoadBakShape = 0;
		}
        m_vopmd.iRefSelectCode = m_pbitstrmIn ->getBits (2) ;
	}
	return TRUE;
}

//added by sony for spatial scalability decoding loop
Int CVideoObjectDecoder::ReadNextVopPredType ()
{
	m_pbitstrmIn -> setBookmark ();

	if (findStartCode () == EOF) {
		m_pbitstrmIn -> gotoBookmark ();
		return EOF;
	}

	// Start code
	UInt uiVopStartCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_START_CODE);
	assert(uiVopStartCode == VOP_START_CODE);

	Int	vopPredType = (VOPpredType) m_pbitstrmIn -> getBits (NUMBITS_VOP_PRED_TYPE);
	// Time reference and VOP_pred_type
	
	m_pbitstrmIn -> gotoBookmark ();

	return(vopPredType);
}

Void CVideoObjectDecoder::errorInBitstream (Char* rgchErorrMsg)
{
	fprintf (stderr, "%s at %d\n", rgchErorrMsg, 0);
	assert (FALSE);
	exit (1);
}


// Added by Sharp(1998-02-10)
void CVideoObjectDecoder::updateBuffVOPsBase (
	CVideoObjectDecoder* pvodecEnhc
)
{
	switch(m_vopmd.vopPredType) {
		case IVOP:	
			if (!pvodecEnhc -> m_pBuffP2 -> empty ())	// added by Sharp (98/3/11)
				if ( pvodecEnhc -> m_pBuffP2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
				pvodecEnhc -> m_pBuffP1 -> copyBuf (*(pvodecEnhc -> m_pBuffP2)); // added by Sharp (98/3/11)
			pvodecEnhc -> m_pBuffP2 -> getBuf (this);
			break;
		case PVOP:
				if ( pvodecEnhc -> m_pBuffP2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
			pvodecEnhc -> m_pBuffP1 -> copyBuf (*(pvodecEnhc -> m_pBuffP2));
			pvodecEnhc -> m_pBuffP2 -> getBuf (this);
			break;
		case BVOP:
			if(!(pvodecEnhc -> m_pBuffB2 -> empty ())) {
				if ( pvodecEnhc -> m_pBuffB2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
				pvodecEnhc -> m_pBuffB1 -> copyBuf (*(pvodecEnhc -> m_pBuffB2));
			}
			pvodecEnhc -> m_pBuffB2 -> getBuf (this);
			break;
		default:	exit(1);
	}
}

void CVideoObjectDecoder::updateRefVOPsEnhc ()
{
	Int tQ0 = 0, tQ1 = 0;
	switch(m_vopmd.vopPredType) {
		case IVOP:	// printf(" Not defined in updateRefVOPsEnhc. \n");  exit(1); // deleted by Sharp (99/1/25)
			break; // added by Sharp (99/1/25)
		case PVOP:
			switch(m_vopmd.iRefSelectCode) {
				case 0:	m_pBuffE -> putBufToQ0 (this);  tQ0 = m_pBuffE -> m_t;
					break;
				case 1:	if(!(m_pBuffB1 -> empty ()))	{ m_pBuffB1 -> putBufToQ0 (this); tQ0 = m_pBuffB1 -> m_t; }
					else				{ m_pBuffP1 -> putBufToQ0 (this); tQ0 = m_pBuffP1 -> m_t; }
					break;
				case 2:	if(!(m_pBuffB2 -> empty ()))	{ m_pBuffB2 -> putBufToQ0 (this); tQ0 = m_pBuffB2 -> m_t; }
					else				{ m_pBuffP2 -> putBufToQ0 (this); tQ0 = m_pBuffP2 -> m_t; }
					break;
				case 3:	// printf(" For Spatial Scalability -- Not defined\n"); exit(1);
					if(!(m_pBuffB1 -> empty ()))	{ m_pBuffB1 -> putBufToQ0 (this); tQ0 = m_pBuffB1 -> m_t; }
					else				{ m_pBuffP1 -> putBufToQ0 (this); tQ0 = m_pBuffP1 -> m_t; }
					break;
			}
			m_tPastRef   = tQ0;
			break;
		case BVOP:
			switch(m_vopmd.iRefSelectCode) {
				case 0:	// printf(" For Spatial Scalability -- Not defined\n"); exit(1);
					m_pBuffE -> putBufToQ0 (this);	tQ0 = m_pBuffE -> m_t;
					if(!(m_pBuffB1 -> empty ()))	{ m_pBuffB1 -> putBufToQ1 (this); tQ1 = m_pBuffB1 -> m_t; }
					else				{ m_pBuffP1 -> putBufToQ1 (this); tQ1 = m_pBuffP1 -> m_t; }
					break;
				case 1:	m_pBuffE -> putBufToQ0 (this);	tQ0 = m_pBuffE -> m_t;
					if(!(m_pBuffB1 -> empty ()))	{ m_pBuffB1 -> putBufToQ1 (this); tQ1 = m_pBuffB1 -> m_t; }
					else				{ m_pBuffP1 -> putBufToQ1 (this); tQ1 = m_pBuffP1 -> m_t; }
					break;
				case 2:	m_pBuffE -> putBufToQ0 (this);	tQ0 = m_pBuffE -> m_t;
					if(!(m_pBuffB2 -> empty ()))	{ m_pBuffB2 -> putBufToQ1 (this); tQ1 = m_pBuffB2 -> m_t; }
					else				{ m_pBuffP2 -> putBufToQ1 (this); tQ1 = m_pBuffP2 -> m_t; }
					break;
				case 3:	if(!(m_pBuffB1 -> empty ()))	{ m_pBuffB1 -> putBufToQ0 (this); tQ0 = m_pBuffB1 -> m_t; }
					else				{ m_pBuffP1 -> putBufToQ0 (this); tQ0 = m_pBuffP1 -> m_t; }
					if(!(m_pBuffB2 -> empty ()))	{ m_pBuffB2 -> putBufToQ1 (this); tQ1 = m_pBuffB2 -> m_t; }
					else				{ m_pBuffP2 -> putBufToQ1 (this); tQ1 = m_pBuffP2 -> m_t; }
					m_iBCount = (getTime () - tQ0);
					break;
			}
			m_tPastRef   = tQ0;
			m_tFutureRef = tQ1;
			break;
		default:	exit(1);
	}
}

void CVideoObjectDecoder::updateBuffVOPsEnhc ()
{
	if ( this -> m_bCodedFutureRef == 1 ){ // added by Sharp (99/1/28)
	switch(m_vopmd.vopPredType) {
		case IVOP:	// printf(" Not defined in updateBuffVOPsEnhc. \n");  exit(1); // deleted by Sharp (99/1/25)
			        m_pBuffE -> getBuf (this); // added by Sharp (99/1/22)
							break; //added by Sharp (99/1/25)
		case PVOP:	m_pBuffE -> getBuf (this);
				break;
		case BVOP:	m_pBuffE -> getBuf (this);
				break;
		default:	exit(1);
	}
	} // added by Sharp (99/1/28)
}

void CVideoObjectDecoder::bufferB2flush ()
{
	if (!(m_pBuffB2 -> empty ())) {
	if ( m_pBuffB2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
		m_pBuffB1 -> copyBuf (*m_pBuffB2);
		m_pBuffB2 -> dispose ();
	}
}
/* Added */
void CVideoObjectDecoder::set_enh_display_size(CRct rctDisplay, CRct *rctDisplay_SSenh)
{

	float tmp_right,tmp_left,tmp_top,tmp_bottom,tmp_width;
	
	tmp_right = (float) rctDisplay.right * ((float) m_volmd.ihor_sampling_factor_n / m_volmd.ihor_sampling_factor_m);
	tmp_left  = (float) rctDisplay.left  * ((float) m_volmd.ihor_sampling_factor_n / m_volmd.ihor_sampling_factor_m);
	tmp_width = (float) rctDisplay.width * ((float) m_volmd.ihor_sampling_factor_n / m_volmd.ihor_sampling_factor_m);

	tmp_top     = (float) rctDisplay.top * ((float) m_volmd.iver_sampling_factor_n / m_volmd.iver_sampling_factor_m);
	tmp_bottom  = (float) rctDisplay.bottom  * ((float) m_volmd.iver_sampling_factor_n / m_volmd.iver_sampling_factor_m);

	rctDisplay_SSenh->right