VVC代码学习之自定义数据结构阅读4

最新推荐文章于 2022-06-01 15:30:50 发布
最新推荐文章于 2022-06-01 15:30:50 发布
阅读量418 收藏 1
点赞数
分类专栏： vvc c++ 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45133943/article/details/120986956
版权
vvc 同时被 2 个专栏收录
6 篇文章 4 订阅
订阅专栏
c++
4 篇文章 0 订阅
订阅专栏

class CodingStructure

1.这个类中存储了编码所需要的一系列信息，区域，图片，父类CS，bestCS，以及slice，同时还存放了相关的QP信息，以及各种参数集SPS,PPS,VPS等等，并且可以从CS中提取到当前的cu，pu 和tu，更可以获取到可以遍历当前CU的遍历器。

2.定义三个数组，分别存放CU,TU,PU, 以及m_numCUs，cucache等等，同时还保存了预测，残差，原始，重构的Pelstorage，同时可以获取当前的运动信息getMotionBuf

3.同样的，因为由picture成员变量，所以可以访问原始，预测，残差等等的buf。

补充：一帧中的所有CU都会存放在CodingStructure中，存放的位置就是vector的数组，tu，pu同理

class CodingStructure
{
public:

  UnitArea         area;

  Picture         *picture;
  CodingStructure *parent;
  CodingStructure *bestCS;
  Slice           *slice;

  UnitScale        unitScale[MAX_NUM_COMPONENT];

  int         baseQP;
  int         prevQP[MAX_NUM_CHANNEL_TYPE];
  int         currQP[MAX_NUM_CHANNEL_TYPE];
  int         chromaQpAdj;
  const SPS *sps;
  const PPS *pps;
  PicHeader *picHeader;
  APS*       alfApss[ALF_CTB_MAX_NUM_APS];
  APS *      lmcsAps;
  APS *      scalinglistAps;
  const VPS *vps;
  const PreCalcValues* pcv;

  CodingStructure(CUCache&, PUCache&, TUCache&);

  void create(const UnitArea &_unit, const bool isTopLayer, const bool isPLTused);
  void create(const ChromaFormat &_chromaFormat, const Area& _area, const bool isTopLayer, const bool isPLTused);

  void destroy();
  void releaseIntermediateData();

  void rebindPicBufs();

  void createCoeffs(const bool isPLTused);
  void destroyCoeffs();

  void allocateVectorsAtPicLevel();

  // ---------------------------------------------------------------------------
  // global accessors
  // ---------------------------------------------------------------------------

  bool isDecomp (const Position &pos, const ChannelType _chType) const;
  bool isDecomp (const Position &pos, const ChannelType _chType);
  void setDecomp(const CompArea &area, const bool _isCoded = true);
  void setDecomp(const UnitArea &area, const bool _isCoded = true);

  const CodingUnit     *getCU(const Position &pos, const ChannelType _chType) const;
  const PredictionUnit *getPU(const Position &pos, const ChannelType _chType) const;
  const TransformUnit  *getTU(const Position &pos, const ChannelType _chType, const int subTuIdx = -1) const;

  CodingUnit     *getCU(const Position &pos, const ChannelType _chType);
  CodingUnit     *getLumaCU( const Position &pos );
  PredictionUnit *getPU(const Position &pos, const ChannelType _chType);
  TransformUnit  *getTU(const Position &pos, const ChannelType _chType, const int subTuIdx = -1);

  const CodingUnit     *getCU(const ChannelType &_chType) const { return getCU(area.blocks[_chType].pos(), _chType); }
  const PredictionUnit *getPU(const ChannelType &_chType) const { return getPU(area.blocks[_chType].pos(), _chType); }
  const TransformUnit  *getTU(const ChannelType &_chType) const { return getTU(area.blocks[_chType].pos(), _chType); }

  CodingUnit     *getCU(const ChannelType &_chType ) { return getCU(area.blocks[_chType].pos(), _chType); }
  PredictionUnit *getPU(const ChannelType &_chType ) { return getPU(area.blocks[_chType].pos(), _chType); }
  TransformUnit  *getTU(const ChannelType &_chType ) { return getTU(area.blocks[_chType].pos(), _chType); }

  const CodingUnit     *getCURestricted(const Position &pos, const Position curPos, const unsigned curSliceIdx, const unsigned curTileIdx, const ChannelType _chType) const;
  const CodingUnit     *getCURestricted(const Position &pos, const CodingUnit& curCu,                               const ChannelType _chType) const;
  const PredictionUnit *getPURestricted(const Position &pos, const PredictionUnit& curPu,                           const ChannelType _chType) const;
  const TransformUnit  *getTURestricted(const Position &pos, const TransformUnit& curTu,                            const ChannelType _chType) const;

  CodingUnit&     addCU(const UnitArea &unit, const ChannelType _chType);
  PredictionUnit& addPU(const UnitArea &unit, const ChannelType _chType);
  TransformUnit&  addTU(const UnitArea &unit, const ChannelType _chType);
  void            addEmptyTUs(Partitioner &partitioner);

  CUTraverser     traverseCUs(const UnitArea& _unit, const ChannelType _chType);
  PUTraverser     traversePUs(const UnitArea& _unit, const ChannelType _chType);
  TUTraverser     traverseTUs(const UnitArea& _unit, const ChannelType _chType);

  cCUTraverser    traverseCUs(const UnitArea& _unit, const ChannelType _chType) const;
  cPUTraverser    traversePUs(const UnitArea& _unit, const ChannelType _chType) const;
  cTUTraverser    traverseTUs(const UnitArea& _unit, const ChannelType _chType) const;
  // ---------------------------------------------------------------------------
  // encoding search utilities
  // ---------------------------------------------------------------------------

  static_vector<double, NUM_ENC_FEATURES> features;

  double      cost;
  bool        useDbCost;
  double      costDbOffset;
  double      lumaCost;
  uint64_t      fracBits;
  Distortion  dist;
  Distortion  interHad;
  TreeType    treeType; //because partitioner can not go deep to tu and cu coding (e.g., addCU()), need another variable for indicating treeType
  ModeType    modeType;

  void initStructData  (const int &QP = MAX_INT, const bool &skipMotBuf = false);
  void initSubStructure(      CodingStructure& cs, const ChannelType chType, const UnitArea &subArea, const bool &isTuEnc);

  void copyStructure   (const CodingStructure& cs, const ChannelType chType, const bool copyTUs = false, const bool copyRecoBuffer = false);
  void useSubStructure (const CodingStructure& cs, const ChannelType chType, const UnitArea &subArea, const bool cpyPred, const bool cpyReco, const bool cpyOrgResi, const bool cpyResi, const bool updateCost);
  void useSubStructure (const CodingStructure& cs, const ChannelType chType,                          const bool cpyPred, const bool cpyReco, const bool cpyOrgResi, const bool cpyResi, const bool updateCost) { useSubStructure(cs, chType, cs.area, cpyPred, cpyReco, cpyOrgResi, cpyResi, updateCost); }

  void clearTUs();
  void clearPUs();
  void clearCUs();
  const int signalModeCons( const PartSplit split, Partitioner &partitioner, const ModeType modeTypeParent ) const;
  void clearCuPuTuIdxMap  ( const UnitArea &_area, uint32_t numCu, uint32_t numPu, uint32_t numTu, uint32_t* pOffset );
  void getNumCuPuTuOffset ( uint32_t* pArray )
  {
    pArray[0] = m_numCUs;     pArray[1] = m_numPUs;     pArray[2] = m_numTUs;
    pArray[3] = m_offsets[0]; pArray[4] = m_offsets[1]; pArray[5] = m_offsets[2];
  }


private:
  void createInternals(const UnitArea& _unit, const bool isTopLayer, const bool isPLTused);

public:

  std::vector<    CodingUnit*> cus;
  std::vector<PredictionUnit*> pus;
  std::vector< TransformUnit*> tus;

  LutMotionCand motionLut;

  void addMiToLut(static_vector<MotionInfo, MAX_NUM_HMVP_CANDS>& lut, const MotionInfo &mi);

  PLTBuf prevPLT;
  void resetPrevPLT(PLTBuf& prevPLT);
  void reorderPrevPLT(PLTBuf& prevPLT, uint8_t curPLTSize[MAX_NUM_CHANNEL_TYPE], Pel curPLT[MAX_NUM_COMPONENT][MAXPLTSIZE], bool reuseflag[MAX_NUM_CHANNEL_TYPE][MAXPLTPREDSIZE], uint32_t compBegin, uint32_t numComp, bool jointPLT);
  void setPrevPLT(PLTBuf predictor);
  void storePrevPLT(PLTBuf& predictor);
private:

  // needed for TU encoding
  bool m_isTuEnc;

  unsigned *m_cuIdx   [MAX_NUM_CHANNEL_TYPE];
  unsigned *m_puIdx   [MAX_NUM_CHANNEL_TYPE];
  unsigned *m_tuIdx   [MAX_NUM_CHANNEL_TYPE];
  bool     *m_isDecomp[MAX_NUM_CHANNEL_TYPE];

  unsigned m_numCUs;
  unsigned m_numPUs;
  unsigned m_numTUs;

  CUCache& m_cuCache;
  PUCache& m_puCache;
  TUCache& m_tuCache;

  std::vector<SAOBlkParam> m_sao;

  PelStorage m_pred;
  PelStorage m_resi;
  PelStorage m_reco;
  PelStorage m_orgr;

  TCoeff *m_coeffs [ MAX_NUM_COMPONENT ];
  Pel    *m_pcmbuf [ MAX_NUM_COMPONENT ];
  bool   *m_runType[ MAX_NUM_CHANNEL_TYPE ];
  int     m_offsets[ MAX_NUM_COMPONENT ];

  MotionInfo *m_motionBuf;

public:
  CodingStructure *bestParent;
  double        tmpColorSpaceCost;
  bool          firstColorSpaceSelected;
  double        tmpColorSpaceIntraCost[2];
  bool          firstColorSpaceTestOnly;
  bool resetIBCBuffer;

  MotionBuf getMotionBuf( const     Area& _area );
  MotionBuf getMotionBuf( const UnitArea& _area ) { return getMotionBuf( _area.Y() ); }
  MotionBuf getMotionBuf()                        { return getMotionBuf(  area.Y() ); }

  const CMotionBuf getMotionBuf( const     Area& _area ) const;
  const CMotionBuf getMotionBuf( const UnitArea& _area ) const { return getMotionBuf( _area.Y() ); }
  const CMotionBuf getMotionBuf()                        const { return getMotionBuf(  area.Y() ); }

  MotionInfo& getMotionInfo( const Position& pos );
  const MotionInfo& getMotionInfo( const Position& pos ) const;


public:
  // ---------------------------------------------------------------------------
  // temporary (shadowed) data accessors
  // ---------------------------------------------------------------------------
         PelBuf       getPredBuf(const CompArea &blk);
  const CPelBuf       getPredBuf(const CompArea &blk) const;
         PelUnitBuf   getPredBuf(const UnitArea &unit);
  const CPelUnitBuf   getPredBuf(const UnitArea &unit) const;

         PelBuf       getResiBuf(const CompArea &blk);
  const CPelBuf       getResiBuf(const CompArea &blk) const;
         PelUnitBuf   getResiBuf(const UnitArea &unit);
  const CPelUnitBuf   getResiBuf(const UnitArea &unit) const;

         PelBuf       getRecoBuf(const CompArea &blk);
  const CPelBuf       getRecoBuf(const CompArea &blk) const;
         PelUnitBuf   getRecoBuf(const UnitArea &unit);
  const CPelUnitBuf   getRecoBuf(const UnitArea &unit) const;
         PelUnitBuf&  getRecoBufRef() { return m_reco; }

         PelBuf       getOrgResiBuf(const CompArea &blk);
  const CPelBuf       getOrgResiBuf(const CompArea &blk) const;
         PelUnitBuf   getOrgResiBuf(const UnitArea &unit);
  const CPelUnitBuf   getOrgResiBuf(const UnitArea &unit) const;

         PelBuf       getOrgBuf(const CompArea &blk);
  const CPelBuf       getOrgBuf(const CompArea &blk) const;
         PelUnitBuf   getOrgBuf(const UnitArea &unit);
  const CPelUnitBuf   getOrgBuf(const UnitArea &unit) const;

         PelBuf       getOrgBuf(const ComponentID &compID);
  const CPelBuf       getOrgBuf(const ComponentID &compID) const;
         PelUnitBuf   getOrgBuf();
  const CPelUnitBuf   getOrgBuf() const;


  // pred buffer
         PelBuf       getPredBuf(const ComponentID &compID)       { return m_pred.get(compID); }
  const CPelBuf       getPredBuf(const ComponentID &compID) const { return m_pred.get(compID); }
         PelUnitBuf   getPredBuf()                                { return m_pred; }
  const CPelUnitBuf   getPredBuf()                          const { return m_pred; }

  // resi buffer
         PelBuf       getResiBuf(const ComponentID compID)        { return m_resi.get(compID); }
  const CPelBuf       getResiBuf(const ComponentID compID)  const { return m_resi.get(compID); }
         PelUnitBuf   getResiBuf()                                { return m_resi; }
  const CPelUnitBuf   getResiBuf()                          const { return m_resi; }

  // org-resi buffer
         PelBuf       getOrgResiBuf(const ComponentID &compID)       { return m_orgr.get(compID); }
  const CPelBuf       getOrgResiBuf(const ComponentID &compID) const { return m_orgr.get(compID); }
         PelUnitBuf   getOrgResiBuf()                                { return m_orgr; }
  const CPelUnitBuf   getOrgResiBuf()                          const { return m_orgr; }

  // reco buffer
         PelBuf       getRecoBuf(const ComponentID compID)         { return m_reco.get(compID); }
  const CPelBuf       getRecoBuf(const ComponentID compID)   const { return m_reco.get(compID); }
         PelUnitBuf   getRecoBuf()                                 { return m_reco; }
  const CPelUnitBuf   getRecoBuf()                           const { return m_reco; }

private:

  inline        PelBuf       getBuf(const CompArea &blk,  const PictureType &type);
  inline const CPelBuf       getBuf(const CompArea &blk,  const PictureType &type) const;
  inline        PelUnitBuf   getBuf(const UnitArea &unit, const PictureType &type);
  inline const CPelUnitBuf   getBuf(const UnitArea &unit, const PictureType &type) const;
};


static inline uint32_t getNumberValidTBlocks(const PreCalcValues& pcv) { return (pcv.chrFormat==CHROMA_400) ? 1 : ( pcv.multiBlock422 ? MAX_NUM_TBLOCKS : MAX_NUM_COMPONENT ); }

#endif

weixin_45133943
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VVC/H.266代码阅读（VTM8.0）(一. NALU提取)
曹健的博客
05-02 4060
VVC（Versatile Video Coding）是下一代视频编解码标准，目前仍在制定阶段。本系列博客从解码端入手，结合标准draft一步步分析相关代码，深入理解VVC的编解码过程。 本文是本系列的第一篇博客，内容是分析解码端将收到的二进制码流bin文件提取成一个个NALU的过程。
VVC学习之四：VTM中的数据结构——Position，Size，Area，compArea，UnitArea
Aidoneus_y
04-28 1946
Position struct Position {   PosType x;   PosType y;   Position()                   &nbsp...
xCheckModeSplit()中的useSubStructure()函数，releaseIntermediateData()函数解析，add()函数解析（getBuf()函数没看）
dfhg54的博客
06-01 372
主要作用：将子cu的最优模式信息copy到tempCS中 releaseIntermediateData()函数： 明天写
H.266/VVC代码学习：去块滤波Deblock代码一
BigDream123的博客
04-21 1040
最近整个人感觉完全不在状态，什么都看不进，所以准备重新开始学习VTM10.0的代码，找找状态，顺带学习一些新技术。 去块滤波技术的原理参考：去块滤波 VTM中，去块滤波代码的入口函数是loopFilterPic函数，在该函数中遍历全部CU，对每个调用xDeblockCU函数进行去块滤波。 首先对垂直边界进行滤波，再对水平边界滤波。对每一个方向的边界，通过pcv中的widthInCtus和heightInCtus参数遍历全部CTU，再通过cs.traverseCUs函数遍历CTU中所有的CU，针对每个C
H.266/VVC代码学习:xCheckModeSplit函数
BigDream123的博客
08-02 1530
xCheckModeSplit函数主要是根据划分类型对当前CU进行划分，然后调用xCompressCU函数对划分后的子CU进一步划分和模式选择。 这里，传入到xCheckModeSplit函数的tempCS和bestCS是待划分CU对应的CS结构，在xCheckModeSplit函数中调用的xCompressCU函数传递的tempCS和bestCS参数是根据划分后子CU的尺寸从m_pTempCS和m_pBestCS得到的Coding Structure结构，要注意区分tempCS和bestCS。 xCh
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中一些4K序列
10-24
VVC一些比较难找的4K测试序列：FoodMarket，后续会继续更新，部分4K序列压缩后太大，没法上传，有需要的私信就可以
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 ...
BMS/VTM代码学习：decompressSlice函数
慢慢积累
07-14 884
今天正式转入BMS代码的学习，最近在干解码端的东西，就从解码这边开始看了。先来看decompressSlice函数。在之前的 HEVC代码学习38：decompressSlice函数 中已经讲过HM中的两个decompressSlice函数，BMS中整合为一个decompressSlice函数，变化不大。 DecSlice::decompressSlice 该函数比较简单，是解码一帧图像的上层...
关于语法节点Tree、类型Type和符号Symbol
05-24 987
每个语法节点Tree都有Type属性，部分的语法节点有Symbol属性，如下： 与Symbol类型与Type类型之间的关系如下： 下面是Symbol与Type之间的关系： （1）MethodSymbol("finalize").type = MethodType("()void").tsym= ClassSymbol("Method").type=...
VVC 代码阅读 compressCtu()函数
dfhg54的博客
04-14 533
void EncCu::compressCtu( CodingStructure& cs, const UnitArea& area, const unsigned ctuRsAddr, const int prevQP[], const int currQP[] ) VTM3.0代码阅读：compressCtu函数_矛盾统一的博客-CSDN博客 H.266/VVC代码学习13：VTM4.0中的CU层操作（compressCtu 、 xCompressCU）_海洋之心。的博客-CSD..
VVC块划分
热门推荐
Dillon2015的博客
12-03 5万+
VVC和HEVC与AVC一样，都是基于块的混合编码框架，其编码流程也都类似。下图是VVC的编码架构。 VVC和HEVC的块划分有很多类似的地方，同时划分方式、形状、尺寸等又有很多不同。 1、slices，tiles和bricks划分 VVC里的slice和tile跟HEVC是一样的。 一帧图像被划分为一个或多个tile行和tile列，每个tile是一个矩形区域包含整数个CTU。 ...
VVC学习之四：VTM中的数据结构——描述
Aidoneus_y
04-26 3167
VTM中的数据结构 HM的代码复杂难懂，结构混乱，缺少数据和逻辑封装，Z-order和raster-order换来换去让人头痛不已，代码可读性比较差。同时HM中很多数据结构的设计都是针对其CU尺寸都是正方形而设计的，扩展性也不好。 为了解决HM数据结构复杂、代码可读性差、内存管理负责的问题，VTM使用的数据结构，使用了OO设计理念，对琐碎的计算进行封装，并跟内存管理逻辑，增强代码的可读性。 （移除...
H.266/VVC代码学习3：VTM4.0中的CTU层操作（encodeCtus）
时间有泪
02-23 3967
由于要研究比特数的相关内容，本周阅读了encodeCtus。学习笔记如下： void EncSlice::encodeCtus( Picture* pcPic, const bool bCompressEntireSlice, const bool bFastDeltaQP, uint32_t startCtuTsAddr, uint32_t boundingCtuTsAddr, EncLib* ...
H.266/VVC代码学习4：VTM代码整体结构及最上层函数
时间有泪
03-02 7041
最近在做一些较上层的内容，从老师和师兄师姐的博客里学到了很多，对VTM代码有了进一步的理解。VTM4.0代码整体结构如下，并会后面分别介绍几个主要函数的作用。 EncSlice::encodeCtus 大体操作：以CTU为单位，对划分后的内容进行熵编码。 每个slice为一帧。一帧中对所有CTU（128*128）都进行编码（for循环每个CTU，分别调用compressCtu函数），具体来说主要...
H.266/VVC-VTM代码学习-帧内预测15-解码端解压缩decompressCtu函数及xReconIntraQT调用xIntraRecQT函数完成帧内预测重建
liaojq2020的博客
11-27 662
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习-帧内预测13-ISP模式在estIntraPredLumaQT中的设定（1） 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、RD cost细选时ISP模式相关代码1.estIntraPredLumaQT函数中RD cost细选时对为ISP预留的候选模式进行处理2.xSortISPCandList函数准备使用RD cost测试的潜在帧内模式候选列表（入口在1中）3.xGetNextISPMode函数决定ISP列表中的哪个模式
GOP、IDR、SPS、PPS、SS等视频编码术语
qq542794284的博客
11-23 2801
缩写 全称 GOP group of pictures IDR instantaneous decoding refresh（即时解码刷新） SS slice segment CTU coding tree unit SPS sequence parameter set, 序列参数集(解码相关信息，档次级别、分别率、某档次中编码工具开关标识和涉及的参数、时域可分级信息等) PPS picture parameter set, 图像参数集（一幅图像所用的公共参数，一幅图像...
ffmpeg安装vvc
最新发布
05-21
要使用FFmpeg进行VVC编解码，需要安装支持VVC的x265编码器和VVC的HEVC运动估计器（HM）。以下是基本的安装步骤： 1. 下载和安装HEVC运动估计器（HM）： - 下载HM源代码，解压缩并进入目录。 - 运行“make”命令...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值