今天介绍一下帧间预测技术中的MMVD技术(Merge mode with MVD),也称带有运动矢量差的融合技术,MMVD也属于基于Merge的技术中的一种,在解码端的语法元素中也属于Merge分支。不过我觉着按严格来讲,MMVD并不属于Merge系列,而更像是inter系列,因为MMVD是要传送MVD到解码端,就这一点来看,MMVD就已经不在Merge范围之内了。下面我来讲解一下MMVD的技术细节吧。
MMVD技术应用于帧间预测的Skip和Merge模式中,是一种运动矢量的特殊表达形式。在目前最新的VVC版本——VTM6.0中,MMVD技术的流程大致如下:
(1)首先重复利用普通Merge模式的Merge候选,在这些候选中选择位与列表的前两个候选作为初始的运动矢量基。
(2)对该初始MV进行扩展,主要在运动幅度和运动方向上进行扩展,来得到最终的扩展后的运动矢量,以形成新的运动矢量。
具体的详细步骤如下:
(1)首先利用VVC中普通Merge候选列表构建的过程,得到当前CU的候选列表,检查邻近块的顺序如图所示:
需要注意的是,候选列表的长度为6,通过上述顺序的方法检查块的运动信息是否有效。如果有效,将该块的运动信息添加到候选列表中去;如果没有填满,则在候选列表中填充0矢量。
(2)然后,对于列表中前两个候选,最为初始的MV,以该候选MV在参考图像(分前向或者后向)中所指向的位置为起点,在上下左右四个方向上。进行8种步长的搜索,如下图所示:
其中步长和方向的索引具体如下表所示:
步长索引:
方向索引:
那么每个初始MV在每个方向上的每种步长都会形成一个新的MV,也即是细化过的MV(该扩展MV中包括三个信息:起始点、搜索方向、搜索步长),因此一个初始MV可以扩展出32个新的MV,两个初始MV总共可以扩展形成总共64个新MV,这些新的MV也会通过一次运动补偿得到当前CU的预测值。
那么MMVD在代码中具体是怎么实现的呢?
首先要对扩展的64种MV进行循环遍历,进行率失真代价比较,具体的代码段如下:我有详细的注释,以及起始点、搜索方向、搜索步长是如何表示的,我都有详细的注释。
if ( pu.cs->sps->getUseMMVD() )//使用MMVD模式,这里选出最优的MMVD的Merge候选(初始MV+搜索方向+搜索步长)
{
cu.mmvdSkip = true;
#if JVET_O0249_MERGE_SYNTAX
pu.regularMergeFlag = true;//普通Merge列表依旧可用,因为初始的MV还是要从普通Merge中获取
#endif
const int tempNum = (mergeCtx.numValidMergeCand > 1) ? MMVD_ADD_NUM : MMVD_ADD_NUM >> 1;
//对MMVD候选循环遍历
for (int mmvdMergeCand = 0; mmvdMergeCand < tempNum; mmvdMergeCand++)//循环64遍,前32种得到起始点1以及对应的8个步长
//因为对于每种MV扩展都可以得到4*8种组合,因此两个起始点总共是64种组合
{
int baseIdx = mmvdMergeCand / MMVD_MAX_REFINE_NUM;//候选基MV(即初始MV)索引,要么0 要么1,(这里就是两个初始MV的起点,每个初始MV有32种4*8的步长+方向的组合)
int refineStep = (mmvdMergeCand - (baseIdx * MMVD_MAX_REFINE_NUM)) / 4;//表示8种步长
if (refineStep >= m_pcEncCfg->getMmvdDisNum())
continue;
//设置MMVD候选的信息,得到每个扩展MV具体的搜索初始点以及每个方向以及对应的步长
mergeCtx.setMmvdMergeCandiInfo(pu, mmvdMergeCand);
PU::spanMotionInfo(pu, mergeCtx);
pu.mvRefine = true;
distParam.cur = singleMergeTempBuffer->Y();
pu.mmvdEncOptMode = (refineStep > 2 ? 2 : 1);
CHECK(!pu.mmvdMergeFlag, "MMVD merge should be set");
// Don't do chroma MC here
//MMVD的Merge候选运动补偿计算预测值
m_pcInterSearch->motionCompensation(pu, *singleMergeTempBuffer, REF_PIC_LIST_X, true, false);
pu.mmvdEncOptMode = 0;
pu.mvRefine = false;
Distortion uiSad = distParam.distFunc(distParam);//失真函数
m_CABACEstimator->getCtx() = ctxStart;
uint64_t fracBits = m_pcInterSearch->xCalcPuMeBits(pu);//计算码率
double cost = (double)uiSad + (double)fracBits * sqrtLambdaForFirstPassIntra; //计算RDcost
insertPos = -1;
//更新候选列表
updateCandList(ModeInfo(mmvdMergeCand, false, true, false), cost, RdModeList, candCostList, uiNumMrgSATDCand, &insertPos);
if (insertPos != -1)
{
for (int i = int(RdModeList.size()) - 1; i > insertPos; i--)
{
swap(acMergeTempBuffer[i - 1], acMergeTempBuffer[i]);
}
swap(singleMergeTempBuffer, acMergeTempBuffer[insertPos]);//将代价更小的那个MV插入到Merge列表中
}
}
}
当然,这里关于MMVD新的扩展MV的生成有一个专门的函数,setMmvdMergeCandiInfo()函数中设置MMVD候选的信息,得到每个扩展MV具体的搜索初始点以及每个方向以及对应的步长。该函数代码具体如下,想要看的细一点的同学可以研究一下我加的注释:
//设置MMVD的候选信息,candIdx就是32种组合中的一种模式的索引
void MergeCtx::setMmvdMergeCandiInfo(PredictionUnit& pu, int candIdx)
{
const Slice &slice = *pu.cs->slice;
const int mvShift = MV_FRACTIONAL_BITS_DIFF;
//参考MVD的候选,2,4,8,16,32,64,128,256
//这里面实际就是8种步长的偏置量
const int refMvdCands[8] = { 1 << mvShift , 2 << mvShift , 4 << mvShift , 8 << mvShift , 16 << mvShift , 32 << mvShift, 64 << mvShift , 128 << mvShift };
int fPosGroup = 0;
int fPosBaseIdx = 0;//起始MV的索引
int fPosStep = 0;//搜索步长
int tempIdx = 0;
int fPosPosition = 0;//搜索方向
Mv tempMv[2];//里面存储前向MV和后向MV
tempIdx = candIdx;//组合新的MV索引
fPosGroup = tempIdx / (MMVD_BASE_MV_NUM * MMVD_MAX_REFINE_NUM);//整个候选列表的初始位置0
tempIdx = tempIdx - fPosGroup * (MMVD_BASE_MV_NUM * MMVD_MAX_REFINE_NUM); //0-63,传进来的扩展MV的索引
fPosBaseIdx = tempIdx / MMVD_MAX_REFINE_NUM;//第一个初始向量的索引0或者第二个初始向量的索引1
tempIdx = tempIdx - fPosBaseIdx * (MMVD_MAX_REFINE_NUM);//0-31(各自初始向量的32种扩展MV)
fPosStep = tempIdx / 4; //每个初始MV对应的8种步长的索引
fPosPosition = tempIdx - fPosStep * (4);//该值总为0-3,也就是对应的四个方向的索引
int offset = refMvdCands[fPosStep];//8种步长对应的偏置
if ( pu.cu->slice->getDisFracMMVD() )
{
offset <<= 2;
}
const int refList0 = mmvdBaseMv[fPosBaseIdx][0].refIdx;//每个初始MV的前向参考列表
const int refList1 = mmvdBaseMv[fPosBaseIdx][1].refIdx;//每个初始MV的后向参考列表
if ((refList0 != -1) && (refList1 != -1))//双向的参考列表存在
{
const int poc0 = slice.getRefPOC(REF_PIC_LIST_0, refList0); //前向参考帧的POC
const int poc1 = slice.getRefPOC(REF_PIC_LIST_1, refList1);//后向参考帧的POC
const int currPoc = slice.getPOC();//当前帧的POC
//每个MV的结构体里包含其搜索方向,以及搜索步长,然后赋值给tempMv数组
if (fPosPosition == 0)
{
tempMv[0] = Mv(offset, 0);//右
}
else if (fPosPosition == 1)
{
tempMv[0] = Mv(-offset, 0);//左
}
else if (fPosPosition == 2)
{
tempMv[0] = Mv(0, offset);//上
}
else
{
tempMv[0] = Mv(0, -offset);//下
}
if ((poc0 - currPoc) == (poc1 - currPoc))//前后向参考帧属于同一帧
{
tempMv[1] = tempMv[0];//双向的MVD是一样的
}
else if (abs(poc1 - currPoc) > abs(poc0 - currPoc))//后向参考帧POC大于前向参考帧的POC
{
const int scale = PU::getDistScaleFactor(currPoc, poc0, currPoc, poc1);
tempMv[1] = tempMv[0];
const bool isL0RefLongTerm = slice.getRefPic(REF_PIC_LIST_0, refList0)->longTerm;
const bool isL1RefLongTerm = slice.getRefPic(REF_PIC_LIST_1, refList1)->longTerm;
if (isL0RefLongTerm || isL1RefLongTerm)//有其中一个是长期参考帧
{
if ((poc1 - currPoc)*(poc0 - currPoc) > 0)
{
tempMv[0] = tempMv[1];
}
else
{
tempMv[0].set(-1 * tempMv[1].getHor(), -1 * tempMv[1].getVer());
}
}
else//都不是长期参考帧
tempMv[0] = tempMv[1].scaleMv(scale);
}
else
{
const int scale = PU::getDistScaleFactor(currPoc, poc1, currPoc, poc0);
const bool isL0RefLongTerm = slice.getRefPic(REF_PIC_LIST_0, refList0)->longTerm;
const bool isL1RefLongTerm = slice.getRefPic(REF_PIC_LIST_1, refList1)->longTerm;
if (isL0RefLongTerm || isL1RefLongTerm)
{
if ((poc1 - currPoc)*(poc0 - currPoc) > 0)//若前后向参考帧都来自当前帧的时域的同一侧,后向MMVDoffet与前向的相等
{
tempMv[1] = tempMv[0];
}
else//若不来自同一侧,前向和后向的MMVDOffset相对称
{
tempMv[1].set(-1 * tempMv[0].getHor(), -1 * tempMv[0].getVer());
}
}
else
tempMv[1] = tempMv[0].scaleMv(scale);
}
pu.interDir = 3;//双向列表的DIr设置为3
//这里为每个选中的MV选择起始MV然后加上步长和方向
pu.mv[REF_PIC_LIST_0] = mmvdBaseMv[fPosBaseIdx][0].mv + tempMv[0];//MMVD的前向MV
pu.refIdx[REF_PIC_LIST_0] = refList0;
pu.mv[REF_PIC_LIST_1] = mmvdBaseMv[fPosBaseIdx][1].mv + tempMv[1];//MMVD的后向MV
pu.refIdx[REF_PIC_LIST_1] = refList1;
}
else if (refList0 != -1)//如果只有前向列表存在
{
if (fPosPosition == 0)//右
{
tempMv[0] = Mv(offset, 0);
}
else if (fPosPosition == 1)//左
{
tempMv[0] = Mv(-offset, 0);
}
else if (fPosPosition == 2)//上
{
tempMv[0] = Mv(0, offset);
}
else//下
{
tempMv[0] = Mv(0, -offset);
}
pu.interDir = 1;//前向列表的DIr设置为1
pu.mv[REF_PIC_LIST_0] = mmvdBaseMv[fPosBaseIdx][0].mv + tempMv[0];
pu.refIdx[REF_PIC_LIST_0] = refList0;
pu.mv[REF_PIC_LIST_1] = Mv(0, 0);
pu.refIdx[REF_PIC_LIST_1] = -1;
}
else if (refList1 != -1)
{
if (fPosPosition == 0)
{
tempMv[1] = Mv(offset, 0);
}
else if (fPosPosition == 1)
{
tempMv[1] = Mv(-offset, 0);
}
else if (fPosPosition == 2)
{
tempMv[1] = Mv(0, offset);
}
else
{
tempMv[1] = Mv(0, -offset);
}
pu.interDir = 2;//后向列表的DIr设置为2
pu.mv[REF_PIC_LIST_0] = Mv(0, 0);
pu.refIdx[REF_PIC_LIST_0] = -1;
pu.mv[REF_PIC_LIST_1] = mmvdBaseMv[fPosBaseIdx][1].mv + tempMv[1];
pu.refIdx[REF_PIC_LIST_1] = refList1;
}
pu.mmvdMergeFlag = true;
pu.mmvdMergeIdx = candIdx;
pu.mergeFlag = true;
#if JVET_O0249_MERGE_SYNTAX
pu.regularMergeFlag = true;
#else
pu.regularMergeFlag = false;
#endif
pu.mergeIdx = candIdx;
pu.mergeType = MRG_TYPE_DEFAULT_N;
pu.mvd[REF_PIC_LIST_0] = Mv();
pu.mvd[REF_PIC_LIST_1] = Mv();
pu.mvpIdx[REF_PIC_LIST_0] = NOT_VALID;
pu.mvpIdx[REF_PIC_LIST_1] = NOT_VALID;
pu.mvpNum[REF_PIC_LIST_0] = NOT_VALID;
pu.mvpNum[REF_PIC_LIST_1] = NOT_VALID;
#if JVET_O0057_ALTHPELIF
pu.cu->imv = mmvdUseAltHpelIf[fPosBaseIdx] ? IMV_HPEL : 0;//MV使用半像素精度
#endif
pu.cu->GBiIdx = (interDirNeighbours[fPosBaseIdx] == 3) ? GBiIdx[fPosBaseIdx] : GBI_DEFAULT;//双向参考索引
for (int refList = 0; refList < 2; refList++)
{
if (pu.refIdx[refList] >= 0)
{
pu.mv[refList].clipToStorageBitDepth();
}
}
PU::restrictBiPredMergeCandsOne(pu);
}
最后,关于MMVD熵编码的部分我在后续打算专门写一篇博客讲一下,顺便将所有Merge的熵编码部分都放在一起讲,比较统一也方便大家理解~