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

最新推荐文章于 2022-07-09 18:59:41 发布
最新推荐文章于 2022-07-09 18:59:41 发布
阅读量282 收藏 3
点赞数
分类专栏： vvc 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45133943/article/details/120828229
版权
本文详细介绍了structUnitArea类，其包含ChromaFormat和块数组blocks，用于表示视频编码中的不同通道信息。UnitArea类提供了方便的操作接口，如获取各个通道的CompArea。此外，UnitBuf作为更全面的结构，整合了Y、Cb、Cr通道的AreaBuf。博客还提及了AreaBuf模板类，用于缓存不同类型的数据。
摘要由CSDN通过智能技术生成

在学习1中我们看到了CompArea这个类，他继承了Area中的size和position两个属性，并且给这两个补充了他们的chromaFormat和compnentID两个属性。今天我们继续看下一个类。

struct UnitArea

这个类中有两个成员变量，分别是chromaFormat和blocks，chromaFormat存储的当前单元的编码格式（420，400...）blocks是类似于vector容器的一个数组，存放的数据类型为CompArea，其分别代表Y，Cb，Cr三个通道的分量

调用Y(),Cb(),Cr()三个成员函数可以分别返回三个代表该通道的CompArea类型的值，其余的方法类似于前面的介绍。

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

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

template struct AreaBuf

这是一个模板类，其成员函数有一个模板指针，以及int型整数stride，根据具体的类型定义的不同，它可以作为不同数据的缓存，可以缓存像素的信息，变换的信息，运动向量的信息等等。同时它的基类是Size，在先前的结构中，已经有个坐标，大小，通道，编码格式等信息，所以我们就可以凭借这些信息在AreaBuf中拿出我们想要的具体的值。

类中定义了许多的成员函数，大多数的作用顾名思义，at()方法与大多数容器一样返回一个值，bufat()返回当前位置的指针，subbuf()返回一个子AreaBuf

template<typename T>
struct AreaBuf : public Size
{
  T*        buf;
  int       stride;
  // the proper type causes awful lot of errors
  //ptrdiff_t stride;

  AreaBuf()                                                                               : Size(),                  buf( NULL ), stride( 0 )          { }
  AreaBuf( T *_buf, const Size &size )                                                    : Size( size ),            buf( _buf ), stride( size.width ) { }
  AreaBuf( T *_buf, const int &_stride, const Size &size )                                : Size( size ),            buf( _buf ), stride( _stride )    { }
  AreaBuf( T *_buf, const SizeType &_width, const SizeType &_height )                     : Size( _width, _height ), buf( _buf ), stride( _width )     { }
  AreaBuf( T *_buf, const int &_stride, const SizeType &_width, const SizeType &_height ) : Size( _width, _height ), buf( _buf ), stride( _stride )    { }

  operator AreaBuf<const T>() const { return AreaBuf<const T>( buf, stride, width, height ); }

  void fill                 ( const T &val );
  void memset               ( const int val );

  void copyFrom             ( const AreaBuf<const T> &other );
  void roundToOutputBitdepth(const AreaBuf<const T> &src, const ClpRng& clpRng);

  void reconstruct          ( const AreaBuf<const T> &pred, const AreaBuf<const T> &resi, const ClpRng& clpRng);
  void copyClip             ( const AreaBuf<const T> &src, const ClpRng& clpRng);

  void subtract             ( const AreaBuf<const T> &other );
  void extendSingleBorderPel();
  void extendBorderPel      (  unsigned margin );
  void extendBorderPel(unsigned marginX, unsigned marginY);
  void padBorderPel         ( unsigned marginX, unsigned marginY, int dir );
  void addWeightedAvg       ( const AreaBuf<const T> &other1, const AreaBuf<const T> &other2, const ClpRng& clpRng, const int8_t bcwIdx);
  void removeWeightHighFreq ( const AreaBuf<T>& other, const bool bClip, const ClpRng& clpRng, const int8_t iBcwWeight);
  void addAvg               ( const AreaBuf<const T> &other1, const AreaBuf<const T> &other2, const ClpRng& clpRng );
  void removeHighFreq       ( const AreaBuf<T>& other, const bool bClip, const ClpRng& clpRng);
  void updateHistogram      ( std::vector<int32_t>& hist ) const;

  T    meanDiff             ( const AreaBuf<const T> &other ) const;
  void subtract             ( const T val );

  void linearTransform      ( const int scale, const int shift, const int offset, bool bClip, const ClpRng& clpRng );

  void transposedFrom       ( const AreaBuf<const T> &other );

  void toLast               ( const ClpRng& clpRng );

  void rspSignal            ( std::vector<Pel>& pLUT );
  void scaleSignal          ( const int scale, const bool dir , const ClpRng& clpRng);
  T    computeAvg           ( ) const;

        T& at( const int &x, const int &y )          { return buf[y * stride + x]; }
  const T& at( const int &x, const int &y ) const    { return buf[y * stride + x]; }

        T& at( const Position &pos )                 { return buf[pos.y * stride + pos.x]; }
  const T& at( const Position &pos ) const           { return buf[pos.y * stride + pos.x]; }


        T* bufAt( const int &x, const int &y )       { return &at( x, y ); }
  const T* bufAt( const int &x, const int &y ) const { return &at( x, y ); }

        T* bufAt( const Position& pos )              { return &at( pos ); }
  const T* bufAt( const Position& pos ) const        { return &at( pos ); }

  AreaBuf<      T> subBuf( const Position &pos, const Size &size )                                    { return AreaBuf<      T>( bufAt( pos  ), stride, size   ); }
  AreaBuf<const T> subBuf( const Position &pos, const Size &size )                              const { return AreaBuf<const T>( bufAt( pos  ), stride, size   ); }
  AreaBuf<      T> subBuf( const int &x, const int &y, const unsigned &_w, const unsigned &_h )       { return AreaBuf<      T>( bufAt( x, y ), stride, _w, _h ); }
  AreaBuf<const T> subBuf( const int &x, const int &y, const unsigned &_w, const unsigned &_h ) const { return AreaBuf<const T>( bufAt( x, y ), stride, _w, _h ); }
};
typedef AreaBuf<      Pel>  PelBuf;
typedef AreaBuf<const Pel> CPelBuf;

typedef AreaBuf<      TCoeff>  CoeffBuf;
typedef AreaBuf<const TCoeff> CCoeffBuf;

typedef AreaBuf<      MotionInfo>  MotionBuf;
typedef AreaBuf<const MotionInfo> CMotionBuf;

typedef AreaBuf<      TCoeff>  PLTescapeBuf;
typedef AreaBuf<const TCoeff> CPLTescapeBuf;

typedef AreaBuf<      bool>  PLTtypeBuf;
typedef AreaBuf<const bool> CPLTtypeBu

template struct UnitBuf

就目前所看到带有unit的数据结构，都是将之前的单通道的结构，整合成为了一个更全面的结构，是一种层层包含的关系，在AreaBuf中只存在Y，Cb或者Cr一个通道，而在UnitBuf中，它将分别代表Y,Cb,Cr的AreaBuf当作一个数组元素，存放进了static_vector中。

struct UnitArea;

template<typename T>
struct UnitBuf
{
  typedef static_vector<AreaBuf<T>,       MAX_NUM_COMPONENT> UnitBufBuffers;
  typedef static_vector<AreaBuf<const T>, MAX_NUM_COMPONENT> ConstUnitBufBuffers;

  ChromaFormat chromaFormat;
  UnitBufBuffers bufs;

  UnitBuf() : chromaFormat( NUM_CHROMA_FORMAT ) { }
  UnitBuf( const ChromaFormat &_chromaFormat, const UnitBufBuffers&  _bufs ) : chromaFormat( _chromaFormat ), bufs( _bufs ) { }
  UnitBuf( const ChromaFormat &_chromaFormat,       UnitBufBuffers&& _bufs ) : chromaFormat( _chromaFormat ), bufs( std::forward<UnitBufBuffers>( _bufs ) ) { }
  UnitBuf( const ChromaFormat &_chromaFormat, const AreaBuf<T>  &blkY ) : chromaFormat( _chromaFormat ), bufs{ blkY } { }
  UnitBuf( const ChromaFormat &_chromaFormat,       AreaBuf<T> &&blkY ) : chromaFormat( _chromaFormat ), bufs{ std::forward<AreaBuf<T> >(blkY) } { }
  UnitBuf( const ChromaFormat &_chromaFormat, const AreaBuf<T>  &blkY, const AreaBuf<T>  &blkCb, const AreaBuf<T>  &blkCr ) : chromaFormat( _chromaFormat ), bufs{ blkY, blkCb, blkCr } { }
  UnitBuf( const ChromaFormat &_chromaFormat,       AreaBuf<T> &&blkY,       AreaBuf<T> &&blkCb,       AreaBuf<T> &&blkCr ) : chromaFormat( _chromaFormat ), bufs{ std::forward<AreaBuf<T> >(blkY), std::forward<AreaBuf<T> >(blkCb), std::forward<AreaBuf<T> >(blkCr) } { }

  operator UnitBuf<const T>() const
  {
    return UnitBuf<const T>( chromaFormat, ConstUnitBufBuffers( bufs.begin(), bufs.end() ) );
  }

        AreaBuf<T>& get( const ComponentID comp )        { return bufs[comp]; }
  const AreaBuf<T>& get( const ComponentID comp )  const { return bufs[comp]; }

        AreaBuf<T>& Y()        { return bufs[0]; }
  const AreaBuf<T>& Y()  const { return bufs[0]; }
        AreaBuf<T>& Cb()       { return bufs[1]; }
  const AreaBuf<T>& Cb() const { return bufs[1]; }
        AreaBuf<T>& Cr()       { return bufs[2]; }
  const AreaBuf<T>& Cr() const { return bufs[2]; }

  void fill                 ( const T &val );
  void copyFrom             ( const UnitBuf<const T> &other, const bool lumaOnly = false, const bool chromaOnly = false );
  void roundToOutputBitdepth(const UnitBuf<const T> &src, const ClpRngs& clpRngs);
  void reconstruct          ( const UnitBuf<const T> &pred, const UnitBuf<const T> &resi, const ClpRngs& clpRngs );
  void copyClip             ( const UnitBuf<const T> &src, const ClpRngs& clpRngs, const bool lumaOnly = false, const bool chromaOnly = false );
  void subtract             ( const UnitBuf<const T> &other );
  void addWeightedAvg       ( const UnitBuf<const T> &other1, const UnitBuf<const T> &other2, const ClpRngs& clpRngs, const uint8_t bcwIdx = BCW_DEFAULT, const bool chromaOnly = false, const bool lumaOnly = false);
  void addAvg               ( const UnitBuf<const T> &other1, const UnitBuf<const T> &other2, const ClpRngs& clpRngs, const bool chromaOnly = false, const bool lumaOnly = false);
  void extendSingleBorderPel();
  void extendBorderPel(unsigned marginX, unsigned marginY);
  void padBorderPel         ( unsigned margin, int dir );
  void extendBorderPel      ( unsigned margin );
  void removeHighFreq       ( const UnitBuf<T>& other, const bool bClip, const ClpRngs& clpRngs
                            , const int8_t bcwWeight = g_BcwWeights[BCW_DEFAULT]
                            );

        UnitBuf<      T> subBuf (const UnitArea& subArea);
  const UnitBuf<const T> subBuf (const UnitArea& subArea) const;
  void colorSpaceConvert(const UnitBuf<T> &other, const bool forward, const ClpRng& clpRng);
};

typedef UnitBuf<      Pel>  PelUnitBuf;
typedef UnitBuf<const Pel> CPelUnitBuf;

typedef UnitBuf<      TCoeff>  CoeffUnitBuf;
typedef UnitBuf<const TCoeff> CCoeffUnitBuf;

struct PelStorage：public PelUnitBuf

这个类简单来说就是开辟内存使用的，为缓存器开闭对应的内存存储数据，主要使用create成员函数为其分配相应大小的内存空间。

//Buffer.h
struct UnitArea;
struct CompArea;

struct PelStorage : public PelUnitBuf
{
  PelStorage();
  ~PelStorage();

  void swap( PelStorage& other );
  void createFromBuf( PelUnitBuf buf );
  void create( const UnitArea &_unit );
  void create( const ChromaFormat &_chromaFormat, const Area& _area, const unsigned _maxCUSize = 0,
  	 			const unsigned _margin = 0, const unsigned _alignment = 0, const bool _scaleChromaMargin = true );
  void destroy();

         PelBuf getBuf( const CompArea &blk );
  const CPelBuf getBuf( const CompArea &blk ) const;

         PelBuf getBuf( const ComponentID CompID );
  const CPelBuf getBuf( const ComponentID CompID ) const;

         PelUnitBuf getBuf( const UnitArea &unit );
  const CPelUnitBuf getBuf( const UnitArea &unit ) const;
  Pel *getOrigin( const int id ) const { return m_origin[id]; }

private:

  Pel *m_origin[MAX_NUM_COMPONENT];
};

//Buffer.cpp
void PelStorage::create( const UnitArea &_UnitArea )
{
  create( _UnitArea.chromaFormat, _UnitArea.blocks[0] );
}

void PelStorage::create( const ChromaFormat &_chromaFormat, const Area& _area, const unsigned _maxCUSize, const unsigned _margin, const unsigned _alignment, const bool _scaleChromaMargin )
{
  CHECK( !bufs.empty(), "Trying to re-create an already initialized buffer" );

  chromaFormat = _chromaFormat;

  const uint32_t numCh = getNumberValidComponents( _chromaFormat );

  unsigned extHeight = _area.height;
  unsigned extWidth  = _area.width;

  if( _maxCUSize )
  {
    extHeight = ( ( _area.height + _maxCUSize - 1 ) / _maxCUSize ) * _maxCUSize;
    extWidth  = ( ( _area.width  + _maxCUSize - 1 ) / _maxCUSize ) * _maxCUSize;
  }

  for( uint32_t i = 0; i < numCh; i++ )
  {
    const ComponentID compID = ComponentID( i );
    const unsigned scaleX = ::getComponentScaleX( compID, _chromaFormat );
    const unsigned scaleY = ::getComponentScaleY( compID, _chromaFormat );

    unsigned scaledHeight = extHeight >> scaleY;
    unsigned scaledWidth  = extWidth  >> scaleX;
    unsigned ymargin      = _margin >> (_scaleChromaMargin?scaleY:0);
    unsigned xmargin      = _margin >> (_scaleChromaMargin?scaleX:0);
    unsigned totalWidth   = scaledWidth + 2*xmargin;
    unsigned totalHeight  = scaledHeight +2*ymargin;

    if( _alignment )
    {
      // make sure buffer lines are align
      CHECK( _alignment != MEMORY_ALIGN_DEF_SIZE, "Unsupported alignment" );
      totalWidth = ( ( totalWidth + _alignment - 1 ) / _alignment ) * _alignment;
    }
    uint32_t area = totalWidth * totalHeight;
    CHECK( !area, "Trying to create a buffer with zero area" );

    m_origin[i] = ( Pel* ) xMalloc( Pel, area );
    Pel* topLeft = m_origin[i] + totalWidth * ymargin + xmargin;
    bufs.push_back( PelBuf( topLeft, totalWidth, _area.width >> scaleX, _area.height >> scaleY ) );
  }
}

weixin_45133943
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
chrome formats
FlexFun&Maven Driver
12-15 88
name:'app name'   version:"0.0.1"   description:'something '   icons:{ 16:'', 48:'', 128:'' }   "chrome_url_overrides": {  覆盖chrome 默认的tab页 "newtab": "newtab.html"  }   "options_p...
【H.266/VVC】Unit.h代码阅读
allensu374125056的博客
04-24 712
带Comp的如CompArea 是指单一分量（Y，Cb，Cr）的数据，记录了带有通道属性的Area，给Area增加了通道属性，之前就是一个矩形，有坐标和长宽，现在还有了是Y 还U 还是V。并且可以通过一个CompArea 获得另一个通道对应的CompArea 的坐标，长宽等信息。 struct CompArea : public Area { CompArea() : Area(), chro...
H.266/VVC技术学习：帧内预测之MIP技术
BigDream123的博客
05-21 4067
Matrix Weighted Intra Prediction（MIP）技术，即矩阵加权帧内预测技术，是VVC中新增加的一种帧内预测技术。其最初的思想来源于基于神经网络的帧内预测技术（JVET-J0037），即利用多层神经网络基于相邻已重建像素预测当前pu像素值。但是这种预测方式复杂度太高，经过权衡，发展出最后采纳的基于线性仿射变换的帧内预测技术。 Tracking route: N0217 ...
chroma_format_idc表示的色度采样结构
幽雨雨幽
05-09 1417
chroma_format_idc 是指如 6.2 节所提出的，与亮度取样对应的色度取样。chroma_format_idc 的值应该在 0 到 3的范围内（包括 0和 3）。当 chroma_format_idc不存在时，应推断其值为 1（4：2：0的色度格式）。 色度采样结构 ...
VVC/VTM：JVET-N0671—Support of 4:4:4 and 4:2:2 chroma formats in VVC
Moomin的博客
03-27 760
JVET-N0671： Support of 4:4:4 and 4:2:2 chroma formats in VVC 主要对VTM标准软件和VVC标准文档进行修改，以便支持YUV4:4:4, RGB4:4:4, and YUV4:2:2格式（现有的VTM仅仅支持420格式）。因此，主要的改动在于CCLM模式和Affine模式 原有CCLM CCLM利用当前块重建的亮度像素预测色度像素，因此...
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 ...
vc++游戏源代码 第3章 贪吃蛇
06-23
vc++游戏源代码 第3章 贪吃蛇vc++游戏源代码 第3章 贪吃蛇vc++游戏源代码 第3章 贪吃蛇vc++游戏源代码 第3章 贪吃蛇vc++游戏源代码 第3章 贪吃蛇vc++游戏源代码 第3章 贪吃蛇vc++游戏源代码 第3章 贪吃蛇vc++游戏源...
vvc 266 标准发布会的ppt
11-19
VVC时域编码结构包括Random Access、Reference Picture Resampling和Reference Picture Management等技术，以提供高效的视频编解码。 VI. VVC空间编码结构 VVC空间编码结构包括Coding Tree Units、Slices and ...
H.264码流分析
m0_52082331的博客
07-09 419
H.264视频码流分析仪
VVC学习之四：VTM中的数据结构——AreaBuf，UnitBuf
Aidoneus_y
05-06 1671
文章目录AreaBuf AreaBuf，UnitBuf 封装了二维视频信号的一维存储下的内存管理方法，提供了简单内存操作接口。 AreaBuf AreaBuf是一个类模板，AreaBuf采用了通用数据类型成员，VTM中以AreaBuf为模板实例化6个模板类，分别管理像素、变换系数和运动信息的存储和访问，如下： typedef AreaBuf< Pel> PelBuf; typedef...
VCIP2020：VVC中的ACT
Dillon2015的博客
05-14 3万+
本文来自VCIP2020论文《Adaptive Color Transform in VVC Standard》 ACT(Adaptive Color Transform)用于去除4:4:4采样格式的视频不同颜色分量间的相关性，主要用于SCC场景。ACT自适应的将预测残差信号从原始空间转换到另一个颜色空间。 ACT的编解码流程 图Fig.1是编码器中加入ACT后的工作流程，包含两个模块：Forward ACT和Inverse ACT。编码器首先进行模式决策然后获得残差信号，CU通过RDO决定是否使
屏幕内容编码：HEVC SCC、VVC、AVS3、AV1和EVC
weixin_46969363的博客
01-05 4757
近年来，随着许多相关应用变得非常流行，包括计算机生成的文本、图形和动画在内的屏幕内容视频引起了比以往更多的关注。然而，传统的视频编解码器通常被设计成处理摄像机捕获的自然视频。另一方面，屏幕内容视频表现出不同的信号特征和人类对失真的视觉敏感度的不同水平。为了解决对这种内容进行高效编码的需要，已经专门开发了许多编码工具，并且在编码效率方面取得了巨大进步。所有最近开发的视频编码标准都包含屏幕内容编码(SCC)功能，这一事实充分说明了屏幕内容应用的重要性。尽管如此，在这些标准中包含SCC工具的考虑是非常不同的。每个
VVC之SCC（一）：IBC
热门推荐
Dillon2015的博客
04-06 5万+
VVC之SCC（一）：IBC Intra block copy(IBC)是屏幕内容编码(Screen Content Coding,SCC)的主要技术之一。IBC是块级的编码模式，在编码端会使用块匹配(Block Matching,BM)技术为每个CU寻找最优匹配块，并计算块向量(block vector)。块向量表明当前块和最优匹配块的位置关系。 当CU使用IBC模式编码，其亮度分量的块向量...
VVC新技术（汇总中）
iuvgood
08-27 3207
内容非原创 帧内预测： 简介https://blog.csdn.net/u012038173/article/details/90084591#2_CCLM_66 1. 扩展角度帧内模式 ：65个帧内预测模式和WAIP预测模式 ：https://cloud.tencent.com/developer/article/1430270 针对这个非对称问题，对于水平的预测单元，模式67~ 80...
VVC学习之SubBlock Transform（SBT）
Aidoneus_y
07-28 1224
文章目录基于子块的变换编码SubBlock Transform（SBT）1. 执行条件2. 模式类型3. 语法要素 基于子块的变换编码SubBlock Transform（SBT） 变换时，只有残差块的部分进行编码。早期版本中，帧间指明MTS信息确定变换类型，目前的版本中（VTM-7.0）变换的部分残差块的部分可以根据位置自适应推导得出，其他残差为0. 1. 执行条件 帧间模式（帧内、IBC、PLT、triangle不行） cu_cbf == 1 && cu_sbt_flag == 1 C
VVC帧内预测（二）CCLM
Dillon2015的博客
12-06 5万+
跨分支线性模型(Cross-component linear model,CCLM)预测中假设同一个编码块的色度像素值和对应的亮度像素值有线性关系，所以CCLM使用一个线性模型从亮度像素的重建值生成对应色度像素的预测值。 CCLM的参数α和β由相邻的4个色度像素和对应的降采样的亮度像素生成，假设当前块尺寸是WxH，则W′和H′由下列步骤生成： 当使用LM模式时，W′=W，H′=H...
H.266/VVC 视频编码标准详解
**第二章编码结构** 描述了VVC的编码单元划分，如四叉树划分、多类型树划分和VPDUs，以及slice、Tile和子图像的组织方式。此外，还提到了Profile、Tier和level的概念，这些都是定义编码能力的参数，用于确保兼容性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值