📄 umc_vc1_enc_picture_sm.cpp
字号:
pCompressedMB->SetACPrediction(dACPrediction);
pCompressedMB->SetMBCBPCY(CBPCY);
/* ---------------------coding------------------------------------------------------------- */
{
err = pCompressedMB->WriteMBHeaderI_SM(pCodedPicture, m_bRawBitplanes);
if (err != UMC::UMC_OK)
return err;
for (blk = 0; blk<6; blk++)
{
err = pCompressedMB->WriteBlock(pCodedPicture,pDCTableVLC[blk],m_uiQuant,pACTablesVLC[blk],&ACEscInfo,blk);
VC1_ENC_CHECK (err)
}//for
}
#ifdef VC1_ENC_DEBUG_ON
pDebug->SetMBType(VC1_ENC_I_MB);
pDebug->SetCPB(MBPattern, CBPCY);
pDebug->SetQuant(m_uiQuant,m_bHalfQuant);
pDebug->SetBlockDifference(pCurMBData->m_pBlock, pCurMBData->m_uiBlockStep);
#endif
/*--------------Reconstruction (if is needed)--------------------------------------------------*/
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]);
for (blk=0;blk<6; blk++)
{
STATISTICS_START_TIME(m_TStat->InvQT_StartTime);
InvTransformQuantACFunction(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);
if (m_pSequenceHeader->IsOverlap())
{
roiSize.height = 8;
roiSize.width = 8;
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);
/*------------------------------------------------------------------------------------------------*/
err = m_pMBs->NextMB();
if (err != UMC::UMC_OK && j < w-1)
return err;
#ifdef VC1_ENC_DEBUG_ON
pDebug->NextMB();
#endif
}
STATISTICS_START_TIME(m_TStat->Reconst_StartTime);
if (m_pSequenceHeader->IsLoopFilter() && i!=0 && bRaiseFrame)
{
STATISTICS_START_TIME(m_TStat->Deblk_StartTime);
for (Ipp32s n=0; n< 1+(i==h-1); n++)
{
// Two iterations for last row
Ipp8u *pYMBDebl = m_pRaisedPlane[0] + (i-1+n)*m_uiRaisedPlaneStep[0]*VC1_ENC_LUMA_SIZE;
Ipp8u *pUMBDebl = m_pRaisedPlane[1] + (i-1+n)*m_uiRaisedPlaneStep[1]*VC1_ENC_CHROMA_SIZE;
Ipp8u *pVMBDebl = m_pRaisedPlane[2] + (i-1+n)*m_uiRaisedPlaneStep[2]*VC1_ENC_CHROMA_SIZE;
m_pMBs->StartRow();
// The first block in row
(pDeblockingLumaHor)[n](pYMBDebl,m_uiRaisedPlaneStep[0],m_uiQuant,0, 0, 0, 0);
(pDeblockingChromaHor)[n](pUMBDebl,m_uiRaisedPlaneStep[1], m_uiQuant,0, 0);
(pDeblockingChromaHor)[n](pVMBDebl,m_uiRaisedPlaneStep[2], m_uiQuant,0, 0);
while (m_pMBs->NextMB() == UMC::UMC_OK)
{
pYMBDebl += VC1_ENC_LUMA_SIZE;
pUMBDebl += VC1_ENC_CHROMA_SIZE;
pVMBDebl += VC1_ENC_CHROMA_SIZE;
(pDeblockingLumaHor)[n](pYMBDebl,m_uiRaisedPlaneStep[0],m_uiQuant,0, 0, 0, 0);
(pDeblockingChromaHor)[n](pUMBDebl,m_uiRaisedPlaneStep[1], m_uiQuant,0, 0);
(pDeblockingChromaHor)[n](pVMBDebl,m_uiRaisedPlaneStep[2], m_uiQuant,0, 0);
DeblockingNOVSTLumaVer(pYMBDebl-16, m_uiRaisedPlaneStep[0],m_uiQuant,0, 0, 0, 0);
DeblockingNOVSTChromaVer(pUMBDebl-8,m_uiRaisedPlaneStep[1], m_uiQuant,0, 0);
DeblockingNOVSTChromaVer(pVMBDebl-8,m_uiRaisedPlaneStep[2], m_uiQuant,0, 0);
}
//The last block in row
DeblockingNOVSTLumaVerLast(pYMBDebl, m_uiRaisedPlaneStep[0],m_uiQuant,0, 0, 0, 0);
DeblockingNOVSTChromaVerLast(pUMBDebl,m_uiRaisedPlaneStep[1], m_uiQuant,0, 0);
DeblockingNOVSTChromaVerLast(pVMBDebl,m_uiRaisedPlaneStep[2], m_uiQuant,0, 0);
}
STATISTICS_END_TIME(m_TStat->Deblk_StartTime, m_TStat->Deblk_EndTime, m_TStat->Deblk_TotalTime);
}
STATISTICS_END_TIME(m_TStat->Reconst_StartTime, m_TStat->Reconst_EndTime, m_TStat->Reconst_TotalTime);
err = m_pMBs->NextRow();
if (err != UMC::UMC_OK)
return err;
pCurMBRow[0]+= m_uiPlaneStep[0]*VC1_ENC_LUMA_SIZE;
pCurMBRow[1]+= m_uiPlaneStep[1]*VC1_ENC_CHROMA_SIZE;
pCurMBRow[2]+= m_uiPlaneStep[2]*VC1_ENC_CHROMA_SIZE;
}
/*
static FILE* f=0;
if (!f)
f=fopen("1.yuv","wb");
for (i=0; i < h*16; i++)
{
fwrite(m_pRaisedPlane[0]+i*m_uiRaisedPlaneStep[0],1,w*16,f);
}
for (i=0; i < h*8; i++)
{
fwrite(m_pRaisedPlane[1]+i*m_uiRaisedPlaneStep[1],1,w*8,f);
}
for (i=0; i < h*8; i++)
{
fwrite(m_pRaisedPlane[2]+i*m_uiRaisedPlaneStep[2],1,w*8,f);
}
fflush(f);
*/
return err;
}
UMC::Status VC1EncoderPictureSM::SetInterpolationParams(IppVCInterpolate_8u* pY,
IppVCInterpolate_8u* pU,
IppVCInterpolate_8u* pV,
Ipp8u* buffer,
bool bForward)
{
UMC::Status ret = UMC::UMC_OK;
Ipp8u **pPlane;
Ipp32u *pStep;
if (bForward)
{
pPlane = m_pForwardPlane;
pStep = m_uiForwardPlaneStep;
}
else
{
pPlane = m_pBackwardPlane;
pStep = m_uiBackwardPlaneStep;
}
pY->pSrc = pPlane[0];
pY->srcStep = pStep[0];
pY->pDst = buffer;
pY->dstStep = VC1_ENC_LUMA_SIZE;
pY->dx = 0;
pY->dy = 0;
pY->roundControl = m_uiRoundControl;
pY->roiSize.height = VC1_ENC_LUMA_SIZE;
pY->roiSize.width = VC1_ENC_LUMA_SIZE;
pU->pSrc = pPlane[1];
pU->srcStep = pStep[1];
pU->pDst = buffer + VC1_ENC_LUMA_SIZE*VC1_ENC_LUMA_SIZE;
pU->dstStep = VC1_ENC_CHROMA_SIZE;
pU->dx = 0;
pU->dy = 0;
pU->roundControl = m_uiRoundControl;
pU->roiSize.height = VC1_ENC_CHROMA_SIZE;
pU->roiSize.width = VC1_ENC_CHROMA_SIZE;
pV->pSrc = pPlane[2];
pV->srcStep = pStep[2];
pV->pDst = buffer + VC1_ENC_LUMA_SIZE*VC1_ENC_LUMA_SIZE + VC1_ENC_CHROMA_SIZE*VC1_ENC_CHROMA_SIZE;
pV->dstStep = VC1_ENC_CHROMA_SIZE;
pV->dx = 0;
pV->dy = 0;
pV->roundControl = m_uiRoundControl;
pV->roiSize.height = VC1_ENC_CHROMA_SIZE;
pV->roiSize.width = VC1_ENC_CHROMA_SIZE;
return ret;
}
//motion estimation
UMC::Status VC1EncoderPictureSM::SetMEParams(UMC::MeBase* pME, Ipp32s MESearchSpeed)
{
UMC::Status err = UMC::UMC_OK;
m_pME = pME;
m_MESearchSpeed = MESearchSpeed;
return err;
}
UMC::Status VC1EncoderPictureSM::WritePFrame(VC1EncoderBitStreamSM* pCodedPicture)
{
Ipp32u i=0, j=0, blk = 0;
bool bRaiseFrame = (m_pRaisedPlane[0])&&(m_pRaisedPlane[1])&&(m_pRaisedPlane[2]);
UMC::Status err = UMC::UMC_OK;
Ipp8u* pCurMBRow[3] = {m_pPlane[0], m_pPlane[1], m_pPlane[2]};
Ipp8u* pFMBRow [3] = {m_pForwardPlane[0], m_pForwardPlane[1], m_pForwardPlane[2]};
Ipp32u h = m_pSequenceHeader->GetNumMBInCol();
Ipp32u w = m_pSequenceHeader->GetNumMBInRow();
IppiSize roiSize = {8, 8};
//forward transform quantization
IntraTransformQuantFunction IntraTransformQuantACFunction = (m_bUniformQuant) ? IntraTransformQuantUniform :
IntraTransformQuantNonUniform;
InterTransformQuantFunction InterTransformQuantACFunction = (m_bUniformQuant) ? InterTransformQuantUniform :
InterTransformQuantNonUniform;
//inverse transform quantization
IntraInvTransformQuantFunction IntraInvTransformQuantACFunction = (m_bUniformQuant) ? IntraInvTransformQuantUniform :
IntraInvTransformQuantNonUniform;
InterInvTransformQuantFunction InterInvTransformQuantACFunction = (m_bUniformQuant) ? InterInvTransformQuantUniform :
InterInvTransformQuantNonUniform;
CalculateCromaFunction CalculateCroma = (m_pSequenceHeader->IsFastUVMC())?
GetChromaMVFast:GetChromaMV;
bool bIsBilinearInterpolation = (m_uiMVMode == VC1_ENC_1MV_HALF_BILINEAR);
InterpolateFunction InterpolateLumaFunction = (bIsBilinearInterpolation)?
_own_ippiInterpolateQPBilinear_VC1_8u_C1R:
_own_ippiInterpolateQPBicubic_VC1_8u_C1R;
InterpolateFunction InterpolateChromaFunction = _own_ippiInterpolateQPBilinear_VC1_8u_C1R;
Ipp8u tempInterpolationBuffer[VC1_ENC_BLOCK_SIZE*VC1_ENC_NUMBER_OF_BLOCKS];
//------------------motion estimation------------------------
UMC::MeParams MEParams;
UMC::MeFrame MEFrame;
//-----------------------------------------------------------
IppVCInterpolate_8u sYInterpolation;
IppVCInterpolate_8u sUInterpolation;
IppVCInterpolate_8u sVInterpolation;
VC1EncoderMBData TempBlock;
Ipp16s tempBuffer[VC1_ENC_BLOCK_SIZE*VC1_ENC_NUMBER_OF_BLOCKS];
Ipp8u defDCPredCoeff = (m_pSequenceHeader->IsLoopFilter()&& m_uiQuant>=9)? 0:1;
eDirection direction[VC1_ENC_NUMBER_OF_BLOCKS];
bool dACPrediction = true;
Ipp8u RSize3Mode = 0, LSize3Mode = 0;
IppiSize blkSize = {8,8};
IppiSize blkSizeLuma = {16,16};
const Ipp16u* pCBPCYTable = VLCTableCBPCY_PB[m_uiCBPTab];
eCodingSet LumaCodingSetIntra = LumaCodingSetsIntra [m_uiQuantIndex>8][m_uiDecTypeAC1];
eCodingSet ChromaCodingSetIntra = ChromaCodingSetsIntra[m_uiQuantIndex>8][m_uiDecTypeAC1];
eCodingSet CodingSetInter = CodingSetsInter [m_uiQuantIndex>8][m_uiDecTypeAC1];
const sACTablesSet* pACTablesSetIntra[6] = {
&(ACTablesSet[LumaCodingSetIntra]),
&(ACTablesSet[LumaCodingSetIntra]),
&(ACTablesSet[LumaCodingSetIntra]),
&(ACTablesSet[LumaCodingSetIntra]),
&(ACTablesSet[ChromaCodingSetIntra]),
&(ACTablesSet[ChromaCodingSetIntra])};
const sACTablesSet* pACTablesSetInter = &(ACTablesSet[CodingSetInter]);
const Ipp32u* pDCTableVLCIntra[6] ={
DCTables[m_uiDecTypeDCIntra][0], DCTables[m_uiDecTypeDCIntra][0],DCTables[m_uiDecTypeDCIntra][0], DCTables[m_uiDecTypeDCIntra][0],
DCTables[m_uiDecTypeDCIntra][1], DCTables[m_uiDecTypeDCIntra][1]};
sACEscInfo ACEscInfo = {(m_uiQuant<= 7 /*&& !VOPQuant*/)?
Mode3SizeConservativeVLC : Mode3SizeEfficientVLC,
0, 0
};
Ipp8u doubleQuant = 2*m_uiQuant + m_bHalfQuant;
Ipp8u DCQuant = DCQuantValues[m_uiQuant];
Ipp16s defPredictor = 0;//defDCPredCoeff*(1024 + (DCQuant>>1))/DCQuant;
Ipp16s* pSavedMV = m_pSavedMV;
sCoordinate MVPredMBMin = {-60,-60};
sCoordinate MVPredMBMax = {w*16*4-4, h*16*4-4};
sCoordinate MVSavedMBMin = {-8,-8};
sCoordinate MVSavedMBMax = {w*8, h*8};
bool bMBHalf = (m_uiMVMode == VC1_ENC_1MV_HALF_BILINEAR ||
m_uiMVMode == VC1_ENC_1MV_HALF_BICUBIC) ? true: false;
bool bCalculateVSTransform = (m_pSequenceHeader->IsVSTransform())&&(!m_bVSTransform);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -