VVC代码阅读 xCompressCU(2) do while结构 最后面有两小段函数没看

已于 2022-06-06 12:00:47 修改
阅读量654 收藏 3
点赞数 2
分类专栏： 视频编解码 文章标签： c++
于 2022-04-20 10:24:33 首次发布
好
本文链接：https://blog.csdn.net/dfhg54/article/details/124265950
版权

H.266/VVC代码学习：xCompressCU函数_涵小呆的博客-CSDN博客

尝试当前编码器各种可用的模式：如skip，帧间，帧内，PCM等，进行预测及划分。

do
{
} while( m_modeCtrl->nextMode( *tempCS, partitioner ) );

for (int i = compBegin; i < (compBegin + numComp); i++)
    {
      ComponentID comID = jointPLT ? (ComponentID)compBegin : ((i > 0) ? COMPONENT_Cb : COMPONENT_Y);
      tempCS->prevPLT.curPLTSize[comID] = curLastPLTSize[comID];
      memcpy(tempCS->prevPLT.curPLT[i], curLastPLT[i], curLastPLTSize[comID] * sizeof(Pel));
    }
    EncTestMode currTestMode = m_modeCtrl->currTestMode();
    currTestMode.maxCostAllowed = maxCostAllowed;

for循环:遍历分量，将 PLT 的相关变量填充。当前帧未使用PLT，先跳过

currTestMode：当前要测试的模式

maxCostAllowed：当前测试模式允许的最大cost


    if (pps.getUseDQP() && partitioner.isSepTree(*tempCS) && isChroma( partitioner.chType ))
    {
      const Position chromaCentral(tempCS->area.Cb().chromaPos().offset(tempCS->area.Cb().chromaSize().width >> 1, tempCS->area.Cb().chromaSize().height >> 1));
      const Position lumaRefPos(chromaCentral.x << getComponentScaleX(COMPONENT_Cb, tempCS->area.chromaFormat), chromaCentral.y << getComponentScaleY(COMPONENT_Cb, tempCS->area.chromaFormat));
      const CodingStructure* baseCS = bestCS->picture->cs;
      const CodingUnit* colLumaCu = baseCS->getCU(lumaRefPos, CHANNEL_TYPE_LUMA);

      if (colLumaCu)
      {
        currTestMode.qp = colLumaCu->qp;
      }
    }

dqp:delta QP

【笔记】HEVC 编码标准（六）——量化_lock。的博客-CSDN博客_hevc 量化

这个函数放在后面去看

    if( currTestMode.type == ETM_INTER_ME )
    {
      if( ( currTestMode.opts & ETO_IMV ) != 0 )
      {
        const bool skipAltHpelIF = ( int( ( currTestMode.opts & ETO_IMV ) >> ETO_IMV_SHIFT ) == 4 ) && ( bestIntPelCost > 1.25 * bestCS->cost );
        if (!skipAltHpelIF)
        {
          tempCS->bestCS = bestCS;
          xCheckRDCostInterIMV(tempCS, bestCS, partitioner, currTestMode, bestIntPelCost);
          tempCS->bestCS = nullptr;
        }
      }
      else
      {
        tempCS->bestCS = bestCS;
        xCheckRDCostInter( tempCS, bestCS, partitioner, currTestMode );
        tempCS->bestCS = nullptr;
      }

    }

当前测试模式为inter时启用

    // 若当前测试模式是 HASH INTER
    // 则检查 HashInter 的 RD cost 
else if (currTestMode.type == ETM_HASH_INTER)
    {
      xCheckRDCostHashInter( tempCS, bestCS, partitioner, currTestMode );
    }
    // 若当前测试模式是 AFFINE
    // 则检查 Affine 的 RD cost
    else if( currTestMode.type == ETM_AFFINE )
    {
      xCheckRDCostAffineMerge2Nx2N( tempCS, bestCS, partitioner, currTestMode );
    }
#if REUSE_CU_RESULTS
    // 若当前测试模式是 RECO_CACHED
    // 则检查 Reuse Cached 的 RD cost
    else if( currTestMode.type == ETM_RECO_CACHED )
    {
      xReuseCachedResult( tempCS, bestCS, partitioner );
    }
    // 若当前测试模式是 MERGE_SKIP
    // 则检查 Merge 的 RD cost
    else if( currTestMode.type == ETM_MERGE_SKIP )
    {
      xCheckRDCostMerge2Nx2N( tempCS, bestCS, partitioner, currTestMode );
      CodingUnit* cu = bestCS->getCU(partitioner.chType);
      if (cu)
      {
        cu->mmvdSkip = cu->skip == false ? false : cu->mmvdSkip;
      }
    }
    // 若当前测试模式是 MERGE_GEO
    // 则检查 Merge Geo 的 RD cost
    else if( currTestMode.type == ETM_MERGE_GEO )
    {
      xCheckRDCostMergeGeo2Nx2N( tempCS, bestCS, partitioner, currTestMode );
    }

之后再细看

 else if( currTestMode.type == ETM_INTRA )
    {
      //若使用色彩变换且不为dual tree
      if (slice.getSPS()->getUseColorTrans() && !CS::isDualITree(*tempCS))
      {
        //不跳过第二色彩空间
        bool skipSecColorSpace = false;
        skipSecColorSpace = xCheckRDCostIntra(tempCS, bestCS, partitioner, currTestMode, (m_pcEncCfg->getRGBFormatFlag() ? true : false));
        if ((m_pcEncCfg->getCostMode() == COST_LOSSLESS_CODING && slice.isLossless()) && !m_pcEncCfg->getRGBFormatFlag())
        {
          skipSecColorSpace = true;
        }
        if (!skipSecColorSpace && !tempCS->firstColorSpaceTestOnly)
        {
          xCheckRDCostIntra(tempCS, bestCS, partitioner, currTestMode, (m_pcEncCfg->getRGBFormatFlag() ? false : true));
        }

        if (!tempCS->firstColorSpaceTestOnly)
        {
          if (tempCS->tmpColorSpaceIntraCost[0] != MAX_DOUBLE && tempCS->tmpColorSpaceIntraCost[1] != MAX_DOUBLE)
          {
            double skipCostRatio = m_pcEncCfg->getRGBFormatFlag() ? 1.1 : 1.0;
            if (tempCS->tmpColorSpaceIntraCost[1] > (skipCostRatio*tempCS->tmpColorSpaceIntraCost[0]))
            {
              tempCS->firstColorSpaceTestOnly = bestCS->firstColorSpaceTestOnly = true;
            }
          }
        }
        else
        {
          CHECK(tempCS->tmpColorSpaceIntraCost[1] != MAX_DOUBLE, "the RD test of the second color space should be skipped");
        }
      }
      else
      {
        xCheckRDCostIntra(tempCS, bestCS, partitioner, currTestMode, false);
      }
    }

当前测试模式是intra

    // 若当前测试模式是 PALETTE
    // 则检查 PLT 的 RD cost
else if (currTestMode.type == ETM_PALETTE)
    {
      xCheckPLT( tempCS, bestCS, partitioner, currTestMode );
    }
    // 若当前测试模式是 IBC（Intra block copy）
    // 则检查 IBC 的 RD cost
    else if (currTestMode.type == ETM_IBC)
    {
      xCheckRDCostIBCMode(tempCS, bestCS, partitioner, currTestMode);
    }
    // 若当前测试模式是 IBC_MERGE
    // 则检查 IBC_MERGE 的 RD cost
    else if (currTestMode.type == ETM_IBC_MERGE)
    {
      xCheckRDCostIBCModeMerge2Nx2N(tempCS, bestCS, partitioner, currTestMode);
    }

之后再看

else if( isModeSplit( currTestMode ) )
    {
      if (bestCS->cus.size() != 0) //size()返回当前序列长度，不为0表示已划分过
      {
        splitmode = bestCS->cus[0]->splitSeries;
      }
      assert( partitioner.modeType == tempCS->modeType );
      int signalModeConsVal = tempCS->signalModeCons( getPartSplit( currTestMode ), partitioner, modeTypeParent );
      int numRoundRdo = signalModeConsVal == LDT_MODE_TYPE_SIGNAL ? 2 : 1;
      bool skipInterPass = false;
    // 遍历 RDO 轮次
      for( int i = 0; i < numRoundRdo; i++ )
      {
        //change cons modes
        // 若当前信号模式值为 LDT_MODE_TYPE_SIGNAL
        // 则当前测试模式类型在第一轮设置为 INTER，在第二轮设置为 INTRA
        if( signalModeConsVal == LDT_MODE_TYPE_SIGNAL )
        {
          CHECK( numRoundRdo != 2, "numRoundRdo shall be 2 - [LDT_MODE_TYPE_SIGNAL]" );
          tempCS->modeType = partitioner.modeType = (i == 0) ? MODE_TYPE_INTER : MODE_TYPE_INTRA;
        }
        // 若当前信号模式值为 LDT_MODE_TYPE_INFER
        // 则当前测试模式类型为 INTRA
        else if( signalModeConsVal == LDT_MODE_TYPE_INFER )
        {
          CHECK( numRoundRdo != 1, "numRoundRdo shall be 1 - [LDT_MODE_TYPE_INFER]" );
          tempCS->modeType = partitioner.modeType = MODE_TYPE_INTRA;
        }
        // 若当前信号模式值为 LDT_MODE_TYPE_INHERIT
        // 则当前测试模式类型为父结点模式类型
        else if( signalModeConsVal == LDT_MODE_TYPE_INHERIT )
        {
          CHECK( numRoundRdo != 1, "numRoundRdo shall be 1 - [LDT_MODE_TYPE_INHERIT]" );
          tempCS->modeType = partitioner.modeType = modeTypeParent;
        }

        //for lite intra encoding fast algorithm, set the status to save inter coding info
        //帧间模式
        // 若父结点模式类型为 MODE_TYPE_ALL（可以尝试所有类型），且当前测试模式类型为 Inter
        // 则 SaveCuCostInSCIPU，且设置 NumCuInSCIPU 为0
        if( modeTypeParent == MODE_TYPE_ALL && tempCS->modeType == MODE_TYPE_INTER )
        {
          m_pcIntraSearch->setSaveCuCostInSCIPU( true );
          m_pcIntraSearch->setNumCuInSCIPU( 0 );
        }
        // 若父结点模式类型为 MODE_TYPE_ALL（可以尝试所有类型），且当前测试模式类型不为 Inter
        // 则 SaveCuCostInSCIPU 为 false，且当前测试模式 MODE_TYPE_ALL 时设置 NumCuInSCIPU 为0
        else if( modeTypeParent == MODE_TYPE_ALL && tempCS->modeType != MODE_TYPE_INTER )
        {
          m_pcIntraSearch->setSaveCuCostInSCIPU( false );
          if( tempCS->modeType == MODE_TYPE_ALL )
          {
            m_pcIntraSearch->setNumCuInSCIPU( 0 );
          }
        }

        xCheckModeSplit( tempCS, bestCS, partitioner, currTestMode, modeTypeParent, skipInterPass );
        //recover cons modes
        tempCS->modeType = partitioner.modeType = modeTypeParent;
        tempCS->treeType = partitioner.treeType = treeTypeParent;
        partitioner.chType = chTypeParent;
        if( modeTypeParent == MODE_TYPE_ALL )
        {
          m_pcIntraSearch->setSaveCuCostInSCIPU( false );
          if( numRoundRdo == 2 && tempCS->modeType == MODE_TYPE_INTRA )
          {
            m_pcIntraSearch->initCuAreaCostInSCIPU();
          }
        }
        if( skipInterPass )
        {
          break;
        }
      }
#if GDR_ENABLED
      if (bestCS->cus.size() > 0 && splitmode != bestCS->cus[0]->splitSeries)
#else
      if (splitmode != bestCS->cus[0]->splitSeries)
#endif
      {
        splitmode = bestCS->cus[0]->splitSeries;
        const CodingUnit&     cu = *bestCS->cus.front();
        cu.cs->prevPLT = bestCS->prevPLT;
        for (int i = compBegin; i < (compBegin + numComp); i++)
        {
          ComponentID comID = jointPLT ? (ComponentID)compBegin : ((i > 0) ? COMPONENT_Cb : COMPONENT_Y);
          bestLastPLTSize[comID] = bestCS->cus[0]->cs->prevPLT.curPLTSize[comID];
          memcpy(bestLastPLT[i], bestCS->cus[0]->cs->prevPLT.curPLT[i], bestCS->cus[0]->cs->prevPLT.curPLTSize[comID] * sizeof(Pel));
        }
      }
    }
else
    {
      THROW( "Don't know how to handle mode: type = " << currTestMode.type << ", options = " << currTestMode.opts );
    }
  } while( m_modeCtrl->nextMode( *tempCS, partitioner ) );

当前测试模式为划分

SplitSeries 类：对于每个cu尺寸的具体的划分顺序的一个参数

VVC学习之四：VTM中的数据结构——CodingUnit、PredictionUnit、TransformUnit_Aidoneus_y的博客-CSDN博客

bestCS->cus.size()：若当前CU已划分，则当前BestCs的cu数目就不为零。此时设置splitmode，这个好像与在帧内预测中的一个叫getSplitSeries()函数有关，之后看到帧内时再写。推测表示划分时的顺序

assert：检验当前CS结构modeType是否和划分类中设定的modeType相同，如果不同，则终止程序

getPartSplit():从当前测试模式中得到当前CU的划分方式

https://blog.csdn.net/dfhg54/article/details/124284888

signalModeConsVal()：获得当前信号模式值，规定了子节点是否继承父节点的模式测试方法。0，1,2分别代表三个模式。如0代表LDT_MODE_TYPE_INHERIT

numRoundRdo：当前信号模式值为 LDT_MODE_TYPE_SIGNAL，则Rdo轮次为2

for循环：注释在代码里

xCheckModeSplit():划分模式，这里会递归调用xcompressCu

 //
  // Finishing CU
  if( tempCS->cost == MAX_DOUBLE && bestCS->cost == MAX_DOUBLE )
  {
    //although some coding modes were planned to be tried in RDO, no coding mode actually finished encoding due to early termination
    //thus tempCS->cost and bestCS->cost are both MAX_DOUBLE; in this case, skip the following process for normal case
    m_modeCtrl->finishCULevel( partitioner );
    return;
  }

  // set context states
  m_CABACEstimator->getCtx() = m_CurrCtx->best;

如果tempCS和bestCS中的cost都等于double最大值，则finishCULevel()中实现

m_ComprCUCtxList.pop_back();

 在运行完以后，m_ComprCUCtxList的size减少了1.原本的那层出了intra没有其他模式，所以当前CU已经算测试完了，就把栈中这个CU的信息消去，返回上一层父CU

 

  // QP from last processed CU for further processing
  //copy the qp of the last non-chroma CU
  int numCUInThisNode = (int)bestCS->cus.size();
  if( numCUInThisNode > 1 && bestCS->cus.back()->chType == CHANNEL_TYPE_CHROMA && !CS::isDualITree( *bestCS ) )
  {
    CHECK( bestCS->cus[numCUInThisNode-2]->chType != CHANNEL_TYPE_LUMA, "wrong chType" );
    bestCS->prevQP[partitioner.chType] = bestCS->cus[numCUInThisNode-2]->qp;
  }
  else
  {
  bestCS->prevQP[partitioner.chType] = bestCS->cus.back()->qp;
  }
  if ((!slice.isIntra() || slice.getSPS()->getIBCFlag())
    && partitioner.chType == CHANNEL_TYPE_LUMA
    && bestCS->cus.size() == 1 && (bestCS->cus.back()->predMode == MODE_INTER || bestCS->cus.back()->predMode == MODE_IBC)
    && bestCS->area.Y() == (*bestCS->cus.back()).Y()
    )
  {
    const CodingUnit&     cu = *bestCS->cus.front();

    bool isIbcSmallBlk = CU::isIBC(cu) && (cu.lwidth() * cu.lheight() <= 16);
    CU::saveMotionInHMVP( cu, isIbcSmallBlk );
  }
  // 将预测像素和重建像素复制到bestCS->picture中
  bestCS->picture->getPredBuf(currCsArea).copyFrom(bestCS->getPredBuf(currCsArea));
  bestCS->picture->getRecoBuf( currCsArea ).copyFrom( bestCS->getRecoBuf( currCsArea ) );
  m_modeCtrl->finishCULevel( partitioner );
  if( m_pcIntraSearch->getSaveCuCostInSCIPU() && bestCS->cus.size() == 1 )
  {
    m_pcIntraSearch->saveCuAreaCostInSCIPU( Area( partitioner.currArea().lumaPos(), partitioner.currArea().lumaSize() ), bestCS->cost );
  }

这部分代码有预测和重建像素，要结合后面的预测函数来看

 if (bestCS->cus.size() == 1) // no partition
  {
    CHECK(bestCS->cus[0]->tileIdx != bestCS->pps->getTileIdx(bestCS->area.lumaPos()), "Wrong tile index!");
    if (bestCS->cus[0]->predMode == MODE_PLT)
    {
      for (int i = compBegin; i < (compBegin + numComp); i++)
      {
        ComponentID comID = jointPLT ? (ComponentID)compBegin : ((i > 0) ? COMPONENT_Cb : COMPONENT_Y);
        bestCS->prevPLT.curPLTSize[comID] = curLastPLTSize[comID];
        memcpy(bestCS->prevPLT.curPLT[i], curLastPLT[i], curLastPLTSize[comID] * sizeof(Pel));
      }
      bestCS->reorderPrevPLT(bestCS->prevPLT, bestCS->cus[0]->curPLTSize, bestCS->cus[0]->curPLT, bestCS->cus[0]->reuseflag, compBegin, numComp, jointPLT);
    }
    else
    {
      for (int i = compBegin; i<(compBegin + numComp); i++)
      {
        ComponentID comID = jointPLT ? (ComponentID)compBegin : ((i > 0) ? COMPONENT_Cb : COMPONENT_Y);
        bestCS->prevPLT.curPLTSize[comID] = curLastPLTSize[comID];
        memcpy(bestCS->prevPLT.curPLT[i], curLastPLT[i], bestCS->prevPLT.curPLTSize[comID] * sizeof(Pel));
      }
    }
  }
  else
  {
    for (int i = compBegin; i<(compBegin + numComp); i++)
    {
      ComponentID comID = jointPLT ? (ComponentID)compBegin : ((i > 0) ? COMPONENT_Cb : COMPONENT_Y);
      bestCS->prevPLT.curPLTSize[comID] = bestLastPLTSize[comID];
      memcpy(bestCS->prevPLT.curPLT[i], bestLastPLT[i], bestCS->prevPLT.curPLTSize[comID] * sizeof(Pel));
    }
  }
  const CodingUnit&     cu = *bestCS->cus.front();
  cu.cs->prevPLT = bestCS->prevPLT;
  // Assert if Best prediction mode is NONE
  // Selected mode's RD-cost must be not MAX_DOUBLE.
  CHECK( bestCS->cus.empty()                                   , "No possible encoding found" );
  CHECK( bestCS->cus[0]->predMode == NUMBER_OF_PREDICTION_MODES, "No possible encoding found" );
  CHECK( bestCS->cost             == MAX_DOUBLE                , "No possible encoding found" );
}

与PLT模式有关，之后再看

青椒鸡汤
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VTM3.0代码阅读：xCheckRDCostInter函数
矛盾统一
12-27 498
xCheckRDCostInter函数在xCompressCU中被调用，用来check普通帧间模式，也就是inter_ME模式。 inter_ME模式通过AMVP得到相邻块中的最优的两个运动信息，以此作为运动估计的起始点，然后经过ME，获得MVP和MVD等inter运动信息。 在通过ME得到运动信息之后，即MVP之后，通过MC得到pred像素。这些都在predInterSearch函数中实现。(p...
VTM代码学习（1）CU划分
jwgroot的博客
06-18 3145
新人上路，请多多指教。 一直想写博客，今天才开始写第一篇。 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 这次来讲一下VTM9.0中关于CU划分的部分，主要是两个函数xCompressCU和xCheckMo.
VVC代码学习1：xCompressCU函数
Everglow_zbz的博客
09-14 1941
一、函数简述 xCompressCU这个函数通过递归的调用自己来完成对整个CTU的划分和每个CU的模式选择。与HEVC中该函数不同的是，VVC中加入了很多新的模式，比如帧间Affine模式，帧内IBC模式等。 亮度块最大允许尺寸为128×128，并且划分方式采用多类型树结构，CU可以进行四叉划分，水平二叉划分，垂直二叉划分，水平三叉划分，垂直三叉划分。最优划分模式的确定在xCheckModeSpl...
H.266/VVC技术学习：算术编码
BigDream123的博客
08-15 2005
算术编码是一种常用的变长编码方法，和Huffman编码类似，也是对出现概率大的符号赋予短码，出现概率小的符号赋予长码，但算术编码不是简单的将每个信源符号映射成一个码字，而是对整个输入序列分配一个码字，所以平均意义上可以为每个信源符号分配长度小于1的码字。 算术编码的原理参考：熵编码：算术编码 H.266/VVC中采用的是基于上下文的自适应二进制算术编码（Context-based Adaptive Binary Arithmetic Coding，CABAC）。CABAC将二进制算术编码和上下文模型结合
VVC/H.266中的划分函数void EncCu::xCheckModeSplit
zhang2039的博客
08-17 1605
VVC中的编码块的划分与HEVC中有很大的不同。VVC中专门的一个函数来实现划分xCheckModeSplit。在void EncCu::xCheckModeSplit中的会进行具体的QT.BT.TT的划分，在xCompressCUz这个函数也会调用xCheckModeSplit这里面的划分结果，首先先看一个EncTestMode，会得到具体的CU划分模式 ETM_SPLIT_QT, ETM_SPLIT_BT_H, ETM_SPLIT_BT_V, ETM_SPLIT_TT_H, ETM...
VTM xCheckRDCostIntra---estIntraPredLumaQT
ChaChaoYueYue的博客
07-15 415
xCompressCU // 以下 do 循环开始遍历 m_ComprCUCtxList 中的测试模式（划分、模式、QP） do { // 遍历分量，将 PLT 的相关变量填充 for (int i = compBegin; i < (compBegin + numComp); i++) { } // 当前测试模式 EncTestMode currTestMode = m_modeCtrl->currTestMode(); //
H266-VVC源代码解析-视频编解码
10-25
2. `common`模块：包含通用函数和数据结构，为编码器提供基础支持。这里包括了像素操作、数学运算、内存管理等功能。 3. `configuration`模块：负责处理编码参数的设置和读取，允许用户根据需求调整编码器的参数。 ...
VTM块划分代码_块划分；_H.266_statementzbb_VVC_
10-03
本文将深入探讨"VTM块划分代码"，这是基于H.266标准（也称为VVC，即Versatile Video Coding）的一种实现。我们将讨论块划分的重要性、其在VTM（Versatile Test Model）中的实现以及可能的优化策略。 块划分是视频...
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 ...
代码段.rar
08-08
"代码段.rar"这个压缩包文件显然包含了一系列与C语言相关的代码示例，涵盖了线性结构、链表、结构体和指针等核心概念。这些主题都是理解C语言数据组织和内存管理的基础。 首先，让我们详细探讨一下线性结构。线性...
最新通用视频编码标准H.266VVC.pdf
11-28
《H.266/VVC 视频编码标准详解》 在数字媒体技术飞速发展的今天，视频编码标准不断演进以满足日益增长的高清、超高清以及虚拟现实等应用场景的需求。H.266，又称为Versatile Video Coding（VVC），是继H.264/AVC和H...
VVC系列（三）xCompressCTU、xCompressCU和xCheckModeSplit解析
weixin_43721070的博客
10-30 1056
判断是否需要执行IBC模式（帧内块复制技术，屏幕内容编码的一种技术，参考区域不局限在相邻像素行，而是可以利用当前帧所有已编码区域，预测待编码CU）该函数的主要部分是一个do-while循环，遍历子CU的区域，和x265相同的是，也会比较当前累计的cost和最优cost，用来进行提前终止。判断是否开启了 CTU Dual Tree技术，如果开启，需要对色度分量进行一次预测。维护需要测试的mode，通过一个do-while循环，尝试各种划分模式。用来存储当前compress区域各种模式下的数据，
H.266/VVC代码学习：xCompressCU函数
BigDream123的博客
08-02 2505
xCompressCU函数是用来进行CU划分（递归调用自身）以及模式选择。 首先调用m_modeCtrl->initCULevel函数初始化模式选择列表，由堆栈控制，将当前CU可以划分的模式（四叉划分、二叉划分和三叉划分）、编码模式（帧内、帧间Merge、帧间inter等） 之后，遍历模式列表，将待测试的模式出栈，根据模式调用不同的函数，所有待测试的模式如下所示： enum EncTestModeType { ETM_HASH_INTER, ETM_MERGE_SKIP, ETM_
H.266/VVC代码学习:xCheckModeSplit函数
BigDream123的博客
08-02 1543
xCheckModeSplit函数主要是根据划分类型对当前CU进行划分，然后调用xCompressCU函数对划分后的子CU进一步划分和模式选择。 这里，传入到xCheckModeSplit函数的tempCS和bestCS是待划分CU对应的CS结构，在xCheckModeSplit函数中调用的xCompressCU函数传递的tempCS和bestCS参数是根据划分后子CU的尺寸从m_pTempCS和m_pBestCS得到的Coding Structure结构，要注意区分tempCS和bestCS。 xCh
H.266/VVC代码学习13：VTM4.0中的CU层操作（compressCtu 、 xCompressCU）
时间有泪
03-22 5572
从H.266/VVC代码学习3：VTM4.0中的CTU层操作（encodeCtus）我们了解到了视频最基本的操作块为CTU，现在我们进一步学习CU层的操作。有两个十分重要的函数： 1 compressCtu: 是对encodeCtu中拿到的单个ctu进行操作，是进行CU划分预测等处理的入口。内部一共会调用两次 xCompressCU ，一次是对亮度进行处理，一次是对色度进行处理。可见compre...
VVC/VTM 4.2 帧内编码——亮度预测理解
destination00的博客
06-04 1006
xCompressCU()是帧内编码的核心函数，它把从上层函数compressCtu()得到的基本编码单元CTU递归地用函数xCheckModeSplit()进行宏块划分。在此过程中，xCheckModeSplit()会调用xCompressCU ()。 xCompressCU()函数 xCompressCU()函数的主要流程如下： 1、初始化：设置各种可用模式，上下文模型等； 2、遍历各种帧内模...
HEVC参考软件HM源码分析--帧间预测（2）--xCheckRDCostInter
qq_40934347的博客
10-27 488
这篇文章对xCompressCU中的一个核心子函数xCheckRDCostInter函数进行介绍。对xCompressCU函数的详细介绍见楼主上一篇博客 https://blog.csdn.net/qq_40934347/article/details/102716826. 函数作用： xCompressCU函数完成的是从众多帧间划分模式、以及帧内、PCM模式中选择最优CU模式的工作，而对于每一个...
VVC/JEM代码学习18：xCheckRDCostInter
小小柴的博客
04-01 807
在xCheckRDCostMerge2N*2N执行完，如果m_useEarlySkipDetection==false,则继续执行xCheckRDCostInter函数。（如果m_useEarlySkipDetection==true,则此函数在帧间的最开始执行）#if AMP_MRG Void TEncCu::xCheckRDCostInter( TComDataCU*&amp; rpcBest...
noi 百练：简单的整数划分问题（递归）
木静音yy的博客
12-13 835
http://bailian.openjudge.cn/practice/4117/ 描述 将正整数n 表示成一系列正整数之和，n=n1+n2+…+nk, 其中n1>=n2>=…>=nk>=1 ，k>=1 。 正整数n 的这种表示称为正整数n 的划分。正整数n 的不同的划分个数称为正整数n 的划分数。 输入 标准的输入包含若干组测试数据。每组测试数据是一个整数N(0 < N <= 50)。 输出 对于每组测试数据，输出N的划分数。 样例输入 5 样例输出 7 提示
H.266/VVC 视频编码标准详解
"该文档是关于最新的视频编码标准H.266（也称为VVC，Video Coding Standard）的中文版。文档详细介绍了H.266标准的基础知识，包括编码结构、帧内预测和帧间预测技术，以及变换编码和量化等核心概念。" 在H.266（VVC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值