H.266/VVC代码学习:xCheckRDCostAffineMerge2Nx2N函数

已于 2022-08-04 22:07:20 修改
阅读量856 收藏 2
点赞数 1
分类专栏： VVC/H.266 文章标签： 视频编码 H.266/VVC
于 2021-06-05 22:02:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigDream123/article/details/117606452
版权

xCheckRDCostAffineMerge2Nx2N函数和xCheckRDCostMerge2Nx2N函数类似，但是过程要比其简单很多。xCheckRDCostAffineMerge2Nx2N函数是用来选出Affine Merge模式中的最佳候选MV。

主要过程如下：

  1. 获取Affine Merge候选列表，Affine Merge候选列表的推导参考：仿射运动补偿预测
  2. 若开启快速Merge模式，根据当前CU的编码信息缩减进行细选的Merge模式数目
    1. 若当前CU最佳模式不是Skip模式，则先遍历可用候选Merge模式，进行运动补偿计算预测值，然后根据SAD和Merge模式比特数更新RD代价列表，如果第i个模式代价 > 第一个模式的代价*MRG_FAST_RATIO(1.25)，则将细选模式数设置为i
    2. 否则，进行细选的模式数为可用的Merge模式数
  3. 进行细选，细选过程和xCheckRDCostMerge2Nx2N的细选过程类似

代码及注释如下：

void EncCu::xCheckRDCostAffineMerge2Nx2N( CodingStructure *&tempCS, CodingStructure *&bestCS, Partitioner &partitioner, const EncTestMode& encTestMode )
{
  if( m_modeCtrl->getFastDeltaQp() )
  {
    return;
  }

  if ( bestCS->area.lumaSize().width < 8 || bestCS->area.lumaSize().height < 8 )
  {
    return;
  }
  m_bestModeUpdated = tempCS->useDbCost = bestCS->useDbCost = false;
  const Slice &slice = *tempCS->slice;

  CHECK( slice.getSliceType() == I_SLICE, "Affine Merge modes not available for I-slices" );

  tempCS->initStructData( encTestMode.qp );

  AffineMergeCtx affineMergeCtx; //Affine Merge上下文
  const SPS &sps = *tempCS->sps;
  if (sps.getMaxNumAffineMergeCand() == 0)
  {
    return;
  }

  setAFFBestSATDCost(MAX_DOUBLE);

  MergeCtx mrgCtx;
  if (sps.getSbTMVPEnabledFlag())
  {
    Size bufSize = g_miScaling.scale( tempCS->area.lumaSize() );
    mrgCtx.subPuMvpMiBuf = MotionBuf( m_SubPuMiBuf, bufSize );
    affineMergeCtx.mrgCtx = &mrgCtx;
  }

  {
    // first get merge candidates 首先获得Merge候选模式
    CodingUnit cu( tempCS->area );
    cu.cs = tempCS;
    cu.predMode = MODE_INTER;
    cu.slice = tempCS->slice;
    cu.tileIdx          = tempCS->pps->getTileIdx( tempCS->area.lumaPos() );
    cu.mmvdSkip = false;

    PredictionUnit pu( tempCS->area );
    pu.cu = &cu;
    pu.cs = tempCS;
    pu.regularMergeFlag = false;
    PU::getAffineMergeCand( pu, affineMergeCtx ); //获得Merge候选模式

    if ( affineMergeCtx.numValidMergeCand <= 0 )
    {
      return;
    }
  }

  bool candHasNoResidual[AFFINE_MRG_MAX_NUM_CANDS];
  for ( uint32_t ui = 0; ui < affineMergeCtx.numValidMergeCand; ui++ )
  {
    candHasNoResidual[ui] = false;
  }

  bool                                        bestIsSkip = false;
  uint32_t                                    uiNumMrgSATDCand = affineMergeCtx.numValidMergeCand;
  PelUnitBuf                                  acMergeBuffer[AFFINE_MRG_MAX_NUM_CANDS];
  static_vector<uint32_t, AFFINE_MRG_MAX_NUM_CANDS>  RdModeList;
  bool                                        mrgTempBufSet = false;

  for ( uint32_t i = 0; i < AFFINE_MRG_MAX_NUM_CANDS; i++ )
  {
    RdModeList.push_back( i );
  }

  if ( m_pcEncCfg->getUseFastMerge() ) //快速Merge模式
  {
    uiNumMrgSATDCand = std::min( NUM_AFF_MRG_SATD_CAND, affineMergeCtx.numValidMergeCand );
    bestIsSkip = false;

    if ( auto blkCache = dynamic_cast<CacheBlkInfoCtrl*>(m_modeCtrl) )
    {
      bestIsSkip = blkCache->isSkip( tempCS->area );
    }

    static_vector<double, AFFINE_MRG_MAX_NUM_CANDS> candCostList;

    // 1. Pass: get SATD-cost for selected candidates and reduce their count 获得所选候选人的SATD费用，并减少其数量
    if ( !bestIsSkip )
    {
      RdModeList.clear();
      mrgTempBufSet = true;
      const double sqrtLambdaForFirstPass = m_pcRdCost->getMotionLambda( );

      CodingUnit &cu = tempCS->addCU( tempCS->area, partitioner.chType );

      partitioner.setCUData( cu );
      cu.slice = tempCS->slice;
      cu.tileIdx          = tempCS->pps->getTileIdx( tempCS->area.lumaPos() );
      cu.skip = false;
      cu.affine = true;
      cu.predMode = MODE_INTER;
      cu.chromaQpAdj = m_cuChromaQpOffsetIdxPlus1;
      cu.qp = encTestMode.qp;

      PredictionUnit &pu = tempCS->addPU( cu, partitioner.chType );

      DistParam distParam;
      const bool bUseHadamard = !tempCS->slice->getDisableSATDForRD();
      m_pcRdCost->setDistParam( distParam, tempCS->getOrgBuf().Y(), m_acMergeBuffer[0].Y(), sps.getBitDepth( CHANNEL_TYPE_LUMA ), COMPONENT_Y, bUseHadamard );

      const UnitArea localUnitArea( tempCS->area.chromaFormat, Area( 0, 0, tempCS->area.Y().width, tempCS->area.Y().height ) );
      // 遍历可用候选Merge模式
      for ( uint32_t uiMergeCand = 0; uiMergeCand < affineMergeCtx.numValidMergeCand; uiMergeCand++ )
      {
        acMergeBuffer[uiMergeCand] = m_acMergeBuffer[uiMergeCand].getBuf( localUnitArea );

        // set merge information
        pu.interDir = affineMergeCtx.interDirNeighbours[uiMergeCand];
        pu.mergeFlag = true;
        pu.regularMergeFlag = false;
        pu.mergeIdx = uiMergeCand;
        cu.affineType = affineMergeCtx.affineType[uiMergeCand];
        cu.BcwIdx = affineMergeCtx.BcwIdx[uiMergeCand];

        pu.mergeType = affineMergeCtx.mergeType[uiMergeCand];
        if ( pu.mergeType == MRG_TYPE_SUBPU_ATMVP )
        {
          pu.refIdx[0] = affineMergeCtx.mvFieldNeighbours[(uiMergeCand << 1) + 0][0].refIdx;
          pu.refIdx[1] = affineMergeCtx.mvFieldNeighbours[(uiMergeCand << 1) + 1][0].refIdx;
          PU::spanMotionInfo( pu, mrgCtx );
        }
        else
        {
          PU::setAllAffineMvField( pu, affineMergeCtx.mvFieldNeighbours[(uiMergeCand << 1) + 0], REF_PIC_LIST_0 );
          PU::setAllAffineMvField( pu, affineMergeCtx.mvFieldNeighbours[(uiMergeCand << 1) + 1], REF_PIC_LIST_1 );

          PU::spanMotionInfo( pu );
        }

        distParam.cur = acMergeBuffer[uiMergeCand].Y();
        // 运动补偿
        m_pcInterSearch->motionCompensation( pu, acMergeBuffer[uiMergeCand], REF_PIC_LIST_X, true, false );

        Distortion uiSad = distParam.distFunc( distParam );
        uint32_t   uiBitsCand = uiMergeCand + 1;
        if ( uiMergeCand == tempCS->picHeader->getMaxNumAffineMergeCand() - 1 )
        {
          uiBitsCand--;
        }
        double cost = (double)uiSad + (double)uiBitsCand * sqrtLambdaForFirstPass;
        updateCandList( uiMergeCand, cost, RdModeList, candCostList
          , uiNumMrgSATDCand );

        CHECK( std::min( uiMergeCand + 1, uiNumMrgSATDCand ) != RdModeList.size(), "" );
      }

      // Try to limit number of candidates using SATD-costs 尽量限制使用SATD Cost的模式数
      for ( uint32_t i = 1; i < uiNumMrgSATDCand; i++ )
      {
        if ( candCostList[i] > MRG_FAST_RATIO * candCostList[0] )
        {
          uiNumMrgSATDCand = i;
          break;
        }
      }

      tempCS->initStructData( encTestMode.qp );
      setAFFBestSATDCost(candCostList[0]);

    }
    else
    {
      uiNumMrgSATDCand = affineMergeCtx.numValidMergeCand;
    }
  }

  uint32_t iteration;
  uint32_t iterationBegin = 0;
  iteration = 2;
  for (uint32_t uiNoResidualPass = iterationBegin; uiNoResidualPass < iteration; ++uiNoResidualPass)
  {
    for ( uint32_t uiMrgHADIdx = 0; uiMrgHADIdx < uiNumMrgSATDCand; uiMrgHADIdx++ )
    {
      uint32_t uiMergeCand = RdModeList[uiMrgHADIdx];

      if ( ((uiNoResidualPass != 0) && candHasNoResidual[uiMergeCand])
        || ((uiNoResidualPass == 0) && bestIsSkip) )
      {
        continue;
      }

      // first get merge candidates
      CodingUnit &cu = tempCS->addCU( tempCS->area, partitioner.chType );

      partitioner.setCUData( cu );
      cu.slice = tempCS->slice;
      cu.tileIdx          = tempCS->pps->getTileIdx( tempCS->area.lumaPos() );
      cu.skip = false;
      cu.affine = true;
      cu.predMode = MODE_INTER;
      cu.chromaQpAdj = m_cuChromaQpOffsetIdxPlus1;
      cu.qp = encTestMode.qp;
      PredictionUnit &pu = tempCS->addPU( cu, partitioner.chType );

      // set merge information
      pu.mergeFlag = true;
      pu.mergeIdx = uiMergeCand;
      pu.interDir = affineMergeCtx.interDirNeighbours[uiMergeCand];
      cu.affineType = affineMergeCtx.affineType[uiMergeCand];
      cu.BcwIdx = affineMergeCtx.BcwIdx[uiMergeCand];

      pu.mergeType = affineMergeCtx.mergeType[uiMergeCand];
      if ( pu.mergeType == MRG_TYPE_SUBPU_ATMVP )
      {
        pu.refIdx[0] = affineMergeCtx.mvFieldNeighbours[(uiMergeCand << 1) + 0][0].refIdx;
        pu.refIdx[1] = affineMergeCtx.mvFieldNeighbours[(uiMergeCand << 1) + 1][0].refIdx;
        PU::spanMotionInfo( pu, mrgCtx );
      }
      else
      {
        PU::setAllAffineMvField( pu, affineMergeCtx.mvFieldNeighbours[(uiMergeCand << 1) + 0], REF_PIC_LIST_0 );
        PU::setAllAffineMvField( pu, affineMergeCtx.mvFieldNeighbours[(uiMergeCand << 1) + 1], REF_PIC_LIST_1 );

        PU::spanMotionInfo( pu );
      }

      if( m_pcEncCfg->getMCTSEncConstraint() && ( !( MCTSHelper::checkMvBufferForMCTSConstraint( *cu.firstPU ) ) ) )
      {
        // Do not use this mode
        tempCS->initStructData( encTestMode.qp );
        return;
      }
      if ( mrgTempBufSet )
      {
        tempCS->getPredBuf().copyFrom(acMergeBuffer[uiMergeCand], true, false);   // Copy Luma Only
        m_pcInterSearch->motionCompensation(pu, REF_PIC_LIST_X, false, true);
      }
      else
      {
        m_pcInterSearch->motionCompensation( pu );
      }

      xEncodeInterResidual( tempCS, bestCS, partitioner, encTestMode, uiNoResidualPass, ( uiNoResidualPass == 0 ? &candHasNoResidual[uiMergeCand] : NULL ) );

      if ( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
      {
        bestIsSkip = bestCS->getCU( partitioner.chType )->rootCbf == 0;
      }
      tempCS->initStructData( encTestMode.qp );
    }// end loop uiMrgHADIdx

    if ( uiNoResidualPass == 0 && m_pcEncCfg->getUseEarlySkipDetection() )
    {
      const CodingUnit     &bestCU = *bestCS->getCU( partitioner.chType );
      const PredictionUnit &bestPU = *bestCS->getPU( partitioner.chType );

      if ( bestCU.rootCbf == 0 )
      {
        if ( bestPU.mergeFlag )
        {
          m_modeCtrl->setEarlySkipDetected();
        }
        else if ( m_pcEncCfg->getMotionEstimationSearchMethod() != MESEARCH_SELECTIVE )
        {
          int absolute_MV = 0;

          for ( uint32_t uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
          {
            if ( slice.getNumRefIdx( RefPicList( uiRefListIdx ) ) > 0 )
            {
              absolute_MV += bestPU.mvd[uiRefListIdx].getAbsHor() + bestPU.mvd[uiRefListIdx].getAbsVer();
            }
          }

          if ( absolute_MV == 0 )
          {
            m_modeCtrl->setEarlySkipDetected();
          }
        }
      }
    }
  }
  if ( m_bestModeUpdated && bestCS->cost != MAX_DOUBLE )
  {
    xCalDebCost( *bestCS, partitioner );
  }
}

涵小呆
关注
专栏目录
视频编码原理技术详解——H.266/VVC
shengyin714959的博客
08-07 63
VVC新增支持全景视频，而全景视频转换为平面视频的投影方式有：经纬图等角投影ERP(Equirectangular Projection)、立方体投影CMP(Cube Map Projection)、八面体投影OHP(Octahedron Projection)、截断金字塔投影SSP(Segmented Sphere Projection)。SCC(Screen Content Coding)，称为屏幕内容编码，包括：帧内块复制、变换跳过模式的残差编码、块差分脉冲编码调制、调色板模式、自适应色度变换。
VTM3.0代码阅读：xCheckRDCostAffineMerge2Nx2N函数
矛盾统一
12-27 515
由于宏JVET_L0632_AFFINE_MERGE默认开启，因此删减了函数中一些无用代码。 xCheckRDCostAffineMerge2Nx2N函数的流程和普通Merge模式的函数流程基本完全一样。都是先获取候模式选列表，然后SATD，再RDO选最优。 Affine_Merge模式要求，块的大小长宽必须都大于8. 其中调用getAffineMergeCand函数获取AffineMerge候选...
H.266/VVC代码学习:xCheckRDCostMerge2Nx2N函数
BigDream123的博客
06-05 1483
xCheckRDCostMerge2Nx2N函数是用来选出Merge模式中最佳的候选MV，根据常规Merge模式、带有运动矢量差的Merge模式(MMVD)以及CIIP模式产生的预测值和原始值得SATD Cost，选出最佳的运动信息。 主要分为以下过程： ① 获取Merge模式候选列表 首先通过getInterMergeCandidates函数和getInterMMVDMergeCandidates函数分别获取常规Merge模式和MMVD模式的候选列表，常规Merge的候选列表推导参考：扩展的Merg
VVC/JEM代码学习16：xCheckRDCostMerge2Nx2N
小小柴的博客
04-01 777
在执行完xCheckRDCostAffineMerge2N*2N函数后，执行此函数，在HEVC中，merge的候选模式个数为5个，在JEM中，候选模式的个数增加到了7个（加了两个额外ATMVP和STMVP推导得到的merge模式）。并且为了加速，先对7个候选模式计算SATD，选取其中4个最小的模式，并且如果在前四个中有模式的代价大于最小SATD的1.25倍，则该模式及其后面模式被取消候选资格。最后...
H.266/VVC代码学习笔记14：xCheckRDCostMerge2Nx2N（）函数
Peter_Red_Boy的博客
10-01 1643
近期学习了一下xCheckRDCostMerge2Nx2N（）函数，这是编码端帧间预测中非常重要的一个函数，该函数类似于帧内的xCheckRDCostIntra（）函数，是对三种Merge模式：regular_Merge、CIIPMerge、MMVD_Merge；进行率失真代价的比较，选出代价最小也就是最优的一种Merge候选。大体上看明白了该函数的流程，简要的讲一下该函数的具体的流程，如下： 1...
VTM10.0代码学习18：xCheckRDCostMerge2Nx2N()
hjhyxq2014的博客
06-29 906
此系列是为了记录自己学习VTM10.0的过程，目前正在看编码端。主要的参考文档有JVET-S2001-vH和JVET-S2002-v1。由于本人水平有限，出现的错误恳请大家指正。如果觉得我的文章对您有帮助的话，不妨点赞收藏加关注，谢谢！！ 本篇博文就是这个系列的最后一篇了，从开始看VTM到现在差不多9个月，之中断断续续地把VTM的主干大致过了一遍，虽然有很多部分都略过未看，但也对VVC有了大致的认识，算得上是实现开始更新这个系列时的初心。之后如果没有找到想跟大家分享的内容，应该就是无期停更了。欢迎大家.
最新通用视频编码标准H.266VVC.pdf
11-28
《H.266/VVC 视频编码标准详解》 在数字媒体技术飞速发展的今天，视频编码标准不断演进以满足日益增长的高清、超高清以及虚拟现实等应用场景的需求。H.266，又称为Versatile Video Coding（VVC），是继H.264/AVC和H...
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:原理、标准与实现电子书
最新发布
01-04
新一代通用视频编码H.266/VVC是一种用于视频压缩和编码的标准，旨在提供更高的压缩效率和更好的视频质量。该标准基于先前的H.265/HEVC标准，但引入了许多新的技术和算法以提高性能。H.266/VVC的主要原理是通过有效地...
新一代通用视频编码h.266/vvc:原理、标准与实现 pdf
10-25
H.266/VVC（Versatile Video Coding）是一种新一代的通用视频编码标准。它的目标是在保证视频质量的同时，实现更高的压缩率，以降低视频传输和存储的成本。 H.266/VVC采用了一系列先进的视频编码技术，包括运动估计...
H266/VVC码流解析器
10-22
Eleard官方的码流解析器
[VTM19.0代码阅读] xCheckRDCostMerge2Nx2N
stylexf的博客
03-31 327
【代码】[VTM19.0代码阅读] xCheckRDCostMerge2Nx2N。
TEncCu::xCheckRDCostMerge2Nx2N
mashiying2013的专栏
08-19 1497
VoidTEncCu::xCheckRDCostMerge2Nx2N( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, Bool *earlyDetectionSkipMode ) {   assert( rpcTempCU->getSlice()->getSliceType() !=I_SLICE ); //确定该片是P Sli
HM16.0之帧间Merge模式——xCheckRDCostMerge2Nx2N
weixin_30507481的博客
06-10 173
参考：https://blog.csdn.net/nb_vol_1/article/details/51163625 1、源代码： /** check RD costs for a CU block encoded with merge * \param rpcBestCU * \param rpcTempCU * \returns Void */ Void TEncCu...
VTM1.0代码阅读：xCheckRDCostMerge2Nx2N函数
矛盾统一
12-26 311
xCheckRDCostMerge2Nx2N在xCompressCU函数中调用，用来进行Merge模式的计算。skip模式相较于Merge模式，不向解码端发送残差系数。 首先由getInterMergeCandidates获取merge候选模式信息，存储于mergeCtx； 如果不进行fastMerge，则跳过SATD直接进行RDO选最优； fastMerge时，对7个merge候选模式进行SAT...
HEVC代码学习31：xCheckRDCostMerge2Nx2N函数
慢慢积累
11-16 2728
推荐阅读 http://blog.csdn.net/nb_vol_1/article/details/51163625 http://blog.csdn.net/guoyaoyao1990/article/details/35339717 今天来学习HM中merge部分的代码，其入口函数为xCheckRDCostMerge2Nx2N。 这里需要注意的是，merge是借用空间邻近块的MV作为
VTM3.0代码阅读：xCheckRDCostMerge2Nx2N函数
矛盾统一
12-26 555
xCheckRDCostMerge2Nx2N在xCompressCU函数中调用，用来测试Merge模式、mmvd模式以及CIIP模式。 首先由getInterMergeCandidates获取merge候选模式信息，存储于，mergeCtx。同时由merge列表获取MMVD模式的两个baseMV。 如果不进行fastMerge，则跳过SATD直接进行RDO选最优 fastMerge时，对7个mer...
VVC/JEM代码学习15：xCheckRDCostAffineMerge2Nx2N
小小柴的博客
04-01 832
Affine模式是JEM中新加的，属于帧间预测，与FRUC,merge,inter形成竞争关系。#if COM16_C1016_AFFINE Void TEncCu::xCheckRDCostAffineMerge2Nx2N( TComDataCU*&amp; rpcBestCU, TComDataCU*&amp; rpcTempCU ) { assert( rpcTempCU-&gt;ge...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值