if (rctWarpNew.right > m_rctSptExp.right) rctWarpNew.right = m_rctSptExp.right;
			rctSptQNew.include (rctWarpNew);
			uiF = ((rctSptQNew.right <= rctSptQ.right) && (rctSptQNew.left >= rctSptQ.left))
				? (uiF + uiTR) : (uiF - uiTR);
		}
		Int left = (rctPiece.left < rctSptQNew.left) ? 	rctSptQNew.left :  rctPiece.left;
		Int right = (rctPiece.right > rctSptQNew.right) ? 	rctSptQNew.right :  rctPiece.right;
		if ((right-MB_SIZE) > left)
			rctSpt = encPiece (CRct (left, m_rctSptExp.top, right, m_rctSptExp.bottom));
	}
	else {
		uiF = boundary;
	}
	if (uiF  > boundary)		
		uiF = boundary;

	if (m_vopmd.SpriteXmitMode == PIECE )
		m_tPiece = uiF;
	if (m_vopmd.SpriteXmitMode == UPDATE ) 			
		m_tUpdate = uiF;

	if (uiF  >= boundary) {
		if (( m_sptMode == PIECE_OBJECT) || m_vopmd.SpriteXmitMode == UPDATE )
			m_vopmd.SpriteXmitMode = NEXT;
	}
}

CRct CVideoObjectEncoder::PieceSize (Bool rightpiece, UInt uiSptPieceSize)
{	

	Int right, left;

	CRct rctSptQ = (m_vopmd.SpriteXmitMode == PIECE ) ? m_rctPieceQ : m_rctUpdateQ ; 
	Int AvgBitsMb = (m_vopmd.SpriteXmitMode == PIECE ) ? m_pSptmbBits [AVGUPDATEMB] : m_pSptmbBits[AVGUPDATEMB];
	assert (AvgBitsMb != 0);	

	m_iPieceHeight = (MB_SIZE-1 + m_rctPieceQ.height ()) / MB_SIZE;
	m_iPieceWidth= (Int) (0.5 + uiSptPieceSize/(AvgBitsMb * m_iPieceHeight));

	m_iPieceWidth= (m_iPieceWidth<2)? 2 : m_iPieceWidth;

	if (rightpiece) {
		right = rctSptQ.right + MB_SIZE * m_iPieceWidth;
		if (right > m_rctSptExp.right) {
			right = m_rctSptExp.right;
		}
		if ((m_vopmd.SpriteXmitMode == UPDATE ) && (right > m_rctPieceQ.right)) {
			right = m_rctPieceQ.right;
		}
		left = rctSptQ.right;
	}
	else  {
		left = rctSptQ.left - MB_SIZE* m_iPieceWidth;
		if (left < m_rctSptExp.left) {
			left = m_rctSptExp.left ;
		}
		if ((m_vopmd.SpriteXmitMode == UPDATE ) && (left < m_rctPieceQ.left)) {
			left = m_rctPieceQ.left ;
		}
		right = rctSptQ.left;
	}
	CRct rctSptPieceY = CRct (left, m_rctSptExp.top, right, m_rctSptExp.bottom);
	if ((m_tUpdate > (Time) m_nFirstFrame) || (m_vopmd.SpriteXmitMode == PIECE )) 
		if (rightpiece) {
			if (left > (m_rctSptExp.left+MB_SIZE))
			{
				left -=  MB_SIZE;
				rctSptPieceY = CRct (left, rctSptPieceY.top, rctSptPieceY.right, rctSptPieceY.bottom);
			}
		}
		else{
			if (right < (m_rctSptExp.right - MB_SIZE))
			{
				right +=  MB_SIZE;
				rctSptPieceY = CRct (rctSptPieceY.left, rctSptPieceY.top, right, rctSptPieceY.bottom);
			}
		}
	return	rctSptPieceY;
}

CRct CVideoObjectEncoder::encPiece (CRct rctpiece)
{	
	Time ts;
	Int right = rctpiece.right; 
	Int left = rctpiece.left;
	CRct rctSpt = (m_vopmd.SpriteXmitMode == PIECE ) ? m_rctPieceQ : m_rctUpdateQ ; 

	CRct rctSptPieceY = PieceExpand (rctpiece);
//	m_rctSptPieceY = rctSptPieceY;
//	m_rctSptPieceY.shift(m_rctSpt.left, m_rctSpt.top);

	if (m_volmd.fAUsage == RECTANGLE) {
		m_rctCurrVOPY = rctSptPieceY;		
		m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
	}

	m_iPieceWidth= rctSptPieceY.width / MB_SIZE;
	m_iPieceHeight= rctSptPieceY.height () / MB_SIZE;
		
	m_iPieceXoffset= (rctSptPieceY.left - m_rctSptExp.left) / MB_SIZE;
	m_iPieceYoffset= (rctSptPieceY.top - m_rctSptExp.top) / MB_SIZE;
	rctSpt.include(rctSptPieceY);
	codeVOSHead ();

	Int OldCount = m_pbitstrmOut -> getCounter ();

 	// encode sprite piece	
	m_pvopcSptP = new CVOPU8YUVBA (*m_pvopcSpt, m_volmd.fAUsage, rctSptPieceY);
	m_pvopcSptP -> shift (-rctSptPieceY.left, -rctSptPieceY.top);	
	CRct rctRefFrameY = m_pvopcSptP -> whereY() ;
	m_rctCurrVOPY = CRct (0, 0, rctRefFrameY.width, rctRefFrameY.height());		
	m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();

	m_rctRefFrameY = CRct (
		-EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME, 
		EXPANDY_REF_FRAME + rctRefFrameY.width, EXPANDY_REF_FRAME + rctRefFrameY.height()
	);
	m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
	m_pvopcOrig = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY, m_volmd.iAuxCompCount); 
	VOPOverlay (*m_pvopcSptP, *m_pvopcOrig);

	m_pvopcOrig->setBoundRct (m_rctCurrVOPY);

	m_pvopcRefQ1 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY, m_volmd.iAuxCompCount);
	delete m_pvopcSptP;
	m_pvopcSptP = new CVOPU8YUVBA (*m_pvopcSptQ, m_volmd.fAUsage, rctSptPieceY);	 // extract reference
	m_pvopcSptP -> shift (-rctSptPieceY.left, -rctSptPieceY.top);
	VOPOverlay (*m_pvopcSptP, *m_pvopcRefQ1);

	if (m_vopmd.SpriteXmitMode == PIECE ) {		
		m_rctPieceQ = rctSpt;
		ts = m_tPiece;
		m_vopmd.vopPredType = IVOP;
	}
	else {
		m_rctUpdateQ = rctSpt;
		ts = m_tUpdate;
		m_vopmd.vopPredType = PVOP;
	}
		
 	m_pvopcRefQ0 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY, m_volmd.iAuxCompCount);
	m_iFrameWidthY = m_pvopcRefQ0->whereY ().width;
	m_iFrameWidthUV = m_pvopcRefQ0->whereUV ().width;
	m_iFrameWidthYxMBSize = MB_SIZE * m_pvopcRefQ0->whereY ().width; 
	m_iFrameWidthYxBlkSize = BLOCK_SIZE * m_pvopcRefQ0->whereY ().width; 
	m_iFrameWidthUVxBlkSize = BLOCK_SIZE * m_pvopcRefQ0->whereUV ().width;

	encode (TRUE, ts, m_vopmd.vopPredType);
//	encode (TRUE, ts, m_vopmd.SpriteXmitMode);
	
	m_pvopcRefQ1 -> shift (rctSptPieceY.left, rctSptPieceY.top);  
	VOPOverlay (*m_pvopcRefQ1, *m_pvopcSptQ, 1);
	delete m_pvopcSptP;	
	delete m_pvopcOrig;	 m_pvopcOrig = NULL ;
	delete m_pvopcRefQ0; m_pvopcRefQ0 = NULL ;	
	delete m_pvopcRefQ1; m_pvopcRefQ1 = NULL ;
 	if (m_iNumOfPnts == 0) {
		m_pvopcRefQ1 = m_pvopcSptQ;	  // to avoid	"rgpvoenc [BASE_LAYER] -> swapRefQ1toSpt (); "
	}

	Int Curr = (m_pbitstrmOut -> getCounter ()) - OldCount;	
	if (m_iNumSptMB > 0) {
		if (m_vopmd.SpriteXmitMode == PIECE ) 
			m_pSptmbBits[AVGPIECEMB] = Curr / m_iNumSptMB; // average macroblock bits used by a sprite piece	
		if (m_vopmd.SpriteXmitMode == UPDATE ) 
			m_pSptmbBits[AVGUPDATEMB] = Curr / m_iNumSptMB; // average macroblock bits used by a sprite piece 
	}
	return rctSpt;
}
CRct CVideoObjectEncoder::ZoomOrPan ()
{
	CRct rctWarpNew ;
	CRct rctWarpOld ;
	UInt uiTR = m_volmd.iTemporalRate;
	UInt uiF = (m_vopmd.SpriteXmitMode == PIECE ) ? m_tPiece : m_tUpdate;
	UInt boundary = m_nLastFrame ;

	if (uiF >= boundary)
		return rctWarpNew;		

	rctWarpNew = CornerWarp (m_pprgstDest[uiF- m_nFirstFrame], m_rgstSrcQ);
	rctWarpOld = rctWarpNew;
	// determine if sprite is zooming or panning?
	while (rctWarpNew == rctWarpOld) {
		uiF += uiTR ;
		rctWarpNew = CornerWarp (m_pprgstDest[uiF- m_nFirstFrame], m_rgstSrcQ);
	}
	if ((rctWarpNew.right > rctWarpOld.right) && (rctWarpNew.left < rctWarpOld.left))
		m_bSptZoom = TRUE;  // sprite is zooming
	else {
		m_bSptZoom = FALSE ;  // sprite is panning		 
		if (rctWarpNew.left < rctWarpOld.left)
			m_bSptRightPiece = FALSE;  // sprite is panning to the left
		else
			m_bSptRightPiece = TRUE;  // sprite is panning to the right
	}
	rctWarpNew.include (rctWarpOld);
	return rctWarpNew;		
}

Void CVideoObjectEncoder::codeVOSHead ()   
{
	m_pbitstrmOut -> putBits (m_vopmd.SpriteXmitMode, NUMBITS_SPRITE_XMIT_MODE, "Sprite_TRANSMIT_MODE");
	if (( m_vopmd.SpriteXmitMode != STOP) &&( m_vopmd.SpriteXmitMode != PAUSE)) {
		// Sprite piece overhead code
		static UInt uiNumBitsStart = 4* NUMBITS_SPRITE_MB_OFFSET + NUMBITS_SPRITE_XMIT_MODE + NUMBITS_VOP_QUANTIZER;
		Int stepToBeCoded = (m_vopmd.SpriteXmitMode == UPDATE) ? m_vopmd.intStep : m_vopmd.intStepI;
		m_pbitstrmOut -> putBits (stepToBeCoded, NUMBITS_VOP_QUANTIZER, "sprite_Piece_Quantier");
		m_pbitstrmOut -> putBits (m_iPieceWidth, (UInt) NUMBITS_SPRITE_MB_OFFSET, "sprite_Piece_width");		//plus 9 bits
		m_pbitstrmOut -> putBits (m_iPieceHeight, (UInt) NUMBITS_SPRITE_MB_OFFSET, "sprite_Piece_height");		//plus 9 bits
// Begin: modified by Hughes	  4/9/98
		m_pbitstrmOut -> putBits (MARKER_BIT, MARKER_BIT, "Marker_Bit");
// End: modified by Hughes	  4/9/98
		m_pbitstrmOut -> putBits (m_iPieceXoffset, (UInt) NUMBITS_SPRITE_MB_OFFSET, "sprite_Piece_Xoffset");		//plus 9 bits
		m_pbitstrmOut -> putBits (m_iPieceYoffset, (UInt) NUMBITS_SPRITE_MB_OFFSET, "sprite_Piece_Yoffset");		//plus 9 bits
	}
}

CRct CVideoObjectEncoder::findTightBoundingBox (CVOPU8YUVBA* vopuc)
{
	const CRct& rctOrig =  vopuc -> whereY ();
	CoordI left = rctOrig.right - 1;
	CoordI top = rctOrig.bottom - 1;
	CoordI right = rctOrig.left;
	CoordI bottom = rctOrig.top;
	const PixelC* ppxlcBY = vopuc->pixelsBY ();
	for (CoordI y = rctOrig.top; y < rctOrig.bottom; y++) {
		for (CoordI x = rctOrig.left; x < rctOrig.right; x++) {
			if (*ppxlcBY != transpValue) {
				left = min (left, x);
				top = min (top, y);
				right = max (right, x);
				bottom = max (bottom, y);
			}								
			ppxlcBY++;
		}
	}
	right++;
	bottom++;
	if (left % 2 != 0)
		left--;
	if (top % 2 != 0)
		top--;

	return PieceExpand (CRct (left, top, right, bottom));
}

//  extend the rctOrg size to multiples of MBSize w.r.t. m_rctSptExp 
CRct CVideoObjectEncoder::PieceExpand (const CRct& rctOrg)
{
// Begin: modified by Hughes	  4/9/98
//	Int left = rctOrg.left ;	
//	Int right = rctOrg.right ;	
//	Int top = rctOrg.top ;	
//	Int bottom = rctOrg.bottom ;

	Int left = (rctOrg.left < m_rctSptExp.left) ? m_rctSptExp.left : rctOrg.left;	
	Int right = (rctOrg.right > m_rctSptExp.right) ? m_rctSptExp.right : rctOrg.right;
	Int top = (rctOrg.top < m_rctSptExp.top) ? m_rctSptExp.top : rctOrg.top;	
	Int bottom = (rctOrg.bottom > m_rctSptExp.bottom) ? m_rctSptExp.bottom : rctOrg.bottom;
// End: modified by Hughes	  4/9/98

	Int iMod = (left - m_rctSptExp.left) % MB_SIZE;
	if (iMod > 0)
		left -= iMod;
	iMod = (right - left) % MB_SIZE;
	if (iMod > 0)
		right += MB_SIZE - iMod;
	iMod = (top - m_rctSptExp.top) % MB_SIZE;
	if (iMod > 0)
		top -= iMod;
	iMod = (bottom - top) % MB_SIZE;
	if (iMod > 0)
		bottom += MB_SIZE - iMod;
	// for update pieces, skip the entire row of MBs if the cooresponding object piece if missing
	if (m_vopmd.SpriteXmitMode == UPDATE) {
		Int iMBX, iMBX_left, iMBX_right ;
		Int iMBY, iMBY_top, iMBY_bottom ;
		iMBX_left =  (left - m_rctSptExp.left) / MB_SIZE;
		iMBX_right =  (right - m_rctSptExp.left) / MB_SIZE;	
		iMBY_top =  (top - m_rctSptExp.top) / MB_SIZE;
		iMBY_bottom =  (bottom - m_rctSptExp.top) / MB_SIZE;
		for (iMBY = iMBY_top; iMBY < iMBY_bottom; iMBY++)	{
			for (iMBX = iMBX_left; iMBX < iMBX_right; iMBX++)	{
				if ( m_ppPieceMBstatus[iMBY][iMBX] != PIECE_DONE) {
					top = top  +  MB_SIZE;
					break;				
				}
			}
		}
		for (iMBY = iMBY_bottom-1; iMBY > iMBY_top; iMBY--)	{
			for (iMBX = iMBX_left; iMBX < iMBX_right; iMBX++)	{
				if ( m_ppPieceMBstatus[iMBY][iMBX] != PIECE_DONE) {
					bottom = bottom  -  MB_SIZE;
					break;				
				}
			}
		}
	}

	return CRct(left, top, right, bottom);
}