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

最新推荐文章于 2022-04-28 15:31:12 发布
最新推荐文章于 2022-04-28 15:31:12 发布
阅读量1.3k 收藏 6
点赞数
分类专栏： VVC/H.266 文章标签： 视频编码 H.266/VVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigDream123/article/details/118364243
版权

motionCompensation函数是根据之前得到的MV，进行运动补偿，得到当前块的预测值。

在运动估计中，得到的MV是亚像素精度的，而参考图像是整像素的，亚像素位置上是没有值的。如果通过MV找到的参考块是非整像素位置的，那么在参考图像上是没有这个参考块的。首先需要对参考图像进行插值，构造亚像素参考块。得到的这个参考块作为最终的预测块。

motionCompensation函数调用的函数如下图所示，所调用的各函数的作用如下：

  • xPredInterUni 单向预测
    • xPredInterBlk：非Affine模式产生运动补偿块（进行插值得到预测块）
    • xPredAffineBlk：Affine模式产生运动补偿块
  • xSubPuBio：当应用BDOF且不满足DMVR条件时且PU宽度或者高度大于16时，调用该函数，然后将PU分为多个子PU进行运动补偿，执行BDOF修正
  • xSubPuMC：当PU是ATMVP模式时，调用该函数，将PU分为多个子PU进行运动补偿
  • xPredInterBi：双向预测，即分别进行两次单向预测，然后将其进行加权。在函数内部会判断是否进行DMVR、BDOF、BCW、WP
    • xWeightedPredictionBi：对于B帧，双向加权预测
    • xWeightedPredictionUni：P帧，单向加权预测
    • xProcessDMVR：进行DMVR细化操作
    • xWeightedAverage：
      • addWeightedAvg：CU级双向加权预测 BCW
      • applyBiOptFlow：应用BDOF技术

void InterPrediction::motionCompensation( PredictionUnit &pu, PelUnitBuf &predBuf, const RefPicList &eRefPicList
  , const bool luma, const bool chroma
  , PelUnitBuf* predBufWOBIO /*= NULL*/
)
{
  // Note: there appears to be an interaction with weighted prediction that
  // makes the code follow different paths if chroma is on or off (in the encoder).
  // Therefore for 4:0:0, "chroma" is not changed to false.
  CHECK(predBufWOBIO && pu.ciipFlag, "the case should not happen!");

  if (!pu.cs->pcv->isEncoder)
  {
    if (CU::isIBC(*pu.cu))
    {
      CHECK(!luma, "IBC only for Chroma is not allowed.");
      xIntraBlockCopy(pu, predBuf, COMPONENT_Y);
      if (chroma && isChromaEnabled(pu.chromaFormat))
      {
        xIntraBlockCopy(pu, predBuf, COMPONENT_Cb);
        xIntraBlockCopy(pu, predBuf, COMPONENT_Cr);
      }
      return;
    }
  }
  // dual tree handling for IBC as the only ref
  if ((!luma || !chroma) && eRefPicList == REF_PIC_LIST_0)
  {
    xPredInterUni(pu, eRefPicList, predBuf, false, false, luma, chroma);
    return;
  }
  // else, go with regular MC below
        CodingStructure &cs = *pu.cs;
  const PPS &pps            = *cs.pps;
  const SliceType sliceType =  cs.slice->getSliceType();

  if( eRefPicList != REF_PIC_LIST_X ) //指明了pu的参考列表，单向预测
  {
    CHECK(predBufWOBIO != NULL, "the case should not happen!");
    if ((CU::isIBC(*pu.cu) == false) && ((sliceType == P_SLICE && pps.getUseWP()) || (sliceType == B_SLICE && pps.getWPBiPred())))
    {
      //使用加权预测
      xPredInterUni(pu, eRefPicList, predBuf, true, false, luma, chroma);
      xWeightedPredictionUni(pu, predBuf, eRefPicList, predBuf, -1, m_maxCompIDToPred, (luma && !chroma),
                             (!luma && chroma));//单向加权预测
    }
    else
    {
      xPredInterUni(pu, eRefPicList, predBuf, false, false, luma, chroma);//单向预测
    }
  }
  else //双向预测
  {
    CHECK( !pu.cu->affine && pu.refIdx[0] >= 0 && pu.refIdx[1] >= 0 && ( pu.lwidth() + pu.lheight() == 12 ), "invalid 4x8/8x4 bi-predicted blocks" );
    int refIdx0 = pu.refIdx[REF_PIC_LIST_0];
    int refIdx1 = pu.refIdx[REF_PIC_LIST_1];

    const WPScalingParam *wp0 = pu.cs->slice->getWpScaling(REF_PIC_LIST_0, refIdx0);
    const WPScalingParam *wp1 = pu.cs->slice->getWpScaling(REF_PIC_LIST_1, refIdx1);

    bool bioApplied = false;
    const Slice &slice = *pu.cs->slice;
    if (pu.cs->sps->getBDOFEnabledFlag() && (!pu.cs->picHeader->getDisBdofFlag()))
    {
      if (pu.cu->affine || m_subPuMC)
      {
        bioApplied = false;
      }
      else
      {
        const bool biocheck0 =
          !((WPScalingParam::isWeighted(wp0) || WPScalingParam::isWeighted(wp1)) && slice.getSliceType() == B_SLICE);
        const bool biocheck1 = !(pps.getUseWP() && slice.getSliceType() == P_SLICE);
        if (biocheck0
          && biocheck1
          && PU::isBiPredFromDifferentDirEqDistPoc(pu)
          && (pu.Y().height >= 8)
          && (pu.Y().width >= 8)
          && ((pu.Y().height * pu.Y().width) >= 128)
          )
        {
          bioApplied = true;
        }
      }

      if (bioApplied && pu.ciipFlag)
      {
        bioApplied = false;
      }

      if (bioApplied && pu.cu->smvdMode)
      {
        bioApplied = false;
      }
      if (pu.cu->cs->sps->getUseBcw() && bioApplied && pu.cu->BcwIdx != BCW_DEFAULT)
      {
        bioApplied = false;
      }
      if (pu.mmvdEncOptMode == 2 && pu.mmvdMergeFlag)
      {
        bioApplied = false;
      }
    }

    bool refIsScaled = ( refIdx0 < 0 ? false : pu.cu->slice->getRefPic( REF_PIC_LIST_0, refIdx0 )->isRefScaled( pu.cs->pps ) ) ||
                       ( refIdx1 < 0 ? false : pu.cu->slice->getRefPic( REF_PIC_LIST_1, refIdx1 )->isRefScaled( pu.cs->pps ) );
    bioApplied = refIsScaled ? false : bioApplied;
    bool dmvrApplied = false;
    dmvrApplied = (pu.mvRefine) && PU::checkDMVRCondition(pu);
    // 应用BDOF且不使用DMVR且PU宽度或者高度大于16且不是ATMVP模式
    if ((pu.lumaSize().width > MAX_BDOF_APPLICATION_REGION || pu.lumaSize().height > MAX_BDOF_APPLICATION_REGION) && pu.mergeType != MRG_TYPE_SUBPU_ATMVP && (bioApplied && !dmvrApplied))
    {
      xSubPuBio(pu, predBuf, eRefPicList, predBufWOBIO);
    }
    else
    {
      if (pu.mergeType != MRG_TYPE_DEFAULT_N && pu.mergeType != MRG_TYPE_IBC)
      {
        // MRG_TYPE_SUBPU_ATMVP
        CHECK(predBufWOBIO != NULL, "the case should not happen!");
        xSubPuMC(pu, predBuf, eRefPicList, luma, chroma);
      }
      else if (xCheckIdenticalMotion(pu)) //如果前后两个方向的参考poc相同，mv相同，则归为单向处理
      {
        xPredInterUni(pu, REF_PIC_LIST_0, predBuf, false, false, luma, chroma);
        if (predBufWOBIO)
          predBufWOBIO->copyFrom(predBuf, (luma && !chroma), (chroma && !luma));
      }
      else
      {
        xPredInterBi(pu, predBuf, luma, chroma, predBufWOBIO);//双向预测，其中会判断是否进行DMVR、BDOF、BCW、WP
      }
    }
  }
  return;
}
//单向预测的运动补偿算法
//xPredInterUni调用xPredInterBlk函数进行pu的每个通道的预测像素的获取
void InterPrediction::xPredInterUni(const PredictionUnit &pu, const RefPicList &eRefPicList, PelUnitBuf &pcYuvPred,
                                    const bool &bi, const bool &bioApplied, const bool luma, const bool chroma)
{
  const SPS &sps = *pu.cs->sps;

  int iRefIdx = pu.refIdx[eRefPicList];
  Mv mv[3];
  bool isIBC = false;
  CHECK( !CU::isIBC( *pu.cu ) && pu.lwidth() == 4 && pu.lheight() == 4, "invalid 4x4 inter blocks" );
  if (CU::isIBC(*pu.cu))
  {
    isIBC = true;
  }
  if( pu.cu->affine ) //Affine模式
  {
    CHECK( iRefIdx < 0, "iRefIdx incorrect." );

    mv[0] = pu.mvAffi[eRefPicList][0]; //Affine模式时运动补偿用到mv为控制点mv
    mv[1] = pu.mvAffi[eRefPicList][1];
    mv[2] = pu.mvAffi[eRefPicList][2];
  }
  else
  {
    mv[0] = pu.mv[eRefPicList];//非Affine模式时，运动补偿所用mv为之前merge、inter_ME等获取的
  }

  if( !pu.cu->affine )
  {
    if( !isIBC && pu.cu->slice->getRefPic( eRefPicList, iRefIdx )->isRefScaled( pu.cs->pps ) == false )
    {
      if( !pu.cs->pps->getWrapAroundEnabledFlag() )
      {
        clipMv( mv[0], pu.cu->lumaPos(), pu.cu->lumaSize(), sps, *pu.cs->pps );
      }
    }
  }

  for( uint32_t comp = COMPONENT_Y; comp < pcYuvPred.bufs.size() && comp <= m_maxCompIDToPred; comp++ )
  {
    const ComponentID compID = ComponentID( comp );
    if (compID == COMPONENT_Y && !luma)
    {
      continue;
    }
    if (compID != COMPONENT_Y && !chroma)
    {
      continue;
    }
    if ( pu.cu->affine ) //Affine模式
    {
      CHECK( bioApplied, "BIO is not allowed with affine" );
      m_iRefListIdx = eRefPicList;
      bool genChromaMv = (!luma && chroma && compID == COMPONENT_Cb);
      //Affine模式pu块的运动补偿，获取pu块的预测像素
      xPredAffineBlk( compID, pu, pu.cu->slice->getRefPic( eRefPicList, iRefIdx )->unscaledPic, mv, pcYuvPred, bi, pu.cu->slice->clpRng( compID ), genChromaMv, pu.cu->slice->getScalingRatio( eRefPicList, iRefIdx ));
    }
    else
    {
      if (isIBC)
      {
        xPredInterBlk(compID, pu, pu.cu->slice->getPic(), mv[0], pcYuvPred, bi, pu.cu->slice->clpRng(compID),
                      bioApplied, isIBC);
      }
      else
      {
        //非Affine模式pu块的每个通道，进行运动补偿，获取pu预测像素
        xPredInterBlk( compID, pu, pu.cu->slice->getRefPic( eRefPicList, iRefIdx )->unscaledPic, mv[0], pcYuvPred, bi, pu.cu->slice->clpRng( compID ), bioApplied, isIBC, pu.cu->slice->getScalingRatio( eRefPicList, iRefIdx ) );
      }
    }
  }
}

//双向预测的运动补偿算法
//双向运动补偿，可以看做是分别进行前向运动补偿和后向运动补偿，分别获得前向的预测像素和后向的预测像素
//之后分情况进行加权预测
void InterPrediction::xPredInterBi(PredictionUnit &pu, PelUnitBuf &pcYuvPred, const bool luma, const bool chroma, PelUnitBuf *yuvPredTmp /*= NULL*/)
{
  const PPS   &pps   = *pu.cs->pps;
  const Slice &slice = *pu.cs->slice;
  CHECK( !pu.cu->affine && pu.refIdx[0] >= 0 && pu.refIdx[1] >= 0 && ( pu.lwidth() + pu.lheight() == 12 ), "invalid 4x8/8x4 bi-predicted blocks" );

  int refIdx0 = pu.refIdx[REF_PIC_LIST_0];
  int refIdx1 = pu.refIdx[REF_PIC_LIST_1];

  const WPScalingParam *wp0 = pu.cs->slice->getWpScaling(REF_PIC_LIST_0, refIdx0);
  const WPScalingParam *wp1 = pu.cs->slice->getWpScaling(REF_PIC_LIST_1, refIdx1);

  bool bioApplied = false; //BDOF应用标志
  if (pu.cs->sps->getBDOFEnabledFlag() && (!pu.cs->picHeader->getDisBdofFlag()))
  {
    if (pu.cu->affine || m_subPuMC)
    {
      bioApplied = false;
    }
    else
    {
      const bool biocheck0 =
        !((WPScalingParam::isWeighted(wp0) || WPScalingParam::isWeighted(wp1)) && slice.getSliceType() == B_SLICE);
      const bool biocheck1 = !(pps.getUseWP() && slice.getSliceType() == P_SLICE);
      if (biocheck0
        && biocheck1
        && PU::isBiPredFromDifferentDirEqDistPoc(pu)
        && (pu.Y().height >= 8)
        && (pu.Y().width >= 8)
        && ((pu.Y().height * pu.Y().width) >= 128)
       )
      {
        bioApplied = true;
      }
    }

    if (bioApplied && pu.ciipFlag)
    {
      bioApplied = false;
    }

    if (bioApplied && pu.cu->smvdMode)
    {
      bioApplied = false;
    }

    if (pu.cu->cs->sps->getUseBcw() && bioApplied && pu.cu->BcwIdx != BCW_DEFAULT)
    {
      bioApplied = false;
    }
  } //判断是否使用BDOF
  if (pu.mmvdEncOptMode == 2 && pu.mmvdMergeFlag)
  {
    bioApplied = false;
  }
  bool dmvrApplied = false;
  dmvrApplied = (pu.mvRefine) && PU::checkDMVRCondition(pu);

  bool refIsScaled = ( refIdx0 < 0 ? false : pu.cu->slice->getRefPic( REF_PIC_LIST_0, refIdx0 )->isRefScaled( pu.cs->pps ) ) ||
                     ( refIdx1 < 0 ? false : pu.cu->slice->getRefPic( REF_PIC_LIST_1, refIdx1 )->isRefScaled( pu.cs->pps ) );
  dmvrApplied = dmvrApplied && !refIsScaled;
  bioApplied = bioApplied && !refIsScaled;

  //前后向两次单向补偿，合起来就是双向预测运动补偿
  for (uint32_t refList = 0; refList < NUM_REF_PIC_LIST_01; refList++)
  {
    if( pu.refIdx[refList] < 0)
    {
      continue;
    }

    RefPicList eRefPicList = (refList ? REF_PIC_LIST_1 : REF_PIC_LIST_0);

    CHECK(CU::isIBC(*pu.cu) && eRefPicList != REF_PIC_LIST_0, "Invalid interdir for ibc mode");
    CHECK(CU::isIBC(*pu.cu) && pu.refIdx[refList] != MAX_NUM_REF, "Invalid reference index for ibc mode");
    CHECK((CU::isInter(*pu.cu) && pu.refIdx[refList] >= slice.getNumRefIdx(eRefPicList)), "Invalid reference index");
    m_iRefListIdx = refList;
    // 单向运动补偿获得的前向和后向预测像素，存储于m_acYuvPred
    PelUnitBuf pcMbBuf = ( pu.chromaFormat == CHROMA_400 ?
                           PelUnitBuf(pu.chromaFormat, PelBuf(m_acYuvPred[refList][0], pcYuvPred.Y())) :
                           PelUnitBuf(pu.chromaFormat, PelBuf(m_acYuvPred[refList][0], pcYuvPred.Y()), PelBuf(m_acYuvPred[refList][1], pcYuvPred.Cb()), PelBuf(m_acYuvPred[refList][2], pcYuvPred.Cr())) );

    if (pu.refIdx[0] >= 0 && pu.refIdx[1] >= 0) //pu的前后向预测皆可用
    {
      if (dmvrApplied)
      {
        if (yuvPredTmp)
        {
          xPredInterUni(pu, eRefPicList, pcMbBuf, true, false, luma, chroma);//单向运动补偿
        }
        continue;
      }
      xPredInterUni(pu, eRefPicList, pcMbBuf, true, bioApplied, luma, chroma);
    }
    else //单向预测
    {
      if( ( (pps.getUseWP() && slice.getSliceType() == P_SLICE) || (pps.getWPBiPred() && slice.getSliceType() == B_SLICE) ) )
      {
        xPredInterUni(pu, eRefPicList, pcMbBuf, true, bioApplied, luma, chroma);
      }
      else
      {
        xPredInterUni(pu, eRefPicList, pcMbBuf, pu.cu->geoFlag, bioApplied, luma, chroma);
      }
    }
  }
  //m_acYuvPred中存储的，就是前面通过单向运动补偿获得的前向和后向预测像素
  //srcPred0为前向运动补偿的预测像素，srcPred1为后向运动补偿的预测像素
  CPelUnitBuf srcPred0 = ( pu.chromaFormat == CHROMA_400 ?
                           CPelUnitBuf(pu.chromaFormat, PelBuf(m_acYuvPred[0][0], pcYuvPred.Y())) :
                           CPelUnitBuf(pu.chromaFormat, PelBuf(m_acYuvPred[0][0], pcYuvPred.Y()), PelBuf(m_acYuvPred[0][1], pcYuvPred.Cb()), PelBuf(m_acYuvPred[0][2], pcYuvPred.Cr())) );
  CPelUnitBuf srcPred1 = ( pu.chromaFormat == CHROMA_400 ?
                           CPelUnitBuf(pu.chromaFormat, PelBuf(m_acYuvPred[1][0], pcYuvPred.Y())) :
                           CPelUnitBuf(pu.chromaFormat, PelBuf(m_acYuvPred[1][0], pcYuvPred.Y()), PelBuf(m_acYuvPred[1][1], pcYuvPred.Cb()), PelBuf(m_acYuvPred[1][2], pcYuvPred.Cr())) );
  const bool lumaOnly   = luma && !chroma;
  const bool chromaOnly = !luma && chroma;
  // 加权预测
  if( !pu.cu->geoFlag && (!dmvrApplied) && (!bioApplied) && pps.getWPBiPred() && slice.getSliceType() == B_SLICE && pu.cu->BcwIdx == BCW_DEFAULT)
  {
    //B帧且采用加权预测时，双向加权预测
    xWeightedPredictionBi( pu, srcPred0, srcPred1, pcYuvPred, m_maxCompIDToPred, lumaOnly, chromaOnly );
    if (yuvPredTmp)
    {
      yuvPredTmp->copyFrom(pcYuvPred);
    }
  }
  else if( !pu.cu->geoFlag && pps.getUseWP() && slice.getSliceType() == P_SLICE )
  {
    //P帧且采用加权预测时，单向加权预测
    xWeightedPredictionUni( pu, srcPred0, REF_PIC_LIST_0, pcYuvPred, -1, m_maxCompIDToPred, lumaOnly, chromaOnly );
    if (yuvPredTmp)
    {
      yuvPredTmp->copyFrom(pcYuvPred);
    }
  }
  else
  {
    if (dmvrApplied)
    {
      if (yuvPredTmp)
      {
        yuvPredTmp->addAvg(srcPred0, srcPred1, slice.clpRngs(), false);
      }
      xProcessDMVR(pu, pcYuvPred, slice.clpRngs(), bioApplied);
    }
    else
    {
      // BCW CU级双向加权预测 BDOF
      xWeightedAverage( pu, srcPred0, srcPred1, pcYuvPred, slice.getSPS()->getBitDepths(), slice.clpRngs(), bioApplied, lumaOnly, chromaOnly, yuvPredTmp );
    }
  }
}

涵小呆
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
windows平台x265的编译流程
小金牛来了
08-26 1405
windows平台x265的编译流程
H.266/VVC帧间预测技术学习:双向光流技术(Bi-directional optical flow, BDOF)
BigDream123的博客
05-25 2984
双向光流技术(Bi-directional optical flow，BDOF ) VVC中采用了双向光流技术来修正双向预测的像素值。BDOF以前被称为BIO，包含在JEM参考软件中。与JEM中的版本相比，VVC中的BDOF是一个更简单的版本，计算复杂度更低，特别是在乘法次数和乘法器的大小方面。 BDOF仅应用于亮度分量。 顾名思义，BDOF模式基于光流概念，该概念假定对象的运动是平滑的。 BDOF用于修正CU的4×4子块的双向预测信号。对于每个4×4子块，通过最小化L0和L1预测像素之间的差异来计算运
VTM3.0代码阅读：motionCompensation函数
矛盾统一
12-26 976
motionCompensation运动补偿，在帧间模式(merge和inter_ME)中，根据之前获取到的Qter精度的mv，就能在参考帧中得到pu的参考块，在pu的参考块位置处，通过亚像素插值来得到亚像素位置的pu的预测像素pred。 总之，MC运动补偿，就是根据运动向量mv，得到当前pu的预测像素。 motionCompensation调用了xPredInterUni函数进行单向预测的运动补...
HTM-16.2代码（7）——motionCompensation
Eyrane的博客
12-28 1018
运动补偿MC——motionCompensation （1） iPartIdx &gt;= 0，对索引为iPartIdx的PU进行操作 1）不使用VSP a.对某一参考列表list0或list1（单向），判断是否进行加权预测。 b.对某一参考列表list0和list1（双向），判断是否SPIVMP I）进行SPIVMP II）只考虑时...
SAGE算法代码matlab-motion_compensation:运动补偿
06-02
SAGE算法代码matlab 运动补偿 CL Chen、L. Hermans、MC Viswanathan、D. Fortun、M. Unser、A. Cammarato、MH Dickinson 和P.拉姆迪亚。 该代码仅供科学或个人使用。 如何安装 安装MIJ库（）：复制MATLAB的java文件夹下的ij.jar和mij.jar文件（应该是/path/to/MATLAB/java/jar/ ，例如： /usr/local/MATLAB/R2018a/java/jar/ ）。 请注意，它需要 MATLAB Compiler 和 Parallel Computing Toolbox（都可以通过 MATLAB 安装程序安装） 克隆存储库： git clone https://github.com/NeLy-EPFL/motion_compensation 输入： cd motion_compensation 使用目录中的以下命令编译深度匹配代码： cd code/external/deepmatching_1.2.2_c++_mac/或cd code/external/deepmatc
VTM1.0代码阅读：motionCompensation函数
矛盾统一
12-26 373
motionCompensation运动补偿，在帧间模式(merge和inter_ME)中，根据之前获取到的Qter精度的mv，就能在参考帧中得到pu的参考块，在pu的参考块位置处，通过亚像素插值来得到亚像素位置的pu的预测像素pred。 总之，MC运动补偿，就是根据运动向量mv，得到当前pu的预测像素。 motionCompensation调用了xPredInterUni函数进行单向预测的运动补...
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.266VVC.pdf
11-28
《H.266/VVC 视频编码标准详解》 在数字媒体技术飞速发展的今天，视频编码标准不断演进以满足日益增长的高清、超高清以及虚拟现实等应用场景的需求。H.266，又称为Versatile Video Coding（VVC），是继H.264/AVC和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 ...
最新视频编码标准（H.266）VVC-Draft10版本，预发布版本！
02-24
2. **增强的预测技术**：H.266/VVC采用了新的预测模式，包括角度自适应预测、跨块预测和基于深度学习的预测等。这些模式能更准确地估计像素的运动和变化，减少编码过程中的信息损失。 3. **变换和量化优化**：H.266...
VTM块划分代码_块划分；_H.266_statementzbb_VVC_
10-03
3. **块大小的灵活性**：H.266/VVC支持从最小4x4到最大128x128的块大小，甚至允许非矩形的四边形划分。这种灵活性有助于更好地适应图像内容的细节变化。 4. **变换和量化**：块划分后的像素值会经过离散余弦变换...
HEVC代码学习14：motionCompensation函数
慢慢积累
05-24 5606
今天来看运动补偿，推荐两篇博文： http://blog.csdn.net/hevc_cjl/article/details/8457642 http://blog.csdn.net/nb_vol_1/article/details/55253979 运动补偿的功能是根据之前的局部图像来预测补偿当前的局部图像。而实际代码来看，主要完成的是亚像素插值补偿的工作。在运动估计中，得到的MV是亚像素精
运动估计运动补偿（Motion estimation and motion compensation，MEMC）入门总结
longshaonihaoa的博客
04-28 6560
本文不生产内容， 本文制作内容的搬运工，希望通过本文系统性的整理，能够让您对该领域具有整体的认识。认准原创 文章将按照以下目录展开：
H266：xCheckRdCostInter（）到xPredInterUni（）流程
Moomin的博客
04-16 770
rpcTempCU-&gt;setICFlagSubParts(bICFlag, 0, uiDepth); xCheckRDCostInter() Bool bICFlag = rpcTempCU-&gt;getICFlag( 0 ); if( bIMV &amp;&amp; pcCUInfo2Reuse != NULL )//若信息可以重复使用，则无需进行帧间预测 { rpcTempCU-&...
AV1标准特色编码工具简介
Aidoneus_y
02-19 5046
文章目录1. 编码单元划分结构2. 帧内预测技术3. 帧间预测技术4. 变换5. 环内滤波和编码后处理 作为新一代性能优异的开源编码标准，AV1收到越来越多企业的青睐。AV1编码标准继承自Google在2011年构建VP8及2013年的VP9标准，有谷歌等30多家企业在2015年成立的开放媒体联盟（Alliance for Open Media， AOM）进行开发和维护，并在2018年6月发布了...
H.266/VVC代码学习:xPatternSearchFracDIF函数
BigDream123的博客
06-29 1008
xPatternSearchFracDIF函数是用于由xMotionEstimation函数调用，进行亚像素运动估计。主要是进行1/2像素插值，搜索，得到1/2像素精度MV；再进行1/4像素插值，搜索得到1/4像素精度MV。 代码及注释如下： void InterSearch::xPatternSearchFracDIF( const PredictionUnit& pu, RefPicList eRefPicList, int
HEVC官方软件HM源代码简单分析-解码器TAppDecoder
热门推荐
雷霄骅(leixiaohua1020)的专栏
11-23 5万+
本文记录HEVC官方参考软件HM的源代码结构。HM相比于JM来说，采用了面向对象的编程方法，因而结构相对更加清晰。HM包含了视频解码器TAppDecoder和视频编码器TAppEncoder。本文记录视频解码器TAppDecoder的结构。函数调用关系图HM中的HEVC视频解码器TAppDecoder的函数调用关系图如下所示。单击查看更清晰的大图下面解释一下图中关键标记的含义。函数背景色函数在图中
VTM3.0代码阅读：Affine模式运动补偿时xPredAffineBlk函数
矛盾统一
12-27 704
xPredAffineBlk函数在pu块的运动补偿的时候被调用，处理Affine模式时的运动补偿任务，根据控制点运动信息CPMVP获取预测像素pred。 _mv为affine模式2或3个控制点的CPMVP，dstPic为需要得到的Affine模式预测像素。 运动补偿函数见：VTM3.0代码阅读：motionCompensation函数 void InterPrediction::xPredAff...
深入剖析H.264帧间预测(P宏块)
认知 行动 坚持
10-26 1万+
工具：foreman_qcif.yuv, JM8.6, H.264visa. 下面仅讨论P宏块的亮度Y分量，为简便起见，只讨论整数像素. 步骤1：用JM8.6编码foreman_qcif.yuv的3帧(IPP), 得到test.264,用H.264visa打开test.264. 在第二帧中，用H.264visa选中第4行的第9个宏块（宏块共有9行11列)，在H.264visa中该宏块位置显
H.266/VVC 灰度
最新发布
05-19
H.266/VVC是一种新的视频编码标准，全称为High Efficiency Video Coding，中文名为高效视频编码。它是一种用于压缩视频数据的技术，可以将视频数据压缩到更小的文件大小，同时保持高质量的图像和视频。 灰度通常是指一种黑白图像，只有黑色和白色两种颜色。在H.266/VVC编码中，灰度图像可以被视为一种特殊的颜色空间，其中每个像素只有一个亮度值，因此它只需要占用很少的存储空间。H.266/VVC支持各种颜色空间，包括灰度、RGB、YUV等。 相比于以前的视频编码标准，H.266/VVC可以将视频数据压缩到更小的文件大小，同时保持更高的图像和视频质量。这使得它成为一种非常有用的技术，可以用于各种视频应用，如视频流媒体、视频会议、数字电视等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值