HEVC中的Merge Mode——x265代码getInterMergeCandidates（）函数解析

最新推荐文章于 2023-09-04 21:17:12 发布
最新推荐文章于 2023-09-04 21:17:12 发布
阅读量1.3k 收藏 8
点赞数 3
分类专栏： 视频编码 文章标签： 视频编码 x265 HEVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40102403/article/details/84034149
版权

HEVC中的mv预测技术主要分为两种：AMVP mode 和Merge mode，这里就主要来聊聊Merge mode。
由于很多时候当前的编码CU与相邻已经完成编码的CU具有相同的mv，因此从相邻的若干个PU中获取最佳的mv就是Merge mode要做的主要事情：

  1. 通过搜索相邻PU的motion information（包括reference index和mv）是否可用，可得时加入MergeCandidateList，作为motion information的候选。
  2. 逐个服复用MergeCandidateList中的motion information，计算残差。
  3. 模型选择最终选定Merge mode为预测模式，则将Merge index和相应的残差写入码流。

这次要讨论的getInterMergeCandidates()函数主要就是建立MergeCandidateList的过程。在x265的源码中，不同的preset对应的MergeCandidate个数是不一样的。从ultrafast到medium的maxNumMergeCand为2，slow和slower为3，veryslow为4，placebo为5。不同的candidate个数会对编码计算复杂度和压缩效率产生影响，需要根据应用场景进行调整。
为了获得更好的压缩效果，在获取MergeCandidateList的过程中，需要考虑以下几点：

  1. 加入MergeCandidateList的motion information的次序会对编码产生影响。放在candidate list中靠前位置的motion information应该是最有可能被选中的块。这样在对merge index进行变长编码时就会占用最小的bits。经过大量的试验表明，周边PU的搜索顺序为left（A1）->above（B1）->above right（B0）->left bottom（A0）->above left（B2）->temporal->填充candidate。
  2. Candidate的质量也会有影响，体现在有效的Candidate的个数。在getInterMergeCandidates()函数中，有pruning的过程来筛选掉重复的Candidate。pruning的算法为B1与A1做pruning，B0与B1做pruning，A0与A1做pruning，B2与A1和B1做pruning。这样可以减少candidate list中重复的motion information，将有效的放在list前面。
    在这里插入图片描述

在3D-HEVC中MergeCandidateList的获取过程中就加入了disparity motion vector作为candidate之一，也是提高了candidate的质量，从而提高编码效果。

下面是x265中getInterMergeCandidates()函数的源代码和注释，供大家参考。

/* Construct list of merging candidates, returns count */
uint32_t CUData::getInterMergeCandidates(uint32_t absPartIdx, uint32_t puIdx, MVField(*candMvField)[2], uint8_t* candDir) const
{
    uint32_t absPartAddr = m_absIdxInCTU + absPartIdx;//计算当前CU的绝对位置
    const bool isInterB = m_slice->isInterB();

	//最大的MergeCandidate个数，默认为2，其中slow和slower模式为3，veryslow模式为4，placebo模式为5
    const uint32_t maxNumMergeCand = m_slice->m_maxNumMergeCand;
    //assert(m_slice->m_maxNumMergeCand == 2);

    for (uint32_t i = 0; i < maxNumMergeCand; ++i)//初始化Mergecandidates的mv和refidx为0
    {
        candMvField[i][0].mv = 0;
        candMvField[i][1].mv = 0;
        candMvField[i][0].refIdx = REF_NOT_VALID;
        candMvField[i][1].refIdx = REF_NOT_VALID;
    }

    /* calculate the location of upper-left corner pixel and size of the current PU */
    int xP, yP, nPSW, nPSH;

    int cuSize = 1 << m_log2CUSize[0];//获取CU的大小
    int partMode = m_partSize[0];//获取四叉树划分模式

    int tmp = partTable[partMode][puIdx][0];
    nPSW = ((tmp >> 4) * cuSize) >> 2;//PU的宽度
    nPSH = ((tmp & 0xF) * cuSize) >> 2;//PU的高度

    tmp = partTable[partMode][puIdx][1];
    xP = ((tmp >> 4) * cuSize) >> 2;//PU top-left像素x坐标
    yP = ((tmp & 0xF) * cuSize) >> 2;//PU top-left像素y坐标

    if(xP == 16 || yP == 16)
      int a = 0;
    if(nPSW == 8 && nPSH == 8)
      int b = 0;
    uint32_t count = 0;

    uint32_t partIdxLT, partIdxRT, partIdxLB = deriveLeftBottomIdx(puIdx);
    PartSize curPS = (PartSize)m_partSize[absPartIdx];
    
    //merge candidates的PU搜索顺序：left（A1）->above->above right->left bottom->above left->temporal->填充candidate
    //按照统计规律，上述PU的排序按照与当前PU具备最佳mv的概率从高到低排列，被选中的candidate的index值越小，写入码流后占用的bit越小
    //因此需要将选中概率大的PU放在candidate list的靠前位置
    // left
    uint32_t leftPartIdx = 0;
    const CUData* cuLeft = getPULeft(leftPartIdx, partIdxLB);//获取left PU
    //isavailableA1：A1是否可用，判断条件为：
    //1. A1存在
    //2. A1与当前coding PU不属于同一merge域（与当前coding PU不共用同一套merge info）
    //3. 当前PU不能具备下列条件：index为1，划分方式为Nx2N,nLx2N,nrx2N 
    //4. A1为inter mode（这样才具备mv）
    bool isAvailableA1 = cuLeft &&
        cuLeft->isDiffMER(xP - 1, yP + nPSH - 1, xP, yP) &&
        !(puIdx == 1 && (curPS == SIZE_Nx2N || curPS == SIZE_nLx2N || curPS == SIZE_nRx2N)) &&
        cuLeft->isInter(leftPartIdx);
    if (isAvailableA1)
    {
        // get Inter Dir
        candDir[count] = cuLeft->m_interDir[leftPartIdx];//复用inter direction
        // get Mv from Left
        cuLeft->getMvField(cuLeft, leftPartIdx, 0, candMvField[count][0]);//P或者B的list0，复用mv
        if (isInterB)
            cuLeft->getMvField(cuLeft, leftPartIdx, 1, candMvField[count][1]);//B的list1，复用mv

        if (++count == maxNumMergeCand)//MergeCand个数
            return maxNumMergeCand;
    }

    deriveLeftRightTopIdx(puIdx, partIdxLT, partIdxRT);

    // above
    uint32_t abovePartIdx = 0;
    const CUData* cuAbove = getPUAbove(abovePartIdx, partIdxRT);//获取B1
    bool isAvailableB1 = cuAbove &&
        cuAbove->isDiffMER(xP + nPSW - 1, yP - 1, xP, yP) &&
        !(puIdx == 1 && (curPS == SIZE_2NxN || curPS == SIZE_2NxnU || curPS == SIZE_2NxnD)) &&
        cuAbove->isInter(abovePartIdx);
    if (isAvailableB1 && (!isAvailableA1 || !cuLeft->hasEqualMotion(leftPartIdx, *cuAbove, abovePartIdx)))//与A1的motion info做互比，舍去相同的
    {
        // get Inter Dir
        candDir[count] = cuAbove->m_interDir[abovePartIdx];
        // get Mv from Left
        cuAbove->getMvField(cuAbove, abovePartIdx, 0, candMvField[count][0]);
        if (isInterB)
            cuAbove->getMvField(cuAbove, abovePartIdx, 1, candMvField[count][1]);

        if (++count == maxNumMergeCand)
            return maxNumMergeCand;
    }

    // above right
    uint32_t aboveRightPartIdx = 0;
    const CUData* cuAboveRight = getPUAboveRight(aboveRightPartIdx, partIdxRT);
    bool isAvailableB0 = cuAboveRight &&
        cuAboveRight->isDiffMER(xP + nPSW, yP - 1, xP, yP) &&
        cuAboveRight->isInter(aboveRightPartIdx);
    if (isAvailableB0 && (!isAvailableB1 || !cuAbove->hasEqualMotion(abovePartIdx, *cuAboveRight, aboveRightPartIdx)))//与B1做互比
    {
        // get Inter Dir
        candDir[count] = cuAboveRight->m_interDir[aboveRightPartIdx];
        // get Mv from Left
        cuAboveRight->getMvField(cuAboveRight, aboveRightPartIdx, 0, candMvField[count][0]);
        if (isInterB)
            cuAboveRight->getMvField(cuAboveRight, aboveRightPartIdx, 1, candMvField[count][1]);

        if (++count == maxNumMergeCand)
            return maxNumMergeCand;
    }

    // left bottom
    uint32_t leftBottomPartIdx = 0;
    const CUData* cuLeftBottom = this->getPUBelowLeft(leftBottomPartIdx, partIdxLB);
    bool isAvailableA0 = cuLeftBottom &&
        cuLeftBottom->isDiffMER(xP - 1, yP + nPSH, xP, yP) &&
        cuLeftBottom->isInter(leftBottomPartIdx);
    if (isAvailableA0 && (!isAvailableA1 || !cuLeft->hasEqualMotion(leftPartIdx, *cuLeftBottom, leftBottomPartIdx)))//与A1互比
    {
        // get Inter Dir
        candDir[count] = cuLeftBottom->m_interDir[leftBottomPartIdx];
        // get Mv from Left
        cuLeftBottom->getMvField(cuLeftBottom, leftBottomPartIdx, 0, candMvField[count][0]);
        if (isInterB)
            cuLeftBottom->getMvField(cuLeftBottom, leftBottomPartIdx, 1, candMvField[count][1]);

        if (++count == maxNumMergeCand)
            return maxNumMergeCand;
    }

    // above left
    if (count < 4)
    {
        uint32_t aboveLeftPartIdx = 0;
        const CUData* cuAboveLeft = getPUAboveLeft(aboveLeftPartIdx, absPartAddr);
        bool isAvailableB2 = cuAboveLeft &&
            cuAboveLeft->isDiffMER(xP - 1, yP - 1, xP, yP) &&
            cuAboveLeft->isInter(aboveLeftPartIdx);
        if (isAvailableB2 && (!isAvailableA1 || !cuLeft->hasEqualMotion(leftPartIdx, *cuAboveLeft, aboveLeftPartIdx))
            && (!isAvailableB1 || !cuAbove->hasEqualMotion(abovePartIdx, *cuAboveLeft, aboveLeftPartIdx)))//与A1和B1做互比
        {
            // get Inter Dir
            candDir[count] = cuAboveLeft->m_interDir[aboveLeftPartIdx];
            // get Mv from Left
            cuAboveLeft->getMvField(cuAboveLeft, aboveLeftPartIdx, 0, candMvField[count][0]);
            if (isInterB)
                cuAboveLeft->getMvField(cuAboveLeft, aboveLeftPartIdx, 1, candMvField[count][1]);

            if (++count == maxNumMergeCand)
                return maxNumMergeCand;
        }
    }

    //检查当前帧是否打开了temporal MVP，如果存在，则检查temporal mv是否可加入candidate list
    if (m_slice->m_sps->bTemporalMVPEnabled)
    {
        uint32_t partIdxRB = deriveRightBottomIdx(puIdx);
        MV colmv;
        int ctuIdx = -1;

        // image boundary check
        if (m_encData->getPicCTU(m_cuAddr)->m_cuPelX + g_zscanToPelX[partIdxRB] + UNIT_SIZE < m_slice->m_sps->picWidthInLumaSamples &&
            m_encData->getPicCTU(m_cuAddr)->m_cuPelY + g_zscanToPelY[partIdxRB] + UNIT_SIZE < m_slice->m_sps->picHeightInLumaSamples)
        {
            uint32_t absPartIdxRB = g_zscanToRaster[partIdxRB];
            uint32_t numUnits = s_numPartInCUSize;
            bool bNotLastCol = lessThanCol(absPartIdxRB, numUnits - 1); // is not at the last column of CTU
            bool bNotLastRow = lessThanRow(absPartIdxRB, numUnits - 1); // is not at the last row    of CTU

            if (bNotLastCol && bNotLastRow)//如果不是当前CTU的最后一行、最后一列，则取当前PU的right bottom的address
            {
                absPartAddr = g_rasterToZscan[absPartIdxRB + RASTER_SIZE + 1];
                ctuIdx = m_cuAddr;
            }
            //如果是最后一行，但不是最后一列，则取下一行CTU中对应当前PU的right bottom的address
            //注意，这里并没有把CTU的index更新，这里为了在编码时避免CTU跨行，在这种情况下直接取中心位置的PU的mv作为candidate
            else if (bNotLastCol)
                absPartAddr = g_rasterToZscan[(absPartIdxRB + 1) & (numUnits - 1)];
            else if (bNotLastRow)//如果是最后一列，但不是最后一行，则取下一个CU的中对应当前PU的right bottom的address
            {
                absPartAddr = g_rasterToZscan[absPartIdxRB + RASTER_SIZE - numUnits + 1];
                ctuIdx = m_cuAddr + 1;
            }
            else // is the right bottom corner of CTU如果是当前CTU的右下角，
                absPartAddr = 0;
        }

        int maxList = isInterB ? 2 : 1;
        int dir = 0, refIdx = 0;
        for (int list = 0; list < maxList; list++)
        {
            bool bExistMV = ctuIdx >= 0 && getColMVP(colmv, refIdx, list, ctuIdx, absPartAddr);//取MVP
            if (!bExistMV)//如果没有取成功，则取中央位置PU的mvp，这里对应上述的CTU跨行的问题
            {
                uint32_t partIdxCenter = deriveCenterIdx(puIdx);
                bExistMV = getColMVP(colmv, refIdx, list, m_cuAddr, partIdxCenter);
            }
            if (bExistMV)//如果取成功，将mvp加入candidate list
            {
                dir |= (1 << list);
                candMvField[count][list].mv = colmv;
                candMvField[count][list].refIdx = refIdx;
            }
        }

        if (dir != 0)
        {
            candDir[count] = (uint8_t)dir;

            if (++count == maxNumMergeCand)
                return maxNumMergeCand;
        }
    }


    //当前如果是interB时，之前的candidate个数大于1，则按照已制定好的优先级组合已有的candidate info，形成一个新的candidate，并加入list
    if (isInterB)
    {
        const uint32_t cutoff = count * (count - 1);
        uint32_t priorityList0 = 0xEDC984; // { 0, 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3 }
        uint32_t priorityList1 = 0xB73621; // { 1, 0, 2, 0, 2, 1, 3, 0, 3, 1, 3, 2 }

        for (uint32_t idx = 0; idx < cutoff; idx++, priorityList0 >>= 2, priorityList1 >>= 2)
        {
            int i = priorityList0 & 3;
            int j = priorityList1 & 3;

            if ((candDir[i] & 0x1) && (candDir[j] & 0x2))
            {
                // get Mv from cand[i] and cand[j]
                int refIdxL0 = candMvField[i][0].refIdx;
                int refIdxL1 = candMvField[j][1].refIdx;
                int refPOCL0 = m_slice->m_refPOCList[0][refIdxL0];
                int refPOCL1 = m_slice->m_refPOCList[1][refIdxL1];
                if (!(refPOCL0 == refPOCL1 && candMvField[i][0].mv == candMvField[j][1].mv))
                {
                    candMvField[count][0].mv = candMvField[i][0].mv;
                    candMvField[count][0].refIdx = refIdxL0;
                    candMvField[count][1].mv = candMvField[j][1].mv;
                    candMvField[count][1].refIdx = refIdxL1;
                    candDir[count] = 3;

                    if (++count == maxNumMergeCand)
                        return maxNumMergeCand;
                }
            }
        }
    }

    //上述的过程选出的candidate个数如果还小于maxNumMergeCand，则补充0
    int numRefIdx = (isInterB) ? X265_MIN(m_slice->m_numRefIdx[0], m_slice->m_numRefIdx[1]) : m_slice->m_numRefIdx[0];
    int r = 0;
    int refcnt = 0;
    while (count < maxNumMergeCand)
    {
        candDir[count] = 1;
        candMvField[count][0].mv.word = 0;
        candMvField[count][0].refIdx = r;

        if (isInterB)
        {
            candDir[count] = 3;
            candMvField[count][1].mv.word = 0;
            candMvField[count][1].refIdx = r;
        }

        count++;

        if (refcnt == numRefIdx - 1)
            r = 0;
        else
        {
            ++r;
            ++refcnt;
        }
    }

    return count;
}
羌笛须怨杨
关注
专栏目录
x265编码器 encodeResAndCalcRdSkipCU 函数分析
想都是问题，做才有答案～～
10-24 581
x265中encodeResAndCalcRdSkipCU()分析
x265编码器 recodeCU 函数分析
想都是问题，做才有答案～～
09-04 373
x265中recodeCU()的函数调用分析
HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析
HEVC_CJL的专栏
03-12 1万+
从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。   大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostInter，xCheckRD
HEVC的Merge模式
syn_0123的博客
07-16 1492
帧间预测有两种方式，一种是磨人的inter模式，一种是merge模式。 merge模式是对相邻（空间相邻或时间相邻）已编码的PU进行合并处理，其运动参数相同或相近。只需为每个小区传输一次运动参数。 merge进行的是MV的预测，没有ME过程。主要过程包括： 1. 构造参考列表； 2.以竞争方式选择参考PU。 inter模式调用函数流程： xCheckRDCostInter——&g...
hevc编码merge 模式
fantasy_ARM9的博客
11-16 693
hevc candidate
HEVC代码学习9：getInterMergeCandidates函数
慢慢积累
05-08 1859
今天需要统计Merge的候选列表信息，来看下getInterMergeCandidates函数，用于建立merge候选列表。 其主要工作流程： 1.建立空间列表，如果达到最大候选数，退出。 2.空间列表不能填满候选列表，建立时域列表补足，如果达到最大候选数，退出。 3.空间+时域列表不能填满候选列表，建立组合列表补足，如果达到最大候选数，退出。 4.若依然为填满，则使用零MV补足。//!
HTM-16.2代码（13）——getInterMergeCandidates
Eyrane的博客
12-28 683
getInterMergeCandidates是Merge技术候选列表的实现。空域：选取的顺序为A1-&gt;B1-&gt;B0-&gt;A0-&gt;(B2)。其中，B2只有在A1，B1，B0，A0中有一个不存在或者帧内预测的情况才可使用。时域：一般情况下首先考虑的是H位置，当H位置不存在或者编码模式使用的是帧内编码模式或者超出了CTU的边界时，选择C3位置。 //! Cons...
【转载】HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析
HEVC_heiyue的专栏
12-23 570
转载自 从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。   大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostI
x265编码参数详细介绍
最新发布
想都是问题，做才有答案～～
09-04 1375
x265 编码参数详细介绍
X265源代码201209版(HEVC/H.265实现)
03-15
简单而强大的HEVC/H.265实现。 针对嵌入式，FPGA，GPU多核系统进行优化。目前，在GPU上的测试不成功。我想这是由于NVidia Kepler GPU开关速度不够快。每当HM-N.0发布时，该SDK将上传。 最新发布的SDK是兼容HM-10.0V。代码在我的x86平台上开发，现在还未正式支持x64版本。要想在x64系统上使用X265，请配置'GCC-M32'。
帧间预测（一）Void TComDataCU ::getInterMergeCandidates
u010289908的专栏
10-02 587
对应Merge模式的建立 /** Constructs a list of merging candidates  * \param uiAbsPartIdx  * \param uiPUIdx  * \param uiDepth  * \param pcMvFieldNeighbours  * \param puhInterDirNeighbours  * \param n
CUData::getInterMergeCandidates()/getNeighbourMV()
workspace
04-08 401
CUData::getInterMergeCandidates()构造当前PU的merge备选集 空间merge备选集 必要，5选4，B2替补 时间merge备选集 可选，2选1，C3替补 /* Construct list of merging candidates, returns count 构造merge备选集列表，返回备选集个数 备选集方案： 1.空域...
H.266/VVC代码学习笔记13：VTM6.0中的getInterMergeCandidates（）函数
Peter_Red_Boy的博客
09-16 1388
getInterMergeCandidates（）函数是帧间预测技术中一个非常重要的函数，它是Merge列表的构造函数，所有的Merge模式都要先构造一个Merge候选列表，然后根据不同的模式在此regularMerge列表的基础上去延伸出相对应的Merge列表，就比如MMVD的Merge列表需要在常规Merge列表的基础上去选择两个初始MV，然后构造MMVDMerge。 普通Merge列表的构造...
VTM1.0代码阅读：getInterMergeCandidates函数
矛盾统一
12-26 275
xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。 MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息： class MergeCtx { public: MergeCtx() : numValidMergeCand( 0 ), hasMergedCandList( fa...
VTM3.0代码阅读：getInterMergeCandidates函数
矛盾统一
12-26 282
xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。 MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息： class MergeCtx { //... public: MvField mvFieldNeighbours [ MRG_MAX_NUM_CANDS...
HEVC函数入门（19）——帧间编码AMVP
不是他人太努力，只是自己努力不够罢了
08-21 2082
本文整理自http://blog.csdn.net/NB_vol_1/article/details/51162391 简介 和 predInterSearch主要的工作是ME（运动估计）和MC（运动补偿）。 函数中有一个bTestNormalMC变量，它表示是否进行正常的MC过程，正常的MC过程就是进行ME再进行MC。 正常的MC流程是，遍历所有的参考帧，进行ME（运动
HEVC开源编码器x265
09-19
Open Source (GPL) H.265/HEVC video encoder 下载网址：https://bitbucket.org/multicoreware/x265/src x265 developer wiki To compile x265 you must first install Mercurial (or TortoiseHg on Windows) and CMake. Then follow these easy steps: (for the most definitive instructions, consult our build README) Linux Instructions # ubuntu packages: $ sudo apt-get install mercurial cmake cmake-curses-gui build-essential yasm # Note: if the packaged yasm is older than 1.2, you must download yasm-1.2 and build it $ hg clone https://bitbucket.org/multicoreware/x265 $ cd x265/build/linux $ ./make-Makefiles.bash $ make Windows (Visual Studio) Instructions $ hg clone https://bitbucket.org/multicoreware/x265 Then run make-solutions.bat in the build\ folder that corresponds to your favorite compiler, configure your build options, click 'configure', click 'generate', then close cmake-gui. You will be rewarded with an x265.sln file. Also see cmake documentation. Intel Compiler Instructions On Windows, you should open an Intel Compiler command prompt and within it run one of the make-makefiles.bat scripts in build/icl32 or build/icl64, then run nmake. On Linux, you can tell cmake to build Makefiles for icpc directly. This requires you to have configured Intel's compiler environment (by sourcing the appropriate shell script). For example: $ source /opt/intel/composer_xe_2013/bin/compilervars.sh intel64 $ cd repos/x265/build/linux $ export CXX=icpc $ export CC=icc $ ./make-Makefiles $ make Command line interface The Makefile/solution builds a static encoder.lib library and a standalone x265 executable that aims to be similar to x264 in its command line interface. Running without arguments shows you the command line help. Info Mission Statement Road Map TODO HOWTO add a new encoder performance primitive HOWTO Contribute patches to x265 HOWTO cross compile from Linux to Windows Coding Style Helpful links
VVC帧间预测（二）Merge mode with MVD (MMVD)
热门推荐
Dillon2015的博客
12-27 5万+
在上一篇文章扩展的merge模式中，当前CU在生成的merge list中选择一个率失真代价最小的候选项的运动信息直接作为自己的运动信息。而MMVD是将候选项的运动信息作为自己MV的预测值，需要编码传输MVD（自己最优MV与预测MV的差值）。 MMVD起源于之前提案中的ultimate motion vector expression（UMVE）技术，UMVE是一种新的运动向量表示方法，在ski...
HEVC中Merge模式候选决策的探究和优化
10-16
针对Merge模式中存在的运算时间长且计算复杂度高的问题，通过对候选PU的合并过程进行研究，提出了优化的候选决策算法。基于时域候选和空域候选决策算法在不同情况下对当前块的影响程度不同，自适应地改变候选决策列表来减少计算复杂度和提高预测精度。与标准算法相比，该算法在视频序列的PSNR值略有增高、码率减少的情况下，编码时间得到有效减少。而且该算法在提高HEVC编码率失真性能的同时有效降低了计算复杂度。
HM编码器代码阅读(17)——帧间预测之merge模式（一）Merge模式的介绍以及相关函数
NB_vol_1的专栏
04-15 7743
入口函数：TEncCu::xCheckRDCostMerge2Nx2N 主要流程： （1）获取可用merge候选MV数量以及merge候选MV （2）判断是否为无损模式，如果是无损模式，那么下面的for循环只需迭代一次，如果不是武勋模式，那么下面的for循环要迭代两次 （3）一个for循环，遍历所有的merge模式候选者      1）设置相关参数      2）调用motionCom
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值