UnitPartitioner.h 9.54 KB
Newer Older
1
2
3
4
5
/* The copyright in this software is being made available under the BSD
* License, included below. This software may be subject to other third party
* and contributor rights, including patent rights, and no such rights are
* granted under this license.
*
6
* Copyright (c) 2010-2019, ITU/ISO/IEC
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted 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 ITU/ISO/IEC nor the names of its contributors may
*    be used to endorse or promote products derived from this software without
*    specific prior written permission.
*
* 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     UnitPartitioner.h
 *  \brief    Provides a class for partitioning management
 */

#ifndef __UNITPARTITIONER__
#define __UNITPARTITIONER__

#include "Unit.h"

#include "CommonDef.h"

static_assert( MAX_CU_TILING_PARTITIONS >= 4, "Minimum required number of partitions for the Partitioning type is 4!" );
46
47
48
#if JVET_M0102_INTRA_SUBPARTITIONS
typedef std::vector <UnitArea> Partitioning;
#else
49
typedef static_vector<UnitArea, MAX_CU_TILING_PARTITIONS> Partitioning;
50
#endif
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//////////////////////////////////////////////////////////////////////////
// PartManager class - manages the partitioning tree
//
// contains the currently processed partitioning area (currArea)
// as well as the all partitioning decisions that led to this area
// being processed (in m_partStack).
//////////////////////////////////////////////////////////////////////////

enum PartSplit
{
  CTU_LEVEL        = 0,
  CU_QUAD_SPLIT,

  CU_HORZ_SPLIT,
  CU_VERT_SPLIT,
  CU_TRIH_SPLIT,
  CU_TRIV_SPLIT,
  TU_MAX_TR_SPLIT,
70
71
72
73
#if JVET_M0102_INTRA_SUBPARTITIONS
  TU_NO_ISP,
  TU_1D_HORZ_SPLIT,
  TU_1D_VERT_SPLIT,
74
75
76
77
78
79
80
81
82
83
#endif
#if JVET_M0140_SBT
  SBT_VER_HALF_POS0_SPLIT,
  SBT_VER_HALF_POS1_SPLIT,
  SBT_HOR_HALF_POS0_SPLIT,
  SBT_HOR_HALF_POS1_SPLIT,
  SBT_VER_QUAD_POS0_SPLIT,
  SBT_VER_QUAD_POS1_SPLIT,
  SBT_HOR_QUAD_POS0_SPLIT,
  SBT_HOR_QUAD_POS1_SPLIT,
84
#endif
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
  NUM_PART_SPLIT,
  CU_MT_SPLIT             = 1000, ///< dummy element to indicate the MT (multi-type-tree) split
  CU_BT_SPLIT             = 1001, ///< dummy element to indicate the BT split
  CU_DONT_SPLIT           = 2000  ///< dummy element to indicate no splitting
};



struct PartLevel
{
  PartSplit    split;
  Partitioning parts;
  unsigned     idx;
  bool         checkdIfImplicit;
  bool         isImplicit;
  PartSplit    implicitSplit;
  PartSplit    firstSubPartSplit;
  bool         canQtSplit;
103
104
105
106
#if JVET_M0113_M0188_QG_SIZE
  bool         qgEnable;
  bool         qgChromaEnable;
#endif
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

  PartLevel();
  PartLevel( const PartSplit _split, const Partitioning&  _parts );
  PartLevel( const PartSplit _split,       Partitioning&& _parts );
};

// set depending on max QT / BT possibilities
typedef static_vector<PartLevel, 2 * MAX_CU_DEPTH + 1> PartitioningStack;

class Partitioner
{
protected:
  PartitioningStack m_partStack;
#if _DEBUG
  UnitArea          m_currArea;
#endif

public:
  unsigned currDepth;
  unsigned currQtDepth;
  unsigned currTrDepth;
  unsigned currBtDepth;
  unsigned currMtDepth;
130
131
132
#if JVET_M0113_M0188_QG_SIZE
  unsigned currSubdiv;
#endif
133
134
135
136
137
138
139
140
141
142

  unsigned currImplicitBtDepth;
  ChannelType chType;

  virtual ~Partitioner                    () { }

  const PartLevel& currPartLevel          () const { return m_partStack.back(); }
  const UnitArea&  currArea               () const { return currPartLevel().parts[currPartIdx()]; }
  const unsigned   currPartIdx            () const { return currPartLevel().idx; }
  const PartitioningStack& getPartStack   () const { return m_partStack; }
143
144
145
146
#if JVET_M0113_M0188_QG_SIZE
  const bool currQgEnable                 () const { return currPartLevel().qgEnable; }
  const bool currQgChromaEnable           () const { return currPartLevel().qgChromaEnable; }
#endif
147
148
149
150
151
152
153
154
155
156
157
158
159
160

  SplitSeries getSplitSeries              () const;

  virtual void initCtu                    ( const UnitArea& ctuArea, const ChannelType _chType, const Slice& slice )    = 0;
  virtual void splitCurrArea              ( const PartSplit split, const CodingStructure &cs )                          = 0;
  virtual void exitCurrSplit              ()                                                                            = 0;
  virtual bool nextPart                   ( const CodingStructure &cs, bool autoPop = false )                           = 0;
  virtual bool hasNextPart                ()                                                                            = 0;

  virtual void setCUData                  ( CodingUnit& cu );

  virtual void copyState                  ( const Partitioner& other );

public:
Adam Wieckowski's avatar
Adam Wieckowski committed
161
162
163
#if JVET_M0421_SPLIT_SIG
  virtual void canSplit                   ( const CodingStructure &cs, bool& canNo, bool& canQt, bool& canBh, bool& canBv, bool& canTh, bool& canTv ) = 0;
#endif
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
  virtual bool canSplit                   ( const PartSplit split,                          const CodingStructure &cs ) = 0;
  virtual bool isSplitImplicit            ( const PartSplit split,                          const CodingStructure &cs ) = 0;
  virtual PartSplit getImplicitSplit      (                                                 const CodingStructure &cs ) = 0;
};

class AdaptiveDepthPartitioner : public Partitioner
{
public:
  void setMaxMinDepth( unsigned& minDepth, unsigned& maxDepth, const CodingStructure& cs ) const;
};

class QTBTPartitioner : public AdaptiveDepthPartitioner
{
public:
  void initCtu                    ( const UnitArea& ctuArea, const ChannelType _chType, const Slice& slice );
  void splitCurrArea              ( const PartSplit split, const CodingStructure &cs );
  void exitCurrSplit              ();
  bool nextPart                   ( const CodingStructure &cs, bool autoPop = false );
  bool hasNextPart                ();
183

Adam Wieckowski's avatar
Adam Wieckowski committed
184
185
186
#if JVET_M0421_SPLIT_SIG
  void canSplit                   ( const CodingStructure &cs, bool& canNo, bool& canQt, bool& canBh, bool& canBv, bool& canTh, bool& canTv );
#endif
187
188
189
190
191
  bool canSplit                   ( const PartSplit split,                          const CodingStructure &cs );
  bool isSplitImplicit            ( const PartSplit split,                          const CodingStructure &cs );
  PartSplit getImplicitSplit      (                                                 const CodingStructure &cs );
};

192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
#if JVET_M0102_INTRA_SUBPARTITIONS
class TUIntraSubPartitioner : public Partitioner
{
public:
  TUIntraSubPartitioner(Partitioner& _initialState)
  {
    //we copy the input partitioner data
    m_partStack.push_back(PartLevel(TU_NO_ISP, { _initialState.currArea() }));

    currDepth    = _initialState.currDepth;
    currQtDepth  = _initialState.currQtDepth;
    currTrDepth  = _initialState.currTrDepth;
    currBtDepth  = _initialState.currBtDepth;
    currMtDepth  = _initialState.currMtDepth;
    chType       = _initialState.chType;
#if _DEBUG
    m_currArea   = _initialState.currArea();
#endif
  }

  void initCtu               (const UnitArea& ctuArea, const ChannelType chType, const Slice& slice) {}; // not needed
  void splitCurrArea         (const PartSplit split, const CodingStructure &cs);
  void exitCurrSplit         ();
  bool nextPart              (const CodingStructure &cs, bool autoPop = false);
  bool hasNextPart           ();
  void canSplit              (const CodingStructure &cs, bool& canNo, bool& canQt, bool& canBh, bool& canBv, bool& canTh, bool& canTv) {};
  bool canSplit              (const PartSplit split, const CodingStructure &cs);
  bool isSplitImplicit       (const PartSplit split, const CodingStructure &cs) { return false; }; //not needed
  PartSplit getImplicitSplit (const CodingStructure &cs) { return CU_DONT_SPLIT; }; //not needed
};
#endif
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239




namespace PartitionerFactory
{
  Partitioner* get( const Slice& slice );
};

//////////////////////////////////////////////////////////////////////////
// Partitioner namespace - contains methods calculating the actual splits
//////////////////////////////////////////////////////////////////////////

namespace PartitionerImpl
{
  Partitioning getCUSubPartitions( const UnitArea   &cuArea, const CodingStructure &cs, const PartSplit splitType = CU_QUAD_SPLIT );
  Partitioning getMaxTuTiling    ( const UnitArea& curArea, const CodingStructure &cs );
240
241
242
#if JVET_M0102_INTRA_SUBPARTITIONS
  void    getTUIntraSubPartitions( Partitioning &sub, const UnitArea &tuArea, const CodingStructure &cs, const PartSplit splitType );
#endif
243
244
245
#if JVET_M0140_SBT
  Partitioning getSbtTuTiling    ( const UnitArea& curArea, const CodingStructure &cs, const PartSplit splitType );
#endif
246
247
248
};

#endif