📄 vopses.cpp
字号:
(m_rgpmbmAbove [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
(m_rgpmbmCurr [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
}
}
}
Void CVideoObject::repeatPadYOrA (PixelC* ppxlcOldLeft, CVOPU8YUVBA* pvopcRef)
{
PixelC* ppxlcLeftTop = ppxlcOldLeft - EXPANDY_REFVOP * m_iFrameWidthY - EXPANDY_REFVOP;
// point to the left top of the expanded bounding box (+- EXPANDY_REFVOP)
const PixelC* ppxlcOldRight = ppxlcOldLeft + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth:m_rctPrevNoExpandY.width) - 1; // modified by Sharp (99/1/14)
// point to the right-top of the bounding box
const PixelC* ppxlcOldTopLn = ppxlcOldLeft - EXPANDY_REFVOP;
// point to the (left, top) - EXPANDY_REFVOP
PixelC* ppxlcNewLeft = (PixelC*) ppxlcOldTopLn;
PixelC* ppxlcNewRight = (PixelC*) ppxlcOldRight + 1;
CoordI y;
// begin: modified by Sharp (99/1/14)
Int PrevNoExpandY_height = (m_volmd.fAUsage == RECTANGLE)?m_ivolHeight:m_rctPrevNoExpandY.height ();
for (y = 0; y < PrevNoExpandY_height; y++) { // x-direction interpolation
// end: modified by Sharp
for (Int i=0; i<EXPANDY_REFVOP; i++) {
ppxlcNewLeft[i] = *ppxlcOldLeft;
ppxlcNewRight[i] = *ppxlcOldRight;
}
ppxlcNewLeft += pvopcRef->whereY ().width;
ppxlcNewRight += pvopcRef->whereY ().width;
ppxlcOldLeft += pvopcRef->whereY ().width;
ppxlcOldRight += pvopcRef->whereY ().width;
}
/* commented out due to fact of no field padding now
// Added for field based unrestricted MC padding by Hyundai(1998-5-9)
if (m_vopmd.bInterlace) {
Int iUnit = sizeof (PixelC);
Int width = pvopcRef->whereY ().width;
Int iFieldSkip = 2*width;
Int iPadArea = (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*iUnit;
const PixelC
*ppxlcSrcTopFieldLn1 = ppxlcOldTopLn,
*ppxlcSrcTopFieldLn2 = ppxlcNewLeft - iFieldSkip,
*ppxlcSrcBotFieldLn1 = ppxlcOldTopLn + width,
*ppxlcSrcBotFieldLn2 = ppxlcNewLeft - width;
PixelC *ppxlcDstTopFieldLn1 = ppxlcLeftTop,
*ppxlcDstTopFieldLn2 = ppxlcNewLeft,
*ppxlcDstBotFieldLn1 = ppxlcLeftTop + width,
*ppxlcDstBotFieldLn2 = ppxlcNewLeft + width;
for (y = 0; y < EXPANDY_REFVOP/2; y++) {
memcpy (ppxlcDstTopFieldLn1, ppxlcSrcTopFieldLn1, iPadArea);
memcpy (ppxlcDstTopFieldLn2, ppxlcSrcTopFieldLn2, iPadArea);
memcpy (ppxlcDstBotFieldLn1, ppxlcSrcBotFieldLn1, iPadArea);
memcpy (ppxlcDstBotFieldLn2, ppxlcSrcBotFieldLn2, iPadArea);
ppxlcDstTopFieldLn1 += iFieldSkip;
ppxlcDstTopFieldLn2 += iFieldSkip;
ppxlcDstBotFieldLn1 += iFieldSkip;
ppxlcDstBotFieldLn2 += iFieldSkip;
}
return;
}
// End of Hyundai(1998-5-9)
*/
const PixelC* ppxlcOldBotLn = ppxlcNewLeft - pvopcRef->whereY ().width;
for (y = 0; y < EXPANDY_REFVOP; y++) {
memcpy (ppxlcLeftTop, ppxlcOldTopLn, (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*sizeof(PixelC));
memcpy (ppxlcNewLeft, ppxlcOldBotLn, (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*sizeof(PixelC));
ppxlcNewLeft += pvopcRef->whereY ().width;
ppxlcLeftTop += pvopcRef->whereY ().width;
}
}
Void CVideoObject::repeatPadUV (CVOPU8YUVBA* pvopcRef)
{
const PixelC* ppxlcOldLeftU = pvopcRef->pixelsU () + m_iOffsetForPadUV; // point to the left-top of bounding box
const PixelC* ppxlcOldLeftV = pvopcRef->pixelsV () + m_iOffsetForPadUV; // point to the left-top of bounding box
PixelC* ppxlcLeftTopU = (PixelC*) ppxlcOldLeftU - EXPANDUV_REFVOP * m_iFrameWidthUV - EXPANDUV_REFVOP;
PixelC* ppxlcLeftTopV = (PixelC*) ppxlcOldLeftV - EXPANDUV_REFVOP * m_iFrameWidthUV - EXPANDUV_REFVOP;
// point to the left top of the expanded bounding box (+- EXPANDY_REFVOP)
const PixelC* ppxlcOldRightU = ppxlcOldLeftU + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth/2:m_rctPrevNoExpandUV.width) - 1; // modified by Sharp (99/1/14)
const PixelC* ppxlcOldRightV = ppxlcOldLeftV + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth/2:m_rctPrevNoExpandUV.width) - 1; // modified by Sharp (99/1/14)
// point to the right-top of the bounding box
const PixelC* ppxlcOldTopLnU = ppxlcOldLeftU - EXPANDUV_REFVOP;
const PixelC* ppxlcOldTopLnV = ppxlcOldLeftV - EXPANDUV_REFVOP;
// point to the (left, top) - EXPANDY_REFVOP
PixelC* ppxlcNewLeftU = (PixelC*) ppxlcOldTopLnU;
PixelC* ppxlcNewLeftV = (PixelC*) ppxlcOldTopLnV;
PixelC* ppxlcNewRightU = (PixelC*) ppxlcOldRightU + 1;
PixelC* ppxlcNewRightV = (PixelC*) ppxlcOldRightV + 1;
CoordI y;
// begin: modified by Sharp (99/1/14)
Int PrevNoExpandUV_height = (m_volmd.fAUsage == RECTANGLE)?m_ivolHeight/2:m_rctPrevNoExpandUV.height ();
for (y = 0; y < PrevNoExpandUV_height; y++) { // x-direction interpolation
// end: modified by Sharp (99/1/14)
for (Int i=0; i<EXPANDUV_REFVOP; i++) {
ppxlcNewLeftU[i] = *ppxlcOldLeftU;
ppxlcNewLeftV[i] = *ppxlcOldLeftV;
ppxlcNewRightU[i] = *ppxlcOldRightU;
ppxlcNewRightV[i] = *ppxlcOldRightV;
}
ppxlcNewLeftU += pvopcRef->whereUV ().width;
ppxlcNewLeftV += pvopcRef->whereUV ().width;
ppxlcNewRightU += pvopcRef->whereUV ().width;
ppxlcNewRightV += pvopcRef->whereUV ().width;
ppxlcOldLeftU += pvopcRef->whereUV ().width;
ppxlcOldLeftV += pvopcRef->whereUV ().width;
ppxlcOldRightU += pvopcRef->whereUV ().width;
ppxlcOldRightV += pvopcRef->whereUV ().width;
}
/* no longer any field based padding
// Added for field based unrestricted MC padding by Hyundai(1998-5-9)
if (m_vopmd.bInterlace) {
Int iUnit = sizeof(PixelC);
Int width = pvopcRef->whereUV ().width;
Int iFieldSkip = 2*width;
Int iPadArea = (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*iUnit;
const PixelC
*ppxlcSrcTopFieldLn1U = ppxlcOldTopLnU,
*ppxlcSrcTopFieldLn2U = ppxlcNewLeftU - iFieldSkip,
*ppxlcSrcBotFieldLn1U = ppxlcOldTopLnU + width,
*ppxlcSrcBotFieldLn2U = ppxlcNewLeftU - width,
*ppxlcSrcTopFieldLn1V = ppxlcOldTopLnV,
*ppxlcSrcTopFieldLn2V = ppxlcNewLeftV - iFieldSkip,
*ppxlcSrcBotFieldLn1V = ppxlcOldTopLnV + width,
*ppxlcSrcBotFieldLn2V = ppxlcNewLeftV - width;
PixelC *ppxlcDstTopFieldLn1U = ppxlcLeftTopU,
*ppxlcDstTopFieldLn2U = ppxlcNewLeftU,
*ppxlcDstBotFieldLn1U = ppxlcLeftTopU + width,
*ppxlcDstBotFieldLn2U = ppxlcNewLeftU + width,
*ppxlcDstTopFieldLn1V = ppxlcLeftTopV,
*ppxlcDstTopFieldLn2V = ppxlcNewLeftV,
*ppxlcDstBotFieldLn1V = ppxlcLeftTopV + width,
*ppxlcDstBotFieldLn2V = ppxlcNewLeftV + width;
for (y = 0; y < EXPANDUV_REFVOP/2; y++) {
memcpy (ppxlcDstTopFieldLn1U, ppxlcSrcTopFieldLn1U, iPadArea);
memcpy (ppxlcDstTopFieldLn2U, ppxlcSrcTopFieldLn2U, iPadArea);
memcpy (ppxlcDstBotFieldLn1U, ppxlcSrcBotFieldLn1U, iPadArea);
memcpy (ppxlcDstBotFieldLn2U, ppxlcSrcBotFieldLn2U, iPadArea);
memcpy (ppxlcDstTopFieldLn1V, ppxlcSrcTopFieldLn1V, iPadArea);
memcpy (ppxlcDstTopFieldLn2V, ppxlcSrcTopFieldLn2V, iPadArea);
memcpy (ppxlcDstBotFieldLn1V, ppxlcSrcBotFieldLn1V, iPadArea);
memcpy (ppxlcDstBotFieldLn2V, ppxlcSrcBotFieldLn2V, iPadArea);
ppxlcDstTopFieldLn1U += iFieldSkip;
ppxlcDstTopFieldLn2U += iFieldSkip;
ppxlcDstBotFieldLn1U += iFieldSkip;
ppxlcDstBotFieldLn2U += iFieldSkip;
ppxlcDstTopFieldLn1V += iFieldSkip;
ppxlcDstTopFieldLn2V += iFieldSkip;
ppxlcDstBotFieldLn1V += iFieldSkip;
ppxlcDstBotFieldLn2V += iFieldSkip;
}
return;
}
// End of Hyundai(1998-5-9)
*/
const PixelC* ppxlcOldBotLnU = ppxlcNewLeftU - pvopcRef->whereUV ().width;
const PixelC* ppxlcOldBotLnV = ppxlcNewLeftV - pvopcRef->whereUV ().width;
for (y = 0; y < EXPANDUV_REFVOP; y++) {
memcpy (ppxlcLeftTopU, ppxlcOldTopLnU, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
memcpy (ppxlcLeftTopV, ppxlcOldTopLnV, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
memcpy (ppxlcNewLeftU, ppxlcOldBotLnU, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
memcpy (ppxlcNewLeftV, ppxlcOldBotLnV, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
ppxlcNewLeftU += pvopcRef->whereUV ().width;
ppxlcNewLeftV += pvopcRef->whereUV ().width;
ppxlcLeftTopU += pvopcRef->whereUV ().width;
ppxlcLeftTopV += pvopcRef->whereUV ().width;
}
}
Void CVideoObject::saveShapeMode()
{
// called after reference frame encode/decode
if(m_rgshpmd == NULL)
{
// first time
m_iRefShpNumMBX = m_iNumMBX;
m_iRefShpNumMBY = m_iNumMBY;
m_rgshpmd = new ShapeMode [m_iNumMB];
}
else
{
// update if changed
if(m_iRefShpNumMBX!=m_iNumMBXRef || m_iRefShpNumMBY != m_iNumMBYRef)
{
delete [] m_rgshpmd;
m_rgshpmd = new ShapeMode [m_iNumMBRef];
m_iRefShpNumMBX = m_iNumMBXRef;
m_iRefShpNumMBY = m_iNumMBYRef;
}
// copy shape mode from previous ref to save
Int i;
for (i=0; i<m_iNumMBRef; i++ )
m_rgshpmd[i] = m_rgmbmdRef[i].m_shpmd;
}
}
Void CVideoObject::resetBYPlane ()
{
if (m_vopmd.vopPredType == PVOP || m_vopmd.vopPredType == IVOP) {
PixelC* ppxlcBY = (PixelC*) m_pvopcRefQ1->pixelsBY ();
memset (ppxlcBY, 0, m_pvopcRefQ1->whereY().area() * sizeof(PixelC));
}
else {
PixelC* ppxlcBY = (PixelC*) m_pvopcCurrQ->pixelsBY ();
memset (ppxlcBY, 0, m_pvopcCurrQ->whereY().area() * sizeof(PixelC));
}
}
Void CVideoObject::updateAllRefVOPs ()
// perform this after VOP prediction type decided and before encoding
{
if (m_vopmd.vopPredType != BVOP) {
m_rctRefVOPY0 = m_rctRefVOPY1;
swapVOPU8Pointers (m_pvopcRefQ0, m_pvopcRefQ1);
}
}
// for spatial scalability
Void CVideoObject::updateAllRefVOPs (const CVOPU8YUVBA* pvopcRefBaseLayer)
{
CVOPU8YUVBA *pvopcUpSampled = NULL;
// Int fEnhancementLayer = 0;
assert (m_volmd.volType == ENHN_LAYER);
pvopcUpSampled = pvopcRefBaseLayer->upsampleForSpatialScalability (
m_volmd.iver_sampling_factor_m,
m_volmd.iver_sampling_factor_n,
m_volmd.ihor_sampling_factor_m,
m_volmd.ihor_sampling_factor_n,
EXPANDY_REF_FRAME,
EXPANDUV_REF_FRAME);
if(m_vopmd.vopPredType == PVOP) {
m_rctRefVOPY0 = m_rctRefVOPY1;
swapVOPU8Pointers (m_pvopcRefQ0,pvopcUpSampled);
m_pvopcRefQ0->setBoundRct(m_rctRefVOPY0);
delete pvopcUpSampled;
}
else if(m_vopmd.vopPredType == BVOP){
CRct tmp;
tmp = m_rctRefVOPY0;
m_rctRefVOPY0 = m_rctRefVOPY1;
m_rctRefVOPY1 = tmp;
swapVOPU8Pointers (m_pvopcRefQ0,m_pvopcRefQ1);
swapVOPU8Pointers (m_pvopcRefQ1,pvopcUpSampled);
m_pvopcRefQ0->setBoundRct(m_rctRefVOPY0);
m_pvopcRefQ1->setBoundRct(m_rctRefVOPY1);
delete pvopcUpSampled;
}
}
Void CVideoObject::swapVOPU8Pointers (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1)
{
CVOPU8YUVBA* pvopcTmp = pvopc0;
pvopc0 = pvopc1;
pvopc1 = pvopcTmp;
}
Void CVideoObject::swapVOPIntPointers (CVOPIntYUVBA*& pvopi0, CVOPIntYUVBA*& pvopi1)
{
CVOPIntYUVBA* pvopiTmp = pvopi0;
pvopi0 = pvopi1;
pvopi1 = pvopiTmp;
}
Void CVideoObject::setRefStartingPointers ()
{
m_iStartInRefToCurrRctY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
m_iStartInRefToCurrRctUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
}
const CVOPU8YUVBA* CVideoObject::pvopcReconCurr () const
{
if (m_vopmd.vopPredType == SPRITE && m_iNumOfPnts > 0)
return m_pvopcCurrQ;
else if (m_vopmd.vopPredType == SPRITE && m_iNumOfPnts == 0) {
if (m_sptMode != BASIC_SPRITE)
return m_pvopcSptQ;
else
return m_pvopcRefQ1;
}
else if ((m_vopmd.vopPredType == BVOP && m_volmd.volType == BASE_LAYER)
||(m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode != 0))
return m_pvopcCurrQ;
else
return m_pvopcRefQ1;
}
////////// 97/12/22 start
Void CVideoObject::compute_bfShapeMembers ()
{
m_iVOPWidthY = m_rctCurrVOPY.width;
m_iVOPWidthUV = m_rctCurrVOPUV.width;
m_iNumMBX = m_iVOPWidthY / MB_SIZE;
m_iNumMBY = m_rctCurrVOPY.height () / MB_SIZE;
m_iNumMB = m_iNumMBX * m_iNumMBY;
// m_iNumOfTotalMVPerRow = 5 * m_iNumMBX;
// wchen: changed to const as discussed with Bob.
m_iNumOfTotalMVPerRow = PVOP_MV_PER_REF_PER_MB * m_iNumMBX;
}
Void CVideoObject::copyVOPU8YUVBA(CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1)
{
delete pvopc0; pvopc0 = NULL;
pvopc0 = new CVOPU8YUVBA (*pvopc1); /* i.e. pvopc0 = pvopc1; */
}
Void CVideoObject::copyVOPU8YUVBA(CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1, CVOPU8YUVBA*& pvopc2)
{
delete pvopc0; pvopc0 = NULL;
pvopc0 = (pvopc1 != NULL) ?
new CVOPU8YUVBA (*pvopc1) : new CVOPU8YUVBA (*pvopc2);
}
///// 97/12/22 end
Void dumpNonCodedFrame(FILE* pfYUV, FILE* pfSeg, CRct& rct, UInt nBits)
{
Int iW = rct.width;
Int iH = rct.height();
Int i;
PixelC pxlcVal = 1<<(nBits-1);
PixelC *ppxlcPix = new PixelC [iW];
pxlcmemset(ppxlcPix, pxlcVal, iW);
for(i=0; i<iH; i++) // Y
fwrite(ppxlcPix, sizeof(PixelC), iW, pfYUV);
for(i=0; i<iH; i++) // UV
fwrite(ppxlcPix, sizeof(PixelC), iW>>1, pfYUV);
if(pfSeg!=NULL)
{
pxlcmemset(ppxlcPix, 0, iW);
for(i=0; i<iH; i++) // A
fwrite(ppxlcPix, sizeof(PixelC), iW, pfSeg);
}
delete ppxlcPix;
}
/*BBM// Added for Boundary by Hyundai(1998-5-9)
Void CVideoObject::boundaryMacroBlockMerge (CMBMode* pmbmd)
{
if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[2]) == PARTIAL) {
pmbmd->m_bMerged[1] = checkMergedStatus (7, 8, 7, 0);
if (pmbmd->m_bMerged[1]) {
pmbmd->m_rgTranspStatusBBM[2] = ALL;
overlayBlocks (7, 8, 7, 0, pmbmd->m_dctMd);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -