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

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     HLSyntaxReader.cpp

 *  \brief    Reader for high level syntax

 */

//! \ingroup DecoderLib

//! \{

#include "HLSyntaxReader.h"

#include "CommonLib/CommonDef.h"

#include "CommonLib/Rom.h"

#include "CommonLib/dtrace_next.h"

#include "CommonLib/AdaptiveLoopFilter.h"

#include "ParameterSetManager.h"

#define CHECK_CONSTRAINT( cond, msg ) CHECK( cond, msg )

namespace vvdec

{

void AUDReader::parseAccessUnitDelimiter( InputBitstream* bs, uint32_t &picType )

{

  setBitstream( bs );

#if ENABLE_TRACING

  xTraceAccessUnitDelimiter();

#endif

  X_READ_FLAG( aud_irap_or_gdr_au_flag );

  (void)aud_irap_or_gdr_au_flag;

  X_READ_CODE_NO_RANGE( aud_pic_type, 3 );

  picType = aud_pic_type;

  xReadRbspTrailingBits();

}

void FDReader::parseFillerData( InputBitstream* bs, uint32_t &fdSize )

{

  setBitstream( bs );

#if ENABLE_TRACING

  DTRACE( g_trace_ctx, D_HEADER, "=========== Filler Data ===========\n" );

#endif

  fdSize = 0;

  while( m_pcBitstream->getNumBitsLeft() > 8 )

  {

    X_READ_CODE_NO_RANGE( fd_ff_byte, 8 );

    CHECK_WARN( fd_ff_byte != 0xff, "Invalid fillter data not '0xff'" );

    fdSize++;

  }

  xReadRbspTrailingBits();

}

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

// Public member functions

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

void HLSyntaxReader::copyRefPicList( const SPS* sps, const ReferencePictureList* source_rpl, ReferencePictureList* dest_rp )

{

  memcpy( dest_rp, source_rpl, sizeof( ReferencePictureList ) );

  if( !sps->getLongTermRefsPresent() )

  {

    dest_rp->setNumberOfLongtermPictures( 0 );

  }

}

void HLSyntaxReader::parseRefPicList( ReferencePictureList* rpl, int rplIdx, const SPS* sps )

{

  X_READ_UVLC_idx( num_ref_entries, "[ listIdx ][ rplsIdx ]", 0, MAX_NUM_REF_PICS );

  // The value of num_ref_entries[ listIdx ][ rplsIdx ] shall be in the range of 0 to MaxDpbSize + 13, inclusive,

  //  where MaxDpbSize is as specified in clause A.4.2.

  if( sps->getLongTermRefsPresent() && num_ref_entries > 0 && rplIdx != -1 )   // rplsIdx == -1 means it's called from parsePicOrSliceHeader

  {

    X_READ_FLAG_idx( ltrp_in_header_flag, "[ listIdx ][ rplsIdx ]" );

    rpl->setLtrpInSliceHeaderFlag( ltrp_in_header_flag );

  }

  else if( sps->getLongTermRefsPresent() )

  {

    // When sps_long_term_ref_pics_flag is equal to 1 and rplsIdx is equal to sps_num_ref_pic_lists[ listIdx ],

    //  the value of ltrp_in_header_flag[ listIdx ][ rplsIdx ] is inferred to be equal to 1.

    rpl->setLtrpInSliceHeaderFlag( 1 );

  }

  uint32_t numStrp = 0;

  uint32_t numLtrp = 0;

  uint32_t numIlrp = 0;

  rpl->setInterLayerPresentFlag( sps->getInterLayerPresentFlag() );

  int prevDelta = 0;

  for( unsigned ii = 0; ii < num_ref_entries; ii++ )

  {

    if( rpl->getInterLayerPresentFlag() )

    {

      X_READ_FLAG_idx( inter_layer_ref_pic_flag, "[ listIdx ][ rplsIdx ][ i ]" );

      if( inter_layer_ref_pic_flag )

      {

        X_READ_UVLC_idx( ilrp_idx, "[ listIdx ][ rplsIdx ][ i ]", 0, MAX_VPS_LAYERS );

        // The value of ilrp_idx[ listIdx ][ rplsIdx ][ i ] shall be in the range of 0 to NumDirectRefLayers[ GeneralLayerIdx[ nuh_layer_id ] ] − 1, inclusive.

        rpl->setRefPicIdentifier( ii, 0, true, true, ilrp_idx );

        numIlrp++;

        continue;

      }

    }

    // if( !inter_layer_ref_pic_flag )  // implicit due to previous `continue`

    {

      bool isLongTerm = false;

      if( sps->getLongTermRefsPresent() )

      {

        X_READ_FLAG_idx( st_ref_pic_flag, "[ listIdx ][ rplsIdx ][ i ]" );

        isLongTerm = !st_ref_pic_flag;

      }

      if( !isLongTerm )

      {

        X_READ_UVLC_idx( abs_delta_poc_st, "[ listIdx ][ rplsIdx ][ i ]", 0, ( 1 << 15 ) - 1 );

        int deltaPocSt = abs_delta_poc_st;

        if( ( !sps->getUseWP() && !sps->getUseWPBiPred() ) || ii == 0 )

        {

          deltaPocSt++;

        }

        if( deltaPocSt > 0 )

        {

          X_READ_FLAG_idx( strp_entry_sign_flag, "[ listIdx ][ rplsIdx ][ i ]" );

          if( strp_entry_sign_flag )

          {

            deltaPocSt = -deltaPocSt;

          }

        }

        deltaPocSt += prevDelta;

        prevDelta = deltaPocSt;

        rpl->setRefPicIdentifier( ii, deltaPocSt, false, false, 0 );

        numStrp++;

      }

      else

      {

        if( !rpl->getLtrpInSliceHeaderFlag() )

        {

          X_READ_CODE_NO_RANGE_idx( rpls_poc_lsb_lt, "[ listIdx ][ rplsIdx ][ j++ ]", sps->getBitsForPOC() );

          rpl->setRefPicIdentifier( ii, rpls_poc_lsb_lt, true, false, 0 );

        }

        else

        {

          rpl->setRefPicIdentifier( ii, 0, true, false, 0 );

        }

        numLtrp++;

      }

    }

  }

  rpl->setNumberOfShorttermPictures( numStrp );

  rpl->setNumberOfLongtermPictures( numLtrp );

  rpl->setNumberOfInterLayerPictures( numIlrp );

}

void HLSyntaxReader::parsePPS( PPS* pcPPS, const ParameterSetManager* parameterSetManager )

{

#if ENABLE_TRACING

  xTracePPSHeader();

#endif

  X_READ_CODE_NO_RANGE( pps_pic_parameter_set_id, 6 );

  pcPPS->setPPSId( pps_pic_parameter_set_id );

  X_READ_CODE( pps_seq_parameter_set_id, 4, 0, 15 );

  const SPS* sps = parameterSetManager->getSPS( pps_seq_parameter_set_id );

  CHECK( !sps, "SPS with id " << pps_seq_parameter_set_id << " missing." );

  pcPPS->setSPSId( pps_seq_parameter_set_id );

  const int SubWidthC  = 1 << getChannelTypeScaleX( CHANNEL_TYPE_CHROMA, sps->getChromaFormatIdc() );

  const int SubHeightC = 1 << getChannelTypeScaleY( CHANNEL_TYPE_CHROMA, sps->getChromaFormatIdc() );

  X_READ_FLAG( pps_mixed_nalu_types_in_pic_flag );

  pcPPS->setMixedNaluTypesInPicFlag( pps_mixed_nalu_types_in_pic_flag == 1 );

  const int CtbSizeY   = sps->getCTUSize();

  const int MinCbSizeY = 1 << sps->getLog2MinCodingBlockSize();

  X_READ_UVLC( pps_pic_width_in_luma_samples, 1, sps->getMaxPicWidthInLumaSamples() );

  CHECK( pps_pic_width_in_luma_samples & std::max( 8 - 1, MinCbSizeY - 1 ), "pps_pic_width_in_luma_samples not a multiple of 8 or MinCbSizeY" );

  CHECK( !sps->getResChangeInClvsEnabledFlag() && pps_pic_width_in_luma_samples != sps->getMaxPicWidthInLumaSamples(),

         "When sps_res_change_in_clvs_allowed_flag equal to 0, the value of pps_pic_width_in_luma_samples shall be equal"

         " to sps_pic_width_max_in_luma_samples." )

  CHECK( sps->getUseWrapAround() && CtbSizeY / MinCbSizeY + 1 > pps_pic_width_in_luma_samples / MinCbSizeY - 1,

         "When sps_ref_wraparound_enabled_flag is equal to 1, the value of ( CtbSizeY / MinCbSizeY + 1 ) shall be less than or"

         " equal to the value of ( pps_pic_width_in_luma_samples / MinCbSizeY − 1 )." );

  pcPPS->setPicWidthInLumaSamples( pps_pic_width_in_luma_samples );

  X_READ_UVLC( pps_pic_height_in_luma_samples, 1, sps->getMaxPicHeightInLumaSamples() );

  CHECK( pps_pic_height_in_luma_samples & std::max( 8 - 1, MinCbSizeY - 1 ), "pps_pic_height_in_luma_samples not a multiple of 8 or MinCbSizeY" );

  CHECK( !sps->getResChangeInClvsEnabledFlag() && pps_pic_height_in_luma_samples != sps->getMaxPicHeightInLumaSamples(),

         "When sps_res_change_in_clvs_allowed_flag equal to 0, the value of pps_pic_height_in_luma_samples shall be equal"

         " to sps_pic_height_max_in_luma_samples." )

  pcPPS->setPicHeightInLumaSamples( pps_pic_height_in_luma_samples );

  const unsigned PicWidthInCtbsY     = ( pps_pic_width_in_luma_samples + CtbSizeY - 1 ) / CtbSizeY;      (void) PicWidthInCtbsY;

  const unsigned PicHeightInCtbsY    = ( pps_pic_height_in_luma_samples + CtbSizeY - 1 ) / CtbSizeY;     (void) PicHeightInCtbsY;

  const unsigned PicSizeInCtbsY      = PicWidthInCtbsY * PicHeightInCtbsY;                               (void) PicSizeInCtbsY;

  const unsigned PicWidthInMinCbsY   = pps_pic_width_in_luma_samples / MinCbSizeY;                       (void) PicWidthInMinCbsY;

  const unsigned PicHeightInMinCbsY  = pps_pic_height_in_luma_samples / MinCbSizeY;                      (void) PicHeightInMinCbsY;

  const unsigned PicSizeInMinCbsY    = PicWidthInMinCbsY * PicHeightInMinCbsY;                           (void) PicSizeInMinCbsY;

  const unsigned PicSizeInSamplesY   = pps_pic_width_in_luma_samples * pps_pic_height_in_luma_samples;   (void) PicSizeInSamplesY;

  const unsigned PicWidthInSamplesC  = pps_pic_width_in_luma_samples / SubWidthC;                        (void) PicWidthInSamplesC;

  const unsigned PicHeightInSamplesC = pps_pic_height_in_luma_samples / SubHeightC;                      (void) PicHeightInSamplesC;

  X_READ_FLAG( pps_conformance_window_flag );

  CHECK( pps_conformance_window_flag != 0 && pcPPS->getPicWidthInLumaSamples() == sps->getMaxPicWidthInLumaSamples()

           && pcPPS->getPicHeightInLumaSamples() == sps->getMaxPicHeightInLumaSamples(),

         "pps_conformance_window_flag shall be equal to 0" )

  pcPPS->setConformanceWindowPresentFlag( pps_conformance_window_flag );

  if( pps_conformance_window_flag != 0 )

  {

    X_READ_UVLC_NO_RANGE( pps_conf_win_left_offset );

    X_READ_UVLC_NO_RANGE( pps_conf_win_right_offset );

    X_READ_UVLC_NO_RANGE( pps_conf_win_top_offset );

    X_READ_UVLC_NO_RANGE( pps_conf_win_bottom_offset );

    CHECK( SubWidthC * ( pps_conf_win_left_offset + pps_conf_win_right_offset ) >= pps_pic_width_in_luma_samples,

           "pps_conf_win_left_offset + pps_conf_win_right_offset too large" );

    CHECK( SubHeightC * ( pps_conf_win_top_offset + pps_conf_win_bottom_offset ) >= pps_pic_height_in_luma_samples,

           "pps_conf_win_top_offset + pps_conf_win_bottom_offset too large" );

    Window& conf = pcPPS->getConformanceWindow();

    conf.setWindowLeftOffset( pps_conf_win_left_offset );

    conf.setWindowRightOffset( pps_conf_win_right_offset );

    conf.setWindowTopOffset( pps_conf_win_top_offset );

    conf.setWindowBottomOffset( pps_conf_win_bottom_offset );

  }

  X_READ_FLAG_CHECK( pps_scaling_window_explicit_signalling_flag,

                     !sps->getRprEnabledFlag() && pps_scaling_window_explicit_signalling_flag != 0,

                     "When sps_ref_pic_resampling_enabled_flag is equal to 0, the value of pps_scaling_window_explicit_signalling_flag shall be equal to 0" );

  if( pps_scaling_window_explicit_signalling_flag != 0 )

  {

    X_READ_SVLC_NO_RANGE( pps_scaling_win_left_offset );

    X_READ_SVLC_NO_RANGE( pps_scaling_win_right_offset );

    X_READ_SVLC_NO_RANGE( pps_scaling_win_top_offset );

    X_READ_SVLC_NO_RANGE( pps_scaling_win_bottom_offset );

    CHECK( SubWidthC * pps_scaling_win_left_offset < -(int) pps_pic_width_in_luma_samples * 15

             || SubWidthC * pps_scaling_win_left_offset >= (int) pps_pic_width_in_luma_samples,

           "pps_scaling_win_left_offset (" << pps_scaling_win_left_offset << ") out of bounds" );

    CHECK( SubWidthC * pps_scaling_win_right_offset < -(int) pps_pic_width_in_luma_samples * 15

             || SubWidthC * pps_scaling_win_right_offset >= (int) pps_pic_width_in_luma_samples,

           "pps_scaling_win_right_offset (" << pps_scaling_win_right_offset << ") out of bounds" );

    CHECK( SubHeightC * pps_scaling_win_top_offset < -(int) pps_pic_height_in_luma_samples * 15

             || SubHeightC * pps_scaling_win_top_offset >= (int) pps_pic_height_in_luma_samples,

           "pps_scaling_win_top_offset (" << pps_scaling_win_top_offset << ") out of bounds" );

    CHECK( SubHeightC * pps_scaling_win_bottom_offset < -(int) pps_pic_height_in_luma_samples * 15

             || SubHeightC * pps_scaling_win_bottom_offset >= (int) pps_pic_height_in_luma_samples,

           "pps_scaling_win_bottom_offset (" << pps_scaling_win_bottom_offset << ") out of bounds" );

    CHECK( SubWidthC * ( pps_scaling_win_left_offset + pps_scaling_win_right_offset ) < -(int) pps_pic_width_in_luma_samples * 15

             || SubWidthC * ( pps_scaling_win_left_offset + pps_scaling_win_right_offset ) >= (int) pps_pic_width_in_luma_samples,

           "SubWidthC * ( pps_scaling_win_left_offset + pps_scaling_win_right_offset ) shall be greater than or equal to"

           " -pps_pic_width_in_luma_samples * 15 and less than pps_pic_width_in_luma_samples."

           " (pps_scaling_win_left_offset + pps_scaling_win_right_offset = "

             << pps_scaling_win_left_offset + pps_scaling_win_right_offset << ")" );

    CHECK( SubHeightC * ( pps_scaling_win_top_offset + pps_scaling_win_bottom_offset ) < -(int) pps_pic_height_in_luma_samples * 15

             || SubHeightC * ( pps_scaling_win_top_offset + pps_scaling_win_bottom_offset ) >= (int) pps_pic_height_in_luma_samples,

           "SubHeightC * ( pps_scaling_win_top_offset + pps_scaling_win_bottom_offset ) shall be greater than or equal to"

           " -pps_pic_height_in_luma_samples * 15 and less than pps_pic_height_in_luma_samples."

           " (pps_scaling_win_top_offset + pps_scaling_win_bottom_offset = "

             << pps_scaling_win_top_offset + pps_scaling_win_bottom_offset << ")" )

#if 0

    // these checks need to be moved to the creation of ref pic lists

    //

    const int CurrPicScalWinWidthL  = pps_pic_width_in_luma_samples - SubWidthC * ( pps_scaling_win_right_offset + pps_scaling_win_left_offset );

    const int CurrPicScalWinHeightL = pps_pic_height_in_luma_samples - SubHeightC * ( pps_scaling_win_bottom_offset + pps_scaling_win_top_offset );

    CHECK( CurrPicScalWinWidthL * 2 < refPicScalWinWidthL,

           "Requirement of bitstream conformance: CurrPicScalWinWidthL * 2 is greater than or equal to refPicScalWinWidthL." );

    CHECK( CurrPicScalWinHeightL * 2 < refPicScalWinHeightL,

           "Requirement of bitstream conformance: CurrPicScalWinHeightL * 2 is greater than or equal to refPicScalWinHeightL." );

    CHECK( CurrPicScalWinWidthL > refPicScalWinWidthL * 8,

           "Requirement of bitstream conformance: CurrPicScalWinWidthL is less than or equal to refPicScalWinWidthL * 8." );

    CHECK( CurrPicScalWinHeightL > refPicScalWinHeightL * 8,

           "Requirement of bitstream conformance: CurrPicScalWinHeightL is less than or equal to refPicScalWinHeightL * 8." );

    CHECK( CurrPicScalWinWidthL * sps->getMaxPicWidthInLumaSamples() < refPicScalWinWidthL * ( pps_pic_width_in_luma_samples - std::max( 8, MinCbSizeY ) ),

           "Requirement of bitstream conformance: CurrPicScalWinWidthL * sps_pic_width_max_in_luma_samples is greater than or equal to"

           " refPicScalWinWidthL * ( pps_pic_width_in_luma_samples - Max( 8, MinCbSizeY ) )." );

    CHECK( CurrPicScalWinHeightL * sps->getMaxPicHeightInLumaSamples() < refPicScalWinHeightL * ( pps_pic_height_in_luma_samples - std::max( 8, MinCbSizeY ) ),

           "Requirement of bitstream conformance: CurrPicScalWinHeightL * sps_pic_height_max_in_luma_samples is greater than or equal to"

           " refPicScalWinHeightL * ( pps_pic_height_in_luma_samples - Max( 8, MinCbSizeY ) )." );

#endif

    Window& scalingWindow = pcPPS->getScalingWindow();

    scalingWindow.setWindowLeftOffset( pps_scaling_win_left_offset );

    scalingWindow.setWindowRightOffset( pps_scaling_win_right_offset );

    scalingWindow.setWindowTopOffset( pps_scaling_win_top_offset );

    scalingWindow.setWindowBottomOffset( pps_scaling_win_bottom_offset );

  }

  else

  {

    pcPPS->setScalingWindow( pcPPS->getConformanceWindow() );

  }

  X_READ_FLAG( pps_output_flag_present_flag );

  pcPPS->setOutputFlagPresentFlag( pps_output_flag_present_flag );

  X_READ_FLAG_CHECK( pps_no_pic_partition_flag,

                     ( sps->getNumSubPics() > 1 || pps_mixed_nalu_types_in_pic_flag == 1 ) && pps_no_pic_partition_flag != 0,

                     "When sps_num_subpics_minus1 is greater than 0 or pps_mixed_nalu_types_in_pic_flag is equal to 1, the value of pps_no_pic_partition_flag "

                     "shall be equal to 0." );

  pcPPS->setNoPicPartitionFlag( pps_no_pic_partition_flag );

  X_READ_FLAG( pps_subpic_id_mapping_present_flag );

  CHECK( ( sps->getSubPicIdMappingExplicitlySignalledFlag() == 0 || sps->getSubPicIdMappingPresentFlag() == 1 ) && pps_subpic_id_mapping_present_flag != 0,

         "If sps_subpic_id_mapping_explicitly_signalled_flag is 0 or sps_subpic_id_mapping_present_flag is equal to 1, the value of"

         " pps_subpic_id_mapping_present_flag shall be equal to 0." );

  CHECK( ( sps->getSubPicIdMappingExplicitlySignalledFlag() == 1 && sps->getSubPicIdMappingPresentFlag() == 0 ) && pps_subpic_id_mapping_present_flag != 1,

         "Otherwise (sps_subpic_id_mapping_explicitly_signalled_flag is equal to 1 and sps_subpic_id_mapping_present_flag is equal to 0), the value of"

         " pps_subpic_id_mapping_present_flag  shall be equal to 1." );

  pcPPS->setSubPicIdMappingPresentFlag( pps_subpic_id_mapping_present_flag );

  if( pps_subpic_id_mapping_present_flag )

  {

    if( !pps_no_pic_partition_flag )

    {

      X_READ_UVLC( pps_num_subpics_minus1, 0, MAX_NUM_SUB_PICS - 1 );

      CHECK( pps_num_subpics_minus1 != sps->getNumSubPics() - 1, "pps_num_subpics_minus1 shall be equal to sps_num_subpics_minus1" );

      pcPPS->setNumSubPics( pps_num_subpics_minus1 + 1 );

    }

    else

    {

      // When pps_no_pic_partition_flag is equal to 1, the value of pps_num_subpics_minus1 is inferred to be equal to 0.

      pcPPS->setNumSubPics( 1 );

    }

    X_READ_UVLC( pps_subpic_id_len_minus1, 0, 15 );

    CHECK( pps_subpic_id_len_minus1 != sps->getSubPicIdLen() - 1, "pps_subpic_id_len_minus1 shall be equal to sps_subpic_id_len_minus1" );

    CHECK( ( 1 << ( pps_subpic_id_len_minus1 + 1 ) ) < pcPPS->getNumSubPics(), "pps_subpic_id_len too short" );

    pcPPS->setSubPicIdLen( pps_subpic_id_len_minus1 + 1 );

    for( int picIdx = 0; picIdx < pcPPS->getNumSubPics(); picIdx++ )

    {

      X_READ_CODE_NO_RANGE_idx( pps_subpic_id, "[i]", pcPPS->getSubPicIdLen() );

      pcPPS->setSubPicId( picIdx, pps_subpic_id );

    }

  }

  else

  {

    for( int picIdx = 0; picIdx < MAX_NUM_SUB_PICS; picIdx++ )

    {

      pcPPS->setSubPicId( picIdx, sps->getSubPicIdMappingExplicitlySignalledFlag() ? sps->getSubPicId( picIdx ) : picIdx );

    }

  }

  for( int i = 0; i < pcPPS->getNumSubPics(); ++i )

  {

    for( int j = 0; j < i; ++j )

    {

      CHECK( pcPPS->getSubPicId( i ) == pcPPS->getSubPicId( j ),

                         "It is a requirement of bitstream conformance that, for any two different values of i and j in the range of"

                         " 0 to sps_num_subpics_minus1, inclusive, SubpicIdVal[ i ] shall not be equal to SubpicIdVal[ j ]." )

    }

  }

  pcPPS->resetTileSliceInfo();

  if( !pps_no_pic_partition_flag )

  {

    // CTU size - required to match size in SPS

    X_READ_CODE( pps_log2_ctu_size_minus5, 2, 0,2 );

    CHECK( pps_log2_ctu_size_minus5 != getLog2( sps->getCTUSize() ) - 5, "pps_log2_ctu_size_minus5 shall be equal to sps_log2_ctu_size_minus5" );

    pcPPS->setLog2CtuSize( pps_log2_ctu_size_minus5 + 5 );

    // number of explicit tile columns/rows

    X_READ_UVLC( pps_num_exp_tile_columns_minus1, 0, PicWidthInCtbsY - 1 );

    pcPPS->setNumExpTileColumns( pps_num_exp_tile_columns_minus1 + 1 );

    X_READ_UVLC( pps_num_exp_tile_rows_minus1, 0, PicHeightInCtbsY - 1 );

    pcPPS->setNumExpTileRows( pps_num_exp_tile_rows_minus1 + 1 );

    CHECK( pcPPS->getNumExpTileColumns() > MAX_TILE_COLS, "Number of explicit tile columns exceeds valid range" );

    // tile sizes

    for( int colIdx = 0; colIdx < pcPPS->getNumExpTileColumns(); colIdx++ )

    {

      X_READ_UVLC_idx( pps_tile_column_width_minus1, "[i]", 0, PicWidthInCtbsY - 1 );

      pcPPS->addTileColumnWidth( pps_tile_column_width_minus1 + 1 );

    }

    for( int rowIdx = 0; rowIdx < pcPPS->getNumExpTileRows(); rowIdx++ )

    {

      X_READ_UVLC_idx( pps_tile_row_height_minus1, "[i]", 0, PicHeightInCtbsY - 1 );

      pcPPS->addTileRowHeight( pps_tile_row_height_minus1 + 1 );

    }

    pcPPS->initTiles();

    // rectangular slice signalling

    if( pcPPS->getNumTiles() > 1 )

    {

      X_READ_FLAG( pps_loop_filter_across_tiles_enabled_flag );

      pcPPS->setLoopFilterAcrossTilesEnabledFlag( pps_loop_filter_across_tiles_enabled_flag );

      X_READ_FLAG( pps_rect_slice_flag );

      CHECK( ( sps->getSubPicInfoPresentFlag() || pps_mixed_nalu_types_in_pic_flag ) && pps_rect_slice_flag != 1,

             "When sps_subpic_info_present_flag is equal to 1 or pps_mixed_nalu_types_in_pic_flag is equal to 1,"

             " the value of pps_rect_slice_flag shall be equal to 1." );

      pcPPS->setRectSliceFlag( pps_rect_slice_flag );

    }

    else

    {

      pcPPS->setLoopFilterAcrossTilesEnabledFlag( false );

      pcPPS->setRectSliceFlag( true );

    }

    if( pcPPS->getRectSliceFlag() )

    {

      X_READ_FLAG( pps_single_slice_per_subpic_flag );

      pcPPS->setSingleSlicePerSubPicFlag( pps_single_slice_per_subpic_flag );

    }

    if( pcPPS->getRectSliceFlag() && !pcPPS->getSingleSlicePerSubPicFlag() )

    {

      X_READ_UVLC( pps_num_slices_in_pic_minus1, 0, MAX_SLICES - 1 /*  TODO: should be MaxSlicesPerAU -1  */ );

      pcPPS->setNumSlicesInPic( pps_num_slices_in_pic_minus1 + 1 );

      if( pps_num_slices_in_pic_minus1 > 1 )

      {

        X_READ_FLAG( pps_tile_idx_delta_present_flag );

        pcPPS->setTileIdxDeltaPresentFlag( pps_tile_idx_delta_present_flag );

      }

      pcPPS->initRectSlices();

      int32_t tileIdx = 0;

      // read rectangular slice parameters

      for( int sliceIdx = 0; sliceIdx < pcPPS->getNumSlicesInPic() - 1; sliceIdx++ )

      {

        pcPPS->setSliceTileIdx( sliceIdx, tileIdx );   // this is SliceTopLeftTileIdx[ i ]

        // complete tiles within a single slice

        if( tileIdx % pcPPS->getNumTileColumns() != pcPPS->getNumTileColumns() - 1 )

        {

          X_READ_UVLC_idx( pps_slice_width_in_tiles_minus1, "[i]", 0, pcPPS->getNumTileColumns() - 1 );

          pcPPS->setSliceWidthInTiles( sliceIdx, pps_slice_width_in_tiles_minus1 + 1 );

        }

        else

        {

          pcPPS->setSliceWidthInTiles( sliceIdx, 1 );

        }

        if( tileIdx / pcPPS->getNumTileColumns() != pcPPS->getNumTileRows() - 1

            && ( pcPPS->getTileIdxDeltaPresentFlag() || tileIdx % pcPPS->getNumTileColumns() == 0 ) )

        {

          X_READ_UVLC_idx( pps_slice_height_in_tiles_minus1, "[i]", 0, pcPPS->getNumTileRows() - 1 );

          pcPPS->setSliceHeightInTiles( sliceIdx, pps_slice_height_in_tiles_minus1 + 1 );

        }

        else

        {

          if( tileIdx / pcPPS->getNumTileColumns() == pcPPS->getNumTileRows() - 1 )

          {

            pcPPS->setSliceHeightInTiles( sliceIdx, 1 );

          }

          else

          {

            pcPPS->setSliceHeightInTiles( sliceIdx, pcPPS->getSliceHeightInTiles( sliceIdx - 1 ) );

          }

        }

        // multiple slices within a single tile special case

        if( pcPPS->getSliceWidthInTiles( sliceIdx ) == 1 && pcPPS->getSliceHeightInTiles( sliceIdx ) == 1 )

        {

          if( pcPPS->getTileRowHeight( tileIdx / pcPPS->getNumTileColumns() ) > 1 )

          {

            X_READ_UVLC_idx( pps_num_exp_slices_in_tile, "[i]", 0, pcPPS->getTileRowHeight( tileIdx / pcPPS->getNumTileColumns() ) - 1 );

            if( pps_num_exp_slices_in_tile == 0 )

            {

              pcPPS->setNumSlicesInTile( sliceIdx, 1 );

              pcPPS->setSliceHeightInCtu( sliceIdx, pcPPS->getTileRowHeight( tileIdx / pcPPS->getNumTileColumns() ) );

            }

            else   // ( pps_num_exp_slices_in_tile > 0 )

            {

              uint32_t remTileRowHeight         = pcPPS->getTileRowHeight( tileIdx / pcPPS->getNumTileColumns() );

              uint32_t lastExpSliceHeightInCtus = 0;

              int j = 0;

              for( ; j < pps_num_exp_slices_in_tile; j++ )

              {

                X_READ_UVLC_idx( pps_exp_slice_height_in_ctus_minus1, "[i][j]", 0, pcPPS->getTileRowHeight( tileIdx / pcPPS->getNumTileColumns() ) - 1 );

                pcPPS->setSliceHeightInCtu( sliceIdx + j, pps_exp_slice_height_in_ctus_minus1 + 1 );

                remTileRowHeight -= ( pps_exp_slice_height_in_ctus_minus1 + 1 );

                lastExpSliceHeightInCtus = pps_exp_slice_height_in_ctus_minus1 + 1;

              }

              uint32_t uniformSliceHeight = lastExpSliceHeightInCtus;

              while( remTileRowHeight >= uniformSliceHeight )

              {

                pcPPS->setSliceHeightInCtu( sliceIdx + j, uniformSliceHeight );

                remTileRowHeight -= uniformSliceHeight;

                j++;

              }

              if( remTileRowHeight > 0 )

              {

                pcPPS->setSliceHeightInCtu( sliceIdx + j, remTileRowHeight );

                j++;

              }

              for( int k = 0; k < j; k++ )

              {

                pcPPS->setNumSlicesInTile( sliceIdx + k, j );

                pcPPS->setSliceWidthInTiles( sliceIdx + k, 1 );

                pcPPS->setSliceHeightInTiles( sliceIdx + k, 1 );

                pcPPS->setSliceTileIdx( sliceIdx + k, tileIdx );

              }

              sliceIdx += ( j - 1 );

            }    // ( pps_num_exp_slices_in_tile > 0 )

          }

          else   // ( pps->getTileRowHeight( tileIdx / pps->getNumTileColumns() ) <= 1 )

          {

            pcPPS->setNumSlicesInTile( sliceIdx, 1 );

            pcPPS->setSliceHeightInCtu( sliceIdx, pcPPS->getTileRowHeight( tileIdx / pcPPS->getNumTileColumns() ) );

          }

        }   // ( pps->getSliceWidthInTiles(sliceIdx) == 1 && pps->getSliceHeightInTiles(sliceIdx) == 1 )

        // tile index offset to start of next slice

        if( sliceIdx < pps_num_slices_in_pic_minus1 )

        {

          if( pcPPS->getTileIdxDeltaPresentFlag() )

          {

            X_READ_SVLC_idx( pps_tile_idx_delta_val, "[i]", -(int) pcPPS->getNumTiles() + 1, (int) pcPPS->getNumTiles() - 1 );

            CHECK( pps_tile_idx_delta_val == 0, "When present, the value of pps_tile_idx_delta_val[ i ] shall not be equal to 0." );

            // TODO: When pps_rect_slice_flag is equal to 1, it is a requirement of bitstrream conformance that, for any two slices, with picture-

            //       level slice indices idxA and idxB, that belong to the same picture and different subpictures, when

            //       SubpicIdxForSlice[idxA] is less than SubpicIdxForSlice[idxB], the value of idxA shall be less than idxB.

            // CHECK( pps->getRectSliceFlag() && /* TODO */ )

            tileIdx += pps_tile_idx_delta_val;

            CHECK( tileIdx < 0 || tileIdx >= (int) pcPPS->getNumTiles(), "Invalid tile_idx_delta." );

          }

          else

          {

            tileIdx += pcPPS->getSliceWidthInTiles( sliceIdx );

            if( tileIdx % pcPPS->getNumTileColumns() == 0 )

            {

              tileIdx += ( pcPPS->getSliceHeightInTiles( sliceIdx ) - 1 ) * pcPPS->getNumTileColumns();

            }

          }

        }

        // TODO: hier?

        CHECK( tileIdx < 0 || tileIdx >= (int) pcPPS->getNumTiles(), "Invalid tile_idx_delta." );

      }   // for( int i = 0; i < pps->getNumSlicesInPic()-1; i++ )

      pcPPS->setSliceTileIdx( pcPPS->getNumSlicesInPic() - 1, tileIdx );

    }   // if( pps->getRectSliceFlag() && !pps->getSingleSlicePerSubPicFlag() )

    if( !pcPPS->getRectSliceFlag() || pcPPS->getSingleSlicePerSubPicFlag() || pcPPS->getNumSlicesInPic() > 1 )

    {

      X_READ_FLAG( pps_loop_filter_across_slices_enabled_flag );

      pcPPS->setLoopFilterAcrossSlicesEnabledFlag( pps_loop_filter_across_slices_enabled_flag );

    }

    else

    {

      pcPPS->setLoopFilterAcrossSlicesEnabledFlag( false );

    }

  }

  else   // if( !pps_no_pic_partition_flag )

  {

    // When pps_no_pic_partition_flag is equal to 1, the value of pps_single_slice_per_subpic_flag is inferred to be equal to 1.

    pcPPS->setSingleSlicePerSubPicFlag( 1 );

  }

  X_READ_FLAG( pps_cabac_init_present_flag );

  pcPPS->setCabacInitPresentFlag( pps_cabac_init_present_flag );

  {

    X_READ_UVLC_idx( pps_num_ref_idx_default_active_minus1, "[0]", 0, 14 );

    pcPPS->setNumRefIdxL0DefaultActive( pps_num_ref_idx_default_active_minus1 + 1 );

  }

  {

    X_READ_UVLC_idx( pps_num_ref_idx_default_active_minus1, "[1]", 0, 14 );

    pcPPS->setNumRefIdxL1DefaultActive( pps_num_ref_idx_default_active_minus1 + 1 );

  }

  X_READ_FLAG( pps_rpl1_idx_present_flag );

  pcPPS->setRpl1IdxPresentFlag( pps_rpl1_idx_present_flag );

  X_READ_FLAG_CHECK( pps_weighted_pred_flag,

                     sps->getUseWP() == 0 && pps_weighted_pred_flag != 0,

                     "sps_weighted_pred_flag is equal to 0, the value of pps_weighted_pred_flag shall be equal to 0." );

  pcPPS->setUseWP( pps_weighted_pred_flag );

  X_READ_FLAG_CHECK( pps_weighted_bipred_flag,

                     sps->getUseWPBiPred() == 0 && pps_weighted_bipred_flag != 0,

                     "When sps_weighted_bipred_flag is equal to 0, the value of pps_weighted_bipred_flag shall be equal to 0." );

  pcPPS->setWPBiPred( pps_weighted_bipred_flag );

  X_READ_FLAG_CHECK( pps_ref_wraparound_enabled_flag,

                     ( sps->getUseWrapAround() == 0 || CtbSizeY / MinCbSizeY + 1 > pps_pic_width_in_luma_samples / MinCbSizeY - 1 )

                       && pps_ref_wraparound_enabled_flag != 0,

                     "When sps_ref_wraparound_enabled_flag is equal to 0 or the value of CtbSizeY / MinCbSizeY + 1 is greater than"

                     " pps_pic_width_in_luma_samples / MinCbSizeY − 1, the value of pps_ref_wraparound_enabled_flag shall be equal to 0." );

  pcPPS->setUseWrapAround( pps_ref_wraparound_enabled_flag );

  if( pps_ref_wraparound_enabled_flag )

  {

    X_READ_UVLC( pps_pic_width_minus_wraparound_offset, 0, ( pps_pic_width_in_luma_samples / MinCbSizeY ) - ( CtbSizeY / MinCbSizeY ) - 2 );

    pcPPS->setPicWidthMinusWrapAroundOffset( pps_pic_width_minus_wraparound_offset );

  }

  X_READ_SVLC( pps_init_qp_minus26, -( 26 + sps->getQpBDOffset() ), 37 );

  pcPPS->setPicInitQPMinus26( pps_init_qp_minus26 );

  X_READ_FLAG( pps_cu_qp_delta_enabled_flag );

  pcPPS->setUseDQP( pps_cu_qp_delta_enabled_flag );

  X_READ_FLAG_CHECK( pps_chroma_tool_offsets_present_flag,

                     sps->getChromaFormatIdc() == 0 && pps_chroma_tool_offsets_present_flag != 0,

                     "When sps_chroma_format_idc is equal to 0, the value of pps_chroma_tool_offsets_present_flag shall be equal to 0." );

  pcPPS->setPPSChromaToolFlag( pps_chroma_tool_offsets_present_flag );

  if( pps_chroma_tool_offsets_present_flag )

  {

    X_READ_SVLC( pps_cb_qp_offset, -12, 12 );

    pcPPS->setQpOffset( COMPONENT_Cb, pps_cb_qp_offset );

    X_READ_SVLC( pps_cr_qp_offset, -12, 12 );

    pcPPS->setQpOffset( COMPONENT_Cr, pps_cr_qp_offset );

    X_READ_FLAG_CHECK( pps_joint_cbcr_qp_offset_present_flag,

                       ( sps->getChromaFormatIdc() == 0 || sps->getJointCbCrEnabledFlag() == 0 ) && pps_joint_cbcr_qp_offset_present_flag != 0,

                       "When sps_chroma_format_idc is equal to 0 or sps_joint_cbcr_enabled_flag is equal to 0, the value of"

                       " pps_joint_cbcr_qp_offset_present_flag shall be equal to 0." );

    pcPPS->setJointCbCrQpOffsetPresentFlag( pps_joint_cbcr_qp_offset_present_flag );

    if( pps_joint_cbcr_qp_offset_present_flag )

    {

      X_READ_SVLC( pps_joint_cbcr_qp_offset_value, -12, 12 );

      pcPPS->setQpOffset( JOINT_CbCr, pps_joint_cbcr_qp_offset_value );

    }

    else

    {

      pcPPS->setQpOffset( JOINT_CbCr, 0 );

    }

    X_READ_FLAG( pps_slice_chroma_qp_offsets_present_flag );

    pcPPS->setSliceChromaQpFlag( pps_slice_chroma_qp_offsets_present_flag );

    X_READ_FLAG( pps_cu_chroma_qp_offset_list_enabled_flag );

    if( !pps_cu_chroma_qp_offset_list_enabled_flag )

    {

      pcPPS->clearChromaQpOffsetList();

    }

    else

    {

      X_READ_UVLC( pps_chroma_qp_offset_list_len_minus1, 0, MAX_QP_OFFSET_LIST_SIZE - 1 );

      for( int cuChromaQpOffsetIdx = 0; cuChromaQpOffsetIdx <= pps_chroma_qp_offset_list_len_minus1; cuChromaQpOffsetIdx++ )

      {

        X_READ_SVLC_idx( pps_cb_qp_offset_list, "[i]", -12, 12 );

        X_READ_SVLC_idx( pps_cr_qp_offset_list, "[i]", -12, 12 );

        int jointCbCrOffset = 0;

        if( pps_joint_cbcr_qp_offset_present_flag )

        {

          X_READ_SVLC_idx( pps_joint_cbcr_qp_offset_list, "[i]", -12, 12 );

          jointCbCrOffset = pps_joint_cbcr_qp_offset_list;

        }

        // table uses +1 for index (see comment inside the function)

        pcPPS->setChromaQpOffsetListEntry( cuChromaQpOffsetIdx + 1, pps_cb_qp_offset_list, pps_cr_qp_offset_list, jointCbCrOffset );

      }

      CHECK( pcPPS->getChromaQpOffsetListLen() != pps_chroma_qp_offset_list_len_minus1 + 1, "Invalid chroma QP offset list length" );

    }

  }

  else

  {

    pcPPS->setQpOffset( COMPONENT_Cb, 0 );

    pcPPS->setQpOffset( COMPONENT_Cr, 0 );

    pcPPS->setJointCbCrQpOffsetPresentFlag( 0 );

    pcPPS->setSliceChromaQpFlag( 0 );

    pcPPS->clearChromaQpOffsetList();

  }

  X_READ_FLAG( pps_deblocking_filter_control_present_flag );

  pcPPS->setDeblockingFilterControlPresentFlag( pps_deblocking_filter_control_present_flag );

  if( pps_deblocking_filter_control_present_flag )

  {

    X_READ_FLAG( pps_deblocking_filter_override_enabled_flag );

    pcPPS->setDeblockingFilterOverrideEnabledFlag( pps_deblocking_filter_override_enabled_flag );

    X_READ_FLAG( pps_deblocking_filter_disabled_flag );

    pcPPS->setPPSDeblockingFilterDisabledFlag( pps_deblocking_filter_disabled_flag );

    if( !pps_no_pic_partition_flag && pps_deblocking_filter_override_enabled_flag )

    {

      X_READ_FLAG( pps_dbf_info_in_ph_flag );

      pcPPS->setDbfInfoInPhFlag( pps_dbf_info_in_ph_flag );

    }

    if( !pps_deblocking_filter_disabled_flag )

    {

      X_READ_SVLC( pps_luma_beta_offset_div2, -12, 12 );

      pcPPS->setDeblockingFilterBetaOffsetDiv2( pps_luma_beta_offset_div2 );

      X_READ_SVLC( pps_luma_tc_offset_div2, -12, 12 );

      pcPPS->setDeblockingFilterTcOffsetDiv2( pps_luma_tc_offset_div2 );

      if( pps_chroma_tool_offsets_present_flag )

      {

        X_READ_SVLC( pps_cb_beta_offset_div2, -12, 12 );

        pcPPS->setDeblockingFilterCbBetaOffsetDiv2( pps_cb_beta_offset_div2 );

        X_READ_SVLC( pps_cb_tc_offset_div2, -12, 12 );

        pcPPS->setDeblockingFilterCbTcOffsetDiv2( pps_cb_tc_offset_div2 );

        X_READ_SVLC( pps_cr_beta_offset_div2, -12, 12 );

        pcPPS->setDeblockingFilterCrBetaOffsetDiv2( pps_cr_beta_offset_div2 );

        X_READ_SVLC( pps_cr_tc_offset_div2, -12, 12 );

        pcPPS->setDeblockingFilterCrTcOffsetDiv2( pps_cr_tc_offset_div2 );

      }

      else

      {

        pcPPS->setDeblockingFilterCbBetaOffsetDiv2( pps_luma_beta_offset_div2 );

        pcPPS->setDeblockingFilterCbTcOffsetDiv2( pps_luma_tc_offset_div2 );

        pcPPS->setDeblockingFilterCrBetaOffsetDiv2( pps_luma_beta_offset_div2 );

        pcPPS->setDeblockingFilterCrTcOffsetDiv2( pps_luma_tc_offset_div2 );

      }

    }

  }

  if( !pps_no_pic_partition_flag )

  {

    X_READ_FLAG( pps_rpl_info_in_ph_flag );

    pcPPS->setRplInfoInPhFlag( pps_rpl_info_in_ph_flag );

    X_READ_FLAG( pps_sao_info_in_ph_flag );

    pcPPS->setSaoInfoInPhFlag( pps_sao_info_in_ph_flag );

    X_READ_FLAG( pps_alf_info_in_ph_flag );

    pcPPS->setAlfInfoInPhFlag( pps_alf_info_in_ph_flag );

    if( ( pps_weighted_pred_flag || pps_weighted_bipred_flag ) && pps_rpl_info_in_ph_flag )

    {

      X_READ_FLAG( pps_wp_info_in_ph_flag );

      pcPPS->setWpInfoInPhFlag( pps_wp_info_in_ph_flag );

    }

    X_READ_FLAG( pps_qp_delta_info_in_ph_flag );

    pcPPS->setQpDeltaInfoInPhFlag( pps_qp_delta_info_in_ph_flag );

  }

  X_READ_FLAG( pps_picture_header_extension_present_flag );

  pcPPS->setPictureHeaderExtensionPresentFlag( pps_picture_header_extension_present_flag );

  X_READ_FLAG( pps_slice_header_extension_present_flag );

  pcPPS->setSliceHeaderExtensionPresentFlag( pps_slice_header_extension_present_flag );

  X_READ_FLAG( pps_extension_flag );

  if( pps_extension_flag )

  {

    while( xMoreRbspData() )

    {

      X_READ_FLAG( pps_extension_data_flag );

      (void) pps_extension_data_flag;

    }

  }

  xReadRbspTrailingBits();

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

  //  PPS READING DONE

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

  if( pcPPS->getPicWidthInLumaSamples() == sps->getMaxPicWidthInLumaSamples() && pcPPS->getPicHeightInLumaSamples() == sps->getMaxPicHeightInLumaSamples() )

  {

    CHECK( pcPPS->getConformanceWindowPresentFlag(),

                       "When pps_pic_width_in_luma_samples is equal to sps_pic_width_max_in_luma_samples and "

                       "pps_pic_height_in_luma_samples is equal to sps_pic_height_max_in_luma_samples, the value of "

                       "pps_conformance_window_flag shall be equal to 0" );

    pcPPS->setConformanceWindow( sps->getConformanceWindow() );

    if( !pcPPS->getScalingWindow().getWindowEnabledFlag() )

    {

      pcPPS->setScalingWindow( pcPPS->getConformanceWindow() );

    }

  }

  pcPPS->finalizePPSPartitioning( sps );

  // set wraparound offset from PPS and SPS info

  int minCbSizeY = ( 1 << sps->getLog2MinCodingBlockSize() );

  CHECK( !sps->getUseWrapAround() && pcPPS->getUseWrapAround(),

         "When sps_ref_wraparound_enabled_flag is equal to 0, the value of pps_ref_wraparound_enabled_flag shall be equal to 0." );

  CHECK( sps->getCTUSize() / minCbSizeY + 1 > pcPPS->getPicWidthInLumaSamples() / minCbSizeY - 1 && pcPPS->getUseWrapAround(),

         "When the value of CtbSizeY / MinCbSizeY + 1 is greater than pic_width_in_luma_samples / MinCbSizeY - 1, the value of "

         "pps_ref_wraparound_enabled_flag shall be equal to 0." );

  if( pcPPS->getUseWrapAround() )

  {

    CHECK( pcPPS->getPicWidthMinusWrapAroundOffset() > pcPPS->getPicWidthInLumaSamples() / minCbSizeY - sps->getCTUSize() / minCbSizeY - 2,

           "pps_pic_width_minus_wraparound_ofsfet shall be less than or equal to pps_pic_width_in_luma_samples/MinCbSizeY - CtbSizeY/MinCbSizeY-2" );

    pcPPS->setWrapAroundOffset( minCbSizeY * ( pcPPS->getPicWidthInLumaSamples() / minCbSizeY - pcPPS->getPicWidthMinusWrapAroundOffset() ) );

  }

  else

  {

    pcPPS->setWrapAroundOffset( 0 );

  }

  pcPPS->pcv = std::make_unique<PreCalcValues>( *sps, *pcPPS );

}

bool HLSyntaxReader::parseAPS( APS* aps )

{

#if ENABLE_TRACING

  xTraceAPSHeader();

#endif

  X_READ_CODE_NO_RANGE( aps_params_type, 3 );

  // if not in supported range, this APS is ignored `switch() -> default`

  aps->setAPSType( aps_params_type );

  X_READ_CODE_NO_RANGE( adaptation_parameter_set_id, 5 );

  // range check happens later in the `switch( aps_params_type )`

  aps->setAPSId( adaptation_parameter_set_id );

  X_READ_FLAG( aps_chroma_present_flag );

  aps->chromaPresentFlag = aps_chroma_present_flag;

  switch( aps_params_type )

  {

  case ALF_APS:

    CHECK_READ_RANGE( adaptation_parameter_set_id, 0, 7, "adaptation_parameter_set_id for ALF_APS" );

    parseAlfAps( aps );

    break;

  case LMCS_APS:

    CHECK_READ_RANGE( adaptation_parameter_set_id, 0, 3, "adaptation_parameter_set_id for LMCS_APS," );

    parseLmcsAps( aps );

    break;

  case SCALING_LIST_APS:

    CHECK_READ_RANGE( adaptation_parameter_set_id, 0, 7, "adaptation_parameter_set_id for SCALING_APS" );

    parseScalingListAps( aps );

    break;

  default:

    WARN( "unknown APS type (" << aps_params_type << ")" );

    return false;

  }

  X_READ_FLAG( aps_extension_flag );

  if( aps_extension_flag )

  {

    while( xMoreRbspData() )

    {

      X_READ_FLAG( aps_extension_data_flag );

      (void) aps_extension_data_flag;

    }

  }

  xReadRbspTrailingBits();

  return true;

}

void HLSyntaxReader::parseAlfAps( APS* aps )

{

  AlfSliceParam& param = aps->getAlfAPSParam();

  param.reset();

  X_READ_FLAG( alf_luma_new_filter );   //  standard: alf_luma_filter_signal_flag

  param.newFilterFlag[CHANNEL_TYPE_LUMA] = alf_luma_new_filter;

  CcAlfFilterParam& ccAlfParam = aps->getCcAlfAPSParam();