📄 umc_vc1_enc_picture_adv.cpp
字号:
fDeblockingVSTLumaVer pDeblockingLumaVerLast = (bSubBlkTS)? DeblockingVSTLumaVerLast:DeblockingNOVSTLumaVerLast;
fDeblockingVSTChromaVer pDeblockingChromaVer = (bSubBlkTS)? DeblockingVSTChromaVer:DeblockingNOVSTChromaVer;
fDeblockingVSTChromaVer pDeblockingChromaVerLast = (bSubBlkTS)? DeblockingVSTChromaVerLast:DeblockingNOVSTChromaVerLast;
// fWriteDCAdv pWriteDC = (m_uiQuant<=2)?
//pWriteDCAdv[m_uiQuant-1]:pWriteDCAdv[2];
IppStatus ippSts = ippStsNoErr;
if (m_uiQuant<5)
{
pTTMBVLC = TTMBVLC_HighRate;
pTTBlkVLC = TTBLKVLC_HighRate;
pSubPattern4x4VLC = SubPattern4x4VLC_HighRate;
}
else if (m_uiQuant<13)
{
pTTMBVLC = TTMBVLC_MediumRate;
pTTBlkVLC = TTBLKVLC_MediumRate;
pSubPattern4x4VLC = SubPattern4x4VLC_MediumRate;
}
else
{
pTTMBVLC = TTMBVLC_LowRate;
pTTBlkVLC = TTBLKVLC_LowRate;
pSubPattern4x4VLC = SubPattern4x4VLC_LowRate;
}
if (m_pSavedMV)
{
memset(m_pSavedMV,0,w*h*2*sizeof(Ipp16s));
}
TempBlock.InitBlocks(tempBuffer);
err = m_pMBs->Reset();
if (err != UMC::UMC_OK)
return err;
SetInterpolationParams(&sYInterpolation,&sUInterpolation,&sVInterpolation,
tempInterpolationBuffer,true);
/* -------------------motion estimation------------------------------------*/
err = SetMEParams_P(&MEParams,&MEFrame);
if(err !=UMC::UMC_OK)
return err;
STATISTICS_START_TIME(m_TStat->me_StartTime);
if(!(m_pME->EstimateFrame(&MEParams,&MEFrame)))
return UMC::UMC_ERR_INVALID_PARAMS;
STATISTICS_END_TIME(m_TStat->me_StartTime, m_TStat->me_EndTime, m_TStat->me_TotalTime);
/* -------------------------------------------------------------------------*/
for (i=0; i < h; i++)
{
for (j=0; j < w; j++)
{
bool bIntra = false;
Ipp16s xLuma = VC1_ENC_LUMA_SIZE*j;
Ipp16s xChroma = VC1_ENC_CHROMA_SIZE*j;
Ipp16s posY = VC1_ENC_LUMA_SIZE*i;
sCoordinate MVInt = {0,0};
sCoordinate MVQuarter = {0,0};
sCoordinate MV = {0,0};
Ipp8u MBPattern = 0;
Ipp8u CBPCY = 0;
VC1EncoderMBInfo * pCurMBInfo = m_pMBs->GetCurrMBInfo();
VC1EncoderMBData * pCurMBData = m_pMBs->GetCurrMBData();
VC1EncoderMBInfo* left = m_pMBs->GetLeftMBInfo();
VC1EncoderMBInfo* topLeft = m_pMBs->GetTopLeftMBInfo();
VC1EncoderMBInfo* top = m_pMBs->GetTopMBInfo();
VC1EncoderMBInfo* topRight = m_pMBs->GetTopRightMBInfo();
VC1EncoderCodedMB* pCompressedMB = &(m_pCodedMB[w*i+j]);
bIntra = (MEFrame.MBs[j + i*w].MbType == UMC::MbIntra);
if (bIntra)
{
MV.x = 0;
MV.y =0;
pCompressedMB->Init(VC1_ENC_P_MB_INTRA);
pCurMBInfo->Init(true);
/*-------------------------- Compression ----------------------------------------------------------*/
pCurMBData->CopyMBProg(pCurMBRow[0]+xLuma, m_uiPlaneStep[0],
pCurMBRow[1]+xChroma,m_uiPlaneStep[1],
pCurMBRow[2]+xChroma,m_uiPlaneStep[2]);
//only intra blocks:
for (blk = 0; blk<6; blk++)
{
roiSize.height = 8;
roiSize.width = 8;
IPP_STAT_START_TIME(m_IppStat->IppStartTime);
_own_Diff8x8C_16s(128, pCurMBData->m_pBlock[blk], pCurMBData->m_uiBlockStep[blk], roiSize, 0);
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);
STATISTICS_START_TIME(m_TStat->FwdQT_StartTime);
IntraTransformQuantACFunction(pCurMBData->m_pBlock[blk], pCurMBData->m_uiBlockStep[blk],
DCQuant, doubleQuant);
STATISTICS_END_TIME(m_TStat->FwdQT_StartTime, m_TStat->FwdQT_EndTime, m_TStat->FwdQT_TotalTime);
}
STATISTICS_START_TIME(m_TStat->Intra_StartTime);
dACPrediction = DCACPredictionIFrameAdv( pCurMBData,
((left)? left->isIntra():0)? m_pMBs->GetLeftMBData():0,
((top)? top->isIntra():0)? m_pMBs->GetTopMBData(): 0,
((topLeft)? topLeft->isIntra():0)? m_pMBs->GetTopLeftMBData():0,
&TempBlock,direction);
STATISTICS_END_TIME(m_TStat->Intra_StartTime, m_TStat->Intra_EndTime, m_TStat->Intra_TotalTime);
for (blk=0; blk<6; blk++)
{
pCompressedMB->SaveResidual( TempBlock.m_pBlock[blk],
TempBlock.m_uiBlockStep[blk],
VC1_Inter_8x8_Scan,
blk);
}
MBPattern = pCompressedMB->GetMBPattern();
CBPCY = MBPattern;
pCurMBInfo->SetMBPattern(MBPattern);
pCompressedMB->SetACPrediction(dACPrediction);
pCompressedMB->SetMBCBPCY(CBPCY);
pCurMBInfo->SetEdgesIntra(i==0, j==0);
// ------------------------------encoding (intra MB)-------------------------------------------
{
err = pCompressedMB->WriteMBHeaderP_INTRA ( pCodedPicture,
m_bRawBitplanes,
MVDiffTablesVLC[m_uiMVTab],
pCBPCYTable);
VC1_ENC_CHECK (err)
//Blocks coding
for (blk = 0; blk<6; blk++)
{
err = pCompressedMB->WriteBlock(pCodedPicture,pDCTableVLCIntra[blk],m_uiQuant,pACTablesSetIntra[blk],&ACEscInfo,blk);
VC1_ENC_CHECK (err)
}//for
}//coding
#ifdef VC1_ENC_DEBUG_ON
pDebug->SetMBType(VC1_ENC_P_MB_INTRA);
pDebug->SetCPB(MBPattern, CBPCY);
pDebug->SetQuant(m_uiQuant,m_bHalfQuant);
pDebug->SetBlockDifference(pCurMBData->m_pBlock, pCurMBData->m_uiBlockStep);
#endif
/*-------------------------- Reconstruction ----------------------------------------------------------*/
STATISTICS_START_TIME(m_TStat->Reconst_StartTime);
if (bRaiseFrame)
{
Ipp8u *pRFrameY = m_pRaisedPlane[0]+VC1_ENC_LUMA_SIZE*(j+i*m_uiRaisedPlaneStep[0]);
Ipp8u *pRFrameU = m_pRaisedPlane[1]+VC1_ENC_CHROMA_SIZE*(j+i*m_uiRaisedPlaneStep[1]);
Ipp8u *pRFrameV = m_pRaisedPlane[2]+VC1_ENC_CHROMA_SIZE*(j+i*m_uiRaisedPlaneStep[2]);
roiSize.height = 8;
roiSize.width = 8;
for (blk=0;blk<6; blk++)
{
STATISTICS_START_TIME(m_TStat->InvQT_StartTime);
IntraInvTransformQuantACFunction(pCurMBData->m_pBlock[blk],pCurMBData->m_uiBlockStep[blk],
TempBlock.m_pBlock[blk],TempBlock.m_uiBlockStep[blk],
DCQuant, doubleQuant);
STATISTICS_END_TIME(m_TStat->InvQT_StartTime, m_TStat->InvQT_EndTime, m_TStat->InvQT_TotalTime);
IPP_STAT_START_TIME(m_IppStat->IppStartTime);
_own_Add8x8C_16s(128, TempBlock.m_pBlock[blk],TempBlock.m_uiBlockStep[blk],roiSize, 0);
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);
}
IPP_STAT_START_TIME(m_IppStat->IppStartTime);
ippiConvert_16s8u_C1R(TempBlock.m_pBlock[0],TempBlock.m_uiBlockStep[0],pRFrameY,m_uiRaisedPlaneStep[0],blkSizeLuma);
ippiConvert_16s8u_C1R(TempBlock.m_pBlock[4],TempBlock.m_uiBlockStep[4],pRFrameU,m_uiRaisedPlaneStep[1],blkSize);
ippiConvert_16s8u_C1R(TempBlock.m_pBlock[5],TempBlock.m_uiBlockStep[5],pRFrameV,m_uiRaisedPlaneStep[2],blkSize);
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);
}
STATISTICS_END_TIME(m_TStat->Reconst_StartTime, m_TStat->Reconst_EndTime, m_TStat->Reconst_TotalTime);
/*------------------------------------------- ----------------------------------------------------------*/
}
else
{
/*--------------------------------------- Inter --------------------------------------------------*/
sCoordinate MVIntChroma = {0,0};
sCoordinate MVQuarterChroma = {0,0};
sCoordinate MVChroma = {0,0};
sCoordinate *mvC=0, *mvB=0, *mvA=0;
sCoordinate mv1, mv2, mv3;
sCoordinate mvPred;
sCoordinate mvDiff;
eTransformType BlockTSTypes[6] = { m_uiTransformType, m_uiTransformType,
m_uiTransformType, m_uiTransformType,
m_uiTransformType, m_uiTransformType};
Ipp8u SubblockPattern[6]= {0};
bool bMBTSType = false;
Ipp8s nFirstNonSkippedBlock = -1;
Ipp8u hybrid = 0;
MV.x = MEFrame.MBs[j + i*w].MVs->x;
MV.y = MEFrame.MBs[j + i*w].MVs->y;
MV.x = (bMBHalf)? (MV.x>>1)<<1:MV.x;
MV.y = (bMBHalf)? (MV.y>>1)<<1:MV.y;
if ((MV.x>>2)+(Ipp32s)(j*VC1_ENC_LUMA_SIZE) > (Ipp32s)(w*VC1_ENC_LUMA_SIZE))
{
MV.x = (w - j)*VC1_ENC_LUMA_SIZE + (MV.x & 0x03);
}
if ((MV.y>>2)+(Ipp32s)(i*VC1_ENC_LUMA_SIZE) > (Ipp32s)(h*VC1_ENC_LUMA_SIZE))
{
MV.y = (h - i)*VC1_ENC_LUMA_SIZE + (MV.y & 0x03);
}
if ((MV.x>>2)+(Ipp32s)(j*VC1_ENC_LUMA_SIZE) < -16)
{
MV.x = (1 - (Ipp32s)j)*VC1_ENC_LUMA_SIZE ;
}
if ((MV.y>>2)+(Ipp32s)(i*VC1_ENC_LUMA_SIZE) < -16)
{
MV.y = (1 - (Ipp32s)i)*VC1_ENC_LUMA_SIZE ;
}
if (bCalculateVSTransform)
{
//copy from ME class
Ipp8u LumaTrans = MEFrame.MBs[j + i*w].BlockTrans;
Ipp8u BlockTrans = LumaTrans && 0x02;
Ipp32u blk_num = 0;
for(blk_num = 0; blk_num < 4; blk_num++)
{
BlockTSTypes[blk_num] = BlkTransformTypeTabl[BlockTrans];
LumaTrans>>=2;
BlockTrans = LumaTrans && 0x02;
}
BlockTSTypes[4] = BlkTransformTypeTabl[0];
BlockTSTypes[5] = BlkTransformTypeTabl[0];
}
/*---------------------------Compression ------------------------------------*/
pCompressedMB->Init(VC1_ENC_P_MB_1MV);
pCompressedMB->SetHalfMV (bMBHalf);
pCompressedMB->SetTSType(BlockTSTypes);
pCurMBInfo->Init(false);
pCurMBInfo->SetMV(MV);
GetIntQuarterMV(MV,&MVInt, &MVQuarter);
CalculateCroma(MV,&MVChroma);
pCurMBInfo->SetMVChroma(MV);
GetIntQuarterMV(MVChroma,&MVIntChroma,&MVQuarterChroma);
STATISTICS_START_TIME(m_TStat->Inter_StartTime);
GetMVPredictionP(true)
PredictMV(mvA,mvB,mvC, &mvPred);
ScalePredict(&mvPred, j*16*4,i*16*4,MVPredMBMin,MVPredMBMax);
hybrid = HybridPrediction(&mvPred,&MV,mvA,mvC);
STATISTICS_END_TIME(m_TStat->Inter_StartTime, m_TStat->Inter_EndTime, m_TStat->Inter_TotalTime);
mvDiff.x = MV.x - mvPred.x;
mvDiff.y = MV.y - mvPred.y;
pCompressedMB->SetHybrid(hybrid);
pCompressedMB->SetdMV(mvDiff);
STATISTICS_START_TIME(m_TStat->Interpolate_StartTime);
SetInterpolationParamsSrc(&sYInterpolation,pFMBRow[0]+ xLuma, m_uiForwardPlaneStep[0], &MVInt, &MVQuarter);
SetInterpolationParamsSrc(&sUInterpolation,pFMBRow[1]+ xChroma, m_uiForwardPlaneStep[1], &MVIntChroma, &MVQuarterChroma);
SetInterpolationParamsSrc(&sVInterpolation,pFMBRow[2]+ xChroma, m_uiForwardPlaneStep[2], &MVIntChroma, &MVQuarterChroma);
IPP_STAT_START_TIME(m_IppStat->IppStartTime);
ippSts = InterpolateLumaFunction(&sYInterpolation);
if (ippSts != ippStsNoErr)
return UMC::UMC_ERR_OPEN_FAILED;
ippSts = InterpolateChromaFunction(&sUInterpolation);
if (ippSts != ippStsNoErr)
return UMC::UMC_ERR_OPEN_FAILED;
ippSts = InterpolateChromaFunction(&sVInterpolation);
if (ippSts != ippStsNoErr)
return UMC::UMC_ERR_OPEN_FAILED;
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);
STATISTICS_END_TIME(m_TStat->Interpolate_StartTime, m_TStat->Interpolate_EndTime, m_TStat->Interpolate_TotalTime);
//-----------------------------------------------------------------------
IPP_STAT_START_TIME(m_IppStat->IppStartTime);
_own_Diff16x16_8u16s(pCurMBRow[0]+xLuma,m_uiPlaneStep[0],
sYInterpolation.pDst,sYInterpolation.dstStep,
pCurMBData->m_pBlock[0],pCurMBData->m_uiBlockStep[0],
NULL, 0, 0, 0);
_own_Diff8x8_8u16s(pCurMBRow[1]+xChroma,m_uiPlaneStep[1],
sUInterpolation.pDst,sUInterpolation.dstStep,
pCurMBData->m_pBlock[4],pCurMBData->m_uiBlockStep[4],
NULL, 0, 0, 0);
_own_Diff8x8_8u16s(pCurMBRow[2]+xChroma,m_uiPlaneStep[2],
sVInterpolation.pDst ,sVInterpolation.dstStep,
pCurMBData->m_pBlock[5],pCurMBData->m_uiBlockStep[5],
NULL, 0, 0, 0);
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);
MBPattern = 0;
for (blk = 0; blk<6; blk++)
{
S⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -