sptenc.cpp

网络MPEG4IP流媒体开发源代码

	if (m_volmd.fAUsage == RECTANGLE) {
//		m_rctCurrVOPY = CRct (0, 0, iSessionWidthRound, iSessionHeightRound);
		m_pvopcOrig->setBoundRct (m_rctCurrVOPY);
		m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
		
		m_rctRefVOPY0 = m_rctCurrVOPY;
		m_rctRefVOPY0.expand (EXPANDY_REFVOP);
		m_rctRefVOPUV0 = m_rctRefVOPY0.downSampleBy2 ();
		
		m_rctRefVOPY1 = m_rctRefVOPY0;
		m_rctRefVOPUV1 = m_rctRefVOPUV0;
		
		m_rctRefVOPZoom0 = m_rctRefVOPY0.upSampleBy2 ();
		m_rctRefVOPZoom1 = m_rctRefVOPY1.upSampleBy2 ();
		m_pvopcRefOrig0->setBoundRct (m_rctRefVOPY0);
		m_pvopcRefOrig1->setBoundRct (m_rctRefVOPY1);
		computeVOLConstMembers (); // these VOP members are the same for all frames
	}

	m_tPiece = -1;
	encode (TRUE, -1, IVOP);

	m_pvopcSptQ = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctSptQ);  
	VOPOverlay(*m_pvopcRefQ1, *m_pvopcSptQ, 1);
 	delete m_pvopcSptP;	  m_pvopcSptP = NULL;  
	delete m_pvopcOrig;	  m_pvopcOrig  = NULL;
	delete m_pvopcRefQ0;	m_pvopcRefQ0 = NULL;
	delete m_pvopcRefQ1;

	m_pvopcRefQ1 = 	m_pvopcSptQ ; // to support	"rgpvoenc [BASE_LAYER] -> swapRefQ1toSpt (); "

	m_iNumMBX = m_rctSptExp.width / MB_SIZE; 
	m_iNumMBY = m_rctSptExp.height () / MB_SIZE;

	CMBMode* pmbmd = m_rgmbmdRef;
	IntraPredDirection* Spreddir;
	IntraPredDirection* preddir;
	// initialize  MB hole status array	
	Int iMB_left = (rctRefFrameY.left - m_rctSptExp.left) / MB_SIZE;	
	Int iMB_right = (rctRefFrameY.right - m_rctSptExp.left) / MB_SIZE;  	
	Int iMB_top = (rctRefFrameY.top - m_rctSptExp.top) / MB_SIZE;	
	Int iMB_bottom = (rctRefFrameY.bottom - m_rctSptExp.top) / MB_SIZE;
	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) 
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
			if ((iMBX >= iMB_left && iMBX < iMB_right) && (iMBY >= iMB_top && iMBY < iMB_bottom)) 
			{
				m_ppPieceMBstatus[iMBY][iMBX] = PIECE_DONE;
				m_rgmbmdSpt[iMBY][iMBX] = CMBMode (*pmbmd);
				Spreddir = m_rgmbmdSpt[iMBY][iMBX].m_preddir;
				preddir = (*pmbmd).m_preddir;
				memcpy (Spreddir, preddir, 10  * sizeof (IntraPredDirection));
				pmbmd++;
			}
			else
				m_ppPieceMBstatus[iMBY][iMBX] = NOT_DONE;
			m_ppUpdateMBstatus[iMBY][iMBX] = NOT_DONE;
		}
	Int Curr = (m_pbitstrmOut -> getCounter ()) - OldCount;
	Int Num_MB = (iMB_right-iMB_left) * (iMB_bottom-iMB_top);
	m_pSptmbBits[AVGPIECEMB] = Curr / Num_MB; // average macroblock bits used by a sprite piece
	
	InitPieceRect = rctRefFrameY; 
	InitPartialRect = InitPieceRect; 
	m_rctPieceQ = InitPieceRect;
*/
#ifdef __TRACE_AND_STATS_
	m_pbitstrmOut -> trace (-1, "VOP_Time");
#endif // __TRACE_AND_STATS_
	m_rctPieceQ = CRct ( m_rctSptPieceY.left, m_rctSptPieceY.top, m_rctSptPieceY.left, m_rctSptPieceY.top);
	m_pvopcSptQ = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctSptQ);  
	m_pvopcRefQ1 = 	m_pvopcSptQ ; // to support	"rgpvoenc [BASE_LAYER] -> swapRefQ1toSpt (); "
	m_pbitstrmOut->reset ();	// inserted as a result of half day debug
// end:  modified by Hughes	  4/9/98

	m_tPiece = m_nFirstFrame;
	m_tUpdate = m_nFirstFrame;
	m_vopmd.SpriteXmitMode = PIECE;
	if ( m_sptMode == BASIC_SPRITE)
		m_vopmd.SpriteXmitMode  = NEXT;
}

Void CVideoObjectEncoder::initialSpritePiece (Int iSessionWidth, Int iSessionHeight)
{
	// identify initial sprite piece
	CRct rctRefFrameY, rct ;
	Bool SpriteObject =  (m_sptMode == PIECE_UPDATE) || ( m_sptMode == BASIC_SPRITE);

// Begin: modified by Hughes	  4/9/98
	m_rctSptExp = CRct (0, 0, iSessionWidth, iSessionHeight);  // m_rctSptExp is specified in relative coordinate
// end:  modified by Hughes	  4/9/98

	if (!SpriteObject) 
	{
		if (m_iNumOfPnts == 0) 
			rct =  CRct (0, 0, iSessionWidth, iSessionHeight);
		else
			rct = InitialPieceRect (0);
		rctRefFrameY = CRct (rct.left, rct.top, rct.right, (rct.bottom + 16 - rct.height()/2));	   //dshu: 12/22/97
//		rctRefFrameY = CRct (rct.left, rct.top, rct.right, (rct.bottom - rct.width/2));	 
	}
	else
		rctRefFrameY = CRct (0, 0, iSessionWidth, iSessionHeight);
	if (!SpriteObject)
		rctRefFrameY = 	PieceExpand (rctRefFrameY);
	m_rctSptPieceY =  rctRefFrameY;
}

CRct CVideoObjectEncoder::InitialPieceRect (Time ts)
{
	CRct rctSpt, rctSptQ;
	CSiteD rgstSrcQ [4];
	rgstSrcQ [0] = CSiteD (m_rctOrg.left, m_rctOrg.top);
	rgstSrcQ [1] = CSiteD (m_rctOrg.right, m_rctOrg.top);
	rgstSrcQ [2] = CSiteD (m_rctOrg.left, m_rctOrg.bottom);
	rgstSrcQ [3] = CSiteD (m_rctOrg.right, m_rctOrg.bottom);

	for (Int i = 0; i < m_iNumOfPnts; i++) {
		// quantization	rgstSrc
		CoordD x = rgstSrcQ [i].x, y = rgstSrcQ [i].y;
		Int rnd = (x > 0) ? (Int) (2.0 * x + .5) : (Int) (2.0 * x - .5);
		m_rgstSrcQ [i].x = (CoordD) rnd / (CoordD) 2.;
		rnd = (y > 0) ? (Int) (2.0 * y + .5) : (Int) (2.0 * y - .5);
		m_rgstSrcQ [i].y = (CoordD) rnd / (CoordD) 2.;
	}
									   
	rctSptQ = CornerWarp (m_pprgstDest[ts], m_rgstSrcQ); 
	rctSpt = CRct (rctSptQ.left, 0, rctSptQ.right, m_rctSpt.height());	 
	return rctSpt;		
}

CRct CVideoObjectEncoder::CornerWarp (const CSiteD* rgstDst, 
									  const CSiteD* rgstSrcQ)
{
	CSiteD stdLeftTopWarp, stdRightTopWarp, stdLeftBottomWarp, stdRightBottomWarp;
	CPerspective2D persp (m_iNumOfPnts, rgstSrcQ, rgstDst, m_uiWarpingAccuracy);
	stdLeftTopWarp = (persp * CSiteD (0, 0)).s;
	stdRightTopWarp = (persp * CSiteD (m_rctOrg.width, 0)).s;
	stdLeftBottomWarp = (persp * CSiteD (0, m_rctOrg.height())).s;
	stdRightBottomWarp = (persp * CSiteD (m_rctOrg.width, m_rctOrg.height())).s;

	CRct rctWarp (stdLeftTopWarp, stdRightTopWarp, stdLeftBottomWarp, stdRightBottomWarp);
	UInt accuracy1 = 1 << (m_uiWarpingAccuracy + 1);
	rctWarp =  rctWarp	/ accuracy1 ; 
	rctWarp.shift(-m_rctSpt.left, -m_rctSpt.top);  // rectangle is w.r.t. UL corner of sprite object

	return rctWarp;
}

Void CVideoObjectEncoder::encodeSpritePiece (Time t)
// code sprite pieces 
{
	if (m_vopmd.SpriteXmitMode  == STOP)
		return ;
	if ((m_vopmd.SpriteXmitMode  == PIECE) || (m_vopmd.SpriteXmitMode  == UPDATE)){
		m_pvopcSptQ -> shift(-m_rctSpt.left, -m_rctSpt.top);	// prepare m_pvopcSptQ to merge new piece
		UInt uiF = t + m_volmd.iTemporalRate;
		uiF = (	uiF >  m_nLastFrame) ?  m_nLastFrame :  uiF;
		UInt uiSptPieceSize = m_iBufferSize/(300/m_volmd.iTemporalRate);
		CRct rct = m_rctPieceQ;
		if (( m_sptMode != PIECE_UPDATE) && (m_tPiece == (Time) m_nFirstFrame))
		{	
// Begin: modified by Hughes	  4/9/98
			InitPieceRect = encPiece (m_rctSptPieceY);
			rct = InitPieceRect;
// End: modified by Hughes	  4/9/98
			rct = CRct (rct.left, (rct.top - 3*MB_SIZE + m_rctSpt.height()/2), rct.right, m_rctSpt.height()); // dshu: 1/4/98	 
			InitPartialRect = encPiece (rct);

			m_vopmd.SpriteXmitMode = UPDATE;
			m_rctUpdateQ = CRct ( rct.left, rct.top, rct.left, rct.bottom);
			CRct rcttemp = encPiece (rct);
			rcttemp = encPiece (CRct ( rct.left, m_rctPieceQ.top, rct.right, rct.top));
			m_vopmd.SpriteXmitMode = PIECE;
			m_tPiece = 	uiF;

			if (m_iNumOfPnts == 0)
				m_vopmd.SpriteXmitMode  = NEXT; 
		}
		else  {
			if (( InitPartialRect.right >= InitPieceRect.right) &&
				( InitPartialRect.left <= InitPieceRect.left))  {
				CRct rctSptQ = ZoomOrPan ();
				encSptPiece (rctSptQ, uiSptPieceSize);
				while ((m_tPiece < (Time) uiF) &&
					(m_vopmd.SpriteXmitMode  == PIECE) )
					encSptPiece (ZoomOrPan (), uiSptPieceSize);
			}
			else {
				m_bSptRightPiece = TRUE;
				encSptPiece (m_rctUpdateQ, uiSptPieceSize);
				InitPartialRect = m_rctUpdateQ;
			}
			Bool StartUpdate = (m_tPiece >= (Time) m_nLastFrame) 
				&& (m_tUpdate == (Time) m_nFirstFrame);
			if ( StartUpdate )	{
				m_vopmd.SpriteXmitMode  = UPDATE;
				if(( t < (Time) m_nLastFrame) && (m_sptMode != PIECE_OBJECT)) {
					// identify initial update piece
					rct = InitialPieceRect (t-m_nFirstFrame);
					Int left = (rct.left < m_rctSptExp.left) ? 	m_rctSptExp.left : rct.left;
					Int right = (rct.right > m_rctSptExp.right) ? 	m_rctSptExp.right : rct.right;
					InitPieceRect = CRct (left, rct.top, right, rct.bottom);
					rct = InitPieceRect ;
					if (m_sptMode == PIECE_UPDATE) {					
						cout << "\t" << "\n start sending updates for sprite..."  << "\n";
						cout.flush ();
						m_tUpdate = -1;
						m_rctUpdateQ = CRct ( left, rct.top, left, rct.bottom);
						m_pSptmbBits[AVGUPDATEMB] = m_pSptmbBits[AVGUPDATEMB] ;
						rct = PieceSize (TRUE, uiSptPieceSize);
					}
					rct = encPiece (rct);
					InitPartialRect = m_rctUpdateQ;				
					m_tUpdate = t;
				}
				else 
					m_vopmd.SpriteXmitMode = NEXT;
			}
		}
		m_pvopcSptQ -> shift(m_rctSpt.left, m_rctSpt.top);	 // prepare m_pvopcSptQ for warping	
		m_vopmd.vopPredType = SPRITE;
		// --- begin of bug fix (David Shu)
		if (m_volmd.fAUsage != RECTANGLE)
		{
			CRct r1 =  m_rctSptQ;
			m_rctSptQ = m_rctSptExp;
			m_rctCurrVOPY  = CRct(0,0, m_rctSptQ.width, m_rctSptQ.height());
			m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
			m_rctRefFrameY = CRct (-EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME,
				EXPANDY_REF_FRAME + m_rctSptQ.width, EXPANDY_REF_FRAME + m_rctSptQ.height());
			m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
			setRefStartingPointers ();
			m_iFrameWidthY = m_rctRefFrameY.width;
			m_iFrameWidthUV = m_rctRefFrameUV.width;
			m_iFrameWidthYxMBSize = MB_SIZE * m_iFrameWidthY;
			m_iFrameWidthYxBlkSize = BLOCK_SIZE * m_iFrameWidthY;
			m_iFrameWidthUVxBlkSize = BLOCK_SIZE * m_iFrameWidthUV;
			m_iOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
			m_iOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left,m_rctCurrVOPUV.top);
			padSprite() ;  //    final padding just before warping

			m_rctSptQ = r1;
		}
		// --- end of bug fix
	}
	
	if (m_vopmd.SpriteXmitMode  != STOP){
		SptXmitMode  PieceXmitMode = m_vopmd.SpriteXmitMode;
		if (m_vopmd.SpriteXmitMode  == NEXT )
		{
			PieceXmitMode = STOP ;
			m_vopmd.SpriteXmitMode  = STOP;
			m_iNumMBX = m_rctSptExp.width / MB_SIZE; 
			m_iNumMBY = m_rctSptExp.height () / MB_SIZE;
			Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
			for (Int iMBY = 0; iMBY < m_iNumMBY; iMBY++){
				for (Int iMB = 0; iMB < m_iNumMBX; iMB++)	{
					for (Int iBlk = 0; iBlk < nBlk; iBlk++)	
						delete [] (m_rgpmbmCurr_Spt[iMBY][iMB]->rgblkm) [iBlk];

					delete [] m_rgpmbmCurr_Spt [iMBY][iMB]->rgblkm;
					delete [] m_rgpmbmCurr_Spt [iMBY][iMB];
				}
				delete [] m_ppPieceMBstatus[iMBY] ; 
				delete [] m_ppUpdateMBstatus[iMBY] ;  
				delete [] m_rgmbmdSpt[iMBY] ;
				delete [] m_rgpmbmCurr_Spt[iMBY];
			}
			delete [] m_ppPieceMBstatus ; 
			delete [] m_ppUpdateMBstatus ;  
			delete [] m_rgmbmdSpt ;
			delete [] m_rgpmbmCurr_Spt;
// Begin: modified by Hughes	  4/9/98
			delete [] m_rgmbmdSprite ;	   
// end:  modified by Hughes	  4/9/98
		}
		else
			m_vopmd.SpriteXmitMode  = PAUSE;
		codeVOSHead ();
		if (m_vopmd.SpriteXmitMode  != STOP)
			m_vopmd.SpriteXmitMode  = PieceXmitMode;

	}
}

Void CVideoObjectEncoder::encSptPiece (CRct rctSptQ, UInt uiSptPieceSize)
{
	UInt uiTR = m_volmd.iTemporalRate;
	CRct rctSpt = (m_vopmd.SpriteXmitMode == PIECE ) ? m_rctPieceQ : m_rctUpdateQ ; 
	CRct rctSptQNew = rctSpt;
	CRct rctPiece = PieceSize (m_bSptRightPiece, uiSptPieceSize);
	rctSpt.include(rctPiece);

	UInt uiF = (m_vopmd.SpriteXmitMode == PIECE ) ? m_tPiece : m_tUpdate;
	UInt boundary = m_nLastFrame ;	
	if ( rctSptQ.valid() && (rctSptQNew != m_rctSptExp)) {
		rctSptQ = rctSpt;
		uiF += uiTR ;  
		while ((rctSptQNew.right <= rctSptQ.right) && (rctSptQNew.left >= rctSptQ.left) 
			&& (uiF <= boundary)) {
			CRct rctWarpNew = CornerWarp (m_pprgstDest[uiF- m_nFirstFrame], m_rgstSrcQ);
			if (rctWarpNew.left < m_rctSptExp.left) rctWarpNew.left = m_rctSptExp.left;
			if (rctWarpNew.right > m_rctSptExp.right) rctWarpNew.right = m_rctSptExp.right;
			rctSptQNew.include (rctWarpNew);