/src/vvenc/source/Lib/CommonLib/CodingStructure.h

Source
/* -----------------------------------------------------------------------------
The copyright in this software is being made available under the Clear BSD
License, included below. No patent rights, trademark rights and/or 
other Intellectual Property Rights other than the copyrights concerning 
the Software are granted under this license.

The Clear BSD License

Copyright (c) 2019-2026, Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. & The VVenC Authors.
All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted (subject to the limitations in the disclaimer below) provided that
the following conditions are met:

     * Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.

     * Neither the name of the copyright holder nor the names of its
     contributors may be used to endorse or promote products derived from this
     software without specific prior written permission.

NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.


------------------------------------------------------------------------------------------- */
/** \file     CodingStructure.h
 *  \brief    A class managing the coding information for a specific image part
 */

#pragma once

#include "Unit.h"
#include "CommonDef.h"
#include "UnitPartitioner.h"
#include "Slice.h"

#include <vector>
#include <mutex>

//! \ingroup CommonLib
//! \{

namespace vvenc {

struct Picture;


enum PictureType
{
  PIC_RECONSTRUCTION = 0,
  PIC_ORIGINAL,
  PIC_ORIGINAL_RSP,
  PIC_PREDICTION,
  PIC_RESIDUAL,
  PIC_SAO_TEMP,
  NUM_PIC_TYPES,
  PIC_ORIGINAL_RSP_REC,
};

// ---------------------------------------------------------------------------
// coding structure
// ---------------------------------------------------------------------------

class CodingStructure
{
public:

  UnitArea         area;
  UnitArea         _maxArea;

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

  UnitScale        unitScale[MAX_NUM_COMP];

  int         baseQP;
  int         prevQP[MAX_NUM_CH];
  int         currQP[MAX_NUM_CH];
  int         chromaQpAdj; //th this seems to belong to CUCtx rather than to cs
  const SPS*  sps;
  const PPS*  pps;
  PicHeader*  picHeader;
  APS*        alfAps[ALF_CTB_MAX_NUM_APS];
  APS*        lmcsAps;
  APS*        scalinglistAps;
  const VPS*  vps;
  const PreCalcValues* pcv;

  CodingStructure( XUCache& unitCache, std::mutex* mutex );
  void createPicLevel( const UnitArea& _unit, const PreCalcValues* _pcv );
  void createForSearch( const ChromaFormat _chromaFormat, const Area& _area );
  void destroy();
  void releaseIntermediateData();

  void rebindPicBufs();
  void createCoeffs();
  void destroyCoeffs();

  void allocateVectorsAtPicLevel();

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

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

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

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

  CodingUnit*          getCU(const ChannelType& _chType, const TreeType _treeType ) { return getCU(area.blocks[_chType].pos(), _chType, _treeType); }
  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 TreeType treeType) const;
  const CodingUnit*    getCURestricted(const Position& pos, const CodingUnit& curCu,    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, CodingUnit* cuInit = nullptr);
  TransformUnit&  addTU(const UnitArea& unit, const ChannelType _chType, CodingUnit* cu, TransformUnit* tuInit = nullptr);
  void addEmptyTUs( Partitioner &partitioner, CodingUnit* cu );

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

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

  double      cost;
  double      costDbOffset;
  double      lumaCost;
  uint64_t    fracBits;
  Distortion  dist;
  Distortion  interHad;

  void initStructData  ( const int QP = MAX_INT, const bool skipMotBuf = true, const UnitArea* area = nullptr );
  void initSubStructure(      CodingStructure& cs, const ChannelType chType, const UnitArea& subArea, const bool isTuEnc, PelStorage* pOrgBuffer = nullptr, PelStorage* pRspBuffer = nullptr);
  void compactResize   ( const UnitArea& area );

  void copyStructure   (const CodingStructure& cs, const ChannelType chType, const TreeType treeType, const bool copyTUs = false, const bool copyRecoBuffer = false);
  void useSubStructure (      CodingStructure& cs, const ChannelType chType, const TreeType treeType, const UnitArea& subArea, const bool cpyRecoToPic = true);

  void clearTUs( bool force = false );
  void clearCUs( bool force = false );

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

public:


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

  LutMotionCand motionLut;
  std::vector<LutMotionCand> motionLutBuf;
  void addMiToLut(static_vector<HPMVInfo, MAX_NUM_HMVP_CANDS>& lut, const HPMVInfo &mi);

private:

  // needed for TU encoding
  bool m_isTuEnc;

  CodingUnit**      m_cuPtr   [MAX_NUM_CH];

  unsigned m_numCUs;
  unsigned m_numTUs;

  CUCache& m_cuCache;
  TUCache& m_tuCache;
  std::mutex* m_unitCacheMutex;

  std::vector<SAOBlkParam> m_sao;

  PelStorage  m_pred;
  PelStorage  m_resi;
  PelStorage  m_reco;
  PelStorage  m_rspreco;
  PelStorage* m_org;
  PelStorage* m_rsporg;

  TCoeffSig*  m_coeffs [MAX_NUM_COMP];
  int         m_offsets[MAX_NUM_COMP];

  std::vector<Mv>   m_dmvrMvCache;
  int               m_dmvrMvCacheOffset;

  MotionInfo*       m_motionBuf;

  LoopFilterParam*  m_lfParam[NUM_EDGE_DIR];

  Size              m_mapSize[MAX_NUM_CH];


public:
  CodingStructure*  bestParent;
  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;

  MotionInfo const* getMiMapPtr()    const { return m_motionBuf; }
  MotionInfo      * getMiMapPtr()          { return m_motionBuf; }
  ptrdiff_t         getMiMapStride() const { return ( ptrdiff_t ) g_miScaling.scaleHor( area.Y().width ); }

  LFPBuf getLoopFilterParamBuf(const DeblockEdgeDir& edgeDir);
  const CLFPBuf getLoopFilterParamBuf(const DeblockEdgeDir& edgeDir) const;

  LoopFilterParam const* getLFPMapPtr   ( const DeblockEdgeDir edgeDir ) const { return m_lfParam[edgeDir]; }
  LoopFilterParam      * getLFPMapPtr   ( const DeblockEdgeDir edgeDir )       { return m_lfParam[edgeDir]; }
  ptrdiff_t              getLFPMapStride() const { return ( ptrdiff_t ) m_mapSize[CH_L].width; }

  UnitScale getScaling(const UnitScale::ScaliningType type, const ChannelType chType = CH_L) const
  {
    return type == UnitScale::MI_MAP ? g_miScaling : unitScale[chType];
  }

public:
  // ---------------------------------------------------------------------------
  // temporary (shadowed) data accessors
  // ---------------------------------------------------------------------------
         PelBuf       getPredBuf(const CompArea& blk)           { return getBuf(blk,  PIC_PREDICTION); }
  const CPelBuf       getPredBuf(const CompArea& blk)     const { return getBuf(blk,  PIC_PREDICTION); }
         PelUnitBuf   getPredBuf(const UnitArea& unit)          { return getBuf(unit, PIC_PREDICTION); }
  const CPelUnitBuf   getPredBuf(const UnitArea& unit)    const { return getBuf(unit, PIC_PREDICTION); }

         PelBuf       getResiBuf(const CompArea& blk)           { return getBuf(blk,  PIC_RESIDUAL); }
  const CPelBuf       getResiBuf(const CompArea& blk)     const { return getBuf(blk,  PIC_RESIDUAL); }
         PelUnitBuf   getResiBuf(const UnitArea& unit)          { return getBuf(unit, PIC_RESIDUAL); }
  const CPelUnitBuf   getResiBuf(const UnitArea& unit)    const { return getBuf(unit, PIC_RESIDUAL); }

         PelBuf       getRecoBuf(const CompArea& blk)           { return getBuf(blk,  PIC_RECONSTRUCTION); }
  const CPelBuf       getRecoBuf(const CompArea& blk)     const { return getBuf(blk,  PIC_RECONSTRUCTION); }
         PelUnitBuf   getRecoBuf(const UnitArea& unit)          { return getBuf(unit, PIC_RECONSTRUCTION); }
  const CPelUnitBuf   getRecoBuf(const UnitArea& unit)    const { return getBuf(unit, PIC_RECONSTRUCTION); }

         PelBuf       getOrgBuf(const CompArea& blk)            { return getBuf(blk,  PIC_ORIGINAL); }
  const CPelBuf       getOrgBuf(const CompArea& blk)      const { return getBuf(blk,  PIC_ORIGINAL); }
         PelUnitBuf   getOrgBuf(const UnitArea& unit)           { return getBuf(unit, PIC_ORIGINAL); }
  const CPelUnitBuf   getOrgBuf(const UnitArea& unit)     const { return getBuf(unit, PIC_ORIGINAL); }

         PelBuf       getRspOrgBuf(const CompArea& blk)         { return getBuf(blk,  PIC_ORIGINAL_RSP); }
  const CPelBuf       getRspOrgBuf(const CompArea& blk)   const { return getBuf(blk,  PIC_ORIGINAL_RSP); }

         PelBuf        getRspRecoBuf(const CompArea &blk)         { return getBuf(blk, PIC_ORIGINAL_RSP_REC); }
  const CPelBuf        getRspRecoBuf(const CompArea &blk)   const { return getBuf(blk, PIC_ORIGINAL_RSP_REC); }

         PelUnitBuf&  getRecoBufRef()                           { return m_reco; }
         PelBuf&      getRspRecoBuf()                           { return m_rspreco.Y(); }
  const CPelBuf       getRspRecoBuf()                     const { return m_rspreco.Y(); }

         PelBuf&      getRspOrgBuf()                            { return m_rsporg->Y(); }
  const CPelBuf       getRspOrgBuf()                      const { return m_rsporg->Y(); }

         PelBuf       getOrgBuf(const ComponentID compID)       { return m_org->get(compID); }
  const CPelBuf       getOrgBuf(const ComponentID compID) const { return m_org->get(compID); }
         PelUnitBuf&  getOrgBuf()                               { return *m_org; }
  const CPelUnitBuf   getOrgBuf()                         const { return *m_org; }

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

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

private:

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


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

} // namespace vvenc

//! \}


Coverage Report

Created: 2026-04-01 07:49

Line	Count	Source
1		/* -----------------------------------------------------------------------------
2		The copyright in this software is being made available under the Clear BSD
3		License, included below. No patent rights, trademark rights and/or
4		other Intellectual Property Rights other than the copyrights concerning
5		the Software are granted under this license.
6
7		The Clear BSD License
8
9		Copyright (c) 2019-2026, Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. & The VVenC Authors.
10		All rights reserved.
11
12		Redistribution and use in source and binary forms, with or without modification,
13		are permitted (subject to the limitations in the disclaimer below) provided that
14		the following conditions are met:
15
16		* Redistributions of source code must retain the above copyright notice,
17		this list of conditions and the following disclaimer.
18
19		* Redistributions in binary form must reproduce the above copyright
20		notice, this list of conditions and the following disclaimer in the
21		documentation and/or other materials provided with the distribution.
22
23		* Neither the name of the copyright holder nor the names of its
24		contributors may be used to endorse or promote products derived from this
25		software without specific prior written permission.
26
27		NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
28		THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
29		CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30		LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
31		PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
32		CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
33		EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
34		PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
35		BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
36		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37		ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38		POSSIBILITY OF SUCH DAMAGE.
39
40
41		------------------------------------------------------------------------------------------- */
42		/** \file CodingStructure.h
43		* \brief A class managing the coding information for a specific image part
44		*/
45
46		#pragma once
47
48		#include "Unit.h"
49		#include "CommonDef.h"
50		#include "UnitPartitioner.h"
51		#include "Slice.h"
52
53		#include <vector>
54		#include <mutex>
55
56		//! \ingroup CommonLib
57		//! \{
58
59		namespace vvenc {
60
61		struct Picture;
62
63
64		enum PictureType
65		{
66		PIC_RECONSTRUCTION = 0,
67		PIC_ORIGINAL,
68		PIC_ORIGINAL_RSP,
69		PIC_PREDICTION,
70		PIC_RESIDUAL,
71		PIC_SAO_TEMP,
72		NUM_PIC_TYPES,
73		PIC_ORIGINAL_RSP_REC,
74		};
75
76		// ---------------------------------------------------------------------------
77		// coding structure
78		// ---------------------------------------------------------------------------
79
80		class CodingStructure
81		{
82		public:
83
84		UnitArea area;
85		UnitArea _maxArea;
86
87		Picture* picture;
88		CodingStructure* parent;
89		CodingStructure* lumaCS;
90		Slice* slice;
91
92		UnitScale unitScale[MAX_NUM_COMP];
93
94		int baseQP;
95		int prevQP[MAX_NUM_CH];
96		int currQP[MAX_NUM_CH];
97		int chromaQpAdj; //th this seems to belong to CUCtx rather than to cs
98		const SPS* sps;
99		const PPS* pps;
100		PicHeader* picHeader;
101		APS* alfAps[ALF_CTB_MAX_NUM_APS];
102		APS* lmcsAps;
103		APS* scalinglistAps;
104		const VPS* vps;
105		const PreCalcValues* pcv;
106
107		CodingStructure( XUCache& unitCache, std::mutex* mutex );
108		void createPicLevel( const UnitArea& _unit, const PreCalcValues* _pcv );
109		void createForSearch( const ChromaFormat _chromaFormat, const Area& _area );
110		void destroy();
111		void releaseIntermediateData();
112
113		void rebindPicBufs();
114		void createCoeffs();
115		void destroyCoeffs();
116
117		void allocateVectorsAtPicLevel();
118
119		// ---------------------------------------------------------------------------
120		// global accessors
121		// ---------------------------------------------------------------------------
122
123		const CodingUnit* getCU(const Position& pos, const ChannelType _chType, const TreeType _treeType) const;
124		const TransformUnit* getTU(const Position& pos, const ChannelType _chType, const int subTuIdx = -1) const;
125
126		CodingUnit* getCU(const Position& pos, const ChannelType _chType, const TreeType _treeType);
127		CodingUnit* getLumaCU( const Position& pos );
128		TransformUnit* getTU(const Position& pos, const ChannelType _chType, const int subTuIdx = -1);
129
130	0	const CodingUnit* getCU(const ChannelType& _chType, const TreeType _treeType) const { return getCU(area.blocks[_chType].pos(), _chType, _treeType); }
131	0	const TransformUnit* getTU(const ChannelType& _chType) const { return getTU(area.blocks[_chType].pos(), _chType); }
132
133	0	CodingUnit* getCU(const ChannelType& _chType, const TreeType _treeType ) { return getCU(area.blocks[_chType].pos(), _chType, _treeType); }
134	0	TransformUnit* getTU(const ChannelType& _chType ) { return getTU(area.blocks[_chType].pos(), _chType); }
135
136		const CodingUnit* getCURestricted(const Position& pos, const Position curPos, const unsigned curSliceIdx, const unsigned curTileIdx, const ChannelType _chType, const TreeType treeType) const;
137		const CodingUnit* getCURestricted(const Position& pos, const CodingUnit& curCu, const ChannelType _chType) const;
138		const TransformUnit* getTURestricted(const Position& pos, const TransformUnit& curTu, const ChannelType _chType) const;
139
140		CodingUnit& addCU(const UnitArea& unit, const ChannelType _chType, CodingUnit* cuInit = nullptr);
141		TransformUnit& addTU(const UnitArea& unit, const ChannelType _chType, CodingUnit* cu, TransformUnit* tuInit = nullptr);
142		void addEmptyTUs( Partitioner &partitioner, CodingUnit* cu );
143
144		CUTraverser traverseCUs(const UnitArea& _unit, const ChannelType _chType);
145		TUTraverser traverseTUs(const UnitArea& _unit, const ChannelType _chType);
146
147		cCUTraverser traverseCUs(const UnitArea& _unit, const ChannelType _chType) const;
148		cTUTraverser traverseTUs(const UnitArea& _unit, const ChannelType _chType) const;
149		// ---------------------------------------------------------------------------
150		// encoding search utilities
151		// ---------------------------------------------------------------------------
152
153		double cost;
154		double costDbOffset;
155		double lumaCost;
156		uint64_t fracBits;
157		Distortion dist;
158		Distortion interHad;
159
160		void initStructData ( const int QP = MAX_INT, const bool skipMotBuf = true, const UnitArea* area = nullptr );
161		void initSubStructure( CodingStructure& cs, const ChannelType chType, const UnitArea& subArea, const bool isTuEnc, PelStorage* pOrgBuffer = nullptr, PelStorage* pRspBuffer = nullptr);
162		void compactResize ( const UnitArea& area );
163
164		void copyStructure (const CodingStructure& cs, const ChannelType chType, const TreeType treeType, const bool copyTUs = false, const bool copyRecoBuffer = false);
165		void useSubStructure ( CodingStructure& cs, const ChannelType chType, const TreeType treeType, const UnitArea& subArea, const bool cpyRecoToPic = true);
166
167		void clearTUs( bool force = false );
168		void clearCUs( bool force = false );
169
170		void createTempBuffers( const bool isTopLayer );
171		void destroyTempBuffers();
172		private:
173		void createInternals(const UnitArea& _unit, const bool isTopLayer);
174
175		public:
176
177
178		std::vector< CodingUnit*> cus;
179		std::vector< TransformUnit*> tus;
180
181		LutMotionCand motionLut;
182		std::vector<LutMotionCand> motionLutBuf;
183		void addMiToLut(static_vector<HPMVInfo, MAX_NUM_HMVP_CANDS>& lut, const HPMVInfo &mi);
184
185		private:
186
187		// needed for TU encoding
188		bool m_isTuEnc;
189
190		CodingUnit** m_cuPtr [MAX_NUM_CH];
191
192		unsigned m_numCUs;
193		unsigned m_numTUs;
194
195		CUCache& m_cuCache;
196		TUCache& m_tuCache;
197		std::mutex* m_unitCacheMutex;
198
199		std::vector<SAOBlkParam> m_sao;
200
201		PelStorage m_pred;
202		PelStorage m_resi;
203		PelStorage m_reco;
204		PelStorage m_rspreco;
205		PelStorage* m_org;
206		PelStorage* m_rsporg;
207
208		TCoeffSig* m_coeffs [MAX_NUM_COMP];
209		int m_offsets[MAX_NUM_COMP];
210
211		std::vector<Mv> m_dmvrMvCache;
212		int m_dmvrMvCacheOffset;
213
214		MotionInfo* m_motionBuf;
215
216		LoopFilterParam* m_lfParam[NUM_EDGE_DIR];
217
218		Size m_mapSize[MAX_NUM_CH];
219
220
221		public:
222		CodingStructure* bestParent;
223		bool resetIBCBuffer;
224
225		MotionBuf getMotionBuf( const Area& _area );
226	0	MotionBuf getMotionBuf( const UnitArea& _area ) { return getMotionBuf( _area.Y() ); }
227	0	MotionBuf getMotionBuf() { return getMotionBuf( area.Y() ); }
228
229		const CMotionBuf getMotionBuf( const Area& _area ) const;
230	0	const CMotionBuf getMotionBuf( const UnitArea& _area ) const { return getMotionBuf( _area.Y() ); }
231	0	const CMotionBuf getMotionBuf() const { return getMotionBuf( area.Y() ); }
232
233		MotionInfo& getMotionInfo( const Position& pos );
234		const MotionInfo& getMotionInfo( const Position& pos ) const;
235
236	0	MotionInfo const* getMiMapPtr() const { return m_motionBuf; }
237	0	MotionInfo * getMiMapPtr() { return m_motionBuf; }
238	0	ptrdiff_t getMiMapStride() const { return ( ptrdiff_t ) g_miScaling.scaleHor( area.Y().width ); }
239
240		LFPBuf getLoopFilterParamBuf(const DeblockEdgeDir& edgeDir);
241		const CLFPBuf getLoopFilterParamBuf(const DeblockEdgeDir& edgeDir) const;
242
243	0	LoopFilterParam const* getLFPMapPtr ( const DeblockEdgeDir edgeDir ) const { return m_lfParam[edgeDir]; }
244	0	LoopFilterParam * getLFPMapPtr ( const DeblockEdgeDir edgeDir ) { return m_lfParam[edgeDir]; }
245	0	ptrdiff_t getLFPMapStride() const { return ( ptrdiff_t ) m_mapSize[CH_L].width; }
246
247		UnitScale getScaling(const UnitScale::ScaliningType type, const ChannelType chType = CH_L) const
248	0	{
249	0	return type == UnitScale::MI_MAP ? g_miScaling : unitScale[chType];
250	0	}
251
252		public:
253		// ---------------------------------------------------------------------------
254		// temporary (shadowed) data accessors
255		// ---------------------------------------------------------------------------
256	0	PelBuf getPredBuf(const CompArea& blk) { return getBuf(blk, PIC_PREDICTION); }
257	0	const CPelBuf getPredBuf(const CompArea& blk) const { return getBuf(blk, PIC_PREDICTION); }
258	0	PelUnitBuf getPredBuf(const UnitArea& unit) { return getBuf(unit, PIC_PREDICTION); }
259	0	const CPelUnitBuf getPredBuf(const UnitArea& unit) const { return getBuf(unit, PIC_PREDICTION); }
260
261	0	PelBuf getResiBuf(const CompArea& blk) { return getBuf(blk, PIC_RESIDUAL); }
262	0	const CPelBuf getResiBuf(const CompArea& blk) const { return getBuf(blk, PIC_RESIDUAL); }
263	0	PelUnitBuf getResiBuf(const UnitArea& unit) { return getBuf(unit, PIC_RESIDUAL); }
264	0	const CPelUnitBuf getResiBuf(const UnitArea& unit) const { return getBuf(unit, PIC_RESIDUAL); }
265
266	0	PelBuf getRecoBuf(const CompArea& blk) { return getBuf(blk, PIC_RECONSTRUCTION); }
267	0	const CPelBuf getRecoBuf(const CompArea& blk) const { return getBuf(blk, PIC_RECONSTRUCTION); }
268	0	PelUnitBuf getRecoBuf(const UnitArea& unit) { return getBuf(unit, PIC_RECONSTRUCTION); }
269	0	const CPelUnitBuf getRecoBuf(const UnitArea& unit) const { return getBuf(unit, PIC_RECONSTRUCTION); }
270
271	0	PelBuf getOrgBuf(const CompArea& blk) { return getBuf(blk, PIC_ORIGINAL); }
272	0	const CPelBuf getOrgBuf(const CompArea& blk) const { return getBuf(blk, PIC_ORIGINAL); }
273	0	PelUnitBuf getOrgBuf(const UnitArea& unit) { return getBuf(unit, PIC_ORIGINAL); }
274	0	const CPelUnitBuf getOrgBuf(const UnitArea& unit) const { return getBuf(unit, PIC_ORIGINAL); }
275
276	0	PelBuf getRspOrgBuf(const CompArea& blk) { return getBuf(blk, PIC_ORIGINAL_RSP); }
277	0	const CPelBuf getRspOrgBuf(const CompArea& blk) const { return getBuf(blk, PIC_ORIGINAL_RSP); }
278
279	0	PelBuf getRspRecoBuf(const CompArea &blk) { return getBuf(blk, PIC_ORIGINAL_RSP_REC); }
280	0	const CPelBuf getRspRecoBuf(const CompArea &blk) const { return getBuf(blk, PIC_ORIGINAL_RSP_REC); }
281
282	0	PelUnitBuf& getRecoBufRef() { return m_reco; }
283	0	PelBuf& getRspRecoBuf() { return m_rspreco.Y(); }
284	0	const CPelBuf getRspRecoBuf() const { return m_rspreco.Y(); }
285
286	0	PelBuf& getRspOrgBuf() { return m_rsporg->Y(); }
287	0	const CPelBuf getRspOrgBuf() const { return m_rsporg->Y(); }
288
289	0	PelBuf getOrgBuf(const ComponentID compID) { return m_org->get(compID); }
290	0	const CPelBuf getOrgBuf(const ComponentID compID) const { return m_org->get(compID); }
291	0	PelUnitBuf& getOrgBuf() { return *m_org; }
292	0	const CPelUnitBuf getOrgBuf() const { return *m_org; }
293
294		// pred buffer
295	0	PelBuf getPredBuf(const ComponentID compID) { return m_pred.get(compID); }
296	0	const CPelBuf getPredBuf(const ComponentID compID)const { return m_pred.get(compID); }
297	0	PelUnitBuf& getPredBuf() { return m_pred; }
298	0	const CPelUnitBuf getPredBuf() const { return m_pred; }
299
300		// resi buffer
301	0	PelBuf getResiBuf(const ComponentID compID) { return m_resi.get(compID); }
302	0	const CPelBuf getResiBuf(const ComponentID compID)const { return m_resi.get(compID); }
303	0	PelUnitBuf& getResiBuf() { return m_resi; }
304	0	const CPelUnitBuf getResiBuf() const { return m_resi; }
305
306		// reco buffer
307	0	const CPelBuf getRecoBuf(const ComponentID compID)const { return m_reco.get(compID); }
308	0	PelBuf getRecoBuf(const ComponentID compID) { return m_reco.get(compID); }
309	0	PelUnitBuf& getRecoBuf() { return m_reco; }
310	0	const CPelUnitBuf getRecoBuf() const { return m_reco; }
311
312		private:
313
314		PelBuf getBuf(const CompArea& blk, const PictureType type);
315		const CPelBuf getBuf(const CompArea& blk, const PictureType type) const;
316		PelUnitBuf getBuf(const UnitArea& unit, const PictureType type);
317		const CPelUnitBuf getBuf(const UnitArea& unit, const PictureType type) const;
318		};
319
320
321	0	static inline uint32_t getNumberValidTBlocks(const PreCalcValues& pcv) { return (pcv.chrFormat==CHROMA_400) ? 1 : MAX_NUM_COMP; } Unexecuted instantiation: vvencimpl.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: InitX86.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: AdaptiveLoopFilter_sse41.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: FGA_sse41.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: InterPred_sse41.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: IntraPred_sse41.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: LoopFilter_sse41.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: MCTF_avx41.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: AdaptiveLoopFilter_avx2.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: FGA_avx2.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: InterPred_avx2.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: IntraPred_avx2.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: LoopFilter_avx2.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: MCTF_avx2.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: AdaptiveLoopFilter.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: CodingStructure.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: ContextModelling.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: DepQuant.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: Picture.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: Quant.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: QuantRDOQ2.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: Rom.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: Slice.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: Unit.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: UnitPartitioner.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: UnitTools.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncLib.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: PreProcess.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: RateCtrl.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: InterPrediction.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: MCTF.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: Mv.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: QuantRDOQ.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: BitAllocation.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncGOP.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncPicture.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncReshape.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncSlice.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: GOPCfg.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: InterSearch.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: SEIFilmGrainAnalyzer.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: SEIwrite.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: VLCWriter.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: LoopFilter.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: PicYuvMD5.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: Reshape.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: SampleAdaptiveOffset.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: TrQuant.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: CABACWriter.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncAdaptiveLoopFilter.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncCu.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncModeCtrl.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: EncSampleAdaptiveOffset.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: IntraSearch.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: IntraPrediction.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: MatrixIntraPrediction.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&) Unexecuted instantiation: DecCu.cpp:vvenc::getNumberValidTBlocks(vvenc::PreCalcValues const&)
322
323		} // namespace vvenc
324
325		//! \}
326