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

The copyright in this software is being made available under the Clear BSD

License, included below. No patent rights, trademark rights and/or 

other Intellectual Property Rights other than the copyrights concerning 

the Software are granted under this license.

The Clear BSD License

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

All rights reserved.

Redistribution and use in source and binary forms, with or without modification,

are permitted (subject to the limitations in the disclaimer below) provided that

the following conditions are met:

     * Redistributions of source code must retain the above copyright notice,

     this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above copyright

     notice, this list of conditions and the following disclaimer in the

     documentation and/or other materials provided with the distribution.

     * Neither the name of the copyright holder nor the names of its

     contributors may be used to endorse or promote products derived from this

     software without specific prior written permission.

NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY

THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER

IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

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

#include "DepQuant.h"

#include "TrQuant.h"

#include "CodingStructure.h"

#include "UnitTools.h"

#include <bitset>

//! \ingroup CommonLib

//! \{

namespace vvenc {

namespace DQIntern

{

  void Rom::xInitScanArrays()

  {

    if( m_scansInitialized )

    {

      return;

    }

    ::memset( m_scanId2NbInfoSbbArray, 0, sizeof(m_scanId2NbInfoSbbArray) );

    ::memset( m_scanId2NbInfoOutArray, 0, sizeof(m_scanId2NbInfoOutArray) );

    ::memset( m_tuParameters,          0, sizeof(m_tuParameters) );

    uint32_t raster2id[ MAX_CU_SIZE * MAX_CU_SIZE ];

    ::memset(raster2id, 0, sizeof(raster2id));

    for( int hd = 0; hd < MAX_TU_SIZE_IDX; hd++ )

    {

      for( int vd = 0; vd < MAX_TU_SIZE_IDX; vd++ )

      {

        if( (hd == 0 && vd <= 1) || (hd <= 1 && vd == 0) )

        {

          continue;

        }

        const uint32_t      blockWidth    = (1 << hd);

        const uint32_t      blockHeight   = (1 << vd);

        const uint32_t      log2CGWidth   = g_log2SbbSize[hd][vd][0];

        const uint32_t      log2CGHeight  = g_log2SbbSize[hd][vd][1];

        const uint32_t      groupWidth    = 1 << log2CGWidth;

        const uint32_t      groupHeight   = 1 << log2CGHeight;

        const uint32_t      groupSize     = groupWidth * groupHeight;

        const SizeType      blkWidthIdx   = Log2( blockWidth );

        const SizeType      blkHeightIdx  = Log2( blockHeight );

        const ScanElement * scanId2RP     = getScanOrder( SCAN_GROUPED_4x4, blkWidthIdx, blkHeightIdx );

        NbInfoSbb*&         sId2NbSbb     = m_scanId2NbInfoSbbArray[hd][vd];

        NbInfoOut*&         sId2NbOut     = m_scanId2NbInfoOutArray[hd][vd];

        // consider only non-zero-out region

        const uint32_t      blkWidthNZOut = std::min<unsigned>( JVET_C0024_ZERO_OUT_TH, blockWidth  );

        const uint32_t      blkHeightNZOut= std::min<unsigned>( JVET_C0024_ZERO_OUT_TH, blockHeight );

        const uint32_t      totalValues   = blkWidthNZOut * blkHeightNZOut;

        sId2NbSbb = new NbInfoSbb[ totalValues ];

        sId2NbOut = new NbInfoOut[ totalValues ];

        for( uint32_t scanId = 0; scanId < totalValues; scanId++ )

        {

          raster2id[scanId2RP[scanId].idx] = scanId;

          sId2NbSbb[scanId].numInv = 0;

        }

        for( unsigned scanId = 0; scanId < totalValues; scanId++ )

        {

          const int posX = scanId2RP[scanId].x;

          const int posY = scanId2RP[scanId].y;

          const int rpos = scanId2RP[scanId].idx;

          {

            //===== inside subband neighbours =====

            const int      begSbb = scanId - ( scanId & (groupSize-1) ); // first pos in current subblock

            int            cpos[5];

            cpos[0] = ( posX + 1 < blkWidthNZOut                              ? ( raster2id[rpos+1           ] < groupSize + begSbb ? raster2id[rpos+1           ] - begSbb : 0 ) : 0 );

            cpos[1] = ( posX + 2 < blkWidthNZOut                              ? ( raster2id[rpos+2           ] < groupSize + begSbb ? raster2id[rpos+2           ] - begSbb : 0 ) : 0 );

            cpos[2] = ( posX + 1 < blkWidthNZOut && posY + 1 < blkHeightNZOut ? ( raster2id[rpos+1+blockWidth] < groupSize + begSbb ? raster2id[rpos+1+blockWidth] - begSbb : 0 ) : 0 );

            cpos[3] = ( posY + 1 < blkHeightNZOut                             ? ( raster2id[rpos+  blockWidth] < groupSize + begSbb ? raster2id[rpos+  blockWidth] - begSbb : 0 ) : 0 );

            cpos[4] = ( posY + 2 < blkHeightNZOut                             ? ( raster2id[rpos+2*blockWidth] < groupSize + begSbb ? raster2id[rpos+2*blockWidth] - begSbb : 0 ) : 0 );

            int num = 0;

            int inPos[5] = { 0, };

            while( true )

            {

              int nk = -1;

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

              {

                if( cpos[k] != 0 && ( nk < 0 || cpos[k] < cpos[nk] ) )

                {

                  nk = k;

                }

              }

              if( nk < 0 )

              {

                break;

              }

              inPos[ num++ ] = uint8_t( cpos[nk] );

              cpos[nk] = 0;

            }

            for( int k = num; k < 5; k++ )

            {

              inPos[k] = 0;

            }

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

            {

              CHECK( sId2NbSbb[begSbb + inPos[k]].numInv >= 5, "" );

              sId2NbSbb[begSbb + inPos[k]].invInPos[sId2NbSbb[begSbb + inPos[k]].numInv++] = scanId & ( groupSize - 1 );

            }

          }

          {

            //===== outside subband neighbours =====

            NbInfoOut&     nbOut  = sId2NbOut[ scanId ];

            const int      begSbb = scanId - ( scanId & (groupSize-1) ); // first pos in current subblock

            int            cpos[5];

            cpos[0] = ( posX + 1 < blkWidthNZOut                              ? ( raster2id[rpos+1           ] >= groupSize + begSbb ? raster2id[rpos+1           ] : 0 ) : 0 );

            cpos[1] = ( posX + 2 < blkWidthNZOut                              ? ( raster2id[rpos+2           ] >= groupSize + begSbb ? raster2id[rpos+2           ] : 0 ) : 0 );

            cpos[2] = ( posX + 1 < blkWidthNZOut && posY + 1 < blkHeightNZOut ? ( raster2id[rpos+1+blockWidth] >= groupSize + begSbb ? raster2id[rpos+1+blockWidth] : 0 ) : 0 );

            cpos[3] = ( posY + 1 < blkHeightNZOut                             ? ( raster2id[rpos+  blockWidth] >= groupSize + begSbb ? raster2id[rpos+  blockWidth] : 0 ) : 0 );

            cpos[4] = ( posY + 2 < blkHeightNZOut                             ? ( raster2id[rpos+2*blockWidth] >= groupSize + begSbb ? raster2id[rpos+2*blockWidth] : 0 ) : 0 );

            for( nbOut.num = 0; true; )

            {

              int nk = -1;

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

              {

                if( cpos[k] != 0 && ( nk < 0 || cpos[k] < cpos[nk] ) )

                {

                  nk = k;

                }

              }

              if( nk < 0 )

              {

                break;

              }

              nbOut.outPos[ nbOut.num++ ] = uint16_t( cpos[nk] );

              cpos[nk] = 0;

            }

            for( int k = nbOut.num; k < 5; k++ )

            {

              nbOut.outPos[k] = 0;

            }

            nbOut.maxDist = ( scanId == 0 ? 0 : sId2NbOut[scanId-1].maxDist );

            for( int k = 0; k < nbOut.num; k++ )

            {

              if( nbOut.outPos[k] > nbOut.maxDist )

              {

                nbOut.maxDist = nbOut.outPos[k];

              }

            }

          }

        }

        // make it relative

        for( unsigned scanId = 0; scanId < totalValues; scanId++ )

        {

          NbInfoOut& nbOut  = sId2NbOut[scanId];

          const int  begSbb = scanId - ( scanId & (groupSize-1) ); // first pos in current subblock

          for( int k = 0; k < nbOut.num; k++ )

          {

            CHECK(begSbb > nbOut.outPos[k], "Position must be past sub block begin");

            nbOut.outPos[k] -= begSbb;

          }

          nbOut.maxDist -= scanId;

        }

        for( int chId = 0; chId < MAX_NUM_CH; chId++ )

        {

          m_tuParameters[hd][vd][chId] = new TUParameters( *this, blockWidth, blockHeight, ChannelType(chId) );

        }

      }

    }

    m_scansInitialized = true;

  }

  void Rom::xUninitScanArrays()

  {

    if( !m_scansInitialized )

    {

      return;

    }

    for( int hd = 0; hd < MAX_TU_SIZE_IDX; hd++ )

    {

      for( int vd = 0; vd < MAX_TU_SIZE_IDX; vd++ )

      {

        NbInfoSbb*& sId2NbSbb = m_scanId2NbInfoSbbArray[hd][vd];

        NbInfoOut*& sId2NbOut = m_scanId2NbInfoOutArray[hd][vd];

        if( sId2NbSbb )

        {

          delete [] sId2NbSbb;

        }

        if( sId2NbOut )

        {

          delete [] sId2NbOut;

        }

        for( int chId = 0; chId < MAX_NUM_CH; chId++ )

        {

          TUParameters*& tuPars = m_tuParameters[hd][vd][chId];

          if( tuPars )

          {

            delete tuPars;

          }

        }

      }

    }

    m_scansInitialized = false;

  }

  TUParameters::TUParameters( const Rom& rom, const unsigned width, const unsigned height, const ChannelType chType )

  {

    m_chType              = chType;

    m_width               = width;

    m_height              = height;

    const uint32_t nonzeroWidth  = std::min<uint32_t>(JVET_C0024_ZERO_OUT_TH, m_width);

    const uint32_t nonzeroHeight = std::min<uint32_t>(JVET_C0024_ZERO_OUT_TH, m_height);

    m_numCoeff                   = nonzeroWidth * nonzeroHeight;

    m_log2SbbWidth        = g_log2SbbSize[ Log2(m_width) ][ Log2(m_height) ][0];

    m_log2SbbHeight       = g_log2SbbSize[ Log2(m_width) ][ Log2(m_height) ][1];

    m_log2SbbSize         = m_log2SbbWidth + m_log2SbbHeight;

    m_sbbSize             = ( 1 << m_log2SbbSize );

    m_sbbMask             = m_sbbSize - 1;

    m_widthInSbb  = nonzeroWidth >> m_log2SbbWidth;

    m_heightInSbb = nonzeroHeight >> m_log2SbbHeight;

    m_numSbb              = m_widthInSbb * m_heightInSbb;

    SizeType        hsbb  = Log2( m_widthInSbb  );

    SizeType        vsbb  = Log2( m_heightInSbb );

    SizeType        hsId  = Log2( m_width  );

    SizeType        vsId  = Log2( m_height );

    m_scanSbbId2SbbPos    = getScanOrder( SCAN_UNGROUPED   , hsbb , vsbb );

    m_scanId2BlkPos       = getScanOrder( SCAN_GROUPED_4x4 , hsId , vsId );

    int log2W             = Log2( m_width  );

    int log2H             = Log2( m_height );

    m_scanId2NbInfoSbb    = rom.getNbInfoSbb( log2W, log2H );

    m_scanId2NbInfoOut    = rom.getNbInfoOut( log2W, log2H );

    m_scanInfo            = new ScanInfo[ m_numCoeff ];

    for( int scanIdx = 0; scanIdx < m_numCoeff; scanIdx++ )

    {

      xSetScanInfo( m_scanInfo[scanIdx], scanIdx );

    }

  }

  void TUParameters::xSetScanInfo( ScanInfo& scanInfo, int scanIdx )

  {

    scanInfo.sbbSize    = m_sbbSize;

    scanInfo.numSbb     = m_numSbb;

    scanInfo.scanIdx    = scanIdx;

    scanInfo.rasterPos  = m_scanId2BlkPos[scanIdx].idx;

    scanInfo.sbbPos     = m_scanSbbId2SbbPos[scanIdx >> m_log2SbbSize].idx;

    scanInfo.insidePos  = scanIdx & m_sbbMask;

    scanInfo.spt        = SCAN_ISCSBB;

    if(  scanInfo.insidePos == m_sbbMask && scanIdx > scanInfo.sbbSize && scanIdx < m_numCoeff - 1 )

      scanInfo.spt      = SCAN_SOCSBB;

    else if( scanInfo.insidePos == 0 && scanIdx > 0 && scanIdx < m_numCoeff - m_sbbSize )

      scanInfo.spt      = SCAN_EOCSBB;

    scanInfo.posX = m_scanId2BlkPos[scanIdx].x;

    scanInfo.posY = m_scanId2BlkPos[scanIdx].y;

    if( scanIdx )

    {

      const int nextScanIdx = scanIdx - 1;

      const int diag        = m_scanId2BlkPos[nextScanIdx].x + m_scanId2BlkPos[nextScanIdx].y;

      if( m_chType == CH_L )

      {

        scanInfo.sigCtxOffsetNext = ( diag < 2 ? 8 : diag < 5 ?  4 : 0 );

        scanInfo.gtxCtxOffsetNext = ( diag < 1 ? 16 : diag < 3 ? 11 : diag < 10 ? 6 : 1 );

      }

      else

      {

        scanInfo.sigCtxOffsetNext = ( diag < 2 ? 4 : 0 );

        scanInfo.gtxCtxOffsetNext = ( diag < 1 ? 6 : 1 );

      }

      scanInfo.nextInsidePos      = nextScanIdx & m_sbbMask;

      scanInfo.currNbInfoSbb      = m_scanId2NbInfoSbb[ scanIdx ];

      if( scanInfo.insidePos == 0 )

      {

        const int nextSbbPos  = m_scanSbbId2SbbPos[nextScanIdx >> m_log2SbbSize].idx;

        const int nextSbbPosY = nextSbbPos               / m_widthInSbb;

        const int nextSbbPosX = nextSbbPos - nextSbbPosY * m_widthInSbb;

        scanInfo.nextSbbRight = ( nextSbbPosX < m_widthInSbb  - 1 ? nextSbbPos + 1            : 0 );

        scanInfo.nextSbbBelow = ( nextSbbPosY < m_heightInSbb - 1 ? nextSbbPos + m_widthInSbb : 0 );

      }

    }

  }

  void RateEstimator::initCtx( const TUParameters& tuPars, const TransformUnit& tu, const ComponentID compID, const FracBitsAccess& fracBitsAccess )

  {

    m_scanId2Pos = tuPars.m_scanId2BlkPos;

    xSetSigSbbFracBits  ( fracBitsAccess, tuPars.m_chType );

    xSetSigFlagBits     ( fracBitsAccess, tuPars.m_chType );

    xSetGtxFlagBits     ( fracBitsAccess, tuPars.m_chType );

    xSetLastCoeffOffset ( fracBitsAccess, tuPars, tu, compID );

  }

  void RateEstimator::xSetLastCoeffOffset( const FracBitsAccess& fracBitsAccess, const TUParameters& tuPars, const TransformUnit& tu, const ComponentID compID )

  {

    const ChannelType chType = ( compID == COMP_Y ? CH_L : CH_C );

    int32_t cbfDeltaBits = 0;

    if( compID == COMP_Y && !CU::isIntra(*tu.cu) && !tu.depth )

    {

      const BinFracBits bits  = fracBitsAccess.getFracBitsArray( Ctx::QtRootCbf() );

      cbfDeltaBits            = int32_t( bits.intBits[1] ) - int32_t( bits.intBits[0] );

    }

    else

    {

      BinFracBits bits;

      bool prevLumaCbf           = false;

      bool lastCbfIsInferred     = false;

      bool useIntraSubPartitions = tu.cu->ispMode && isLuma(chType);

      if( useIntraSubPartitions )

      {

        bool rootCbfSoFar = false;

        bool isLastSubPartition = CU::isISPLast(*tu.cu, tu.Y(), compID);

        uint32_t nTus = tu.cu->ispMode == HOR_INTRA_SUBPARTITIONS ? tu.cu->lheight() >> Log2(tu.lheight()) : tu.cu->lwidth() >> Log2(tu.lwidth());

        if( isLastSubPartition )

        {

          TransformUnit* tuPointer = tu.cu->firstTU;

          for( int tuIdx = 0; tuIdx < nTus - 1; tuIdx++ )

          {

            rootCbfSoFar |= TU::getCbfAtDepth(*tuPointer, COMP_Y, tu.depth);

            tuPointer     = tuPointer->next;

          }

          if( !rootCbfSoFar )

          {

            lastCbfIsInferred = true;

          }

        }

        if( !lastCbfIsInferred )

        {

          prevLumaCbf = TU::getPrevTuCbfAtDepth(tu, compID, tu.depth);

        }

        bits = fracBitsAccess.getFracBitsArray(Ctx::QtCbf[compID](DeriveCtx::CtxQtCbf(compID, prevLumaCbf, true)));

      }

      else

      {

        bits = fracBitsAccess.getFracBitsArray(Ctx::QtCbf[compID](DeriveCtx::CtxQtCbf(compID, tu.cbf[COMP_Cb])));

      }

      cbfDeltaBits = lastCbfIsInferred ? 0 : int32_t(bits.intBits[1]) - int32_t(bits.intBits[0]);

    }

    static const unsigned prefixCtx[] = { 0, 0, 0, 3, 6, 10, 15, 21 };

    uint32_t              ctxBits  [ LAST_SIGNIFICANT_GROUPS ];

    for( unsigned xy = 0; xy < 2; xy++ )

    {

      int32_t             bitOffset   = ( xy ? cbfDeltaBits : 0 );

      int32_t*            lastBits    = ( xy ? m_lastBitsY : m_lastBitsX );

      const unsigned      size        = ( xy ? tuPars.m_height : tuPars.m_width );

      const unsigned      log2Size    = Log2( size );

      const bool          useYCtx     = ( xy != 0 );

      const CtxSet&       ctxSetLast  = ( useYCtx ? Ctx::LastY : Ctx::LastX )[ chType ];

      const unsigned      lastShift   = ( compID == COMP_Y ? (log2Size+1)>>2 : Clip3<unsigned>(0,2,size>>3) );

      const unsigned      lastOffset  = ( compID == COMP_Y ? ( prefixCtx[log2Size] ) : 0 );

      uint32_t            sumFBits    = 0;

      unsigned            maxCtxId    = g_uiGroupIdx[std::min<unsigned>(JVET_C0024_ZERO_OUT_TH, size) - 1];

      for( unsigned ctxId = 0; ctxId < maxCtxId; ctxId++ )

      {

        const BinFracBits bits  = fracBitsAccess.getFracBitsArray( ctxSetLast( lastOffset + ( ctxId >> lastShift ) ) );

        ctxBits[ ctxId ]        = sumFBits + bits.intBits[0] + ( ctxId>3 ? ((ctxId-2)>>1)<<SCALE_BITS : 0 ) + bitOffset;

        sumFBits               +=            bits.intBits[1];

      }

      ctxBits  [ maxCtxId ]     = sumFBits + ( maxCtxId>3 ? ((maxCtxId-2)>>1)<<SCALE_BITS : 0 ) + bitOffset;

      for (unsigned pos = 0; pos < std::min<unsigned>(JVET_C0024_ZERO_OUT_TH, size); pos++)

      {

        lastBits[ pos ]         = ctxBits[ g_uiGroupIdx[ pos ] ];

      }

    }

  }

  void RateEstimator::xSetSigSbbFracBits( const FracBitsAccess& fracBitsAccess, ChannelType chType )

  {

    const CtxSet& ctxSet = Ctx::SigCoeffGroup[ chType ];

    for( unsigned ctxId = 0; ctxId < sm_maxNumSigSbbCtx; ctxId++ )

    {

      m_sigSbbFracBits[ ctxId ] = fracBitsAccess.getFracBitsArray( ctxSet( ctxId ) );

    }

  }

  void RateEstimator::xSetSigFlagBits( const FracBitsAccess& fracBitsAccess, ChannelType chType )

  {

    for( unsigned ctxSetId = 0; ctxSetId < sm_numCtxSetsSig; ctxSetId++ )

    {

      BinFracBits*    bits    = m_sigFracBits [ ctxSetId ];

      const CtxSet&   ctxSet  = Ctx::SigFlag  [ chType + 2*ctxSetId ];

      const unsigned  numCtx  = ( chType == CH_L ? 12 : 8 );

      for( unsigned ctxId = 0; ctxId < numCtx; ctxId++ )

      {

        bits[ ctxId ] = fracBitsAccess.getFracBitsArray( ctxSet( ctxId ) );

      }

    }

  }

  void RateEstimator::xSetGtxFlagBits( const FracBitsAccess& fracBitsAccess, ChannelType chType )

  {

    const CtxSet&   ctxSetPar   = Ctx::ParFlag [     chType ];

    const CtxSet&   ctxSetGt1   = Ctx::GtxFlag [ 2 + chType ];

    const CtxSet&   ctxSetGt2   = Ctx::GtxFlag [     chType ];

    const unsigned  numCtx      = ( chType == CH_L ? 21 : 11 );

    for( unsigned ctxId = 0; ctxId < numCtx; ctxId++ )

    {

      BinFracBits     fbPar = fracBitsAccess.getFracBitsArray( ctxSetPar( ctxId ) );

      BinFracBits     fbGt1 = fracBitsAccess.getFracBitsArray( ctxSetGt1( ctxId ) );

      BinFracBits     fbGt2 = fracBitsAccess.getFracBitsArray( ctxSetGt2( ctxId ) );

      CoeffFracBits&  cb    = m_gtxFracBits[ ctxId ];

      int32_t         par0  = (1<<SCALE_BITS) + int32_t(fbPar.intBits[0]);

      int32_t         par1  = (1<<SCALE_BITS) + int32_t(fbPar.intBits[1]);

      cb.bits[0] = 0;

      cb.bits[1] = fbGt1.intBits[0] + (1 << SCALE_BITS);

      cb.bits[2] = fbGt1.intBits[1] + par0 + fbGt2.intBits[0];

      cb.bits[3] = fbGt1.intBits[1] + par1 + fbGt2.intBits[0];

      cb.bits[4] = fbGt1.intBits[1] + par0 + fbGt2.intBits[1];

      cb.bits[5] = fbGt1.intBits[1] + par1 + fbGt2.intBits[1];

    }

  }

  void CommonCtx::update( const ScanInfo& scanInfo, const int prevId, int stateId, StateMem& curr )

  {

    uint8_t*    sbbFlags  = m_currSbbCtx[stateId].sbbFlags;

    uint8_t*    levels    = m_currSbbCtx[stateId].levels;

    uint16_t    maxDist   = m_nbInfo[scanInfo.scanIdx - 1].maxDist;

    uint16_t    sbbSize   = scanInfo.sbbSize;

    std::size_t setCpSize = ( maxDist > sbbSize ? maxDist - sbbSize : 0 ) * sizeof( uint8_t );

    if( prevId >= 0 )

    {

      ::memcpy( sbbFlags, m_prevSbbCtx[prevId].sbbFlags, scanInfo.numSbb * sizeof( uint8_t ) );

      ::memcpy( levels + scanInfo.scanIdx + sbbSize, m_prevSbbCtx[prevId].levels + scanInfo.scanIdx + sbbSize, setCpSize );

    }

    else

    {

      ::memset( sbbFlags, 0, scanInfo.numSbb * sizeof( uint8_t ) );

      ::memset( levels + scanInfo.scanIdx + sbbSize, 0, setCpSize );

    }

    sbbFlags[scanInfo.sbbPos] = !!curr.numSig[stateId];

    const int       sigNSbb = ( ( scanInfo.nextSbbRight ? sbbFlags[scanInfo.nextSbbRight] : false ) || ( scanInfo.nextSbbBelow ? sbbFlags[scanInfo.nextSbbBelow] : false ) ? 1 : 0 );

    curr.refSbbCtxId[stateId] = stateId;

    const BinFracBits sbbBits = m_sbbFlagBits[sigNSbb];

    curr.sbbBits0[stateId] = sbbBits.intBits[0];

    curr.sbbBits1[stateId] = sbbBits.intBits[1];

    if( sigNSbb || ( ( scanInfo.nextSbbRight && scanInfo.nextSbbBelow ) ? sbbFlags[scanInfo.nextSbbBelow + 1] : false ) )

    {

      const int         scanBeg = scanInfo.scanIdx - scanInfo.sbbSize;

      const NbInfoOut* nbOut = m_nbInfo + scanBeg;

      const uint8_t* absLevels = levels + scanBeg;

      for( int id = 0; id < scanInfo.sbbSize; id++, nbOut++ )

      {

        if( nbOut->num )

        {

          TCoeff sumAbs = 0, sumAbs1 = 0, sumNum = 0;

#define UPDATE(k) {TCoeff t=absLevels[nbOut->outPos[k]]; sumAbs+=t; sumAbs1+=std::min<TCoeff>(4+(t&1),t); sumNum+=!!t; }

          switch( nbOut->num )

          {

          default:

          case 5:

            UPDATE( 4 );

          case 4:

            UPDATE( 3 );

          case 3:

            UPDATE( 2 );

          case 2:

            UPDATE( 1 );

          case 1:

            UPDATE( 0 );

          }

#undef UPDATE

          curr.tplAcc[id][stateId] = ( sumNum << 5 ) | sumAbs1;

          curr.sum1st[id][stateId] = ( uint8_t ) std::min( 255, sumAbs );

        }

      }

    }

  }

  void Quantizer::initQuantBlock(const TransformUnit& tu, const ComponentID compID, const QpParam& cQP, const double lambda, int gValue)

  {

    CHECKD( lambda <= 0.0, "Lambda must be greater than 0" );

    const int         qpDQ                  = cQP.Qp(tu.mtsIdx[compID]==MTS_SKIP) + 1;

    const int         qpPer                 = qpDQ / 6;

    const int         qpRem                 = qpDQ - 6 * qpPer;

    const SPS&        sps                   = *tu.cs->sps;

    const CompArea&   area                  = tu.blocks[ compID ];

    const ChannelType chType                = toChannelType( compID );

    const int         channelBitDepth       = sps.bitDepths[ chType ];

    const int         maxLog2TrDynamicRange = sps.getMaxLog2TrDynamicRange();

    const int         nomTransformShift     = getTransformShift( channelBitDepth, area.size(), maxLog2TrDynamicRange );

    const bool    needsSqrt2ScaleAdjustment = TU::needsSqrt2Scale(tu, compID);

    const int         transformShift        = nomTransformShift + (needsSqrt2ScaleAdjustment?-1:0);

    // quant parameters

    m_QShift                    = QUANT_SHIFT  - 1 + qpPer + transformShift;

    m_QAdd                      = -( ( 3 << m_QShift ) >> 1 );

    Intermediate_Int  invShift  = IQUANT_SHIFT + 1 - qpPer - transformShift;

    m_QScale                    = g_quantScales[needsSqrt2ScaleAdjustment?1:0][ qpRem ];

    const unsigned    qIdxBD    = std::min<unsigned>( maxLog2TrDynamicRange + 1, 8*sizeof(Intermediate_Int) + invShift - IQUANT_SHIFT - 1 );

    m_maxQIdx                   = ( 1 << (qIdxBD-1) ) - 4;

    if( m_QShift )

      m_thresLast               = TCoeff((int64_t(m_DqThrVal) << (m_QShift-1)));

    else

      m_thresLast               = TCoeff((int64_t(m_DqThrVal>>1) << m_QShift));

    m_thresSSbb                 = TCoeff((int64_t(3) << m_QShift));

    // distortion calculation parameters

    const int64_t qScale        = (gValue==-1) ? m_QScale : gValue;

    const int nomDShift =

      SCALE_BITS - 2 * (nomTransformShift + DISTORTION_PRECISION_ADJUSTMENT(channelBitDepth)) + m_QShift + (needsSqrt2ScaleAdjustment ? 1 : 0);

    const double  qScale2       = double( qScale * qScale );

    const double  nomDistFactor = ( nomDShift < 0 ? 1.0/(double(int64_t(1)<<(-nomDShift))*qScale2*lambda) : double(int64_t(1)<<nomDShift)/(qScale2*lambda) );

    const uint32_t pow2dfShift   = (uint32_t)( nomDistFactor * qScale2 ) + 1;

    const int     dfShift       = ceilLog2( pow2dfShift );

    m_DistShift                 = 62 + m_QShift - 2*maxLog2TrDynamicRange - dfShift;

    m_DistAdd                   = (int64_t(1) << m_DistShift) >> 1;

    m_DistStepAdd               = ((m_DistShift+m_QShift)>=64 ? (int64_t)( nomDistFactor * pow(2,m_DistShift+m_QShift) + .5 ) : (int64_t)( nomDistFactor * double(int64_t(1)<<(m_DistShift+m_QShift)) + .5 ));

    m_DistOrgFact               = (int64_t)( nomDistFactor * double(int64_t(1)<<(m_DistShift+1       )) + .5 );

  }

  void Quantizer::dequantBlock( const TransformUnit& tu, const ComponentID compID, const QpParam& cQP, CoeffBuf& recCoeff, bool enableScalingLists, int* piDequantCoef) const

  {

    //----- set basic parameters -----

    const CompArea&     area      = tu.blocks[ compID ];

    const int           numCoeff  = area.area();

    const SizeType      hsId      = Log2( area.width );

    const SizeType      vsId      = Log2( area.height );

    const ScanElement  *scan      = getScanOrder( SCAN_GROUPED_4x4, hsId, vsId );

    const TCoeffSig*    qCoeff    = tu.getCoeffs( compID ).buf;

          TCoeff*       tCoeff    = recCoeff.buf;

    //----- reset coefficients and get last scan index -----

    ::memset( tCoeff, 0, numCoeff * sizeof( TCoeff ) );

    int lastScanIdx = tu.lastPos[compID];

    if( lastScanIdx < 0 )

    {

      return;

    }

    //----- set dequant parameters -----

    const int         qpDQ                  = cQP.Qp(tu.mtsIdx[compID]==MTS_SKIP) + 1;

    const int         qpPer                 = qpDQ / 6;

    const int         qpRem                 = qpDQ - 6 * qpPer;

    const SPS&        sps                   = *tu.cs->sps;

    const ChannelType chType                = toChannelType( compID );

    const int         channelBitDepth       = sps.bitDepths[ chType ];

    const int         maxLog2TrDynamicRange = sps.getMaxLog2TrDynamicRange();

    const TCoeff      minTCoeff             = -( 1 << maxLog2TrDynamicRange );

    const TCoeff      maxTCoeff             =  ( 1 << maxLog2TrDynamicRange ) - 1;

    const int         nomTransformShift     = getTransformShift( channelBitDepth, area.size(), maxLog2TrDynamicRange );

    const bool    needsSqrt2ScaleAdjustment = TU::needsSqrt2Scale(tu, compID);

    const int         transformShift        = nomTransformShift + (needsSqrt2ScaleAdjustment?-1:0);

    Intermediate_Int  shift                 = IQUANT_SHIFT + 1 - qpPer - transformShift + (enableScalingLists ? LOG2_SCALING_LIST_NEUTRAL_VALUE : 0);

    Intermediate_Int  invQScale             = g_invQuantScales[needsSqrt2ScaleAdjustment?1:0][ qpRem ];

    Intermediate_Int  add                   = (shift < 0) ? 0 : ((1 << shift) >> 1);

    //----- dequant coefficients -----

    for( int state = 0, scanIdx = lastScanIdx; scanIdx >= 0; scanIdx-- )

    {

      const unsigned   rasterPos = scan[scanIdx].idx;

      const TCoeffSig& level     = qCoeff[ rasterPos ];

      if( level )

      {

        if (enableScalingLists)

          invQScale = piDequantCoef[rasterPos];//scalingfactor*levelScale

        if (shift < 0 && (enableScalingLists || scanIdx == lastScanIdx))

        {

          invQScale <<= -shift;

        }

        Intermediate_Int qIdx = 2 * level + (level > 0 ? -(state>>1) : (state>>1));

        int64_t  nomTCoeff          = ((int64_t)qIdx * (int64_t)invQScale + add) >> ((shift < 0) ? 0 : shift);

        tCoeff[rasterPos]           = (TCoeff)Clip3<int64_t>(minTCoeff, maxTCoeff, nomTCoeff);

      }

      state = ( 32040 >> ((state<<2)+((level&1)<<1)) ) & 3;   // the 16-bit value "32040" represent the state transition table

    }

  }

  bool Quantizer::preQuantCoeff( const TCoeff absCoeff, PQData* pqData, int quanCoeff ) const

  {

    int64_t scaledOrg = int64_t( absCoeff ) * quanCoeff;

    TCoeff  qIdx      = TCoeff( ( scaledOrg + m_QAdd ) >> m_QShift );

    if( qIdx < 0 )

    {

      int64_t scaledAdd = m_DistStepAdd - scaledOrg * m_DistOrgFact;

      PQData& pq_a      = pqData[1];

      PQData& pq_b      = pqData[2];

      pq_a.deltaDist    = ( ( scaledAdd + 0 * m_DistStepAdd ) * 1 + m_DistAdd ) >> m_DistShift;

      pq_a.absLevel     = 1;

      pq_b.deltaDist    = ( ( scaledAdd + 1 * m_DistStepAdd ) * 2 + m_DistAdd ) >> m_DistShift;

      pq_b.absLevel     = 1;

      return true;

    }

    qIdx              = std::max<TCoeff>( 1, std::min<TCoeff>( m_maxQIdx, qIdx ) );

    int64_t scaledAdd = qIdx * m_DistStepAdd - scaledOrg * m_DistOrgFact;

    PQData& pq_a      = pqData[( qIdx + 0 ) & 3];

    PQData& pq_b      = pqData[( qIdx + 1 ) & 3];

    PQData& pq_c      = pqData[( qIdx + 2 ) & 3];

    PQData& pq_d      = pqData[( qIdx + 3 ) & 3];

    pq_a.deltaDist    = ( ( scaledAdd + 0 * m_DistStepAdd ) * ( qIdx + 0 ) + m_DistAdd ) >> m_DistShift;

    pq_a.absLevel     = ( qIdx + 1 ) >> 1;

    pq_b.deltaDist    = ( ( scaledAdd + 1 * m_DistStepAdd ) * ( qIdx + 1 ) + m_DistAdd ) >> m_DistShift;

    pq_b.absLevel     = ( qIdx + 2 ) >> 1;

    pq_c.deltaDist    = ( ( scaledAdd + 2 * m_DistStepAdd ) * ( qIdx + 2 ) + m_DistAdd ) >> m_DistShift;

    pq_c.absLevel     = ( qIdx + 3 ) >> 1;

    pq_d.deltaDist    = ( ( scaledAdd + 3 * m_DistStepAdd ) * ( qIdx + 3 ) + m_DistAdd ) >> m_DistShift;

    pq_d.absLevel     = ( qIdx + 4 ) >> 1;

    return false;

  }

  const int32_t g_goRiceBits[4][RICEMAX] =

  {

    { 32768,  65536,  98304, 131072, 163840, 196608, 262144, 262144, 327680, 327680, 327680, 327680, 393216, 393216, 393216, 393216, 393216, 393216, 393216, 393216, 458752, 458752, 458752, 458752, 458752, 458752, 458752, 458752, 458752, 458752, 458752, 458752},

    { 65536,  65536,  98304,  98304, 131072, 131072, 163840, 163840, 196608, 196608, 229376, 229376, 294912, 294912, 294912, 294912, 360448, 360448, 360448, 360448, 360448, 360448, 360448, 360448, 425984, 425984, 425984, 425984, 425984, 425984, 425984, 425984},

    { 98304,  98304,  98304,  98304, 131072, 131072, 131072, 131072, 163840, 163840, 163840, 163840, 196608, 196608, 196608, 196608, 229376, 229376, 229376, 229376, 262144, 262144, 262144, 262144, 327680, 327680, 327680, 327680, 327680, 327680, 327680, 327680},

    {131072, 131072, 131072, 131072, 131072, 131072, 131072, 131072, 163840, 163840, 163840, 163840, 163840, 163840, 163840, 163840, 196608, 196608, 196608, 196608, 196608, 196608, 196608, 196608, 229376, 229376, 229376, 229376, 229376, 229376, 229376, 229376}

  };

  static inline void initStates( const int stateId, DQIntern::StateMem& state )

  {

    state.rdCost[stateId]         = DQIntern::rdCostInit;

    state.ctx.cff[stateId]        =  0;

    state.ctx.sig[stateId]        =  0;

    state.numSig[stateId]         =  0;

    state.refSbbCtxId[stateId]    = -1;

    state.remRegBins[stateId]     =  4;

    state.cffBitsCtxOffset        =  0;

    state.m_goRicePar[stateId]    =  0;

    state.m_goRiceZero[stateId]   =  0;

    state.sbbBits0[stateId]       =  0;

    state.sbbBits1[stateId]       =  0;

  }

  template<bool rrgEnsured = false>

  static inline void checkRdCosts( const int stateId, const DQIntern::ScanPosType spt, const DQIntern::PQData& pqDataA, const DQIntern::PQData& pqDataB, DQIntern::Decisions& decisions, int idxAZ, int idxB, const DQIntern::StateMem& state )

  {

    const int32_t* goRiceTab = DQIntern::g_goRiceBits[state.m_goRicePar[stateId]];

    int64_t         rdCostA = state.rdCost[stateId] + pqDataA.deltaDist;

    int64_t         rdCostB = state.rdCost[stateId] + pqDataB.deltaDist;

    int64_t         rdCostZ = state.rdCost[stateId];

    if( rrgEnsured || state.remRegBins[stateId] >= 4 )

    {

      const CoeffFracBits& cffBits = state.m_gtxFracBitsArray[state.ctx.cff[stateId]];

      const BinFracBits    sigBits = state.m_sigFracBitsArray[stateId][state.ctx.sig[stateId]];

      if( pqDataA.absLevel < 4 )

        rdCostA += cffBits.bits[pqDataA.absLevel];

      else

      {

        const unsigned value = ( pqDataA.absLevel - 4 ) >> 1;

        rdCostA += cffBits.bits[pqDataA.absLevel - ( value << 1 )] + goRiceTab[std::min<unsigned>( value, RICEMAX - 1 )];

      }

      if( pqDataB.absLevel < 4 )

        rdCostB += cffBits.bits[pqDataB.absLevel];

      else

      {

        const unsigned value = ( pqDataB.absLevel - 4 ) >> 1;

        rdCostB += cffBits.bits[pqDataB.absLevel - ( value << 1 )] + goRiceTab[std::min<unsigned>( value, RICEMAX - 1 )];

      }

      if( spt == SCAN_ISCSBB )

      {

        rdCostA += sigBits.intBits[1];

        rdCostB += sigBits.intBits[1];

        rdCostZ += sigBits.intBits[0];

      }

      else if( spt == SCAN_SOCSBB )

      {

        rdCostA += state.sbbBits1[stateId] + sigBits.intBits[1];

        rdCostB += state.sbbBits1[stateId] + sigBits.intBits[1];

        rdCostZ += state.sbbBits1[stateId] + sigBits.intBits[0];

      }

      else if( state.numSig[stateId] )

      {

        rdCostA += sigBits.intBits[1];

        rdCostB += sigBits.intBits[1];

        rdCostZ += sigBits.intBits[0];

      }

      else

      {

        rdCostZ = rdCostInit;

      }

    }

    else

    {

      rdCostA += ( 1 << SCALE_BITS ) + goRiceTab[pqDataA.absLevel <= state.m_goRiceZero[stateId] ? pqDataA.absLevel - 1 : std::min<int>( pqDataA.absLevel, RICEMAX - 1 )];

      rdCostB += ( 1 << SCALE_BITS ) + goRiceTab[pqDataB.absLevel <= state.m_goRiceZero[stateId] ? pqDataB.absLevel - 1 : std::min<int>( pqDataB.absLevel, RICEMAX - 1 )];

      rdCostZ += goRiceTab[state.m_goRiceZero[stateId]];

    }

    if( rdCostA < rdCostZ && rdCostA < decisions.rdCost[idxAZ] )

    {

      decisions.rdCost[idxAZ] = rdCostA;

      decisions.absLevel[idxAZ] = pqDataA.absLevel;

      decisions.prevId[idxAZ] = stateId;

    }

    else if( rdCostZ < decisions.rdCost[idxAZ] )

    {

      decisions.rdCost[idxAZ] = rdCostZ;

      decisions.absLevel[idxAZ] = 0;

      decisions.prevId[idxAZ] = stateId;

    }

    if( rdCostB < decisions.rdCost[idxB] )

    {

      decisions.rdCost[idxB] = rdCostB;

      decisions.absLevel[idxB] = pqDataB.absLevel;

      decisions.prevId[idxB] = stateId;

    }

  }

Unexecuted instantiation: DepQuant.cpp:void vvenc::DQIntern::checkRdCosts<true>(int, vvenc::DQIntern::ScanPosType, vvenc::DQIntern::PQData const&, vvenc::DQIntern::PQData const&, vvenc::DQIntern::Decisions&, int, int, vvenc::DQIntern::StateMem const&)

Unexecuted instantiation: DepQuant.cpp:void vvenc::DQIntern::checkRdCosts<false>(int, vvenc::DQIntern::ScanPosType, vvenc::DQIntern::PQData const&, vvenc::DQIntern::PQData const&, vvenc::DQIntern::Decisions&, int, int, vvenc::DQIntern::StateMem const&)

  void checkAllRdCosts( const DQIntern::ScanPosType spt, const DQIntern::PQData* pqData, DQIntern::Decisions& decisions, const DQIntern::StateMem& state )

  {

    checkRdCosts<true>( 0, spt, pqData[0], pqData[2], decisions, 0, 2, state );

    checkRdCosts<true>( 1, spt, pqData[0], pqData[2], decisions, 2, 0, state );

    checkRdCosts<true>( 2, spt, pqData[3], pqData[1], decisions, 1, 3, state );

    checkRdCosts<true>( 3, spt, pqData[3], pqData[1], decisions, 3, 1, state );

  }

  template<bool rrgEnsured = false>

  static void checkRdCostsOdd1( const int stateId, const ScanPosType spt, const int64_t deltaDist, Decisions& decisions, int idxA, int idxZ, const StateMem& state )

  {

    int64_t         rdCostA = state.rdCost[stateId] + deltaDist;

    int64_t         rdCostZ = state.rdCost[stateId];

    if( rrgEnsured || state.remRegBins[stateId] >= 4 )

    {

      const BinFracBits sigBits = state.m_sigFracBitsArray[stateId][state.ctx.sig[stateId]];

      rdCostA += state.cffBits1[state.ctx.cff[stateId]];

      if( spt == SCAN_ISCSBB )

      {

        rdCostA += sigBits.intBits[1];

        rdCostZ += sigBits.intBits[0];

      }

      else if( spt == SCAN_SOCSBB )

      {

        rdCostA += state.sbbBits1[stateId] + sigBits.intBits[1];

        rdCostZ += state.sbbBits1[stateId] + sigBits.intBits[0];

      }

      else if( state.numSig[stateId] )

      {

        rdCostA += sigBits.intBits[1];

        rdCostZ += sigBits.intBits[0];

      }

      else

      {

        rdCostZ = rdCostInit;

      }

    }

    else

    {

      const int32_t* goRiceTab = g_goRiceBits[state.m_goRicePar[stateId]];

      rdCostA += ( 1 << SCALE_BITS ) + goRiceTab[0];

      rdCostZ += goRiceTab[state.m_goRiceZero[stateId]];

    }

    if( rdCostA < decisions.rdCost[idxA] )

    {

      decisions.rdCost[idxA] = rdCostA;

      decisions.absLevel[idxA] = 1;

      decisions.prevId[idxA] = stateId;

    }

    if( rdCostZ < decisions.rdCost[idxZ] )

    {

      decisions.rdCost[idxZ] = rdCostZ;

      decisions.absLevel[idxZ] = 0;

      decisions.prevId[idxZ] = stateId;

    }

  }

Unexecuted instantiation: DepQuant.cpp:void vvenc::DQIntern::checkRdCostsOdd1<true>(int, vvenc::DQIntern::ScanPosType, long, vvenc::DQIntern::Decisions&, int, int, vvenc::DQIntern::StateMem const&)

Unexecuted instantiation: DepQuant.cpp:void vvenc::DQIntern::checkRdCostsOdd1<false>(int, vvenc::DQIntern::ScanPosType, long, vvenc::DQIntern::Decisions&, int, int, vvenc::DQIntern::StateMem const&)

  static void checkAllRdCostsOdd1( const DQIntern::ScanPosType spt, const int64_t pq_a_dist, const int64_t pq_b_dist, DQIntern::Decisions& decisions, const DQIntern::StateMem& state )

  {

    checkRdCostsOdd1<true>( 0, spt, pq_b_dist, decisions, 2, 0, state );

    checkRdCostsOdd1<true>( 1, spt, pq_b_dist, decisions, 0, 2, state );

    checkRdCostsOdd1<true>( 2, spt, pq_a_dist, decisions, 3, 1, state );

    checkRdCostsOdd1<true>( 3, spt, pq_a_dist, decisions, 1, 3, state );