/* -----------------------------------------------------------------------------

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) 2018-2026, Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. & The VVdeC 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     Slice.h

    \brief    slice header and SPS class (header)

*/

#pragma once

#include "CommonDef.h"

#include "ChromaFormat.h"

#include "Common.h"

#include "BitStream.h"

#include "Utilities/ThreadPool.h"

#include <cstring>

#include <list>

#include <vector>

namespace vvdec

{

// ====================================================================================================================

// Constants

// ====================================================================================================================

class PreCalcValues;

class ParameterSetManager;

struct Picture;

typedef std::list<Picture*> PicList;

static const uint32_t REF_PIC_LIST_NUM_IDX=32;

using PartitionConstraints = std::array<unsigned, 3>;

using AlfApsIdVec          = static_vector<int, MAX_NUM_ALF_APS_IDS>;

// ====================================================================================================================

// Class definition

// ====================================================================================================================

struct DpbParameters

{

  int m_maxDecPicBuffering     [MAX_TLAYER] = { 0 };

  int m_numReorderPics         [MAX_TLAYER] = { 0 };

  int m_maxLatencyIncreasePlus1[MAX_TLAYER] = { 0 };

};

class ReferencePictureList

{

private:

  int   m_numberOfShorttermPictures                = 0;

  int   m_numberOfLongtermPictures                 = 0;

  int   m_isLongtermRefPic      [MAX_NUM_REF_PICS] = { 0 };

  int   m_refPicIdentifier      [MAX_NUM_REF_PICS] = { 0 };   // This can be delta POC for STRP or POC LSB for LTRP

  int   m_POC                   [MAX_NUM_REF_PICS] = { 0 };

  int   m_deltaPOCMSBCycleLT    [MAX_NUM_REF_PICS] = { 0 };

  bool  m_deltaPocMSBPresentFlag[MAX_NUM_REF_PICS] = { 0 };

  bool  m_ltrp_in_slice_header_flag                = false;

  bool  m_interLayerPresentFlag                    = false;

  bool  m_isInterLayerRefPic [MAX_NUM_REF_PICS]    = { 0 };

  int   m_interLayerRefPicIdx[MAX_NUM_REF_PICS]    = { 0 };

  int   m_numberOfInterLayerPictures               = 0;

public:

  ReferencePictureList();

  void clear();

  void setRefPicIdentifier( int idx, int identifier, bool isLongterm, bool isInterLayerRefPic, int interLayerIdx );

  int  getRefPicIdentifier( int idx ) const;

  bool isRefPicLongterm( int idx ) const;

  void setRefPicLongterm( int idx, bool isLongterm );

  void setNumberOfShorttermPictures( int numberOfStrp );

  int  getNumberOfShorttermPictures() const;

  void setNumberOfLongtermPictures( int numberOfLtrp );

  int  getNumberOfLongtermPictures() const;

  void setLtrpInSliceHeaderFlag( bool flag ) { m_ltrp_in_slice_header_flag = flag; }

  bool getLtrpInSliceHeaderFlag() const { return m_ltrp_in_slice_header_flag; }

  void setNumberOfInterLayerPictures( const int numberOfIlrp ) { m_numberOfInterLayerPictures = numberOfIlrp; }

  int  getNumberOfInterLayerPictures() const { return m_numberOfInterLayerPictures; }

  int getNumRefEntries() const { return m_numberOfShorttermPictures + m_numberOfLongtermPictures + m_numberOfInterLayerPictures; }

  void setPOC( int idx, int POC );

  int  getPOC( int idx ) const;

  int  getDeltaPocMSBCycleLT( int i ) const { return m_deltaPOCMSBCycleLT[i]; }

  void setDeltaPocMSBCycleLT( int i, int x );

  bool getDeltaPocMSBPresentFlag( int i ) const { return m_deltaPocMSBPresentFlag[i]; }

  void setDeltaPocMSBPresentFlag( int i, bool x );

  void printRefPicInfo() const;

  bool getInterLayerPresentFlag() const { return m_interLayerPresentFlag; }

  void setInterLayerPresentFlag( bool b ) { m_interLayerPresentFlag = b; }

  bool isInterLayerRefPic( int idx ) const { return m_isInterLayerRefPic[idx]; }

  int  getInterLayerRefPicIdx( int idx ) const { return m_interLayerRefPicIdx[idx]; }

  void setInterLayerRefPicIdx( int idx, int layerIdc );

  bool findInRefPicList( const Picture* checkRefPic, int currPicPoc, int layerId ) const;

  static int calcLTRefPOC( int currPoc, int bitsForPoc, int refPicIdentifier, bool pocMSBPresent, int deltaPocMSBCycle );

  int        calcLTRefPOC( int currPoc, int bitsForPoc, int refPicIdx ) const;

};

bool isLTPocEqual( int poc1, int poc2, int bitsForPoc, bool msbPresent );

/// Reference Picture List set class

typedef std::vector<ReferencePictureList> RPLList;

/// SCALING_LIST class

class ScalingList

{

public:

  ScalingList();

  ~ScalingList() = default;

  CLASS_COPY_MOVE_DEFAULT( ScalingList )

  void       reset();

  static inline int  matrixSize( uint32_t scalingListId )   { return scalingListId < SCALING_LIST_1D_START_4x4 ? 2 : scalingListId < SCALING_LIST_1D_START_8x8 ? 4 : 8; }

  static inline bool isLumaScalingList( int scalingListId ) { return scalingListId % MAX_NUM_COMPONENT == SCALING_LIST_1D_START_4x4 || scalingListId == SCALING_LIST_1D_START_64x64 + 1;}

  void              setScalingListDC(uint32_t scalingListId, uint32_t u)             { m_scalingListDC[scalingListId] = u;                       } //!< set DC value

  int               getScalingListDC(uint32_t scalingListId) const                   { return m_scalingListDC[scalingListId];                    } //!< get DC value

  int*              getScalingListAddress(uint32_t scalingListId)                    { return m_scalingListCoef[scalingListId].data();           } //!< get matrix coefficient

  const int*        getScalingListAddress(uint32_t scalingListId) const              { return m_scalingListCoef[scalingListId].data();           } //!< get matrix coefficient

  std::vector<int>& getScalingListVec( uint32_t scalingListId )                      { return m_scalingListCoef[scalingListId]; }

private:

  int              m_scalingListDC  [28] = { 0 }; //!< the DC value of the matrix coefficient for 16x16

  std::vector<int> m_scalingListCoef[28];         //!< quantization matrix

};

class ConstraintInfo

{

  bool         m_gciPresentFlag                               = false;

  bool         m_noRprConstraintFlag                          = false;

  bool         m_noResChangeInClvsConstraintFlag              = false;

  bool         m_oneTilePerPicConstraintFlag                  = false;

  bool         m_picHeaderInSliceHeaderConstraintFlag         = false;

  bool         m_oneSlicePerPicConstraintFlag                 = false;

  bool         m_noIdrRplConstraintFlag                       = false;

  bool         m_noRectSliceConstraintFlag                    = false;

  bool         m_oneSlicePerSubpicConstraintFlag              = false;

  bool         m_noSubpicInfoConstraintFlag                   = false;

  bool         m_intraOnlyConstraintFlag                      = false;

  uint32_t     m_maxBitDepthConstraintIdc                     = 16;

  ChromaFormat m_maxChromaFormatConstraintIdc                 = CHROMA_444;

  bool         m_onePictureOnlyConstraintFlag                 = false;

  bool         m_lowerBitRateConstraintFlag                   = false;

  bool         m_allLayersIndependentConstraintFlag           = false;

  bool         m_noMrlConstraintFlag                          = false;

  bool         m_noIspConstraintFlag                          = false;

  bool         m_noMipConstraintFlag                          = false;

  bool         m_noLfnstConstraintFlag                        = false;

  bool         m_noMmvdConstraintFlag                         = false;

  bool         m_noSmvdConstraintFlag                         = false;

  bool         m_noProfConstraintFlag                         = false;

  bool         m_noPaletteConstraintFlag                      = false;

  bool         m_noActConstraintFlag                          = false;

  bool         m_noLmcsConstraintFlag                         = false;

  bool         m_noExplicitScaleListConstraintFlag            = false;

  bool         m_noVirtualBoundaryConstraintFlag              = false;

  bool         m_noMttConstraintFlag                          = false;

  bool         m_noChromaQpOffsetConstraintFlag               = false;

  bool         m_noQtbttDualTreeIntraConstraintFlag           = false;

  int          m_maxLog2CtuSizeConstraintIdc                  = 8;

  bool         m_noPartitionConstraintsOverrideConstraintFlag = false;

  bool         m_noSaoConstraintFlag                          = false;

  bool         m_noAlfConstraintFlag                          = false;

  bool         m_noCCAlfConstraintFlag                        = false;

  bool         m_noWeightedPredictionConstraintFlag           = false;

  bool         m_noRefWraparoundConstraintFlag                = false;

  bool         m_noTemporalMvpConstraintFlag                  = false;

  bool         m_noSbtmvpConstraintFlag                       = false;

  bool         m_noAmvrConstraintFlag                         = false;

  bool         m_noBdofConstraintFlag                         = false;

  bool         m_noDmvrConstraintFlag                         = false;

  bool         m_noCclmConstraintFlag                         = false;

  bool         m_noMtsConstraintFlag                          = false;

  bool         m_noSbtConstraintFlag                          = false;

  bool         m_noAffineMotionConstraintFlag                 = false;

  bool         m_noBcwConstraintFlag                          = false;

  bool         m_noIbcConstraintFlag                          = false;

  bool         m_noCiipConstraintFlag                         = false;

  bool         m_noGeoConstraintFlag                          = false;

  bool         m_noLadfConstraintFlag                         = false;

  bool         m_noTransformSkipConstraintFlag                = false;

  bool         m_noLumaTransformSize64ConstraintFlag          = false;

  bool         m_noBDPCMConstraintFlag                        = false;

  bool         m_noJointCbCrConstraintFlag                    = false;

  bool         m_noQpDeltaConstraintFlag                      = false;

  bool         m_noDepQuantConstraintFlag                     = false;

  bool         m_noSignDataHidingConstraintFlag               = false;

  bool         m_noMixedNaluTypesInPicConstraintFlag          = false;

  bool         m_noTrailConstraintFlag                        = false;

  bool         m_noStsaConstraintFlag                         = false;

  bool         m_noRaslConstraintFlag                         = false;

  bool         m_noRadlConstraintFlag                         = false;

  bool         m_noIdrConstraintFlag                          = false;

  bool         m_noCraConstraintFlag                          = false;

  bool         m_noGdrConstraintFlag                          = false;

  bool         m_noApsConstraintFlag                          = false;

public:

  bool          getGciPresentFlag() const { return m_gciPresentFlag; }

  void          setGciPresentFlag(bool b) { m_gciPresentFlag = b; }

  uint32_t      getMaxBitDepthConstraintIdc() const { return m_maxBitDepthConstraintIdc; }

  void          setMaxBitDepthConstraintIdc(uint32_t bitDepth) { m_maxBitDepthConstraintIdc = bitDepth; }

  ChromaFormat  getMaxChromaFormatConstraintIdc() const { return m_maxChromaFormatConstraintIdc; }

  void          setMaxChromaFormatConstraintIdc(ChromaFormat fmt) { m_maxChromaFormatConstraintIdc = fmt; }

  bool          getNoRprConstraintFlag() const { return m_noRprConstraintFlag; }

  void          setNoRprConstraintFlag(bool b) { m_noRprConstraintFlag = b; }

  bool          getNoResChangeInClvsConstraintFlag() const { return m_noResChangeInClvsConstraintFlag; }

  void          setNoResChangeInClvsConstraintFlag(bool b) { m_noResChangeInClvsConstraintFlag = b; }

  bool          getOneTilePerPicConstraintFlag() const { return m_oneTilePerPicConstraintFlag; }

  void          setOneTilePerPicConstraintFlag(bool b) { m_oneTilePerPicConstraintFlag = b; }

  bool          getPicHeaderInSliceHeaderConstraintFlag() const { return m_picHeaderInSliceHeaderConstraintFlag; }

  void          setPicHeaderInSliceHeaderConstraintFlag(bool b) { m_picHeaderInSliceHeaderConstraintFlag = b; }

  bool          getOneSlicePerPicConstraintFlag() const { return m_oneSlicePerPicConstraintFlag; }

  void          setOneSlicePerPicConstraintFlag(bool b) { m_oneSlicePerPicConstraintFlag = b; }

  bool          getNoIdrRplConstraintFlag() const          { return m_noIdrRplConstraintFlag; }

  void          setNoIdrRplConstraintFlag(bool b)          { m_noIdrRplConstraintFlag = b; }

  bool          getNoRectSliceConstraintFlag() const       { return m_noRectSliceConstraintFlag; }

  void          setNoRectSliceConstraintFlag(bool b)       { m_noRectSliceConstraintFlag = b; }

  bool          getOneSlicePerSubpicConstraintFlag() const { return m_oneSlicePerSubpicConstraintFlag; }

  void          setOneSlicePerSubpicConstraintFlag(bool b) { m_oneSlicePerSubpicConstraintFlag = b; }

  bool          getNoSubpicInfoConstraintFlag() const      { return m_noSubpicInfoConstraintFlag; }

  void          setNoSubpicInfoConstraintFlag(bool b)      { m_noSubpicInfoConstraintFlag = b; }

  bool          getIntraOnlyConstraintFlag() const { return m_intraOnlyConstraintFlag; }

  void          setIntraOnlyConstraintFlag(bool b) { m_intraOnlyConstraintFlag = b; }

  bool          getOnePictureOnlyConstraintFlag() const { return m_onePictureOnlyConstraintFlag; }

  void          setOnePictureOnlyConstraintFlag(bool b) { m_onePictureOnlyConstraintFlag = b; }

  bool          getLowerBitRateConstraintFlag() const { return m_lowerBitRateConstraintFlag; }

  void          setLowerBitRateConstraintFlag(bool b) { m_lowerBitRateConstraintFlag = b; }

  bool          getAllLayersIndependentConstraintFlag() const { return m_allLayersIndependentConstraintFlag; }

  void          setAllLayersIndependentConstraintFlag(bool b) { m_allLayersIndependentConstraintFlag = b; }

  bool          getNoMrlConstraintFlag() const { return m_noMrlConstraintFlag; }

  void          setNoMrlConstraintFlag(bool b) { m_noMrlConstraintFlag = b; }

  bool          getNoIspConstraintFlag() const { return m_noIspConstraintFlag; }

  void          setNoIspConstraintFlag(bool b) { m_noIspConstraintFlag = b; }

  bool          getNoMipConstraintFlag() const { return m_noMipConstraintFlag; }

  void          setNoMipConstraintFlag(bool b) { m_noMipConstraintFlag = b; }

  bool          getNoLfnstConstraintFlag() const { return m_noLfnstConstraintFlag; }

  void          setNoLfnstConstraintFlag(bool b) { m_noLfnstConstraintFlag = b; }

  bool          getNoMmvdConstraintFlag() const { return m_noMmvdConstraintFlag; }

  void          setNoMmvdConstraintFlag(bool b) { m_noMmvdConstraintFlag = b; }

  bool          getNoSmvdConstraintFlag() const { return m_noSmvdConstraintFlag; }

  void          setNoSmvdConstraintFlag(bool b) { m_noSmvdConstraintFlag = b; }

  bool          getNoProfConstraintFlag() const { return m_noProfConstraintFlag; }

  void          setNoProfConstraintFlag(bool b) { m_noProfConstraintFlag = b; }

  bool          getNoPaletteConstraintFlag() const { return m_noPaletteConstraintFlag; }

  void          setNoPaletteConstraintFlag(bool b) { m_noPaletteConstraintFlag = b; }

  bool          getNoActConstraintFlag() const { return m_noActConstraintFlag; }

  void          setNoActConstraintFlag(bool b) { m_noActConstraintFlag = b; }

  bool          getNoLmcsConstraintFlag() const { return m_noLmcsConstraintFlag; }

  void          setNoLmcsConstraintFlag(bool b) { m_noLmcsConstraintFlag = b; }

  bool          getNoExplicitScaleListConstraintFlag() const { return m_noExplicitScaleListConstraintFlag; }

  void          setNoExplicitScaleListConstraintFlag(bool b) { m_noExplicitScaleListConstraintFlag = b; }

  bool          getNoVirtualBoundaryConstraintFlag() const { return m_noVirtualBoundaryConstraintFlag; }

  void          setNoVirtualBoundaryConstraintFlag(bool b) { m_noVirtualBoundaryConstraintFlag = b; }

  bool          getNoMttConstraintFlag() const { return m_noMttConstraintFlag; }

  void          setNoMttConstraintFlag(bool bVal) { m_noMttConstraintFlag = bVal; }

  bool          getNoChromaQpOffsetConstraintFlag() const { return m_noChromaQpOffsetConstraintFlag; }

  void          setNoChromaQpOffsetConstraintFlag(bool b) { m_noChromaQpOffsetConstraintFlag = b; }

  bool          getNoQtbttDualTreeIntraConstraintFlag() const { return m_noQtbttDualTreeIntraConstraintFlag; }

  void          setNoQtbttDualTreeIntraConstraintFlag(bool bVal) { m_noQtbttDualTreeIntraConstraintFlag = bVal; }

  int           getMaxLog2CtuSizeConstraintIdc() const { return m_maxLog2CtuSizeConstraintIdc; }

  void          setMaxLog2CtuSizeConstraintIdc(int idc) { m_maxLog2CtuSizeConstraintIdc = idc; }

  bool          getNoPartitionConstraintsOverrideConstraintFlag() const { return m_noPartitionConstraintsOverrideConstraintFlag; }

  void          setNoPartitionConstraintsOverrideConstraintFlag(bool bVal) { m_noPartitionConstraintsOverrideConstraintFlag = bVal; }

  bool          getNoSaoConstraintFlag() const { return m_noSaoConstraintFlag; }

  void          setNoSaoConstraintFlag(bool bVal) { m_noSaoConstraintFlag = bVal; }

  bool          getNoAlfConstraintFlag() const { return m_noAlfConstraintFlag; }

  void          setNoAlfConstraintFlag(bool bVal) { m_noAlfConstraintFlag = bVal; }

  bool          getNoCCAlfConstraintFlag() const { return m_noCCAlfConstraintFlag; }

  void          setNoCCAlfConstraintFlag(bool val) { m_noCCAlfConstraintFlag = val; }

  bool          getNoJointCbCrConstraintFlag() const { return m_noJointCbCrConstraintFlag; }

  void          setNoJointCbCrConstraintFlag(bool bVal) { m_noJointCbCrConstraintFlag = bVal; }

  bool          getNoWeightedPredictionConstraintFlag() const { return m_noWeightedPredictionConstraintFlag; }

  void          setNoWeightedPredictionConstraintFlag(bool bVal) { m_noWeightedPredictionConstraintFlag = bVal; }

  bool          getNoRefWraparoundConstraintFlag() const { return m_noRefWraparoundConstraintFlag; }

  void          setNoRefWraparoundConstraintFlag(bool bVal) { m_noRefWraparoundConstraintFlag = bVal; }

  bool          getNoTemporalMvpConstraintFlag() const { return m_noTemporalMvpConstraintFlag; }

  void          setNoTemporalMvpConstraintFlag(bool bVal) { m_noTemporalMvpConstraintFlag = bVal; }

  bool          getNoSbtmvpConstraintFlag() const { return m_noSbtmvpConstraintFlag; }

  void          setNoSbtmvpConstraintFlag(bool bVal) { m_noSbtmvpConstraintFlag = bVal; }

  bool          getNoAmvrConstraintFlag() const { return m_noAmvrConstraintFlag; }

  void          setNoAmvrConstraintFlag(bool bVal) { m_noAmvrConstraintFlag = bVal; }

  bool          getNoBdofConstraintFlag() const { return m_noBdofConstraintFlag; }

  void          setNoBdofConstraintFlag(bool bVal) { m_noBdofConstraintFlag = bVal; }

  bool          getNoDmvrConstraintFlag() const { return m_noDmvrConstraintFlag; }

  void          setNoDmvrConstraintFlag(bool bVal) { m_noDmvrConstraintFlag = bVal; }

  bool          getNoCclmConstraintFlag() const { return m_noCclmConstraintFlag; }

  void          setNoCclmConstraintFlag(bool bVal) { m_noCclmConstraintFlag = bVal; }

  bool          getNoMtsConstraintFlag() const { return m_noMtsConstraintFlag; }

  void          setNoMtsConstraintFlag(bool bVal) { m_noMtsConstraintFlag = bVal; }

  bool          getNoSbtConstraintFlag() const { return m_noSbtConstraintFlag; }

  void          setNoSbtConstraintFlag(bool bVal) { m_noSbtConstraintFlag = bVal; }

  bool          getNoAffineMotionConstraintFlag() const { return m_noAffineMotionConstraintFlag; }

  void          setNoAffineMotionConstraintFlag(bool bVal) { m_noAffineMotionConstraintFlag = bVal; }

  bool          getNoBcwConstraintFlag() const { return m_noBcwConstraintFlag; }

  void          setNoBcwConstraintFlag(bool bVal) { m_noBcwConstraintFlag = bVal; }

  bool          getNoIbcConstraintFlag() const { return m_noIbcConstraintFlag; }

  void          setNoIbcConstraintFlag(bool bVal) { m_noIbcConstraintFlag = bVal; }

  bool          getNoCiipConstraintFlag() const { return m_noCiipConstraintFlag; }

  void          setNoCiipConstraintFlag(bool bVal) { m_noCiipConstraintFlag = bVal; }

  bool          getNoGeoConstraintFlag() const { return m_noGeoConstraintFlag; }

  void          setNoGeoConstraintFlag(bool bVal) { m_noGeoConstraintFlag = bVal; }

  bool          getNoLadfConstraintFlag() const { return m_noLadfConstraintFlag; }

  void          setNoLadfConstraintFlag(bool bVal) { m_noLadfConstraintFlag = bVal; }

  bool          getNoTransformSkipConstraintFlag() const { return m_noTransformSkipConstraintFlag; }

  void          setNoTransformSkipConstraintFlag(bool bVal) { m_noTransformSkipConstraintFlag = bVal; }

  bool          getNoLumaTransformSize64ConstraintFlag() const { return m_noLumaTransformSize64ConstraintFlag; }

  void          setNoLumaTransformSize64ConstraintFlag(bool bVal) { m_noLumaTransformSize64ConstraintFlag = bVal; }

  bool          getNoBDPCMConstraintFlag() const { return m_noBDPCMConstraintFlag; }

  void          setNoBDPCMConstraintFlag(bool bVal) { m_noBDPCMConstraintFlag = bVal; }

  bool          getNoQpDeltaConstraintFlag() const { return m_noQpDeltaConstraintFlag; }

  void          setNoQpDeltaConstraintFlag(bool bVal) { m_noQpDeltaConstraintFlag = bVal; }

  bool          getNoDepQuantConstraintFlag() const { return m_noDepQuantConstraintFlag; }

  void          setNoDepQuantConstraintFlag(bool bVal) { m_noDepQuantConstraintFlag = bVal; }

  bool          getNoSignDataHidingConstraintFlag() const { return m_noSignDataHidingConstraintFlag; }

  void          setNoSignDataHidingConstraintFlag(bool bVal) { m_noSignDataHidingConstraintFlag = bVal; }

  bool          getNoMixedNaluTypesInPicConstraintFlag() const    { return m_noMixedNaluTypesInPicConstraintFlag; }

  void          setNoMixedNaluTypesInPicConstraintFlag(bool bVal) { m_noMixedNaluTypesInPicConstraintFlag = bVal; }

  bool          getNoTrailConstraintFlag() const { return m_noTrailConstraintFlag; }

  void          setNoTrailConstraintFlag(bool bVal) { m_noTrailConstraintFlag = bVal; }

  bool          getNoStsaConstraintFlag() const { return m_noStsaConstraintFlag; }

  void          setNoStsaConstraintFlag(bool bVal) { m_noStsaConstraintFlag = bVal; }

  bool          getNoRaslConstraintFlag() const { return m_noRaslConstraintFlag; }

  void          setNoRaslConstraintFlag(bool bVal) { m_noRaslConstraintFlag = bVal; }

  bool          getNoRadlConstraintFlag() const { return m_noRadlConstraintFlag; }

  void          setNoRadlConstraintFlag(bool bVal) { m_noRadlConstraintFlag = bVal; }

  bool          getNoIdrConstraintFlag() const { return m_noIdrConstraintFlag; }

  void          setNoIdrConstraintFlag(bool bVal) { m_noIdrConstraintFlag = bVal; }

  bool          getNoCraConstraintFlag() const { return m_noCraConstraintFlag; }

  void          setNoCraConstraintFlag(bool bVal) { m_noCraConstraintFlag = bVal; }

  bool          getNoGdrConstraintFlag() const { return m_noGdrConstraintFlag; }

  void          setNoGdrConstraintFlag(bool bVal) { m_noGdrConstraintFlag = bVal; }

  bool          getNoApsConstraintFlag() const { return m_noApsConstraintFlag; }

  void          setNoApsConstraintFlag(bool bVal) { m_noApsConstraintFlag = bVal; }

  friend bool             operator == (const ConstraintInfo& op1, const ConstraintInfo& op2);

  friend bool             operator != (const ConstraintInfo& op1, const ConstraintInfo& op2);

};

class ProfileTierLevel

{

  Tier                  m_tierFlag                = Tier::MAIN;

  Profile::Name         m_profileIdc              = Profile::NONE;

  uint8_t               m_numSubProfile           = 0;

  std::vector<uint32_t> m_subProfileIdc;

  vvdecLevel            m_levelIdc                = vvdecLevel::VVDEC_LEVEL_NONE;

  bool                  m_frameOnlyConstraintFlag = true;

  bool                  m_multiLayerEnabledFlag   = false;

  ConstraintInfo        m_constraintInfo;

  bool                  m_subLayerLevelPresentFlag[MAX_TLAYER - 1] = { 0 };

  vvdecLevel            m_subLayerLevelIdc        [MAX_TLAYER]     = { vvdecLevel::VVDEC_LEVEL_NONE };

public:

  ProfileTierLevel() = default;

  CLASS_COPY_MOVE_DEFAULT( ProfileTierLevel )

  Tier                    getTierFlag() const                         { return m_tierFlag;                    }

  void                    setTierFlag(Tier x)                         { m_tierFlag = x;                       }

  Profile::Name           getProfileIdc() const                       { return m_profileIdc;                  }

  void                    setProfileIdc(Profile::Name x)              { m_profileIdc = x;                     }

  uint8_t                 getNumSubProfile() const                    { return m_numSubProfile; }

  void                    setNumSubProfile(uint8_t x)                 { m_numSubProfile = x; m_subProfileIdc.resize(m_numSubProfile); }

  uint32_t                getSubProfileIdc(int i) const               { return m_subProfileIdc[i]; }

  void                    setSubProfileIdc(int i, uint32_t x)         { m_subProfileIdc[i] = x; }

  vvdecLevel              getLevelIdc() const                         { return m_levelIdc;                    }

  void                    setLevelIdc(vvdecLevel x)                   { m_levelIdc = x;                       }

  bool                    getFrameOnlyConstraintFlag() const          { return m_frameOnlyConstraintFlag; }

  void                    setFrameOnlyConstraintFlag(bool x)          { m_frameOnlyConstraintFlag = x;    }

  bool                    getMultiLayerEnabledFlag() const           { return m_multiLayerEnabledFlag; }

  void                    setMultiLayerEnabledFlag(bool x)           { m_multiLayerEnabledFlag = x;    }

  ConstraintInfo*         getConstraintInfo()                        { return &m_constraintInfo; }

  const ConstraintInfo*   getConstraintInfo() const                  { return &m_constraintInfo; }

  bool                    getSubLayerLevelPresentFlag(int i) const   { return m_subLayerLevelPresentFlag[i];   }

  void                    setSubLayerLevelPresentFlag(int i, bool x) { m_subLayerLevelPresentFlag[i] = x;      }

  vvdecLevel              getSubLayerLevelIdc(int i) const           { return m_subLayerLevelIdc[i];   }

  void                    setSubLayerLevelIdc(int i, vvdecLevel x)   { m_subLayerLevelIdc[i] = x;      }

  friend bool             operator == (const ProfileTierLevel& op1, const ProfileTierLevel& op2);

  friend bool             operator != (const ProfileTierLevel& op1, const ProfileTierLevel& op2);

};

struct HrdSubLayerInfo

{

  bool     fixedPicRateFlag          = 0;

  bool     fixedPicRateWithinCvsFlag = 0;

  uint32_t picDurationInTcMinus1     = 0;

  bool     lowDelayHrdFlag           = 0;

  uint32_t cpbCntMinus1              = 0;

  uint32_t bitRateValueMinus1[MAX_CPB_CNT][2] = { { 0 } };

  uint32_t cpbSizeValue      [MAX_CPB_CNT][2] = { { 0 } };

  uint32_t ducpbSizeValue    [MAX_CPB_CNT][2] = { { 0 } };

  bool     cbrFlag           [MAX_CPB_CNT][2] = { { 0 } };

  uint32_t duBitRateValue    [MAX_CPB_CNT][2] = { { 0 } };

};

class SliceReshapeInfo

{

public:

  bool     sliceReshaperEnableFlag                   = 0;

  bool     sliceReshaperModelPresentFlag             = 0;

  unsigned enableChromaAdj                           = 0;

  uint32_t reshaperModelMinBinIdx                    = 0;

  uint32_t reshaperModelMaxBinIdx                    = 0;

  int      reshaperModelBinCWDelta[PIC_CODE_CW_BINS] = { 0 };

  int      maxNbitsNeededDeltaCW                     = 0;

  int      chrResScalingOffset                       = 0;

  void reset()

  {

    memset( this, 0, sizeof( *this ) );

  }

};

template<class T>

struct BasePS: public std::enable_shared_from_this<T>

{

  std::shared_ptr<T> getSharedPtr()

  {

    return (static_cast<T*>(this))->shared_from_this();

  }

  std::shared_ptr<const T> getSharedPtr() const

  {

    return (static_cast<const T*>(this))->shared_from_this();

  }

Unexecuted instantiation: vvdec::BasePS<vvdec::PPS>::getSharedPtr() const

Unexecuted instantiation: vvdec::BasePS<vvdec::SPS>::getSharedPtr() const

Unexecuted instantiation: vvdec::BasePS<vvdec::APS>::getSharedPtr() const

  void clearChangedFlag()

  {

    m_changedFlag = false;

  }

Unexecuted instantiation: vvdec::BasePS<vvdec::SPS>::clearChangedFlag()

Unexecuted instantiation: vvdec::BasePS<vvdec::PPS>::clearChangedFlag()

Unexecuted instantiation: vvdec::BasePS<vvdec::APS>::clearChangedFlag()

  bool getChangedFlag() const

  {

    return m_changedFlag;

  }

Unexecuted instantiation: vvdec::BasePS<vvdec::SPS>::getChangedFlag() const

Unexecuted instantiation: vvdec::BasePS<vvdec::PPS>::getChangedFlag() const

Unexecuted instantiation: vvdec::BasePS<vvdec::APS>::getChangedFlag() const

  bool             m_changedFlag = false;

  template<class Tf, int MAX_ID> friend class ParameterSetMap;

};

class DCI

{

private:

  int                           m_maxSubLayersMinus1 = 0;

  std::vector<ProfileTierLevel> m_profileTierLevel;

public:

  int                     getMaxSubLayersMinus1()                                 const { return m_maxSubLayersMinus1; }

  void                    setMaxSubLayersMinus1(int val)                                { m_maxSubLayersMinus1 = val; }

  size_t                  getNumPTLs()                                            const { return m_profileTierLevel.size(); }

  const ProfileTierLevel& getProfileTierLevel(int idx)                            const { return m_profileTierLevel[idx]; }

  void                    setProfileTierLevel( std::vector<ProfileTierLevel>&& val )    { m_profileTierLevel = std::move( val ); }

  bool IsIndenticalDCI(const DCI& comparedDCI) const

  {

    if(m_maxSubLayersMinus1 != comparedDCI.m_maxSubLayersMinus1) return false;

    if(m_profileTierLevel != comparedDCI.m_profileTierLevel) return false;

    return true;

  }

};

class OlsHrdParams

{

private:

  bool     m_fixedPicRateGeneralFlag   = false;

  bool     m_fixedPicRateWithinCvsFlag = false;

  uint32_t m_elementDurationInTcMinus1 = false;

  bool     m_lowDelayHrdFlag           = false;

  uint32_t m_bitRateValueMinus1  [MAX_CPB_CNT][2] = { { 0 } };

  uint32_t m_cpbSizeValueMinus1  [MAX_CPB_CNT][2] = { { 0 } };

  uint32_t m_ducpbSizeValueMinus1[MAX_CPB_CNT][2] = { { 0 } };

  uint32_t m_duBitRateValueMinus1[MAX_CPB_CNT][2] = { { 0 } };

  bool     m_cbrFlag             [MAX_CPB_CNT][2] = { { 0 } };

public:

  void      setFixedPicRateGeneralFlag(bool flag)                             { m_fixedPicRateGeneralFlag = flag;    }

  bool      getFixedPicRateGeneralFlag() const                                { return m_fixedPicRateGeneralFlag;    }

  void      setFixedPicRateWithinCvsFlag(bool flag)                           { m_fixedPicRateWithinCvsFlag = flag;  }

  bool      getFixedPicRateWithinCvsFlag() const                              { return m_fixedPicRateWithinCvsFlag;  }

  void      setElementDurationInTcMinus1(uint32_t value)                      { m_elementDurationInTcMinus1 = value; }

  uint32_t  getElementDurationInTcMinus1() const                              { return m_elementDurationInTcMinus1;  }

  void      setLowDelayHrdFlag(bool flag)                                     { m_lowDelayHrdFlag = flag;            }

  bool      getLowDelayHrdFlag() const                                        { return m_lowDelayHrdFlag;            }

  void      setBitRateValueMinus1(int cpbcnt, int nalOrVcl, uint32_t value)   { m_bitRateValueMinus1[cpbcnt][nalOrVcl] = value;   }

  uint32_t  getBitRateValueMinus1(int cpbcnt, int nalOrVcl) const             { return m_bitRateValueMinus1[cpbcnt][nalOrVcl];    }

  void      setCpbSizeValueMinus1(int cpbcnt, int nalOrVcl, uint32_t value)   { m_cpbSizeValueMinus1[cpbcnt][nalOrVcl] = value;   }

  uint32_t  getCpbSizeValueMinus1(int cpbcnt, int nalOrVcl) const             { return m_cpbSizeValueMinus1[cpbcnt][nalOrVcl];    }

  void      setDuCpbSizeValueMinus1(int cpbcnt, int nalOrVcl, uint32_t value) { m_ducpbSizeValueMinus1[cpbcnt][nalOrVcl] = value; }

  uint32_t  getDuCpbSizeValueMinus1(int cpbcnt, int nalOrVcl) const           { return m_ducpbSizeValueMinus1[cpbcnt][nalOrVcl];  }

  void      setDuBitRateValueMinus1(int cpbcnt, int nalOrVcl, uint32_t value) { m_duBitRateValueMinus1[cpbcnt][nalOrVcl] = value; }

  uint32_t  getDuBitRateValueMinus1(int cpbcnt, int nalOrVcl) const           { return m_duBitRateValueMinus1[cpbcnt][nalOrVcl];  }

  void      setCbrFlag(int cpbcnt, int nalOrVcl, bool value)                  { m_cbrFlag[cpbcnt][nalOrVcl] = value;              }

  bool      getCbrFlag(int cpbcnt, int nalOrVcl) const                        { return m_cbrFlag[cpbcnt][nalOrVcl];               }

};

class GeneralHrdParams

{

private:

  uint32_t m_numUnitsInTick                   = 0;

  uint32_t m_timeScale                        = 0;

  bool     m_generalNalHrdParamsPresentFlag   = 0;

  bool     m_generalVclHrdParamsPresentFlag   = 0;

  bool     m_generalSamePicTimingInAllOlsFlag = false;

  uint32_t m_tickDivisorMinus2                = 0;

  bool     m_generalDuHrdParamsPresentFlag    = false;

  uint32_t m_bitRateScale                     = 0;

  uint32_t m_cpbSizeScale                     = 0;

  uint32_t m_cpbSizeDuScale                   = 0;

  uint32_t m_hrdCpbCntMinus1                  = 0;

public:

  void      setNumUnitsInTick(uint32_t value)                { m_numUnitsInTick = value; }

  uint32_t  getNumUnitsInTick() const                        { return m_numUnitsInTick; }

  void      setTimeScale(uint32_t value)                     { m_timeScale = value; }

  uint32_t  getTimeScale() const                             { return m_timeScale; }

  void      setGeneralNalHrdParamsPresentFlag( bool flag )   { m_generalNalHrdParamsPresentFlag = flag; }

  bool      getGeneralNalHrdParamsPresentFlag() const        { return m_generalNalHrdParamsPresentFlag; }

  void      setGeneralVclHrdParamsPresentFlag( bool flag )   { m_generalVclHrdParamsPresentFlag = flag; }

  bool      getGeneralVclHrdParamsPresentFlag() const        { return m_generalVclHrdParamsPresentFlag; }

  void      setGeneralSamePicTimingInAllOlsFlag( bool flag ) { m_generalSamePicTimingInAllOlsFlag = flag; }

  bool      getGeneralSamePicTimingInAllOlsFlag() const      { return m_generalSamePicTimingInAllOlsFlag; }

  void      setTickDivisorMinus2( uint32_t value )           { m_tickDivisorMinus2 = value;            }

  uint32_t  getTickDivisorMinus2( ) const                    { return m_tickDivisorMinus2;             }

  void      setGeneralDuHrdParamsPresentFlag( bool flag )    { m_generalDuHrdParamsPresentFlag = flag; }

  bool      getGeneralDuHrdParamsPresentFlag( ) const        { return m_generalDuHrdParamsPresentFlag; }

  void      setBitRateScale( uint32_t value )                { m_bitRateScale = value;                 }

  uint32_t  getBitRateScale( ) const                         { return m_bitRateScale;                  }

  void      setCpbSizeScale( uint32_t value )                { m_cpbSizeScale = value;                 }

  uint32_t  getCpbSizeScale( ) const                         { return m_cpbSizeScale;                  }

  void      setCpbSizeDuScale( uint32_t value )              { m_cpbSizeDuScale = value;               }

  uint32_t  getCpbSizeDuScale( ) const                       { return m_cpbSizeDuScale;                }

  void      setHrdCpbCntMinus1(uint32_t value)               { m_hrdCpbCntMinus1 = value;              }

  uint32_t  getHrdCpbCntMinus1() const                       { return m_hrdCpbCntMinus1;               }

};

class HRD

{

public:

  HRD()  = default;

  ~HRD() = default;

  void                    setGeneralHrdParameters(GeneralHrdParams &generalHrdParam) { m_generalHrdParams = generalHrdParam; }

  GeneralHrdParams        getGeneralHrdParameters() const { return m_generalHrdParams; }

  const GeneralHrdParams& getGeneralHrdParameters() { return m_generalHrdParams; }

  void                setOlsHrdParameters(int tLayter, OlsHrdParams &olsHrdParam) { m_olsHrdParams[tLayter] = olsHrdParam; }

  OlsHrdParams        getOlsHrdParameters() { return m_olsHrdParams[0]; }

  OlsHrdParams*       getOlsHrdParametersAddr() { return &m_olsHrdParams[0]; }

  const OlsHrdParams& getOlsHrdParameters() const { return m_olsHrdParams[0]; }

  void                           setBufferingPeriodSEI(const vvdecSEIBufferingPeriod* bp)  { m_bufferingPeriodSEI = *bp; m_bufferingPeriodInitialized = true; }

  const vvdecSEIBufferingPeriod* getBufferingPeriodSEI() const                        { return m_bufferingPeriodInitialized ? &m_bufferingPeriodSEI : nullptr; }

  void                           setPictureTimingSEI(const vvdecSEIPictureTiming* pt)  { m_pictureTimingSEI = *pt; m_pictureTimingAvailable = true; }

  const vvdecSEIPictureTiming*   getPictureTimingSEI() const                      { return m_pictureTimingAvailable ? &m_pictureTimingSEI : nullptr; }

protected:

  GeneralHrdParams             m_generalHrdParams;

  OlsHrdParams                 m_olsHrdParams[MAX_TLAYER];

  bool                         m_bufferingPeriodInitialized = false;

  vvdecSEIBufferingPeriod      m_bufferingPeriodSEI;

  bool                         m_pictureTimingAvailable     = false;

  vvdecSEIPictureTiming        m_pictureTimingSEI;

};

class TimingInfo

{

  bool     m_timingInfoPresentFlag       = false;

  uint32_t m_numUnitsInTick              = 1001;

  uint32_t m_timeScale                   = 60000;

  bool     m_pocProportionalToTimingFlag = false;

  int      m_numTicksPocDiffOneMinus1    = 0;

public:

  void     setTimingInfoPresentFlag( bool flag )   { m_timingInfoPresentFlag = flag;       }

  bool     getTimingInfoPresentFlag( ) const       { return m_timingInfoPresentFlag;       }

  void     setNumUnitsInTick( uint32_t value )     { m_numUnitsInTick = value;             }

  uint32_t getNumUnitsInTick( ) const              { return m_numUnitsInTick;              }

  void     setTimeScale( uint32_t value )          { m_timeScale = value;                  }

  uint32_t getTimeScale( ) const                   { return m_timeScale;                   }

  void     setPocProportionalToTimingFlag(bool x)  { m_pocProportionalToTimingFlag = x;    }

  bool     getPocProportionalToTimingFlag( ) const { return m_pocProportionalToTimingFlag; }

  void     setNumTicksPocDiffOneMinus1(int x)      { m_numTicksPocDiffOneMinus1 = x;       }

  int      getNumTicksPocDiffOneMinus1( ) const    { return m_numTicksPocDiffOneMinus1;    }

};

struct ChromaQpOffset

{

  int CbOffset        = 0;

  int CrOffset        = 0;

  int JointCbCrOffset = 0;

  int  get( ComponentID compID ) const { return ( compID == COMPONENT_Y ) ? 0 : ( compID == COMPONENT_Cb ? CbOffset : compID == COMPONENT_Cr ? CrOffset : JointCbCrOffset ); }

  void set( ComponentID compID, int val )

  {

    if( compID == COMPONENT_Cb )

    {

      CbOffset = val;

    }

    else if( compID == COMPONENT_Cr )

    {

      CrOffset = val;

    }

    else if( compID == JOINT_CbCr )

    {

      JointCbCrOffset = val;

    }

    else

    {

      THROW_RECOVERABLE( "Invalid chroma QP offset" );

    }

  }

};

struct ChromaQpMappingTableParams {

  int              m_qpBdOffset                   = 12;

  bool             m_sameCQPTableForAllChromaFlag = true;

  int              m_numQpTables                  = 1;

  int              m_qpTableStartMinus26   [MAX_NUM_CQP_MAPPING_TABLES] = { 0 };

  int              m_numPtsInCQPTableMinus1[MAX_NUM_CQP_MAPPING_TABLES] = { 0 };

  std::vector<int> m_deltaQpInValMinus1    [MAX_NUM_CQP_MAPPING_TABLES];

  std::vector<int> m_deltaQpOutVal         [MAX_NUM_CQP_MAPPING_TABLES];

  ChromaQpMappingTableParams()

  {

    m_deltaQpInValMinus1[0].resize( 1, 0 );

    m_deltaQpOutVal     [0].resize( 1, 0 );

  }

  ~ChromaQpMappingTableParams() = default;

  CLASS_COPY_MOVE_DEFAULT( ChromaQpMappingTableParams )

  void      setSameCQPTableForAllChromaFlag(bool b)                             { m_sameCQPTableForAllChromaFlag = b; }

  bool      getSameCQPTableForAllChromaFlag()                             const { return m_sameCQPTableForAllChromaFlag; }

  void      setNumQpTables(int n)                                               { m_numQpTables = n; }

  int       getNumQpTables()                                              const { return m_numQpTables; }

  void      setQpTableStartMinus26(int tableIdx, int n)                         { m_qpTableStartMinus26[tableIdx] = n; }

  int       getQpTableStartMinus26(int tableIdx)                          const { return m_qpTableStartMinus26[tableIdx]; }

  void      setNumPtsInCQPTableMinus1(int tableIdx, int n)                      { m_numPtsInCQPTableMinus1[tableIdx] = n; }

  int       getNumPtsInCQPTableMinus1(int tableIdx)                       const { return m_numPtsInCQPTableMinus1[tableIdx]; }

  void      setDeltaQpInValMinus1(int tableIdx, std::vector<int> &inVals)       { m_deltaQpInValMinus1[tableIdx] = inVals; }

  int       getDeltaQpInValMinus1(int tableIdx, int idx)                  const { return m_deltaQpInValMinus1[tableIdx][idx]; }

  void      setDeltaQpOutVal(int tableIdx, std::vector<int> &outVals)           { m_deltaQpOutVal[tableIdx] = outVals; }

  int       getDeltaQpOutVal(int tableIdx, int idx)                       const { return m_deltaQpOutVal[tableIdx][idx]; }

};

struct ChromaQpMappingTable : ChromaQpMappingTableParams

{

  ChromaQpMappingTable()  = default;

  ~ChromaQpMappingTable() = default;

  CLASS_COPY_MOVE_DEFAULT( ChromaQpMappingTable )

  explicit ChromaQpMappingTable( const ChromaQpMappingTableParams& params ) : ChromaQpMappingTableParams( params ) {}

  // ChromaQpMappingTable& operator=( const ChromaQpMappingTableParams& params ) { *this = ChromaQpMappingTable( params ); return *this; }

  std::vector<int> m_chromaQpMappingTables[MAX_NUM_CQP_MAPPING_TABLES];

  int       getMappedChromaQpValue(ComponentID compID, const int qpVal)  const { return m_chromaQpMappingTables[m_sameCQPTableForAllChromaFlag ? 0 : (int)compID - 1].at(qpVal + m_qpBdOffset); }

  void      deriveChromaQPMappingTables();

};

class SliceMap

{

private:

  uint32_t               m_sliceID         = 0;               //!< slice identifier (slice index for rectangular slices, slice address for raser-scan slices)

  uint32_t               m_numCtuInSlice   = 0;               //!< number of CTUs in the slice

  std::vector<uint32_t>  m_ctuAddrInSlice;                    //!< raster-scan addresses of all the CTUs in the slice

public:

  SliceMap();

  ~SliceMap();

  void                         setSliceID( uint32_t u )           { m_sliceID = u;            }

  uint32_t                     getSliceID() const                 { return m_sliceID;         }

  uint32_t                     getNumCtuInSlice() const           { return m_numCtuInSlice;   }

  const std::vector<uint32_t>& getCtuAddrList() const             { return m_ctuAddrInSlice;  }

  uint32_t                     getCtuAddrInSlice( int idx ) const { CHECK(idx >= m_ctuAddrInSlice.size(), "CTU index exceeds number of CTUs in slice."); return m_ctuAddrInSlice[idx]; }

  void  resetSliceMap()

  {

    m_sliceID         = 0;

    m_numCtuInSlice   = 0;

    m_ctuAddrInSlice.clear();

  }

  void  addCtusToSlice( uint32_t startX, uint32_t stopX, uint32_t startY, uint32_t stopY, uint32_t picWidthInCtbsY )

  {

    CHECK( startX >= stopX || startY >= stopY, "Invalid slice definition");

    m_ctuAddrInSlice.reserve( m_ctuAddrInSlice.size() + ( stopY - startY ) * ( stopX - startX ) );

    for( uint32_t ctbY = startY; ctbY < stopY; ctbY++ )

    {

      for( uint32_t ctbX = startX; ctbX < stopX; ctbX++ )

      {

        m_ctuAddrInSlice.push_back( ctbY * picWidthInCtbsY + ctbX );

        m_numCtuInSlice++;

      }

    }

  }

};

class RectSlice

{

private:

  uint32_t         m_tileIdx            = 0;                //!< tile index corresponding to the first CTU in the slice

  uint32_t         m_sliceWidthInTiles  = 0;                //!< slice width in units of tiles

  uint32_t         m_sliceHeightInTiles = 0;                //!< slice height in units of tiles

  uint32_t         m_numSlicesInTile    = 0;                //!< number of slices in current tile for the special case of multiple slices inside a single tile

  uint32_t         m_sliceHeightInCtu   = 0;                //!< slice height in units of CTUs for the special case of multiple slices inside a single tile

public:

  RectSlice() = default;

  ~RectSlice() = default;

  void             setSliceWidthInTiles( uint32_t u )   { m_sliceWidthInTiles = u;      }

  uint32_t         getSliceWidthInTiles( ) const        { return  m_sliceWidthInTiles;  }

  void             setSliceHeightInTiles( uint32_t u )  { m_sliceHeightInTiles = u;     }

  uint32_t         getSliceHeightInTiles( ) const       { return  m_sliceHeightInTiles; }

  void             setNumSlicesInTile( uint32_t u )     { m_numSlicesInTile = u;        }

  uint32_t         getNumSlicesInTile( ) const          { return  m_numSlicesInTile;    }

  void             setSliceHeightInCtu( uint32_t u )    { m_sliceHeightInCtu = u;       }

  uint32_t         getSliceHeightInCtu( ) const         { return  m_sliceHeightInCtu;   }

  void             setTileIdx( uint32_t u )             { m_tileIdx = u;                }

  uint32_t         getTileIdx( ) const                  { return  m_tileIdx;            }

};

class SubPic

{

private:

  uint32_t         m_subPicID                          = 0;      //!< ID of subpicture

  uint32_t         m_subPicIdx                         = 0;      //!< Index of subpicture

  uint32_t         m_numCTUsInSubPic                   = 0;      //!< number of CTUs contained in this sub-picture

  uint32_t         m_subPicCtuTopLeftX                 = 0;      //!< horizontal position of top left CTU of the subpicture in unit of CTU

  uint32_t         m_subPicCtuTopLeftY                 = 0;      //!< vertical position of top left CTU of the subpicture in unit of CTU

  uint32_t         m_subPicWidth                       = 0;      //!< the width of subpicture in units of CTU

  uint32_t         m_subPicHeight                      = 0;      //!< the height of subpicture in units of CTU

  uint32_t         m_subPicWidthInLumaSample           = 0;      //!< the width of subpicture in units of luma sample

  uint32_t         m_subPicHeightInLumaSample          = 0;      //!< the height of subpicture in units of luma sample

  uint32_t         m_firstCtuInSubPic                  = 0;      //!< the raster scan index of the first CTU in a subpicture

  uint32_t         m_lastCtuInSubPic                   = 0;      //!< the raster scan index of the last CTU in a subpicture

  uint32_t         m_subPicLeft                        = 0;      //!< the position of left boundary

  uint32_t         m_subPicRight                       = 0;      //!< the position of right boundary

  uint32_t         m_subPicTop                         = 0;      //!< the position of top boundary

  uint32_t         m_subPicBottom                      = 0;      //!< the position of bottom boundary

  std::vector<uint32_t> m_ctuAddrInSubPic;                       //!< raster scan addresses of all the CTUs in the slice

  bool             m_treatedAsPicFlag                  = false;  //!< whether the subpicture is treated as a picture in the decoding process excluding in-loop filtering operations

  bool             m_loopFilterAcrossSubPicEnabledFlag = false;  //!< whether in-loop filtering operations may be performed across the boundaries of the subpicture

  uint32_t         m_numSlicesInSubPic                 = 0;      //!< Number of slices contained in this subpicture

public:

  SubPic() = default;

  ~SubPic() = default;

  void             setSubPicID          (uint32_t u)       {         m_subPicID = u;              }

  uint32_t         getSubPicID          ()           const { return  m_subPicID;                  }

  void             setSubPicIdx         (uint32_t u)       {         m_subPicIdx = u;             }

  uint32_t         getSubPicIdx         ()           const { return  m_subPicIdx;                 }

  void             setNumCTUsInSubPic   (uint32_t u)       {         m_numCTUsInSubPic = u;       }

  uint32_t         getNumCTUsInSubPic   ()           const { return  m_numCTUsInSubPic;           }

  void             setSubPicCtuTopLeftX (uint32_t u)       {         m_subPicCtuTopLeftX = u;     }

  uint32_t         getSubPicCtuTopLeftX ()           const { return  m_subPicCtuTopLeftX;         }

  void             setSubPicCtuTopLeftY (uint32_t u)       {         m_subPicCtuTopLeftY = u;     }

  uint32_t         getSubPicCtuTopLeftY ()           const { return  m_subPicCtuTopLeftY;         }

  void             setSubPicWidthInCTUs (uint32_t u)       {         m_subPicWidth = u;           }

  uint32_t         getSubPicWidthInCTUs ()           const { return  m_subPicWidth;               }

  void             setSubPicHeightInCTUs(uint32_t u)       {         m_subPicHeight = u;          }

  uint32_t         getSubPicHeightInCTUs()           const { return  m_subPicHeight;              }

  void             setFirstCTUInSubPic  (uint32_t u)       {         m_firstCtuInSubPic = u;      }

  uint32_t         getFirstCTUInSubPic  ()           const { return  m_firstCtuInSubPic;          }

  void             setLastCTUInSubPic   (uint32_t u)       {         m_lastCtuInSubPic = u;       }

  uint32_t         getLastCTUInSubPic   ()           const { return  m_lastCtuInSubPic;           }

  void             setSubPicLeft        (uint32_t u)       {         m_subPicLeft = u;            }

  uint32_t         getSubPicLeft        ()           const { return  m_subPicLeft;                }

  void             setSubPicRight       (uint32_t u)       {         m_subPicRight = u;           }

  uint32_t         getSubPicRight       ()           const { return  m_subPicRight;               }

  void             setSubPicTop         (uint32_t u)       {         m_subPicTop = u;             }

  uint32_t         getSubPicTop         ()           const { return  m_subPicTop;                 }

  void             setSubPicBottom      (uint32_t u)       {         m_subPicBottom = u;          }

  uint32_t         getSubPicBottom      ()           const { return  m_subPicBottom;              }

  void             setSubPicWidthInLumaSample (uint32_t u) {         m_subPicWidthInLumaSample = u;   }

  uint32_t         getSubPicWidthInLumaSample()      const { return  m_subPicWidthInLumaSample;       }

  void             setSubPicHeightInLumaSample(uint32_t u) {         m_subPicHeightInLumaSample = u;  }

  uint32_t         getSubPicHeightInLumaSample()     const { return  m_subPicHeightInLumaSample;      }

  Area             getArea()                         const { return Area( m_subPicLeft, m_subPicTop, m_subPicWidth,             m_subPicHeight );             }

  Area             getLumaArea()                     const { return Area( m_subPicLeft, m_subPicTop, m_subPicWidthInLumaSample, m_subPicHeightInLumaSample ); }

  const std::vector<uint32_t>& getCtuAddrList  ()    const { return  m_ctuAddrInSubPic;           }

  void                         clearCTUAddrList()          { m_ctuAddrInSubPic.clear();           }

  void                         addCTUsToSubPic( const std::vector<uint32_t>& ctuAddrInSlice )

  {

    const size_t oldSize = m_ctuAddrInSubPic.size();

    m_ctuAddrInSubPic.resize( m_ctuAddrInSubPic.size() + ctuAddrInSlice.size() );

    std::copy( ctuAddrInSlice.cbegin(), ctuAddrInSlice.cend(), m_ctuAddrInSubPic.begin() + oldSize );

  }

  void                         addAllCtusInPicToSubPic( uint32_t startX, uint32_t stopX, uint32_t startY, uint32_t stopY, uint32_t picWidthInCtbsY )

  {

    CHECK(startX >= stopX || startY >= stopY, "Invalid slice definition");

    m_ctuAddrInSubPic.reserve( m_ctuAddrInSubPic.size() + ( stopY - startY ) * ( stopX - startX ) );

    for( uint32_t ctbY = startY; ctbY < stopY; ctbY++ )

    {

      for( uint32_t ctbX = startX; ctbX < stopX; ctbX++ )

      {

        m_ctuAddrInSubPic.push_back( ctbY * picWidthInCtbsY + ctbX );

      }

    }

  }

  bool             isContainingPos(const Position& pos) const

  {

    return pos.x >= m_subPicLeft && pos.x <= m_subPicRight && pos.y >= m_subPicTop  && pos.y <= m_subPicBottom;

  }

  void             setTreatedAsPicFlag                 (bool u)  {         m_treatedAsPicFlag = u;   }

  bool             getTreatedAsPicFlag                 ()  const { return  m_treatedAsPicFlag;       }

  void             setloopFilterAcrossSubPicEnabledFlag(bool u)  {         m_loopFilterAcrossSubPicEnabledFlag = u; }

  bool             getloopFilterAcrossSubPicEnabledFlag()  const { return  m_loopFilterAcrossSubPicEnabledFlag;     }

  bool             isFirstCTUinSubPic(uint32_t ctuAddr)    { return  ctuAddr == m_firstCtuInSubPic;  }

  bool             isLastCTUinSubPic(uint32_t ctuAddr)     { return  ctuAddr == m_lastCtuInSubPic;   }

  void             setNumSlicesInSubPic( uint32_t val )    { m_numSlicesInSubPic = val; }

  uint32_t         getNumSlicesInSubPic() const            { return m_numSlicesInSubPic; }

  bool             containsCtu(const Position& pos) const

  {

    return pos.x >= m_subPicCtuTopLeftX && pos.x < m_subPicCtuTopLeftX + m_subPicWidth &&

           pos.y >= m_subPicCtuTopLeftY && pos.y < m_subPicCtuTopLeftY + m_subPicHeight;

  }

};

class VPS : public BasePS<VPS>

{

private:

  int                   m_VPSId            = 0;

  uint32_t              m_uiMaxLayers      = 1;

  uint32_t                      m_vpsMaxSubLayers                                       = 1;

  uint32_t                      m_vpsLayerId[MAX_VPS_LAYERS]                            = { 0 };

  bool                          m_vpsAllLayersSameNumSubLayersFlag                      = true;

  bool                          m_vpsAllIndependentLayersFlag                           = true;

  uint32_t                      m_vpsCfgPredDirection[MAX_VPS_SUBLAYERS]                = { 0 };

  bool                          m_vpsIndependentLayerFlag[MAX_VPS_LAYERS]               = { 0 };

  bool                          m_vpsDirectRefLayerFlag[MAX_VPS_LAYERS][MAX_VPS_LAYERS] = { { 0 } };

  uint32_t                      m_vpsMaxTidIlRefPicsPlus1[MAX_VPS_LAYERS]               = { 0 };

  bool                          m_vpsEachLayerIsAnOlsFlag                               = true;

  uint32_t                      m_vpsOlsModeIdc                                         = 0;

  uint32_t                      m_vpsNumOutputLayerSets                                 = 0;

  bool                          m_vpsOlsOutputLayerFlag[MAX_NUM_OLSS][MAX_VPS_LAYERS]   = { { 0 } };

  uint32_t                      m_directRefLayerIdx[MAX_VPS_LAYERS][MAX_VPS_LAYERS]     = { { 0 } };

  uint32_t                      m_generalLayerIdx[MAX_VPS_LAYERS]                       = { 0 };

  uint32_t                      m_vpsNumPtls                                            = 1;

  bool                          m_ptPresentFlag[MAX_NUM_OLSS]                           = { 0 };

  uint32_t                      m_ptlMaxTemporalId[MAX_NUM_OLSS]                        = { 0 };

  std::vector<ProfileTierLevel> m_vpsProfileTierLevel;

  uint32_t                      m_olsPtlIdx[MAX_NUM_OLSS]                               = { 0 };

  uint32_t                      m_interLayerRefIdx[MAX_VPS_LAYERS][MAX_VPS_LAYERS]      = { { 0 } };

  bool                          m_vpsExtensionFlag                                      = false;

  bool                          m_vpsGeneralHrdParamsPresentFlag                        = 0;

  bool                          m_vpsSublayerCpbParamsPresentFlag                       = false;

  uint32_t                      m_numOlsHrdParamsMinus1                                 = 0;

  uint32_t                      m_hrdMaxTid[MAX_NUM_OLSS]                               = { 0 };

  uint32_t                      m_olsHrdIdx[MAX_NUM_OLSS]                               = { 0 };

  GeneralHrdParams              m_generalHrdParams;

  std::vector<int>              m_multiLayerOlsIdxToOlsIdx; // mapping from multi-layer OLS index to OLS index. Initialized in deriveOutputLayerSets()

                                                            // m_multiLayerOlsIdxToOlsIdx[n] is the OLSidx of the n-th multi-layer OLS.

  std::vector<Size>             m_olsDpbPicSize;

  std::vector<int>              m_olsDpbParamsIdx;

  std::vector<std::vector<int>> m_outputLayerIdInOls;

public:

  std::vector<std::vector<OlsHrdParams>> m_olsHrdParams;

  int                                    m_totalNumOLSs                   = 0;

  int                                    m_numMultiLayeredOlss            = 0;

  uint32_t                               m_multiLayerOlsIdx[MAX_NUM_OLSS] = { 0 };

  int                                    m_numDpbParams                   = 0;

  std::vector<DpbParameters>             m_dpbParameters;

  bool                                   m_sublayerDpbParamsPresentFlag   = false;

  std::vector<int>                       m_dpbMaxTemporalId;

  std::vector<int>                       m_targetOutputLayerIdSet;                  ///< set of LayerIds to be outputted

  std::vector<int>                       m_targetLayerIdSet;                        ///< set of LayerIds to be included in the sub-bitstream extraction process.

  int                                    m_iTargetLayer                   = -1;

  std::vector<int>                       m_numOutputLayersInOls;

  std::vector<int>                       m_numLayersInOls;

  std::vector<std::vector<int>>          m_layerIdInOls;

  std::vector<int>                       m_olsDpbChromaFormatIdc;

  std::vector<int>                       m_olsDpbBitDepthMinus8;

public:

  VPS()  = default;

  ~VPS() = default;

  int               getVPSId() const                                     { return m_VPSId;                     }

  void              setVPSId(int i)                                      { m_VPSId = i;                        }

  uint32_t          getMaxLayers() const                                 { return m_uiMaxLayers;               }

  void              setMaxLayers(uint32_t l)                             { m_uiMaxLayers = l;                  }

  bool              getVPSExtensionFlag() const                          { return m_vpsExtensionFlag;          }

  void              setVPSExtensionFlag(bool t)                          { m_vpsExtensionFlag = t;             }

  uint32_t          getPredDirection(uint32_t tmplayer) const            { return m_vpsCfgPredDirection[tmplayer]; }

  void              setPredDirection(uint32_t tmplayer, uint32_t t)      { m_vpsCfgPredDirection[tmplayer] = t; }

  uint32_t          getMaxSubLayers() const                              { return m_vpsMaxSubLayers;           }

  void              setMaxSubLayers(uint32_t value)                      { m_vpsMaxSubLayers = value;          }

  bool              getAllLayersSameNumSublayersFlag() const             { return m_vpsAllLayersSameNumSubLayersFlag; }