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


Ignore:
Timestamp:
11 May 2012, 21:20:17 (12 years ago)
Author:
hschwarz
Message:

updated trunk (move to HM6.1)

File:
1 edited

Legend:

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

    r5 r56  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license.
     4 * granted under this license. 
    55 *
    6  * Copyright (c) 2010-2011, ISO/IEC
     6 * Copyright (c) 2010-2012, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    1515 *    this list of conditions and the following disclaimer in the documentation
    1616 *    and/or other materials provided with the distribution.
    17  *  * Neither the name of the ISO/IEC nor the names of its contributors may
     17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
    1818 *    be used to endorse or promote products derived from this software without
    1919 *    specific prior written permission.
     
    3232 */
    3333
    34 
    35 /** \file     TEncCU.cpp
    36     \brief    CU encoder class
     34/** \file     TEncCu.cpp
     35    \brief    Coding Unit (CU) encoder class
    3736*/
    3837
     
    4140#include "TEncCu.h"
    4241#include "TEncAnalyze.h"
     42
     43#include <cmath>
     44#include <algorithm>
     45using namespace std;
     46
     47//! \ingroup TLibEncoder
     48//! \{
    4349
    4450// ====================================================================================================================
     
    5460{
    5561  Int i;
    56 
     62 
    5763  m_uhTotalDepth   = uhTotalDepth + 1;
    5864  m_ppcBestCU      = new TComDataCU*[m_uhTotalDepth-1];
    5965  m_ppcTempCU      = new TComDataCU*[m_uhTotalDepth-1];
    60 
     66 
    6167  m_ppcPredYuvBest = new TComYuv*[m_uhTotalDepth-1];
    6268  m_ppcResiYuvBest = new TComYuv*[m_uhTotalDepth-1];
     
    6672  m_ppcRecoYuvTemp = new TComYuv*[m_uhTotalDepth-1];
    6773  m_ppcOrigYuv     = new TComYuv*[m_uhTotalDepth-1];
     74#if HHI_INTER_VIEW_RESIDUAL_PRED
    6875  m_ppcResPredTmp  = new TComYuv*[m_uhTotalDepth-1];
    69 
     76#endif
     77 
    7078#if HHI_MPI
    7179  m_puhDepthSaved  = new UChar[1ll<<( ( m_uhTotalDepth - 1 )<<1 )];
     
    7381  m_puhHeightSaved = new UChar[1ll<<( ( m_uhTotalDepth - 1 )<<1 )];
    7482#endif
     83
    7584  UInt uiNumPartitions;
    7685  for( i=0 ; i<m_uhTotalDepth-1 ; i++)
     
    7988    UInt uiWidth  = uiMaxWidth  >> i;
    8089    UInt uiHeight = uiMaxHeight >> i;
    81 
    82     m_ppcBestCU[i] = new TComDataCU; m_ppcBestCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false );
    83     m_ppcTempCU[i] = new TComDataCU; m_ppcTempCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false );
    84 
     90   
     91    m_ppcBestCU[i] = new TComDataCU; m_ppcBestCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
     92    m_ppcTempCU[i] = new TComDataCU; m_ppcTempCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
     93   
    8594    m_ppcPredYuvBest[i] = new TComYuv; m_ppcPredYuvBest[i]->create(uiWidth, uiHeight);
    8695    m_ppcResiYuvBest[i] = new TComYuv; m_ppcResiYuvBest[i]->create(uiWidth, uiHeight);
    8796    m_ppcRecoYuvBest[i] = new TComYuv; m_ppcRecoYuvBest[i]->create(uiWidth, uiHeight);
    88 
     97   
    8998    m_ppcPredYuvTemp[i] = new TComYuv; m_ppcPredYuvTemp[i]->create(uiWidth, uiHeight);
    9099    m_ppcResiYuvTemp[i] = new TComYuv; m_ppcResiYuvTemp[i]->create(uiWidth, uiHeight);
    91100    m_ppcRecoYuvTemp[i] = new TComYuv; m_ppcRecoYuvTemp[i]->create(uiWidth, uiHeight);
    92 
     101   
    93102    m_ppcOrigYuv    [i] = new TComYuv; m_ppcOrigYuv    [i]->create(uiWidth, uiHeight);
    94 
     103#if HHI_INTER_VIEW_RESIDUAL_PRED
    95104    m_ppcResPredTmp [i] = new TComYuv; m_ppcResPredTmp [i]->create(uiWidth, uiHeight);
    96   }
     105#endif
     106  }
     107 
     108  m_bEncodeDQP = false;
     109#if BURST_IPCM
     110  m_checkBurstIPCMFlag = false;
     111#endif
    97112
    98113  // initialize partition order.
     
    100115  initZscanToRaster( m_uhTotalDepth, 1, 0, piTmp);
    101116  initRasterToZscan( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
    102 
     117 
    103118  // initialize conversion matrix from partition index to pel
    104119  initRasterToPelXY( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
     120  initMotionReferIdx ( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
    105121}
    106122
     
    108124{
    109125  Int i;
    110 
     126 
    111127#if HHI_MPI
    112128  delete[] m_puhDepthSaved;  m_puhDepthSaved  = NULL;
     
    152168      m_ppcOrigYuv[i]->destroy();     delete m_ppcOrigYuv[i];     m_ppcOrigYuv[i] = NULL;
    153169    }
     170#if HHI_INTER_VIEW_RESIDUAL_PRED
    154171    if(m_ppcResPredTmp[i])
    155172    {
    156173      m_ppcResPredTmp [i]->destroy(); delete m_ppcResPredTmp[i];  m_ppcResPredTmp[i] = NULL;
    157174    }
     175#endif
    158176  }
    159177  if(m_ppcBestCU)
     
    167185    m_ppcTempCU = NULL;
    168186  }
    169 
     187 
    170188  if(m_ppcPredYuvBest)
    171189  {
     
    203221    m_ppcOrigYuv = NULL;
    204222  }
     223#if HHI_INTER_VIEW_RESIDUAL_PRED
    205224  if(m_ppcResPredTmp)
    206225  {
     
    208227    m_ppcResPredTmp = NULL;
    209228  }
     229#endif
    210230}
    211231
     
    215235{
    216236  m_pcEncCfg           = pcEncTop;
    217   m_pcEncTop           = pcEncTop;
    218237  m_pcPredSearch       = pcEncTop->getPredSearch();
    219238  m_pcTrQuant          = pcEncTop->getTrQuant();
    220239  m_pcBitCounter       = pcEncTop->getBitCounter();
    221240  m_pcRdCost           = pcEncTop->getRdCost();
    222 
     241 
    223242  m_pcEntropyCoder     = pcEncTop->getEntropyCoder();
    224243  m_pcCavlcCoder       = pcEncTop->getCavlcCoder();
    225244  m_pcSbacCoder       = pcEncTop->getSbacCoder();
    226245  m_pcBinCABAC         = pcEncTop->getBinCABAC();
    227 
     246 
    228247  m_pppcRDSbacCoder   = pcEncTop->getRDSbacCoder();
    229248  m_pcRDGoOnSbacCoder = pcEncTop->getRDGoOnSbacCoder();
    230 
     249 
    231250  m_bUseSBACRD        = pcEncTop->getUseSBACRD();
    232251}
     
    240259Void TEncCu::compressCU( TComDataCU*& rpcCU )
    241260{
    242   // single-QP coding mode
    243   if ( rpcCU->getSlice()->getSPS()->getUseDQP() == false )
    244   {
    245     // initialize CU data
    246     m_ppcBestCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    247     m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    248 
    249     // analysis of CU
    250     xCompressCU( m_ppcBestCU[0], m_ppcTempCU[0], 0 );
    251   }
    252   // multiple-QP coding mode
    253   else
    254   {
    255     Int iQP  = rpcCU->getSlice()->getSliceQp();
    256     Int idQP = m_pcEncCfg->getMaxDeltaQP();
    257     Int i;
    258     Int iBestQP = iQP;
    259     Double fBestCost = MAX_DOUBLE;
    260 
    261     rpcCU->getSlice()->setSliceQp( iQP );
    262     m_ppcBestCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    263     m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    264     m_ppcBestCU[0]->setQPSubParts( iQP, 0, 0 );
    265     m_ppcTempCU[0]->setQPSubParts( iQP, 0, 0 );
    266 
    267     // first try
    268     xCompressCU( m_ppcBestCU[0], m_ppcTempCU[0], 0 );
    269 
    270     // for non-zero residual case
    271     if ( !( m_ppcBestCU[0]->isSkipped( 0 ) && m_ppcBestCU[0]->getDepth( 0 ) == 0 ) )
    272     {
    273       // add dQP bits
    274       m_pcEntropyCoder->resetBits();
    275       m_pcEntropyCoder->encodeQP( m_ppcBestCU[0], 0, false );
    276       m_ppcBestCU[0]->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
    277 
    278 
    279 #if HHI_VSO
    280       if ( m_pcRdCost->getUseLambdaScaleVSO() )
    281       {
    282         m_ppcBestCU[0]->getTotalCost() = m_pcRdCost->calcRdCostVSO( m_ppcBestCU[0]->getTotalBits(), m_ppcBestCU[0]->getTotalDistortion() );
    283       }
    284       else
    285 #endif
    286       {
    287         m_ppcBestCU[0]->getTotalCost()  = m_pcRdCost->calcRdCost( m_ppcBestCU[0]->getTotalBits(), m_ppcBestCU[0]->getTotalDistortion() );
    288       }
    289 
    290       fBestCost = m_ppcBestCU[0]->getTotalCost();
    291 
    292       // try every case
    293       for ( i=iQP-idQP; i<=iQP+idQP; i++ )
    294       {
    295         if ( i == iQP ) continue;
    296 
    297         rpcCU->getSlice()->setSliceQp( i );
    298         m_ppcBestCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    299         m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    300         m_ppcBestCU[0]->setQPSubParts( i, 0, 0 );
    301         m_ppcTempCU[0]->setQPSubParts( i, 0, 0 );
    302 
    303         xCompressCU( m_ppcBestCU[0], m_ppcTempCU[0], 0 );
    304 
    305         // add dQP bits
    306         rpcCU->getSlice()->setSliceQp( iQP );
    307         m_pcEntropyCoder->resetBits();
    308         m_pcEntropyCoder->encodeQP( m_ppcBestCU[0], 0, false );
    309         m_ppcBestCU[0]->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
    310 
    311 #if HHI_VSO
    312         if (m_pcRdCost->getUseLambdaScaleVSO())
    313         {
    314           m_ppcBestCU[0]->getTotalCost()  = m_pcRdCost->calcRdCostVSO( m_ppcBestCU[0]->getTotalBits(), m_ppcBestCU[0]->getTotalDistortion() );
    315         }
    316         else
    317 #endif
    318         {
    319           m_ppcBestCU[0]->getTotalCost()  = m_pcRdCost->calcRdCost( m_ppcBestCU[0]->getTotalBits(), m_ppcBestCU[0]->getTotalDistortion() );
    320         }
    321 
    322         if ( fBestCost > m_ppcBestCU[0]->getTotalCost() )
    323         {
    324           fBestCost = m_ppcBestCU[0]->getTotalCost();
    325           iBestQP   = i;
    326         }
    327       }
    328 
    329       // perform best case
    330       rpcCU->getSlice()->setSliceQp( iBestQP );
    331       m_ppcBestCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    332       m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    333       m_ppcBestCU[0]->setQPSubParts( iBestQP, 0, 0 );
    334       m_ppcTempCU[0]->setQPSubParts( iBestQP, 0, 0 );
    335 
    336       xCompressCU( m_ppcBestCU[0], m_ppcTempCU[0], 0 );
    337 
    338       // add dQP bits
    339       rpcCU->getSlice()->setSliceQp( iQP );
    340       m_pcEntropyCoder->resetBits();
    341       m_pcEntropyCoder->encodeQP( m_ppcBestCU[0], 0, false );
    342       m_ppcBestCU[0]->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
    343 
    344 #if HHI_VSO
    345       if (m_pcRdCost->getUseLambdaScaleVSO())
    346       {
    347         m_ppcBestCU[0]->getTotalCost()  = m_pcRdCost->calcRdCostVSO( m_ppcBestCU[0]->getTotalBits(), m_ppcBestCU[0]->getTotalDistortion() );
    348       }
    349       else
    350 #endif
    351       {
    352         m_ppcBestCU[0]->getTotalCost()  = m_pcRdCost->calcRdCost( m_ppcBestCU[0]->getTotalBits(), m_ppcBestCU[0]->getTotalDistortion() );
    353       }
    354     }
    355   }
    356 }
    357 
     261  // initialize CU data
     262  m_ppcBestCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
     263  m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
     264
     265  // analysis of CU
     266  xCompressCU( m_ppcBestCU[0], m_ppcTempCU[0], 0 );
     267
     268#if ADAPTIVE_QP_SELECTION
     269  if( m_pcEncCfg->getUseAdaptQpSelect() )
     270  {
     271    if(rpcCU->getSlice()->getSliceType()!=I_SLICE) //IIII
     272    {
     273      xLcuCollectARLStats( rpcCU);
     274    }
     275  }
     276#endif
     277}
    358278/** \param  pcCU  pointer of CU data class, bForceTerminate when set to true terminates slice (default is false).
    359279 */
    360280Void TEncCu::encodeCU ( TComDataCU* pcCU, Bool bForceTerminate )
    361281{
    362 #if SNY_DQP
    363   if ( pcCU->getSlice()->getSPS()->getUseDQP() )
    364   {
    365     pcCU->setdQPFlag(true);
    366   }
    367 #endif//SNY_DQP
    368   // encode CU data
     282  if ( pcCU->getSlice()->getPPS()->getUseDQP() )
     283  {
     284    setdQPFlag(true);
     285  }
     286
     287#if BURST_IPCM
     288  TComPic* pcPic = pcCU->getPic();
     289  Bool checkBurstIPCMFlag = (pcPic->getSlice(0)->getSPS()->getUsePCM())? true : false;
     290
     291  setCheckBurstIPCMFlag( checkBurstIPCMFlag );
     292
     293  pcCU->setNumSucIPCM(0);
     294  pcCU->setLastCUSucIPCMFlag(false);
     295#endif
     296
     297  // Encode CU data
    369298  xEncodeCU( pcCU, 0, 0 );
    370 
    371 #if SNY_DQP
    372   // dQP: only for LCU
    373   if ( pcCU->getSlice()->getSPS()->getUseDQP() )
    374   {
    375     if ( pcCU->isSkipped( 0 ) && pcCU->getDepth( 0 ) == 0 )
    376     {
    377     }
    378     else if ( pcCU->getdQPFlag())// non-skip
    379     {
    380 
    381       m_pcEntropyCoder->encodeQP( pcCU, 0 );
    382       pcCU->setdQPFlag(false);
    383     }
    384   }
    385 #else
    386   // dQP: only for LCU
    387   if ( pcCU->getSlice()->getSPS()->getUseDQP() )
    388   {
    389     if ( pcCU->isSkipped( 0 ) && pcCU->getDepth( 0 ) == 0 )
    390     {
    391     }
    392     else
    393     {
    394       m_pcEntropyCoder->encodeQP( pcCU, 0 );
    395     }
    396   }
    397 #endif//SNY_DQP
    398 
    399   //--- write terminating bit ---
    400   Bool bTerminateSlice = bForceTerminate;
     299 
     300#if OL_FLUSH
     301  bool bTerminateSlice = bForceTerminate;
    401302  UInt uiCUAddr = pcCU->getAddr();
    402 
    403   if (uiCUAddr == (pcCU->getPic()->getNumCUsInFrame()-1) )
    404     bTerminateSlice = true;
    405 
    406   if (uiCUAddr == (pcCU->getSlice()->getSliceCurEndCUAddr()-1))
    407     bTerminateSlice = true;
    408 
    409   m_pcEntropyCoder->encodeTerminatingBit( bTerminateSlice ? 1 : 0 );
    410 
    411   // Encode slice finish
    412   if ( bTerminateSlice )
    413   {
    414     m_pcEntropyCoder->encodeSliceFinish();
    415   }
     303    /* If at the end of an LCU line but not at the end of a substream, perform CABAC flush */
     304#if WPP_SIMPLIFICATION
     305    if (!bTerminateSlice && pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
     306#else
     307    if (!bTerminateSlice && pcCU->getSlice()->getPPS()->getCabacIstateReset())
     308#endif
     309    {
     310      Int iNumSubstreams = pcCU->getSlice()->getPPS()->getNumSubstreams();
     311      UInt uiWidthInLCUs = pcCU->getPic()->getPicSym()->getFrameWidthInCU();
     312      UInt uiCol     = uiCUAddr % uiWidthInLCUs;
     313      UInt uiLin     = uiCUAddr / uiWidthInLCUs;
     314#if !REMOVE_TILE_DEPENDENCE
     315      Int iBreakDep = pcCU->getPic()->getPicSym()->getTileBoundaryIndependenceIdr();
     316#endif
     317      UInt uiTileStartLCU = pcCU->getPic()->getPicSym()->getTComTile(pcCU->getPic()->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
     318      UInt uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
     319      UInt uiTileLCUY = uiTileStartLCU / uiWidthInLCUs;
     320      UInt uiTileWidth = pcCU->getPic()->getPicSym()->getTComTile(pcCU->getPic()->getPicSym()->getTileIdxMap(uiCUAddr))->getTileWidth();
     321      UInt uiTileHeight = pcCU->getPic()->getPicSym()->getTComTile(pcCU->getPic()->getPicSym()->getTileIdxMap(uiCUAddr))->getTileHeight();
     322      Int iNumSubstreamsPerTile = iNumSubstreams;
     323#if !REMOVE_TILE_DEPENDENCE
     324#if WPP_SIMPLIFICATION
     325      if (iBreakDep && pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
     326#else
     327      if (iBreakDep && pcCU->getSlice()->getPPS()->getEntropyCodingSynchro())
     328#endif
     329        iNumSubstreamsPerTile /= pcCU->getPic()->getPicSym()->getNumTiles();
     330      if ((iBreakDep && (uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
     331          || (!iBreakDep && (uiCol == uiWidthInLCUs-1) && (uiLin+iNumSubstreams < pcCU->getPic()->getFrameHeightInCU())))
     332      {
     333        m_pcEntropyCoder->encodeFlush();
     334      }
     335#else
     336#if WPP_SIMPLIFICATION
     337      if (pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
     338#else
     339      if (pcCU->getSlice()->getPPS()->getEntropyCodingSynchro())
     340#endif
     341      {
     342        iNumSubstreamsPerTile /= pcCU->getPic()->getPicSym()->getNumTiles();
     343      }
     344      if ((uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
     345      {
     346        m_pcEntropyCoder->encodeFlush();
     347      }
     348#endif
     349    }
     350#endif // OL_FLUSH
    416351}
    417352
     
    419354// Protected member functions
    420355// ====================================================================================================================
    421 
     356/** Derive small set of test modes for AMP encoder speed-up
     357 *\param   rpcBestCU
     358 *\param   eParentPartSize
     359 *\param   bTestAMP_Hor
     360 *\param   bTestAMP_Ver
     361 *\param   bTestMergeAMP_Hor
     362 *\param   bTestMergeAMP_Ver
     363 *\returns Void
     364*/
     365#if AMP_ENC_SPEEDUP
     366#if AMP_MRG
     367Void TEncCu::deriveTestModeAMP (TComDataCU *&rpcBestCU, PartSize eParentPartSize, Bool &bTestAMP_Hor, Bool &bTestAMP_Ver, Bool &bTestMergeAMP_Hor, Bool &bTestMergeAMP_Ver)
     368#else
     369Void TEncCu::deriveTestModeAMP (TComDataCU *&rpcBestCU, PartSize eParentPartSize, Bool &bTestAMP_Hor, Bool &bTestAMP_Ver)
     370#endif
     371{
     372  if ( rpcBestCU->getPartitionSize(0) == SIZE_2NxN )
     373  {
     374    bTestAMP_Hor = true;
     375  }
     376  else if ( rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
     377  {
     378    bTestAMP_Ver = true;
     379  }
     380  else if ( rpcBestCU->getPartitionSize(0) == SIZE_2Nx2N && rpcBestCU->getMergeFlag(0) == false && rpcBestCU->isSkipped(0) == false )
     381  {
     382    bTestAMP_Hor = true;         
     383    bTestAMP_Ver = true;         
     384  }
     385
     386#if AMP_MRG
     387  //! Utilizing the partition size of parent PU   
     388  if ( eParentPartSize >= SIZE_2NxnU && eParentPartSize <= SIZE_nRx2N )
     389  {
     390    bTestMergeAMP_Hor = true;
     391    bTestMergeAMP_Ver = true;
     392  }
     393
     394  if ( eParentPartSize == SIZE_NONE ) //! if parent is intra
     395  {
     396    if ( rpcBestCU->getPartitionSize(0) == SIZE_2NxN )
     397    {
     398      bTestMergeAMP_Hor = true;
     399    }
     400    else if ( rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
     401    {
     402      bTestMergeAMP_Ver = true;
     403    }
     404  }
     405
     406  if ( rpcBestCU->getPartitionSize(0) == SIZE_2Nx2N && rpcBestCU->isSkipped(0) == false )
     407  {
     408    bTestMergeAMP_Hor = true;         
     409    bTestMergeAMP_Ver = true;         
     410  }
     411
     412  if ( rpcBestCU->getWidth(0) == 64 )
     413  {
     414    bTestAMP_Hor = false;
     415    bTestAMP_Ver = false;
     416  }   
     417#else
     418  //! Utilizing the partition size of parent PU       
     419  if ( eParentPartSize >= SIZE_2NxnU && eParentPartSize <= SIZE_nRx2N )
     420  {
     421    bTestAMP_Hor = true;
     422    bTestAMP_Ver = true;
     423  }
     424
     425  if ( eParentPartSize == SIZE_2Nx2N )
     426  {
     427    bTestAMP_Hor = false;
     428    bTestAMP_Ver = false;
     429  }     
     430#endif
     431}
     432#endif
     433
     434// ====================================================================================================================
     435// Protected member functions
     436// ====================================================================================================================
     437/** Compress a CU block recursively with enabling sub-LCU-level delta QP
     438 *\param   rpcBestCU
     439 *\param   rpcTempCU
     440 *\param   uiDepth
     441 *\returns Void
     442 *
     443 *- for loop of QP value to compress the current CU with all possible QP
     444*/
     445#if AMP_ENC_SPEEDUP
     446Void TEncCu::xCompressCU( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, UInt uiDepth, PartSize eParentPartSize )
     447#else
    422448Void TEncCu::xCompressCU( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, UInt uiDepth )
     449#endif
    423450{
    424451  TComPic* pcPic = rpcBestCU->getPic();
     
    428455
    429456  // variables for fast encoder decision
    430   TComDataCU* pcTempCU;
    431457  Bool    bEarlySkip  = false;
    432458  Bool    bTrySplit    = true;
    433459  Double  fRD_Skip    = MAX_DOUBLE;
     460
     461  // variable for Early CU determination
     462  Bool    bSubBranch = true;
     463
     464  // variable for Cbf fast mode PU decision
     465  Bool    doNotBlockPu = true;
     466
     467  Bool    bTrySplitDQP  = true;
    434468
    435469  static  Double  afCost[ MAX_CU_DEPTH ];
     
    448482  UInt uiBPelY   = uiTPelY + rpcBestCU->getHeight(0) - 1;
    449483
    450 #if ( HHI_INTERVIEW_SKIP)
     484#if HHI_INTERVIEW_SKIP
    451485  Bool bFullyRenderedSec = true ;
    452486  if( m_pcEncCfg->getInterViewSkip() )
     
    478512    bFullyRenderedSec = false ;
    479513  }
     514
    480515#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    481516  if( bFullyRenderedSec )
     
    491526
    492527#endif
    493   if( ( uiRPelX < rpcBestCU->getSlice()->getSPS()->getWidth() ) && ( uiBPelY < rpcBestCU->getSlice()->getSPS()->getHeight() ) )
    494   {
    495     // do inter modes
    496     if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
    497     {
    498 #if HHI_INTER_VIEW_RESIDUAL_PRED
    499       // check availability of residual prediction
    500       Bool  bResPredAvailable   = false;
    501       Bool  bResPredAllowed     =                    (!rpcBestCU->getSlice()->getSPS()->isDepth                () );
    502       bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getViewId              () );
    503       bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getMultiviewResPredMode() );
    504       if( bResPredAllowed )
    505       {
    506         bResPredAvailable       = rpcBestCU->getResidualSamples( 0, m_ppcResPredTmp[uiDepth] );
    507       }
    508 
    509       for( UInt uiResPrdId = 0; uiResPrdId < ( bResPredAvailable ? 2 : 1 ); uiResPrdId++ )
    510       {
    511         Bool bResPredFlag  = ( uiResPrdId > 0 );
    512 #endif
    513 
    514       // SKIP
    515       pcTempCU = rpcTempCU;
    516 
    517       if( pcPic->getSlice(0)->getSPS()->getUseMRG() )
    518       {
    519 #if !HHI_MRG_SKIP
     528  Int iBaseQP = xComputeQP( rpcBestCU, uiDepth );
     529  Int iMinQP;
     530  Int iMaxQP;
     531#if LOSSLESS_CODING
     532  Bool isAddLowestQP = false;
     533#if H0736_AVC_STYLE_QP_RANGE
     534  Int lowestQP = -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY();
     535#else
     536  Int lowestQP = 0;
     537#endif
     538#endif
     539
     540  if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
     541  {
     542    Int idQP = m_pcEncCfg->getMaxDeltaQP();
     543#if H0736_AVC_STYLE_QP_RANGE
     544    iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
     545    iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
     546#if LOSSLESS_CODING
     547    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
     548    {
     549      isAddLowestQP = true;
     550      iMinQP = iMinQP - 1;
     551       
     552    }
     553#endif
     554#else
     555    iMinQP = Clip3( MIN_QP, MAX_QP, iBaseQP-idQP );
     556    iMaxQP = Clip3( MIN_QP, MAX_QP, iBaseQP+idQP );
     557#if LOSSLESS_CODING
     558    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
     559    {
     560      isAddLowestQP = true;
     561      iMinQP = iMinQP - 1;
     562    }
     563#endif
     564#endif
     565  }
     566  else
     567  {
     568    iMinQP = rpcTempCU->getQP(0);
     569    iMaxQP = rpcTempCU->getQP(0);
     570  }
     571
     572  // If slice start or slice end is within this cu...
     573  TComSlice * pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
     574  Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr()>rpcTempCU->getSCUAddr()&&pcSlice->getEntropySliceCurStartCUAddr()<rpcTempCU->getSCUAddr()+rpcTempCU->getTotalNumPart();
     575  Bool bSliceEnd = (pcSlice->getEntropySliceCurEndCUAddr()>rpcTempCU->getSCUAddr()&&pcSlice->getEntropySliceCurEndCUAddr()<rpcTempCU->getSCUAddr()+rpcTempCU->getTotalNumPart());
     576  Bool bInsidePicture = ( uiRPelX < rpcBestCU->getSlice()->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < rpcBestCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
     577  // We need to split, so don't try these modes.
     578  if(!bSliceEnd && !bSliceStart && bInsidePicture )
     579  {
     580    for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
     581    {
     582#if LOSSLESS_CODING
     583      if (isAddLowestQP && (iQP == iMinQP))
     584      {
     585        iQP = lowestQP;
     586      }
     587#endif
     588      // variables for fast encoder decision
     589      bEarlySkip  = false;
     590      bTrySplit    = true;
     591      fRD_Skip    = MAX_DOUBLE;
     592
     593      rpcTempCU->initEstData( uiDepth, iQP );
     594
     595      // do inter modes, SKIP and 2Nx2N
     596      if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
     597      {
     598#if HHI_INTER_VIEW_RESIDUAL_PRED
     599        // check availability of residual prediction
     600        Bool  bResPredAvailable   = false;
     601        Bool  bResPredAllowed     =                    (!rpcBestCU->getSlice()->getSPS()->isDepth                () );
     602        bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getViewId              () );
     603        bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getMultiviewResPredMode() );
     604        if( bResPredAllowed )
     605        {
     606          bResPredAvailable       = rpcBestCU->getResidualSamples( 0, m_ppcResPredTmp[uiDepth] );
     607        }
     608
     609        for( UInt uiResPrdId = 0; uiResPrdId < ( bResPredAvailable ? 2 : 1 ); uiResPrdId++ )
     610        {
     611          Bool bResPredFlag  = ( uiResPrdId > 0 );
     612#endif
    520613#if HHI_INTER_VIEW_RESIDUAL_PRED
    521614        rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    522615#endif
    523         xCheckRDCostAMVPSkip ( rpcBestCU, rpcTempCU );        rpcTempCU->initEstData();
    524 #endif
    525 #if HHI_INTER_VIEW_RESIDUAL_PRED
    526         rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    527 #endif
     616        // SKIP
    528617#if HHI_INTERVIEW_SKIP
    529         xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU, bFullyRenderedSec );            rpcTempCU->initEstData();
    530 #else
    531         xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU );            rpcTempCU->initEstData();
    532 #endif
     618        xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU, bFullyRenderedSec );
     619#else
     620        xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU );
     621#endif
     622        rpcTempCU->initEstData( uiDepth, iQP );
     623
     624        // fast encoder decision for early skip
     625        if ( m_pcEncCfg->getUseFastEnc() )
     626        {
     627          Int iIdx = g_aucConvertToBit[ rpcBestCU->getWidth(0) ];
     628          if ( aiNum [ iIdx ] > 5 && fRD_Skip < EARLY_SKIP_THRES*afCost[ iIdx ]/aiNum[ iIdx ] )
     629          {
     630            bEarlySkip = true;
     631            bTrySplit  = false;
     632          }
     633        }
     634
     635        // 2Nx2N, NxN
     636        if ( !bEarlySkip )
     637        {
     638#if HHI_INTER_VIEW_RESIDUAL_PRED
     639          rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     640#endif
     641#if HHI_INTERVIEW_SKIP
     642            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFullyRenderedSec );
     643
     644#else
     645            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
     646#endif
     647          rpcTempCU->initEstData( uiDepth, iQP );
     648          if(m_pcEncCfg->getUseCbfFastMode())
     649          {
     650            doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     651          }
     652        }
     653#if HHI_INTER_VIEW_RESIDUAL_PRED
     654        } // uiResPrdId
     655#endif
     656      } // != I_SLICE
     657
     658
     659      if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
     660      {
     661        if(iQP == iBaseQP)
     662        {
     663          bTrySplitDQP = bTrySplit;
     664        }
    533665      }
    534666      else
    535667      {
    536 #if HHI_INTER_VIEW_RESIDUAL_PRED
    537         rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    538 #endif
    539         xCheckRDCostAMVPSkip ( rpcBestCU, rpcTempCU );        rpcTempCU->initEstData();
    540       }
    541 
    542       // fast encoder decision for early skip
    543       if ( m_pcEncCfg->getUseFastEnc() )
    544       {
    545         Int iIdx = g_aucConvertToBit[ rpcBestCU->getWidth(0) ];
    546         if ( aiNum [ iIdx ] > 5 && fRD_Skip < EARLY_SKIP_THRES*afCost[ iIdx ]/aiNum[ iIdx ] )
    547         {
    548           bEarlySkip = true;
    549           bTrySplit  = false;
     668        bTrySplitDQP = bTrySplit;
     669      }
     670#if LOSSLESS_CODING
     671      if (isAddLowestQP && (iQP == lowestQP))
     672      {
     673        iQP = iMinQP;
     674      }
     675#endif
     676    }  // end for iMinQP to iMaxQP
     677
     678
     679    for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
     680    {
     681#if LOSSLESS_CODING
     682      if (isAddLowestQP && (iQP == iMinQP))
     683      {
     684        iQP = lowestQP;
     685      }
     686#endif
     687      rpcTempCU->initEstData( uiDepth, iQP );
     688
     689      // do inter modes, NxN, 2NxN, and Nx2N
     690      if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
     691      {
     692#if HHI_INTER_VIEW_RESIDUAL_PRED
     693        // check availability of residual prediction
     694        Bool  bResPredAvailable   = false;
     695        Bool  bResPredAllowed     =                    (!rpcBestCU->getSlice()->getSPS()->isDepth                () );
     696        bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getViewId              () );
     697        bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getMultiviewResPredMode() );
     698        if( bResPredAllowed )
     699        {
     700          bResPredAvailable       = rpcBestCU->getResidualSamples( 0, m_ppcResPredTmp[uiDepth] );
    550701        }
    551       }
    552 
    553       // 2Nx2N, NxN
     702
     703        for( UInt uiResPrdId = 0; uiResPrdId < ( bResPredAvailable ? 2 : 1 ); uiResPrdId++ )
     704        {
     705          Bool bResPredFlag  = ( uiResPrdId > 0 );
     706#endif
     707        // 2Nx2N, NxN
     708        if ( !bEarlySkip )
     709        {
     710
     711        if(!( rpcBestCU->getSlice()->getSPS()->getDisInter4x4()  && (rpcBestCU->getWidth(0)==8) && (rpcBestCU->getHeight(0)==8) ))
     712        {
     713          if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && doNotBlockPu)
     714          {
     715#if HHI_INTER_VIEW_RESIDUAL_PRED
     716            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     717#endif
     718#if HHI_INTERVIEW_SKIP
     719            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN, bFullyRenderedSec   );
     720#else
     721            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN   );
     722#endif
     723            rpcTempCU->initEstData( uiDepth, iQP );
     724          }
     725        }
     726        }
     727
     728        { // 2NxN, Nx2N
     729          if(doNotBlockPu)
     730          {
     731#if HHI_INTER_VIEW_RESIDUAL_PRED
     732            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     733#endif
     734#if HHI_INTERVIEW_SKIP
     735            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N, bFullyRenderedSec   );
     736#else
     737            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N  );
     738#endif
     739            rpcTempCU->initEstData( uiDepth, iQP );
     740            if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
     741            {
     742              doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     743            }
     744          }
     745          if(doNotBlockPu)
     746          {
     747#if HHI_INTER_VIEW_RESIDUAL_PRED
     748            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     749#endif
     750#if HHI_INTERVIEW_SKIP
     751            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxN, bFullyRenderedSec   );
     752#else
     753            xCheckRDCostInter      ( rpcBestCU, rpcTempCU, SIZE_2NxN  );
     754#endif
     755            rpcTempCU->initEstData( uiDepth, iQP );
     756            if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxN)
     757            {
     758              doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     759            }
     760          }
     761        }
     762
     763#if 1
     764        //! Try AMP (SIZE_2NxnU, SIZE_2NxnD, SIZE_nLx2N, SIZE_nRx2N)
     765        if( pcPic->getSlice(0)->getSPS()->getAMPAcc(uiDepth) )
     766        {
     767#if AMP_ENC_SPEEDUP       
     768          Bool bTestAMP_Hor = false, bTestAMP_Ver = false;
     769
     770#if AMP_MRG
     771          Bool bTestMergeAMP_Hor = false, bTestMergeAMP_Ver = false;
     772
     773          deriveTestModeAMP (rpcBestCU, eParentPartSize, bTestAMP_Hor, bTestAMP_Ver, bTestMergeAMP_Hor, bTestMergeAMP_Ver);
     774#else
     775          deriveTestModeAMP (rpcBestCU, eParentPartSize, bTestAMP_Hor, bTestAMP_Ver);
     776#endif
     777
     778          //! Do horizontal AMP
     779          if ( bTestAMP_Hor )
     780          {
     781            if(doNotBlockPu)
     782            {
     783#if HHI_INTER_VIEW_RESIDUAL_PRED
     784              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     785#endif
     786#if HHI_INTERVIEW_SKIP
     787              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec );
     788#else
     789              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
     790#endif
     791              rpcTempCU->initEstData( uiDepth, iQP );
     792              if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
     793              {
     794                doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     795              }
     796            }
     797            if(doNotBlockPu)
     798            {
     799#if HHI_INTER_VIEW_RESIDUAL_PRED
     800              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     801#endif
     802#if HHI_INTERVIEW_SKIP
     803              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec );
     804#else
     805              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
     806#endif
     807              rpcTempCU->initEstData( uiDepth, iQP );
     808              if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
     809              {
     810                doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     811              }
     812            }
     813          }
     814#if AMP_MRG
     815          else if ( bTestMergeAMP_Hor )
     816          {
     817            if(doNotBlockPu)
     818            {
     819#if HHI_INTER_VIEW_RESIDUAL_PRED
     820              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     821#endif
     822#if HHI_INTERVIEW_SKIP
     823              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec, true );
     824#else
     825              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, true );
     826#endif
     827              rpcTempCU->initEstData( uiDepth, iQP );
     828              if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
     829              {
     830                doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     831              }
     832            }
     833            if(doNotBlockPu)
     834            {
     835#if HHI_INTER_VIEW_RESIDUAL_PRED
     836              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     837#endif
     838#if HHI_INTERVIEW_SKIP
     839              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec, true );
     840#else
     841              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, true );
     842#endif
     843              rpcTempCU->initEstData( uiDepth, iQP );
     844              if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
     845              {
     846                doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     847              }
     848            }
     849          }
     850#endif
     851
     852          //! Do horizontal AMP
     853          if ( bTestAMP_Ver )
     854          {
     855            if(doNotBlockPu)
     856            {
     857#if HHI_INTER_VIEW_RESIDUAL_PRED
     858              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     859#endif
     860#if HHI_INTERVIEW_SKIP
     861              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec );
     862#else
     863              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
     864#endif
     865              rpcTempCU->initEstData( uiDepth, iQP );
     866              if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
     867              {
     868                doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     869              }
     870            }
     871            if(doNotBlockPu)
     872            {
     873#if HHI_INTER_VIEW_RESIDUAL_PRED
     874              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     875#endif
     876#if HHI_INTERVIEW_SKIP
     877              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec );
     878#else
     879              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
     880#endif
     881              rpcTempCU->initEstData( uiDepth, iQP );
     882            }
     883          }
     884#if AMP_MRG
     885          else if ( bTestMergeAMP_Ver )
     886          {
     887            if(doNotBlockPu)
     888            {
     889#if HHI_INTER_VIEW_RESIDUAL_PRED
     890              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     891#endif
     892#if HHI_INTERVIEW_SKIP
     893              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec, true );
     894#else
     895              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, true );
     896#endif
     897              rpcTempCU->initEstData( uiDepth, iQP );
     898              if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
     899              {
     900                doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
     901              }
     902            }
     903            if(doNotBlockPu)
     904            {
     905#if HHI_INTER_VIEW_RESIDUAL_PRED
     906              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     907#endif
     908#if HHI_INTERVIEW_SKIP
     909              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec, true );
     910#else
     911              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, true );
     912#endif
     913              rpcTempCU->initEstData( uiDepth, iQP );
     914            }
     915          }
     916#endif
     917
     918#else
     919#if HHI_INTER_VIEW_RESIDUAL_PRED
     920              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     921#endif
     922#if HHI_INTERVIEW_SKIP
     923              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec );
     924#else
     925          xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
     926#endif
     927          rpcTempCU->initEstData( uiDepth, iQP );
     928#if HHI_INTER_VIEW_RESIDUAL_PRED
     929              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     930#endif
     931#if HHI_INTERVIEW_SKIP
     932              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec );
     933#else
     934          xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
     935#endif
     936          rpcTempCU->initEstData( uiDepth, iQP );
     937#if HHI_INTER_VIEW_RESIDUAL_PRED
     938              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     939#endif
     940#if HHI_INTERVIEW_SKIP
     941              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec );
     942#else
     943          xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
     944#endif
     945          rpcTempCU->initEstData( uiDepth, iQP );
     946#if HHI_INTER_VIEW_RESIDUAL_PRED
     947              rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
     948#endif
     949#if HHI_INTERVIEW_SKIP
     950              xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec );
     951#else
     952          xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
     953#endif
     954          rpcTempCU->initEstData( uiDepth, iQP );
     955
     956#endif
     957        } //! Try AMP (SIZE_2NxnU, SIZE_2NxnD, SIZE_nLx2N, SIZE_nRx2N)
     958#endif
     959#if HHI_INTER_VIEW_RESIDUAL_PRED
     960        } // uiResPrdId
     961#endif
     962      } // != I_SLICE
     963
     964      // initialize PCM flag
     965      rpcTempCU->setIPCMFlag( 0, false);
     966      rpcTempCU->setIPCMFlagSubParts ( false, 0, uiDepth); //SUB_LCU_DQP
     967
     968      // do normal intra modes
    554969      if ( !bEarlySkip )
    555970      {
    556 #if HHI_DISABLE_INTER_NxN_SPLIT
    557 #if HHI_INTER_VIEW_RESIDUAL_PRED
    558         rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    559 #endif
    560 #if HHI_INTERVIEW_SKIP
    561         xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFullyRenderedSec );  rpcTempCU->initEstData();
    562 #else
    563         xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );  rpcTempCU->initEstData();
    564 #endif
    565         if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    566         {
    567 #if HHI_INTER_VIEW_RESIDUAL_PRED
    568           rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    569 #endif
    570 #if HHI_INTERVIEW_SKIP
    571           xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFullyRenderedSec );  rpcTempCU->initEstData();
    572 #else
    573           xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN   );  rpcTempCU->initEstData();
    574 #endif
    575         }
    576 #else
    577 #if HHI_INTER_VIEW_RESIDUAL_PRED
    578         rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    579 #endif
    580 #if HHI_INTERVIEW_SKIP
    581         xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFullyRenderedSec );  rpcTempCU->initEstData();
    582 #else
    583         xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );  rpcTempCU->initEstData();
    584 #endif
    585 #if HHI_INTER_VIEW_RESIDUAL_PRED
    586         rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    587 #endif
    588 #if HHI_INTERVIEW_SKIP
    589         xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN, bFullyRenderedSec   );  rpcTempCU->initEstData();
    590 #else
    591         xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN   );  rpcTempCU->initEstData();
    592 #endif
    593 #endif
    594       }
    595 
    596 #if HHI_RMP_SWITCH
    597       if( pcPic->getSlice(0)->getSPS()->getUseRMP() )
    598 #endif
    599       { // 2NxN, Nx2N
    600 #if HHI_INTER_VIEW_RESIDUAL_PRED
    601         rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    602 #endif
    603 #if HHI_INTERVIEW_SKIP
    604         xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N, bFullyRenderedSec  );  rpcTempCU->initEstData();
    605 #else
    606         xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N  );  rpcTempCU->initEstData();
    607 #endif
    608 #if HHI_INTER_VIEW_RESIDUAL_PRED
    609         rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
    610 #endif
    611 #if HHI_INTERVIEW_SKIP
    612         xCheckRDCostInter      ( rpcBestCU, rpcTempCU, SIZE_2NxN, bFullyRenderedSec  );  rpcTempCU->initEstData();
    613 #else
    614         xCheckRDCostInter      ( rpcBestCU, rpcTempCU, SIZE_2NxN  );  rpcTempCU->initEstData();
    615 #endif
    616       }
    617 
    618 #if HHI_INTER_VIEW_RESIDUAL_PRED
    619     } // uiResPrdId
    620 #endif
    621     }
    622 
    623     // do normal intra modes
    624     if ( !bEarlySkip )
    625     {
    626       // speedup for inter frames
     971        // speedup for inter frames
    627972#if HHI_INTERVIEW_SKIP
    628973      if( ( rpcBestCU->getSlice()->getSliceType() == I_SLICE ||
     
    631976               rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0 ) && !bFullyRenderedSec ) // avoid very complex intra if it is unlikely
    632977#else
    633       if( rpcBestCU->getSlice()->getSliceType() == I_SLICE ||
    634          rpcBestCU->getCbf( 0, TEXT_LUMA     ) != 0   ||
    635          rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0   ||
    636          rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0     ) // avoid very complex intra if it is unlikely
    637 #endif
    638       {
    639         xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N ); rpcTempCU->initEstData();
    640 #if MTK_DISABLE_INTRA_NxN_SPLIT
    641         if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    642 #endif
    643         {
    644           if( rpcTempCU->getWidth(0) > ( 1 << rpcTempCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() ) )
     978        if( rpcBestCU->getSlice()->getSliceType() == I_SLICE ||
     979          rpcBestCU->getCbf( 0, TEXT_LUMA     ) != 0   ||
     980          rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0   ||
     981          rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0     ) // avoid very complex intra if it is unlikely
     982#endif
     983        {
     984          xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
     985          rpcTempCU->initEstData( uiDepth, iQP );
     986          if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
    645987          {
    646             xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN   ); rpcTempCU->initEstData();
     988            if( rpcTempCU->getWidth(0) > ( 1 << rpcTempCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() ) )
     989            {
     990              xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN   );
     991              rpcTempCU->initEstData( uiDepth, iQP );
     992            }
    647993          }
    648994        }
    649995      }
     996
     997      // test PCM
     998      if(pcPic->getSlice(0)->getSPS()->getUsePCM()
     999        && rpcTempCU->getWidth(0) <= (1<<pcPic->getSlice(0)->getSPS()->getPCMLog2MaxSize())
     1000        && rpcTempCU->getWidth(0) >= (1<<pcPic->getSlice(0)->getSPS()->getPCMLog2MinSize()) )
     1001      {
     1002        UInt uiRawBits = (g_uiBitDepth * rpcBestCU->getWidth(0) * rpcBestCU->getHeight(0) * 3 / 2);
     1003        UInt uiBestBits = rpcBestCU->getTotalBits();
     1004#if HHI_VSO
     1005        Double dRDCostTemp = m_pcRdCost->getUseVSO() ? m_pcRdCost->calcRdCostVSO(uiRawBits, 0) : m_pcRdCost->calcRdCost(uiRawBits, 0);
     1006        if((uiBestBits > uiRawBits) || (rpcBestCU->getTotalCost() > dRDCostTemp ))
     1007#else
     1008        if((uiBestBits > uiRawBits) || (rpcBestCU->getTotalCost() > m_pcRdCost->calcRdCost(uiRawBits, 0)))
     1009#endif
     1010        {
     1011          xCheckIntraPCM (rpcBestCU, rpcTempCU);
     1012          rpcTempCU->initEstData( uiDepth, iQP );
     1013        }
     1014      }
     1015#if HHI_MPI
     1016      if( rpcBestCU->getSlice()->getSPS()->getUseMVI() && rpcBestCU->getSlice()->getSliceType() != I_SLICE )
     1017      {
     1018        xCheckRDCostMvInheritance( rpcBestCU, rpcTempCU, uiDepth, false, false );
     1019        rpcTempCU->initEstData( uiDepth, iQP );
     1020        xCheckRDCostMvInheritance( rpcBestCU, rpcTempCU, uiDepth, true, false );
     1021        rpcTempCU->initEstData( uiDepth, iQP );
     1022      }
     1023#endif
     1024#if LOSSLESS_CODING
     1025      if (isAddLowestQP && (iQP == lowestQP))
     1026      {
     1027        iQP = iMinQP;
     1028      }
     1029#endif
    6501030    }
    6511031
     
    6531033    m_pcEntropyCoder->encodeSplitFlag( rpcBestCU, 0, uiDepth, true );
    6541034    rpcBestCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
    655 
    656 #if HHI_VSO
    657     if (m_pcRdCost->getUseLambdaScaleVSO())
     1035    if(m_pcEncCfg->getUseSBACRD())
     1036    {
     1037      rpcBestCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
     1038    }
     1039
     1040#if HHI_VSO   
     1041    if ( m_pcRdCost->getUseVSO() )
    6581042    {
    6591043      rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
     
    6621046#endif
    6631047    {
    664 #if HHI_INTERVIEW_SKIP
    665   if(  m_pcEncCfg->getInterViewSkip())
    666       {
    667         TComYuv*  pRec    = m_ppcRecoYuvBest[ uiDepth ];
    668         TComYuv*  pOrg    = m_ppcOrigYuv    [ uiDepth ];
    669         Pel*      pUsedY  = pcPic->getUsedPelsMap()->getLumaAddr( rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
    670         Pel*      pUsedU  = pcPic->getUsedPelsMap()->getCbAddr  ( rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
    671         Pel*      pUsedV  = pcPic->getUsedPelsMap()->getCrAddr  ( rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
    672         Int       iUStrdY = pcPic->getUsedPelsMap()->getStride  ();
    673         Int       iUStrdC = pcPic->getUsedPelsMap()->getCStride ();
    674         UInt      uiWdt   = rpcBestCU->getWidth ( 0 );
    675         UInt      uiHgt   = rpcBestCU->getHeight( 0 );
    676         UInt      uiDist  = ( m_pcRdCost->getDistPart( pRec->getLumaAddr(), pRec->getStride(),  pOrg->getLumaAddr(), pOrg->getStride(),  pUsedY, iUStrdY, uiWdt,      uiHgt      )
    677                             + m_pcRdCost->getDistPart( pRec->getCbAddr(),   pRec->getCStride(), pOrg->getCbAddr(),   pOrg->getCStride(), pUsedU, iUStrdC, uiWdt >> 1, uiHgt >> 1 )
    678                             + m_pcRdCost->getDistPart( pRec->getCrAddr(),   pRec->getCStride(), pOrg->getCrAddr(),   pOrg->getCStride(), pUsedV, iUStrdC, uiWdt >> 1, uiHgt >> 1 ) );
    679 //        printf("\nD(as is) = %d,   D(new) = %d,  diff = %d", rpcBestCU->getTotalDistortion(), uiDist, Int(rpcBestCU->getTotalDistortion()-uiDist) );
    680         rpcBestCU->getTotalDistortion() = uiDist;
    681       }
    682 #endif
    683       rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
    684     }
    685    
     1048    rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
     1049    }
    6861050
    6871051    // accumulate statistics for early skip
     
    6951059      }
    6961060    }
    697 #if HHI_MPI
    698     if( rpcBestCU->getSlice()->getSPS()->getUseMVI() && rpcBestCU->getSlice()->getSliceType() != I_SLICE )
    699     {
    700       xCheckRDCostMvInheritance( rpcBestCU, rpcTempCU, uiDepth, false, false ); rpcTempCU->initEstData();
    701       rpcTempCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, 0, uiDepth );
    702       rpcTempCU->setDepthSubParts( uiDepth, 0 );
    703       xCheckRDCostMvInheritance( rpcBestCU, rpcTempCU, uiDepth, true, false );  rpcTempCU->initEstData();
    704     }
    705 #endif
     1061
     1062    // Early CU determination
     1063    if( m_pcEncCfg->getUseEarlyCU() && ((*rpcBestCU->getPredictionMode()) == 0) )
     1064    {
     1065      bSubBranch = false;
     1066    }
     1067    else
     1068    {
     1069      bSubBranch = true;
     1070    }
     1071#if HHI_INTERVIEW_SKIP
     1072  rpcBestCU->setRenderableSubParts(bFullyRenderedSec,0,rpcBestCU->getDepth( 0 )) ;
     1073#endif
     1074  }
     1075  else if(!(bSliceEnd && bInsidePicture))
     1076  {
     1077    bBoundary = true;
     1078  }
     1079
     1080#if LOSSLESS_CODING
     1081  // copy orginal YUV samples to PCM buffer
     1082  if( rpcBestCU->isLosslessCoded(0) && (rpcBestCU->getIPCMFlag(0) == false))
     1083  {
     1084    xFillPCMBuffer(rpcBestCU, m_ppcOrigYuv[uiDepth]);
     1085  }
     1086#endif
     1087  if( (g_uiMaxCUWidth>>uiDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
     1088  {
     1089    Int idQP = m_pcEncCfg->getMaxDeltaQP();
     1090#if H0736_AVC_STYLE_QP_RANGE
     1091    iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
     1092    iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
     1093#if LOSSLESS_CODING
     1094    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
     1095    {
     1096      isAddLowestQP = true;
     1097      iMinQP = iMinQP - 1;     
     1098    }
     1099#endif
     1100#else
     1101    iMinQP = Clip3( MIN_QP, MAX_QP, iBaseQP-idQP );
     1102    iMaxQP = Clip3( MIN_QP, MAX_QP, iBaseQP+idQP );
     1103#if LOSSLESS_CODING
     1104    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
     1105    {
     1106      isAddLowestQP = true;
     1107      iMinQP = iMinQP - 1;
     1108    }
     1109#endif
     1110#endif
     1111  }
     1112  else if( (g_uiMaxCUWidth>>uiDepth) > rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
     1113  {
     1114    iMinQP = iBaseQP;
     1115    iMaxQP = iBaseQP;
    7061116  }
    7071117  else
    7081118  {
    709     bBoundary = true;
    710   }
    711 
    712   // further split
    713   if( bTrySplit && uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth )
    714   {
     1119    Int iStartQP;
     1120    if( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) == pcSlice->getEntropySliceCurStartCUAddr())
     1121    {
     1122      iStartQP = rpcTempCU->getQP(0);
     1123    }
     1124    else
     1125    {
     1126      UInt uiCurSliceStartPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
     1127      iStartQP = rpcTempCU->getQP(uiCurSliceStartPartIdx);
     1128    }
     1129    iMinQP = iStartQP;
     1130    iMaxQP = iStartQP;
     1131  }
     1132
     1133  for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
     1134  {
     1135#if LOSSLESS_CODING
     1136      if (isAddLowestQP && (iQP == iMinQP))
     1137      {
     1138        iQP = lowestQP;
     1139      }
     1140#endif
     1141    rpcTempCU->initEstData( uiDepth, iQP );
     1142
     1143    // further split
     1144    if( bSubBranch && bTrySplitDQP && uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth )
     1145    {
    7151146#if HHI_VSO
    716     // reset Model
    717     if( m_pcRdCost->getUseRenModel() )
    718     {
    719       UInt  uiWidth     = m_ppcBestCU[uiDepth]->getWidth ( 0 );
    720       UInt  uiHeight    = m_ppcBestCU[uiDepth]->getHeight( 0 );
    721       Pel*  piSrc       = m_ppcOrigYuv[uiDepth]->getLumaAddr( 0 );
    722       UInt  uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride();
    723       m_pcRdCost->setRenModelData( m_ppcBestCU[uiDepth], 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    724     }
    725 #endif
    726 
    727     UChar       uhNextDepth         = uiDepth+1;
    728     TComDataCU* pcSubBestPartCU     = m_ppcBestCU[uhNextDepth];
    729     TComDataCU* pcSubTempPartCU     = m_ppcTempCU[uhNextDepth];
    730 
    731     for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
    732     {
    733       pcSubBestPartCU->initSubCU( rpcBestCU, uiPartUnitIdx, uhNextDepth );           // clear sub partition datas or init.
    734       pcSubTempPartCU->initSubCU( rpcBestCU, uiPartUnitIdx, uhNextDepth );           // clear sub partition datas or init.
    735 
    736       if( ( pcSubBestPartCU->getCUPelX() < pcSubBestPartCU->getSlice()->getSPS()->getWidth() ) && ( pcSubBestPartCU->getCUPelY() < pcSubBestPartCU->getSlice()->getSPS()->getHeight() ) )
    737       {
    738         if( m_bUseSBACRD )
    739         {
    740           if ( 0 == uiPartUnitIdx) //initialize RD with previous depth buffer
     1147      // reset Model
     1148      if( m_pcRdCost->getUseRenModel() )
     1149      {
     1150        UInt  uiWidth     = m_ppcBestCU[uiDepth]->getWidth ( 0 );
     1151        UInt  uiHeight    = m_ppcBestCU[uiDepth]->getHeight( 0 );
     1152        Pel*  piSrc       = m_ppcOrigYuv[uiDepth]->getLumaAddr( 0 );
     1153        UInt  uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride();
     1154        m_pcRdCost->setRenModelData( m_ppcBestCU[uiDepth], 0, piSrc, uiSrcStride, uiWidth, uiHeight );
     1155      }
     1156#endif
     1157      UChar       uhNextDepth         = uiDepth+1;
     1158      TComDataCU* pcSubBestPartCU     = m_ppcBestCU[uhNextDepth];
     1159      TComDataCU* pcSubTempPartCU     = m_ppcTempCU[uhNextDepth];
     1160
     1161      for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
     1162      {
     1163        pcSubBestPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP );           // clear sub partition datas or init.
     1164        pcSubTempPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP );           // clear sub partition datas or init.
     1165
     1166        Bool bInSlice = pcSubBestPartCU->getSCUAddr()+pcSubBestPartCU->getTotalNumPart()>pcSlice->getEntropySliceCurStartCUAddr()&&pcSubBestPartCU->getSCUAddr()<pcSlice->getEntropySliceCurEndCUAddr();
     1167        if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
     1168        {
     1169          if( m_bUseSBACRD )
    7411170          {
    742             m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
     1171            if ( 0 == uiPartUnitIdx) //initialize RD with previous depth buffer
     1172            {
     1173              m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
     1174            }
     1175            else
     1176            {
     1177              m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
     1178            }
     1179          }
     1180
     1181#if AMP_ENC_SPEEDUP
     1182          if ( rpcBestCU->isIntra(0) )
     1183          {
     1184            xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth, SIZE_NONE );
    7431185          }
    7441186          else
    7451187          {
    746             m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
    747           }
     1188            xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth, rpcBestCU->getPartitionSize(0) );
     1189          }
     1190#else
     1191          xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth );
     1192#endif
     1193
     1194          rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );         // Keep best part data to current temporary data.
     1195          xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
     1196
     1197#if HHI_VSO
     1198          if( m_pcRdCost->getUseRenModel() ) // necessary ??
     1199          {
     1200            UInt  uiWidth     = pcSubBestPartCU->getWidth ( 0 );
     1201            UInt  uiHeight    = pcSubBestPartCU->getHeight( 0 );
     1202            Pel*  piSrc       = m_ppcRecoYuvBest[pcSubBestPartCU->getDepth(0)]->getLumaAddr( 0 );
     1203            UInt  uiSrcStride = m_ppcRecoYuvBest[pcSubBestPartCU->getDepth(0)]->getStride();
     1204            m_pcRdCost->setRenModelData( pcSubBestPartCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
     1205          }
     1206#endif
    7481207        }
    749 
    750         xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth );
     1208        else if (bInSlice)
     1209        {
     1210          pcSubBestPartCU->copyToPic( uhNextDepth );
     1211          rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );
     1212        }
     1213      }
     1214
     1215      if( !bBoundary )
     1216      {
     1217        m_pcEntropyCoder->resetBits();
     1218        m_pcEntropyCoder->encodeSplitFlag( rpcTempCU, 0, uiDepth, true );
     1219
     1220        rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
     1221        if(m_pcEncCfg->getUseSBACRD())
     1222        {
     1223          rpcTempCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
     1224        }
     1225      }
     1226#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
     1227      if( bFullyRenderedSec )
     1228      {
     1229        m_pcRdCost->setLambdaScale( m_pcEncCfg->getInterViewSkipLambdaScale() );
     1230      }
     1231      else
     1232      {
     1233        m_pcRdCost->setLambdaScale( 1 );
     1234      }
     1235#endif
    7511236
    7521237#if HHI_VSO
    753         if( m_pcRdCost->getUseRenModel() )
    754         {
    755           UInt  uiWidth     = pcSubBestPartCU->getWidth ( 0 );
    756           UInt  uiHeight    = pcSubBestPartCU->getHeight( 0 );
    757           Pel*  piSrc       = m_ppcRecoYuvBest[pcSubBestPartCU->getDepth(0)]->getLumaAddr( 0 );
    758           UInt  uiSrcStride = m_ppcRecoYuvBest[pcSubBestPartCU->getDepth(0)]->getStride();
    759           m_pcRdCost->setRenModelData( pcSubBestPartCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
     1238      if ( m_pcRdCost->getUseVSO() )
     1239      {
     1240        rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     1241      }
     1242      else
     1243#endif
     1244      {           
     1245      rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     1246      }
     1247
     1248      if( (g_uiMaxCUWidth>>uiDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() && rpcTempCU->getSlice()->getPPS()->getUseDQP())
     1249      {
     1250        Bool bHasRedisual = false;
     1251        for( UInt uiBlkIdx = 0; uiBlkIdx < rpcTempCU->getTotalNumPart(); uiBlkIdx ++)
     1252        {
     1253          if( ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(uiBlkIdx+rpcTempCU->getZorderIdxInCU()) == rpcTempCU->getSlice()->getEntropySliceCurStartCUAddr() ) &&
     1254              ( rpcTempCU->getCbf( uiBlkIdx, TEXT_LUMA ) || rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_U ) || rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_V ) ) )
     1255          {
     1256            bHasRedisual = true;
     1257            break;
     1258          }
    7601259        }
    761 #endif
    762         rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );         // Keep best part data to current temporary data.
    763         xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
    764       }
    765     }
    766 
    767     if( !bBoundary )
    768     {
    769       m_pcEntropyCoder->resetBits();
    770       m_pcEntropyCoder->encodeSplitFlag( rpcTempCU, 0, uiDepth, true );
    771 
    772       rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
    773     }
    774 
    775 #if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    776     if( bFullyRenderedSec )
    777     {
    778       m_pcRdCost->setLambdaScale( m_pcEncCfg->getInterViewSkipLambdaScale() );
    779     }
    780     else
    781     {
    782       m_pcRdCost->setLambdaScale( 1 );
    783     }
    784 #endif
     1260
     1261        UInt uiTargetPartIdx;
     1262        if ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) != pcSlice->getEntropySliceCurStartCUAddr() )
     1263        {
     1264          uiTargetPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
     1265        }
     1266        else
     1267        {
     1268          uiTargetPartIdx = 0;
     1269        }
     1270        if ( bHasRedisual )
     1271        {
     1272#if !RDO_WITHOUT_DQP_BITS
     1273          m_pcEntropyCoder->resetBits();
     1274          m_pcEntropyCoder->encodeQP( rpcTempCU, uiTargetPartIdx, false );
     1275          rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
     1276          if(m_pcEncCfg->getUseSBACRD())
     1277          {
     1278            rpcTempCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
     1279          }
    7851280#if HHI_VSO
    786     if ( m_pcRdCost->getUseLambdaScaleVSO())
    787     {
    788       rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
    789     }
    790     else
    791 #endif
    792     {
    793       rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
    794     }
    795 
    796     if( m_bUseSBACRD )
    797     {
    798       m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
    799     }
    800     xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth );                                          // RD compare current larger prediction
     1281          if ( m_pcRdCost->getUseLambdaScaleVSO())
     1282          {
     1283            rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     1284          }
     1285          else
     1286#endif
     1287          {
     1288          rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     1289          }
     1290#endif
     1291        }
     1292        else
     1293        {
     1294#if LOSSLESS_CODING
     1295          if (((rpcTempCU->getQP(uiTargetPartIdx) != rpcTempCU->getRefQP(uiTargetPartIdx)) ) && (rpcTempCU->getSlice()->getSPS()->getUseLossless()))
     1296          {
     1297            rpcTempCU->getTotalCost() = MAX_DOUBLE;
     1298          }
     1299#endif
     1300          rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( uiTargetPartIdx ), 0, uiDepth ); // set QP to default QP
     1301        }
     1302      }
     1303
     1304      if( m_bUseSBACRD )
     1305      {
     1306        m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
     1307      }
     1308      Bool bEntropyLimit=false;
     1309      Bool bSliceLimit=false;
     1310      bSliceLimit=rpcBestCU->getSlice()->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE&&(rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getSliceArgument()<<3);
     1311      if(rpcBestCU->getSlice()->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&m_pcEncCfg->getUseSBACRD())
     1312      {
     1313        if(rpcBestCU->getTotalBins()>rpcBestCU->getSlice()->getEntropySliceArgument())
     1314        {
     1315          bEntropyLimit=true;
     1316        }
     1317      }
     1318      else if(rpcBestCU->getSlice()->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE)
     1319      {
     1320        if(rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getEntropySliceArgument())
     1321        {
     1322          bEntropyLimit=true;
     1323        }
     1324      }
     1325      if(rpcBestCU->getDepth(0)>=rpcBestCU->getSlice()->getPPS()->getSliceGranularity())
     1326      {
     1327        bSliceLimit=false;
     1328        bEntropyLimit=false;
     1329      }
     1330      if(bSliceLimit||bEntropyLimit)
     1331      {
     1332        rpcBestCU->getTotalCost()=rpcTempCU->getTotalCost()+1;
     1333      }
     1334      xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth);                                  // RD compare current larger prediction
     1335    }                                                                                  // with sub partitioned prediction.
     1336#if LOSSLESS_CODING
     1337      if (isAddLowestQP && (iQP == lowestQP))
     1338      {
     1339        iQP = iMinQP;
     1340      }
     1341#endif
     1342  } // SPLIT- QP Loop
    8011343
    8021344#if HHI_VSO
    803     if( m_pcRdCost->getUseRenModel() )
    804     {
    805       UInt  uiWidth     = rpcBestCU->getWidth ( 0 );
    806       UInt  uiHeight    = rpcBestCU->getHeight( 0 );
    807       Pel*  piSrc       = m_ppcRecoYuvBest[uiDepth]->getLumaAddr( 0 );
    808       UInt  uiSrcStride = m_ppcRecoYuvBest[uiDepth]->getStride();
    809       m_pcRdCost->setRenModelData( rpcBestCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    810     }
    811 #endif
    812   }                                                                                  // with sub partitioned prediction.
     1345  if( m_pcRdCost->getUseRenModel() )
     1346  {
     1347    UInt  uiWidth     = rpcBestCU->getWidth ( 0 );
     1348    UInt  uiHeight    = rpcBestCU->getHeight( 0 );
     1349    Pel*  piSrc       = m_ppcRecoYuvBest[uiDepth]->getLumaAddr( 0 );
     1350    UInt  uiSrcStride = m_ppcRecoYuvBest[uiDepth]->getStride();
     1351    m_pcRdCost->setRenModelData( rpcBestCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
     1352  }
     1353#endif
    8131354
    8141355  rpcBestCU->copyToPic(uiDepth);                                                     // Copy Best data to Picture for next partition prediction.
    8151356
    816   if( bBoundary )
     1357  xCopyYuv2Pic( rpcBestCU->getPic(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU(), uiDepth, uiDepth, rpcBestCU, uiLPelX, uiTPelY );   // Copy Yuv data to picture Yuv
     1358  if( bBoundary ||(bSliceEnd && bInsidePicture))
     1359  {
    8171360    return;
    818 
    819   xCopyYuv2Pic( rpcBestCU->getPic(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU(), uiDepth );   // Copy Yuv data to picture Yuv
     1361  }
    8201362
    8211363  // Assert if Best prediction mode is NONE
     
    8261368}
    8271369
     1370/** finish encoding a cu and handle end-of-slice conditions
     1371 * \param pcCU
     1372 * \param uiAbsPartIdx
     1373 * \param uiDepth
     1374 * \returns Void
     1375 */
     1376Void TEncCu::finishCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
     1377{
     1378  TComPic* pcPic = pcCU->getPic();
     1379  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
     1380
     1381  //Calculate end address
     1382  UInt uiCUAddr = pcCU->getSCUAddr()+uiAbsPartIdx;
     1383
     1384  UInt uiInternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurEndCUAddr()-1) % pcPic->getNumPartInCU();
     1385  UInt uiExternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurEndCUAddr()-1) / pcPic->getNumPartInCU();
     1386  UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
     1387  UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
     1388  UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
     1389  UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
     1390  while(uiPosX>=uiWidth||uiPosY>=uiHeight)
     1391  {
     1392    uiInternalAddress--;
     1393    uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
     1394    uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
     1395  }
     1396  uiInternalAddress++;
     1397  if(uiInternalAddress==pcCU->getPic()->getNumPartInCU())
     1398  {
     1399    uiInternalAddress = 0;
     1400    uiExternalAddress = pcPic->getPicSym()->getCUOrderMap(pcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
     1401  }
     1402  UInt uiRealEndAddress = pcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress);
     1403
     1404  // Encode slice finish
     1405  Bool bTerminateSlice = false;
     1406  if (uiCUAddr+(pcCU->getPic()->getNumPartInCU()>>(uiDepth<<1)) == uiRealEndAddress)
     1407  {
     1408    bTerminateSlice = true;
     1409  }
     1410  UInt uiGranularityWidth = g_uiMaxCUWidth>>(pcSlice->getPPS()->getSliceGranularity());
     1411  uiPosX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
     1412  uiPosY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
     1413  Bool granularityBoundary=((uiPosX+pcCU->getWidth(uiAbsPartIdx))%uiGranularityWidth==0||(uiPosX+pcCU->getWidth(uiAbsPartIdx)==uiWidth))
     1414    &&((uiPosY+pcCU->getHeight(uiAbsPartIdx))%uiGranularityWidth==0||(uiPosY+pcCU->getHeight(uiAbsPartIdx)==uiHeight));
     1415 
     1416#if BURST_IPCM
     1417  if(granularityBoundary && (!(pcCU->getIPCMFlag(uiAbsPartIdx) && ( pcCU->getNumSucIPCM() > 1 ))))
     1418#else
     1419  if(granularityBoundary)
     1420#endif
     1421  {
     1422    // The 1-terminating bit is added to all streams, so don't add it here when it's 1.
     1423    if (!bTerminateSlice)
     1424      m_pcEntropyCoder->encodeTerminatingBit( bTerminateSlice ? 1 : 0 );
     1425  }
     1426 
     1427  Int numberOfWrittenBits = 0;
     1428  if (m_pcBitCounter)
     1429  {
     1430    numberOfWrittenBits = m_pcEntropyCoder->getNumberOfWrittenBits();
     1431  }
     1432 
     1433  // Calculate slice end IF this CU puts us over slice bit size.
     1434  unsigned iGranularitySize = pcCU->getPic()->getNumPartInCU()>>(pcSlice->getPPS()->getSliceGranularity()<<1);
     1435  int iGranularityEnd = ((pcCU->getSCUAddr()+uiAbsPartIdx)/iGranularitySize)*iGranularitySize;
     1436  if(iGranularityEnd<=pcSlice->getEntropySliceCurStartCUAddr())
     1437  {
     1438    iGranularityEnd+=max(iGranularitySize,(pcCU->getPic()->getNumPartInCU()>>(uiDepth<<1)));
     1439  }
     1440  // Set slice end parameter
     1441  if(pcSlice->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE&&!pcSlice->getFinalized()&&pcSlice->getSliceBits()+numberOfWrittenBits>pcSlice->getSliceArgument()<<3)
     1442  {
     1443    pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
     1444    pcSlice->setSliceCurEndCUAddr(iGranularityEnd);
     1445    return;
     1446  }
     1447  // Set entropy slice end parameter
     1448  if(m_pcEncCfg->getUseSBACRD())
     1449  {
     1450    TEncBinCABAC *pppcRDSbacCoder = (TEncBinCABAC *) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
     1451    UInt uiBinsCoded = pppcRDSbacCoder->getBinsCoded();
     1452    if(pcSlice->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&!pcSlice->getFinalized()&&pcSlice->getEntropySliceCounter()+uiBinsCoded>pcSlice->getEntropySliceArgument())
     1453    {
     1454      pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
     1455      return;
     1456    }
     1457  }
     1458  else
     1459  {
     1460    if(pcSlice->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&!pcSlice->getFinalized()&&pcSlice->getEntropySliceCounter()+numberOfWrittenBits>pcSlice->getEntropySliceArgument())
     1461    {
     1462      pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
     1463      return;
     1464    }
     1465  }
     1466  if(granularityBoundary)
     1467  {
     1468    pcSlice->setSliceBits( (UInt)(pcSlice->getSliceBits() + numberOfWrittenBits) );
     1469    if(m_pcEncCfg->getUseSBACRD())
     1470    {
     1471      TEncBinCABAC *pppcRDSbacCoder = (TEncBinCABAC *) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
     1472      pcSlice->setEntropySliceCounter(pcSlice->getEntropySliceCounter()+pppcRDSbacCoder->getBinsCoded());
     1473      pppcRDSbacCoder->setBinsCoded( 0 );
     1474    }
     1475    else
     1476    {
     1477      pcSlice->setEntropySliceCounter(pcSlice->getEntropySliceCounter()+numberOfWrittenBits);
     1478    }
     1479    if (m_pcBitCounter)
     1480    {
     1481      m_pcEntropyCoder->resetBits();     
     1482    }
     1483  }
     1484}
     1485
     1486/** Compute QP for each CU
     1487 * \param pcCU Target CU
     1488 * \param uiDepth CU depth
     1489 * \returns quantization parameter
     1490 */
     1491Int TEncCu::xComputeQP( TComDataCU* pcCU, UInt uiDepth )
     1492{
     1493  Int iBaseQp = pcCU->getSlice()->getSliceQp();
     1494  Int iQpOffset = 0;
     1495  if ( m_pcEncCfg->getUseAdaptiveQP() )
     1496  {
     1497    TEncPic* pcEPic = dynamic_cast<TEncPic*>( pcCU->getPic() );
     1498    UInt uiAQDepth = min( uiDepth, pcEPic->getMaxAQDepth()-1 );
     1499    TEncPicQPAdaptationLayer* pcAQLayer = pcEPic->getAQLayer( uiAQDepth );
     1500    UInt uiAQUPosX = pcCU->getCUPelX() / pcAQLayer->getAQPartWidth();
     1501    UInt uiAQUPosY = pcCU->getCUPelY() / pcAQLayer->getAQPartHeight();
     1502    UInt uiAQUStride = pcAQLayer->getAQPartStride();
     1503    TEncQPAdaptationUnit* acAQU = pcAQLayer->getQPAdaptationUnit();
     1504
     1505    Double dMaxQScale = pow(2.0, m_pcEncCfg->getQPAdaptationRange()/6.0);
     1506    Double dAvgAct = pcAQLayer->getAvgActivity();
     1507    Double dCUAct = acAQU[uiAQUPosY * uiAQUStride + uiAQUPosX].getActivity();
     1508    Double dNormAct = (dMaxQScale*dCUAct + dAvgAct) / (dCUAct + dMaxQScale*dAvgAct);
     1509    Double dQpOffset = log(dNormAct) / log(2.0) * 6.0;
     1510    iQpOffset = Int(floor( dQpOffset + 0.49999 ));
     1511  }
     1512#if H0736_AVC_STYLE_QP_RANGE
     1513  return Clip3(-pcCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQp+iQpOffset );
     1514#else
     1515  return Clip3( MIN_QP, MAX_QP, iBaseQp+iQpOffset );
     1516#endif
     1517}
     1518
    8281519/** encode a CU block recursively
    8291520 * \param pcCU
    8301521 * \param uiAbsPartIdx
    831  * \param uiDepth
     1522 * \param uiDepth 
    8321523 * \returns Void
    8331524 */
     
    8351526{
    8361527  TComPic* pcPic = pcCU->getPic();
    837 
     1528 
    8381529  Bool bBoundary = false;
    8391530  UInt uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
     
    8411532  UInt uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
    8421533  UInt uiBPelY   = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
    843 
    844   if( ( uiRPelX < pcCU->getSlice()->getSPS()->getWidth() ) && ( uiBPelY < pcCU->getSlice()->getSPS()->getHeight() ) )
     1534 
     1535#if BURST_IPCM
     1536  if( getCheckBurstIPCMFlag() )
     1537  {
     1538    pcCU->setLastCUSucIPCMFlag( checkLastCUSucIPCM( pcCU, uiAbsPartIdx ));
     1539    pcCU->setNumSucIPCM( countNumSucIPCM ( pcCU, uiAbsPartIdx ) );
     1540  }
     1541#endif
     1542
     1543  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
     1544  // If slice start is within this cu...
     1545  Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr() > pcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
     1546    pcSlice->getEntropySliceCurStartCUAddr() < pcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcPic->getNumPartInCU() >> (uiDepth<<1) );
     1547  // We need to split, so don't try these modes.
     1548  if(!bSliceStart&&( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
    8451549  {
    8461550#if HHI_MPI
    8471551    if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 || uiDepth < pcCU->getTextureModeDepth( uiAbsPartIdx ) )
    8481552#endif
    849       m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
     1553    m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
    8501554  }
    8511555  else
     
    8531557    bBoundary = true;
    8541558  }
    855 
     1559 
    8561560#if HHI_MPI
    8571561  if( uiDepth == pcCU->getTextureModeDepth( uiAbsPartIdx ) )
     
    8611565    pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
    8621566
    863     if( ( uiRPelX < pcCU->getSlice()->getSPS()->getWidth() ) && ( uiBPelY < pcCU->getSlice()->getSPS()->getHeight() ) )
     1567    if( ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
    8641568      m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
    8651569    if( !pcCU->getSlice()->isIntra() )
     
    8701574    if( pcCU->isSkipped( uiAbsPartIdx ) )
    8711575    {
    872 #if HHI_MRG_SKIP
    8731576      m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
    874 #else
    875       if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 ) //if ( ref. frame list0 has at least 1 entry )
    876       {
    877         m_pcEntropyCoder->encodeMVPIdx( pcCU, uiAbsPartIdx, REF_PIC_LIST_0);
    878       }
    879       if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 ) //if ( ref. frame list1 has at least 1 entry )
    880       {
    881         m_pcEntropyCoder->encodeMVPIdx( pcCU, uiAbsPartIdx, REF_PIC_LIST_1);
    882       }
    883 #endif
     1577      finishCU(pcCU,uiAbsPartIdx,uiDepth);
    8841578      xRestoreDepthWidthHeight( pcCU );
    8851579      return;
     
    8991593  {
    9001594    UInt uiQNumParts = ( pcPic->getNumPartInCU() >> (uiDepth<<1) )>>2;
     1595    if( (g_uiMaxCUWidth>>uiDepth) == pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
     1596    {
     1597      setdQPFlag(true);
     1598    }
     1599#if BURST_IPCM
     1600    pcCU->setNumSucIPCM(0);
     1601    pcCU->setLastCUSucIPCMFlag(false);
     1602#endif
    9011603    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
    9021604    {
    9031605      uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
    9041606      uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
    905 
    906       if( ( uiLPelX < pcCU->getSlice()->getSPS()->getWidth() ) && ( uiTPelY < pcCU->getSlice()->getSPS()->getHeight() ) )
     1607      Bool bInSlice = pcCU->getSCUAddr()+uiAbsPartIdx+uiQNumParts>pcSlice->getEntropySliceCurStartCUAddr()&&pcCU->getSCUAddr()+uiAbsPartIdx<pcSlice->getEntropySliceCurEndCUAddr();
     1608      if(bInSlice&&( uiLPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
     1609      {
    9071610        xEncodeCU( pcCU, uiAbsPartIdx, uiDepth+1 );
     1611      }
    9081612    }
    9091613    return;
    9101614  }
    911 
    912 #if TSB_ALF_HEADER
    913 #else
    914   m_pcEntropyCoder->encodeAlfCtrlFlag( pcCU, uiAbsPartIdx );
    915 #endif
    916 
    917 #if HHI_MPI
    918   if( !pcCU->getSlice()->isIntra() && pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
    919 #else
    920   if( !pcCU->getSlice()->isIntra() )
    921 #endif
    922   {
    923     m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
    924   }
    925 
    926   if( pcCU->isSkipped( uiAbsPartIdx ) )
    927   {
    928 #if HHI_MRG_SKIP
    929     m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
    930 #else
    931     if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 ) //if ( ref. frame list0 has at least 1 entry )
    932     {
    933       m_pcEntropyCoder->encodeMVPIdx( pcCU, uiAbsPartIdx, REF_PIC_LIST_0);
    934     }
    935     if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 ) //if ( ref. frame list1 has at least 1 entry )
    936     {
    937       m_pcEntropyCoder->encodeMVPIdx( pcCU, uiAbsPartIdx, REF_PIC_LIST_1);
    938     }
    939 #endif
    940 #if HHI_INTER_VIEW_RESIDUAL_PRED
    941     m_pcEntropyCoder->encodeResPredFlag( pcCU, uiAbsPartIdx, 0 );
    942 #endif
    943     return;
     1615 
     1616  if( (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
     1617  {
     1618    setdQPFlag(true);
    9441619  }
    9451620#if HHI_MPI
    9461621  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
    947   {
    948 #endif
    949     m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
    950 
    951     m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
    952 
    953     // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
    954     m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
    955 
     1622#endif
     1623  if( !pcCU->getSlice()->isIntra() )
     1624  {
     1625    m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
     1626  }
     1627 
     1628  if( pcCU->isSkipped( uiAbsPartIdx ) )
     1629  {
     1630    m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
     1631#if HHI_INTER_VIEW_RESIDUAL_PRED
     1632    m_pcEntropyCoder->encodeResPredFlag( pcCU, uiAbsPartIdx, 0 );
     1633#endif
     1634    finishCU(pcCU,uiAbsPartIdx,uiDepth);
     1635    return;
     1636  }
     1637#if HHI_MPI
     1638  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
     1639  {
     1640#endif
     1641  m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
     1642 
     1643  m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
     1644 
     1645  if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
     1646  {
     1647    m_pcEntropyCoder->encodeIPCMInfo( pcCU, uiAbsPartIdx );
     1648
     1649    if(pcCU->getIPCMFlag(uiAbsPartIdx))
     1650    {
     1651      // Encode slice finish
     1652      finishCU(pcCU,uiAbsPartIdx,uiDepth);
     1653      return;
     1654    }
     1655  }
     1656
     1657  // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
     1658  m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
    9561659#if HHI_INTER_VIEW_RESIDUAL_PRED
    9571660    if( !pcCU->isIntra( uiAbsPartIdx ) )
     
    9631666  }
    9641667#endif
    965 
     1668 
    9661669  // Encode Coefficients
    967   m_pcEntropyCoder->encodeCoeff( pcCU, uiAbsPartIdx, uiDepth, pcCU->getWidth (uiAbsPartIdx), pcCU->getHeight(uiAbsPartIdx) );
    968 }
    969 
    970 Void TEncCu::xCheckRDCostSkip( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, Bool bSkipRes )
    971 {
    972   UChar uhDepth = rpcTempCU->getDepth( 0 );
    973 
    974 #if HHI_VSO
    975   if( m_pcRdCost->getUseRenModel() )
    976   {
    977     UInt  uiWidth     = rpcTempCU->getWidth ( 0 );
    978     UInt  uiHeight    = rpcTempCU->getHeight( 0 );
    979     Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
    980     UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
    981     m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    982   }
    983 #endif
    984 
    985   rpcTempCU->setPredModeSubParts( MODE_SKIP,   0, uhDepth );
    986   rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N,  0, uhDepth );
    987 
    988   m_pcPredSearch->predInterSkipSearch       ( rpcTempCU,
    989                                              m_ppcOrigYuv    [uhDepth],
    990                                              m_ppcPredYuvTemp[uhDepth],
    991                                              m_ppcResiYuvTemp[uhDepth],
    992                                              m_ppcRecoYuvTemp[uhDepth] );
    993 
    994   m_pcPredSearch->encodeResAndCalcRdInterCU ( rpcTempCU,
    995                                              m_ppcOrigYuv    [uhDepth],
    996                                              m_ppcPredYuvTemp[uhDepth],
    997                                              m_ppcResiYuvTemp[uhDepth],
    998                                              m_ppcResiYuvBest[uhDepth],
    999                                              m_ppcRecoYuvTemp[uhDepth],
    1000                                              m_ppcResPredTmp [uhDepth],
    1001                                              bSkipRes );
    1002 
    1003   xCheckBestMode( rpcBestCU, rpcTempCU, uhDepth );
     1670  Bool bCodeDQP = getdQPFlag();
     1671  m_pcEntropyCoder->encodeCoeff( pcCU, uiAbsPartIdx, uiDepth, pcCU->getWidth (uiAbsPartIdx), pcCU->getHeight(uiAbsPartIdx), bCodeDQP );
     1672  setdQPFlag( bCodeDQP );
     1673
     1674  // --- write terminating bit ---
     1675  finishCU(pcCU,uiAbsPartIdx,uiDepth);
    10041676}
    10051677
     
    10161688{
    10171689  assert( rpcTempCU->getSlice()->getSliceType() != I_SLICE );
     1690#if HHI_INTER_VIEW_MOTION_PRED
     1691  TComMvField  cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
     1692  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
     1693#else
    10181694  TComMvField  cMvFieldNeighbours[MRG_MAX_NUM_CANDS << 1]; // double length for mv of both lists
    10191695  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
    1020   UInt uiNeighbourCandIdx[MRG_MAX_NUM_CANDS]; //MVs with same idx => same cand
     1696#endif
     1697  Int numValidMergeCand = 0;
    10211698
    10221699#if HHI_INTER_VIEW_RESIDUAL_PRED
     
    10251702#endif
    10261703
     1704#if HHI_INTER_VIEW_MOTION_PRED
     1705  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS_MEM; ++ui )
     1706#else
    10271707  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ++ui )
     1708#endif
    10281709  {
    10291710    uhInterDirNeighbours[ui] = 0;
    1030     uiNeighbourCandIdx[ui] = 0;
    10311711  }
    10321712  UChar uhDepth = rpcTempCU->getDepth( 0 );
     
    10351715  if( m_pcRdCost->getUseRenModel() )
    10361716  {
     1717    // reset
    10371718    UInt  uiWidth     = rpcTempCU->getWidth ( 0 );
    10381719    UInt  uiHeight    = rpcTempCU->getHeight( 0 );
     
    10441725
    10451726  rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
    1046   rpcTempCU->getInterMergeCandidates( 0, 0, uhDepth, cMvFieldNeighbours,uhInterDirNeighbours, uiNeighbourCandIdx );
    1047 
    1048   Bool bValidCands = false;
    1049   for( UInt uiMergeCand = 0; uiMergeCand < MRG_MAX_NUM_CANDS; ++uiMergeCand )
    1050   {
    1051     if( uiNeighbourCandIdx[uiMergeCand] == ( uiMergeCand + 1 ) )
    1052     {
    1053 #if HHI_MRG_SKIP
     1727  rpcTempCU->getInterMergeCandidates( 0, 0, uhDepth, cMvFieldNeighbours,uhInterDirNeighbours, numValidMergeCand );
     1728
     1729#if FAST_DECISION_FOR_MRG_RD_COST
     1730  Bool bestIsSkip = false;
     1731#endif
     1732 
     1733  for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
     1734  {
     1735    {
    10541736      TComYuv* pcPredYuvTemp = NULL;
     1737#if LOSSLESS_CODING
     1738      UInt iteration;
     1739      if ( rpcTempCU->isLosslessCoded(0))
     1740      {
     1741        iteration = 1;
     1742      }
     1743      else
     1744      {
     1745        iteration = 2;
     1746      }
     1747
    10551748#if HHI_INTERVIEW_SKIP
    1056       for( UInt uiNoResidual = (bSkipRes ? 1:0); uiNoResidual < 2; ++uiNoResidual )
     1749    for( UInt uiNoResidual = (bSkipRes ? 1:0); uiNoResidual < iteration; ++uiNoResidual )
     1750#else
     1751      for( UInt uiNoResidual = 0; uiNoResidual < iteration; ++uiNoResidual )
     1752#endif
     1753#else
     1754#if HHI_INTERVIEW_SKIP
     1755    for( UInt uiNoResidual = (bSkipRes ? 1:0); uiNoResidual < 2; ++uiNoResidual )
    10571756#else
    10581757      for( UInt uiNoResidual = 0; uiNoResidual < 2; ++uiNoResidual )
    10591758#endif
    1060       {
    1061 #endif
    1062       bValidCands = true;
    1063       // set MC parameters
    1064 #if HHI_MRG_SKIP
    1065       rpcTempCU->setPredModeSubParts( MODE_SKIP, 0, uhDepth ); // interprets depth relative to LCU level
    1066 #else
    1067       rpcTempCU->setPredModeSubParts( MODE_INTER, 0, uhDepth ); // interprets depth relative to LCU level
    1068 #endif
    1069       rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
    1070       rpcTempCU->setMergeFlagSubParts( true, 0, 0, uhDepth ); // interprets depth relative to LCU level
    1071       rpcTempCU->setMergeIndexSubParts( uiMergeCand, 0, 0, uhDepth ); // interprets depth relative to LCU level
    1072       rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
    1073       for( UInt uiInner = 0; uiInner < MRG_MAX_NUM_CANDS; uiInner++ )
    1074       {
    1075         rpcTempCU->setNeighbourCandIdxSubParts( uiInner, uiNeighbourCandIdx[uiInner], 0, 0,uhDepth );
    1076       }
    1077       rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand].getMv(), cMvFieldNeighbours[0 + 2*uiMergeCand].getRefIdx(), SIZE_2Nx2N, 0, 0, 0 ); // interprets depth relative to rpcTempCU level
    1078       rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand].getMv(), cMvFieldNeighbours[1 + 2*uiMergeCand].getRefIdx(), SIZE_2Nx2N, 0, 0, 0 ); // interprets depth relative to rpcTempCU level
    1079 
    1080 #if HHI_INTER_VIEW_RESIDUAL_PRED
    1081       rpcTempCU->setResPredAvailSubParts( bResPrdAvail, 0, 0, uhDepth );
    1082       rpcTempCU->setResPredFlagSubParts ( bResPrdFlag,  0, 0, uhDepth );
    1083 #endif
    1084 
    1085 #if HHI_MRG_SKIP
    1086       // do MC
     1759#endif
     1760      {
     1761#if FAST_DECISION_FOR_MRG_RD_COST
     1762        if( !(bestIsSkip && uiNoResidual == 0) )
     1763        {
     1764#endif
     1765          // set MC parameters
     1766          rpcTempCU->setPredModeSubParts( MODE_SKIP, 0, uhDepth ); // interprets depth relative to LCU level
     1767          rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
     1768          rpcTempCU->setMergeFlagSubParts( true, 0, 0, uhDepth ); // interprets depth relative to LCU level
     1769          rpcTempCU->setMergeIndexSubParts( uiMergeCand, 0, 0, uhDepth ); // interprets depth relative to LCU level
     1770          rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
     1771          rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
     1772          rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
     1773
     1774#if HHI_INTER_VIEW_RESIDUAL_PRED
     1775          rpcTempCU->setResPredAvailSubParts( bResPrdAvail, 0, 0, uhDepth );
     1776          rpcTempCU->setResPredFlagSubParts ( bResPrdFlag,  0, 0, uhDepth );
     1777#endif
     1778
     1779          // do MC
    10871780#if HHI_INTERVIEW_SKIP
    10881781      if ( (uiNoResidual == 0) || bSkipRes ){
     
    10901783      if ( uiNoResidual == 0 ){
    10911784#endif
    1092         m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
    1093         // save pred adress
    1094         pcPredYuvTemp = m_ppcPredYuvTemp[uhDepth];
    1095 
    1096       }
    1097       else {
    1098         if ( pcPredYuvTemp != m_ppcPredYuvTemp[uhDepth]) {
    1099           //adress changes take best (old temp)
    1100           pcPredYuvTemp = m_ppcPredYuvBest[uhDepth];
     1785            m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
     1786            // save pred adress
     1787            pcPredYuvTemp = m_ppcPredYuvTemp[uhDepth];
     1788
     1789          }
     1790          else
     1791          {
     1792#if FAST_DECISION_FOR_MRG_RD_COST
     1793            if( bestIsSkip)
     1794            {
     1795              m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
     1796              // save pred adress
     1797              pcPredYuvTemp = m_ppcPredYuvTemp[uhDepth];
     1798            }
     1799            else
     1800            {
     1801#endif
     1802              if ( pcPredYuvTemp != m_ppcPredYuvTemp[uhDepth])
     1803              {
     1804                //adress changes take best (old temp)
     1805                pcPredYuvTemp = m_ppcPredYuvBest[uhDepth];
     1806              }
     1807#if FAST_DECISION_FOR_MRG_RD_COST
     1808            }
     1809#endif
     1810          }
     1811#if HHI_VSO
     1812          if( m_pcRdCost->getUseRenModel() )
     1813          { //Reset
     1814            UInt  uiWidth     = rpcTempCU->getWidth ( 0 );
     1815            UInt  uiHeight    = rpcTempCU->getHeight( 0 );
     1816            Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
     1817            UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
     1818            m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
     1819          }
     1820#endif
     1821          // estimate residual and encode everything
     1822          m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
     1823            m_ppcOrigYuv    [uhDepth],
     1824            pcPredYuvTemp,
     1825            m_ppcResiYuvTemp[uhDepth],
     1826            m_ppcResiYuvBest[uhDepth],
     1827            m_ppcRecoYuvTemp[uhDepth],
     1828#if HHI_INTER_VIEW_RESIDUAL_PRED
     1829                                                     m_ppcResPredTmp [uhDepth],
     1830#endif
     1831            (uiNoResidual? true:false) );     
     1832          Bool bQtRootCbf = rpcTempCU->getQtRootCbf(0) == 1;
     1833
     1834#if H0736_AVC_STYLE_QP_RANGE
     1835          Int orgQP = rpcTempCU->getQP( 0 );
     1836          xCheckDQP( rpcTempCU );
     1837          xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
     1838          rpcTempCU->initEstData( uhDepth, orgQP );
     1839#else
     1840          UInt uiOrgQP = rpcTempCU->getQP( 0 );
     1841          xCheckDQP( rpcTempCU );
     1842          xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
     1843          rpcTempCU->initEstData( uhDepth, uiOrgQP );
     1844#endif
     1845
     1846#if FAST_DECISION_FOR_MRG_RD_COST
     1847          if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
     1848          {
     1849            bestIsSkip = rpcBestCU->getQtRootCbf(0) == 0;
     1850          }
     1851#endif
     1852
     1853          if (!bQtRootCbf)
     1854            break;
     1855#if FAST_DECISION_FOR_MRG_RD_COST
    11011856        }
    1102       }
    1103 #if HHI_VSO
    1104       if( m_pcRdCost->getUseRenModel() )
    1105       { //Reset
    1106         UInt  uiWidth     = rpcTempCU->getWidth ( 0 );
    1107         UInt  uiHeight    = rpcTempCU->getHeight( 0 );
    1108         Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
    1109         UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
    1110         m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    1111       }
    1112 #endif
    1113 
    1114       // estimate residual and encode everything
    1115       m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
    1116                                                 m_ppcOrigYuv    [uhDepth],
    1117                                                 pcPredYuvTemp,
    1118                                                 m_ppcResiYuvTemp[uhDepth],
    1119                                                 m_ppcResiYuvBest[uhDepth],
    1120                                                 m_ppcRecoYuvTemp[uhDepth],
    1121                                                 m_ppcResPredTmp [uhDepth],
    1122                                                 (uiNoResidual? true:false) );
    1123       Bool bQtRootCbf = rpcTempCU->getQtRootCbf(0) == 1;
    1124 #else
    1125       // do MC
    1126       m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
    1127 
    1128       // estimate residual and encode everything
    1129       m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
    1130                                                  m_ppcOrigYuv    [uhDepth],
    1131                                                  m_ppcPredYuvTemp[uhDepth],
    1132                                                  m_ppcResiYuvTemp[uhDepth],
    1133                                                  m_ppcResiYuvBest[uhDepth],
    1134                                                  m_ppcRecoYuvTemp[uhDepth],
    1135                                                  m_ppcResPredTmp [uhDepth],
    1136                                                  false );
    1137 #endif
    1138       xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth );
    1139 
    1140       rpcTempCU->initEstData();
    1141 #if HHI_MRG_SKIP
    1142       if (!bQtRootCbf)
    1143         break;
    1144       }
    1145 #endif
    1146     }
    1147   }
    1148 }
    1149 
     1857#endif
     1858      }
     1859    }
     1860  }
     1861}
     1862
     1863#if AMP_MRG
     1864#if HHI_INTERVIEW_SKIP
     1865Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bSkipRes, Bool bUseMRG)
     1866#else
     1867Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bUseMRG)
     1868#endif
     1869#else
    11501870#if HHI_INTERVIEW_SKIP
    11511871Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bSkipRes)
     
    11531873Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize )
    11541874#endif
     1875#endif
    11551876{
    11561877  UChar uhDepth = rpcTempCU->getDepth( 0 );
    1157 
     1878 
    11581879#if HHI_VSO
    11591880  if( m_pcRdCost->getUseRenModel() )
     
    11651886    m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
    11661887  }
    1167 #endif
     1888#endif 
    11681889
    11691890  rpcTempCU->setDepthSubParts( uhDepth, 0 );
    1170 
     1891 
    11711892#if HHI_INTER_VIEW_RESIDUAL_PRED
    11721893  Bool  bResPrdAvail  = rpcTempCU->getResPredAvail( 0 );
    11731894  Bool  bResPrdFlag   = rpcTempCU->getResPredFlag ( 0 );
    11741895#endif
    1175   rpcTempCU->setPartSizeSubParts    ( SIZE_2Nx2N,   0,    uhDepth );
     1896 
     1897  rpcTempCU->setPartSizeSubParts  ( ePartSize,  0, uhDepth );
    11761898#if HHI_INTER_VIEW_RESIDUAL_PRED
    11771899  rpcTempCU->setResPredAvailSubParts( bResPrdAvail, 0, 0, uhDepth );
    11781900  rpcTempCU->setResPredFlagSubParts ( bResPrdFlag,  0, 0, uhDepth );
    11791901#endif
    1180   rpcTempCU->setPartSizeSubParts    ( ePartSize,    0,    uhDepth );
    1181   rpcTempCU->setPredModeSubParts    ( MODE_INTER,   0,    uhDepth );
    1182 
     1902  rpcTempCU->setPredModeSubParts  ( MODE_INTER, 0, uhDepth );
     1903 
    11831904#if HHI_INTER_VIEW_RESIDUAL_PRED
    11841905  if( rpcTempCU->getResPredFlag( 0 ) )
     
    11871908  }
    11881909#endif
    1189 #if HHI_INTERVIEW_SKIP
     1910
     1911#if AMP_MRG
     1912  rpcTempCU->setMergeAMP (true);
     1913  #if HHI_INTERVIEW_SKIP
     1914  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes, bUseMRG  );
     1915#else
     1916  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], false, bUseMRG );
     1917#endif
     1918#else
     1919  #if HHI_INTERVIEW_SKIP
    11901920  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes );
    1191 #else
     1921#else 
    11921922  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth] );
    11931923#endif
     1924#endif
     1925
    11941926#if HHI_INTER_VIEW_RESIDUAL_PRED
    11951927  if( rpcTempCU->getResPredFlag( 0 ) )
     
    11991931#endif
    12001932
    1201 #if PART_MRG
    1202   if (rpcTempCU->getWidth(0) > 8 && !rpcTempCU->getMergeFlag(0) && (ePartSize != SIZE_2Nx2N && ePartSize != SIZE_NxN))
     1933#if AMP_MRG
     1934  if ( !rpcTempCU->getMergeAMP() )
    12031935  {
    12041936    return;
    12051937  }
    12061938#endif
     1939
    12071940#if HHI_INTERVIEW_SKIP
    1208   m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], m_ppcResPredTmp [uhDepth],bSkipRes );
    1209 #else
    1210   m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], m_ppcResPredTmp [uhDepth], false );
    1211 #endif
    1212 
     1941  m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
     1942                                             m_ppcOrigYuv[uhDepth],
     1943                                             m_ppcPredYuvTemp[uhDepth],
     1944                                             m_ppcResiYuvTemp[uhDepth],
     1945                                             m_ppcResiYuvBest[uhDepth],
     1946                                             m_ppcRecoYuvTemp[uhDepth],
     1947#if HHI_INTER_VIEW_RESIDUAL_PRED
     1948                                             m_ppcResPredTmp [uhDepth],
     1949#endif
     1950                                             bSkipRes );
     1951#else
     1952  m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
     1953                                             m_ppcOrigYuv[uhDepth],
     1954                                             m_ppcPredYuvTemp[uhDepth],
     1955                                             m_ppcResiYuvTemp[uhDepth],
     1956                                             m_ppcResiYuvBest[uhDepth],
     1957                                             m_ppcRecoYuvTemp[uhDepth],
     1958#if HHI_INTER_VIEW_RESIDUAL_PRED
     1959                                             m_ppcResPredTmp [uhDepth],
     1960#endif
     1961                                             false );
     1962#endif
    12131963#if HHI_VSO
    12141964  if( m_pcRdCost->getUseLambdaScaleVSO() )
     
    12191969#endif
    12201970  {
    1221     rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
    1222   }
    1223 
    1224   xCheckBestMode( rpcBestCU, rpcTempCU, uhDepth );
     1971  rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     1972  }
     1973
     1974  xCheckDQP( rpcTempCU );
     1975  xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
    12251976}
    12261977
     
    12281979{
    12291980  UInt uiDepth = rpcTempCU->getDepth( 0 );
    1230 
     1981 
    12311982#if HHI_VSO
    12321983  if( m_pcRdCost->getUseRenModel() )
     
    12421993  rpcTempCU->setPartSizeSubParts( eSize, 0, uiDepth );
    12431994  rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
    1244 
     1995 
    12451996  Bool bSeparateLumaChroma = true; // choose estimation mode
    12461997  Dist uiPreCalcDistC      = 0;
     
    12512002  m_pcPredSearch  ->estIntraPredQT      ( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC, bSeparateLumaChroma );
    12522003
    1253 #if LM_CHROMA
    12542004  m_ppcRecoYuvTemp[uiDepth]->copyToPicLuma(rpcTempCU->getPic()->getPicYuvRec(), rpcTempCU->getAddr(), rpcTempCU->getZorderIdxInCU() );
    1255 #endif
    1256 
     2005 
    12572006  m_pcPredSearch  ->estIntraPredChromaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC );
    1258 
     2007 
    12592008  m_pcEntropyCoder->resetBits();
    12602009  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
     
    12622011  m_pcEntropyCoder->encodePartSize( rpcTempCU, 0, uiDepth, true );
    12632012  m_pcEntropyCoder->encodePredInfo( rpcTempCU, 0,          true );
     2013  m_pcEntropyCoder->encodeIPCMInfo(rpcTempCU, 0, true );
    12642014
    12652015  // Encode Coefficients
    1266   m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0) );
    1267 
     2016  Bool bCodeDQP = getdQPFlag();
     2017  m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0), bCodeDQP );
     2018  setdQPFlag( bCodeDQP );
     2019 
    12682020  if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
    1269 
     2021 
    12702022  rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
     2023  if(m_pcEncCfg->getUseSBACRD())
     2024  {
     2025    rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
     2026  }
    12712027#if HHI_VSO
    12722028  if( m_pcRdCost->getUseLambdaScaleVSO())
     
    12772033#endif
    12782034  {
    1279     rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
    1280   }
    1281 
     2035  rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     2036  }
     2037 
     2038  xCheckDQP( rpcTempCU );
     2039  xCheckBestMode(rpcBestCU, rpcTempCU, uiDepth);
     2040}
     2041
     2042/** Check R-D costs for a CU with PCM mode.
     2043 * \param rpcBestCU pointer to best mode CU data structure
     2044 * \param rpcTempCU pointer to testing mode CU data structure
     2045 * \returns Void
     2046 *
     2047 * \note Current PCM implementation encodes sample values in a lossless way. The distortion of PCM mode CUs are zero. PCM mode is selected if the best mode yields bits greater than that of PCM mode.
     2048 */
     2049Void TEncCu::xCheckIntraPCM( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU )
     2050{
     2051  UInt uiDepth = rpcTempCU->getDepth( 0 );
     2052
     2053  rpcTempCU->setIPCMFlag(0, true);
     2054  rpcTempCU->setIPCMFlagSubParts (true, 0, rpcTempCU->getDepth(0));
     2055  rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
     2056  rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
     2057
     2058  m_pcPredSearch->IPCMSearch( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth]);
     2059
     2060  if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
     2061
     2062  m_pcEntropyCoder->resetBits();
     2063  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
     2064  m_pcEntropyCoder->encodePredMode ( rpcTempCU, 0,          true );
     2065  m_pcEntropyCoder->encodePartSize ( rpcTempCU, 0, uiDepth, true );
     2066  m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
     2067
     2068  if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
     2069
     2070  rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
     2071  if(m_pcEncCfg->getUseSBACRD())
     2072  {
     2073    rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
     2074  }
     2075#if HHI_VSO
     2076  if ( m_pcRdCost->getUseVSO() )
     2077  {
     2078    rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     2079  }
     2080  else
     2081#endif
     2082  { 
     2083  rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
     2084  }
     2085
     2086  xCheckDQP( rpcTempCU );
    12822087  xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth );
    12832088}
    12842089
    12852090// check whether current try is the best
    1286 Void TEncCu::xCheckBestMode( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, UChar uhDepth )
     2091Void TEncCu::xCheckBestMode( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU )
    12872092{
    12882093  if( rpcTempCU->getTotalCost() < rpcBestCU->getTotalCost() )
    12892094  {
    12902095    TComYuv* pcYuv;
     2096    UChar uhDepth = rpcBestCU->getDepth(0);
    12912097
    12922098    // Change Information data
     
    12942100    rpcBestCU = rpcTempCU;
    12952101    rpcTempCU = pcCU;
    1296 
     2102   
    12972103    // Change Prediction data
    12982104    pcYuv = m_ppcPredYuvBest[uhDepth];
    12992105    m_ppcPredYuvBest[uhDepth] = m_ppcPredYuvTemp[uhDepth];
    13002106    m_ppcPredYuvTemp[uhDepth] = pcYuv;
    1301 
     2107   
    13022108    // Change Reconstruction data
    13032109    pcYuv = m_ppcRecoYuvBest[uhDepth];
    13042110    m_ppcRecoYuvBest[uhDepth] = m_ppcRecoYuvTemp[uhDepth];
    13052111    m_ppcRecoYuvTemp[uhDepth] = pcYuv;
    1306 
     2112   
    13072113    pcYuv = NULL;
    13082114    pcCU  = NULL;
    1309 
     2115   
    13102116    if( m_bUseSBACRD )  // store temp best CI for next CU coding
    13112117      m_pppcRDSbacCoder[uhDepth][CI_TEMP_BEST]->store(m_pppcRDSbacCoder[uhDepth][CI_NEXT_BEST]);
     
    13132119}
    13142120
    1315 Void TEncCu::xCheckRDCostAMVPSkip           ( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU )
    1316 {
    1317   UChar uhDepth = rpcTempCU->getDepth(0);
    1318 
    1319 #if HHI_INTER_VIEW_RESIDUAL_PRED
    1320   Bool  bResPrdAvail  = rpcTempCU->getResPredAvail( 0 );
    1321   Bool  bResPrdFlag   = rpcTempCU->getResPredFlag ( 0 );
    1322 #endif
    1323 
    1324   AMVPInfo cAMVPInfo0;
    1325   cAMVPInfo0.iN = 0;
    1326 
    1327   AMVPInfo cAMVPInfo1;
    1328   cAMVPInfo1.iN = 0;
    1329 
    1330   if (rpcTempCU->getAMVPMode(0) == AM_EXPL)
    1331   {
    1332     rpcTempCU->setPredModeSubParts( MODE_SKIP, 0, uhDepth );
    1333     rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N,  0, uhDepth );
    1334 
    1335     if ( rpcTempCU->getSlice()->isInterP() && rpcTempCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 )
    1336     {
    1337       rpcTempCU->fillMvpCand(0, 0, REF_PIC_LIST_0, 0, &cAMVPInfo0);
    1338     }
    1339     else if ( rpcTempCU->getSlice()->isInterB() &&
    1340              rpcTempCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 &&
    1341              rpcTempCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0  )
    1342     {
    1343       rpcTempCU->fillMvpCand(0, 0, REF_PIC_LIST_0, 0, &cAMVPInfo0);
    1344       rpcTempCU->fillMvpCand(0, 0, REF_PIC_LIST_1, 0, &cAMVPInfo1);
     2121/** check whether current try is the best with identifying the depth of current try
     2122 * \param rpcBestCU
     2123 * \param rpcTempCU
     2124 * \returns Void
     2125 */
     2126Void TEncCu::xCheckBestMode( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, UInt uiDepth )
     2127{
     2128  if( rpcTempCU->getTotalCost() < rpcBestCU->getTotalCost() )
     2129  {
     2130    TComYuv* pcYuv;
     2131    // Change Information data
     2132    TComDataCU* pcCU = rpcBestCU;
     2133    rpcBestCU = rpcTempCU;
     2134    rpcTempCU = pcCU;
     2135
     2136    // Change Prediction data
     2137    pcYuv = m_ppcPredYuvBest[uiDepth];
     2138    m_ppcPredYuvBest[uiDepth] = m_ppcPredYuvTemp[uiDepth];
     2139    m_ppcPredYuvTemp[uiDepth] = pcYuv;
     2140
     2141    // Change Reconstruction data
     2142    pcYuv = m_ppcRecoYuvBest[uiDepth];
     2143    m_ppcRecoYuvBest[uiDepth] = m_ppcRecoYuvTemp[uiDepth];
     2144    m_ppcRecoYuvTemp[uiDepth] = pcYuv;
     2145
     2146    pcYuv = NULL;
     2147    pcCU  = NULL;
     2148
     2149    if( m_bUseSBACRD )  // store temp best CI for next CU coding
     2150      m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_NEXT_BEST]);
     2151  }
     2152}
     2153
     2154Void TEncCu::xCheckDQP( TComDataCU* pcCU )
     2155{
     2156  UInt uiDepth = pcCU->getDepth( 0 );
     2157
     2158  if( pcCU->getSlice()->getPPS()->getUseDQP() && (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() )
     2159  {
     2160    if ( pcCU->getCbf( 0, TEXT_LUMA, 0 ) || pcCU->getCbf( 0, TEXT_CHROMA_U, 0 ) || pcCU->getCbf( 0, TEXT_CHROMA_V, 0 ) )
     2161    {
     2162#if !RDO_WITHOUT_DQP_BITS
     2163      m_pcEntropyCoder->resetBits();
     2164      m_pcEntropyCoder->encodeQP( pcCU, 0, false );
     2165      pcCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
     2166      if(m_pcEncCfg->getUseSBACRD())
     2167      {
     2168        pcCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
     2169      }
     2170
     2171      // GT: Change here??
     2172#if HHI_VSO
     2173      if ( m_pcRdCost->getUseVSO() )
     2174      {
     2175        pcCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
     2176      }
     2177      else
     2178#endif
     2179      {
     2180      pcCU->getTotalCost() = m_pcRdCost->calcRdCost( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
     2181      }   
     2182#endif
    13452183    }
    13462184    else
    13472185    {
    1348       assert( 0 );
    1349     }
    1350   }
    1351 
    1352   Int iMVP0, iMVP1;
    1353 
    1354   for (iMVP0 = (cAMVPInfo0.iN > 0? 0:-1); iMVP0 < cAMVPInfo0.iN; iMVP0++)
    1355   {
    1356     for (iMVP1 = (cAMVPInfo1.iN > 0? 0:-1); iMVP1 < cAMVPInfo1.iN; iMVP1++)
    1357     {
    1358       rpcTempCU->setPredModeSubParts( MODE_SKIP, 0, uhDepth );
    1359       rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N,  0, uhDepth );
    1360 #if HHI_INTER_VIEW_RESIDUAL_PRED
    1361       rpcTempCU->setResPredAvailSubParts( bResPrdAvail, 0, 0, uhDepth );
    1362       rpcTempCU->setResPredFlagSubParts ( bResPrdFlag,  0, 0, uhDepth );
    1363 #endif
    1364 
    1365       if (rpcTempCU->getSlice()->isInterB())
    1366         rpcTempCU->setInterDirSubParts( 3, 0, 0, uhDepth );
    1367 
    1368       rpcTempCU->setMVPIdxSubParts( iMVP0, REF_PIC_LIST_0, 0, 0, uhDepth );
    1369       rpcTempCU->setMVPIdxSubParts( iMVP1, REF_PIC_LIST_1, 0, 0, uhDepth );
    1370 
    1371       rpcTempCU->setMVPNumSubParts( cAMVPInfo0.iN, REF_PIC_LIST_0, 0, 0, uhDepth );
    1372       rpcTempCU->setMVPNumSubParts( cAMVPInfo1.iN, REF_PIC_LIST_1, 0, 0, uhDepth );
    1373 
    1374       xCopyAMVPInfo(&cAMVPInfo0, rpcTempCU->getCUMvField(REF_PIC_LIST_0)->getAMVPInfo());
    1375       xCopyAMVPInfo(&cAMVPInfo1, rpcTempCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo());
    1376       xCheckRDCostSkip ( rpcBestCU, rpcTempCU, true );      rpcTempCU->initEstData();
    1377     }
    1378   }
    1379 }
     2186#if LOSSLESS_CODING
     2187      if ((  ( pcCU->getRefQP( 0 ) != pcCU->getQP( 0 )) ) && (pcCU->getSlice()->getSPS()->getUseLossless()))
     2188      {
     2189        pcCU->getTotalCost() = MAX_DOUBLE;
     2190      }
     2191#endif
     2192      pcCU->setQPSubParts( pcCU->getRefQP( 0 ), 0, uiDepth ); // set QP to default QP
     2193    }
     2194  }
     2195}
     2196
     2197#if BURST_IPCM
     2198/** Check whether the last CU shares the same root as the current CU and is IPCM or not. 
     2199 * \param pcCU
     2200 * \param uiCurAbsPartIdx
     2201 * \returns Bool
     2202 */
     2203Bool TEncCu::checkLastCUSucIPCM( TComDataCU* pcCU, UInt uiCurAbsPartIdx )
     2204{
     2205  Bool lastCUSucIPCMFlag = false;
     2206
     2207  UInt curDepth = pcCU->getDepth(uiCurAbsPartIdx);
     2208  UInt shift = ((pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx())->getSPS()->getMaxCUDepth() - curDepth)<<1);
     2209  UInt startPartUnitIdx = ((uiCurAbsPartIdx&(0x03<<shift))>>shift);
     2210
     2211  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
     2212  if( pcSlice->getEntropySliceCurStartCUAddr() == ( pcCU->getSCUAddr() + uiCurAbsPartIdx ) )
     2213  {
     2214    return false;
     2215  }
     2216
     2217  if(curDepth > 0 && startPartUnitIdx > 0)
     2218  {
     2219    Int lastValidPartIdx = pcCU->getLastValidPartIdx((Int) uiCurAbsPartIdx );
     2220
     2221    if( lastValidPartIdx >= 0 )
     2222    {
     2223      if(( pcCU->getSliceStartCU( uiCurAbsPartIdx ) == pcCU->getSliceStartCU( (UInt) lastValidPartIdx ))
     2224        &&
     2225        ( pcCU->getDepth( uiCurAbsPartIdx ) == pcCU->getDepth( (UInt) lastValidPartIdx ))
     2226        &&
     2227        pcCU->getIPCMFlag( (UInt) lastValidPartIdx ) )
     2228      {
     2229        lastCUSucIPCMFlag = true;
     2230      }
     2231    }
     2232  }
     2233
     2234  return  lastCUSucIPCMFlag;
     2235}
     2236
     2237/** Count the number of successive IPCM CUs sharing the same root.
     2238 * \param pcCU
     2239 * \param uiCurAbsPartIdx
     2240 * \returns Int
     2241 */
     2242Int TEncCu::countNumSucIPCM ( TComDataCU* pcCU, UInt uiCurAbsPartIdx )
     2243{
     2244  Int numSucIPCM = 0;
     2245  UInt CurDepth = pcCU->getDepth(uiCurAbsPartIdx);
     2246
     2247  if( pcCU->getIPCMFlag(uiCurAbsPartIdx) )
     2248  {
     2249    if(CurDepth == 0)
     2250    {
     2251       numSucIPCM = 1;
     2252    }
     2253    else
     2254    {
     2255      TComPic* pcPic = pcCU->getPic();
     2256      TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
     2257      UInt qNumParts = ( pcPic->getNumPartInCU() >> ((CurDepth-1)<<1) )>>2;
     2258
     2259      Bool continueFlag = true;
     2260      UInt absPartIdx = uiCurAbsPartIdx;
     2261      UInt shift = ((pcSlice->getSPS()->getMaxCUDepth() - CurDepth)<<1);
     2262      UInt startPartUnitIdx = ((uiCurAbsPartIdx&(0x03<<shift))>>shift);
     2263
     2264      for ( UInt partUnitIdx = startPartUnitIdx; partUnitIdx < 4 && continueFlag; partUnitIdx++, absPartIdx+=qNumParts )
     2265      {
     2266        UInt lPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[absPartIdx] ];
     2267        UInt tPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[absPartIdx] ];
     2268        Bool inSliceFlag = ( pcCU->getSCUAddr()+absPartIdx+qNumParts>pcSlice->getEntropySliceCurStartCUAddr() ) && ( pcCU->getSCUAddr()+absPartIdx < pcSlice->getEntropySliceCurEndCUAddr());
     2269
     2270        if( inSliceFlag && ( lPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( tPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
     2271        {
     2272          UInt uiDepth = pcCU->getDepth(absPartIdx);
     2273
     2274          if( ( CurDepth == uiDepth) && pcCU->getIPCMFlag( absPartIdx ) )
     2275          {
     2276            numSucIPCM++;
     2277          }
     2278          else
     2279          {
     2280            continueFlag = false;
     2281          }
     2282        }
     2283      }
     2284    }
     2285  }
     2286
     2287  return numSucIPCM;
     2288}
     2289#endif
    13802290
    13812291Void TEncCu::xCopyAMVPInfo (AMVPInfo* pSrc, AMVPInfo* pDst)
     
    13872297  }
    13882298}
    1389 
    1390 Void TEncCu::xCopyYuv2Pic(TComPic* rpcPic, UInt uiCUAddr, UInt uiAbsZorderIdx, UInt uiDepth)
    1391 {
    1392   m_ppcRecoYuvBest[uiDepth]->copyToPicYuv( rpcPic->getPicYuvRec (), uiCUAddr, uiAbsZorderIdx );
     2299Void TEncCu::xCopyYuv2Pic(TComPic* rpcPic, UInt uiCUAddr, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSrcDepth, TComDataCU* pcCU, UInt uiLPelX, UInt uiTPelY )
     2300{
     2301  UInt uiRPelX   = uiLPelX + (g_uiMaxCUWidth>>uiDepth)  - 1;
     2302  UInt uiBPelY   = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
     2303  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
     2304  Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr() > rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
     2305    pcSlice->getEntropySliceCurStartCUAddr() < rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) );
     2306  Bool bSliceEnd   = pcSlice->getEntropySliceCurEndCUAddr() > rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
     2307    pcSlice->getEntropySliceCurEndCUAddr() < rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) );
     2308  if(!bSliceEnd && !bSliceStart && ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
     2309  {
     2310    UInt uiAbsPartIdxInRaster = g_auiZscanToRaster[uiAbsPartIdx];
     2311    UInt uiSrcBlkWidth = rpcPic->getNumPartInWidth() >> (uiSrcDepth);
     2312    UInt uiBlkWidth    = rpcPic->getNumPartInWidth() >> (uiDepth);
     2313    UInt uiPartIdxX = ( ( uiAbsPartIdxInRaster % rpcPic->getNumPartInWidth() ) % uiSrcBlkWidth) / uiBlkWidth;
     2314    UInt uiPartIdxY = ( ( uiAbsPartIdxInRaster / rpcPic->getNumPartInWidth() ) % uiSrcBlkWidth) / uiBlkWidth;
     2315    UInt uiPartIdx = uiPartIdxY * ( uiSrcBlkWidth / uiBlkWidth ) + uiPartIdxX;
     2316    m_ppcRecoYuvBest[uiSrcDepth]->copyToPicYuv( rpcPic->getPicYuvRec (), uiCUAddr, uiAbsPartIdx, uiDepth - uiSrcDepth, uiPartIdx);
     2317  }
     2318  else
     2319  {
     2320    UInt uiQNumParts = ( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) )>>2;
     2321
     2322    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
     2323    {
     2324      UInt uiSubCULPelX   = uiLPelX + ( g_uiMaxCUWidth >>(uiDepth+1) )*( uiPartUnitIdx &  1 );
     2325      UInt uiSubCUTPelY   = uiTPelY + ( g_uiMaxCUHeight>>(uiDepth+1) )*( uiPartUnitIdx >> 1 );
     2326
     2327      Bool bInSlice = rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+uiQNumParts > pcSlice->getEntropySliceCurStartCUAddr() &&
     2328        rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx < pcSlice->getEntropySliceCurEndCUAddr();
     2329      if(bInSlice&&( uiSubCULPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiSubCUTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
     2330      {
     2331        xCopyYuv2Pic( rpcPic, uiCUAddr, uiAbsPartIdx, uiDepth+1, uiSrcDepth, pcCU, uiSubCULPelX, uiSubCUTPelY );   // Copy Yuv data to picture Yuv
     2332      }
     2333    }
     2334  }
    13932335}
    13942336
     
    13992341}
    14002342
     2343#if LOSSLESS_CODING
     2344/** Function for filling the PCM buffer of a CU using its original sample array
     2345 * \param pcCU pointer to current CU
     2346 * \param pcOrgYuv pointer to original sample array
     2347 * \returns Void
     2348 */
     2349Void TEncCu::xFillPCMBuffer     ( TComDataCU*& pCU, TComYuv* pOrgYuv )
     2350{
     2351
     2352  UInt   width        = pCU->getWidth(0);
     2353  UInt   height       = pCU->getHeight(0);
     2354
     2355  Pel*   pSrcY = pOrgYuv->getLumaAddr(0, width);
     2356  Pel*   pDstY = pCU->getPCMSampleY();
     2357  UInt   srcStride = pOrgYuv->getStride();
     2358
     2359  for(Int y = 0; y < height; y++ )
     2360  {
     2361    for(Int x = 0; x < width; x++ )
     2362    {
     2363      pDstY[x] = pSrcY[x];
     2364    }
     2365    pDstY += width;
     2366    pSrcY += srcStride;
     2367  }
     2368
     2369  Pel* pSrcCb       = pOrgYuv->getCbAddr();
     2370  Pel* pSrcCr       = pOrgYuv->getCrAddr();;
     2371
     2372  Pel* pDstCb       = pCU->getPCMSampleCb();
     2373  Pel* pDstCr       = pCU->getPCMSampleCr();;
     2374
     2375  UInt srcStrideC = pOrgYuv->getCStride();
     2376  UInt heightC   = height >> 1;
     2377  UInt widthC    = width  >> 1;
     2378
     2379  for(Int y = 0; y < heightC; y++ )
     2380  {
     2381    for(Int x = 0; x < widthC; x++ )
     2382    {
     2383      pDstCb[x] = pSrcCb[x];
     2384      pDstCr[x] = pSrcCr[x];
     2385    }
     2386    pDstCb += widthC;
     2387    pDstCr += widthC;
     2388    pSrcCb += srcStrideC;
     2389    pSrcCr += srcStrideC;
     2390  }
     2391}
     2392#endif
     2393
     2394#if ADAPTIVE_QP_SELECTION
     2395/** Collect ARL statistics from one block
     2396  */
     2397Int TEncCu::xTuCollectARLStats(TCoeff* rpcCoeff, Int* rpcArlCoeff, Int NumCoeffInCU, Double* cSum, UInt* numSamples )
     2398{
     2399  for( Int n = 0; n < NumCoeffInCU; n++ )
     2400  {
     2401    Int u = abs( rpcCoeff[ n ] );
     2402    Int absc = rpcArlCoeff[ n ];
     2403
     2404    if( u != 0 )
     2405    {
     2406      if( u < LEVEL_RANGE )
     2407      {
     2408        cSum[ u ] += ( Double )absc;
     2409        numSamples[ u ]++;
     2410      }
     2411      else
     2412      {
     2413        cSum[ LEVEL_RANGE ] += ( Double )absc - ( Double )( u << ARL_C_PRECISION );
     2414        numSamples[ LEVEL_RANGE ]++;
     2415      }
     2416    }
     2417  }
     2418
     2419  return 0;
     2420}
     2421
     2422/** Collect ARL statistics from one LCU
     2423 * \param pcCU
     2424 */
     2425Void TEncCu::xLcuCollectARLStats(TComDataCU* rpcCU )
     2426{
     2427  Double cSum[ LEVEL_RANGE + 1 ];     //: the sum of DCT coefficients corresponding to datatype and quantization output
     2428  UInt numSamples[ LEVEL_RANGE + 1 ]; //: the number of coefficients corresponding to datatype and quantization output
     2429
     2430  TCoeff* pCoeffY = rpcCU->getCoeffY();
     2431  Int* pArlCoeffY = rpcCU->getArlCoeffY();
     2432
     2433  UInt uiMinCUWidth = g_uiMaxCUWidth >> g_uiMaxCUDepth;
     2434  UInt uiMinNumCoeffInCU = 1 << uiMinCUWidth;
     2435
     2436  memset( cSum, 0, sizeof( Double )*(LEVEL_RANGE+1) );
     2437  memset( numSamples, 0, sizeof( UInt )*(LEVEL_RANGE+1) );
     2438
     2439  // Collect stats to cSum[][] and numSamples[][]
     2440  for(Int i = 0; i < rpcCU->getTotalNumPart(); i ++ )
     2441  {
     2442    UInt uiTrIdx = rpcCU->getTransformIdx(i);
     2443
     2444    if(rpcCU->getPredictionMode(i) == MODE_INTER)
     2445    if( rpcCU->getCbf( i, TEXT_LUMA, uiTrIdx ) )
     2446    {
     2447      xTuCollectARLStats(pCoeffY, pArlCoeffY, uiMinNumCoeffInCU, cSum, numSamples);
     2448    }//Note that only InterY is processed. QP rounding is based on InterY data only.
     2449   
     2450    pCoeffY  += uiMinNumCoeffInCU;
     2451    pArlCoeffY  += uiMinNumCoeffInCU;
     2452  }
     2453
     2454  for(Int u=1; u<LEVEL_RANGE;u++)
     2455  {
     2456    m_pcTrQuant->getSliceSumC()[u] += cSum[ u ] ;
     2457    m_pcTrQuant->getSliceNSamples()[u] += numSamples[ u ] ;
     2458  }
     2459  m_pcTrQuant->getSliceSumC()[LEVEL_RANGE] += cSum[ LEVEL_RANGE ] ;
     2460  m_pcTrQuant->getSliceNSamples()[LEVEL_RANGE] += numSamples[ LEVEL_RANGE ] ;
     2461}
     2462#endif
     2463
    14012464#if HHI_MPI
    14022465Void TEncCu::xCheckRDCostMvInheritance( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, UChar uhTextureModeDepth, Bool bSkipResidual, Bool bRecursiveCall )
    14032466{
    1404   assert( rpcTempCU->getSlice()->getSPS()->isDepth() );
     2467  assert( rpcTempCU->getSlice()->getIsDepth() );
    14052468  TComDataCU *pcTextureCU = rpcTempCU->getSlice()->getTexturePic()->getCU( rpcTempCU->getAddr() );
    14062469
    14072470  const UChar uhDepth  = rpcTempCU->getDepth( 0 );
     2471  const Int   iQP      = rpcTempCU->getQP( 0 );
    14082472  assert( bRecursiveCall == ( uhDepth != uhTextureModeDepth ) );
    14092473
     
    14392503    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
    14402504    {
    1441       pcSubBestPartCU->initSubCU( rpcBestCU, uiPartUnitIdx, uhNextDepth );           // clear sub partition datas or init.
    1442       pcSubTempPartCU->initSubCU( rpcBestCU, uiPartUnitIdx, uhNextDepth );           // clear sub partition datas or init.
    1443 
    1444       if( ( pcSubBestPartCU->getCUPelX() < pcSubBestPartCU->getSlice()->getSPS()->getWidth() ) && ( pcSubBestPartCU->getCUPelY() < pcSubBestPartCU->getSlice()->getSPS()->getHeight() ) )
     2505      pcSubBestPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP );           // clear sub partition datas or init.
     2506      pcSubTempPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP );           // clear sub partition datas or init.
     2507
     2508      TComSlice * pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
     2509      Bool bInSlice = pcSubBestPartCU->getSCUAddr()+pcSubBestPartCU->getTotalNumPart()>pcSlice->getEntropySliceCurStartCUAddr()&&pcSubBestPartCU->getSCUAddr()<pcSlice->getEntropySliceCurEndCUAddr();
     2510      if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
    14452511      {
    14462512        if( m_bUseSBACRD )
     
    14612527        xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
    14622528      }
     2529      else if (bInSlice)
     2530      {
     2531        pcSubBestPartCU->copyToPic( uhNextDepth );
     2532        rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );
     2533      }
    14632534    }
    14642535
     
    14662537    {
    14672538      xAddMVISignallingBits( rpcTempCU );
     2539    }
     2540
     2541    // DQP-Scheiße
     2542    {
     2543      if( (g_uiMaxCUWidth>>uhDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() && rpcTempCU->getSlice()->getPPS()->getUseDQP())
     2544      {
     2545        TComPic *pcPic = rpcTempCU->getPic();
     2546        TComSlice *pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
     2547        Bool bHasRedisual = false;
     2548        for( UInt uiBlkIdx = 0; uiBlkIdx < rpcTempCU->getTotalNumPart(); uiBlkIdx ++)
     2549        {
     2550          if( ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(uiBlkIdx+rpcTempCU->getZorderIdxInCU()) == rpcTempCU->getSlice()->getEntropySliceCurStartCUAddr() ) &&
     2551              ( rpcTempCU->getCbf( uiBlkIdx, TEXT_LUMA ) || rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_U ) || rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_V ) ) )
     2552          {
     2553            bHasRedisual = true;
     2554            break;
     2555          }
     2556        }
     2557
     2558        UInt uiTargetPartIdx;
     2559        if ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) != pcSlice->getEntropySliceCurStartCUAddr() )
     2560        {
     2561          uiTargetPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
     2562        }
     2563        else
     2564        {
     2565          uiTargetPartIdx = 0;
     2566        }
     2567        if ( ! bHasRedisual )
     2568        {
     2569  #if LOSSLESS_CODING
     2570          if (((rpcTempCU->getQP(uiTargetPartIdx) != rpcTempCU->getRefQP(uiTargetPartIdx)) ) && (rpcTempCU->getSlice()->getSPS()->getUseLossless()))
     2571          {
     2572            rpcTempCU->getTotalCost() = MAX_DOUBLE;
     2573          }
     2574  #endif
     2575          rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( uiTargetPartIdx ), 0, uhDepth ); // set QP to default QP
     2576        }
     2577      }
    14682578    }
    14692579
     
    14882598    // get Original YUV data from picture
    14892599    m_ppcOrigYuv[uhDepth]->copyFromPicYuv( rpcBestCU->getPic()->getPicYuvOrg(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
    1490     m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], m_ppcResPredTmp [uhDepth], bSkipResidual );
     2600    m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
     2601                                               m_ppcOrigYuv[uhDepth],
     2602                                               m_ppcPredYuvTemp[uhDepth],
     2603                                               m_ppcResiYuvTemp[uhDepth],
     2604                                               m_ppcResiYuvBest[uhDepth],
     2605                                               m_ppcRecoYuvTemp[uhDepth],
     2606#if HHI_INTER_VIEW_RESIDUAL_PRED
     2607                                               m_ppcResPredTmp [uhDepth],
     2608#endif
     2609                                               bSkipResidual );
    14912610
    14922611    if( uhDepth == uhTextureModeDepth )
     
    14942613      xAddMVISignallingBits( rpcTempCU );
    14952614    }
     2615    xCheckDQP( rpcTempCU );
    14962616  }
    14972617
     
    15072627  }
    15082628
     2629  if( rpcTempCU->getPredictionMode( 0 ) == MODE_SKIP && uhDepth == uhTextureModeDepth )
     2630  {
     2631    if( rpcTempCU->getSlice()->getPPS()->getUseDQP() && (g_uiMaxCUWidth>>uhDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
     2632      rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( 0 ), 0, uhDepth ); // set QP to default QP
     2633  }
    15092634  xCheckBestMode( rpcBestCU, rpcTempCU, uhDepth );
     2635  rpcBestCU->copyToPic(uhDepth);                                                     // Copy Best data to Picture for next partition prediction.
    15102636
    15112637#if HHI_VSO
     
    15302656  pcCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth );
    15312657  pcCU->setMergeFlagSubParts( true, 0, 0, uhDepth );
    1532   pcCU->setMergeIndexSubParts( 0, 0, 0, uhDepth );
    1533 
    1534   {
    1535     TComMvField  cMvFieldNeighbours[MRG_MAX_NUM_CANDS << 1]; // double length for mv of both lists
    1536     UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
    1537     UInt uiNeighbourCandIdx[MRG_MAX_NUM_CANDS]; //MVs with same idx => same cand
    1538 
    1539     for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ++ui )
    1540     {
    1541       uhInterDirNeighbours[ui] = 0;
    1542       uiNeighbourCandIdx[ui] = 0;
    1543     }
    1544     pcCU->getInterMergeCandidates( 0, 0, uhDepth, cMvFieldNeighbours,uhInterDirNeighbours, uiNeighbourCandIdx );
    1545     for( UInt uiMergeCand = 0; uiMergeCand < MRG_MAX_NUM_CANDS; uiMergeCand++ )
    1546     {
    1547       pcCU->setNeighbourCandIdxSubParts( uiMergeCand, uiNeighbourCandIdx[uiMergeCand], 0, 0,uhDepth );
    1548     }
    1549   }
     2658  pcCU->setMergeIndexSubParts( HHI_MPI_MERGE_POS, 0, 0, uhDepth );
    15502659
    15512660  // check for skip mode
     
    15702679  if( pcCU->isSkipped( 0 ) )
    15712680  {
    1572 #if HHI_MRG_SKIP
    15732681    m_pcEntropyCoder->encodeMergeIndex( pcCU, 0, 0, true );
    1574 #else
    1575     if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 ) //if ( ref. frame list0 has at least 1 entry )
    1576     {
    1577       m_pcEntropyCoder->encodeMVPIdx( pcCU, 0, REF_PIC_LIST_0, true );
    1578     }
    1579     if ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 ) //if ( ref. frame list1 has at least 1 entry )
    1580     {
    1581       m_pcEntropyCoder->encodeMVPIdx( pcCU, 0, REF_PIC_LIST_1, true );
    1582     }
    1583 #endif
    15842682  }
    15852683  else
     
    16112709}
    16122710#endif
     2711
     2712//! \}
Note: See TracChangeset for help on using the changeset viewer.