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

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

 *  \brief    Reader for low level syntax

 */

#include "CABACReader.h"

#include "CommonLib/CodingStructure.h"

#include "CommonLib/TrQuant.h"

#include "CommonLib/UnitTools.h"

#include "CommonLib/SampleAdaptiveOffset.h"

#include "CommonLib/dtrace_next.h"

#include "CommonLib/Picture.h"

#include "CommonLib/TimeProfiler.h"

namespace vvdec

{

void CABACReader::initCtxModels( Slice& slice )

{

  SliceType sliceType  = slice.getSliceType();

  int       qp         = slice.getSliceQp();

  if( slice.getPPS()->getCabacInitPresentFlag() && slice.getCabacInitFlag() )

  {

    switch( sliceType )

    {

    case P_SLICE:           // change initialization table to B_SLICE initialization

      sliceType = B_SLICE;

      break;

    case B_SLICE:           // change initialization table to P_SLICE initialization

      sliceType = P_SLICE;

      break;

    default     :           // should not occur

      THROW_RECOVERABLE( "Invalid slice type" );

      break;

    }

  }

  m_BinDecoder.reset( qp, (int)sliceType );

}

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

//  clause 7.3.8.1

//--------------------------------------------------------------------------------

//    bool  terminating_bit()

//    void  remaining_bytes( noTrailingBytesExpected )

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

bool CABACReader::terminating_bit()

{

  if( m_BinDecoder.decodeBinTrm() )

  {

    m_BinDecoder.finish();

    m_Bitstream->readOutTrailingBits();

    return true;

  }

  return false;

}

void CABACReader::remaining_bytes( bool noTrailingBytesExpected )

{

  if( noTrailingBytesExpected )

  {

//    CHECK( 0 != m_Bitstream->getNumBitsLeft(), "Bits left when not supposed" );

  }

  else

  {

    while( m_Bitstream->getNumBitsLeft() )

    {

      unsigned trailingNullByte = m_Bitstream->readByte();

      CHECK( trailingNullByte != 0, "Trailing byte should be '0', but has a value of " << std::hex << trailingNullByte << std::dec << "\n" );

    }

  }

}

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

//  clause 7.3.11.2

//--------------------------------------------------------------------------------

//    bool  coding_tree_unit    ( cs, slice, area, qps[2], ctuRsAddr )

//    bool  dt_implicit_qt_split( cs, pL, cuCtxL, pC, cuCtxC )

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

bool CABACReader::coding_tree_unit( CodingStructure& cs, Slice* slice, const UnitArea& area, int (&qps)[2], unsigned ctuRsAddr )

{

  m_slice = slice;

  CUCtx cuCtx( qps[CH_L] );

  Partitioner &partitioner = m_partL;

  partitioner.initCtu( area, CH_L, cs, *m_slice );

  partitioner.treeType = TREE_D;

  partitioner.modeType = MODE_TYPE_ALL;

  sao( cs, ctuRsAddr );

  readAlf(cs, ctuRsAddr, partitioner);

  bool isLast = false;

  if( partitioner.isDualITree && cs.pcv->chrFormat != CHROMA_400 )

  {

    CUCtx cuCtxC( qps[CH_C] );

    Partitioner &partitionerC = m_partC;

    partitionerC.initCtu( area, CH_C, cs, *m_slice );

    partitionerC.treeType = TREE_D;

    partitionerC.modeType = MODE_TYPE_ALL;

    dt_implicit_qt_split( cs, partitioner, cuCtx, partitionerC, cuCtxC );

    qps[CH_L] = cuCtx.qp;

    qps[CH_C] = cuCtxC.qp;

  }

  else

  {

    isLast = coding_tree( cs, partitioner, cuCtx );

    qps[CH_L] = cuCtx.qp;

  }

  DTRACE_COND( ctuRsAddr == 0, g_trace_ctx, D_QP_PER_CTU, "\n%4d %2d", cs.picture->poc, m_slice->getSliceQp() );

  DTRACE     (                 g_trace_ctx, D_QP_PER_CTU, " %3d",           qps[CH_L] - m_slice->getSliceQp() );

  return isLast;

}

bool CABACReader::dt_implicit_qt_split( CodingStructure& cs, Partitioner& partitionerL, CUCtx& cuCtxL, Partitioner& partitionerC, CUCtx& cuCtxC )

{

  if( partitionerL.currArea().lwidth() > 64 )

  {

    const PPS& pps = *cs.pps;

    // Reset delta QP coding flag and ChromaQPAdjustemt coding flag

    if( pps.getUseDQP() && partitionerL.currQgEnable() )

    {

      cuCtxL.qgStart    = true;

      cuCtxL.isDQPCoded = false;

      cuCtxC.qgStart    = true;

      cuCtxC.isDQPCoded = false;

    }

    if( m_slice->getUseChromaQpAdj() && partitionerL.currQgChromaEnable() )

    {

      cuCtxL.isChromaQpAdjCoded = false;

      cuCtxC.isChromaQpAdjCoded = false;

      cs    .chromaQpAdj        = 0;

    }

    partitionerL.splitCurrArea( CU_QUAD_SPLIT, cs );

    partitionerC.splitCurrArea( CU_QUAD_SPLIT, cs );

    bool lastSegment = false;

    do

    {

      if( !lastSegment && cs.area.blocks[partitionerL.chType].contains( partitionerL.currArea().blocks[partitionerL.chType].pos() ) )

      {

        lastSegment = dt_implicit_qt_split( cs, partitionerL, cuCtxL, partitionerC, cuCtxC );

      }

    } while( partitionerL.nextPart( cs ) && partitionerC.nextPart( cs ) );

    return lastSegment;

  }

  bool isLast = coding_tree( cs, partitionerL, cuCtxL );

  CHECKD( isLast, "Chroma not parsed but end of slice signalled!" );

  isLast      = coding_tree( cs, partitionerC, cuCtxC );

  return isLast;

}

short CABACReader::readAlfCtuFilterIndex( CodingStructure& cs, unsigned ctuRsAddr )

{

  const unsigned numAps               = m_slice->getNumAlfAps();

  const unsigned numAvailableFiltSets = numAps + NUM_FIXED_FILTER_SETS;

  uint32_t filtIndex = 0;

  const bool usePrevFilt = numAps > 0

                        && m_BinDecoder.decodeBin( Ctx::AlfUseTemporalFilt() );

  if( usePrevFilt )

  {

    if( numAps > 1 )

    {

      xReadTruncBinCode( filtIndex, numAvailableFiltSets - NUM_FIXED_FILTER_SETS );

    }

    filtIndex += ( unsigned ) ( NUM_FIXED_FILTER_SETS );

  }

  else

  {

    xReadTruncBinCode( filtIndex, NUM_FIXED_FILTER_SETS );

  }

  return filtIndex;

}

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

//  clause 7.3.11.3

//--------------------------------------------------------------------------------

//    void  sao( cs, ctuRsAddr )

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

void CABACReader::sao( CodingStructure& cs, unsigned ctuRsAddr )

{

  SAOBlkParam&      sao_ctu_pars            = cs.getCtuData( ctuRsAddr ).saoParam;

  sao_ctu_pars[ COMPONENT_Y  ].modeIdc      = SAO_MODE_OFF;

  sao_ctu_pars[ COMPONENT_Cb ].modeIdc      = SAO_MODE_OFF;

  sao_ctu_pars[ COMPONENT_Cr ].modeIdc      = SAO_MODE_OFF;

  const SPS&   sps                          = *cs.sps;

  const Slice& slice                        = *m_slice;

  const bool   slice_sao_luma_flag          = ( slice.getSaoEnabledFlag( CHANNEL_TYPE_LUMA ) );

  const bool   slice_sao_chroma_flag        = ( slice.getSaoEnabledFlag( CHANNEL_TYPE_CHROMA ) && sps.getChromaFormatIdc() != CHROMA_400 );

  if( !slice_sao_luma_flag && !slice_sao_chroma_flag )

  {

    return;

  }

  // merge

  int             frame_width_in_ctus     = cs.pcv->widthInCtus;

  int             ry                      = ctuRsAddr      / frame_width_in_ctus;

  int             rx                      = ctuRsAddr - ry * frame_width_in_ctus;

  int             sao_merge_type          = -1;

  const Position  pos( rx * cs.pcv->maxCUWidth, ry * cs.pcv->maxCUHeight );

  const unsigned  curSliceIdx = m_slice->getIndependentSliceIdx();

  const unsigned  curTileIdx  = cs.pps->getTileIdx( pos );

  if( cs.getCURestricted( pos.offset(-(int)cs.pcv->maxCUWidth, 0), pos, curSliceIdx, curTileIdx, CH_L ) )

  {

    // sao_merge_left_flag

    sao_merge_type  += int( m_BinDecoder.decodeBin( Ctx::SaoMergeFlag() ) );

  }

  if( sao_merge_type < 0 && cs.getCURestricted( pos.offset(0, -(int)cs.pcv->maxCUHeight), pos, curSliceIdx, curTileIdx, CH_L ) )

  {

    // sao_merge_above_flag

    sao_merge_type  += int( m_BinDecoder.decodeBin( Ctx::SaoMergeFlag() ) ) << 1;

  }

  if( sao_merge_type >= 0 )

  {

    if( slice_sao_luma_flag || slice_sao_chroma_flag )

    {

      sao_ctu_pars[ COMPONENT_Y  ].modeIdc  = SAO_MODE_MERGE;

      sao_ctu_pars[ COMPONENT_Y  ].typeIdc  = sao_merge_type;

    }

    if( slice_sao_chroma_flag )

    {

      sao_ctu_pars[ COMPONENT_Cb ].modeIdc  = SAO_MODE_MERGE;

      sao_ctu_pars[ COMPONENT_Cr ].modeIdc  = SAO_MODE_MERGE;

      sao_ctu_pars[ COMPONENT_Cb ].typeIdc  = sao_merge_type;

      sao_ctu_pars[ COMPONENT_Cr ].typeIdc  = sao_merge_type;

    }

    return;

  }

  // explicit parameters

  const ComponentID firstComp = ( slice_sao_luma_flag   ? COMPONENT_Y  : COMPONENT_Cb );

  const ComponentID lastComp  = ( slice_sao_chroma_flag ? COMPONENT_Cr : COMPONENT_Y  );

  for( ComponentID compID = firstComp; compID <= lastComp; compID = ComponentID( compID + 1 ) )

  {

    SAOOffset& sao_pars = sao_ctu_pars[ compID ];

    // sao_type_idx_luma / sao_type_idx_chroma

    if( compID != COMPONENT_Cr )

    {

      if( m_BinDecoder.decodeBin( Ctx::SaoTypeIdx() ) )

      {

        if( m_BinDecoder.decodeBinEP( ) )

        {

          // edge offset

          sao_pars.modeIdc = SAO_MODE_NEW;

          sao_pars.typeIdc = SAO_TYPE_START_EO;

        }

        else

        {

          // band offset

          sao_pars.modeIdc = SAO_MODE_NEW;

          sao_pars.typeIdc = SAO_TYPE_START_BO;

        }

      }

    }

    else //Cr, follow Cb SAO type

    {

      sao_pars.modeIdc = sao_ctu_pars[ COMPONENT_Cb ].modeIdc;

      sao_pars.typeIdc = sao_ctu_pars[ COMPONENT_Cb ].typeIdc;

    }

    if( sao_pars.modeIdc == SAO_MODE_OFF )

    {

      continue;

    }

    // sao_offset_abs

    int       offset[4];

    const int maxOffsetQVal = SampleAdaptiveOffset::getMaxOffsetQVal( sps.getBitDepth() );

    offset    [0]           = (int)unary_max_eqprob( maxOffsetQVal );

    offset    [1]           = (int)unary_max_eqprob( maxOffsetQVal );

    offset    [2]           = (int)unary_max_eqprob( maxOffsetQVal );

    offset    [3]           = (int)unary_max_eqprob( maxOffsetQVal );

    // band offset mode

    if( sao_pars.typeIdc == SAO_TYPE_START_BO )

    {

      // sao_offset_sign

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

      {

        if( offset[k] && m_BinDecoder.decodeBinEP( ) )

        {

          offset[k] = -offset[k];

        }

      }

      // sao_band_position

      sao_pars.typeAuxInfo = m_BinDecoder.decodeBinsEP( NUM_SAO_BO_CLASSES_LOG2 );

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

      {

        sao_pars.offset[ ( sao_pars.typeAuxInfo + k ) % MAX_NUM_SAO_CLASSES ] = offset[k];

      }

      continue;

    }

    // edge offset mode

    sao_pars.typeAuxInfo = 0;

    if( compID != COMPONENT_Cr )

    {

      // sao_eo_class_luma / sao_eo_class_chroma

      sao_pars.typeIdc += m_BinDecoder.decodeBinsEP( NUM_SAO_EO_TYPES_LOG2 );

    }

    else

    {

      sao_pars.typeIdc  = sao_ctu_pars[ COMPONENT_Cb ].typeIdc;

    }

    sao_pars.offset[ SAO_CLASS_EO_FULL_VALLEY ] =  offset[0];

    sao_pars.offset[ SAO_CLASS_EO_HALF_VALLEY ] =  offset[1];

    sao_pars.offset[ SAO_CLASS_EO_PLAIN       ] =  0;

    sao_pars.offset[ SAO_CLASS_EO_HALF_PEAK   ] = -offset[2];

    sao_pars.offset[ SAO_CLASS_EO_FULL_PEAK   ] = -offset[3];

  }

}

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

//    void  readAlf( cs, ctuRsAddr, partitioner )

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

void CABACReader::readAlf( CodingStructure& cs, unsigned int ctuRsAddr, const Partitioner& partitioner )

{

  const PreCalcValues& pcv                = *cs.pcv;

  int                 frame_width_in_ctus = pcv.widthInCtus;

  int                 ry                  = ctuRsAddr / frame_width_in_ctus;

  int                 rx                  = ctuRsAddr - ry * frame_width_in_ctus;

  const Position      pos                 ( rx * cs.pcv->maxCUWidth, ry * cs.pcv->maxCUHeight );

  bool                leftAvail           = cs.getCURestricted( pos.offset( -1, 0 ), pos, partitioner.currSliceIdx, partitioner.currTileIdx, CH_L ) ? true : false;

  bool                aboveAvail          = cs.getCURestricted( pos.offset( 0, -1 ), pos, partitioner.currSliceIdx, partitioner.currTileIdx, CH_L ) ? true : false;

  CtuAlfData& currAlfData = cs.getCtuData( ctuRsAddr ).alfParam;

  CtuAlfData  leftAlfData, aboveAlfData;

  if( leftAvail )  leftAlfData  = cs.getCtuData( ctuRsAddr -                   1 ).alfParam;

  if( aboveAvail ) aboveAlfData = cs.getCtuData( ctuRsAddr - frame_width_in_ctus ).alfParam;

  if( m_slice->getAlfEnabledFlag( COMPONENT_Y ) )

  {

    for( int compIdx = 0; compIdx < MAX_NUM_COMPONENT; compIdx++ )

    {

      if( m_slice->getAlfEnabledFlag( ( ComponentID ) compIdx ) )

      {

        //uint8_t* ctbAlfFlag = m_slice->getPic()->getAlfCtuEnableFlag( compIdx );

        int ctx = 0;

          ctx += leftAlfData.alfCtuEnableFlag[compIdx];

          ctx += aboveAlfData.alfCtuEnableFlag[compIdx];

        currAlfData.alfCtuEnableFlag[compIdx] = m_BinDecoder.decodeBin( Ctx::ctbAlfFlag( compIdx * 3 + ctx ) );

        if( isLuma( ( ComponentID ) compIdx ) && currAlfData.alfCtuEnableFlag[compIdx] )

        {

          currAlfData.alfCtbFilterIndex = readAlfCtuFilterIndex( cs, ctuRsAddr );

        }

        if( isChroma( ( ComponentID ) compIdx ) )

        {

          const int apsIdx                  = m_slice->getAlfApsIdChroma();

          CHECK( m_slice->getAlfAPSs()[apsIdx] == nullptr, "APS not initialized" );

          const AlfSliceParam& alfParam     = m_slice->getAlfAPSs()[apsIdx]->getAlfAPSParam();

          const int numAlts                 = alfParam.numAlternativesChroma;

          currAlfData.alfCtuAlternative[compIdx - 1] = 0;

          if( currAlfData.alfCtuEnableFlag[compIdx] )

          {

            uint8_t decoded = 0;

            while( decoded < numAlts - 1 && m_BinDecoder.decodeBin( Ctx::ctbAlfAlternative( compIdx - 1 ) ) )

              ++decoded;

            currAlfData.alfCtuAlternative[compIdx - 1] = decoded;

          }

        }

      }

    }

  }

  for( int compIdx = 1; compIdx < getNumberValidComponents( cs.pcv->chrFormat ); compIdx++ )

  {

    if( m_slice->getCcAlfEnabledFlag( compIdx ) )

    {

      int ctxt = 0;

      ctxt += ( leftAlfData.ccAlfFilterControl[compIdx - 1] ) ? 1 : 0;

      ctxt += ( aboveAlfData.ccAlfFilterControl[compIdx - 1] ) ? 1 : 0;

      ctxt += ( compIdx == COMPONENT_Cr ) ? 3 : 0;

      int idcVal  = m_BinDecoder.decodeBin( Ctx::CcAlfFilterControlFlag( ctxt ) );

      if ( idcVal )

      {

        const int apsIdx        = compIdx == 1 ? m_slice->getCcAlfCbApsId() : m_slice->getCcAlfCrApsId();

        const int filterCount   = m_slice->getAlfAPSs()[apsIdx]->getCcAlfAPSParam().ccAlfFilterCount[compIdx - 1];

        while ( ( idcVal != filterCount ) && m_BinDecoder.decodeBinEP() )

        {

          idcVal++;

        }

      }

      currAlfData.ccAlfFilterControl[compIdx - 1] = idcVal;

    }

  }

}

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

//  clause 7.3.11.4

//--------------------------------------------------------------------------------

//    bool      coding_tree     ( cs, partitioner, cuCtx )

//    PartSplit split_cu_mode   ( cs, partitioner )

//    ModeType  mode_constraint ( cs, partitioner, splitMode )

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

bool CABACReader::coding_tree( CodingStructure& cs, Partitioner& partitioner, CUCtx& cuCtx )

{

  const PPS      &pps             = *cs.pps;

        UnitArea  currArea        = partitioner.currArea();

  bool            lastSegment     = false;

  bool            chromaNotSplit  = false;

  const ModeType modeTypeParent   = partitioner.modeType;

  // Reset delta QP coding flag and ChromaQPAdjustemt coding flag

  if( pps.getUseDQP() && partitioner.currQgEnable() && !isChroma( partitioner.chType ) )

  {

    cuCtx.qgStart     = true;

    cuCtx.isDQPCoded  = false;

  }

  if( m_slice->getUseChromaQpAdj() && partitioner.currQgChromaEnable() )

  {

    cuCtx.isChromaQpAdjCoded = false;

    cs.chromaQpAdj           = 0;

  }

  const PartSplit split = split_cu_mode( cs, partitioner );

  if( split != CU_DONT_SPLIT )

  {

    partitioner.modeType = mode_constraint( cs, partitioner, split ); //change for child nodes

    //decide chroma split or not

    chromaNotSplit = modeTypeParent == MODE_TYPE_ALL && partitioner.modeType == MODE_TYPE_INTRA;

    CHECK( chromaNotSplit && partitioner.chType != CHANNEL_TYPE_LUMA, "chType must be luma" );

    if( partitioner.treeType == TREE_D )

    {

      partitioner.treeType = chromaNotSplit ? TREE_L : TREE_D;

    }

    partitioner.splitCurrArea( split, cs );

    do

    {

      if( !lastSegment && cs.area.blocks[partitioner.chType].contains( partitioner.currArea().blocks[partitioner.chType].pos() ) )

      {

        lastSegment = coding_tree( cs, partitioner, cuCtx );

      }

    } while( partitioner.nextPart( cs ) );

    partitioner.exitCurrSplit( cs );

    if( chromaNotSplit )

    {

      partitioner.chType    = CHANNEL_TYPE_CHROMA;

      partitioner.treeType  = TREE_C;

      partitioner.updateNeighbors( cs );

      if( !lastSegment && cs.picture->blocks[partitioner.chType].contains( partitioner.currArea().blocks[partitioner.chType].pos() ) )

      {

        lastSegment = coding_tree( cs, partitioner, cuCtx );

      }

      else

      {

        THROW_RECOVERABLE( "Unexpected behavior, not parsing chroma even though luma data is available!" );

      }

      //recover treeType

      partitioner.chType    = CHANNEL_TYPE_LUMA;

      partitioner.treeType  = TREE_D;

    }

    partitioner.modeType = modeTypeParent;

    return lastSegment;

  }

  TreeType treeType = partitioner.treeType;

  if( isChroma( partitioner.chType ) )                                 { currArea.Y()                  = CompArea(); treeType = TREE_C; }

  else if( partitioner.isDualITree || partitioner.treeType == TREE_L ) { currArea.Cb() = currArea.Cr() = CompArea(); treeType = TREE_L; }

  CodingUnit& cu = cs.addCU( currArea, partitioner.chType, treeType, partitioner.modeType, partitioner.currPartLevel().cuLeft, partitioner.currPartLevel().cuAbove );

#if ENABLE_TRACING && 0

  if( cu.chType() == CHANNEL_TYPE_CHROMA )

  {

    DTRACE( g_trace_ctx, D_SYNTAX, "[chroma] CU x=%d, y=%d, w=%d, h=%d\n", cu.Cb().x, cu.Cb().y, cu.Cb().width, cu.Cb().height );

  }

  else

    DTRACE( g_trace_ctx, D_SYNTAX, "CU x=%d, y=%d, w=%d, h=%d\n", cu.Y().x, cu.Y().y, cu.Y().width, cu.Y().height );

#endif

  partitioner.setCUData( cu );

  cu.slice   = m_slice;

  cu.pps     = cu.slice->getPPS();

  cu.sps     = cu.slice->getSPS();

  cu.tileIdx = partitioner.currTileIdx;

  int lumaQPinLocalDualTree = -1;

  // Predict QP on start of quantization group

  if( cuCtx.qgStart )

  {

    cuCtx.qgStart = false;

    cuCtx.qp      = CU::predictQP( cu, cuCtx.qp );

  }

  if( pps.getUseDQP() && partitioner.isSepTree( cs ) && isChroma( cu.chType() ) )

  {

    const Position chromaCentral( cu.chromaPos().offset( cu.chromaSize().width >> 1, cu.chromaSize().height >> 1 ) );

    const Position lumaRefPos( chromaCentral.x << getComponentScaleX( COMPONENT_Cb, cu.chromaFormat ), chromaCentral.y << getComponentScaleY( COMPONENT_Cb, cu.chromaFormat ) );

    //derive chroma qp, but the chroma qp is saved in cuCtx.qp which is used for luma qp

    //therefore, after decoding the chroma CU, the cuCtx.qp shall be recovered to luma qp in order to decode next luma cu qp

//    const CodingUnit* colLumaCu = cs.getLumaCU( lumaRefPos );

    const CodingUnit* colLumaCu = cs.getCU( lumaRefPos, CHANNEL_TYPE_LUMA );

    CHECK( colLumaCu == nullptr, "colLumaCU shall exist" );

    lumaQPinLocalDualTree = cuCtx.qp;

    if( colLumaCu ) cuCtx.qp = colLumaCu->qp;

  }

  cu.qp = cuCtx.qp;                 //NOTE: CU QP can be changed by deltaQP signaling at TU level

  cu.chromaQpAdj = cs.chromaQpAdj;  //NOTE: CU chroma QP adjustment can be changed by adjustment signaling at TU level

  // coding unit

  bool isLastCtu = coding_unit( cu, partitioner, cuCtx );

  //recover cuCtx.qp to luma qp after decoding the chroma CU

  if( pps.getUseDQP() && partitioner.isSepTree( cs ) && isChroma( cu.chType() ) )

  {

    cuCtx.qp = lumaQPinLocalDualTree;

  }

  if( isChromaEnabled( cs.pcv->chrFormat ) )

  for( TransformUnit& tu : TUTraverser( &cu.firstTU, cu.lastTU->next ) )

  {

    if( tu.Cb().valid() )

    {

      QpParam cQP( tu, COMPONENT_Cb, false );

      tu.chromaQp[COMPONENT_Cb - 1] = cQP.Qp( false );

    }

    if( tu.Cr().valid() )

    {

      QpParam cQP( tu, COMPONENT_Cr, false );

      tu.chromaQp[COMPONENT_Cr - 1] = cQP.Qp( false );

    }

  }

#if ENABLE_TRACING

  if( cu.chType() == CHANNEL_TYPE_CHROMA )

  {

    DTRACE( g_trace_ctx, D_QP, "[chroma CU]x=%d, y=%d, w=%d, h=%d, qp=%d\n", cu.Cb().x, cu.Cb().y, cu.Cb().width, cu.Cb().height, cu.qp );

  }

  else

    DTRACE( g_trace_ctx, D_QP, "x=%d, y=%d, w=%d, h=%d, qp=%d\n", cu.Y().x, cu.Y().y, cu.Y().width, cu.Y().height, cu.qp );

#endif

  return isLastCtu;

}

int signalModeCons( const CodingStructure& cs, const Slice* slice, const PartSplit split, const Partitioner &partitioner, const ModeType modeTypeParent )

{

  if( partitioner.isDualITree || modeTypeParent != MODE_TYPE_ALL || partitioner.currArea().chromaFormat == CHROMA_444 || partitioner.currArea().chromaFormat == CHROMA_400 )

    return LDT_MODE_TYPE_INHERIT;

  int minLumaArea = partitioner.currArea().lumaSize().area();

  if( split == CU_QUAD_SPLIT || split == CU_TRIH_SPLIT || split == CU_TRIV_SPLIT ) // the area is split into 3 or 4 parts

  {

    minLumaArea = minLumaArea >> 2;

  }

  else if( split == CU_VERT_SPLIT || split == CU_HORZ_SPLIT ) // the area is split into 2 parts

  {

    minLumaArea = minLumaArea >> 1;

  }

  const int minChromaBlock  = minLumaArea >> ( getChannelTypeScaleX( CHANNEL_TYPE_CHROMA, partitioner.currArea().chromaFormat ) + getChannelTypeScaleY( CHANNEL_TYPE_CHROMA, partitioner.currArea().chromaFormat ) );

  const bool is2xNChroma    = ( partitioner.currArea().chromaSize().width == 4 && split == CU_VERT_SPLIT ) || ( partitioner.currArea().chromaSize().width == 8 && split == CU_TRIV_SPLIT );

  return    minChromaBlock >= 16 &&

           !is2xNChroma ?

              LDT_MODE_TYPE_INHERIT :

            ( minLumaArea < 32 || slice->isIntra() ) ? LDT_MODE_TYPE_INFER : LDT_MODE_TYPE_SIGNAL;

}

ModeType CABACReader::mode_constraint( CodingStructure& cs, Partitioner &partitioner, PartSplit splitMode )

{

  const int val = signalModeCons( cs, m_slice, splitMode, partitioner, partitioner.modeType );

  if( val == LDT_MODE_TYPE_SIGNAL )

  {

    const int ctxIdx = DeriveCtx::CtxModeConsFlag( cs, partitioner );

    const bool flag  = m_BinDecoder.decodeBin( Ctx::ModeConsFlag( ctxIdx ) );

    DTRACE( g_trace_ctx, D_SYNTAX, "mode_cons_flag() flag=%d\n", flag );

    return flag ? MODE_TYPE_INTRA : MODE_TYPE_INTER;

  }

  else if( val == LDT_MODE_TYPE_INFER )

  {

    return MODE_TYPE_INTRA;

  }

  else

  {

    return partitioner.modeType;

  }

}

PartSplit CABACReader::split_cu_mode( CodingStructure& cs, Partitioner &partitioner )

{

  PartSplit mode = CU_DONT_SPLIT;

  bool canNo, canQt, canBh, canBv, canTh, canTv;

  partitioner.canSplit( cs, canNo, canQt, canBh, canBv, canTh, canTv );

  const unsigned numHor = canBh + canTh;

  const unsigned numVer = canBv + canTv;

  unsigned numSplit = ( canQt << 1 ) + numHor + numVer;

  bool isSplit = !!numSplit;

#if !ENABLE_TRACING

  if( canNo && !isSplit )

  {

    DTRACE( g_trace_ctx, D_SYNTAX, "split_cu_mode() ctx=0 split=0\n" );

    return CU_DONT_SPLIT;

  }

#endif

  unsigned ctxSplit, ctxQtSplit, ctxBttHV, ctxBtt12;

  const CodingUnit* cuLeft   = partitioner.currPartLevel().cuLeft;

  const CodingUnit* cuAbove  = partitioner.currPartLevel().cuAbove;

  const unsigned widthCurr   = partitioner.currArea().blocks[partitioner.chType].width;

  const unsigned heightCurr  = partitioner.currArea().blocks[partitioner.chType].height;

#if !ENABLE_TRACING

  if( canNo && isSplit )

#endif

  {

    ///////////////////////

    // CTX do split (0-8)

    ///////////////////////

    ctxSplit  = ( cuLeft  && cuLeft ->blocks[partitioner.chType].height < heightCurr );

    ctxSplit += ( cuAbove && cuAbove->blocks[partitioner.chType].width  < widthCurr  );

                                      // 0, 1, 2, 3, 4, 5, 6 // split

                                      // 0, 0, 1, 2, 3, 4, 5 // split - 1

    static constexpr int ctxOffset[] = { 0, 0, 0, 3, 3, 6, 6 };

    ctxSplit += ctxOffset[numSplit];

#if ENABLE_TRACING

    if( canNo && isSplit )

#endif // endif

    isSplit = m_BinDecoder.decodeBin( Ctx::SplitFlag( ctxSplit ) );

  }

  DTRACE( g_trace_ctx, D_SYNTAX, "split_cu_mode() ctx=%d split=%d\n", ctxSplit, isSplit );

  if( !isSplit )

  {

    return CU_DONT_SPLIT;

  }

  const bool canBtt = !!numHor || !!numVer;

  bool       isQt   = canQt;

#if !ENABLE_TRACING

  if( isQt && canBtt )

#endif

  {

    //////////////////////////

    // CTX is qt split (0-5)

    //////////////////////////

    ctxQtSplit  = ( cuLeft  && cuLeft->qtDepth  > partitioner.currQtDepth );

    ctxQtSplit += ( cuAbove && cuAbove->qtDepth > partitioner.currQtDepth );

    ctxQtSplit += partitioner.currQtDepth < 2 ? 0 : 3;

#if ENABLE_TRACING

    if( isQt && canBtt )

#endif

    isQt = m_BinDecoder.decodeBin( Ctx::SplitQtFlag( ctxQtSplit ) );

  }

  DTRACE( g_trace_ctx, D_SYNTAX, "split_cu_mode() ctx=%d qt=%d\n", ctxQtSplit, isQt );

  if( isQt )

  {

    return CU_QUAD_SPLIT;

  }

  const bool canHor = !!numHor;

  bool        isVer = !!numVer;

#if !ENABLE_TRACING

  if( isVer && canHor )

#endif

  {

    ////////////////////////////

    // CTX is ver split (0-4)

    ////////////////////////////

    ctxBttHV = 0;

    if( numVer == numHor )

    {

      if( cuLeft && cuAbove )

      {

        const int wIdxAbove = getLog2( cuAbove->blocks[partitioner.chType].width  );

        const int hIdxLeft  = getLog2( cuLeft ->blocks[partitioner.chType].height );

        const int depAbove  = widthCurr  >> wIdxAbove;

        const int depLeft   = heightCurr >> hIdxLeft;

        if( depAbove == depLeft ) ctxBttHV = 0;

        else if( depAbove < depLeft ) ctxBttHV = 1;

        else ctxBttHV = 2;

      }

    }

    else if( numVer < numHor )

    {

      ctxBttHV = 3;

    }

    else

    {

      ctxBttHV = 4;

    }

#if ENABLE_TRACING

    if( isVer && canHor )

#endif

    isVer = m_BinDecoder.decodeBin( Ctx::SplitHvFlag( ctxBttHV ) );

  }

  const bool can14 = isVer ? canTv : canTh;

  bool        is12 = isVer ? canBv : canBh;

#if !ENABLE_TRACING

  if( is12 && can14 )

#endif

  {

    //////////////////////////

    // CTX is h/v bt (0-3)

    //////////////////////////

    ctxBtt12 = !!( partitioner.currMtDepth <= 1 ) + ( isVer << 1 );

#if ENABLE_TRACING

    if( is12 && can14 )

#endif

    is12 = m_BinDecoder.decodeBin( Ctx::Split12Flag( ctxBtt12 ) );

  }

  if     ( isVer && is12 )  mode = CU_VERT_SPLIT;

  else if( isVer && !is12 ) mode = CU_TRIV_SPLIT;

  else if( !isVer && is12 ) mode = CU_HORZ_SPLIT;

  else                      mode = CU_TRIH_SPLIT;

  DTRACE( g_trace_ctx, D_SYNTAX, "split_cu_mode() ctxHv=%d ctx12=%d mode=%d\n", ctxBttHV, ctxBtt12, mode );

  return mode;

}

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

//  clause 7.3.11.5

//--------------------------------------------------------------------------------

//    bool  coding_unit             ( cu, pm, cuCtx )

//    void  cu_skip_flag            ( cu )

//    void  pred_mode               ( cu )

//    void  bdpcm_mode              ( cu, compID )

//    void  cu_pred_data            ( cu )

//    void  cu_bcw_flag             ( cu )

//    void  extend_ref_line         ( cu )

//    void  intra_luma_pred_mode    ( cu )

//    bool  intra_chroma_lmc_mode   ( cu )

//    void  intra_chroma_pred_mode  ( cu )

//    void  cu_residual             ( cu, pm, cuCtx )

//    void  rqt_root_cbf            ( cu )

//    void  adaptive_color_transform( cu )

//    void  sbt_mode                ( cu )

//    void  mip_flag                ( cu )

//    void  mip_pred_mode           ( cu )

//    bool  end_of_ctu              ( cu, cuCtx )

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

bool CABACReader::coding_unit( CodingUnit &cu, Partitioner &partitioner, CUCtx& cuCtx )

{

  CodingStructure& cs = *cu.cs;

  DTRACE( g_trace_ctx, D_SYNTAX, "coding_unit() treeType=%d modeType=%d\n", cu.treeType(), cu.modeType() );

  // skip flag

  if( !m_slice->isIntra() || cs.sps->getIBCFlag() )

  {

    if( cu.Y().valid() )

    {

      cu_skip_flag( cu );

    }

    // skip data

    if( cu.skip() )

    {

      cu.setColorTransform( false );

      cs.addEmptyTUs      ( partitioner, cu );

      MergeCtx              mrgCtx;

      prediction_unit     ( cu );

      return end_of_ctu   ( cu, cuCtx );

    }

    else

    {