Changeset 1413 in 3DVCSoftware for trunk/source/Lib/TLibEncoder/TEncCu.cpp


Ignore:
Timestamp:
11 Jul 2018, 15:19:49 (6 years ago)
Author:
tech
Message:

Merged HTM-16.2-dev@1412

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibEncoder/TEncCu.cpp

    r1405 r1413  
    44 * granted under this license.
    55 *
    6  * Copyright (c) 2010-2016, ITU/ISO/IEC
     6 * Copyright (c) 2010-2017, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    4646using namespace std;
    4747
    48 
    4948//! \ingroup TLibEncoder
    5049//! \{
     
    6867  m_ppcTempCU      = new TComDataCU*[m_uhTotalDepth-1];
    6968
    70 #if NH_3D_ARP
     69#if NH_3D
    7170  m_ppcWeightedTempCU = new TComDataCU*[m_uhTotalDepth-1];
    7271#endif
     
    7978  m_ppcRecoYuvTemp = new TComYuv*[m_uhTotalDepth-1];
    8079  m_ppcOrigYuv     = new TComYuv*[m_uhTotalDepth-1];
    81 #if NH_3D_DBBP
     80#if NH_3D
    8281  m_ppcOrigYuvDBBP = new TComYuv*[m_uhTotalDepth-1];
    8382#endif
     
    9291    m_ppcBestCU[i] = new TComDataCU; m_ppcBestCU[i]->create( chromaFormat, uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
    9392    m_ppcTempCU[i] = new TComDataCU; m_ppcTempCU[i]->create( chromaFormat, uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
    94 #if NH_3D_ARP
     93#if NH_3D
    9594    m_ppcWeightedTempCU[i] = new TComDataCU; m_ppcWeightedTempCU[i]->create( chromaFormat, uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
    9695#endif 
     
    105104
    106105    m_ppcOrigYuv    [i] = new TComYuv; m_ppcOrigYuv    [i]->create(uiWidth, uiHeight, chromaFormat);
    107 #if NH_3D_DBBP
     106#if NH_3D
    108107    m_ppcOrigYuvDBBP[i] = new TComYuv; m_ppcOrigYuvDBBP[i]->create(uiWidth, uiHeight, chromaFormat);
    109108#endif
     
    147146      m_ppcTempCU[i]->destroy();      delete m_ppcTempCU[i];      m_ppcTempCU[i] = NULL;
    148147    }
    149 #if NH_3D_ARP
     148#if NH_3D
    150149    if(m_ppcWeightedTempCU[i])
    151150    {
     
    181180      m_ppcOrigYuv[i]->destroy();     delete m_ppcOrigYuv[i];     m_ppcOrigYuv[i] = NULL;
    182181    }
    183 #if NH_3D_DBBP
     182#if NH_3D
    184183    if(m_ppcOrigYuvDBBP[i])
    185184    {
     
    199198  }
    200199
    201 #if NH_3D_ARP
     200#if NH_3D
    202201  if(m_ppcWeightedTempCU)
    203202  {
     
    241240    m_ppcOrigYuv = NULL;
    242241  }
    243 #if NH_3D_DBBP
     242#if NH_3D
    244243  if(m_ppcOrigYuvDBBP)
    245244  {
     
    266265
    267266  m_pcRateCtrl         = pcEncTop->getRateCtrl();
     267  m_lumaQPOffset       = 0;
     268  initLumaDeltaQpLUT();
    268269}
    269270
     
    281282  m_ppcTempCU[0]->initCtu( pCtu->getPic(), pCtu->getCtuRsAddr() );
    282283
    283 #if NH_3D_ARP
     284#if NH_3D
    284285  m_ppcWeightedTempCU[0]->initCtu( pCtu->getPic(), pCtu->getCtuRsAddr() );
    285286#endif
     
    329330// Protected member functions
    330331// ====================================================================================================================
     332
     333Void TEncCu::initLumaDeltaQpLUT()
     334{
     335  const LumaLevelToDeltaQPMapping &mapping=m_pcEncCfg->getLumaLevelToDeltaQPMapping();
     336
     337  if ( !mapping.isEnabled() )
     338  {
     339    return;
     340  }
     341
     342  // map the sparse LumaLevelToDeltaQPMapping.mapping to a fully populated linear table.
     343
     344  Int         lastDeltaQPValue=0;
     345  std::size_t nextSparseIndex=0;
     346  for(Int index=0; index<LUMA_LEVEL_TO_DQP_LUT_MAXSIZE; index++)
     347  {
     348    while (nextSparseIndex < mapping.mapping.size() && index>=mapping.mapping[nextSparseIndex].first)
     349    {
     350      lastDeltaQPValue=mapping.mapping[nextSparseIndex].second;
     351      nextSparseIndex++;
     352    }
     353    m_lumaLevelToDeltaQPLUT[index]=lastDeltaQPValue;
     354  }
     355}
     356
     357Int TEncCu::calculateLumaDQP(TComDataCU *pCU, const UInt absPartIdx, const TComYuv * pOrgYuv)
     358{
     359  const Pel *pY = pOrgYuv->getAddr(COMPONENT_Y, absPartIdx);
     360  const Int stride  = pOrgYuv->getStride(COMPONENT_Y);
     361  Int width = pCU->getWidth(absPartIdx);
     362  Int height = pCU->getHeight(absPartIdx);
     363  Double avg = 0;
     364
     365  // limit the block by picture size
     366  const TComSPS* pSPS = pCU->getSlice()->getSPS();
     367  if ( pCU->getCUPelX() + width > pSPS->getPicWidthInLumaSamples() )
     368  {
     369    width = pSPS->getPicWidthInLumaSamples() - pCU->getCUPelX();
     370  }
     371  if ( pCU->getCUPelY() + height > pSPS->getPicHeightInLumaSamples() )
     372  {
     373    height = pSPS->getPicHeightInLumaSamples() - pCU->getCUPelY();
     374  }
     375
     376  // Get QP offset derived from Luma level
     377  if ( m_pcEncCfg->getLumaLevelToDeltaQPMapping().mode == LUMALVL_TO_DQP_AVG_METHOD )
     378  {
     379    // Use avg method
     380    Int sum = 0;
     381    for (Int y = 0; y < height; y++)
     382    {
     383      for (Int x = 0; x < width; x++)
     384      {
     385        sum += pY[x];
     386      }
     387      pY += stride;
     388    }
     389    avg = (Double)sum/(width*height);
     390  }
     391  else
     392  {
     393    // Use maximum luma value
     394    Int maxVal = 0;
     395    for (Int y = 0; y < height; y++)
     396    {
     397      for (Int x = 0; x < width; x++)
     398      {
     399        if (pY[x] > maxVal)
     400        {
     401          maxVal = pY[x];
     402        }
     403      }
     404      pY += stride;
     405    }
     406    // use a percentage of the maxVal
     407    avg = (Double)maxVal * m_pcEncCfg->getLumaLevelToDeltaQPMapping().maxMethodWeight;
     408  }
     409
     410  Int lumaIdx = Clip3<Int>(0, Int(LUMA_LEVEL_TO_DQP_LUT_MAXSIZE)-1, Int(avg+0.5) );
     411  Int QP = m_lumaLevelToDeltaQPLUT[lumaIdx];
     412  return QP;
     413}
     414
    331415//! Derive small set of test modes for AMP encoder speed-up
    332416#if AMP_ENC_SPEEDUP
     
    420504  const UInt fastDeltaQPCuMaxSize    = Clip3(sps.getMaxCUHeight()>>sps.getLog2DiffMaxMinCodingBlockSize(), sps.getMaxCUHeight(), 32u);
    421505
    422 #if NH_3D_QTL
    423 #if NH_3D_QTLPC
     506#if NH_3D
    424507  Bool  bLimQtPredFalg    = pcPic->getSlice(0)->getQtPredFlag();
    425 #else
    426   Bool  bLimQtPredFalg    = false;
    427 #endif
    428508  TComPic *pcTexture      = rpcBestCU->getSlice()->getTexturePic();
    429509
     
    440520  m_ppcOrigYuv[uiDepth]->copyFromPicYuv( pcPic->getPicYuvOrg(), rpcBestCU->getCtuRsAddr(), rpcBestCU->getZorderIdxInCtu() );
    441521
    442 #if NH_3D_QTL 
     522#if NH_3D
    443523  Bool    bTrySplit     = true;
    444524  Bool    bTrySplitDQP  = true;
     
    448528  Bool    earlyDetectionSkipMode = false;
    449529
    450 #if NH_3D_NBDV
     530#if NH_3D
    451531  DisInfo DvInfo;
    452532  DvInfo.m_acNBDV.setZero();
    453533  DvInfo.m_aVIdxCan = 0;
    454 #if NH_3D_NBDV_REF
    455534  DvInfo.m_acDoNBDV.setZero();
    456 #endif
    457535#endif
    458536  const UInt uiLPelX   = rpcBestCU->getCUPelX();
     
    492570  }
    493571
     572  if ( m_pcEncCfg->getLumaLevelToDeltaQPMapping().isEnabled() )
     573  {
     574    if ( uiDepth <= pps.getMaxCuDQPDepth() )
     575    {
     576      // keep using the same m_QP_LUMA_OFFSET in the same CTU
     577      m_lumaQPOffset = calculateLumaDQP(rpcTempCU, 0, m_ppcOrigYuv[uiDepth]);
     578    }
     579    iMinQP = Clip3(-sps.getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, iBaseQP - m_lumaQPOffset);
     580    iMaxQP = iMinQP; // force encode choose the modified QO
     581  }
     582
    494583  if ( m_pcEncCfg->getUseRateCtrl() )
    495584  {
     
    502591  const Int lowestQP = iMinQP; // For TQB, use this QP which is the lowest non TQB QP tested (rather than QP'=0) - that way delta QPs are smaller, and TQB can be tested at all CU levels.
    503592
    504   if ( (pps.getTransquantBypassEnableFlag()) )
     593  if ( (pps.getTransquantBypassEnabledFlag()) )
    505594  {
    506595    isAddLowestQP = true; // mark that the first iteration is to cost TQB mode.
     
    512601  }
    513602
    514 #if NH_3D_IC
     603#if NH_3D
    515604  Bool bICEnabled = rpcTempCU->getSlice()->getViewIndex() && ( rpcTempCU->getSlice()->getSliceType() == P_SLICE || rpcTempCU->getSlice()->getSliceType() == B_SLICE ) && !rpcTempCU->getSlice()->getIsDepth();
    516605  bICEnabled = bICEnabled && rpcTempCU->getSlice()->getApplyIC();
     
    536625        iQP = lowestQP;
    537626      }
    538 
    539 #if NH_3D_QTL
     627      if ( m_pcEncCfg->getLumaLevelToDeltaQPMapping().isEnabled() && uiDepth <= pps.getMaxCuDQPDepth() )
     628      {
     629        getSliceEncoder()->updateLambda(pcSlice, iQP);
     630      }
     631
     632
     633
     634#if NH_3D
    540635      bTrySplit    = true;
    541636#endif
     
    555650
    556651      rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    557 #if NH_3D_QTL
     652#if NH_3D
    558653      //logic for setting bTrySplit using the partition information that is stored of the texture colocated CU
    559 #if H_3D_FCO
    560       if(depthMapDetect && !bIntraSliceDetect && !rapPic && ( m_pcEncCfg->getUseQTL() || bLimQtPredFalg ) && pcTexture->getReconMark())
    561 #else
    562654      if(depthMapDetect && !bIntraSliceDetect && !rapPic && ( m_pcEncCfg->getUseQTL() || bLimQtPredFalg ))
    563 #endif
    564655      {
    565656        TComDataCU* pcTextureCU = pcTexture->getCtu( rpcBestCU->getCtuRsAddr() ); //Corresponding texture LCU
     
    592683#endif
    593684
    594 #if NH_3D_NBDV
     685#if NH_3D
    595686      if( rpcTempCU->getSlice()->getSliceType() != I_SLICE )
    596687      {
    597 #if NH_3D_ARP && NH_3D_IV_MERGE && NH_3D_VSP
    598688        if( rpcTempCU->getSlice()->getIvResPredFlag() || rpcTempCU->getSlice()->getIvMvPredFlag() || rpcTempCU->getSlice()->getViewSynthesisPredFlag() )
    599 #else
    600 #if NH_3D_IV_MERGE && NH_3D_VSP
    601         if( rpcTempCU->getSlice()->getIvMvPredFlag() || rpcTempCU->getSlice()->getViewSynthesisPredFlag() )
    602 #else
    603 #if NH_3D_ARP && NH_3D_VSP
    604         if( rpcTempCU->getSlice()->getIvResPredFlag() || rpcTempCU->getSlice()->getViewSynthesisPredFlag() )
    605 #else
    606 #if NH_3D_VSP
    607         if( rpcTempCU->getSlice()->getViewSynthesisPredFlag() )
    608 #else
    609 #if NH_3D_ARP
    610         if( rpcTempCU->getSlice()->getIvResPredFlag() )
    611 #else
    612 #if H_3D_IV_MERGE
    613         if( rpcTempCU->getSlice()->getVPS()->getIvMvPredFlag(rpcTempCU->getSlice()->getLayerId()) )
    614 #else
    615 #if NH_3D_DBBP
    616         if( rpcTempCU->getSlice()->getDepthBasedBlkPartFlag() )
    617 #else
    618         if (0)
    619 #endif
    620 #endif
    621 #endif
    622 #endif
    623 #endif
    624 #endif
    625 #endif
    626689        {
    627690          PartSize ePartTemp = rpcTempCU->getPartitionSize(0);
    628691          rpcTempCU->setPartSizeSubParts(SIZE_2Nx2N, 0, uiDepth);
    629 #if NH_3D_IV_MERGE
    630692          if (rpcTempCU->getSlice()->getIsDepth() )
    631693          {
     
    634696          else
    635697          {
    636 #endif
    637 #if NH_3D_NBDV_REF
    638698            if( rpcTempCU->getSlice()->getDepthRefinementFlag() )
    639699            {
     
    641701            }
    642702            else
    643 #endif
    644703            {
    645704              rpcTempCU->getDisMvpCandNBDV(&DvInfo);
    646705            }
    647 #if NH_3D_IV_MERGE
    648           }
    649 #endif
     706          }
    650707          rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    651708          rpcBestCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
     
    666723      if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
    667724      {
    668 #if NH_3D_IC
     725#if NH_3D
    669726        for( UInt uiICId = 0; uiICId < ( bICEnabled ? 2 : 1 ); uiICId++ )
    670727        {
     
    674731        if(m_pcEncCfg->getUseEarlySkipDetection())
    675732        {
    676 #if NH_3D_IC
     733#if NH_3D
    677734            rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
    678735#endif
     
    683740          rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );//by Competition for inter_2Nx2N
    684741#endif
    685 #if NH_3D_VSP  || NH_3D_DBBP
     742#if NH_3D
    686743          rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    687744#endif
    688745        }
    689746        // SKIP
    690 #if NH_3D_IC
     747#if NH_3D
    691748          rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
    692749#endif
     
    697754
    698755        rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    699 #if NH_3D_VSP  || NH_3D_DBBP
     756#if NH_3D
    700757        rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    701758#endif
     
    704761        {
    705762          // 2Nx2N, NxN
    706 #if NH_3D_IC
     763#if NH_3D
    707764            rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
    708765#endif
     
    714771          rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    715772#endif
    716 #if NH_3D_VSP  || NH_3D_DBBP
     773#if NH_3D
    717774          rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    718 #endif
    719 #if NH_3D_DBBP
    720775            if( rpcTempCU->getSlice()->getDepthBasedBlkPartFlag() && rpcTempCU->getSlice()->getDefaultRefViewIdxAvailableFlag() )
    721776            {
    722777              xCheckRDCostInterDBBP( rpcBestCU, rpcTempCU DEBUG_STRING_PASS_INTO(sDebug), false );
    723778              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode  );
    724 #if NH_3D_VSP  || NH_3D_DBBP
    725779              rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    726 #endif
    727780            }
    728781#endif
     
    733786          }
    734787        }
    735 #if NH_3D_IC
     788#if NH_3D
    736789        }
    737790#endif
    738791      }
    739 #if NH_3D_QTL
     792#if NH_3D
    740793      if(depthMapDetect && !bIntraSliceDetect && !rapPic && ( m_pcEncCfg->getUseQTL() || bLimQtPredFalg ))
    741794      {
     
    757810    }
    758811#endif
    759 #if NH_3D_ENC_DEPTH
     812#if NH_3D
    760813    if( rpcBestCU->getSlice()->getIsDepth() && rpcBestCU->getSlice()->isIRAP() )
    761814    {
    762815      earlyDetectionSkipMode = false;
    763816    }
    764 #endif
    765 #if NH_3D_DIS
     817
    766818    rpcTempCU->initEstData( uiDepth, iMinQP, isAddLowestQP  );
    767819    if( rpcBestCU->getSlice()->getDepthIntraSkipFlag() )
     
    792844          {
    793845            if( uiDepth == sps.getLog2DiffMaxMinCodingBlockSize() && doNotBlockPu
    794 #if NH_3D_QTL
     846#if NH_3D
    795847                && bTrySplit
    796848#endif
     
    804856#endif
    805857              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    806 #if NH_3D_VSP || NH_3D_DBBP
     858#if NH_3D
    807859              rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    808860#endif
     
    812864
    813865          if(doNotBlockPu
    814 #if NH_3D_QTL
     866#if NH_3D
    815867            && bTryNx2N
    816868#endif
     
    823875#endif
    824876            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    825 #if NH_3D_VSP || NH_3D_DBBP
     877#if NH_3D
    826878            rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    827879#endif
     
    833885          }
    834886          if(doNotBlockPu
    835 #if NH_3D_QTL
     887#if NH_3D
    836888            && bTry2NxN
    837889#endif
     
    846898
    847899            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    848 #if NH_3D_VSP || NH_3D_DBBP
     900#if NH_3D
    849901            rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    850902#endif
     
    874926            {
    875927              if(doNotBlockPu
    876 #if NH_3D_QTL
     928#if NH_3D
    877929                && bTry2NxN
    878930#endif
     
    885937#endif
    886938                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    887 #if NH_3D_VSP || NH_3D_DBBP
     939#if NH_3D
    888940                rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    889941#endif
     
    894946              }
    895947              if(doNotBlockPu
    896 #if NH_3D_QTL
     948#if NH_3D
    897949                && bTry2NxN
    898950#endif
     
    906958
    907959                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    908 #if NH_3D_VSP || NH_3D_DBBP
     960#if NH_3D
    909961                rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    910962#endif
     
    920972            {
    921973              if(doNotBlockPu
    922 #if NH_3D_QTL
     974#if NH_3D
    923975                && bTry2NxN
    924976#endif
     
    933985
    934986                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    935 #if NH_3D_VSP || NH_3D_DBBP
     987#if NH_3D
    936988                rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    937989#endif
     
    942994              }
    943995              if(doNotBlockPu
    944 #if NH_3D_QTL
     996#if NH_3D
    945997                && bTry2NxN
    946998#endif
     
    9531005#endif
    9541006                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    955 #if NH_3D_VSP || NH_3D_DBBP
     1007#if NH_3D
    9561008                rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    9571009#endif
     
    9691021            {
    9701022              if(doNotBlockPu
    971 #if NH_3D_QTL
     1023#if NH_3D
    9721024                && bTryNx2N
    9731025#endif
     
    9811033
    9821034                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    983 #if NH_3D_VSP || NH_3D_DBBP
     1035#if NH_3D
    9841036                rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    9851037#endif
     
    9901042              }
    9911043              if(doNotBlockPu
    992 #if NH_3D_QTL
     1044#if NH_3D
    9931045                && bTryNx2N
    9941046#endif
     
    10011053#endif
    10021054                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    1003 #if NH_3D_VSP || NH_3D_DBBP
     1055#if NH_3D
    10041056                rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    10051057#endif
     
    10101062            {
    10111063              if(doNotBlockPu
    1012 #if NH_3D_QTL
     1064#if NH_3D
    10131065                && bTryNx2N
    10141066#endif
     
    10211073#endif
    10221074                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    1023 #if NH_3D_VSP || NH_3D_DBBP
     1075#if NH_3D
    10241076                rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    10251077#endif
     
    10301082              }
    10311083              if(doNotBlockPu
    1032 #if NH_3D_QTL
     1084#if NH_3D
    10331085                && bTryNx2N
    10341086#endif
     
    10421094#endif
    10431095                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    1044 #if NH_3D_VSP || NH_3D_DBBP
     1096#if NH_3D
    10451097                rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    10461098#endif
     
    10511103
    10521104#else
    1053 #if NH_3D_QTL
     1105#if NH_3D
    10541106            if (bTry2NxN)
    10551107            {
    10561108#endif
    1057 
    1058             xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
    1059             rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    1060 #if NH_3D_VSP || NH_3D_DBBP
    1061             rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    1062 #endif
    1063             xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
    1064             rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    1065 #if NH_3D_VSP || NH_3D_DBBP
    1066             rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    1067 #endif
    1068 #if NH_3D_QTL
     1109              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
     1110              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     1111#if NH_3D
     1112              rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
     1113#endif
     1114              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
     1115              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     1116#if NH_3D
     1117              rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    10691118            }
    10701119            if (bTryNx2N)
    10711120            {
    10721121#endif
    1073             xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
    1074             rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    1075 #if NH_3D_VSP || NH_3D_DBBP
    1076             rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    1077 #endif
    1078             xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
    1079             rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    1080 #if NH_3D_VSP || NH_3D_DBBP
    1081             rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    1082 #endif
    1083 #if NH_3D_QTL
     1122              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
     1123              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     1124#if NH_3D
     1125              rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
     1126#endif
     1127              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
     1128              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     1129#if NH_3D
     1130              rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
    10841131            }
    10851132#endif
     
    10931140        {
    10941141#endif
    1095 
    10961142        // do normal intra modes
    10971143        // speedup for inter frames
    10981144
    1099         if((rpcBestCU->getSlice()->getSliceType() == I_SLICE)                                     ||
    1100            ((!m_pcEncCfg->getDisableIntraPUsInInterSlices()) && (
    1101            (rpcBestCU->getCbf( 0, COMPONENT_Y  ) != 0)                                            ||
    1102           ((rpcBestCU->getCbf( 0, COMPONENT_Cb ) != 0) && (numberValidComponents > COMPONENT_Cb)) ||
    1103           ((rpcBestCU->getCbf( 0, COMPONENT_Cr ) != 0) && (numberValidComponents > COMPONENT_Cr))   // avoid very complex intra if it is unlikely
    1104  #if NH_3D_ENC_DEPTH
     1145
     1146#if MCTS_ENC_CHECK
     1147        if ( m_pcEncCfg->getTMCTSSEITileConstraint() || (rpcBestCU->getSlice()->getSliceType() == I_SLICE) ||
     1148             ((!m_pcEncCfg->getDisableIntraPUsInInterSlices()) && (
     1149             (rpcBestCU->getCbf(0, COMPONENT_Y) != 0) ||
     1150             ((rpcBestCU->getCbf(0, COMPONENT_Cb) != 0) && (numberValidComponents > COMPONENT_Cb)) ||
     1151             ((rpcBestCU->getCbf(0, COMPONENT_Cr) != 0) && (numberValidComponents > COMPONENT_Cr))  // avoid very complex intra if it is unlikely
     1152#else
     1153        if((rpcBestCU->getSlice()->getSliceType() == I_SLICE)                                        ||
     1154            ((!m_pcEncCfg->getDisableIntraPUsInInterSlices()) && (
     1155              (rpcBestCU->getCbf( 0, COMPONENT_Y  ) != 0)                                            ||
     1156             ((rpcBestCU->getCbf( 0, COMPONENT_Cb ) != 0) && (numberValidComponents > COMPONENT_Cb)) ||
     1157             ((rpcBestCU->getCbf( 0, COMPONENT_Cr ) != 0) && (numberValidComponents > COMPONENT_Cr))  // avoid very complex intra if it is unlikely
     1158#endif
     1159 #if NH_3D
    11051160            || rpcBestCU->getSlice()->getIsDepth()
    11061161#endif
    11071162            )))
    1108         {
    1109 #if NH_3D_ENC_DEPTH
    1110             Bool bOnlyIVP = false;
    1111             Bool bUseIVP = true;
    1112             if( (rpcBestCU->getSlice()->getSliceType() != I_SLICE) &&
    1113                 !( (rpcBestCU->getCbf( 0, COMPONENT_Y  ) != 0)                                            ||
    1114                   ((rpcBestCU->getCbf( 0, COMPONENT_Cb ) != 0) && (numberValidComponents > COMPONENT_Cb)) ||
    1115                   ((rpcBestCU->getCbf( 0, COMPONENT_Cr ) != 0) && (numberValidComponents > COMPONENT_Cr))   ) &&
    1116                   (rpcBestCU->getSlice()->getIsDepth() && !(rpcBestCU->getSlice()->isIRAP())) )
    1117             {
    1118               bOnlyIVP = true;
    1119               bUseIVP = rpcBestCU->getSlice()->getIntraContourFlag();
    1120             }
    1121             if( bUseIVP )
    1122             {
    1123               xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N DEBUG_STRING_PASS_INTO(sDebug), bOnlyIVP );
    1124 #else
    1125           xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N DEBUG_STRING_PASS_INTO(sDebug) );
     1163          {
     1164#if NH_3D
     1165          Bool bOnlyIVP = false;
     1166          Bool bUseIVP = true;
     1167          if( (rpcBestCU->getSlice()->getSliceType() != I_SLICE) &&
     1168            !( (rpcBestCU->getCbf( 0, COMPONENT_Y  ) != 0)                                            ||
     1169            ((rpcBestCU->getCbf( 0, COMPONENT_Cb ) != 0) && (numberValidComponents > COMPONENT_Cb)) ||
     1170            ((rpcBestCU->getCbf( 0, COMPONENT_Cr ) != 0) && (numberValidComponents > COMPONENT_Cr))   ) &&
     1171            (rpcBestCU->getSlice()->getIsDepth() && !(rpcBestCU->getSlice()->isIRAP())) )
     1172          {
     1173            bOnlyIVP = true;
     1174            bUseIVP = rpcBestCU->getSlice()->getIntraContourFlag();
     1175          }
     1176          if( bUseIVP )
     1177          {
     1178            xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N DEBUG_STRING_PASS_INTO(sDebug), bOnlyIVP );
     1179#else
     1180            xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N DEBUG_STRING_PASS_INTO(sDebug) );
    11261181#endif
    11271182#if KWU_RC_MADPRED_E0227
     
    11331188#endif
    11341189
    1135           rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    1136           if( uiDepth == sps.getLog2DiffMaxMinCodingBlockSize() )
    1137           {
    1138 #if NH_3D_QTL //Try IntraNxN
     1190            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     1191            if( uiDepth == sps.getLog2DiffMaxMinCodingBlockSize() )
     1192            {
     1193#if NH_3D  //Try IntraNxN
    11391194              if(bTrySplit)
    11401195              {
    11411196#endif
    1142             if( rpcTempCU->getWidth(0) > ( 1 << sps.getQuadtreeTULog2MinSize() ) )
    1143             {
    1144 #if NH_3D_ENC_DEPTH
    1145               xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN DEBUG_STRING_PASS_INTO(sDebug), bOnlyIVP );
    1146 #else
    1147               xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN DEBUG_STRING_PASS_INTO(sDebug)   );
     1197                if( rpcTempCU->getWidth(0) > ( 1 << sps.getQuadtreeTULog2MinSize() ) )
     1198                {
     1199#if NH_3D
     1200                  xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN DEBUG_STRING_PASS_INTO(sDebug), bOnlyIVP );
     1201#else
     1202                  xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN DEBUG_STRING_PASS_INTO(sDebug)   );
    11481203#endif       
    1149               rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     1204                  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     1205                }
     1206#if NH_3D
     1207              }
     1208#endif
    11501209            }
    1151 #if NH_3D_QTL
    1152               }
    1153 #endif
    1154           }
    1155 #if NH_3D_ENC_DEPTH
     1210#if NH_3D
    11561211          }
    11571212#endif
     
    11711226          if((uiBestBits > uiRawBits) || (rpcBestCU->getTotalCost() > m_pcRdCost->calcRdCost(uiRawBits, 0)))
    11721227#endif
    1173 
    11741228          {
    11751229            xCheckIntraPCM (rpcBestCU, rpcTempCU);
     
    12361290  }
    12371291
     1292  if ( m_pcEncCfg->getLumaLevelToDeltaQPMapping().isEnabled() )
     1293  {
     1294    iMinQP = Clip3(-sps.getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, iBaseQP - m_lumaQPOffset);
     1295    iMaxQP = iMinQP;
     1296  }
     1297
    12381298  if ( m_pcEncCfg->getUseRateCtrl() )
    12391299  {
     
    12511311  const Bool bSubBranch = bBoundary || !( m_pcEncCfg->getUseEarlyCU() && rpcBestCU->getTotalCost()!=MAX_DOUBLE && rpcBestCU->isSkipped(0) );
    12521312#endif
    1253 #if NH_3D_QTL
     1313#if NH_3D
    12541314  if( bSubBranch && uiDepth < sps.getLog2DiffMaxMinCodingBlockSize() && (!getFastDeltaQp() || uiWidth > fastDeltaQPCuMaxSize || bBoundary) && bTrySplitDQP )
    12551315#else
     
    12581318  {
    12591319    // further split
     1320    Double splitTotalCost = 0;
     1321
    12601322    for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
    12611323    {
     
    12801342      DEBUG_STRING_NEW(sTempDebug)
    12811343
    1282 #if NH_3D_ARP
     1344#if NH_3D
    12831345      m_ppcWeightedTempCU[uhNextDepth]->setSlice( m_ppcWeightedTempCU[ uiDepth]->getSlice());
    12841346      m_ppcWeightedTempCU[uhNextDepth]->setPic  ( m_ppcWeightedTempCU[ uiDepth] );
     
    13181380          rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );         // Keep best part data to current temporary data.
    13191381          xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
     1382          if ( m_pcEncCfg->getLumaLevelToDeltaQPMapping().isEnabled() && pps.getMaxCuDQPDepth() >= 1 )
     1383          {
     1384            splitTotalCost += pcSubBestPartCU->getTotalCost();
     1385          }
    13201386        }
    13211387        else
     
    13311397        m_pcEntropyCoder->resetBits();
    13321398        m_pcEntropyCoder->encodeSplitFlag( rpcTempCU, 0, uiDepth, true );
     1399        if ( m_pcEncCfg->getLumaLevelToDeltaQPMapping().isEnabled() && pps.getMaxCuDQPDepth() >= 1 )
     1400        {
     1401          Int splitBits = m_pcEntropyCoder->getNumberOfWrittenBits();
     1402          Double splitBitCost = m_pcRdCost->calcRdCost( splitBits, 0 );
     1403          splitTotalCost += splitBitCost;
     1404        }
    13331405
    13341406        rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
    13351407        rpcTempCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
    13361408      }
     1409      if ( m_pcEncCfg->getLumaLevelToDeltaQPMapping().isEnabled() && pps.getMaxCuDQPDepth() >= 1 )
     1410      {
     1411        rpcTempCU->getTotalCost() = splitTotalCost;
     1412      }
     1413      else
     1414      {
    13371415#if NH_3D_VSO // M10
    13381416      if ( m_pcRdCost->getUseLambdaScaleVSO() )
     
    13431421#endif
    13441422        rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     1423      }
    13451424
    13461425      if( uiDepth == pps.getMaxCuDQPDepth() && pps.getUseDQP())
     
    15721651  }
    15731652
    1574   if (pps.getTransquantBypassEnableFlag())
     1653  if (pps.getTransquantBypassEnabledFlag())
    15751654  {
    15761655    m_pcEntropyCoder->encodeCUTransquantBypassFlag( pcCU, uiAbsPartIdx );
     
    15911670
    15921671    m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx );
    1593 #if NH_3D_ARP
     1672#if NH_3D
    15941673    m_pcEntropyCoder->encodeARPW( pcCU , uiAbsPartIdx );
    1595 #endif
    1596 #if NH_3D_IC
    15971674    m_pcEntropyCoder->encodeICFlag  ( pcCU, uiAbsPartIdx );
    15981675#endif
     
    16021679  }
    16031680
    1604 #if NH_3D_DIS
     1681#if NH_3D
    16051682  m_pcEntropyCoder->encodeDIS( pcCU, uiAbsPartIdx );
    16061683  if(!pcCU->getDISFlag(uiAbsPartIdx))
    16071684  {
    16081685#endif
    1609   m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
    1610   m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
    1611 
    1612   if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
    1613   {
    1614     m_pcEntropyCoder->encodeIPCMInfo( pcCU, uiAbsPartIdx );
    1615 
    1616     if(pcCU->getIPCMFlag(uiAbsPartIdx))
    1617     {
    1618 #if NH_3D_SDC_INTRA
    1619       m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx );
     1686    m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
     1687    m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
     1688
     1689    if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
     1690    {
     1691      m_pcEntropyCoder->encodeIPCMInfo( pcCU, uiAbsPartIdx );
     1692
     1693      if(pcCU->getIPCMFlag(uiAbsPartIdx))
     1694      {
     1695#if NH_3D
     1696        m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx );
    16201697#endif 
    16211698
    1622       // Encode slice finish
    1623       finishCU(pcCU,uiAbsPartIdx);
    1624       return;
    1625     }
    1626   }
    1627 
    1628   // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
    1629   m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
    1630 #if NH_3D_DBBP
    1631   m_pcEntropyCoder->encodeDBBPFlag( pcCU, uiAbsPartIdx );
    1632 #endif
    1633 #if NH_3D_SDC_INTRA
    1634   m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx );
    1635 #endif 
    1636 #if NH_3D_ARP
    1637   m_pcEntropyCoder->encodeARPW( pcCU , uiAbsPartIdx );
    1638 #endif
    1639 #if NH_3D_IC
    1640   m_pcEntropyCoder->encodeICFlag  ( pcCU, uiAbsPartIdx );
    1641 #endif
    1642 
    1643   // Encode Coefficients
    1644   Bool bCodeDQP = getdQPFlag();
    1645   Bool codeChromaQpAdj = getCodeChromaQpAdjFlag();
    1646   m_pcEntropyCoder->encodeCoeff( pcCU, uiAbsPartIdx, uiDepth, bCodeDQP, codeChromaQpAdj );
    1647   setCodeChromaQpAdjFlag( codeChromaQpAdj );
    1648   setdQPFlag( bCodeDQP );
    1649 #if NH_3D_DIS
     1699        // Encode slice finish
     1700        finishCU(pcCU,uiAbsPartIdx);
     1701        return;
     1702      }
     1703    }
     1704
     1705    // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
     1706    m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
     1707#if NH_3D
     1708    m_pcEntropyCoder->encodeDBBPFlag( pcCU, uiAbsPartIdx );
     1709    m_pcEntropyCoder->encodeSDCFlag( pcCU, uiAbsPartIdx );
     1710    m_pcEntropyCoder->encodeARPW( pcCU , uiAbsPartIdx );
     1711    m_pcEntropyCoder->encodeICFlag  ( pcCU, uiAbsPartIdx );
     1712#endif
     1713
     1714    // Encode Coefficients
     1715    Bool bCodeDQP = getdQPFlag();
     1716    Bool codeChromaQpAdj = getCodeChromaQpAdjFlag();
     1717    m_pcEntropyCoder->encodeCoeff( pcCU, uiAbsPartIdx, uiDepth, bCodeDQP, codeChromaQpAdj );
     1718    setCodeChromaQpAdjFlag( codeChromaQpAdj );
     1719    setdQPFlag( bCodeDQP );
     1720#if NH_3D
    16501721  }
    16511722#endif
     
    17881859#endif
    17891860
    1790 #if NH_3D_MLC
     1861#if NH_3D
    17911862  TComMvField  cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
    17921863  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
     
    18031874  }
    18041875  UChar uhDepth = rpcTempCU->getDepth( 0 );
    1805 #if NH_3D_IC
     1876#if NH_3D
    18061877  Bool bICFlag = rpcTempCU->getICFlag( 0 );
    18071878#endif
     
    18171888#endif
    18181889
    1819 #if NH_3D_ARP
     1890#if NH_3D 
    18201891  DisInfo cOrigDisInfo = rpcTempCU->getDvInfo(0);
    1821 #else
    18221892#endif
    18231893
    18241894  rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to CTU level
    18251895
    1826 #if NH_3D_SPIVMP
     1896#if NH_3D
    18271897  Bool bSPIVMPFlag[MRG_MAX_NUM_CANDS_MEM];
    18281898  memset(bSPIVMPFlag, false, sizeof(Bool)*MRG_MAX_NUM_CANDS_MEM);
     
    18311901  pcMvFieldSP = new TComMvField[rpcTempCU->getPic()->getPicSym()->getNumPartitionsInCtu()*2];
    18321902  puhInterDirSP = new UChar[rpcTempCU->getPic()->getPicSym()->getNumPartitionsInCtu()];
    1833 #endif
    1834 
    1835 #if NH_3D_VSP
    1836 #if !NH_3D_ARP
    1837   Int vspFlag[MRG_MAX_NUM_CANDS_MEM];
    1838   memset(vspFlag, 0, sizeof(Int)*MRG_MAX_NUM_CANDS_MEM);
    1839 #if NH_3D_MLC
    1840   rpcTempCU->initAvailableFlags();
    1841 #endif
    1842   rpcTempCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
    1843 #if NH_3D_MLC
    1844   rpcTempCU->xGetInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours
    1845 #if NH_3D_SPIVMP
    1846     , pcMvFieldSP, puhInterDirSP
    1847 #endif
    1848     , numValidMergeCand
    1849     );
    1850 
    1851   rpcTempCU->buildMCL( cMvFieldNeighbours,uhInterDirNeighbours, vspFlag
    1852 #if NH_3D_SPIVMP
    1853     , bSPIVMPFlag
    1854 #endif
    1855     , numValidMergeCand
    1856     );
    1857 #endif
    1858 #endif
    1859 #else
    1860 #if NH_3D_MLC
    1861   rpcTempCU->initAvailableFlags();
    1862 #endif
     1903  Int mergeCandBuffer[MRG_MAX_NUM_CANDS_MEM];
     1904
     1905  for( UInt ui = 0; ui < rpcTempCU->getSlice()->getMaxNumMergeCand(); ++ui )
     1906#else
     1907
     1908#if MCTS_ENC_CHECK
     1909  UInt numSpatialMergeCandidates = 0;
     1910  rpcTempCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, numSpatialMergeCandidates );
     1911#else
    18631912  rpcTempCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours, numValidMergeCand );
    1864 #if NH_3D_MLC
    1865   rpcTempCU->xGetInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours
    1866 #if H_3D_SPIVMP
    1867     , pcMvFieldSP, puhInterDirSP
    1868 #endif
    1869     , numValidMergeCand
    1870     );
    1871 #if NH_3D_MLC
    1872   rpcTempCU->buildMCL( cMvFieldNeighbours,uhInterDirNeighbours
    1873 #if H_3D_SPIVMP
    1874     , bSPIVMPFlag
    1875 #endif
    1876     , numValidMergeCand
    1877     );
    1878 #endif
    1879 #endif
    1880 #endif
    1881 
    1882 #if NH_3D_MLC
    1883   Int mergeCandBuffer[MRG_MAX_NUM_CANDS_MEM];
    1884 #else
     1913#endif
    18851914  Int mergeCandBuffer[MRG_MAX_NUM_CANDS];
    1886 #endif
    1887 #if NH_3D_MLC
    1888   for( UInt ui = 0; ui < rpcTempCU->getSlice()->getMaxNumMergeCand(); ++ui )
    1889 #else
    18901915  for( UInt ui = 0; ui < numValidMergeCand; ++ui )
    18911916#endif
     
    18931918    mergeCandBuffer[ui] = 0;
    18941919  }
     1920
     1921#if MCTS_ENC_CHECK && !NH_3D
     1922  if (m_pcEncCfg->getTMCTSSEITileConstraint() && rpcTempCU->isLastColumnCTUInTile())
     1923  {
     1924    numValidMergeCand = numSpatialMergeCandidates;
     1925  }
     1926#endif
    18951927
    18961928  Bool bestIsSkip = false;
     
    19071939  DEBUG_STRING_NEW(bestStr)
    19081940
    1909 #if NH_3D_ARP
     1941#if NH_3D
    19101942  Int nARPWMax = rpcTempCU->getSlice()->getARPStepNum() - 1;
    1911 #if NH_3D_IC
    19121943  if( nARPWMax < 0 || bICFlag )
    1913 #else
    1914   if( nARPWMax < 0 )
    1915 #endif
    19161944  {
    19171945    nARPWMax = 0;
     
    19191947  for( Int nARPW=nARPWMax; nARPW >= 0 ; nARPW-- )
    19201948  {
    1921 #if NH_3D
    19221949#if DEBUG_STRING
    19231950    bestStr.clear();
    19241951#endif
    1925 #endif
    1926 #if NH_3D_IV_MERGE
    19271952    memset( mergeCandBuffer, 0, MRG_MAX_NUM_CANDS_MEM*sizeof(Int) );
    1928 #else
    1929     memset( mergeCandBuffer, 0, MRG_MAX_NUM_CANDS * sizeof(Int) );
    1930 #endif
    19311953    rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
    19321954    rpcTempCU->setARPWSubParts( (UChar)nARPW , 0 , uhDepth );
    1933 #if NH_3D_IC
    19341955    rpcTempCU->setICFlagSubParts( bICFlag, 0, 0, uhDepth );
    1935 #endif
    19361956    rpcTempCU->getDvInfo(0) = cOrigDisInfo;
    19371957    rpcTempCU->setDvInfoSubParts(cOrigDisInfo, 0, uhDepth );
    1938 #if NH_3D_VSP
    19391958    Int vspFlag[MRG_MAX_NUM_CANDS_MEM];
    19401959    memset(vspFlag, 0, sizeof(Int)*MRG_MAX_NUM_CANDS_MEM);
    1941 #endif
    1942 #if NH_3D
    1943 #if NH_3D_MLC
    19441960    rpcTempCU->initAvailableFlags();
    1945 #endif
     1961#if MCTS_ENC_CHECK
     1962    UInt numSpatialMergeCandidates = 0;
     1963    rpcTempCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, numSpatialMergeCandidates  );
     1964#else
    19461965    rpcTempCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
    1947     rpcTempCU->xGetInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours
    1948 #if NH_3D_SPIVMP
    1949       , pcMvFieldSP, puhInterDirSP
    1950 #endif
    1951       , numValidMergeCand
    1952       );
    1953 
    1954     rpcTempCU->buildMCL( cMvFieldNeighbours,uhInterDirNeighbours
    1955 #if NH_3D_VSP
    1956       , vspFlag
    1957 #endif
    1958 #if NH_3D_SPIVMP
    1959       , bSPIVMPFlag
    1960 #endif
    1961       , numValidMergeCand
    1962       );
    1963 
    1964 #else
    1965     rpcTempCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours, numValidMergeCand );
    1966 #endif
    1967 
    1968 
     1966#endif
     1967    rpcTempCU->xGetInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours, pcMvFieldSP, puhInterDirSP, numValidMergeCand );
     1968
     1969    rpcTempCU->buildMCL( cMvFieldNeighbours,uhInterDirNeighbours , vspFlag , bSPIVMPFlag, numValidMergeCand );
    19691970#endif
    19701971
     
    19771978    for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
    19781979    {
    1979 #if NH_3D_IC
     1980#if NH_3D
    19801981      if( rpcTempCU->getSlice()->getApplyIC() && rpcTempCU->getSlice()->getIcSkipParseFlag() )
    19811982      {
     
    19971998          // set MC parameters
    19981999          rpcTempCU->setPredModeSubParts( MODE_INTER, 0, uhDepth ); // interprets depth relative to CTU level
    1999 #if NH_3D_IC
     2000#if NH_3D
    20002001          rpcTempCU->setICFlagSubParts( bICFlag, 0, 0, uhDepth );
    20012002#endif
     
    20052006          rpcTempCU->setMergeFlagSubParts( true, 0, 0, uhDepth ); // interprets depth relative to CTU level
    20062007          rpcTempCU->setMergeIndexSubParts( uiMergeCand, 0, 0, uhDepth ); // interprets depth relative to CTU level
    2007 #if NH_3D_ARP
     2008#if NH_3D
    20082009          rpcTempCU->setARPWSubParts( (UChar)nARPW , 0 , uhDepth );
    2009 #endif
    2010 
    2011 #if NH_3D_VSP
    20122010          rpcTempCU->setVSPFlagSubParts( vspFlag[uiMergeCand], 0, 0, uhDepth );
    2013 #endif
    2014 #if NH_3D_SPIVMP
    20152011          rpcTempCU->setSPIVMPFlagSubParts(bSPIVMPFlag[uiMergeCand], 0, 0, uhDepth);
    20162012          if (bSPIVMPFlag[uiMergeCand])
     
    20302026          }
    20312027          else
    2032 #endif
    20332028          {
    2034 #if NH_3D_VSP
    20352029            if ( vspFlag[uiMergeCand] )
    20362030            {
     
    20622056            {
    20632057#endif
    2064             rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to CTU level
    2065             rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
    2066             rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
    2067 #if NH_3D_VSP
     2058              rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to CTU level
     2059              rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
     2060              rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
     2061#if NH_3D
    20682062            }
    20692063#endif
    2070           }
     2064#if MCTS_ENC_CHECK
     2065            if ( m_pcEncCfg->getTMCTSSEITileConstraint () && (!(m_pcPredSearch->checkTMctsMvp(rpcTempCU))))
     2066            {
     2067              continue;
     2068            }
     2069#endif
     2070#if NH_3D
     2071          }
     2072#endif
    20712073          // do MC
    20722074          m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
     
    20992101            mergeCandBuffer[uiMergeCand] = 1;
    21002102          }
    2101 #if NH_3D_DIS
     2103#if NH_3D
    21022104          rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2103 #endif
    2104 #if NH_3D_VSP
    21052105          if( rpcTempCU->getSkipFlag(0) )
    21062106          {
    21072107            rpcTempCU->setTrIdxSubParts(0, 0, uhDepth);
    21082108          }
    2109 #endif
    2110 #if NH_3D_SDC_INTER
    21112109          TComDataCU *rpcTempCUPre = rpcTempCU;
    21122110#endif
     
    21142112          xCheckDQP( rpcTempCU );
    21152113          xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth DEBUG_STRING_PASS_INTO(bestStr) DEBUG_STRING_PASS_INTO(tmpStr));
    2116 #if NH_3D_SDC_INTER
     2114#if NH_3D
    21172115          if( rpcTempCU->getSlice()->getInterSdcFlag() && !uiNoResidual )
    21182116          {
     
    21412139              }
    21422140              rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2143 #if NH_3D_DIS
    21442141              rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2145 #endif
    21462142              rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
    21472143              rpcTempCU->setCbfSubParts( 1, COMPONENT_Y, 0, uhDepth );
     
    21872183          if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
    21882184          {
    2189 #if NH_3D_SDC_INTER
     2185#if NH_3D
    21902186            if( rpcTempCU->getSlice()->getInterSdcFlag() )
    21912187            {
     
    21962192#endif
    21972193            bestIsSkip = rpcBestCU->getQtRootCbf(0) == 0;
    2198 #if NH_3D_SDC_INTER
     2194#if NH_3D
    21992195            }
    22002196#endif
     
    22412237  }
    22422238  DEBUG_STRING_APPEND(sDebug, bestStr)
    2243 #if NH_3D_ARP
     2239
     2240#if NH_3D
    22442241 }
    2245 #endif
    2246 #if NH_3D_SPIVMP
    22472242 delete[] pcMvFieldSP;
    22482243 delete[] puhInterDirSP;
    22492244#endif
     2245
    22502246#if NH_MV
    22512247 D_DEC_INDENT( g_traceModeCheck );
     
    22822278
    22832279  // prior to this, rpcTempCU will have just been reset using rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
    2284 #if NH_3D_ARP
     2280#if NH_3D
    22852281  const Bool bTransquantBypassFlag = rpcTempCU->getCUTransquantBypass(0);
    22862282#endif
     
    22902286#endif
    22912287  UChar uhDepth = rpcTempCU->getDepth( 0 );
    2292 #if NH_3D_ARP
     2288#if NH_3D
    22932289    Bool bFirstTime = true;
    22942290    Int nARPWMax    = rpcTempCU->getSlice()->getARPStepNum() - 1;
    2295 #if NH_3D_IC
     2291
    22962292    if( nARPWMax < 0 || ePartSize != SIZE_2Nx2N || rpcTempCU->getICFlag(0) )
    2297 #else
    2298     if( nARPWMax < 0 || ePartSize != SIZE_2Nx2N )
    2299 #endif
    23002293    {
    23012294      nARPWMax = 0;
     
    23232316      }
    23242317#endif
    2325 #if NH_3D_DIS
     2318#if NH_3D
    23262319      rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    23272320#endif
     
    23292322  rpcTempCU->setPredModeSubParts  ( MODE_INTER, 0, uhDepth );
    23302323  rpcTempCU->setChromaQpAdjSubParts( rpcTempCU->getCUTransquantBypass(0) ? 0 : m_cuChromaQpOffsetIdxPlus1, 0, uhDepth );
    2331 #if NH_3D_ARP
     2324
     2325#if MCTS_ENC_CHECK
     2326  rpcTempCU->setTMctsMvpIsValid(true);
     2327#endif
     2328
     2329#if NH_3D
    23322330      rpcTempCU->setARPWSubParts( (UChar)nARPW , 0 , uhDepth );
    2333 #endif
    2334 #if NH_3D_ARP
    23352331      if( bFirstTime == false && nARPWMax )
    23362332      {
     
    23552351  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth] );
    23562352#endif
    2357 #if NH_3D_ARP
     2353#if NH_3D
    23582354        if( nARPWMax )
    23592355        {
     
    23662362  if ( !rpcTempCU->getMergeAMP() )
    23672363  {
    2368 #if NH_3D_ARP
     2364#if NH_3D
    23692365        if( nARPWMax )
    23702366        {
     
    23912387#endif
    23922388
     2389#if MCTS_ENC_CHECK
     2390  if (m_pcEncCfg->getTMCTSSEITileConstraint() && (!rpcTempCU->getTMctsMvpIsValid()))
     2391  {
     2392    return;
     2393  }
     2394#endif
     2395
     2396
    23932397  m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], false DEBUG_STRING_PASS_INTO(sTest) );
    2394 #if NH_3D_VSP
     2398#if NH_3D
    23952399  if( rpcTempCU->getQtRootCbf(0)==0 )
    23962400  {
     
    24102414  DebugInterPredResiReco(sTest, *(m_ppcPredYuvTemp[uhDepth]), *(m_ppcResiYuvBest[uhDepth]), *(m_ppcRecoYuvTemp[uhDepth]), DebugStringGetPredModeMask(rpcTempCU->getPredictionMode(0)));
    24112415#endif
    2412 #if NH_3D_SDC_INTER
     2416#if NH_3D
    24132417      TComDataCU *rpcTempCUPre = rpcTempCU;
    24142418#endif
     
    24162420  xCheckDQP( rpcTempCU );
    24172421  xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth DEBUG_STRING_PASS_INTO(sDebug) DEBUG_STRING_PASS_INTO(sTest));
    2418 #if NH_3D_SDC_INTER
     2422#if NH_3D
    24192423      if( rpcTempCU->getSlice()->getInterSdcFlag() && ePartSize == SIZE_2Nx2N)
    24202424      {
     
    24452449          }
    24462450          rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
    2447 #if NH_3D_DIS
    24482451          rpcTempCU->setDISFlagSubParts( false, 0, uhDepth );
    2449 #endif
    24502452          rpcTempCU->setTrIdxSubParts( 0, 0, uhDepth );
    24512453          rpcTempCU->setCbfSubParts( 1, COMPONENT_Y, 0, uhDepth );
     
    24872489
    24882490      }
    2489 #endif
    2490 #if NH_3D_ARP
    24912491    }
    24922492#endif
     
    24992499}
    25002500
    2501 #if NH_3D_DBBP
     2501#if NH_3D
    25022502Void TEncCu::xInvalidateOriginalSegments( TComYuv* pOrigYuv, TComYuv* pOrigYuvTemp, Bool* pMask, UInt uiValidSegment )
    25032503{
     
    25582558  }
    25592559}
    2560 #endif
    2561 
    2562 #if NH_3D_DBBP
     2560
    25632561Void TEncCu::xCheckRDCostInterDBBP( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU  DEBUG_STRING_FN_DECLARE(sDebug), Bool bUseMRG )
    25642562{
     
    25832581  AOF( uiWidth == uiHeight );
    25842582 
    2585 #if NH_3D_DBBP
    25862583  if(uiWidth <= 8)
    25872584  {
    25882585    return;
    25892586  }
    2590 #endif
    25912587 
    25922588  rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N,  0, uhDepth );
     
    25942590  // fetch virtual depth block
    25952591  UInt uiDepthStride = 0;
    2596 #if H_3D_FCO
    2597   Pel* pDepthPels = rpcTempCU->getVirtualDepthBlock(rpcTempCU->getZorderIdxInCU(), uiWidth, uiHeight, uiDepthStride);
    2598 #else
    25992592  Pel* pDepthPels = rpcTempCU->getVirtualDepthBlock(0, uiWidth, uiHeight, uiDepthStride);
    2600 #endif
    26012593  AOF( pDepthPels != NULL );
    26022594  AOF( uiDepthStride != 0 );
     
    26432635    pDBBPTmpData->auhMergeIndex[uiSegment] = rpcTempCU->getMergeIndex(0);
    26442636   
    2645 #if NH_3D_VSP
    26462637    AOF( rpcTempCU->getSPIVMPFlag(0) == false );
    26472638    AOF( rpcTempCU->getVSPFlag(0) == 0 );
    2648 #endif
    26492639   
    26502640    for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
     
    26982688  xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth  DEBUG_STRING_PASS_INTO(sDebug) DEBUG_STRING_PASS_INTO(sTest) );
    26992689}
    2700 #endif
    2701 #if NH_3D_DIS
     2690
    27022691Void TEncCu::xCheckRDCostDIS( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize eSize DEBUG_STRING_FN_DECLARE(sDebug) )
    27032692{
     
    27332722  rpcTempCU->setDISFlagSubParts(true, 0, uiDepth);
    27342723  rpcTempCU->setIntraDirSubParts(CHANNEL_TYPE_LUMA, DC_IDX, 0, uiDepth);
    2735 #if NH_3D_SDC_INTRA
    27362724  rpcTempCU->setSDCFlagSubParts( false, 0, uiDepth);
    2737 #endif
    27382725
    27392726  UInt uiPreCalcDistC;
     
    27502737
    27512738  m_pcEntropyCoder->resetBits();
    2752   if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
     2739  if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnabledFlag())
    27532740  {
    27542741    m_pcEntropyCoder->encodeCUTransquantBypassFlag( rpcTempCU, 0,          true );
     
    27822769                                PartSize     eSize
    27832770                                DEBUG_STRING_FN_DECLARE(sDebug)
    2784 #if NH_3D_ENC_DEPTH
     2771#if NH_3D
    27852772                              , Bool bOnlyIVP
    27862773#endif
     
    27982785    }
    27992786  }
     2787
    28002788#if NH_MV
    28012789  D_PRINT_INC_INDENT (g_traceModeCheck, "xCheckRDCostIntra; eSize: " + n2s(eSize) );
     
    28152803
    28162804  rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
    2817 #if NH_3D_DIS
     2805#if NH_3D
    28182806  rpcTempCU->setDISFlagSubParts( false, 0, uiDepth );
    28192807#endif
     
    28272815
    28282816  m_pcPredSearch->estIntraPredLumaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], resiLuma DEBUG_STRING_PASS_INTO(sTest)
    2829 #if NH_3D_ENC_DEPTH
     2817#if NH_3D
    28302818                                    , bOnlyIVP
    28312819#endif
     
    28392827  }
    28402828 
    2841 #if NH_3D_SDC_INTRA
     2829#if NH_3D
    28422830  if( rpcTempCU->getSDCFlag( 0 ) )
    28432831  {
     
    28492837  m_pcEntropyCoder->resetBits();
    28502838
    2851   if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
     2839  if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnabledFlag())
    28522840  {
    28532841    m_pcEntropyCoder->encodeCUTransquantBypassFlag( rpcTempCU, 0,          true );
    28542842  }
    28552843  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
    2856 #if NH_3D_DIS
     2844#if NH_3D
    28572845  m_pcEntropyCoder->encodeDIS( rpcTempCU, 0,          true );
    28582846  if(!rpcTempCU->getDISFlag(0))
     
    28632851    m_pcEntropyCoder->encodePredInfo( rpcTempCU, 0 );
    28642852    m_pcEntropyCoder->encodeIPCMInfo(rpcTempCU, 0, true );
    2865 #if NH_3D_SDC_INTRA
     2853#if NH_3D
    28662854    m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
    28672855#endif
     
    28732861    setCodeChromaQpAdjFlag( codeChromaQpAdjFlag );
    28742862    setdQPFlag( bCodeDQP );
    2875 #if NH_3D_DIS
     2863#if NH_3D
    28762864  }
    28772865#endif
     
    29312919#endif
    29322920  rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
    2933 #if NH_3D_DIS
     2921#if NH_3D
    29342922  rpcTempCU->setDISFlagSubParts( false, 0, uiDepth );
    29352923#endif
     
    29472935  m_pcEntropyCoder->resetBits();
    29482936
    2949   if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
     2937  if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnabledFlag())
    29502938  {
    29512939    m_pcEntropyCoder->encodeCUTransquantBypassFlag( rpcTempCU, 0,          true );
     
    29532941
    29542942  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
    2955 #if NH_3D_DIS
     2943#if NH_3D
    29562944  m_pcEntropyCoder->encodeDIS( rpcTempCU, 0,          true );
    29572945#endif
     
    29592947  m_pcEntropyCoder->encodePartSize ( rpcTempCU, 0, uiDepth, true );
    29602948  m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
    2961 #if NH_3D_SDC_INTRA
     2949#if NH_3D
    29622950  m_pcEntropyCoder->encodeSDCFlag( rpcTempCU, 0, true );
    29632951#endif
Note: See TracChangeset for help on using the changeset viewer.