initCULevel()函数部分，cansplit()函数

最新推荐文章于 2024-01-03 21:05:47 发布
最新推荐文章于 2024-01-03 21:05:47 发布
阅读量457 收藏 2
点赞数
分类专栏： 视频编解码 文章标签： c++
好
本文链接：https://blog.csdn.net/dfhg54/article/details/124798754
版权 
void EncModeCtrlMTnoRQT::initCULevel( Partitioner &partitioner, const CodingStructure& cs )
{
  // Min/max depth
  unsigned minDepth = 0;
  unsigned maxDepth = floorLog2(cs.sps->getCTUSize()) - floorLog2(cs.sps->getMinQTSize( m_slice->getSliceType(), partitioner.chType ));
  if( m_pcEncCfg->getUseFastLCTU() )
  {
    if( auto adPartitioner = dynamic_cast<AdaptiveDepthPartitioner*>( &partitioner ) )
    {
      // LARGE CTU
      adPartitioner->setMaxMinDepth( minDepth, maxDepth, cs );
    }
  }

  m_ComprCUCtxList.push_back( ComprCUCtx( cs, minDepth, maxDepth, NUM_EXTRA_FEATURES ) );

  const CodingUnit* cuLeft  = cs.getCU( cs.area.blocks[partitioner.chType].pos().offset( -1, 0 ), partitioner.chType );
  const CodingUnit* cuAbove = cs.getCU( cs.area.blocks[partitioner.chType].pos().offset( 0, -1 ), partitioner.chType );

  const bool qtBeforeBt = ( (  cuLeft  &&  cuAbove  && cuLeft ->qtDepth > partitioner.currQtDepth && cuAbove->qtDepth > partitioner.currQtDepth )
                         || (  cuLeft  && !cuAbove  && cuLeft ->qtDepth > partitioner.currQtDepth )
                         || ( !cuLeft  &&  cuAbove  && cuAbove->qtDepth > partitioner.currQtDepth )
                         || ( !cuAbove && !cuLeft   && cs.area.lwidth() >= ( 32 << cs.slice->getDepth() ) ) )
                         && ( cs.area.lwidth() > ( cs.pcv->getMinQtSize( *cs.slice, partitioner.chType ) << 1 ) );

cuLeft：当前CU的左侧cu情况。如是第一个cu，则culeft就为NULL.

offset( -1, 0 ):表示当前CU位置向左移动一个单位的CU情况

qtBeforeBt：

  1. cuLeft，cuabove都存在且culeft的QT深度大于当前cu的QT深度，同时cuabove的QT深度大于当前cu的QT深度
  2. 只有culeft存在且culeft的QT深度大于当前cu的QT深度
  3. 只有cuabove存在且cuabove的QT深度大于当前cu的QT深度
  4. 都不存在且当前CTU的亮度width大于32 X 当前深度

若以上四个条件有任一个满足，且当前CTU的亮度分量width大于MinQtSize的2倍，则qtBeforeBt为真

                          

2. initCULevel 函数调用的 cansplit（）函数 

bool QTBTPartitioner::canSplit( const PartSplit split, const CodingStructure &cs )
{
    //当前亮度分量的位置和长宽
  const CompArea area       = currArea().Y();
  const unsigned maxTrSize  = cs.sps->getMaxTbSize();

  bool canNo, canQt, canBh, canTh, canBv, canTv;

  canSplit( cs, canNo, canQt, canBh, canBv, canTh, canTv );
  switch( split )
  {
  case CTU_LEVEL:
    THROW( "Checking if top level split is possible" );
    return true;
    break;
  case TU_MAX_TR_SPLIT:
    return area.width > maxTrSize || area.height > maxTrSize;
    break;
  case SBT_VER_HALF_POS0_SPLIT:
  case SBT_VER_HALF_POS1_SPLIT:
  case SBT_HOR_HALF_POS0_SPLIT:
  case SBT_HOR_HALF_POS1_SPLIT:
  case SBT_VER_QUAD_POS0_SPLIT:
  case SBT_VER_QUAD_POS1_SPLIT:
  case SBT_HOR_QUAD_POS0_SPLIT:
  case SBT_HOR_QUAD_POS1_SPLIT:
    return currTrDepth == 0;
    break;
  case CU_QUAD_SPLIT:
    return canQt;
  case CU_DONT_SPLIT:
    return canNo;
  case CU_HORZ_SPLIT:
    return canBh;
  case CU_VERT_SPLIT:
    return canBv;
  case CU_TRIH_SPLIT:
    return canTh;
  case CU_TRIV_SPLIT:
    return canTv;
  case CU_MT_SPLIT:
    return ( canBh || canTh || canBv || canTv );
  case CU_BT_SPLIT:
    return ( canBh || canBv );
  break;
  default:
    THROW( "Unknown split mode" );
    return false;
    break;
  }

H.264/H.265/H.266三代视频编码的图像划分_@唔问的博客-CSDN博客_h266视频编码对照表

getMaxTbSize():得到最大的TB尺寸 

swicth:根据当前传入的划分模式，判断是否加入测试列表

3.cansplit中调用的决定各个划分模式是否可行的cansplit函数

void QTBTPartitioner::canSplit( const CodingStructure &cs, bool& canNo, bool& canQt, bool& canBh, bool& canBv, bool& canTh, bool& canTv )
{
  //隐式分割设置
  const PartSplit implicitSplit = m_partStack.back().checkdIfImplicit ? m_partStack.back().implicitSplit : getImplicitSplit( cs );
  //一些参数获取
  //maxBT深度是要加上当前隐式分割的BT深度
  const unsigned maxBTD         = cs.pcv->getMaxBtDepth( *cs.slice, chType ) + currImplicitBtDepth;
  const unsigned maxBtSize      = cs.pcv->getMaxBtSize ( *cs.slice, chType );
  const unsigned minBtSize      = cs.pcv->getMinBtSize ( *cs.slice, chType );
  const unsigned maxTtSize      = cs.pcv->getMaxTtSize ( *cs.slice, chType );
  const unsigned minTtSize      = cs.pcv->getMinTtSize ( *cs.slice, chType );
  const unsigned minQtSize      = cs.pcv->getMinQtSize ( *cs.slice, chType );

  canNo = canQt = canBh = canTh = canBv = canTv = true;
  //若设置的BT最大深度大于当前MT的深度，则可以BT和TT
  bool canBtt = currMtDepth < maxBTD;

  // the minimal and maximal sizes are given in luma samples
  const CompArea&  area  = currArea().Y();
  const CompArea  *areaC = (chType == CHANNEL_TYPE_CHROMA) ? &(currArea().Cb()) : nullptr;
        PartLevel& level = m_partStack.back();

  const PartSplit lastSplit = level.split;
  const PartSplit parlSplit = lastSplit == CU_TRIH_SPLIT ? CU_HORZ_SPLIT : CU_VERT_SPLIT;

  // don't allow QT-splitting below a BT split
  //如果上次划分模式不是CTU_LEVEL 且不为CU_QUAD_SPLIT ，canQT为fasle
  if( lastSplit != CTU_LEVEL && lastSplit != CU_QUAD_SPLIT ) canQt = false;
  if( area.width <= minQtSize )                              canQt = false;

  if( areaC && areaC->width <= MIN_DUALTREE_CHROMA_WIDTH ) canQt = false;
  // 若当前树类型为色度分离树
  // 则二叉、三叉、四叉划分均不进行
  if( treeType == TREE_C )
  {
    canQt = canBh = canTh = canBv = canTv = false;
    return;
  }
  // 若隐含划分不为不划分
  if( implicitSplit != CU_DONT_SPLIT )
  {
    // 则不划分、三叉树划分均不进行测试
    canNo = canTh = canTv = false;
    // 根据隐含划分决定二叉树划分是否测试
    canBh = implicitSplit == CU_HORZ_SPLIT;
    canBv = implicitSplit == CU_VERT_SPLIT;
    // 若当前色度区域存在且色度区域宽度等于4，则不进行 BV
    if (areaC && areaC->width == 4) canBv = false;
    // 若不BH、BV、QT，则测试 QT
    if( !canBh && !canBv && !canQt ) canQt = true;
    return;
  }
   // 若上一划分模式为 TH，且当前块索引为 1，则不测试 BH，测试 BV
  // 若上一划分模式为 TV，且当前块索引为 1，则不测试 BV，测试 BH
  if( ( lastSplit == CU_TRIH_SPLIT || lastSplit == CU_TRIV_SPLIT ) && currPartIdx() == 1 )
  {
    canBh = parlSplit != CU_HORZ_SPLIT;
    canBv = parlSplit != CU_VERT_SPLIT;
  }
  // 若同时满足当前 MT 深度小于最大 MT 深度、当前区域宽高均小于等于最小 BT 尺寸、当前区域宽高均小于等于最小 TT 尺寸，则将 canBtt 设为 false
  if( canBtt && ( area.width <= minBtSize && area.height <= minBtSize )
      && ( ( area.width <= minTtSize && area.height <= minTtSize ) ) )
  {
    canBtt = false;
  }
   // 若同时满足当前 MT 深度小于最大 MT 深度、当前区域宽或高大于最大 BT 尺寸、当前区域宽或高大于最大 TT 尺寸，则将 canBtt 设为 false
  if( canBtt && ( area.width > maxBtSize || area.height > maxBtSize )
      && ( ( area.width > maxTtSize || area.height > maxTtSize ) ) )
  {
    canBtt = false;
  }

  if( !canBtt )
  {
    canBh = canTh = canBv = canTv = false;

    return;
  }
  // 若当前区域宽或高大于最大 BT 尺寸
  // 则不尝试 BT
  if( area.width > maxBtSize || area.height > maxBtSize )
  {
    canBh = canBv = false;
  }

  // specific check for BT splits
  // 若当前区域高小于等于最小 BT 尺寸，则不尝试 BH
  if( area.height <= minBtSize )                            canBh = false;
  // 若当前区域宽大于最大 TB 尺寸，且当前区域高小于等于最大 TB 尺寸，则不尝试 BH
  if( area.width > MAX_TB_SIZEY && area.height <= MAX_TB_SIZEY ) canBh = false;
  // 若当前色度区域存在，且面积小于等于 16，则不尝试 BH
  if( areaC && areaC->width * areaC->height <= MIN_DUALTREE_CHROMA_SIZE )     canBh = false;
  // 若当前区域宽小于等于最小 BT 尺寸，则不尝试 BV
  if( area.width <= minBtSize )                              canBv = false;
  // 若当前区域宽小于等于最大 TB 尺寸，且当前区域高大于最大 TB 尺寸，则不尝试 BV
  if( area.width <= MAX_TB_SIZEY && area.height > MAX_TB_SIZEY ) canBv = false;
  // 若当前色度区域存在，且面积小于等于 16 或宽为 4，则不尝试 BV
  if (areaC && (areaC->width * areaC->height <= MIN_DUALTREE_CHROMA_SIZE || areaC->width == 4))     canBv = false;
  // 若为 INTER，且当前区域面积为 32，则不尝试 BT
  if( modeType == MODE_TYPE_INTER && area.width * area.height == 32 )  canBv = canBh = false;
  // 若当前区域高小于等于两倍最小 TT 尺寸，或当前区域高大于最大 TT 尺寸，或当前区域宽大于最大 TT 尺寸
  // 则不尝试 TH
  if( area.height <= 2 * minTtSize || area.height > maxTtSize || area.width > maxTtSize )
                                                                                       canTh = false;
  // 若当前区域宽大于最大 TB 尺寸，或当前区域高大于最大 TB 尺寸，则不尝试 TH
  if( area.width > MAX_TB_SIZEY || area.height > MAX_TB_SIZEY )  canTh = false;
  // 若当前色度区域存在，且面积小于等于 32，则不尝试 TH
  if( areaC && areaC->width * areaC->height <= MIN_DUALTREE_CHROMA_SIZE*2 )     canTh = false;
  // 若当前区域宽度小于等于两倍最小 TT 尺寸，或当前区域宽大于最大 TT 尺寸，或当前区域高大于最大 TT 尺寸
  // 则不尝试 TV
  if( area.width <= 2 * minTtSize || area.width > maxTtSize || area.height > maxTtSize )
                                                                                       canTv = false;
  // 若当前区域宽大于最大 TB 尺寸，或当前区域高大于最大 TB 尺寸，则不尝试 TV
  if( area.width > MAX_TB_SIZEY || area.height > MAX_TB_SIZEY )  canTv = false;
  // 若当前色度区域存在，且面积小于等于 32 或 宽度为 8，则不尝试 TV
  if (areaC && (areaC->width * areaC->height <= MIN_DUALTREE_CHROMA_SIZE * 2 || areaC->width == 8))     canTv = false;
  // 若为 INTER，且当前区域面积为 64，则不尝试 TT
  if( modeType == MODE_TYPE_INTER && area.width * area.height == 64 )  canTv = canTh = false;

}

maxBTD：最大BT深度，是psv中设置的maxBTdepth和当前隐式分割BTdepth的相加

PartLevel& level= m_partStack.back()：将m_partStack中赋给level。m_partStack里为划分树的具体情况

lastSplit：表示的是上一次使用的划分模式

parlSplit：如果上一次为TH，则这次的划分模式BH,否则为BT，赋给parlSplit

青椒鸡汤
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VTM1.0代码阅读：initCULevel函数
矛盾统一
12-26 702
initCULevel函数在xCompressCU函数中被调用，xCompressCU函数中在最开始就调用m_modeCtrl->initCULevel( partitioner, *tempCS )，初始化m_modeCtrl，确定当期cu的test模式。 initCULevel函数用来确定当前compress的cu可以进行以及需要进行test的模式，保存在m_modeCtrl，然后在do...
CAN SPLIT功能作用和SPLIT电容作用
热门推荐
m0_52850847的博客
02-25 1万+
1、CAN总线显隐电平定义 CAN2.0B规范定义： (1) CAN总线为隐性（逻辑1）时，CAN_H和CAN_L的电平都为2.5V（电位差为0V）； （2）CAN总线为显性（逻辑0）时，CAN_H和CAN_L电平分别为3.5V和1.5V（电位差为2.0V）. 2、CAN芯片的SPLIT 管脚作用 （1）如下图示为CAN芯片SPLIT管脚内部原理，在CAN芯片为normal模式时，SPLIT的电压为0.5VCC，能够为CAN总线2.5V的共模电压； （2）减少EME（电磁辐射），为DC电.
H.266/VVC-VTM代码学习22-partitioner类判断划分模式是否可用函数partitioner.canSplit
liaojq2020的博客
04-18 1083
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习21-对划分模式进行RDO的函数xCheckModeSplit 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、函数作用二、函数详解1. initCULevel 函数调用的 canSplit2. canSplit 函数内部调用获取 CU 划分模式是否可行的 canSplit 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准规范与细节。 本文是笔者对VTM代码的一点学
H.266/VVC-VTM代码学习19-CU层确定测试模式函数initCULevel
liaojq2020的博客
04-14 2794
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习-帧内预测17-initIntraPatternChTypeISP函数初始化ISP的帧内预测 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、函数流程二、函数详解 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准规范与细节。 本文是笔者对VTM代码的一点学习记录，成文于笔者刚开始接触VVC期间，期间很多概念和理论框架还很不成熟，若文中存在错误欢迎批评指正，也欢迎广大
H.266/VVC-VTM代码学习23-编码块RDO选择模式（Intra与Inter）initCULevel()
liaojq2020的博客
04-20 1392
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习22-partitioner类判断划分模式是否可用函数partitioner.canSplit 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、简介二、代码详解1. 将 Intra/Inter 加入 RDO 列表① Intra② Inter2. tryIntraRdo 和 tryInterRdo 两变量的确定三、总结 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准
sql实现split函数的脚本
09-10
"SQL实现Split函数的脚本" SQL实现Split函数的脚本是指使用SQL语言创建一个函数，以实现将一个字符串按照指定的分隔符拆分成多个子字符串，并将其返回为一个表的形式。下面是该函数的详细介绍。 函数定义 首先，...
ASP 中 Split 函数的实例分析
01-02
 我先介绍一下Split函数的用法: 返回值数组 = Split(“字符串”,”分割符”) 假设变量strURL保存着URL值，如strURL = “ftp://username:password@server”，这是我们在ＩＥ中登录到FTP上时的ＵＲＬ形式，如果...
re函数split各种情况
12-22
split(pattern, string, maxsplit=0, flags=0) 原文 Split the source string by the occurrences of the pattern, returning a list containing the resulting substrings. If capturing parentheses are used in ...
利用Split函数进行多关键字检索
01-20
`Split` 是一种在多种编程语言（如VBScript、JavaScript等）中可用的内置函数，用于将字符串分割成一个数组，每个元素是原字符串中由指定分隔符切分出来的部分。 在这个问题中，讨论的是如何使用`Split`函数来处理...
Lua实现split函数
09-22
主要介绍了Lua实现split函数,lua中没有split分割字条串函数,本文使用自定义函数实现,需要的朋友可以参考下
VVC系列（四）initCULevel代码解读
weixin_43721070的博客
12-09 657
3、添加划分模式，默认添加顺序是QT、TTV、TTH、BTV 、BTH和Non-split，因为是保存在堆栈中，测试顺序相反。值得注意的是，当current CU的 QtDepth 小于左侧和上侧相邻CU的 QtDepth 时，或者 current CU的决策深度较浅时，会将QT的测试顺序放在BT之前。4、添加测试模式，此时的QP range是Non-split的，包括 intra、inter、IBC 和 palette等模式。的开始被调用，将需要测试的划分模式和编码模式加入堆栈。确定划分模式是否合法，
VVC学习之二：VTM中CU划分结构QTMTT（2）
Aidoneus_y
04-24 4800
上次说了VTM中QTMTT划分的理论部分，这次准备结合代码理解，VTM完全就是C++的代码风格，由于水平有限，应该会有很多理解不到位的地方，还请大佬批评指正，欢迎交流。不同于HEVC，VTM中将CU划分方式也当做编码模式进行处理。在编码每个CU时，首先将初始化所有的编码模式，包括所有的预测模式和划分模式。这部分由lib/EncoderLib/EncCU.cpp中xCompressCU()完成。xC...
VTM代码学习（1）CU划分
jwgroot的博客
06-18 3151
新人上路，请多多指教。 一直想写博客，今天才开始写第一篇。 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 这次来讲一下VTM9.0中关于CU划分的部分，主要是两个函数xCompressCU和xCheckMo.
xcompressCU函数中划分模式的确定
dfhg54的博客
04-21 710
xcompressCU()函数中inter,intra等模式的选择是由initCULevel()函数确定的 // Add unit split modes if( !cuECtx.get<bool>( QT_BEFORE_BT ) ) { for( int qp = maxQP; qp >= minQP; qp-- ) { m_ComprCUCtxList.back().testModes.push_back( { ETM_SPLIT_QT, ET
BMS/VTM代码学习：xCompressCU
慢慢积累
09-26 3767
找工作基本结束，收心回来看266了，从xCompressCU开始吧。在初学者阶段写过HEVC代码学习11：xCompressCU函数，当时实际看的一知半解，作为参考吧。 BMS/VTM中xCompressCU代码精简了很多，看起来容易多了，主要流程为： 1.初始化：设置可用模式、上下文模型等。 2.尝试帧间、帧内各种可用预测模式，当遍历完所有可用模式后，调用xCheckModeSplit进行划分，...
H.266/VVC-VTM代码学习20-CU层进行RDO函数xCompressCU
liaojq2020的博客
04-16 1934
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习19-CU层确定测试模式函数initCULevel 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、函数作用二、函数详解 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准规范与细节。 本文是笔者对VTM代码的一点学习记录，成文于笔者刚开始接触VVC期间，期间很多概念和理论框架还很不成熟，若文中存在错误欢迎批评指正，也欢迎广大视频编码学习者沟通交流、共同进步。 VTM
H.266/VVC-VTM代码学习24-根据当前块位置与尺寸确定隐藏划分模式getImplicitSplit()
liaojq2020的博客
04-21 597
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习23-编码块RDO选择模式（Intra与Inter）initCULevel() 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、简介二、代码详解 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准规范与细节。 本文是笔者对VTM代码的一点学习记录，成文于笔者刚开始接触VVC期间，期间很多概念和理论框架还很不成熟，若文中存在错误欢迎批评指正，也欢迎广大视频编码学习者沟通
H.266/VVC代码学习13：VTM4.0中的CU层操作（compressCtu 、 xCompressCU）
时间有泪
03-22 5574
从H.266/VVC代码学习3：VTM4.0中的CTU层操作（encodeCtus）我们了解到了视频最基本的操作块为CTU，现在我们进一步学习CU层的操作。有两个十分重要的函数： 1 compressCtu: 是对encodeCtu中拿到的单个ctu进行操作，是进行CU划分预测等处理的入口。内部一共会调用两次 xCompressCU ，一次是对亮度进行处理，一次是对色度进行处理。可见compre...
【计算机图形学】PARIS: Part-level Reconstruction and Motion Analysis for Articulated Objects
最新发布
passer__jw767的博客
01-03 913
第一行fridge的例子：在视角变化之后，大部分的静态部分被遮挡，会导致无法正确估计revolute joints的参数第二行椅子的例子：如果movable part的在几何上前后非常相似，会导致椅子的旋转方向出现问题这两点很大程度上是因为3D correspondence学的不好。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值