VTM数据结构2

最新推荐文章于 2022-11-28 17:42:46 发布
最新推荐文章于 2022-11-28 17:42:46 发布
阅读量2.6k 收藏 1
点赞数 1
分类专栏： VTM 文章标签： 视频编解码 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cx52039/article/details/124127972
版权

VTM数据结构2

文章目录

前言

学习CompArea,UnitArea前参考VTM数据结构1
VTM数据结构1
VTM数据结构：CompArea,UnitArea
这两种自定义的数据类型继承于Area

提示：以下是本篇文章正文内容，下面案例可供参考
这两种自定义数据类型在CommonLib/Unit.h中定义

一、CompArea

简介：CopArea继承自Area,用来表示特定分量的二维信息
注意：CompArea作为子类，添加了ChromaFormat型的成员，以及ComponentID型的成员，这两种都是美剧类型的变量。

ChromaFormat和ComponentID枚举类型的定义

enum ChromaFormat
{
  CHROMA_400        = 0,
  CHROMA_420        = 1,
  CHROMA_422        = 2,
  CHROMA_444        = 3,
  NUM_CHROMA_FORMAT = 4
};

enum ComponentID
{
  COMPONENT_Y         = 0,
  COMPONENT_Cb        = 1,
  COMPONENT_Cr        = 2,
  MAX_NUM_COMPONENT   = 3,
  MAX_NUM_TBLOCKS     = MAX_NUM_COMPONENT
};

VTM对CompArea的定义：

struct CompArea : public Area
{
  CompArea() : Area(), chromaFormat(NUM_CHROMA_FORMAT), compID(MAX_NUM_TBLOCKS)                                                                                                                                 { }  //参数初始化列表
  //以给出了
  CompArea(const ComponentID _compID, const ChromaFormat _cf, const Area &_area, const bool isLuma = false)                                          : Area(_area),          chromaFormat(_cf), compID(_compID) { if (isLuma) xRecalcLumaToChroma(); }
  CompArea(const ComponentID _compID, const ChromaFormat _cf, const Position& _pos, const Size& _size, const bool isLuma = false)                    : Area(_pos, _size),    chromaFormat(_cf), compID(_compID) { if (isLuma) xRecalcLumaToChroma(); }
  CompArea(const ComponentID _compID, const ChromaFormat _cf, const uint32_t _x, const uint32_t _y, const uint32_t _w, const uint32_t _h, const bool isLuma = false) : Area(_x, _y, _w, _h), chromaFormat(_cf), compID(_compID) { if (isLuma) xRecalcLumaToChroma(); }

  ChromaFormat chromaFormat;   //新增的成员变量
  ComponentID compID;     //新增的成员变量

  Position chromaPos() const;
  Position lumaPos()   const;

  Size     chromaSize() const;
  Size     lumaSize()   const;

  Position compPos( const ComponentID compID ) const;
  Position chanPos( const ChannelType chType ) const;

  Position topLeftComp    (const ComponentID _compID) const { return recalcPosition(chromaFormat, compID, _compID, *this);                                                     }
  Position topRightComp   (const ComponentID _compID) const { return recalcPosition(chromaFormat, compID, _compID, { (PosType) (x + width - 1), y                          }); }
  Position bottomLeftComp (const ComponentID _compID) const { return recalcPosition(chromaFormat, compID, _compID, { x                        , (PosType) (y + height - 1 )}); }
  Position bottomRightComp(const ComponentID _compID) const { return recalcPosition(chromaFormat, compID, _compID, { (PosType) (x + width - 1), (PosType) (y + height - 1 )}); }

  bool valid() const { return chromaFormat < NUM_CHROMA_FORMAT && compID < MAX_NUM_TBLOCKS && width != 0 && height != 0; }   //校验数据有效

  const bool operator==(const CompArea &other) const   //重载==，
  {
    if (chromaFormat != other.chromaFormat) return false;
    if (compID       != other.compID)       return false;

    return Position::operator==(other) && Size::operator==(other);    //利用父类的重载，
  }

  const bool operator!=(const CompArea &other) const { return !(operator==(other)); }    //重载！=

#if REUSE_CU_RESULTS_WITH_MULTIPLE_TUS
  void     resizeTo          (const Size& newSize)          { Size::resizeTo(newSize); }
#endif
  void     repositionTo      (const Position& newPos)       { Position::repositionTo(newPos); }
  void     positionRelativeTo(const CompArea& origCompArea) { Position::relativeTo(origCompArea); }

private:

  void xRecalcLumaToChroma();
};

二、UnitArea

简介：UnitArea中存放了ChromaFormat型以及CompArea型的数据

1.static_vector的封装

类模板static_vector

template<typename T, size_t N>
class static_vector
{
  T _arr[ N ];
  size_t _size;

public:

  typedef T         value_type;
  typedef size_t    size_type;
  typedef ptrdiff_t difference_type;
  typedef T&        reference;
  typedef T const&  const_reference;
  typedef T*        pointer;
  typedef T const*  const_pointer;
  typedef T*        iterator;
  typedef T const*  const_iterator;

  static const size_type max_num_elements = N;

  static_vector() : _size( 0 )                                 { }
  static_vector( size_t N_ ) : _size( N_ )                     { }
  static_vector( size_t N_, const T& _val ) : _size( 0 )       { resize( N_, _val ); }
  template<typename It>
  static_vector( It _it1, It _it2 ) : _size( 0 )               { while( _it1 < _it2 ) _arr[ _size++ ] = *_it1++; }
  static_vector( std::initializer_list<T> _il ) : _size( 0 )
  {
    typename std::initializer_list<T>::iterator _src1 = _il.begin();
    typename std::initializer_list<T>::iterator _src2 = _il.end();

    while( _src1 < _src2 ) _arr[ _size++ ] = *_src1++;

    CHECKD( _size > N, "capacity exceeded" );
  }
  static_vector& operator=( std::initializer_list<T> _il )
  {
    _size = 0;

    typename std::initializer_list<T>::iterator _src1 = _il.begin();
    typename std::initializer_list<T>::iterator _src2 = _il.end();

    while( _src1 < _src2 ) _arr[ _size++ ] = *_src1++;

    CHECKD( _size > N, "capacity exceeded" );
  }

  void resize( size_t N_ )                      { CHECKD( N_ > N, "capacity exceeded" ); while(_size < N_) _arr[ _size++ ] = T() ; _size = N_; }
  void resize( size_t N_, const T& _val )       { CHECKD( N_ > N, "capacity exceeded" ); while(_size < N_) _arr[ _size++ ] = _val; _size = N_; }
  void reserve( size_t N_ )                     { CHECKD( N_ > N, "capacity exceeded" ); }
  void push_back( const T& _val )               { CHECKD( _size >= N, "capacity exceeded" ); _arr[ _size++ ] = _val; }
  void push_back( T&& val )                     { CHECKD( _size >= N, "capacity exceeded" ); _arr[ _size++ ] = std::forward<T>( val ); }
  void pop_back()                               { CHECKD( _size == 0, "calling pop_back on an empty vector" ); _size--; }
  void pop_front()                              { CHECKD( _size == 0, "calling pop_front on an empty vector" ); _size--; for( int i = 0; i < _size; i++ ) _arr[i] = _arr[i + 1]; }
  void clear()                                  { _size = 0; }
  reference       at( size_t _i )               { CHECKD( _i >= _size, "Trying to access an out-of-bound-element" ); return _arr[ _i ]; }
  const_reference at( size_t _i ) const         { CHECKD( _i >= _size, "Trying to access an out-of-bound-element" ); return _arr[ _i ]; }
  reference       operator[]( size_t _i )       { CHECKD( _i >= _size, "Trying to access an out-of-bound-element" ); return _arr[ _i ]; }
  const_reference operator[]( size_t _i ) const { CHECKD( _i >= _size, "Trying to access an out-of-bound-element" ); return _arr[ _i ]; }
  reference       front()                       { CHECKD( _size == 0, "Trying to access the first element of an empty vector" ); return _arr[ 0 ]; }
  const_reference front() const                 { CHECKD( _size == 0, "Trying to access the first element of an empty vector" ); return _arr[ 0 ]; }
  reference       back()                        { CHECKD( _size == 0, "Trying to access the last element of an empty vector" );  return _arr[ _size - 1 ]; }
  const_reference back() const                  { CHECKD( _size == 0, "Trying to access the last element of an empty vector" );  return _arr[ _size - 1 ]; }
  pointer         data()                        { return _arr; }
  const_pointer   data() const                  { return _arr; }
  iterator        begin()                       { return _arr; }
  const_iterator  begin() const                 { return _arr; }
  const_iterator  cbegin() const                { return _arr; }
  iterator        end()                         { return _arr + _size; }
  const_iterator  end() const                   { return _arr + _size; };
  const_iterator  cend() const                  { return _arr + _size; };
  size_type       size() const                  { return _size; };
  size_type       byte_size() const             { return _size * sizeof( T ); }
  bool            empty() const                 { return _size == 0; }

  size_type       capacity() const              { return N; }
  size_type       max_size() const              { return N; }
  size_type       byte_capacity() const         { return sizeof(_arr); }

  iterator        insert( const_iterator _pos, const T& _val )
                                                { CHECKD( _size >= N, "capacity exceeded" );
                                                  for( difference_type i = _size - 1; i >= _pos - _arr; i-- ) _arr[i + 1] = _arr[i];
                                                  *const_cast<iterator>( _pos ) = _val;
                                                  _size++;
                                                  return const_cast<iterator>( _pos ); }

  iterator        insert( const_iterator _pos, T&& _val )
                                                { CHECKD( _size >= N, "capacity exceeded" );
                                                  for( difference_type i = _size - 1; i >= _pos - _arr; i-- ) _arr[i + 1] = _arr[i];
                                                  *const_cast<iterator>( _pos ) = std::forward<T>( _val );
                                                  _size++; return const_cast<iterator>( _pos ); }
  template<class InputIt>
  iterator        insert( const_iterator _pos, InputIt first, InputIt last )
                                                { const difference_type numEl = last - first;
                                                  CHECKD( _size + numEl >= N, "capacity exceeded" );
                                                  for( difference_type i = _size - 1; i >= _pos - _arr; i-- ) _arr[i + numEl] = _arr[i];
                                                  iterator it = const_cast<iterator>( _pos ); _size += numEl;
                                                  while( first != last ) *it++ = *first++;
                                                  return const_cast<iterator>( _pos ); }
};

UnitArea定义：

typedef static_vector<CompArea, MAX_NUM_TBLOCKS> UnitBlocksType;

struct UnitArea
{
  ChromaFormat chromaFormat;
  UnitBlocksType blocks;

  UnitArea() : chromaFormat(NUM_CHROMA_FORMAT) { }
  UnitArea(const ChromaFormat _chromaFormat);
  UnitArea(const ChromaFormat _chromaFormat, const Area &area);
  UnitArea(const ChromaFormat _chromaFormat, const CompArea  &blkY);
  UnitArea(const ChromaFormat _chromaFormat,       CompArea &&blkY);
  UnitArea(const ChromaFormat _chromaFormat, const CompArea  &blkY, const CompArea  &blkCb, const CompArea  &blkCr);
  UnitArea(const ChromaFormat _chromaFormat,       CompArea &&blkY,       CompArea &&blkCb,       CompArea &&blkCr);

//在static_vector中重载了[],实际上就是返回对应
        CompArea& Y()                                  { return blocks[COMPONENT_Y];  }//这里重载了[],返回的时_arr数组中对应的分量
  const CompArea& Y()                            const { return blocks[COMPONENT_Y];  }
        CompArea& Cb()                                 { return blocks[COMPONENT_Cb]; }
  const CompArea& Cb()                           const { return blocks[COMPONENT_Cb]; }
        CompArea& Cr()                                 { return blocks[COMPONENT_Cr]; }
  const CompArea& Cr()                           const { return blocks[COMPONENT_Cr]; }

        CompArea& block(const ComponentID comp)       { return blocks[comp]; }
  const CompArea& block(const ComponentID comp) const { return blocks[comp]; }

  bool contains(const UnitArea& other) const;
  bool contains(const UnitArea& other, const ChannelType chType) const;

        CompArea& operator[]( const int n )       { return blocks[n]; }
  const CompArea& operator[]( const int n ) const { return blocks[n]; }

  const bool operator==(const UnitArea &other) const
  {
    if (chromaFormat != other.chromaFormat)   return false;
    if (blocks.size() != other.blocks.size()) return false;

    for (uint32_t i = 0; i < blocks.size(); i++)
    {
      if (blocks[i] != other.blocks[i]) return false;
    }

    return true;
  }

#if REUSE_CU_RESULTS_WITH_MULTIPLE_TUS
  void resizeTo    (const UnitArea& unit);
#endif
  void repositionTo(const UnitArea& unit);

  const bool operator!=(const UnitArea &other) const { return !(*this == other); }

  const Position& lumaPos () const { return Y(); }
  const Size&     lumaSize() const { return Y(); }

  const Position& chromaPos () const { return Cb(); }
  const Size&     chromaSize() const { return Cb(); }

  const UnitArea  singleComp(const ComponentID compID) const;
  const UnitArea  singleChan(const ChannelType chType) const;

  const SizeType  lwidth()  const { return Y().width; }  /*! luma width  */
  const SizeType  lheight() const { return Y().height; } /*! luma height */

  const PosType   lx() const { return Y().x; }           /*! luma x-pos */
  const PosType   ly() const { return Y().y; }           /*! luma y-pos */

  bool valid() const { return chromaFormat != NUM_CHROMA_FORMAT && blocks.size() > 0; }
};

总结

CompArea提供了单个分量的信息，UnitArea相当于是CompArea类型的数组，存储多个分量的信号。

static_vector这个类模板的设计很巧妙，相当于设计了一个类似vector容器的结构，相比于vector容器有了长度的限定。

【十八】 H.266/VVC | VTM数据结构学习笔记
weixin_45615071的博客
09-25 1566
一、HM的缺陷 1、复杂的数据结构 Z索引 不明确的数据模型(TComDateCU) 2、槽糕的代码可读性 复杂的内存操作与一般的数据流混杂在一起 缺乏数据和逻辑封装 3、复杂的可扩展性 数据结构的设计由严格的假设(例如：方块) 很多的想法因为扩展性的复杂而被放弃 二、VTM的设计原则 1、简单明确的数据模型：采用现代O-O设计原则，快速且前言 2、全局像素寻址 消除Z索引的使用 消除2级(CUT->Z索引)信号寻址 3、简单操作的封装(例如：内存操作)：允许一般流程更好的可读性 .
VTM的编码结构
weixin_42080965的博客
11-27 1177
VTM的编码结构 基本数据 Position: (x,y) 对应一个像素点的位置； Size: (width,height); 对应一个(width * height)的矩形区域； Area: (position,size) / (x,y,width,height); 对应一个像素位置为(x,y)，大小为(width * height)的矩形区域。 CompArea: (Area, C...
VTM数据结构1
cx52039的博客
04-11 3140
VTM数据结构学习1 文章目录VTM数据结构学习1前言**VTM的基本数据结构 Size,Position,Area** 这些数据信息对二维信息进行了基本的描述，提供了宽，高，以及位置坐标信息。这些信息在CommonLib/Common.h中定义一、Position二、Size简介：Size提供一个矩形块的宽高信息 VTM对Size的定义：Area简介：Area继承于Position和Size总结 前言 VTM的基本数据结构 Size,Position,Area 这些数据信息对二维信息进行了基本的描述，
VTM数据结构3
cx52039的博客
04-14 1166
VTM数据结构3 文章目录VTM数据结构3前言一、AreaBuf1.定义2.内存操作方法的定义二、UnitBuf1.定义2.内存操作三、PelStorage总结 前言 VTM对AreaBuf,UnitBuf,PelStorage的定义在CommonLib/Buffer.h中 简介： VTM中AreaBuf,UnitBuf,PelStorage描述了二维视频信号在内存中的操作，可以根据位置来访问到相应的信号值。 它们以结构体模板的方式来书写,其中AeraBuf为UnitArea提供了一种数据类型，而Pel
VTM数据结构学习
pinkelectronic的博客
10-13 1060
学习
VVC学习之四：VTM中的数据结构——CodingUnit、PredictionUnit、TransformUnit
Aidoneus_y
04-30 2371
文章目录CodingUnitPredictionUnitTransformUnit 基本单元的数据结构中，只定义了CU、PU、TU的属性信息，其头文件为Unit.h。对基本单元的操作定义在UnitTools.h中，为区分对不同基本单元的操作，定义了不同命名空间。 CodingUnit 描述UnitArea定义的区域的压缩方法和方式。 struct CodingUnit : public UnitA...
VVCSoftware_VTM-VTM-11.0
04-14
【标签】"编码"指明了讨论的主要领域，即视频数据的压缩和传输技术，这是数字媒体处理的关键环节，特别是在网络流媒体和存储空间有限的设备上。 在视频编码领域，VVC（Versatile Video Coding）是由ITU-T的VCEG...
数据结构1
08-08
数据结构在计算机科学中扮演着至关重要的角色，特别是在编程和算法设计中。在这个场景中，我们讨论的是"数据结构1"，它涉及到一种名为CodingStructure的类，这是视频编码技术中一个基础且核心的组件。...
VVC/VTM参考软件数据结构（翻译加解读）
RJzz
07-13 2805
本文是对VVC参考软件下doc目录中的NextSoftware-Data Structure的一个翻译 动机 HM的缺点 复杂的数据结构 Z-index 令人产生歧义的数据模型（TComDataCu） 糟糕的代码可读性 复杂的内存操作与一般的数据流混合在一起 缺乏数据和逻辑封装 复杂的可拓展性 ...
VVC学习之四：VTM中的数据结构——AreaBuf，UnitBuf
Aidoneus_y
05-06 1706
文章目录AreaBuf AreaBuf，UnitBuf 封装了二维视频信号的一维存储下的内存管理方法，提供了简单内存操作接口。 AreaBuf AreaBuf是一个类模板，AreaBuf采用了通用数据类型成员，VTM中以AreaBuf为模板实例化6个模板类，分别管理像素、变换系数和运动信息的存储和访问，如下： typedef AreaBuf< Pel> PelBuf; typedef...
VTM输出Dxf
03-25
一直找不到转换的方法 这下好了 VTM输出Dxf
VVC学习之四：VTM中的数据结构——Position，Size，Area，compArea，UnitArea
Aidoneus_y
04-28 2034
Position struct Position {   PosType x;   PosType y;   Position()                   &nbsp...
【C++语法】枚举类型enum类型变量
allensu374125056的博客
04-23 639
一般语法：enum <类型名> {<枚举常量表>}; enum color_set1 {RED, BLUE, WHITE, BLACK}; VVC中的ComponentID 是分量类型，亮度色度，Y通道为0等等 enum ComponentID { COMPONENT_Y = 0, COMPONENT_Cb = 1, COMPON...
TComPicYuv、TComPic、TComPicSym、TComDataCU以及TComYuv的关系
最新发布
qq_46613874的博客
11-28 460
TComPicYuv、TComPic、TComPicSym、TComDataCU以及TComYuv的关系
H.266/VVC-VTM代码学习20-CU层进行RDO函数xCompressCU
liaojq2020的博客
04-16 2162
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习19-CU层确定测试模式函数initCULevel 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、函数作用二、函数详解 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准规范与细节。 本文是笔者对VTM代码的一点学习记录，成文于笔者刚开始接触VVC期间，期间很多概念和理论框架还很不成熟，若文中存在错误欢迎批评指正，也欢迎广大视频编码学习者沟通交流、共同进步。 VTM
VTM代码学习 01一 DATA STRUCTURES
小惊大怪的博客
04-25 1648
相较于上一代参考软件HM， z-index 类等函数叠加顺序上不优，TcomdataCU这个数据模型太模糊。等等细节问题。 加入了面向对象设计程序， 取消了z-index的使用，消除CTU->z-index的信号寻址。 TComDataCU 存储编码信息, 可能代表一个CU或CTU(包含多个CU),图像位置到编码信息的映射 TComTU 不包含实际数据，而是包装TComDataCU TComPicYuv 存储视频信号 ...
H.266新参考软件VTM中的数据结构
小小柴的博客
05-25 3788
     从今天开始研究新的266的参考软件啦----VTM，先来看看新代码中的数据结构。     在以前的HM中，有三个很重要的数据结构，分别为TComDataCU,TComTU,TComPicYuv;       TComDataCU----  存储编码信息；表示一个CU或者CTU；图像位置到编码信息的的映射；       TComTU----允许更简单的TU结构指引的对象； 不包含实际的数据...
chrome沙盒_我对Chrome沙盒逃生漏洞利用链的看法
weixin_26707241的博客
09-11 732
chrome沙盒Google’s Project Zero published a blog post explaining an exploit chain that bypass the Chrome browser sandbox. In this post, I will try to discuss my take on trying to understand the exploit ...
HEVC函数入门（2）——帧内编码一个CU
不是他人太努力，只是自己努力不够罢了
06-18 2183
这里依然整理自http://blog.csdn.net/shaqoneal/article/details/37500715 且阅读CU这部分主要对我而言是为了QP。另外一个方向是Tile不要迷失啦！！！ 提醒我自己看http://blog.csdn.net/leixiaohua1020/article/details/46483721?locationNum=15&fps=1 在一个comp
VTM使用方法与技巧全面指南
2. VTM的核心功能：详细描述VTM能提供哪些具体服务，例如账户查询、交易处理、身份验证、贷款咨询等。 3. VTM的工作原理：介绍VTM如何通过视频通话实现与银行工作人员的远程交互，以及其安全性和可靠性。 4. VTM的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值