VVC学习之四：VTM中的数据结构——Position，Size，Area，compArea，UnitArea

最新推荐文章于 2022-04-12 20:22:03 发布
最新推荐文章于 2022-04-12 20:22:03 发布
阅读量2.1k 收藏 25
点赞数 8
分类专栏： VVC/H.266学习日记 文章标签： VTM data structure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012038173/article/details/89634650
版权

文章目录

Position

struct Position
{
  PosType x;
  PosType y;

  Position()                                   : x(0),  y(0)  { }
  Position(const PosType _x, const PosType _y) : x(_x), y(_y) { }
  
  bool operator!=(const Position &other)   const { return x != other.x || y != other.y; }
  bool operator==(const Position &other)  const { return x == other.x && y == other.y; }

  Position offset(const Position pos)                                   const { return Position(x + pos.x, y + pos.y); }
  Position offset(const PosType _x, const PosType _y)       const { return Position(x + _x   , y + _y   ); }
  void     repositionTo(const Position newPos)               { x  = newPos.x; y  = newPos.y; }
  void     relativeTo  (const Position origin)                     { x -= origin.x; y -= origin.y; }

  Position operator-( const Position &other )         const { return{ x - other.x, y - other.y }; }
};

在这里插入图片描述

Size

struct Size

{
  SizeType width;
  SizeType height;

  Size()                                              : width(0),      height(0)       { }
  Size(const SizeType _width, const SizeType _height) : width(_width), height(_height) { }

  bool operator!=(const Size &other)      const { return (width != other.width) || (height != other.height); }
  bool operator==(const Size &other)      const { return (width == other.width) && (height == other.height); }
  uint32_t area()                             const { return (uint32_t) width * (uint32_t) height; }
  void resizeTo(const Size newSize)             { width = newSize.width; height = newSize.height; }
};

在这里插入图片描述

Area

struct Area : public Position, public Size

{
  Area()                                                                         : Position(),       Size()       { }
  Area(const Position &_pos, const Size &_size)                                  : Position(_pos),   Size(_size)  { }
  Area(const PosType _x, const PosType _y, const SizeType _w, const SizeType _h) : Position(_x, _y), Size(_w, _h) { }

        Position& pos()                           { return *this; }
  const Position& pos()                     const { return *this; }
        Size&     size()                          { return *this; }
  const Size&     size()                    const { return *this; }

  const Position& topLeft()                 const { return *this; }
        Position  topRight()                const { return { (PosType) (x + width - 1), y                          }; }
        Position  bottomLeft()              const { return { x                        , (PosType) (y + height - 1) }; }
        Position  bottomRight()             const { return { (PosType) (x + width - 1), (PosType) (y + height - 1) }; }
        Position  center()                  const { return { (PosType) (x + width / 2), (PosType) (y + height / 2) }; }

  bool contains(const Position &_pos)       const { return (_pos.x >= x) && (_pos.x < (x + width)) && (_pos.y >= y) && (_pos.y < (y + height)); }
  bool contains(const Area &_area)          const { return contains(_area.pos()) && contains(_area.bottomRight()); }

  bool operator!=(const Area &other)        const { return (Size::operator!=(other)) || (Position::operator!=(other)); }
  bool operator==(const Area &other)        const { return (Size::operator==(other)) && (Position::operator==(other)); }
};

在这里插入图片描述

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

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);

        CompArea& Y()                                  { return blocks[COMPONENT_Y];  }
  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; }
};

在这里插入图片描述

数据结构——链表
weixin_42597880的博客
04-19 518
单链表 线性表的链式存储，包含两个域，一个存储的值(this.data)，一个指向下一个链表节点(this.next)。 封装链表类，添加链表的属性：链表节点、头部（链表的起始点）、长度。 // 封装链表类 function LinkedList() { // 内部的类：节点类 function Node(data) { this.d...
VVC/VTM：代码学习——三角划分模式TPM
Moomin的博客
04-26 1212
主体函数为xCheckRDCostMergeTriangle2Nx2N（），进行三角划分模式预测 void EncCu::xCheckRDCostMergeTriangle2Nx2N( CodingStructure *&tempCS, CodingStructure *&bestCS, Partitioner &partitioner, const EncTestMode...
删除方法
u011746310的专栏
09-25 521
template Error_code List::remove(int position) {if(count==0) if(position=count) return rareg_error; x=entry[position]; for(int i=position;i entry[i]=entry[i+1]; }
《数据结构》学习笔记-第三章 列表（逻辑型线性序列call-by-position）
玉帝
04-03 413
邓俊辉《数据结构》学习笔记-第三章 列表（自用）1.接口与实现1.1 ListNode（列表的基本元素）1.2 List2.无序列表2.1 查找（重点！注意语义！）2.2 插入和构造2.2.1 插入2.2.2 基于复制的构造2.3 删除和析构2.3.1 删除2.3.2 析构2.4 唯一化（考察前驱）3.有序列表3.1 唯一化（考察后继）3.2 查找4.排序（无序->有序）4.1 select...
Position 详解
糖衣
10-31 2229
Position 属性规定元素的定位类型，其可用属性为：absolute：生成绝对定位的元素，相对于 static 定位以外的第一个 父元素进行定位。fixed：生成绝对定位的元素，相对于浏览器窗口进行定位。relative：生成相对定位的元素，相对于其正常位置进行定位。static：默认值。没有定位，元素出现在正常流中。inherit：规定应该从父元素继承 position 属性的值。
POSITION定义
paobo的专栏
12-29 1690
 VC的基本头文件AFX.h里对POSITION是这样定义的：     struct   __POSITION   {   };     typedef   __POSITION*   POSITION     显然这里定义了一个没有任何字段的结构体，而POSITION是这个结构体的指针。         VC在使用CList时，一些函数往往用POSITION参数，或者返回POSITION类型，其
【十八】 H.266/VVC | VTM数据结构学习笔记
weixin_45615071的博客
09-25 1669
一、HM的缺陷 1、复杂的数据结构 Z索引 不明确的数据模型(TComDateCU) 2、槽糕的代码可读性 复杂的内存操作与一般的数据流混杂在一起 缺乏数据和逻辑封装 3、复杂的可扩展性 数据结构的设计由严格的假设(例如：方块) 很多的想法因为扩展性的复杂而被放弃 二、VTM的设计原则 1、简单明确的数据模型：采用现代O-O设计原则，快速且前言 2、全局像素寻址 消除Z索引的使用 消除2级(CUT->Z索引)信号寻址 3、简单操作的封装(例如：内存操作)：允许一般流程更好的可读性 .
VVC/VTM：帧间预测——Decoder side motion vector refinement (DMVR)
Moomin的博客
04-15 2896
Decoder side motion vector refinement (DMVR) 在第13次Marrakech会议之后被写入标准（初次出现在JVET-M1002文档中） 为了增加merge模式中MV的准确度，VTM4.0中采用了一种基于解码端MV refinement的双边匹配（bilateral matching），基本原理是在参考帧list0和参考帧list1中的初始MV附近搜索一个...
VVC/VTM参考软件数据结构（翻译加解读）
RJzz
07-13 2870
本文是对VVC参考软件下doc目录中的NextSoftware-Data Structure的一个翻译 动机 HM的缺点 复杂的数据结构 Z-index 令人产生歧义的数据模型（TComDataCu） 糟糕的代码可读性 复杂的内存操作与一般的数据流混合在一起 缺乏数据和逻辑封装 复杂的可拓展性 ...
VVC/VTM 4.2 帧内编码——亮度预测理解
destination00的博客
06-04 1081
xCompressCU()是帧内编码的核心函数，它把从上层函数compressCtu()得到的基本编码单元CTU递归地用函数xCheckModeSplit()进行宏块划分。在此过程中，xCheckModeSplit()会调用xCompressCU ()。 xCompressCU()函数 xCompressCU()函数的主要流程如下： 1、初始化：设置各种可用模式，上下文模型等； 2、遍历各种帧内模...
数据结构学习笔记（三）
Cherish__it的博客
05-04 549
深入理解抽象数据类型; ADT是一些操作的集合，是数学的抽象，在ADT的定义中根本没涉及如何实现操作的集合，这个可以看作是模块化设计的补充。这些操作在程序只编写一次，而程序中任何其他部分需要在该ADT上运行其中的一种操作时可以通过调用适当的函数来进行，若需要改变操作细节，只需要修改运行这些ADT操作的例程就可以。      对所有的表操作都可以通过使用数组来实现，虽然数组是动态指定的，但是还是
position的应用及结构
郭滋滋儿
12-10 337
position:relative; 相对定位： 1、不影响元素本身的特性； 2、不使元素脱离文档流（元素移动之后原始位置会被保留）； 3、如果没有定位偏移量，对元素本身没有任何影响 4、提升层级定位元素位置控制 top/right/bottom/left 定位元素偏移量。position:absolute; 绝对定位 1、使元素完全脱离文档流； 2、使内嵌支持宽高； 3、块属性
VVC代码学习之自定义数据结构阅读4
weixin_45133943的博客
10-27 520
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.同样的，
POSITION用法解释，POSITION是什么？
月光秦王
03-01 7914
POSITION是MFC模板类库中经常使用的一个数据类型，我们从它的定义可以看出，其实，它就是一个指针。 // abstract iteration position struct __POSITION { }; typedef __POSITION* POSITION; MFC给出的注释是：一个抽象的迭代位置，既然是抽象，也就是没有给定具体的数据类型，以满足不同的模板参数的需要。 在C
顺序表操作（数据结构）
Mas的博客
04-26 533
这题我着实弄了很久，一直找不到一个小小的错误，虽然简单，不过代码的严谨性我还差很远的感觉。函数接口定义：List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中Li...
VTM数据结构2
cx52039的博客
04-12 2708
VTM数据结构
position 图文详解
Long_gone的博客
07-03 729
在我们接触html的时候，相信大家总是会遇到这样的问题 1.除了利用边距，可以实现指定位置的放置，还有没有其他方式呢？ 2.当我们想让元素实现重叠的时候，应该怎么办 ？ a、定位背景 为了解决当边距实现不了元素放置指定位置的时候，咋整？ b、定位定义 定位顾名思义就是把指定元素放置到指定位置 c、定位功能 只要是你能看到的位置，无所不能 一、默认定位 position: static 默认值。没有定位，元素出现在正常的流中 对应的css： 结果显示： 我们可以很清楚的看到，三个块就是默认位置，所以默
数据结构--线性结构
拂去烟尘的博客
09-26 424
顺序存储结构typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position Last; }; /* 初始化 */ List MakeEmpty() { List L; L = (List)malloc(sizeof(
浅谈position属性
一个前端小白的瞎扯
04-24 5612
position属性共有四种不同的定位方法，分别是static、fixed、relative、absolute。position:static    static定位是HTML元素的默认值，即没有定位，元素出现在正常的流中。因此这种定位就不会受到top、bottom、left、right的影响。&lt;div class="wrap"&gt;     &lt;div class="content"...
VVC编码标准学习必备：VTM1.0参考软件解读
VVC参考软件VTM（Video Test Model）1.0是实现H.266/VVC标准的参考软件之一，它是由MPEG和ITU-T的联合视频编码组（Joint Video Experts Team, JVET）开发的。参考软件通常是由标准化组织提供的，用于验证和展示新...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值