?? sptenc.cpp
字號:
m_iPieceXoffset= (rctRefFrameY.left - m_rctSptExp.left) / MB_SIZE;
m_iPieceYoffset= (rctRefFrameY.top - m_rctSptExp.top) / MB_SIZE;
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_volmd.iAuxCompCount);
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 rct1 = encPiece (rct);
rct1 = 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;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -