sptdec.cpp

网络MPEG4IP流媒体开发源代码

		m_rctRefVOPY1 = m_rctCurrVOPY;
		m_rctRefVOPY1.expand (EXPANDY_REFVOP);
		m_rctRefVOPUV1 = m_rctCurrVOPUV;
		m_rctRefVOPUV1.expand (EXPANDUV_REFVOP);
		m_pvopcRefQ1->setBoundRct (m_rctRefVOPY1);
	}
/*
	m_tPiece = -1;
	decode ();

// dshu: begin of modification
	// delete the following statement
//	m_rctSptPieceY = m_rctCurrVOPY;	//for non-rectangular only becomes known now
// dshu: end of modification
	m_tPiece = 0;
	m_iStepI = m_vopmd.intStepI ;
	// ensure byte alignment; 9/16/97
	m_pbitstrmIn->flush (8);
	  		 
// dshu: begin of modification
//	m_pvopcSptQ = new CVOPU8YUVBA (*m_pvopcRefQ1);
//	m_pvopcSptQ -> shift (m_rctSptPieceY.left, m_rctSptPieceY.top); 
	m_pvopcSptQ = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctSptExp);
	m_pvopcSptQ -> shift (m_rctSpt.left, m_rctSpt.top);	  // change to absolute value in sprite coordinates
	PiecePut(*m_pvopcRefQ1, *m_pvopcSptQ, m_rctSptPieceY);
// dshu: end of modification


//m_pvopcSptQ->vdlDump("c:\\SptQ.vdl");

//wchen: temporally out due to memory problem

	CMBMode* pmbmd = m_rgmbmdRef;
	IntraPredDirection* Spreddir;
	IntraPredDirection* preddir;
	// initialize  MB hole status array

// dshu: begin of modification
//	Int iMB_left = m_rctSptPieceY.left / MB_SIZE;	
//	Int iMB_right = m_rctSptPieceY.right / MB_SIZE;	
//	Int iMB_top = m_rctSptPieceY.top / MB_SIZE;	
//	Int iMB_bottom = m_rctSptPieceY.bottom / MB_SIZE;

	// MBs are based on vector, not on absolute value in sprite coordinates
	Int iMB_left = m_iPieceXoffset;	
	Int iMB_right = m_iPieceXoffset + m_iPieceWidth;	
	Int iMB_top = m_iPieceYoffset;	
	Int iMB_bottom = m_iPieceYoffset + m_iPieceHeight;
// dshu: end of modification

	for (iMBY = 0; iMBY < iNumMBY; iMBY++) 
		for (iMBX = 0; iMBX < 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);
				m_rgmbmdSprite[iMBX + iNumMBX * iMBY] = CMBMode (*pmbmd);  // dshu: [v071]  added to store mbmd array for sprite
				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;
		}
*/
// End: modified by Hughes	  4/9/98

	m_oldSptXmitMode = PIECE;
	m_vopmd.SpriteXmitMode = PAUSE;
}

Void CVideoObjectDecoder::decodeSpritePieces  ()
// decode sprite pieces
{
	if ( m_vopmd.SpriteXmitMode == STOP)
		return;

	m_vopmd.SpriteXmitMode = m_oldSptXmitMode;
	CRct rctCurrVOPY = m_rctCurrVOPY;	//caching for warping
	do	{
		decodeOneSpritePiece ();
	} while (( m_vopmd.SpriteXmitMode != STOP) && ( m_vopmd.SpriteXmitMode != PAUSE));

// dshu: [v071]  Begin of modification
	m_rctCurrVOPY = rctCurrVOPY;  //    restore for warping
	if (m_volmd.fAUsage != RECTANGLE)
		padSprite()	;  //    final padding just before warping 
// dshu: [v071] end of modification

	if ( m_vopmd.SpriteXmitMode == STOP)	{

// dshu: begin of modification
		Int iNumMBX = m_rctSptQ.width / MB_SIZE; 
		Int iNumMBY = m_rctSptQ.height () / MB_SIZE;
		Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
		for (Int iMBY = 0; iMBY < iNumMBY; iMBY++){
			for (Int iMB = 0; iMB < 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;
		delete [] m_rgmbmdSprite ;	   // dshu: [v071] 
// dshu: end of modification
//wchen: can you just delete double points like this?
//temporarilly removed 

//		delete [] m_ppPieceMBstatus ;
//		delete [] m_ppUpdateMBstatus ;
	}
	
	//restore since it was changed during decoding to I/P
	m_vopmd.vopPredType = SPRITE;
	//restore for warping
//	m_rctCurrVOPY = rctCurrVOPY;   // dshu: [v071];   move to location of one statement before padSprite()
	// ensure byte alignment
	m_pbitstrmIn->flush (8);
}

//wchen: moved decode piece part from vopsedec.cpp -- decode ()
Int CVideoObjectDecoder::decodeOneSpritePiece ()
{
	//wchen: the part deals with stop and pause stay in decode ()
	assert (m_vopmd.SpriteXmitMode != STOP && m_vopmd.SpriteXmitMode != PAUSE);
	m_rctSptPieceY = decodeVOSHead ();
	if (m_vopmd.SpriteXmitMode == STOP || m_vopmd.SpriteXmitMode == PAUSE)
		return TRUE;
	else if (m_vopmd.SpriteXmitMode == PIECE )	//faking the paramters to fool vopmbdec
		m_vopmd.vopPredType = IVOP;
	else 
		m_vopmd.vopPredType = PVOP;

// dshu: begin of modification
//	m_pvopcRefQ1 -> shift (m_rctSptPieceY.left, m_rctSptPieceY.top);
//	PieceOverlay(*m_pvopcSptQ, *m_pvopcRefQ1,  m_rctSptPieceY);	  // extract reference
//	m_pvopcRefQ1 -> shift (-m_rctSptPieceY.left, -m_rctSptPieceY.top);	// restore the m_pvopcRefQ1 to zero offset
// dshu: end of modification


// dshu: begin of modification
	//copy to Q0 via SptP
	//	CVOPU8YUVBA* pvopcSptP = new CVOPU8YUVBA (*m_pvopcSptQ, m_volmd.fAUsage, m_rctSptPieceY);	 // extract reference
	//	m_pvopcRefQ0->overlay (*pvopcSptP);
	//	delete pvopcSptP;

	PieceGet(*m_pvopcRefQ1, *m_pvopcSptQ, m_rctSptPieceY);
// dshu: end of modification


	//always to that since the rect keeps changing
	//internally, every piece starts from (0, 0)
	m_rctCurrVOPY  = CRct(0,0, m_rctSptPieceY.width, m_rctSptPieceY.height());
	m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
	setRefStartingPointers ();
	computeVOPMembers ();
	
	decodeVOP ();
	
	//delete ac/dc pred stuff
	Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
	delete [] m_rgblkmCurrMB;
	m_rgblkmCurrMB = NULL;
	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;
	m_rgpmbmAbove = NULL;
	delete [] m_rgpmbmCurr;
	m_rgpmbmCurr = NULL;

	// Place the decoded sprite piece into sprite buffer.
	// Please notice that initial piece is offset by a vector like any VOP;
	// the rest of sprite pieces have zero offset, thus require shifting to be placed into buffer.
	// shift back to absolutes in sprite coordinates for overlaying	

// dshu: begin of modification
//	m_pvopcRefQ1 -> shift (m_rctSptPieceY.left, m_rctSptPieceY.top);
//	m_pvopcSptQ -> overlay (*m_pvopcRefQ1, m_rctSptPieceY);
	
	PiecePut(*m_pvopcRefQ1, *m_pvopcSptQ, m_rctSptPieceY);
//	PieceOverlay(*m_pvopcRefQ1, *m_pvopcSptQ, m_rctSptPieceY);
	// restore the m_pvopcRefQ1 to zero offset
//	m_pvopcRefQ1 -> shift (-m_rctSptPieceY.left, -m_rctSptPieceY.top);
// dshu: end of modification

	return TRUE;
}

CRct CVideoObjectDecoder::decodeVOSHead ()
{
	m_oldSptXmitMode = m_vopmd.SpriteXmitMode;
	m_vopmd.SpriteXmitMode = (SptXmitMode) m_pbitstrmIn -> getBits (NUMBITS_SPRITE_XMIT_MODE);
	if (( m_vopmd.SpriteXmitMode != STOP) &&( m_vopmd.SpriteXmitMode != PAUSE)) {
		Int stepToBeDeCoded = m_pbitstrmIn -> getBits (NUMBITS_VOP_QUANTIZER);
		if (m_vopmd.SpriteXmitMode == UPDATE) 
			m_vopmd.intStep = stepToBeDeCoded;
		else
			m_vopmd.intStepI = stepToBeDeCoded;
		m_iPieceWidth = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_MB_OFFSET);
		m_iPieceHeight = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_MB_OFFSET);
// Begin: modified by Hughes	  4/9/98
		/* Int iMarker = wmay */ m_pbitstrmIn -> getBits (MARKER_BIT);
// End: modified by Hughes	  4/9/98

		m_iPieceXoffset = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_MB_OFFSET);
		m_iPieceYoffset = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_MB_OFFSET);
		//wchen: changed to absolute value in sprite coordinates
		Int left  = (m_iPieceXoffset * MB_SIZE) + m_rctSpt.left;
		Int top = (m_iPieceYoffset * MB_SIZE)  + m_rctSpt.top;
		Int right = left + m_iPieceWidth * MB_SIZE ;
		Int bottom = top + m_iPieceHeight * MB_SIZE ;
		return CRct (left, top, right, bottom);
	}
	else
		return CRct();
}