【七】 H.266/VVC中 带有运动矢量差的融合技术(MMVD)

最新推荐文章于 2023-05-09 21:34:29 发布
最新推荐文章于 2023-05-09 21:34:29 发布
阅读量1.4k 收藏 9
点赞数
分类专栏： VVC/H.266
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45615071/article/details/107058188
版权

一、前言

在VVC的扩展merge模式当中，当前CU生成的merge list中选择一个率失真代价值最小的候选项直接作为自己的运动信息，而MMVD是将候选项的运动信息作为自己MV的预测值，最终编码对象为实际获得的MV与该预测值之间的差值(MVD)

MMVD技术起源于之前提案中的ultimate motion vector expression（UMVE）技术，该技术是一种新的运动向量表示方法，在skip和merge模式当中使用起始点、运动步长、运动方向三个量来表示运动向量

MMVD技术应用与帧间预测的Skip和Merge模式当中，是一种运动矢量的特殊表达形式，在VTM中，MMVD技术流程大致如下所示：

  • 首先复用普通merge模式的merge候选列表，在这些候选中选择列表的前两个候选作为初始的运动矢量
  • 对该初始MV进行扩展，主要在运动幅度和运动方向上进行扩展，来得到最终的扩展后的运动矢量，以形成新的运动矢量。

二、具体实现步骤

具体实现步骤如下：

(1)、首先利用VVC中普通merge候选列表构建的过程，得到当前CU的merge list，检查邻块的顺序如下图所示

在这里插入图片描述
(2)、对于第一步得到的merge list中的前两个候选，把它们作为初始的MV，以该候选MV在参考图像中所指向的位置作为起始点，在上下左右四个方向上，进行8中步长的搜索，如下图所示

在这里插入图片描述

步长索引表：

在这里插入图片描述

方向索引表：

在这里插入图片描述

这样每一个初始MV在每个方向上的每种步长都会形成一个新的MV，即细化过的MV，该MV包含三个信息，分别是起始点、搜索方向、搜索步长，因此一个初始的MV可以扩展出32个新的MV，这些新的MV也会通过一次运动补偿得到当前CU的预测值。

(3)、在Skip和merge模式下，将所有得到的64个新的预测值之间进行率失真代价比较，最终选择出最优的一种组合作为MMVD的最优的merge候选，我们需要存储该MV的三个信息：分别是其初始MV在merge list中的索引值、移动的方向和搜索步长三个语法元素

三、相关代码的详细分析（VTM8.0）

1.在merge list中选择前两个运动向量作为MMVD的初始向量代码示例

static const int MMVD_BASE_MV_NUM = 2;    //一个全局静态常量，基于MMVD初始向量的个数
//从merge list当中选取两个初始MV
void PU::getInterMMVDMergeCandidates(const PredictionUnit &pu, MergeCtx& mrgCtx, const int& mrgCandIdx)
{
  int refIdxList0, refIdxList1;
  int k;
  int currBaseNum = 0;
  const uint16_t maxNumMergeCand = mrgCtx.numValidMergeCand;

  for (k = 0; k < maxNumMergeCand; k++)
  {
    //只取MRG_TYPE_DEFAULT_N类型候选项
    if (mrgCtx.mrgTypeNeighbours[k] == MRG_TYPE_DEFAULT_N)
    {
      refIdxList0 = mrgCtx.mvFieldNeighbours[(k << 1)].refIdx;
      refIdxList1 = mrgCtx.mvFieldNeighbours[(k << 1) + 1].refIdx;

      if ((refIdxList0 >= 0) && (refIdxList1 >= 0))
      {
        mrgCtx.mmvdBaseMv[currBaseNum][0] = mrgCtx.mvFieldNeighbours[(k << 1)];
        mrgCtx.mmvdBaseMv[currBaseNum][1] = mrgCtx.mvFieldNeighbours[(k << 1) + 1];
      }
      else if (refIdxList0 >= 0)
      {
        mrgCtx.mmvdBaseMv[currBaseNum][0] = mrgCtx.mvFieldNeighbours[(k << 1)];
        mrgCtx.mmvdBaseMv[currBaseNum][1] = MvField(Mv(0, 0), -1);
      }
      else if (refIdxList1 >= 0)
      {
        mrgCtx.mmvdBaseMv[currBaseNum][0] = MvField(Mv(0, 0), -1);
        mrgCtx.mmvdBaseMv[currBaseNum][1] = mrgCtx.mvFieldNeighbours[(k << 1) + 1];
      }
      mrgCtx.mmvdUseAltHpelIf[currBaseNum] = mrgCtx.useAltHpelIf[k];

      currBaseNum++;
      //只取两个base MV
      if (currBaseNum == MMVD_BASE_MV_NUM)
        break;
    }
  }
}

2.对选择的初始运动矢量进行步长和方向的扩展

//设置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，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

  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);  //传进来扩展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->getPicHeader()->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)//若前后参考帧都来自当前帧的时域的同一侧，后向MMVDoffset与前向相等
        {
          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;
  pu.regularMergeFlag = true;
  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;
  pu.cu->imv = mmvdUseAltHpelIf[fPosBaseIdx] ? IMV_HPEL : 0;   //MV使用半像素精度

  pu.cu->BcwIdx = (interDirNeighbours[fPosBaseIdx] == 3) ? BcwIdx[fPosBaseIdx] : BCW_DEFAULT;   //双向参考索引

  for (int refList = 0; refList < 2; refList++)
  {
    if (pu.refIdx[refList] >= 0)
    {
      pu.mv[refList].clipToStorageBitDepth();
    }
  }


  PU::restrictBiPredMergeCandsOne(pu);
}

3.MMVD技术的实现代码

 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列表中
          }
        }
      }

更多关于视频编码知识和资源的分享，更精致的文章排版，欢迎关注博主微信公众号，一起交流、学习、进步！！！
在这里插入图片描述

Cohen_ina
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
VTM3.0代码阅读：MMVD相关的一些类和函数
矛盾统一
12-26 1007
MMVD是在getInterMergeCandidates函数中进行的，同时和普通merge模式以及CIIP模式竞争。 MMVD选择merge列表的前两个MergeMode作为baseMV，然后分别以这两个baseMV为中心，上下左右四个方向，每个方向分别都有8步偏移的MVD。 baseMV加上方向偏移的MVD，就得到了MMVD模式的MVP，然后在这248=64 个MVP中选最优作为MMVD模式的...
H.266/VVC相关技术学习笔记20：帧间预测技术中的MMVD技术（Merge mode with MVD）
Peter_Red_Boy的博客
09-03 3588
今天介绍一下帧间预测技术中的MMVD技术（Merge mode with MVD）,也称带有运动矢量差的融合技术，MMVD也属于基于Merge的技术中的一种，在解码端的语法元素中也属于Merge分支。不过我觉着按严格来讲，MMVD并不属于Merge系列，而更像是inter系列，因为MMVD是要传送MVD到解码端，就这一点来看，MMVD就已经不在Merge范围之内了。下面我来讲解一下MMVD的技术细...
VVC/H.266帧间模式(二)：Merge mode with MVD (MMVD)
Everglow_zbz的博客
11-05 784
一、MMVD综述 在VVC中引入了具有运动矢量差的合并模式（MMVD），merge模式的运动信息将会用于当前CU的预测样值得生成。在传送skip标志和merge标志位之后立刻传送MMVD标志来表明是否对当前CU使用MMVD模式。 在MMVD中，选择完merge候选者后，将通过信号通知的MVD信息进一步完善merge候选者。进一步的信息包括合并候选标记，用于指定运动幅度的索引以及用于指示运动方向的索...
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...
H.266/VVC帧间预测技术学习：带有运动矢量差的Merge技术(Merge mode with MVD)
BigDream123的博客
05-18 1317
在VVC的扩展Merge模式当中，当前CU生成的Merge list中选择一个率失真代价值最小的候选项直接作为自己的运动信息。除了常规Merge模式，VVC还引入了带运动矢量差(Merge mode with MVD)的Merge模式。MMVD是对常规Merge列表的前两个MV进行细化，使预测的MV更加准确，实际上传输的是细化搜索的步长和搜索方向等信息，并没有MVD信息。（这里所谓的MVD应该指的是通过细化常规Merge的MV近似对MV加上MVD） MMVD技术起源于之前提案中的ultimate moti
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件
04-27
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件是视频编码领域的一项重要工具，它基于最新的视频编码标准——Versatile Video Coding（VVC），也被称为H.266。这个软件包的发布是为了支持开发者、研究人员以及业界...
最新视频编码标准（H.266）VVC-Draft10版本，预发布版本！
02-24
最新的视频编码标准，即H.266，又称为Versatile Video Coding (VVC)，是继H.264/AVC和H.265/HEVC之后的下一代编码技术，旨在进一步提高压缩效率，以应对8K超高清视频和互联网流媒体服务的需求增长。本文将深入探讨H....
VVC H.266 360P 60FPS测试片源
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10s 0ms BitRate/String : 507 Kbps BitRate_Maximum/String : 692 ...
VTM块划分代码_块划分；_H.266_statementzbb_VVC_
10-03
在H.266/VVC中，块划分变得更加灵活，允许更细粒度的分割，包括四边形划分和更小的块尺寸，以适应图像内容的复杂性。 VTM是H.266/VVC标准的一个参考模型，提供了标准算法的实现，供研究者和开发者测试和优化新方法...
VVC H.266 4K 60FPS 测试片源
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10 秒 0 毫秒 BitRate/String : 10.0 Mb/s BitRate_Maximum/String : ...
VVC H.266 480P 60FPS测试片源
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10s 0ms BitRate/String : 1007 Kbps BitRate_Maximum/String : 1320 ...
VVC H.266 720P 60FPS测试片源
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10s 0ms BitRate/String : 2008 Kbps BitRate_Maximum/String : 2650 ...
VVC H.266 1080P 60FPS测试片源
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10s 0ms BitRate/String : 4008 Kbps BitRate_Maximum/String : 5196 ...
H266/VVC码流解析器
10-22
Eleard官方的码流解析器
skip类型块（或宏块）没有运动矢量差，但是有残差，只是在编码的时候扔掉了...
wmnmtm的专栏
08-07 722
如果满足以下三个条件则将宏块按 Skip 类型进行编码：（1）最佳模式选择为Inter16×16；（2）MC得到的最终运动矢量等于预测运动矢量，即运动矢量的残差为0；（3）变换系数均被量化为0。--------------------- skip类型块（或宏块）没有运动矢量差，但是有残差，只是在编码的时候扔掉了对于残差的处理在rdo和非rdo下的处理是不一样的在非rdo下，需要对...
AVS3：对称运动矢量差SMVD
Dillon2015的博客
05-09 6426
若当前编码块采用帧间双向预测，并且第一个前向参考帧（记为POC_list0）、第一个后向参考帧（记为POC_list1）和当前帧（记为POC_Cur）满足镜像关系（即满足公式：POC_Cur – POC_list0 = POC_list1 – POC_Cur），则通过传输一个标识符（symmetric mode flag）指示是否采用SMVD模式。对于帧间预测来说，当视频内容较简单时编码残差的比特数可能会较少而编码运动信息的比特数占比可能会变高，此时编码运动信息的码率成为了压缩率的​瓶颈。
VVC编码工具之Inter Prediction
xiangxiazaif的专栏
04-18 1538
声明：本系列博文均为原创，转载请注明出处，谢谢！https://blog.csdn.net/xiangxiazaif/article/details/89375077 1.Extended merge prediction HEVC中，merge候选列表最大值为5（空域4+时域1），候选集为5个空域，2个时域以及候选集总数小于最大值时增加的组合双向预测（只针对B帧）和零MV； VTM4中，mer...
【十六】 H.266/VVC | VVC中帧间预测技术详细总结 | 所有帧间预测技术代码汇总
weixin_45615071的博客
09-14 3349
前言 ​ 帧间预测是影响视频编码性能的关键环节之一，H.266/VVC帧间预测在传统只能应对简单的平移运动的基础上，采用了仿射运动模型，可以描述更加复杂的缩放、旋转等运动。为了更好的发挥合并模式(Merge)的性能，采用了扩展的合并模式、带运动矢量差的合并模式MMVD、子块合并模式、混合帧内帧间CIIP合并模式、三角划分合并模式以及仿射合并模式等，可以有效去除时空相邻块间的冗余。针对双向预测得到的运动矢量，新增光流法、CU级加权、解码端修正等多种修正方法提升运动矢量的精度，降低编码消耗。通过采用更加复杂的.
H.266/VVC 灰度
最新发布
05-19
H.266/VVC是一种新的视频编码标准，全称为High Efficiency Video Coding，中文名为高效视频编码。它是一种用于压缩视频数据的技术，可以将视频数据压缩到更小的文件大小，同时保持高质量的图像和视频。 灰度通常是指一种黑白图像，只有黑色和白色两种颜色。在H.266/VVC编码中，灰度图像可以被视为一种特殊的颜色空间，其中每个像素只有一个亮度值，因此它只需要占用很少的存储空间。H.266/VVC支持各种颜色空间，包括灰度、RGB、YUV等。 相比于以前的视频编码标准，H.266/VVC可以将视频数据压缩到更小的文件大小，同时保持更高的图像和视频质量。这使得它成为一种非常有用的技术，可以用于各种视频应用，如视频流媒体、视频会议、数字电视等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值