📄 errdec.cpp
字号:
// MC padding
if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
padNeighborTranspMBs (
iMBX, iMBY,
pmbmd,
ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
);
}
else {
padCurrAndTopTranspMBFromNeighbor (
iMBX, iMBY,
pmbmd,
ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
);
}
ppxlcRefMBA += MB_SIZE;
ppxlcRefMBBY += MB_SIZE;
ppxlcRefMBBUV += BLOCK_SIZE;
pmbmd++;
piIntraDC += V_BLOCK;
ppxlcRefMBY += MB_SIZE;
ppxlcRefMBU += BLOCK_SIZE;
ppxlcRefMBV += BLOCK_SIZE;
if(iMBX == m_iNumMBX - 1) {
MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
m_rgpmbmAbove = m_rgpmbmCurr;
m_rgpmbmCurr = ppmbmTemp;
ppxlcRefY += m_iFrameWidthYxMBSize;
ppxlcRefU += m_iFrameWidthUVxBlkSize;
ppxlcRefV += m_iFrameWidthUVxBlkSize;
ppxlcRefA += m_iFrameWidthYxMBSize;
ppxlcRefBY += m_iFrameWidthYxMBSize;
ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
}
}
} while( checkResyncMarker() );
delete m_piMCBPC;
}
Void CVideoObjectDecoder::decodePVOP_WithShape_DataPartitioning ()
{
//assert (m_volmd.nBits==8);
assert (m_volmd.fAUsage!=EIGHT_BIT);
Int iMBX, iMBY;
CoordI y = m_rctCurrVOPY.top;
CoordI x = m_rctCurrVOPY.left;
CoordI y_s = m_rctCurrVOPY.top;
CoordI x_s = m_rctCurrVOPY.left;
CMBMode* pmbmd = m_rgmbmd;
CMotionVector* pmv = m_rgmv;
CMotionVector* pmvBY = m_rgmvBY;
PixelC* ppxlcCurrQY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
PixelC* ppxlcCurrQU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
PixelC* ppxlcCurrQV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
PixelC* ppxlcCurrQA = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
PixelC* ppxlcCurrQBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
Int iCurrentQP = m_vopmd.intStep;
Int iVideoPacketNumber = 0; // added for error resilience mode by Toshiba
m_iVPMBnum = 0;
m_piMCBPC = new Int[m_iNumMBX*m_iNumMBY];
Int* piMCBPC = m_piMCBPC;
m_piIntraDC = new Int[m_iNumMBX*m_iNumMBY*V_BLOCK];
Int* piIntraDC = m_piIntraDC;
Int i;
Int mbn = 0, mbnFirst = 0;
PixelC* ppxlcCurrQMBY = NULL;
PixelC* ppxlcCurrQMBU = NULL;
PixelC* ppxlcCurrQMBV = NULL;
PixelC* ppxlcCurrQMBBY = NULL;
PixelC* ppxlcCurrQMBBUV;
PixelC* ppxlcCurrQMBA = NULL;
Bool bMBBackup = FALSE;
CMBMode* pmbmdBackup = NULL;
Int iMBXBackup = 0, iMBYBackup = 0;
CMotionVector* pmvBackup = NULL;
PixelC* ppxlcCurrQMBYBackup = NULL;
PixelC* ppxlcCurrQMBUBackup = NULL;
PixelC* ppxlcCurrQMBVBackup = NULL;
PixelC* ppxlcCurrQMBBYBackup = NULL;
PixelC* ppxlcCurrQMBBUVBackup;
PixelC* ppxlcCurrQMBABackup = NULL;
Bool bPaddedLBackup = FALSE;
Bool bPaddedTBackup = FALSE;
Bool bRestartDelayedQP = TRUE;
do{
CMBMode* pmbmdFirst = pmbmd;
CMotionVector* pmvFirst = pmv;
Int* piMCBPCFirst = piMCBPC;
Int* piIntraDCFirst = piIntraDC;
mbnFirst = mbn;
if( checkResyncMarker() ){
decodeVideoPacketHeader(iCurrentQP);
iVideoPacketNumber++;
bRestartDelayedQP = TRUE;
}
do{
pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
iMBX = mbn % m_iNumMBX;
iMBY = mbn / m_iNumMBX;
if(iMBX == 0 ) {
ppxlcCurrQMBBY = ppxlcCurrQBY;
ppxlcCurrQMBBUV = ppxlcCurrQBUV;
x_s = m_rctCurrVOPY.left;
if(iMBY != 0) y_s += MB_SIZE;
} else {
x_s += MB_SIZE;
}
ShapeMode shpmdColocatedMB;
if(m_vopmd.bShapeCodingType) {
shpmdColocatedMB = m_rgmbmdRef [
MIN (MAX (0, iMBX), m_iNumMBXRef - 1) +
MIN (MAX (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef
].m_shpmd;
decodeInterShape (
m_pvopcRefQ0,
pmbmd,
iMBX, iMBY,
x_s, y_s,
pmv, pmvBY,
m_ppxlcCurrMBBY, ppxlcCurrQMBBY,
shpmdColocatedMB
);
}
else {
decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY,
ppxlcCurrQMBBY);
}
downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
pmbmd->m_bSkip = m_pbitstrmIn->getBits (1);
if (!pmbmd->m_bSkip) {
*piMCBPC = m_pentrdecSet->m_pentrdecMCBPCinter->decodeSymbol ();
assert (*piMCBPC >= 0 && *piMCBPC <= 20);
Int iMBtype = *piMCBPC / 4; //per H.263's MBtype
switch (iMBtype) {
case 0:
pmbmd->m_dctMd = INTER;
pmbmd -> m_bhas4MVForward = FALSE;
break;
case 1:
pmbmd->m_dctMd = INTERQ;
pmbmd -> m_bhas4MVForward = FALSE;
break;
case 2:
pmbmd -> m_dctMd = INTER;
pmbmd -> m_bhas4MVForward = TRUE;
break;
case 3:
pmbmd->m_dctMd = INTRA;
break;
case 4:
pmbmd->m_dctMd = INTRAQ;
break;
default:
assert (FALSE);
}
} else { //skipped
pmbmd->m_dctMd = INTER;
pmbmd -> m_bhas4MVForward = FALSE;
}
decodeMVWithShape (pmbmd, iMBX, iMBY, pmv);
if(pmbmd->m_bhas4MVForward)
padMotionVectors(pmbmd,pmv);
}
if(bMBBackup){
copyRefShapeToMb(m_ppxlcCurrMBBY, ppxlcCurrQMBBYBackup);
downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
pmbmdBackup->m_bPadded = FALSE;
if(iMBXBackup > 0) (pmbmdBackup-1)->m_bPadded = bPaddedLBackup;
if(iMBYBackup > 0) (pmbmdBackup-m_iNumMBX)->m_bPadded = bPaddedTBackup;
if (pmbmdBackup->m_rgTranspStatus [0] != ALL) {
if (pmbmdBackup->m_dctMd == INTER || pmbmdBackup->m_dctMd == INTERQ) {
motionCompMB (
m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
pmvBackup, pmbmdBackup,
iMBXBackup, iMBYBackup,
x, y,
pmbmdBackup->m_bSkip, FALSE,
&m_rctRefVOPY0
);
if (!pmbmdBackup->m_bSkip) {
CoordI iXRefUV, iYRefUV;
mvLookupUVWithShape (pmbmdBackup, pmvBackup, iXRefUV, iYRefUV);
motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
addErrorAndPredToCurrQ (ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup);
}
else {
if (m_volmd.bAdvPredDisable)
copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, &m_rctRefVOPY0);
else
copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, &m_rctRefVOPY0);
}
}
if (pmbmdBackup->m_rgTranspStatus [0] == PARTIAL)
mcPadCurrMB (ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, ppxlcCurrQMBABackup);
padNeighborTranspMBs (
iMBXBackup, iMBYBackup,
pmbmdBackup,
ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, ppxlcCurrQMBABackup
);
}
else {
padCurrAndTopTranspMBFromNeighbor (
iMBXBackup, iMBYBackup,
pmbmdBackup,
ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, ppxlcCurrQMBABackup
);
}
bMBBackup = FALSE;
}
pmbmd++;
pmv += PVOP_MV_PER_REF_PER_MB;
pmvBY++;
mbn++;
piMCBPC++;
ppxlcCurrQMBBY += MB_SIZE;
ppxlcCurrQMBBUV += BLOCK_SIZE;
if(iMBX == m_iNumMBX - 1) {
ppxlcCurrQBY += m_iFrameWidthYxMBSize;
ppxlcCurrQBUV += m_iFrameWidthUVxBlkSize;
}
assert(mbn<=(m_iNumMBX*m_iNumMBY));
} while( !checkMotionMarker() );
m_pbitstrmIn -> getBits (NUMBITS_DP_MOTION_MARKER);
pmbmd = pmbmdFirst;
piMCBPC = piMCBPCFirst;
piIntraDC = piIntraDCFirst;
for(i=mbnFirst;i<mbn;i++) {
if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
decodeMBTextureHeadOfPVOP_DataPartitioning (pmbmd, iCurrentQP, piMCBPC, piIntraDC, bRestartDelayedQP);
}
pmbmd++;
piMCBPC++;
piIntraDC += V_BLOCK;
}
pmbmd = pmbmdFirst;
pmv = pmvFirst;
piIntraDC = piIntraDCFirst;
ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY + (mbnFirst/m_iNumMBX)*m_iFrameWidthYxMBSize;
ppxlcCurrQBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV + (mbnFirst/m_iNumMBX)*m_iFrameWidthUVxBlkSize;
ppxlcCurrQMBBY = ppxlcCurrQBY + (mbnFirst%m_iNumMBX)*MB_SIZE;
ppxlcCurrQMBBUV = ppxlcCurrQBUV + (mbnFirst%m_iNumMBX)*BLOCK_SIZE;
for(i=mbnFirst;i<mbn;i++) {
pmbmd->m_bPadded = FALSE;
iMBX = i % m_iNumMBX;
iMBY = i / m_iNumMBX;
if(iMBX == 0 ) {
ppxlcCurrQMBY = ppxlcCurrQY;
ppxlcCurrQMBU = ppxlcCurrQU;
ppxlcCurrQMBV = ppxlcCurrQV;
ppxlcCurrQMBBY = ppxlcCurrQBY;
ppxlcCurrQMBA = ppxlcCurrQA;
ppxlcCurrQMBBUV = ppxlcCurrQBUV;
x = m_rctCurrVOPY.left;
if(iMBY != 0) y += MB_SIZE;
} else {
x += MB_SIZE;
}
copyRefShapeToMb(m_ppxlcCurrMBBY, ppxlcCurrQMBBY);
downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)
decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, piIntraDC);
else {
if (!pmbmd->m_bSkip)
decodeTextureInterMB (pmbmd);
}
}
if(i==mbn-1){
bMBBackup = TRUE;
pmbmdBackup = pmbmd;
pmvBackup = pmv;
iMBXBackup = iMBX;
iMBYBackup = iMBY;
ppxlcCurrQMBYBackup = ppxlcCurrQMBY;
ppxlcCurrQMBUBackup = ppxlcCurrQMBU;
ppxlcCurrQMBVBackup = ppxlcCurrQMBV;
ppxlcCurrQMBBYBackup = ppxlcCurrQMBBY;
ppxlcCurrQMBBUVBackup = ppxlcCurrQMBBUV;
ppxlcCurrQMBABackup = ppxlcCurrQMBA;
bPaddedLBackup = (pmbmdBackup-1)->m_bPadded;
bPaddedTBackup = (pmbmdBackup-m_iNumMBX)->m_bPadded;
}
if (pmbmd->m_rgTranspStatus [0] != ALL) {
if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) {
// Addded for data partitioning mode by Toshiba(1997-11-26:DP+RVLC)
motionCompMB (
m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
pmv, pmbmd,
iMBX, iMBY,
x, y,
pmbmd->m_bSkip, FALSE,
&m_rctRefVOPY0
);
if (!pmbmd->m_bSkip) {
CoordI iXRefUV, iYRefUV;
mvLookupUVWithShape (pmbmd, pmv, iXRefUV, iYRefUV);
motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
}
else {
if (m_volmd.bAdvPredDisable)
copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0);
else
copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0);
}
}
if (pmbmd->m_rgTranspStatus [0] == PARTIAL)
mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA);
padNeighborTranspMBs (
iMBX, iMBY,
pmbmd,
ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
);
}
else {
padCurrAndTopTranspMBFromNeighbor (
iMBX, iMBY,
pmbmd,
ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
);
}
pmbmd++;
pmv += PVOP_MV_PER_REF_PER_MB;
piIntraDC += V_BLOCK;
ppxlcCurrQMBY += MB_SIZE;
ppxlcCurrQMBU += BLOCK_SIZE;
ppxlcCurrQMBV += BLOCK_SIZE;
ppxlcCurrQMBBY += MB_SIZE;
ppxlcCurrQMBBUV += BLOCK_SIZE;
ppxlcCurrQMBA += MB_SIZE;
if(iMBX == m_iNumMBX - 1) {
MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
m_rgpmbmAbove = m_rgpmbmCurr;
m_rgpmbmCurr = ppmbmTemp;
ppxlcCurrQY += m_iFrameWidthYxMBSize;
ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
ppxlcCurrQBY += m_iFrameWidthYxMBSize;
ppxlcCurrQBUV += m_iFrameWidthYxBlkSize;
ppxlcCurrQA += m_iFrameWidthYxMBSize;
}
}
} while( checkResyncMarker() );
delete m_piIntraDC;
delete m_piMCBPC;
}
// End Toshiba
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -