Ticket #981: Fixes-for-handling-proper-RDOQTS-and-BDPCM-RDOQ.patch

source/Lib/CommonLib/QuantRDOQ.cpp

@@ -537 +537 @@
       {
         if( (tu.cu->bdpcmMode && isLuma(compID)) || (isChroma(compID) && tu.cu->bdpcmModeChroma ) )
         {
+#if QC_TS_RRC_RDOQ
+          if( tu.cs->slice->getTSResidualCodingDisabledFlag() )
+          {
+            forwardRRCRDPCM( tu, compID, pSrc, uiAbsSum, cQP, ctx );
+          }
+          else
+          {
+            forwardRDPCM( tu, compID, pSrc, uiAbsSum, cQP, ctx );
+          }
+#else
           forwardRDPCM( tu, compID, pSrc, uiAbsSum, cQP, ctx );
+#endif
         }
         else
         {
@@ -635 +646 @@
   memset( m_sigRateDelta, 0, sizeof( int    ) *  uiMaxNumCoeff );
   memset( m_deltaU,       0, sizeof( TCoeff ) *  uiMaxNumCoeff );
 
-
+#if QC_TS_RRC_RDOQ
+  const bool   isTransformSkip  = (tu.mtsIdx[compID] == MTS_SKIP);
+  const bool needSqrtAdjustment = isTransformSkip ? false : ( TU::needsBlockSizeTrafoScale( tu, compID ) );
+#else
   const bool needSqrtAdjustment= TU::needsBlockSizeTrafoScale( tu, compID );
   const bool   isTransformSkip = (tu.mtsIdx[compID] == MTS_SKIP);
+#endif
   const double *const pdErrScale = xGetErrScaleCoeffSL(scalingListType, uiLog2BlockWidth, uiLog2BlockHeight, cQP.rem(isTransformSkip));
   const int    *const piQCoef    = getQuantCoeff(scalingListType, cQP.rem(isTransformSkip), uiLog2BlockWidth, uiLog2BlockHeight);
 #if JVET_Q0346_SCALING_LIST_USED_IN_SH
@@ -652 +667 @@
   const bool   enableScalingLists = getUseScalingList(uiWidth, uiHeight, isTransformSkip, tu.cu->lfnstIdx > 0, disableSMForLFNST);
 #endif
   const int    defaultQuantisationCoefficient = g_quantScales[ needSqrtAdjustment ?1:0][cQP.rem(isTransformSkip)];
+#if QC_TS_RRC_RDOQ
+  double defaultErrorScale;
+  if( isTransformSkip )
+  {
+    defaultErrorScale = xGetErrScaleCoeff(needSqrtAdjustment, uiLog2BlockWidth, uiLog2BlockHeight, cQP.rem(isTransformSkip), maxLog2TrDynamicRange, channelBitDepth, isTransformSkip);
+  }
+  else
+  {
+    defaultErrorScale = xGetErrScaleCoeffNoScalingList(scalingListType, uiLog2BlockWidth, uiLog2BlockHeight, cQP.rem(isTransformSkip));
+  }
+  const int iQBits    = QUANT_SHIFT + cQP.per(isTransformSkip) + (isTransformSkip ? 0 : iTransformShift) + (needSqrtAdjustment ? -1 : 0);
+#else
   const double defaultErrorScale              = xGetErrScaleCoeffNoScalingList(scalingListType, uiLog2BlockWidth, uiLog2BlockHeight, cQP.rem(isTransformSkip));
   const int iQBits = QUANT_SHIFT + cQP.per(isTransformSkip) + iTransformShift + (needSqrtAdjustment?-1:0);                   // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits
-
+#endif
 
   const TCoeff entropyCodingMinimum = -(1 << maxLog2TrDynamicRange);
   const TCoeff entropyCodingMaximum =  (1 << maxLog2TrDynamicRange) - 1;
@@ -1413 +1440 @@
   }
 }
 
+#if QC_TS_RRC_RDOQ
+void QuantRDOQ::forwardRRCRDPCM(TransformUnit &tu, const ComponentID &compID, const CCoeffBuf &pSrc, TCoeff &uiAbsSum, const QpParam &cQP, const Ctx &ctx)
+{
+  const FracBitsAccess& fracBits = ctx.getFracBitsAcess();
+
+  const SPS &sps            = *tu.cs->sps;
+  const CompArea &rect      = tu.blocks[compID];
+  const uint32_t uiWidth    = rect.width;
+  const uint32_t uiHeight   = rect.height;
+  const ChannelType chType  = toChannelType(compID);
+  const int channelBitDepth = sps.getBitDepth( chType );
+
+  const bool extendedPrecision     = sps.getSpsRangeExtension().getExtendedPrecisionProcessingFlag();
+  const int  maxLog2TrDynamicRange = sps.getMaxLog2TrDynamicRange(chType);
+
+  const int  dirMode = isLuma(compID) ? tu.cu->bdpcmMode : tu.cu->bdpcmModeChroma;
+
+  // Represents scaling through forward transform
+  int iTransformShift = getTransformShift(channelBitDepth, rect.size(), maxLog2TrDynamicRange);
+
+  if (tu.mtsIdx[compID] == MTS_SKIP && extendedPrecision)
+  {
+    iTransformShift = std::max<int>(0, iTransformShift);
+  }
+
+  double     d64BlockUncodedCost               = 0;
+  const uint32_t uiLog2BlockWidth                  = floorLog2(uiWidth);
+  const uint32_t uiLog2BlockHeight                 = floorLog2(uiHeight);
+  const uint32_t uiMaxNumCoeff                     = rect.area();
+
+  CHECK(compID >= MAX_NUM_TBLOCKS, "Invalid component ID");
+
+  int scalingListType = getScalingListType(tu.cu->predMode, compID);
+
+  CHECK(scalingListType >= SCALING_LIST_NUM, "Invalid scaling list");
+
+// Rotate block
+  const uint32_t  numSamplesInBlock = uiWidth * uiHeight;
+
+  memset(m_srcCoeffTemp, 0, sizeof(TCoeff) * numSamplesInBlock);
+  memset(m_dstCoeffTemp, 0, sizeof(TCoeff) * numSamplesInBlock);
+
+  const uint32_t uiSizeMinus1 = (numSamplesInBlock)-1;
+  for (uint32_t y = 0, coefficientIndex = 0; y < uiHeight; y++)
+  {
+          for (uint32_t x = 0; x < uiWidth; x++, coefficientIndex++)
+          {
+                  m_srcCoeffTemp[coefficientIndex] = pSrc.buf[uiSizeMinus1 - coefficientIndex];
+          }
+  }
+  const TCoeff *plSrcCoeff = m_srcCoeffTemp;
+        TCoeff *piDstCoeff = tu.getCoeffs(compID).buf;
+
+  double *pdCostCoeff  = m_pdCostCoeff;
+  double *pdCostSig    = m_pdCostSig;
+  double *pdCostCoeff0 = m_pdCostCoeff0;
+  int    *rateIncUp    = m_rateIncUp;
+  int    *rateIncDown  = m_rateIncDown;
+  int    *sigRateDelta = m_sigRateDelta;
+  TCoeff *deltaU       = m_deltaU;
+
+  memset(piDstCoeff, 0, sizeof(*piDstCoeff) * uiMaxNumCoeff);
+  memset( m_pdCostCoeff,  0, sizeof( double ) *  uiMaxNumCoeff );
+  memset( m_pdCostSig,    0, sizeof( double ) *  uiMaxNumCoeff );
+  memset( m_rateIncUp,    0, sizeof( int    ) *  uiMaxNumCoeff );
+  memset( m_rateIncDown,  0, sizeof( int    ) *  uiMaxNumCoeff );
+  memset( m_sigRateDelta, 0, sizeof( int    ) *  uiMaxNumCoeff );
+  memset( m_deltaU,       0, sizeof( TCoeff ) *  uiMaxNumCoeff );
+  memset( m_fullCoeff,    0, sizeof(TCoeff)   *  uiMaxNumCoeff );
+
+  m_bdpcm = dirMode;
+
+  const bool   isTransformSkip  = (tu.mtsIdx[compID] == MTS_SKIP);
+  const bool needSqrtAdjustment = isTransformSkip ? false : ( TU::needsBlockSizeTrafoScale( tu, compID ) );
+
+  const int    defaultQuantisationCoefficient = g_quantScales[ needSqrtAdjustment ?1:0][cQP.rem(isTransformSkip)];
+
+ double defaultErrorScale;
+ if( isTransformSkip )
+ {
+   defaultErrorScale = xGetErrScaleCoeff(needSqrtAdjustment, uiLog2BlockWidth, uiLog2BlockHeight, cQP.rem(isTransformSkip), maxLog2TrDynamicRange, channelBitDepth, isTransformSkip);
+ }
+ else
+ {
+   defaultErrorScale = xGetErrScaleCoeffNoScalingList(scalingListType, uiLog2BlockWidth, uiLog2BlockHeight, cQP.rem(isTransformSkip));
+ }
+
+ const int iQBits    = QUANT_SHIFT + cQP.per(isTransformSkip) + (isTransformSkip ? 0 : iTransformShift) + (needSqrtAdjustment ? -1 : 0);
+
+  TrQuantParams trQuantParams;
+  trQuantParams.rightShift = (IQUANT_SHIFT - ((isTransformSkip ? 0 : iTransformShift) + cQP.per(isTransformSkip)));
+  trQuantParams.qScale     = g_invQuantScales[needSqrtAdjustment ? 1 : 0][cQP.rem(isTransformSkip)];
+
+  const TCoeff entropyCodingMaximum =  (1 << maxLog2TrDynamicRange) - 1;
+
+  CoeffCodingContext cctx(tu, compID, tu.cs->picHeader->getSignDataHidingEnabledFlag());
+
+  const int    iCGSizeM1      = (1 << cctx.log2CGSize()) - 1;
+
+  int     iCGLastScanPos      = -1;
+  double  d64BaseCost         = 0;
+  int     iLastScanPos        = -1;
+
+
+  int ctxBinSampleRatio   = (compID == COMPONENT_Y) ? MAX_TU_LEVEL_CTX_CODED_BIN_CONSTRAINT_LUMA : MAX_TU_LEVEL_CTX_CODED_BIN_CONSTRAINT_CHROMA;
+  int remRegBins          = (uiWidth * uiHeight * ctxBinSampleRatio) >> 4;
+
+  uint32_t  goRiceParam   = 0;
+
+  double *pdCostCoeffGroupSig = m_pdCostCoeffGroupSig;
+  memset( pdCostCoeffGroupSig, 0, ( uiMaxNumCoeff >> cctx.log2CGSize() ) * sizeof( double ) );
+  int iScanPos;
+  coeffGroupRDStats rdStats;
+
+#if ENABLE_TRACING
+  DTRACE( g_trace_ctx, D_RDOQ, "%d: %3d, %3d, %dx%d, comp=%d\n", DTRACE_GET_COUNTER( g_trace_ctx, D_RDOQ ), rect.x, rect.y, rect.width, rect.height, compID );
+#endif
+
+  const uint32_t lfnstIdx = tu.cu->lfnstIdx;
+
+  const int iCGNum = lfnstIdx > 0 ? 1 : std::min<int>(JVET_C0024_ZERO_OUT_TH, uiWidth) * std::min<int>(JVET_C0024_ZERO_OUT_TH, uiHeight) >> cctx.log2CGSize();
+
+  for (int subSetId = iCGNum - 1; subSetId >= 0; subSetId--)
+  {
+    cctx.initSubblock( subSetId );
+
+    uint32_t maxNonZeroPosInCG = iCGSizeM1;
+    if( lfnstIdx > 0 && ( ( uiWidth == 4 && uiHeight == 4 ) || ( uiWidth == 8 && uiHeight == 8 && cctx.cgPosX() == 0 && cctx.cgPosY() == 0 ) ) )
+    {
+      maxNonZeroPosInCG = 7;
+    }
+
+    memset( &rdStats, 0, sizeof (coeffGroupRDStats));
+
+
+    for( int iScanPosinCG = iCGSizeM1; iScanPosinCG > maxNonZeroPosInCG; iScanPosinCG-- )
+    {
+      iScanPos = cctx.minSubPos() + iScanPosinCG;
+      uint32_t    blkPos = cctx.blockPos( iScanPos );
+      piDstCoeff[ blkPos ] = 0;
+    }
+
+
+    for( int iScanPosinCG = maxNonZeroPosInCG; iScanPosinCG >= 0; iScanPosinCG-- )
+    {
+      iScanPos = cctx.minSubPos() + iScanPosinCG;
+      //===== quantization =====
+      uint32_t    uiBlkPos          = cctx.blockPos(iScanPos);
+
+            const int posX        = cctx.posX(iScanPos);
+      const int posY        = cctx.posY(iScanPos);
+      const int posS        = (1 == dirMode) ? posX : posY;
+            const int boundaryLim = (1 == dirMode) ? uiWidth-1 : uiHeight-1;
+            const int posNb       = (1 == dirMode) ? (posX + 1) + posY * pSrc.stride : posX + (posY + 1) * pSrc.stride;
+      TCoeff predCoeff      = (boundaryLim != posS) ? m_fullCoeff[posNb] : 0;
+
+      // set coeff
+      const int    quantisationCoefficient = defaultQuantisationCoefficient;
+      const double errorScale              = defaultErrorScale;
+
+            const int64_t  tmpLevel              = int64_t(abs(plSrcCoeff[ uiBlkPos ] - predCoeff)) * quantisationCoefficient;
+
+      const Intermediate_Int lLevelDouble  = (Intermediate_Int)std::min<int64_t>(tmpLevel, std::numeric_limits<Intermediate_Int>::max() - (Intermediate_Int(1) << (iQBits - 1)));
+
+      uint32_t uiMaxAbsLevel        = std::min<uint32_t>(uint32_t(entropyCodingMaximum), uint32_t((lLevelDouble + (Intermediate_Int(1) << (iQBits - 1))) >> iQBits));
+
+      const double dErr         = double( lLevelDouble );
+      pdCostCoeff0[ iScanPos ]  = dErr * dErr * errorScale;
+      d64BlockUncodedCost      += pdCostCoeff0[ iScanPos ];
+      piDstCoeff[ uiBlkPos ]    = uiMaxAbsLevel;
+
+
+      if ( uiMaxAbsLevel > 0 && iLastScanPos < 0 )
+      {
+        iLastScanPos            = iScanPos;
+        iCGLastScanPos          = cctx.subSetId();
+      }
+
+      if ( iLastScanPos >= 0 )
+      {
+#if ENABLE_TRACING
+        uint32_t uiCGPosY = cctx.cgPosX();
+        uint32_t uiCGPosX = cctx.cgPosY();
+        uint32_t uiPosY = cctx.posY( iScanPos );
+        uint32_t uiPosX = cctx.posX( iScanPos );
+        DTRACE( g_trace_ctx, D_RDOQ, "%d [%d][%d][%2d:%2d][%2d:%2d]", DTRACE_GET_COUNTER( g_trace_ctx, D_RDOQ ), iScanPos, uiBlkPos, uiCGPosX, uiCGPosY, uiPosX, uiPosY );
+#endif
+        //===== coefficient level estimation =====
+        unsigned ctxIdSig = 0;
+        if( iScanPos != iLastScanPos )
+        {
+          ctxIdSig = cctx.sigCtxIdAbs( iScanPos, piDstCoeff, 0 );
+        }
+
+
+                const uint8_t  sign = (plSrcCoeff[uiBlkPos] - predCoeff) < 0 ? 1 : 0;
+
+        uint32_t    uiLevel;
+        uint8_t ctxOffset     = cctx.ctxOffsetAbs     ();
+        uint32_t    uiParCtx      = cctx.parityCtxIdAbs   ( ctxOffset );
+        uint32_t    uiGt1Ctx      = cctx.greater1CtxIdAbs ( ctxOffset );
+        uint32_t    uiGt2Ctx      = cctx.greater2CtxIdAbs ( ctxOffset );
+        uint32_t    goRiceZero    = 0;
+        if( remRegBins < 4 )
+        {
+          unsigned  sumAbs = cctx.templateAbsSum( iScanPos, piDstCoeff, 0 );
+          goRiceParam             = g_auiGoRiceParsCoeff   [ sumAbs ];
+          goRiceZero              = g_auiGoRicePosCoeff0(0, goRiceParam);
+        }
+
+        const BinFracBits fracBitsPar = fracBits.getFracBitsArray( uiParCtx );
+        const BinFracBits fracBitsGt1 = fracBits.getFracBitsArray( uiGt1Ctx );
+        const BinFracBits fracBitsGt2 = fracBits.getFracBitsArray( uiGt2Ctx );
+
+        if( iScanPos == iLastScanPos )
+        {
+          uiLevel = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
+                                    lLevelDouble, uiMaxAbsLevel, nullptr, fracBitsPar, fracBitsGt1, fracBitsGt2, remRegBins, goRiceZero, goRiceParam, iQBits, errorScale, 1, extendedPrecision, maxLog2TrDynamicRange );
+        }
+        else
+        {
+          DTRACE_COND( ( uiMaxAbsLevel != 0 ), g_trace_ctx, D_RDOQ_MORE, " uiCtxSig=%d", ctxIdSig );
+
+          const BinFracBits fracBitsSig = fracBits.getFracBitsArray( ctxIdSig );
+          uiLevel = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
+                                    lLevelDouble, uiMaxAbsLevel, &fracBitsSig, fracBitsPar, fracBitsGt1, fracBitsGt2, remRegBins, goRiceZero, goRiceParam, iQBits, errorScale, 0, extendedPrecision, maxLog2TrDynamicRange );
+          sigRateDelta[ uiBlkPos ] = ( remRegBins < 4 ? 0 : fracBitsSig.intBits[1] - fracBitsSig.intBits[0] );
+        }
+
+        DTRACE( g_trace_ctx, D_RDOQ, " Lev=%d \n", uiLevel );
+        DTRACE_COND( ( uiMaxAbsLevel != 0 ), g_trace_ctx, D_RDOQ, " CostC0=%d\n", (int64_t)( pdCostCoeff0[iScanPos] ) );
+        DTRACE_COND( ( uiMaxAbsLevel != 0 ), g_trace_ctx, D_RDOQ, " CostC =%d\n", (int64_t)( pdCostCoeff[iScanPos] ) );
+
+        deltaU[ uiBlkPos ]        = TCoeff((lLevelDouble - (Intermediate_Int(uiLevel) << iQBits)) >> (iQBits-8));
+
+        if( uiLevel > 0 )
+        {
+          int rateNow              = xGetICRate( uiLevel,   fracBitsPar, fracBitsGt1, fracBitsGt2, remRegBins, goRiceZero, goRiceParam, extendedPrecision, maxLog2TrDynamicRange );
+          rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, fracBitsPar, fracBitsGt1, fracBitsGt2, remRegBins, goRiceZero, goRiceParam, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
+          rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, fracBitsPar, fracBitsGt1, fracBitsGt2, remRegBins, goRiceZero, goRiceParam, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
+        }
+        else // uiLevel == 0
+        {
+          if( remRegBins < 4 )
+          {
+            int rateNow            = xGetICRate( uiLevel,   fracBitsPar, fracBitsGt1, fracBitsGt2, remRegBins, goRiceZero, goRiceParam, extendedPrecision, maxLog2TrDynamicRange );
+            rateIncUp [ uiBlkPos ] = xGetICRate( uiLevel+1, fracBitsPar, fracBitsGt1, fracBitsGt2, remRegBins, goRiceZero, goRiceParam, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
+          }
+          else
+          {
+            rateIncUp [ uiBlkPos ] = fracBitsGt1.intBits[ 0 ];
+          }
+        }
+        piDstCoeff[ uiBlkPos ] = uiLevel;
+
+                    if( sign )
+        {
+                      piDstCoeff[uiBlkPos] = -piDstCoeff[uiBlkPos];
+        }
+
+                    xDequantSample( m_fullCoeff[uiBlkPos], piDstCoeff[uiBlkPos], trQuantParams );
+        m_fullCoeff[uiBlkPos] += predCoeff;
+
+        d64BaseCost           += pdCostCoeff [ iScanPos ];
+
+        if( ( (iScanPos & iCGSizeM1) == 0 ) && ( iScanPos > 0 ) )
+        {
+          goRiceParam   = 0;
+        }
+        else if( remRegBins >= 4 )
+        {
+          int  sumAll = cctx.templateAbsSum(iScanPos, piDstCoeff, 4);
+          goRiceParam = g_auiGoRiceParsCoeff[sumAll];
+          remRegBins -= (uiLevel < 2 ? uiLevel : 3) + (iScanPos != iLastScanPos);
+        }
+      }
+      else
+      {
+        d64BaseCost    += pdCostCoeff0[ iScanPos ];
+      }
+      rdStats.d64SigCost += pdCostSig[ iScanPos ];
+      if (iScanPosinCG == 0 )
+      {
+        rdStats.d64SigCost_0 = pdCostSig[ iScanPos ];
+      }
+      if (piDstCoeff[ uiBlkPos ] )
+      {
+        cctx.setSigGroup();
+        rdStats.d64CodedLevelandDist += pdCostCoeff[ iScanPos ] - pdCostSig[ iScanPos ];
+        rdStats.d64UncodedDist += pdCostCoeff0[ iScanPos ];
+        if ( iScanPosinCG != 0 )
+        {
+          rdStats.iNNZbeforePos0++;
+        }
+      }
+    } //end for (iScanPosinCG)
+
+    if (iCGLastScanPos >= 0)
+    {
+      if( cctx.subSetId() )
+      {
+        if( !cctx.isSigGroup() )
+        {
+          const BinFracBits fracBitsSigGroup = fracBits.getFracBitsArray( cctx.sigGroupCtxId() );
+          d64BaseCost += xGetRateSigCoeffGroup(fracBitsSigGroup, 0) - rdStats.d64SigCost;
+          pdCostCoeffGroupSig[ cctx.subSetId() ] = xGetRateSigCoeffGroup(fracBitsSigGroup, 0);
+        }
+        else
+        {
+          {
+            if ( rdStats.iNNZbeforePos0 == 0 )
+            {
+              d64BaseCost -= rdStats.d64SigCost_0;
+              rdStats.d64SigCost -= rdStats.d64SigCost_0;
+            }
+            // rd-cost if SigCoeffGroupFlag = 0, initialization
+            double d64CostZeroCG = d64BaseCost;
+
+            const BinFracBits fracBitsSigGroup = fracBits.getFracBitsArray( cctx.sigGroupCtxId() );
+
+
+            d64BaseCost  += xGetRateSigCoeffGroup(fracBitsSigGroup,1);
+            d64CostZeroCG += xGetRateSigCoeffGroup(fracBitsSigGroup,0);
+            pdCostCoeffGroupSig[ cctx.subSetId() ] = xGetRateSigCoeffGroup(fracBitsSigGroup,1);
+
+            // try to convert the current coeff group from non-zero to all-zero
+            d64CostZeroCG += rdStats.d64UncodedDist;  // distortion for resetting non-zero levels to zero levels
+            d64CostZeroCG -= rdStats.d64CodedLevelandDist;   // distortion and level cost for keeping all non-zero levels
+            d64CostZeroCG -= rdStats.d64SigCost;     // sig cost for all coeffs, including zero levels and non-zerl levels
+
+                                                     // if we can save cost, change this block to all-zero block
+            if ( d64CostZeroCG < d64BaseCost )
+            {
+              cctx.resetSigGroup();
+              d64BaseCost = d64CostZeroCG;
+
+              pdCostCoeffGroupSig[ cctx.subSetId() ] = xGetRateSigCoeffGroup(fracBitsSigGroup,0);
+
+              // reset coeffs to 0 in this block
+              for( int iScanPosinCG = maxNonZeroPosInCG; iScanPosinCG >= 0; iScanPosinCG-- )
+              {
+                iScanPos      = cctx.minSubPos() + iScanPosinCG;
+                uint32_t uiBlkPos = cctx.blockPos( iScanPos );
+                    const int posX        = cctx.posX(iScanPos);
+                const int posY        = cctx.posY(iScanPos);
+                const int posS        = (1 == dirMode) ? posX : posY;
+                    const int boundaryLim = (1 == dirMode) ? uiWidth-1 : uiHeight-1;
+                    const int posNb       = (1 == dirMode) ? (posX + 1) + posY * pSrc.stride : posX + (posY + 1) * pSrc.stride;
+                    m_fullCoeff[uiBlkPos] = (boundaryLim != posS) ? m_fullCoeff[posNb] : 0;     
+
+                if (piDstCoeff[ uiBlkPos ])
+                {
+                  piDstCoeff [ uiBlkPos ] = 0;
+                  pdCostCoeff[ iScanPos ] = pdCostCoeff0[ iScanPos ];
+                  pdCostSig  [ iScanPos ] = 0;
+                }
+              }
+            }
+          }
+        } // end if if (uiSigCoeffGroupFlag[ uiCGBlkPos ] == 0)
+      }
+      else
+      {
+        cctx.setSigGroup();
+      }
+    }
+  } //end for (cctx.subSetId)
+
+
+  //===== estimate last position =====
+  for ( int scanPos = 0; scanPos < uiMaxNumCoeff; scanPos++ )
+  {
+    int blkPos   = cctx.blockPos( scanPos );
+    TCoeff level = piDstCoeff[ blkPos ];
+        uiAbsSum    += abs(level);
+  }
+
+  // rotate block
+  for (uint32_t y = 0, coefficientIndex = 0; y < uiHeight; y++)
+  {
+    for (uint32_t x = 0; x < uiWidth; x++, coefficientIndex++)
+    {
+                m_dstCoeffTemp[coefficientIndex] = tu.getCoeffs(compID).buf[uiSizeMinus1 - coefficientIndex];
+    }
+  }
+  memcpy( tu.getCoeffs(compID).buf, m_dstCoeffTemp, sizeof(TCoeff) * numSamplesInBlock );
+}
+#endif
+
 void QuantRDOQ::forwardRDPCM( TransformUnit &tu, const ComponentID &compID, const CCoeffBuf &coeffs, TCoeff &absSum, const QpParam &qp, const Ctx &ctx )
 {
   const FracBitsAccess& fracBits = ctx.getFracBitsAcess();

source/Lib/CommonLib/QuantRDOQ.h

@@ -66 +66 @@
   // quantization
   void quant                ( TransformUnit &tu, const ComponentID &compID, const CCoeffBuf &pSrc, TCoeff &uiAbsSum, const QpParam &cQP, const Ctx& ctx );
   void forwardRDPCM         ( TransformUnit &tu, const ComponentID &compID, const CCoeffBuf &pSrc, TCoeff &uiAbsSum, const QpParam &cQP, const Ctx &ctx );
+#if QC_TS_RRC_RDOQ
+  void forwardRRCRDPCM        ( TransformUnit &tu, const ComponentID &compID, const CCoeffBuf &pSrc, TCoeff &uiAbsSum, const QpParam &cQP, const Ctx &ctx );
+#endif
 
 private:
   double* xGetErrScaleCoeffSL            ( uint32_t list, uint32_t sizeX, uint32_t sizeY, int qp ) { return m_errScale[sizeX][sizeY][list][qp]; };  //!< get Error Scale Coefficent
@@ -166 +169 @@
   int    m_sigRateDelta       [MAX_TB_SIZEY * MAX_TB_SIZEY];
   TCoeff m_deltaU             [MAX_TB_SIZEY * MAX_TB_SIZEY];
   TCoeff m_fullCoeff          [MAX_TB_SIZEY * MAX_TB_SIZEY];
+#if QC_TS_RRC_RDOQ
+  TCoeff m_srcCoeffTemp       [MAX_TB_SIZEY * MAX_TB_SIZEY];
+  TCoeff m_dstCoeffTemp       [MAX_TB_SIZEY * MAX_TB_SIZEY];
+#endif
   int   m_bdpcm;
   int   m_testedLevels;
 };// END CLASS DEFINITION QuantRDOQ

source/Lib/CommonLib/TypeDef.h

@@ -50 +50 @@
 #include <assert.h>
 #include <cassert>
 
+#define QC_TEST_TS_RRC                                    1
+#define QC_TS_RRC_RDOQ                                    1
+
 #define JVET_Q0237_STSA_TID_ZERO_DEPLAYER                 1 // JVET-Q0237: STSA picture with TemporalId equal to 0 in a dependent layer
 
 #define JVET_Q0798_SPS_NUMBER_MERGE_CANDIDATE             1 // JVET-Q0798: signal the number of merge candidates in SPS

source/Lib/EncoderLib/EncSlice.cpp

@@ -350 +350 @@
   }
   else
   {
+#if QC_TEST_TS_RRC
+    rpcSlice->setTSResidualCodingDisabledFlag(true);
+#else
     rpcSlice->setTSResidualCodingDisabledFlag(false);
+#endif
   }
 #endif