vopseenc.cpp

网络MPEG4IP流媒体开发源代码

		exit(1);
#endif // __TRACE_AND_STATS_
		if (m_vopmd.vopPredType == IVOP) { // !!!! check whether CRct has been expanded
			Double dMad = 
				(m_pvopcOrig->getPlane (Y_PLANE)->sumAbs (m_rctCurrVOPY)) / 
				(Double) (m_rctCurrVOPY.area ());
			m_statRC.reset (
				m_nFirstFrame, 
				m_nLastFrame, 
				m_volmd.iTemporalRate, 
				m_iBufferSize, 
				dMad, 
				m_statsVOL.nBitsTotal,
				m_volmd.dFrameHz
			);
		}
		else if (m_vopmd.vopPredType == PVOP)
			m_statRC.updateRCModel (m_statsVOP.total (), m_statsVOP.head ());
	}

	// store the direct mode data (by swaping pointers)
	if (m_vopmd.vopPredType != BVOP) {
		if(m_volmd.fAUsage != RECTANGLE && bPrevRefVopWasCoded)
			saveShapeMode();
		CMBMode* pmbmdTmp = m_rgmbmd;
		m_rgmbmd = m_rgmbmdRef;
		m_rgmbmdRef = pmbmdTmp;
		CMotionVector* pmvTmp = m_rgmv;
		m_rgmv = m_rgmvRef;
		m_rgmvRef = pmvTmp;
		//wchen: should not only for pvop
		//if (m_vopmd.vopPredType == PVOP) 
		m_rgmvBackward = m_rgmv + BVOP_MV_PER_REF_PER_MB * m_iSessNumMB;
		
#if 0 // Debugging .. use the same anchor VOPs as reference implementation
		static FILE *pfRefPicInputFile = NULL;
		if (pfRefPicInputFile == NULL) {
			pfRefPicInputFile = fopen("ref.yuv", "rb");
			assert(pfRefPicInputFile != NULL);
		}
		Int iLeadingPixels = m_t * m_rctPrevNoExpandY.area ();
		fseek (pfRefPicInputFile, iLeadingPixels + iLeadingPixels / 2, SEEK_SET);	//4:2:0
		static Int iYDataHeight = m_rctPrevNoExpandY.height ();
		static Int iUVDataHeight = m_rctPrevNoExpandY.height () / 2;
		static Int iYFrmWidth = m_pvopcRefQ1->whereY ().width;
		static Int iUvFrmWidth = m_pvopcRefQ1->whereUV ().width;
		static Int nSkipYPixel = iYFrmWidth * EXPANDY_REF_FRAME + EXPANDY_REF_FRAME;
		static Int nSkipUvPixel = iUvFrmWidth * EXPANDUV_REF_FRAME + EXPANDUV_REF_FRAME;
		PixelC* ppxlcY = (PixelC*) m_pvopcRefQ1->pixelsY () + nSkipYPixel;
		PixelC* ppxlcU = (PixelC*) m_pvopcRefQ1->pixelsU () + nSkipUvPixel;
		PixelC* ppxlcV = (PixelC*) m_pvopcRefQ1->pixelsV () + nSkipUvPixel;
		for (CoordI y = 0; y < iYDataHeight; y++) {
			Int size = (Int) fread (ppxlcY, sizeof (U8), m_rctPrevNoExpandY.width, pfRefPicInputFile);
			if (size == 0)
				fprintf (stderr, "Unexpected end of file\n");
			ppxlcY += iYFrmWidth;
		}
		for (y = 0; y < iUVDataHeight; y++) {
			Int size = (Int) fread (ppxlcU, sizeof (U8), m_rctPrevNoExpandY.width / 2, pfRefPicInputFile);
			if (size == 0)
				fprintf (stderr, "Unexpected end of file\n");
			ppxlcU += iUvFrmWidth;
		}

		for (y = 0; y < iUVDataHeight; y++) {
			Int size = (Int) fread (ppxlcV, sizeof (U8), m_rctPrevNoExpandY.width / 2, pfRefPicInputFile);
			if (size == 0)
				fprintf (stderr, "Unexpected end of file\n");
			ppxlcV += iUvFrmWidth;
		}
#endif
	}
	
	if (m_volmd.fAUsage != RECTANGLE) {
		if (m_vopmd.vopPredType != BVOP) {
			m_iNumMBRef = m_iNumMB;
			m_iNumMBXRef = m_iNumMBX;
			m_iNumMBYRef = m_iNumMBY;
			m_iOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
			m_iOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
			m_rctPrevNoExpandY = m_rctCurrVOPY;
			m_rctPrevNoExpandUV = m_rctCurrVOPUV;
			
			m_rctRefVOPY1 = m_rctCurrVOPY;
			m_rctRefVOPY1.expand (EXPANDY_REFVOP);
			m_rctRefVOPUV1 = m_rctCurrVOPUV;
			m_rctRefVOPUV1.expand (EXPANDUV_REFVOP);
			m_pvopcRefQ1->setBoundRct (m_rctRefVOPY1);
		}

// begin:  added by by Sharp (98/2/10)
		if ( bTemporalScalability && m_vopmd.vopPredType == BVOP ) {
			m_iBVOPOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
			m_iBVOPOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
			m_rctBVOPPrevNoExpandY = m_rctCurrVOPY;
			m_rctBVOPPrevNoExpandUV = m_rctCurrVOPUV;

			m_rctBVOPRefVOPY1 = m_rctCurrVOPY;
			m_rctBVOPRefVOPY1.expand (EXPANDY_REFVOP);
			m_rctBVOPRefVOPUV1 = m_rctCurrVOPUV;
			m_rctBVOPRefVOPUV1.expand (EXPANDUV_REFVOP);
		}
// end: added by Sharp (98/2/10)

		//this is ac/dc pred stuff; clean the memory
		Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
		delete [] m_rgblkmCurrMB;
		for (Int iMB = 0; iMB < m_iNumMBX; iMB++)	{
			for (Int iBlk = 0; iBlk < nBlk; iBlk++)	{
				delete [] (m_rgpmbmAbove [iMB]->rgblkm) [iBlk];
				delete [] (m_rgpmbmCurr  [iMB]->rgblkm) [iBlk];
			}
			delete [] m_rgpmbmAbove [iMB]->rgblkm;
			delete m_rgpmbmAbove [iMB];
			delete [] m_rgpmbmCurr [iMB]->rgblkm;
			delete m_rgpmbmCurr [iMB];
		}
		delete [] m_rgpmbmAbove;
		delete [] m_rgpmbmCurr;
	}

// begin: added by Sharp (98/2/10)
	if ( bTemporalScalability && m_volmd.fAUsage == RECTANGLE ) {
		m_iBVOPOffsetForPadY = m_iOffsetForPadY;
		m_iBVOPOffsetForPadUV = m_iOffsetForPadUV;
		m_rctBVOPPrevNoExpandY = m_rctPrevNoExpandY;
		m_rctBVOPPrevNoExpandUV = m_rctPrevNoExpandUV;

		m_rctBVOPRefVOPY1 = m_rctRefVOPY1;
		m_rctBVOPRefVOPUV1 = m_rctRefVOPUV1;
	}
// end: added by Sharp (98/2/10)
	
	// __LOW_LATENCY_SPRITE_
	if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP)
		return;

    if (m_vopmd.vopPredType != BVOP || m_volmd.volType == ENHN_LAYER)	{
		repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ1);
		repeatPadUV (m_pvopcRefQ1);
		if (m_volmd.fAUsage != RECTANGLE)       {
			if (m_volmd.fAUsage == EIGHT_BIT)
				repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsA () + m_iOffsetForPadY, m_pvopcRefQ1);
		}
	}

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

	if (m_volmd.bOriginalForME) {
		if (m_vopmd.vopPredType == IVOP || m_vopmd.vopPredType == PVOP || 
		    (m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0))
			updateAllOrigRefVOPs (); // update all original reference (MotionEsti) VOP's
	}
}

Void CVideoObjectEncoder::codeVOHead ()
{
	m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VOSH_Start_Code");
	m_pbitstrmOut -> putBits (SESSION_START_CODE, 8, "VOSH_Start_Code");
	// Just signal Advanced Simple Profile @ L2 for now
	m_pbitstrmOut -> putBits (0xF3, 8, "VOSH_Start_Code");

	m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VO_Start_Code");
	m_pbitstrmOut -> putBits (VISUAL_OBJ_START_CODE, 8, "Visual_Obj_Start_Code");
	m_pbitstrmOut -> putBits (0x09, 8, "Visual_Object_Id");

	m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VO_Start_Code");
	m_pbitstrmOut -> putBits (VO_START_CODE, NUMBITS_VO_START_CODE, "VO_Start_Code");		//plus 3 bits
	m_pbitstrmOut -> putBits (m_uiVOId, NUMBITS_VO_ID, "VO_Id");
	UInt uiNumBits = NUMBITS_START_CODE_PREFIX + NUMBITS_VO_START_CODE + NUMBITS_VO_ID;;
	m_statsVOL.nBitsHead += uiNumBits;
	cout << "VO Overhead" << "\t\t" << uiNumBits << "\n\n";
	cout.flush ();
}

Void CVideoObjectEncoder::codeVOLHead (Int iSessionWidth, Int iSessionHeight)
{
	m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VOL_Start_Code");
	m_pbitstrmOut -> putBits (VOL_START_CODE, NUMBITS_VOL_START_CODE, "VOL_Start_Code");		//plus 4 bits
	m_pbitstrmOut -> putBits ((Int) (m_volmd.volType == ENHN_LAYER), NUMBITS_VOL_ID, "VOL_Id"); // by katata
	m_statsVOL.nBitsHead+=NUMBITS_START_CODE_PREFIX+NUMBITS_VOL_START_CODE+NUMBITS_VOL_ID;

// Begin: modified by Hughes	  4/9/98	  per clause 2.1.7. in N2171 document
	m_pbitstrmOut -> putBits ((Int) 0, 1, "VOL_Random_Access");		//isn't this a system level flg?
	m_statsVOL.nBitsHead++;
// End: modified by Hughes	  4/9/98

	m_pbitstrmOut -> putBits ((Int) 4, 8, "VOL_Type_Indicator"); // Set to indicate MAIN profile.
	m_statsVOL.nBitsHead+=8;
	m_pbitstrmOut -> putBits ((Int) 0, 1, "VOL_Is_Object_Layer_Identifier"); //useless flag for now
	m_statsVOL.nBitsHead++;
	m_pbitstrmOut -> putBits ((Int) 1, 4, "aspect_ratio_info"); // square pix
	m_statsVOL.nBitsHead+=4;
	
	m_pbitstrmOut -> putBits (m_volmd.uiVolControlParameters, 1, "VOL_Control_Parameters"); //useless flag for now
	m_statsVOL.nBitsHead++;
	
	if(m_volmd.uiVolControlParameters)
	{
		m_pbitstrmOut -> putBits (m_volmd.uiChromaFormat, 2, "Chroma_Format");
		m_pbitstrmOut -> putBits (m_volmd.uiLowDelay, 1, "Low_Delay");
		m_pbitstrmOut -> putBits (m_volmd.uiVBVParams, 1, "VBV_Params");
		m_statsVOL.nBitsHead += 2 + 1 + 1;

		if(m_volmd.uiVBVParams)
		{
			UInt uiFirstHalfBitRate = (m_volmd.uiBitRate >> 15);
			UInt uiLatterHalfBitRate = (m_volmd.uiBitRate & 0x7fff);
			m_pbitstrmOut -> putBits (uiFirstHalfBitRate, 15, "FirstHalf_BitRate");
			m_pbitstrmOut -> putBits (1, 1, "Marker");
			m_pbitstrmOut -> putBits (uiLatterHalfBitRate, 15, "LatterHalf_BitRate");
			m_pbitstrmOut -> putBits (1, 1, "Marker");

			UInt uiFirstHalfVbvBufferSize = (m_volmd.uiVbvBufferSize >> 3);
			UInt uiLatterHalfVbvBufferSize = (m_volmd.uiVbvBufferSize & 7);
			m_pbitstrmOut -> putBits (uiFirstHalfVbvBufferSize, 15, "FirstHalf_VbvBufferSize");
			m_pbitstrmOut -> putBits (1, 1, "Marker");
			m_pbitstrmOut -> putBits (uiLatterHalfVbvBufferSize, 3, "LatterHalf_VbvBufferSize");
			
			UInt uiFirstHalfVbvBufferOccupany = (m_volmd.uiVbvBufferOccupany >> 15);
			UInt uiLatterHalfVbvBufferOccupany = (m_volmd.uiVbvBufferOccupany & 0x7fff);
			m_pbitstrmOut -> putBits (uiFirstHalfVbvBufferOccupany, 11, "FirstHalf_VbvBufferOccupany");
			m_pbitstrmOut -> putBits (1, 1, "Marker");
			m_pbitstrmOut -> putBits (uiLatterHalfVbvBufferOccupany, 15, "LatterHalf_VbvBufferOccupany");
			m_pbitstrmOut -> putBits (1, 1, "Marker");

			m_statsVOL.nBitsHead += 15 + 15 + 15 + 3 + 11 + 15;
			m_statsVOL.nBitsStuffing += 5;
		}

	}

	if(m_volmd.bShapeOnly==TRUE)
	{
		m_pbitstrmOut -> putBits ((Int) 2, NUMBITS_VOL_SHAPE, "VOL_Shape_Type");
		m_pbitstrmOut -> putBits (1, 1, "Marker");
		m_pbitstrmOut -> putBits (m_volmd.iClockRate, NUMBITS_TIME_RESOLUTION, "VOL_Time_Increment_Resolution"); 
		m_pbitstrmOut -> putBits (1, 1, "Marker");
		m_pbitstrmOut -> putBits (0, 1, "VOL_Fixed_Vop_Rate");
		m_pbitstrmOut -> putBits (0, 1, "VOL_resync_marker_disable");
		m_statsVOL.nBitsHead += NUMBITS_VOL_SHAPE + NUMBITS_TIME_RESOLUTION + 2;
		m_statsVOL.nBitsStuffing +=2;
		cout << "VOL Overhead" << "\t\t" << m_statsVOL.nBitsHead << "\n\n";
		cout.flush ();
		return;
	}
	else
	{
		Int iAUsage = (Int)m_volmd.fAUsage;
		if(iAUsage==2) // CD: 0 = rect, 1 = binary, 2 = shape only, 3 = grey alpha
			iAUsage = 3;
		m_pbitstrmOut -> putBits (iAUsage, NUMBITS_VOL_SHAPE, "VOL_Shape_Type");
		m_pbitstrmOut -> putBits (1, 1, "Marker");
		m_pbitstrmOut -> putBits (m_volmd.iClockRate, NUMBITS_TIME_RESOLUTION, "VOL_Time_Increment_Resolution"); 
		m_pbitstrmOut -> putBits (1, 1, "Marker");
		m_pbitstrmOut -> putBits (0, 1, "VOL_Fixed_Vop_Rate");
		m_statsVOL.nBitsHead += NUMBITS_VOL_SHAPE + NUMBITS_TIME_RESOLUTION + 1;
		if (m_volmd.fAUsage == RECTANGLE) {
			m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
			m_statsVOL.nBitsStuffing ++;
			m_pbitstrmOut -> putBits (iSessionWidth, NUMBITS_VOP_WIDTH, "VOL_Width"); 
			m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
			m_statsVOL.nBitsStuffing ++;
			m_pbitstrmOut -> putBits (iSessionHeight, NUMBITS_VOP_HEIGHT, "VOL_Height"); 
			m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
			m_statsVOL.nBitsStuffing ++;
			m_statsVOL.nBitsHead += NUMBITS_VOP_WIDTH + NUMBITS_VOP_HEIGHT;
		}
	}
	m_pbitstrmOut -> putBits (m_vopmd.bInterlace, (UInt) 1, "VOL_interlace");
	m_statsVOL.nBitsHead++;
	m_pbitstrmOut -> putBits (m_volmd.bAdvPredDisable, (UInt) 1, "VOL_OBMC_Disable");
	m_statsVOL.nBitsHead++;

	// code sprite info
	m_pbitstrmOut -> putBits (m_uiSprite, NUMBITS_SPRITE_USAGE, "VOL_Sprite_Usage");		
	m_statsVOL.nBitsHead += NUMBITS_SPRITE_USAGE;
	if (m_uiSprite == 1) {
		m_pbitstrmOut -> putBits (m_rctSpt.width, NUMBITS_SPRITE_HDIM, "SPRT_hdim");
		m_statsVOL.nBitsHead += NUMBITS_SPRITE_HDIM; 
		m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
		m_statsVOL.nBitsStuffing ++;
		m_pbitstrmOut -> putBits (m_rctSpt.height (), NUMBITS_SPRITE_VDIM, "SPRT_vdim");
		m_statsVOL.nBitsHead += NUMBITS_SPRITE_VDIM;
		m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
		m_statsVOL.nBitsStuffing ++;
		if (m_rctSpt.left >= 0) {
			m_pbitstrmOut -> putBits (m_rctSpt.left, NUMBITS_SPRITE_LEFT_EDGE, "SPRT_Left_Edge");
		} else {
			m_pbitstrmOut -> putBits (m_rctSpt.left & 0x00001FFFF, NUMBITS_SPRITE_LEFT_EDGE, "SPRT_Left_Edge");
		}
		m_statsVOL.nBitsHead += NUMBITS_SPRITE_LEFT_EDGE;
		m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
		m_statsVOL.nBitsStuffing += 1;
		if (m_rctSpt.top >= 0) {
			m_pbitstrmOut -> putBits (m_rctSpt.top, NUMBITS_SPRITE_TOP_EDGE, "SPRT_Top_Edge");
		} else {
			m_pbitstrmOut -> putBits (m_rctSpt.top & 0x00001FFFF, NUMBITS_SPRITE_TOP_EDGE, "SPRT_Top_Edge");
		}
		m_statsVOL.nBitsHead += NUMBITS_SPRITE_TOP_EDGE; 
		m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
		m_statsVOL.nBitsStuffing += 1;
		m_pbitstrmOut -> putBits (m_iNumOfPnts, NUMBITS_NUM_SPRITE_POINTS, "SPRT_Num_Pnt");
		m_statsVOL.nBitsHead += NUMBITS_NUM_SPRITE_POINTS;
		m_pbitstrmOut -> putBits (m_uiWarpingAccuracy, NUMBITS_WARPING_ACCURACY, "SPRT_Warping_Accuracy");
		m_statsVOL.nBitsHead += NUMBITS_WARPING_ACCURACY;
		Bool bLightChange = 0;
		m_pbitstrmOut -> putBits (bLightChange, 1, "SPRT_Brightness_Change");
		m_statsVOL.nBitsHead++;

// Begin: modified by Hughes	  4/9/98
		if (m_sptMode == BASIC_SPRITE)
			m_pbitstrmOut -> putBits (FALSE, 1, "Low_latency_sprite_enable");
		else
			m_pbitstrmOut -> putBits (TRUE, 1, "Low_latency_sprite_enable");
		m_statsVOL.nBitsHead++;
// End: modified by Hughes	  4/9/98
	}

	// NBIT
	m_pbitstrmOut -> putBits ((Int) m_volmd.bNot8Bit, 1, "VOL_NOT_8_BIT_VIDEO");
	m_statsVOL.nBitsHead++;
	if (m_volmd.bNot8Bit) {
		m_pbitstrmOut->putBits ((Int) m_volmd.uiQuantPrecision, 4, "QUANT_PRECISION");
		m_pbitstrmOut->putBits ((Int) m_volmd.nBits, 4, "BITS_PER_PIXEL");
		m_statsVOL.nBitsHead+=8;
	}

	if (m_volmd.fAUsage == EIGHT_BIT)	{
		m_pbitstrmOut -> putBits (m_volmd.bNoGrayQuantUpdate, 1, "VOL_Disable_Gray_Q_Update");
		m_pbitstrmOut -> putBits (0, 1, "Composition_Method");
		m_pbitstrmOut -> putBits (1, 1, "Linear_Composition");
		m_statsVOL.nBitsHead+=3;
	}
	m_pbitstrmOut -> putBits ((Int) m_volmd.fQuantizer, 1, "VOL_Quant_Type"); 
	m_statsVOL.nBitsHead++;
	if (m_volmd.fQuantizer == Q_MPEG) {
		m_pbitstrmOut -> putBits (m_volmd.bLoadIntraMatrix, 1, "VOL_Load_Q_Matrix (intra)");
		m_statsVOL.nBitsHead++;