source: 3DVCSoftware/branches/HTM-4.1-dev2-RWTH/source/Lib/TLibEncoder/TEncCu.cpp @ 177

Last change on this file since 177 was 177, checked in by rwth, 12 years ago
  • added RWTH_B0036 (SDC+DLT)
  • Property svn:eol-style set to native
File size: 114.7 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2012, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TEncCu.cpp
35    \brief    Coding Unit (CU) encoder class
36*/
37
38#include <stdio.h>
39#include "TEncTop.h"
40#include "TEncCu.h"
41#include "TEncAnalyze.h"
42
43#include <cmath>
44#include <algorithm>
45using namespace std;
46
47//! \ingroup TLibEncoder
48//! \{
49
50// ====================================================================================================================
51// Constructor / destructor / create / destroy
52// ====================================================================================================================
53
54/**
55 \param    uiTotalDepth  total number of allowable depth
56 \param    uiMaxWidth    largest CU width
57 \param    uiMaxHeight   largest CU height
58 */
59Void TEncCu::create(UChar uhTotalDepth, UInt uiMaxWidth, UInt uiMaxHeight)
60{
61  Int i;
62 
63  m_uhTotalDepth   = uhTotalDepth + 1;
64  m_ppcBestCU      = new TComDataCU*[m_uhTotalDepth-1];
65  m_ppcTempCU      = new TComDataCU*[m_uhTotalDepth-1];
66 
67  m_ppcPredYuvBest = new TComYuv*[m_uhTotalDepth-1];
68  m_ppcResiYuvBest = new TComYuv*[m_uhTotalDepth-1];
69  m_ppcRecoYuvBest = new TComYuv*[m_uhTotalDepth-1];
70  m_ppcPredYuvTemp = new TComYuv*[m_uhTotalDepth-1];
71  m_ppcResiYuvTemp = new TComYuv*[m_uhTotalDepth-1];
72  m_ppcRecoYuvTemp = new TComYuv*[m_uhTotalDepth-1];
73  m_ppcOrigYuv     = new TComYuv*[m_uhTotalDepth-1];
74#if HHI_INTER_VIEW_RESIDUAL_PRED
75  m_ppcResPredTmp  = new TComYuv*[m_uhTotalDepth-1];
76#endif
77 
78#if HHI_MPI
79  m_puhDepthSaved  = new UChar[1ll<<( ( m_uhTotalDepth - 1 )<<1 )];
80  m_puhWidthSaved  = new UChar[1ll<<( ( m_uhTotalDepth - 1 )<<1 )];
81  m_puhHeightSaved = new UChar[1ll<<( ( m_uhTotalDepth - 1 )<<1 )];
82#endif
83
84  UInt uiNumPartitions;
85  for( i=0 ; i<m_uhTotalDepth-1 ; i++)
86  {
87    uiNumPartitions = 1<<( ( m_uhTotalDepth - i - 1 )<<1 );
88    UInt uiWidth  = uiMaxWidth  >> i;
89    UInt uiHeight = uiMaxHeight >> i;
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   
94    m_ppcPredYuvBest[i] = new TComYuv; m_ppcPredYuvBest[i]->create(uiWidth, uiHeight);
95    m_ppcResiYuvBest[i] = new TComYuv; m_ppcResiYuvBest[i]->create(uiWidth, uiHeight);
96    m_ppcRecoYuvBest[i] = new TComYuv; m_ppcRecoYuvBest[i]->create(uiWidth, uiHeight);
97   
98    m_ppcPredYuvTemp[i] = new TComYuv; m_ppcPredYuvTemp[i]->create(uiWidth, uiHeight);
99    m_ppcResiYuvTemp[i] = new TComYuv; m_ppcResiYuvTemp[i]->create(uiWidth, uiHeight);
100    m_ppcRecoYuvTemp[i] = new TComYuv; m_ppcRecoYuvTemp[i]->create(uiWidth, uiHeight);
101   
102    m_ppcOrigYuv    [i] = new TComYuv; m_ppcOrigYuv    [i]->create(uiWidth, uiHeight);
103#if HHI_INTER_VIEW_RESIDUAL_PRED
104    m_ppcResPredTmp [i] = new TComYuv; m_ppcResPredTmp [i]->create(uiWidth, uiHeight);
105#endif
106  }
107 
108  m_bEncodeDQP = false;
109#if BURST_IPCM
110  m_checkBurstIPCMFlag = false;
111#endif
112
113  // initialize partition order.
114  UInt* piTmp = &g_auiZscanToRaster[0];
115  initZscanToRaster( m_uhTotalDepth, 1, 0, piTmp);
116  initRasterToZscan( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
117 
118  // initialize conversion matrix from partition index to pel
119  initRasterToPelXY( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
120  initMotionReferIdx ( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
121}
122
123Void TEncCu::destroy()
124{
125  Int i;
126 
127#if HHI_MPI
128  delete[] m_puhDepthSaved;  m_puhDepthSaved  = NULL;
129  delete[] m_puhWidthSaved;  m_puhWidthSaved  = NULL;
130  delete[] m_puhHeightSaved; m_puhHeightSaved = NULL;
131#endif
132  for( i=0 ; i<m_uhTotalDepth-1 ; i++)
133  {
134    if(m_ppcBestCU[i])
135    {
136      m_ppcBestCU[i]->destroy();      delete m_ppcBestCU[i];      m_ppcBestCU[i] = NULL;
137    }
138    if(m_ppcTempCU[i])
139    {
140      m_ppcTempCU[i]->destroy();      delete m_ppcTempCU[i];      m_ppcTempCU[i] = NULL;
141    }
142    if(m_ppcPredYuvBest[i])
143    {
144      m_ppcPredYuvBest[i]->destroy(); delete m_ppcPredYuvBest[i]; m_ppcPredYuvBest[i] = NULL;
145    }
146    if(m_ppcResiYuvBest[i])
147    {
148      m_ppcResiYuvBest[i]->destroy(); delete m_ppcResiYuvBest[i]; m_ppcResiYuvBest[i] = NULL;
149    }
150    if(m_ppcRecoYuvBest[i])
151    {
152      m_ppcRecoYuvBest[i]->destroy(); delete m_ppcRecoYuvBest[i]; m_ppcRecoYuvBest[i] = NULL;
153    }
154    if(m_ppcPredYuvTemp[i])
155    {
156      m_ppcPredYuvTemp[i]->destroy(); delete m_ppcPredYuvTemp[i]; m_ppcPredYuvTemp[i] = NULL;
157    }
158    if(m_ppcResiYuvTemp[i])
159    {
160      m_ppcResiYuvTemp[i]->destroy(); delete m_ppcResiYuvTemp[i]; m_ppcResiYuvTemp[i] = NULL;
161    }
162    if(m_ppcRecoYuvTemp[i])
163    {
164      m_ppcRecoYuvTemp[i]->destroy(); delete m_ppcRecoYuvTemp[i]; m_ppcRecoYuvTemp[i] = NULL;
165    }
166    if(m_ppcOrigYuv[i])
167    {
168      m_ppcOrigYuv[i]->destroy();     delete m_ppcOrigYuv[i];     m_ppcOrigYuv[i] = NULL;
169    }
170#if HHI_INTER_VIEW_RESIDUAL_PRED
171    if(m_ppcResPredTmp[i])
172    {
173      m_ppcResPredTmp [i]->destroy(); delete m_ppcResPredTmp[i];  m_ppcResPredTmp[i] = NULL;
174    }
175#endif
176  }
177  if(m_ppcBestCU)
178  {
179    delete [] m_ppcBestCU;
180    m_ppcBestCU = NULL;
181  }
182  if(m_ppcTempCU)
183  {
184    delete [] m_ppcTempCU;
185    m_ppcTempCU = NULL;
186  }
187 
188  if(m_ppcPredYuvBest)
189  {
190    delete [] m_ppcPredYuvBest;
191    m_ppcPredYuvBest = NULL;
192  }
193  if(m_ppcResiYuvBest)
194  {
195    delete [] m_ppcResiYuvBest;
196    m_ppcResiYuvBest = NULL;
197  }
198  if(m_ppcRecoYuvBest)
199  {
200    delete [] m_ppcRecoYuvBest;
201    m_ppcRecoYuvBest = NULL;
202  }
203  if(m_ppcPredYuvTemp)
204  {
205    delete [] m_ppcPredYuvTemp;
206    m_ppcPredYuvTemp = NULL;
207  }
208  if(m_ppcResiYuvTemp)
209  {
210    delete [] m_ppcResiYuvTemp;
211    m_ppcResiYuvTemp = NULL;
212  }
213  if(m_ppcRecoYuvTemp)
214  {
215    delete [] m_ppcRecoYuvTemp;
216    m_ppcRecoYuvTemp = NULL;
217  }
218  if(m_ppcOrigYuv)
219  {
220    delete [] m_ppcOrigYuv;
221    m_ppcOrigYuv = NULL;
222  }
223#if HHI_INTER_VIEW_RESIDUAL_PRED
224  if(m_ppcResPredTmp)
225  {
226    delete [] m_ppcResPredTmp;
227    m_ppcResPredTmp = NULL;
228  }
229#endif
230}
231
232/** \param    pcEncTop      pointer of encoder class
233 */
234Void TEncCu::init( TEncTop* pcEncTop )
235{
236  m_pcEncCfg           = pcEncTop;
237  m_pcPredSearch       = pcEncTop->getPredSearch();
238  m_pcTrQuant          = pcEncTop->getTrQuant();
239  m_pcBitCounter       = pcEncTop->getBitCounter();
240  m_pcRdCost           = pcEncTop->getRdCost();
241 
242  m_pcEntropyCoder     = pcEncTop->getEntropyCoder();
243  m_pcCavlcCoder       = pcEncTop->getCavlcCoder();
244  m_pcSbacCoder       = pcEncTop->getSbacCoder();
245  m_pcBinCABAC         = pcEncTop->getBinCABAC();
246 
247  m_pppcRDSbacCoder   = pcEncTop->getRDSbacCoder();
248  m_pcRDGoOnSbacCoder = pcEncTop->getRDGoOnSbacCoder();
249 
250  m_bUseSBACRD        = pcEncTop->getUseSBACRD();
251}
252
253// ====================================================================================================================
254// Public member functions
255// ====================================================================================================================
256
257/** \param  rpcCU pointer of CU data class
258 */
259Void TEncCu::compressCU( TComDataCU*& rpcCU )
260{
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}
278/** \param  pcCU  pointer of CU data class, bForceTerminate when set to true terminates slice (default is false).
279 */
280Void TEncCu::encodeCU ( TComDataCU* pcCU, Bool bForceTerminate )
281{
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
298  xEncodeCU( pcCU, 0, 0 );
299 
300#if OL_FLUSH
301  bool bTerminateSlice = bForceTerminate;
302  UInt uiCUAddr = pcCU->getAddr();
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
351}
352
353// ====================================================================================================================
354// Protected member functions
355// ====================================================================================================================
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
448Void TEncCu::xCompressCU( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, UInt uiDepth )
449#endif
450{
451  TComPic* pcPic = rpcBestCU->getPic();
452
453#if OL_DEPTHLIMIT_A0044
454  TComSPS *sps = pcPic->getSlice(0)->getSPS();
455  TComPic *pcTexture;
456  TComDataCU * pcTextureCU;
457  Bool  depthMapDetect =  false;
458#if !LGE_CLEAN_UP
459  UInt         uiPrevTexPartIndex = 0;
460#endif
461#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
462  Bool bIntraSliceDetect = false;
463#endif
464  Bool bTry2NxN = false;
465  Bool bTryNx2N = false;
466    pcTexture = rpcBestCU->getSlice()->getTexturePic();
467    if(pcTexture != NULL) //depth map being encoded
468    {
469    depthMapDetect = true;
470#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
471      bIntraSliceDetect = (rpcBestCU->getSlice()->getSliceType()==I_SLICE);
472#endif
473    if(uiDepth == 0)
474    {
475      pcTextureCU = pcTexture->getCU( rpcBestCU->getAddr() );
476      pcTexture->setPartInfo(pcTextureCU->readPartInfo());
477      pcTexture->setTexPartIndex(0); 
478    }
479    }
480    else
481    {
482      depthMapDetect = false;
483    }
484#endif
485  // get Original YUV data from picture
486  m_ppcOrigYuv[uiDepth]->copyFromPicYuv( pcPic->getPicYuvOrg(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
487
488  // variables for fast encoder decision
489  Bool    bEarlySkip  = false;
490  Bool    bTrySplit   = true;
491  Double  fRD_Skip    = MAX_DOUBLE;
492
493  // variable for Early CU determination
494  Bool    bSubBranch = true;
495
496  // variable for Cbf fast mode PU decision
497  Bool    doNotBlockPu = true;
498
499  Bool    bTrySplitDQP  = true;
500
501  static  Double  afCost [ MAX_CU_DEPTH ];
502  static  Int      aiNum [ MAX_CU_DEPTH ];
503
504  if ( rpcBestCU->getAddr() == 0 )
505  {
506    ::memset( afCost, 0, sizeof( afCost ) );
507    ::memset( aiNum,  0, sizeof( aiNum  ) );
508  }
509
510  Bool bBoundary = false;
511  UInt uiLPelX   = rpcBestCU->getCUPelX();
512  UInt uiRPelX   = uiLPelX + rpcBestCU->getWidth(0)  - 1;
513  UInt uiTPelY   = rpcBestCU->getCUPelY();
514  UInt uiBPelY   = uiTPelY + rpcBestCU->getHeight(0) - 1;
515
516#if LGE_ILLUCOMP_B0045
517  Bool bICEnabled = (!rpcTempCU->getSlice()->getIsDepth() && rpcTempCU->getSlice()->getViewId());
518
519  bICEnabled = bICEnabled && rpcTempCU->getSlice()->getApplyIC();
520#endif
521
522#if HHI_INTERVIEW_SKIP
523  Bool bFullyRenderedSec = true ;
524  if( m_pcEncCfg->getInterViewSkip() )
525  {
526    Pel* pUsedSamples ;
527    UInt uiStride ;
528    pUsedSamples =  pcPic->getUsedPelsMap()->getLumaAddr( rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
529    uiStride = pcPic->getUsedPelsMap()->getStride();
530
531    for ( Int y=0; y<m_ppcOrigYuv[uiDepth]->getHeight(); y++)
532    {
533      for ( Int x=0; x<m_ppcOrigYuv[uiDepth]->getWidth(); x++)
534      {
535        if( pUsedSamples[x] !=0 )
536        {
537          bFullyRenderedSec = false ;
538          break ;
539        }
540      }
541      if ( !bFullyRenderedSec )
542      {
543        break;
544      }
545      pUsedSamples += uiStride ;
546    }
547  }
548  else
549  {
550    bFullyRenderedSec = false ;
551  }
552
553#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
554  if( bFullyRenderedSec )
555  {
556    m_pcRdCost->setLambdaScale( m_pcEncCfg->getInterViewSkipLambdaScale() );
557  }
558  else
559  {
560    m_pcRdCost->setLambdaScale( 1 );
561  }
562  rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
563#endif
564
565#endif
566  Int iBaseQP = xComputeQP( rpcBestCU, uiDepth );
567  Int iMinQP;
568  Int iMaxQP;
569#if LOSSLESS_CODING
570  Bool isAddLowestQP = false;
571#if H0736_AVC_STYLE_QP_RANGE
572  Int lowestQP = -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY();
573#else
574  Int lowestQP = 0;
575#endif
576#endif
577
578  if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
579  {
580    Int idQP = m_pcEncCfg->getMaxDeltaQP();
581#if H0736_AVC_STYLE_QP_RANGE
582    iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
583    iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
584#if LOSSLESS_CODING
585    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
586    {
587      isAddLowestQP = true; 
588      iMinQP = iMinQP - 1;
589
590    }
591#endif
592#else
593    iMinQP = Clip3( MIN_QP, MAX_QP, iBaseQP-idQP );
594    iMaxQP = Clip3( MIN_QP, MAX_QP, iBaseQP+idQP );
595#if LOSSLESS_CODING
596    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
597    {
598      isAddLowestQP = true;
599      iMinQP = iMinQP - 1;
600    }
601#endif
602#endif
603  }
604  else
605  {
606    iMinQP = rpcTempCU->getQP(0);
607    iMaxQP = rpcTempCU->getQP(0);
608  }
609
610  // If slice start or slice end is within this cu...
611  TComSlice * pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
612  Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr()>rpcTempCU->getSCUAddr()&&pcSlice->getEntropySliceCurStartCUAddr()<rpcTempCU->getSCUAddr()+rpcTempCU->getTotalNumPart();
613  Bool bSliceEnd = (pcSlice->getEntropySliceCurEndCUAddr()>rpcTempCU->getSCUAddr()&&pcSlice->getEntropySliceCurEndCUAddr()<rpcTempCU->getSCUAddr()+rpcTempCU->getTotalNumPart());
614  Bool bInsidePicture = ( uiRPelX < rpcBestCU->getSlice()->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < rpcBestCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
615  // We need to split, so don't try these modes.
616  if(!bSliceEnd && !bSliceStart && bInsidePicture )
617  {
618    for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
619    {
620#if LOSSLESS_CODING
621      if (isAddLowestQP && (iQP == iMinQP))
622      {
623        iQP = lowestQP;
624      }
625#endif
626      // variables for fast encoder decision
627      bEarlySkip  = false;
628      bTrySplit    = true;
629      fRD_Skip    = MAX_DOUBLE;
630
631      rpcTempCU->initEstData( uiDepth, iQP );
632
633#if OL_DEPTHLIMIT_A0044
634      //logic for setting bTrySplit using the partition information that is stored of the texture colocated CU
635#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
636      if(depthMapDetect && !bIntraSliceDetect && sps->getUseDPL())
637#else
638      if(depthMapDetect && sps->getUseDPL()) //depth map being encoded
639#endif
640      {
641        assert(uiDepth == pcTexture->accessPartInfo(1));
642        if(pcTexture->accessPartInfo(0) == 1) //NxN modes
643        {
644          bTrySplit = true;
645          bTryNx2N = true;
646          bTry2NxN = true;
647#if !LGE_CLEAN_UP
648          uiPrevTexPartIndex = pcTexture->getTexPartIndex(); 
649#endif
650          pcTexture->incrementTexPartIndex(); 
651        }
652        else if(pcTexture->accessPartInfo(0) == 0) //2Nx2N modes
653        {
654          UInt uiTexdepth;
655          UInt temp_uiTexPartIndex;
656          bTrySplit = false;
657
658          //scan ahead till next depth
659          uiTexdepth = pcTexture->accessPartInfo(1);
660#if !LGE_CLEAN_UP
661          uiPrevTexPartIndex = pcTexture->getTexPartIndex(); 
662#endif
663          pcTexture->incrementTexPartIndex();
664          temp_uiTexPartIndex = pcTexture->getTexPartIndex(); //store in case to rewind
665
666          while(uiTexdepth != pcTexture->accessPartInfo(1) && uiTexdepth != 0)
667          {
668            if(pcTexture->accessPartInfo(1) < uiTexdepth)
669            {
670              break;
671            }
672            pcTexture->incrementTexPartIndex(); 
673
674            if(pcTexture->accessPartInfo(1) == OL_END_CU)
675            {
676              pcTexture->setTexPartIndex(temp_uiTexPartIndex); 
677              uiTexdepth++;
678              if(uiTexdepth >= g_uiMaxCUDepth)
679              {     
680                break;
681              }
682            }
683          }
684        }
685        else if(pcTexture->accessPartInfo(0) == OL_END_CU)
686        {
687          bTrySplit = false;
688          bTryNx2N = false;
689          bTry2NxN = false;
690        }
691        else if(pcTexture->accessPartInfo(0) == 2) //2NxN case
692        {
693          bTrySplit = false;
694          bTryNx2N = false;
695          bTry2NxN = true;
696#if !LGE_CLEAN_UP
697          uiPrevTexPartIndex = pcTexture->getTexPartIndex(); 
698#endif
699          pcTexture->incrementTexPartIndex(); ;
700        }
701        else if(pcTexture->accessPartInfo(0) == 3) //Nx2N case
702        {
703          bTrySplit = false;
704          bTryNx2N = true;
705          bTry2NxN = false;
706#if !LGE_CLEAN_UP
707          uiPrevTexPartIndex = pcTexture->getTexPartIndex(); 
708#endif
709          pcTexture->incrementTexPartIndex(); ;
710        }
711      }
712#endif
713
714
715      // do inter modes, SKIP and 2Nx2N
716      if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
717      {
718#if HHI_INTER_VIEW_RESIDUAL_PRED
719        // check availability of residual prediction
720        Bool  bResPredAvailable   = false;
721        Bool  bResPredAllowed     =                    (!rpcBestCU->getSlice()->getSPS()->isDepth                () );
722        bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getViewId              () );
723        bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getMultiviewResPredMode() );
724        if( bResPredAllowed )
725        {
726          bResPredAvailable       = rpcBestCU->getResidualSamples( 0, 
727#if QC_SIMPLIFIEDIVRP_M24938
728            true ,
729#endif
730            m_ppcResPredTmp[uiDepth] );
731        }
732
733        for( UInt uiResPrdId = 0; uiResPrdId < ( bResPredAvailable ? 2 : 1 ); uiResPrdId++ )
734        {
735          Bool bResPredFlag  = ( uiResPrdId > 0 );
736#if LGE_ILLUCOMP_B0045
737          for(UInt uiICId = 0; uiICId < (bICEnabled ? 2 : 1); uiICId++)
738          {
739            Bool bICFlag = (uiICId ? true : false);
740            rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
741#endif
742#endif
743#if HHI_INTER_VIEW_RESIDUAL_PRED
744          rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
745#endif
746          // SKIP
747#if HHI_INTERVIEW_SKIP
748          xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU, bFullyRenderedSec );
749#else
750          xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU );
751#endif
752          rpcTempCU->initEstData( uiDepth, iQP );
753
754          // fast encoder decision for early skip
755          if ( m_pcEncCfg->getUseFastEnc() )
756          {
757            Int iIdx = g_aucConvertToBit[ rpcBestCU->getWidth(0) ];
758            if ( aiNum [ iIdx ] > 5 && fRD_Skip < EARLY_SKIP_THRES*afCost[ iIdx ]/aiNum[ iIdx ] )
759            {
760              bEarlySkip = true;
761              bTrySplit  = false;
762            }
763          }
764#if LGE_ILLUCOMP_B0045_ENCSIMP
765          if(bICFlag && rpcBestCU->getMergeFlag(0) && !rpcBestCU->getICFlag(0))
766          {
767             bICEnabled = false;
768             break;
769          }
770#endif
771          // 2Nx2N, NxN
772          if ( !bEarlySkip )
773          {
774#if HHI_INTER_VIEW_RESIDUAL_PRED
775            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
776#endif
777#if HHI_INTERVIEW_SKIP
778            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFullyRenderedSec );
779
780#else
781            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
782#endif
783            rpcTempCU->initEstData( uiDepth, iQP );
784            if(m_pcEncCfg->getUseCbfFastMode())
785            {
786              doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
787            }
788          }
789#if LGE_ILLUCOMP_B0045
790         }
791#endif
792#if HHI_INTER_VIEW_RESIDUAL_PRED
793        } // uiResPrdId
794#endif
795      } // != I_SLICE
796
797#if LGE_ILLUCOMP_B0045_ENCSIMP
798    bICEnabled = rpcBestCU->getICFlag(0);
799#endif
800
801#if OL_DEPTHLIMIT_A0044
802#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
803      if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
804#else
805      if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
806#endif
807      {
808        bTrySplitDQP = bTrySplit;
809      }
810      else
811      {
812        if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
813        {
814          if(iQP == iBaseQP)
815          {
816            bTrySplitDQP = bTrySplit;
817          }
818        }
819        else
820        {
821          bTrySplitDQP = bTrySplit;
822        }
823      }
824#else
825
826      if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
827      {
828        if(iQP == iBaseQP)
829        {
830          bTrySplitDQP = bTrySplit;
831        }
832      }
833      else
834      {
835        bTrySplitDQP = bTrySplit;
836      }
837#endif
838#if LOSSLESS_CODING
839      if (isAddLowestQP && (iQP == lowestQP))
840      {
841        iQP = iMinQP;
842      }
843#endif
844    }  // end for iMinQP to iMaxQP
845
846
847    for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
848    {
849#if LOSSLESS_CODING
850      if (isAddLowestQP && (iQP == iMinQP))
851      {
852        iQP = lowestQP;
853      }
854#endif
855      rpcTempCU->initEstData( uiDepth, iQP );
856
857      // do inter modes, NxN, 2NxN, and Nx2N
858      if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
859      {
860#if HHI_INTER_VIEW_RESIDUAL_PRED
861        // check availability of residual prediction
862        Bool  bResPredAvailable   = false;
863        Bool  bResPredAllowed     =                    (!rpcBestCU->getSlice()->getSPS()->isDepth                () );
864        bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getViewId              () );
865        bResPredAllowed           = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getMultiviewResPredMode() );
866        if( bResPredAllowed )
867        {
868          bResPredAvailable       = rpcBestCU->getResidualSamples( 0, 
869#if QC_SIMPLIFIEDIVRP_M24938
870            true,
871#endif
872            m_ppcResPredTmp[uiDepth] );
873        }
874
875        for( UInt uiResPrdId = 0; uiResPrdId < ( bResPredAvailable ? 2 : 1 ); uiResPrdId++ )
876        {
877          Bool bResPredFlag  = ( uiResPrdId > 0 );
878#if LGE_ILLUCOMP_B0045
879          for(UInt uiICId = 0; uiICId < (bICEnabled ? 2 : 1); uiICId++)
880          {
881            Bool bICFlag = (uiICId ? true : false);
882            rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
883#endif
884#endif
885          // 2Nx2N, NxN
886          if ( !bEarlySkip )
887          {
888
889            if(!( rpcBestCU->getSlice()->getSPS()->getDisInter4x4()  && (rpcBestCU->getWidth(0)==8) && (rpcBestCU->getHeight(0)==8) ))
890            {
891              if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && doNotBlockPu)
892              {
893#if OL_DEPTHLIMIT_A0044 //add code here to select 2NxN or Nx2N or none
894#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
895                if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
896#else
897                if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
898#endif
899                {
900                  if (bTrySplit)
901                  {
902#endif
903#if HHI_INTER_VIEW_RESIDUAL_PRED
904                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
905#endif
906#if HHI_INTERVIEW_SKIP
907                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN, bFullyRenderedSec   );
908#else
909                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN   );
910#endif
911                    rpcTempCU->initEstData( uiDepth, iQP );
912#if OL_DEPTHLIMIT_A0044
913                  }//bTrySplit
914                }//depthMapDetect
915                else//do things normally
916                {
917#if HHI_INTER_VIEW_RESIDUAL_PRED
918                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
919#endif
920#if HHI_INTERVIEW_SKIP
921                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN, bFullyRenderedSec   );
922#else
923                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN   );
924#endif
925                  rpcTempCU->initEstData( uiDepth, iQP );
926                }
927#endif
928              } 
929            }
930          }
931
932          { // 2NxN, Nx2N
933#if OL_DEPTHLIMIT_A0044 //add code here to select 2NxN or Nx2N or none
934#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
935            if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
936#else
937            if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
938#endif
939            {
940              if (bTryNx2N)
941              {
942#endif
943                if(doNotBlockPu)
944                {
945#if HHI_INTER_VIEW_RESIDUAL_PRED
946                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
947#endif
948#if HHI_INTERVIEW_SKIP
949                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N, bFullyRenderedSec   );
950#else
951                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N  );
952#endif
953                  rpcTempCU->initEstData( uiDepth, iQP );
954                  if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
955                  {
956                    doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
957                  }
958                }
959#if OL_DEPTHLIMIT_A0044
960              }//bTryNx2N
961            }//depthMapDetect
962            else//do things normally
963            {
964              if(doNotBlockPu)
965              {
966#if HHI_INTER_VIEW_RESIDUAL_PRED
967                rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
968#endif
969#if HHI_INTERVIEW_SKIP
970                xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N, bFullyRenderedSec   );
971#else
972                xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N  );
973#endif
974                rpcTempCU->initEstData( uiDepth, iQP );
975                if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
976                {
977                  doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
978                }
979              }
980            }
981#endif
982
983#if OL_DEPTHLIMIT_A0044 //add code here to select 2NxN or Nx2N or none
984#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
985            if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
986#else
987            if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
988#endif
989            {
990              if (bTry2NxN)
991              {
992#endif
993                if(doNotBlockPu)
994                {
995#if HHI_INTER_VIEW_RESIDUAL_PRED
996                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
997#endif
998#if HHI_INTERVIEW_SKIP
999                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxN, bFullyRenderedSec   );
1000#else
1001                  xCheckRDCostInter      ( rpcBestCU, rpcTempCU, SIZE_2NxN  );
1002#endif
1003                  rpcTempCU->initEstData( uiDepth, iQP );
1004                  if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxN)
1005                  {
1006                    doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1007                  }
1008                }
1009#if OL_DEPTHLIMIT_A0044
1010              }//bTryNx2N
1011            }//depthMapDetect
1012            else//do things normally
1013            {
1014              if(doNotBlockPu)
1015              {
1016#if HHI_INTER_VIEW_RESIDUAL_PRED
1017                rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1018#endif
1019#if HHI_INTERVIEW_SKIP
1020                xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxN, bFullyRenderedSec   );
1021#else
1022                xCheckRDCostInter      ( rpcBestCU, rpcTempCU, SIZE_2NxN  );
1023#endif
1024                rpcTempCU->initEstData( uiDepth, iQP );
1025                if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxN)
1026                {
1027                  doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1028                }
1029              }
1030            }
1031#endif
1032          }
1033
1034#if 1
1035          //! Try AMP (SIZE_2NxnU, SIZE_2NxnD, SIZE_nLx2N, SIZE_nRx2N)
1036          if( pcPic->getSlice(0)->getSPS()->getAMPAcc(uiDepth) )
1037          {
1038#if AMP_ENC_SPEEDUP       
1039            Bool bTestAMP_Hor = false, bTestAMP_Ver = false;
1040
1041#if AMP_MRG
1042            Bool bTestMergeAMP_Hor = false, bTestMergeAMP_Ver = false;
1043
1044            deriveTestModeAMP (rpcBestCU, eParentPartSize, bTestAMP_Hor, bTestAMP_Ver, bTestMergeAMP_Hor, bTestMergeAMP_Ver);
1045#else
1046            deriveTestModeAMP (rpcBestCU, eParentPartSize, bTestAMP_Hor, bTestAMP_Ver);
1047#endif
1048
1049            //! Do horizontal AMP
1050            if ( bTestAMP_Hor )
1051            {
1052#if OL_DEPTHLIMIT_A0044 //add code here to select 2NxN or Nx2N or none
1053#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
1054              if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
1055#else
1056              if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
1057#endif
1058              {
1059                if (bTry2NxN)
1060                {
1061#endif
1062                  if(doNotBlockPu)
1063                  {
1064#if HHI_INTER_VIEW_RESIDUAL_PRED
1065                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1066#endif
1067#if HHI_INTERVIEW_SKIP
1068                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec );
1069#else
1070                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
1071#endif
1072                    rpcTempCU->initEstData( uiDepth, iQP );
1073                    if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
1074                    {
1075                      doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1076                    }
1077                  }
1078                  if(doNotBlockPu)
1079                  {
1080#if HHI_INTER_VIEW_RESIDUAL_PRED
1081                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1082#endif
1083#if HHI_INTERVIEW_SKIP
1084                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec );
1085#else
1086                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
1087#endif
1088                    rpcTempCU->initEstData( uiDepth, iQP );
1089                    if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
1090                    {
1091                      doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1092                    }
1093                  }
1094#if OL_DEPTHLIMIT_A0044
1095                }//bTry2NxN
1096              }//depthMapDetect
1097              else//do things normally
1098              {
1099                if(doNotBlockPu)
1100                {
1101#if HHI_INTER_VIEW_RESIDUAL_PRED
1102                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1103#endif
1104#if HHI_INTERVIEW_SKIP
1105                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec );
1106#else
1107                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
1108#endif
1109                  rpcTempCU->initEstData( uiDepth, iQP );
1110                  if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
1111                  {
1112                    doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1113                  }
1114                }
1115                if(doNotBlockPu)
1116                {
1117#if HHI_INTER_VIEW_RESIDUAL_PRED
1118                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1119#endif
1120#if HHI_INTERVIEW_SKIP
1121                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec );
1122#else
1123                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
1124#endif
1125                  rpcTempCU->initEstData( uiDepth, iQP );
1126                  if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
1127                  {
1128                    doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1129                  }
1130                }
1131              }
1132#endif
1133            }
1134#if AMP_MRG
1135            else if ( bTestMergeAMP_Hor ) 
1136            {
1137#if OL_DEPTHLIMIT_A0044 //add code here to select 2NxN or Nx2N or none
1138#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
1139              if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
1140#else
1141              if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
1142#endif
1143              {
1144                if (bTry2NxN)
1145                {
1146#endif
1147                  if(doNotBlockPu)
1148                  {
1149#if HHI_INTER_VIEW_RESIDUAL_PRED
1150                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1151#endif
1152#if HHI_INTERVIEW_SKIP
1153                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec, true );
1154#else
1155                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, true );
1156#endif
1157                    rpcTempCU->initEstData( uiDepth, iQP );
1158                    if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
1159                    {
1160                      doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1161                    }
1162                  }
1163                  if(doNotBlockPu)
1164                  {
1165#if HHI_INTER_VIEW_RESIDUAL_PRED
1166                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1167#endif
1168#if HHI_INTERVIEW_SKIP
1169                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec, true );
1170#else
1171                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, true );
1172#endif
1173                    rpcTempCU->initEstData( uiDepth, iQP );
1174                    if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
1175                    {
1176                      doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1177                    }
1178                  }
1179#if OL_DEPTHLIMIT_A0044
1180                }//bTry2NxN
1181              }//depthMapDetect
1182              else//do things normally
1183              {
1184                if(doNotBlockPu)
1185                {
1186#if HHI_INTER_VIEW_RESIDUAL_PRED
1187                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1188#endif
1189#if HHI_INTERVIEW_SKIP
1190                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec, true );
1191#else
1192                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, true );
1193#endif
1194                  rpcTempCU->initEstData( uiDepth, iQP );
1195                  if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
1196                  {
1197                    doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1198                  }
1199                }
1200                if(doNotBlockPu)
1201                {
1202#if HHI_INTER_VIEW_RESIDUAL_PRED
1203                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1204#endif
1205#if HHI_INTERVIEW_SKIP
1206                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec, true );
1207#else
1208                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, true );
1209#endif
1210                  rpcTempCU->initEstData( uiDepth, iQP );
1211                  if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
1212                  {
1213                    doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1214                  }
1215                }
1216
1217              }
1218#endif
1219            }
1220#endif
1221
1222            //! Do horizontal AMP
1223            if ( bTestAMP_Ver )
1224            {
1225#if OL_DEPTHLIMIT_A0044 //add code here to select 2NxN or Nx2N or none
1226#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
1227              if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
1228#else
1229              if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
1230#endif
1231              {
1232                if (bTryNx2N)
1233                {
1234#endif
1235                  if(doNotBlockPu)
1236                  {
1237#if HHI_INTER_VIEW_RESIDUAL_PRED
1238                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1239#endif
1240#if HHI_INTERVIEW_SKIP
1241                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec );
1242#else
1243                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
1244#endif
1245                    rpcTempCU->initEstData( uiDepth, iQP );
1246                    if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
1247                    {
1248                      doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1249                    }
1250                  }
1251                  if(doNotBlockPu)
1252                  {
1253#if HHI_INTER_VIEW_RESIDUAL_PRED
1254                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1255#endif
1256#if HHI_INTERVIEW_SKIP
1257                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec );
1258#else
1259                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
1260#endif
1261                    rpcTempCU->initEstData( uiDepth, iQP );
1262                  }
1263#if OL_DEPTHLIMIT_A0044
1264                }//bTryNx2N
1265              }//depthMapDetect
1266              else//do things normally
1267              {
1268                if(doNotBlockPu)
1269                {
1270#if HHI_INTER_VIEW_RESIDUAL_PRED
1271                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1272#endif
1273#if HHI_INTERVIEW_SKIP
1274                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec );
1275#else
1276                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
1277#endif
1278                  rpcTempCU->initEstData( uiDepth, iQP );
1279                  if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
1280                  {
1281                    doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1282                  }
1283                }
1284                if(doNotBlockPu)
1285                {
1286#if HHI_INTER_VIEW_RESIDUAL_PRED
1287                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1288#endif
1289#if HHI_INTERVIEW_SKIP
1290                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec );
1291#else
1292                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
1293#endif
1294                  rpcTempCU->initEstData( uiDepth, iQP );
1295                }
1296              }
1297#endif
1298            }
1299#if AMP_MRG
1300            else if ( bTestMergeAMP_Ver )
1301            {
1302#if OL_DEPTHLIMIT_A0044 //add code here to select 2NxN or Nx2N or none
1303#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
1304              if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
1305#else
1306              if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
1307#endif
1308              {
1309                if (bTryNx2N)
1310                {
1311#endif
1312                  if(doNotBlockPu)
1313                  {
1314#if HHI_INTER_VIEW_RESIDUAL_PRED
1315                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1316#endif
1317#if HHI_INTERVIEW_SKIP
1318                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec, true );
1319#else
1320                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, true );
1321#endif
1322                    rpcTempCU->initEstData( uiDepth, iQP );
1323                    if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
1324                    {
1325                      doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1326                    }
1327                  }
1328                  if(doNotBlockPu)
1329                  {
1330#if HHI_INTER_VIEW_RESIDUAL_PRED
1331                    rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1332#endif
1333#if HHI_INTERVIEW_SKIP
1334                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec, true );
1335#else
1336                    xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, true );
1337#endif
1338                    rpcTempCU->initEstData( uiDepth, iQP );
1339                  }
1340#if OL_DEPTHLIMIT_A0044
1341                }//bTryNx2N
1342              }//depthMapDetect
1343              else//do things normally
1344              {
1345                if(doNotBlockPu)
1346                {
1347#if HHI_INTER_VIEW_RESIDUAL_PRED
1348                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1349#endif
1350#if HHI_INTERVIEW_SKIP
1351                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec, true );
1352#else
1353                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, true );
1354#endif
1355                  rpcTempCU->initEstData( uiDepth, iQP );
1356                  if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
1357                  {
1358                    doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1359                  }
1360                }
1361                if(doNotBlockPu)
1362                {
1363#if HHI_INTER_VIEW_RESIDUAL_PRED
1364                  rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1365#endif
1366#if HHI_INTERVIEW_SKIP
1367                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec, true );
1368#else
1369                  xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, true );
1370#endif
1371                  rpcTempCU->initEstData( uiDepth, iQP );
1372                }
1373              }
1374#endif
1375            }
1376#endif
1377
1378#else
1379#if HHI_INTER_VIEW_RESIDUAL_PRED
1380            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1381#endif
1382#if HHI_INTERVIEW_SKIP
1383            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec );
1384#else
1385            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
1386#endif
1387            rpcTempCU->initEstData( uiDepth, iQP );
1388#if HHI_INTER_VIEW_RESIDUAL_PRED
1389            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1390#endif
1391#if HHI_INTERVIEW_SKIP
1392            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec );
1393#else
1394            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
1395#endif
1396            rpcTempCU->initEstData( uiDepth, iQP );
1397#if HHI_INTER_VIEW_RESIDUAL_PRED
1398            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1399#endif
1400#if HHI_INTERVIEW_SKIP
1401            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec );
1402#else
1403            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
1404#endif
1405            rpcTempCU->initEstData( uiDepth, iQP );
1406#if HHI_INTER_VIEW_RESIDUAL_PRED
1407            rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1408#endif
1409#if HHI_INTERVIEW_SKIP
1410            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec );
1411#else
1412            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
1413#endif
1414            rpcTempCU->initEstData( uiDepth, iQP );
1415
1416#endif
1417          } //! Try AMP (SIZE_2NxnU, SIZE_2NxnD, SIZE_nLx2N, SIZE_nRx2N)
1418#endif
1419#if LGE_ILLUCOMP_B0045
1420         }
1421#endif
1422#if HHI_INTER_VIEW_RESIDUAL_PRED
1423        } // uiResPrdId
1424#endif
1425      } // != I_SLICE
1426
1427      // initialize PCM flag
1428      rpcTempCU->setIPCMFlag( 0, false);
1429      rpcTempCU->setIPCMFlagSubParts ( false, 0, uiDepth); //SUB_LCU_DQP
1430
1431      // do normal intra modes
1432      if ( !bEarlySkip )
1433      {
1434        // speedup for inter frames
1435#if HHI_INTERVIEW_SKIP
1436        if( ( rpcBestCU->getSlice()->getSliceType() == I_SLICE ||
1437          rpcBestCU->getCbf( 0, TEXT_LUMA     ) != 0   ||
1438          rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0   ||
1439          rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0 ) && !bFullyRenderedSec ) // avoid very complex intra if it is unlikely
1440#else
1441        if( rpcBestCU->getSlice()->getSliceType() == I_SLICE || 
1442          rpcBestCU->getCbf( 0, TEXT_LUMA     ) != 0   ||
1443          rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0   ||
1444          rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0     ) // avoid very complex intra if it is unlikely
1445#endif
1446        {
1447#if LGE_ILLUCOMP_B0045
1448          rpcTempCU->setICFlagSubParts(false, 0, 0, uiDepth);
1449#endif
1450          xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
1451          rpcTempCU->initEstData( uiDepth, iQP );
1452          if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
1453          {
1454#if OL_DEPTHLIMIT_A0044 //add code here to select or deselect NxN mode for Intra
1455#if OL_DO_NOT_LIMIT_INTRA_SLICES_PART
1456            if(depthMapDetect && !bIntraSliceDetect  && sps->getUseDPL())
1457#else
1458            if(depthMapDetect  && sps->getUseDPL()) //depth map being encoded
1459#endif
1460            {
1461              if (bTrySplit)
1462              {
1463
1464#endif
1465                if( rpcTempCU->getWidth(0) > ( 1 << rpcTempCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() ) )
1466                {
1467#if LGE_ILLUCOMP_B0045
1468                  rpcTempCU->setICFlagSubParts(false, 0, 0, uiDepth);
1469#endif
1470                  xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN   );
1471                  rpcTempCU->initEstData( uiDepth, iQP );
1472                }
1473#if OL_DEPTHLIMIT_A0044
1474              }//bTrySplit
1475            }//depthMapDetect
1476            else
1477            {
1478              if( rpcTempCU->getWidth(0) > ( 1 << rpcTempCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() ) )
1479              {
1480                xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN   );
1481                rpcTempCU->initEstData( uiDepth, iQP );
1482              }
1483            }
1484#endif
1485          }
1486        }
1487      }
1488
1489      // test PCM
1490      if(pcPic->getSlice(0)->getSPS()->getUsePCM()
1491        && rpcTempCU->getWidth(0) <= (1<<pcPic->getSlice(0)->getSPS()->getPCMLog2MaxSize())
1492        && rpcTempCU->getWidth(0) >= (1<<pcPic->getSlice(0)->getSPS()->getPCMLog2MinSize()) )
1493      {
1494        UInt uiRawBits = (g_uiBitDepth * rpcBestCU->getWidth(0) * rpcBestCU->getHeight(0) * 3 / 2);
1495        UInt uiBestBits = rpcBestCU->getTotalBits();
1496#if HHI_VSO
1497        Double dRDCostTemp = m_pcRdCost->getUseVSO() ? m_pcRdCost->calcRdCostVSO(uiRawBits, 0) : m_pcRdCost->calcRdCost(uiRawBits, 0);
1498        if((uiBestBits > uiRawBits) || (rpcBestCU->getTotalCost() > dRDCostTemp ))
1499#else
1500        if((uiBestBits > uiRawBits) || (rpcBestCU->getTotalCost() > m_pcRdCost->calcRdCost(uiRawBits, 0)))
1501#endif
1502        {
1503#if LGE_ILLUCOMP_B0045
1504          rpcTempCU->setICFlagSubParts(false, 0, 0, uiDepth);
1505#endif
1506          xCheckIntraPCM (rpcBestCU, rpcTempCU);
1507          rpcTempCU->initEstData( uiDepth, iQP );
1508        }
1509      }
1510#if HHI_MPI
1511      if( rpcBestCU->getSlice()->getSPS()->getUseMVI() && rpcBestCU->getSlice()->getSliceType() != I_SLICE )
1512      {
1513        xCheckRDCostMvInheritance( rpcBestCU, rpcTempCU, uiDepth, false, false );
1514        rpcTempCU->initEstData( uiDepth, iQP );
1515        xCheckRDCostMvInheritance( rpcBestCU, rpcTempCU, uiDepth, true, false );
1516        rpcTempCU->initEstData( uiDepth, iQP );
1517      }
1518#endif
1519#if LOSSLESS_CODING
1520      if (isAddLowestQP && (iQP == lowestQP))
1521      {
1522        iQP = iMinQP;
1523      }
1524#endif
1525    }
1526
1527    m_pcEntropyCoder->resetBits();
1528    m_pcEntropyCoder->encodeSplitFlag( rpcBestCU, 0, uiDepth, true );
1529    rpcBestCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
1530    if(m_pcEncCfg->getUseSBACRD())
1531    {
1532      rpcBestCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
1533    }
1534
1535#if HHI_VSO   
1536    if ( m_pcRdCost->getUseVSO() )
1537    {
1538      rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
1539    }
1540    else
1541#endif
1542    {
1543      rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
1544    }
1545
1546    // accumulate statistics for early skip
1547    if ( m_pcEncCfg->getUseFastEnc() )
1548    {
1549      if ( rpcBestCU->isSkipped(0) )
1550      {
1551        Int iIdx = g_aucConvertToBit[ rpcBestCU->getWidth(0) ];
1552        afCost[ iIdx ] += rpcBestCU->getTotalCost();
1553        aiNum [ iIdx ] ++;
1554      }
1555    }
1556
1557    // Early CU determination
1558    if( m_pcEncCfg->getUseEarlyCU() && ((*rpcBestCU->getPredictionMode()) == 0) )
1559    {
1560      bSubBranch = false;
1561    }
1562    else
1563    {
1564      bSubBranch = true;
1565    }
1566#if HHI_INTERVIEW_SKIP
1567    rpcBestCU->setRenderableSubParts(bFullyRenderedSec,0,rpcBestCU->getDepth( 0 )) ;
1568#endif
1569  }
1570  else if(!(bSliceEnd && bInsidePicture))
1571  {
1572    bBoundary = true;
1573  }
1574
1575#if LOSSLESS_CODING
1576  // copy orginal YUV samples to PCM buffer
1577  if( rpcBestCU->isLosslessCoded(0) && (rpcBestCU->getIPCMFlag(0) == false))
1578  {
1579    xFillPCMBuffer(rpcBestCU, m_ppcOrigYuv[uiDepth]);
1580  }
1581#endif
1582  if( (g_uiMaxCUWidth>>uiDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
1583  {
1584    Int idQP = m_pcEncCfg->getMaxDeltaQP();
1585#if H0736_AVC_STYLE_QP_RANGE
1586    iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
1587    iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
1588#if LOSSLESS_CODING
1589    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
1590    {
1591      isAddLowestQP = true;
1592      iMinQP = iMinQP - 1;     
1593    }
1594#endif
1595#else
1596    iMinQP = Clip3( MIN_QP, MAX_QP, iBaseQP-idQP );
1597    iMaxQP = Clip3( MIN_QP, MAX_QP, iBaseQP+idQP );
1598#if LOSSLESS_CODING
1599    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
1600    {
1601      isAddLowestQP = true;
1602      iMinQP = iMinQP - 1;
1603    }
1604#endif
1605#endif
1606  }
1607  else if( (g_uiMaxCUWidth>>uiDepth) > rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
1608  {
1609    iMinQP = iBaseQP;
1610    iMaxQP = iBaseQP;
1611  }
1612  else
1613  {
1614    Int iStartQP;
1615    if( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) == pcSlice->getEntropySliceCurStartCUAddr())
1616    {
1617      iStartQP = rpcTempCU->getQP(0);
1618    }
1619    else
1620    {
1621      UInt uiCurSliceStartPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
1622      iStartQP = rpcTempCU->getQP(uiCurSliceStartPartIdx);
1623    }
1624    iMinQP = iStartQP;
1625    iMaxQP = iStartQP;
1626  }
1627
1628  for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
1629  {
1630#if LOSSLESS_CODING
1631    if (isAddLowestQP && (iQP == iMinQP))
1632    {
1633      iQP = lowestQP;
1634    }
1635#endif
1636    rpcTempCU->initEstData( uiDepth, iQP );
1637
1638    // further split
1639    if( bSubBranch && bTrySplitDQP && uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth )
1640    {
1641#if HHI_VSO
1642      // reset Model
1643      if( m_pcRdCost->getUseRenModel() )
1644      {
1645        UInt  uiWidth     = m_ppcOrigYuv[uiDepth]->getWidth ( );
1646        UInt  uiHeight    = m_ppcOrigYuv[uiDepth]->getHeight( );
1647        Pel*  piSrc       = m_ppcOrigYuv[uiDepth]->getLumaAddr( 0 );
1648        UInt  uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride();
1649        m_pcRdCost->setRenModelData( m_ppcBestCU[uiDepth], 0, piSrc, uiSrcStride, uiWidth, uiHeight );
1650      }
1651#endif
1652      UChar       uhNextDepth         = uiDepth+1;
1653      TComDataCU* pcSubBestPartCU     = m_ppcBestCU[uhNextDepth];
1654      TComDataCU* pcSubTempPartCU     = m_ppcTempCU[uhNextDepth];
1655
1656      for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
1657      {
1658        pcSubBestPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP );           // clear sub partition datas or init.
1659        pcSubTempPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP );           // clear sub partition datas or init.
1660
1661        Bool bInSlice = pcSubBestPartCU->getSCUAddr()+pcSubBestPartCU->getTotalNumPart()>pcSlice->getEntropySliceCurStartCUAddr()&&pcSubBestPartCU->getSCUAddr()<pcSlice->getEntropySliceCurEndCUAddr();
1662        if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
1663        {
1664          if( m_bUseSBACRD )
1665          {
1666            if ( 0 == uiPartUnitIdx) //initialize RD with previous depth buffer
1667            {
1668              m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
1669            }
1670            else
1671            {
1672              m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
1673            }
1674          }
1675
1676#if AMP_ENC_SPEEDUP
1677          if ( rpcBestCU->isIntra(0) )
1678          {
1679            xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth, SIZE_NONE );
1680          }
1681          else
1682          {
1683            xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth, rpcBestCU->getPartitionSize(0) );
1684          }
1685#else
1686          xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth );
1687#endif
1688
1689          rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );         // Keep best part data to current temporary data.
1690          xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
1691
1692#if HHI_VSO
1693#if HHI_VSO_SET_OPTIM
1694#else
1695          if( m_pcRdCost->getUseRenModel() ) // necessary ??
1696          {
1697            UInt  uiWidth     = m_ppcRecoYuvBest[uhNextDepth]->getWidth   (  );
1698            UInt  uiHeight    = m_ppcRecoYuvBest[uhNextDepth]->getHeight  (   );
1699            Pel*  piSrc       = m_ppcRecoYuvBest[uhNextDepth]->getLumaAddr( 0 );
1700            UInt  uiSrcStride = m_ppcRecoYuvBest[uhNextDepth]->getStride  (   );
1701            m_pcRdCost->setRenModelData( pcSubBestPartCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
1702          }
1703#endif
1704#endif
1705        }
1706        else if (bInSlice)
1707        {
1708          pcSubBestPartCU->copyToPic( uhNextDepth );
1709          rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );
1710        }
1711      }
1712
1713      if( !bBoundary )
1714      {
1715        m_pcEntropyCoder->resetBits();
1716        m_pcEntropyCoder->encodeSplitFlag( rpcTempCU, 0, uiDepth, true );
1717
1718        rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
1719        if(m_pcEncCfg->getUseSBACRD())
1720        {
1721          rpcTempCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
1722        }
1723      }
1724#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
1725      if( bFullyRenderedSec )
1726      {
1727        m_pcRdCost->setLambdaScale( m_pcEncCfg->getInterViewSkipLambdaScale() );
1728      }
1729      else
1730      {
1731        m_pcRdCost->setLambdaScale( 1 );
1732      }
1733#endif
1734
1735#if HHI_VSO
1736      if ( m_pcRdCost->getUseVSO() )
1737      {
1738        rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
1739      }
1740      else
1741#endif
1742      {           
1743        rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
1744      }
1745
1746      if( (g_uiMaxCUWidth>>uiDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() && rpcTempCU->getSlice()->getPPS()->getUseDQP())
1747      {
1748        Bool bHasRedisual = false;
1749        for( UInt uiBlkIdx = 0; uiBlkIdx < rpcTempCU->getTotalNumPart(); uiBlkIdx ++)
1750        {
1751          if( ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(uiBlkIdx+rpcTempCU->getZorderIdxInCU()) == rpcTempCU->getSlice()->getEntropySliceCurStartCUAddr() ) && 
1752            ( rpcTempCU->getCbf( uiBlkIdx, TEXT_LUMA ) || rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_U ) || rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_V ) ) )
1753          {
1754            bHasRedisual = true;
1755            break;
1756          }
1757        }
1758
1759        UInt uiTargetPartIdx;
1760        if ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) != pcSlice->getEntropySliceCurStartCUAddr() )
1761        {
1762          uiTargetPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
1763        }
1764        else
1765        {
1766          uiTargetPartIdx = 0;
1767        }
1768        if ( bHasRedisual )
1769        {
1770#if !RDO_WITHOUT_DQP_BITS
1771          m_pcEntropyCoder->resetBits();
1772          m_pcEntropyCoder->encodeQP( rpcTempCU, uiTargetPartIdx, false );
1773          rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
1774          if(m_pcEncCfg->getUseSBACRD())
1775          {
1776            rpcTempCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
1777          }
1778#if HHI_VSO
1779          if ( m_pcRdCost->getUseLambdaScaleVSO())
1780          {
1781            rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
1782          }
1783          else
1784#endif
1785          {
1786            rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
1787          }
1788#endif
1789        }
1790        else
1791        {
1792#if LOSSLESS_CODING
1793          if (((rpcTempCU->getQP(uiTargetPartIdx) != rpcTempCU->getRefQP(uiTargetPartIdx)) ) && (rpcTempCU->getSlice()->getSPS()->getUseLossless()))
1794          {
1795            rpcTempCU->getTotalCost() = MAX_DOUBLE;
1796          }
1797#endif
1798          rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( uiTargetPartIdx ), 0, uiDepth ); // set QP to default QP
1799        }
1800      }
1801
1802      if( m_bUseSBACRD )
1803      {
1804        m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
1805      }
1806      Bool bEntropyLimit=false;
1807      Bool bSliceLimit=false;
1808      bSliceLimit=rpcBestCU->getSlice()->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE&&(rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getSliceArgument()<<3);
1809      if(rpcBestCU->getSlice()->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&m_pcEncCfg->getUseSBACRD())
1810      {
1811        if(rpcBestCU->getTotalBins()>rpcBestCU->getSlice()->getEntropySliceArgument())
1812        {
1813          bEntropyLimit=true;
1814        }
1815      }
1816      else if(rpcBestCU->getSlice()->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE)
1817      {
1818        if(rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getEntropySliceArgument())
1819        {
1820          bEntropyLimit=true;
1821        }
1822      }
1823      if(rpcBestCU->getDepth(0)>=rpcBestCU->getSlice()->getPPS()->getSliceGranularity())
1824      {
1825        bSliceLimit=false;
1826        bEntropyLimit=false;
1827      }
1828      if(bSliceLimit||bEntropyLimit)
1829      {
1830        rpcBestCU->getTotalCost()=rpcTempCU->getTotalCost()+1;
1831      }
1832      xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth);                                  // RD compare current larger prediction
1833    }                                                                                  // with sub partitioned prediction.
1834#if LOSSLESS_CODING
1835    if (isAddLowestQP && (iQP == lowestQP))
1836    {
1837      iQP = iMinQP;
1838    }
1839#endif
1840  } // SPLIT- QP Loop
1841
1842#if HHI_VSO
1843  if( m_pcRdCost->getUseRenModel() )
1844  {
1845    UInt  uiWidth     = m_ppcRecoYuvBest[uiDepth]->getWidth   ( );
1846    UInt  uiHeight    = m_ppcRecoYuvBest[uiDepth]->getHeight  ( );
1847    Pel*  piSrc       = m_ppcRecoYuvBest[uiDepth]->getLumaAddr( 0 );
1848    UInt  uiSrcStride = m_ppcRecoYuvBest[uiDepth]->getStride  ( );
1849    m_pcRdCost->setRenModelData( rpcBestCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
1850  }
1851#endif
1852
1853  rpcBestCU->copyToPic(uiDepth);                                                     // Copy Best data to Picture for next partition prediction.
1854
1855  xCopyYuv2Pic( rpcBestCU->getPic(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU(), uiDepth, uiDepth, rpcBestCU, uiLPelX, uiTPelY );   // Copy Yuv data to picture Yuv
1856  if( bBoundary ||(bSliceEnd && bInsidePicture))
1857  {
1858    return;
1859  }
1860
1861  // Assert if Best prediction mode is NONE
1862  // Selected mode's RD-cost must be not MAX_DOUBLE.
1863  assert( rpcBestCU->getPartitionSize ( 0 ) != SIZE_NONE  );
1864  assert( rpcBestCU->getPredictionMode( 0 ) != MODE_NONE  );
1865  assert( rpcBestCU->getTotalCost     (   ) != MAX_DOUBLE );
1866}
1867
1868/** finish encoding a cu and handle end-of-slice conditions
1869 * \param pcCU
1870 * \param uiAbsPartIdx
1871 * \param uiDepth
1872 * \returns Void
1873 */
1874Void TEncCu::finishCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1875{
1876  TComPic* pcPic = pcCU->getPic();
1877  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
1878
1879  //Calculate end address
1880  UInt uiCUAddr = pcCU->getSCUAddr()+uiAbsPartIdx;
1881
1882  UInt uiInternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurEndCUAddr()-1) % pcPic->getNumPartInCU();
1883  UInt uiExternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurEndCUAddr()-1) / pcPic->getNumPartInCU();
1884  UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1885  UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1886  UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
1887  UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
1888  while(uiPosX>=uiWidth||uiPosY>=uiHeight)
1889  {
1890    uiInternalAddress--;
1891    uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1892    uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1893  }
1894  uiInternalAddress++;
1895  if(uiInternalAddress==pcCU->getPic()->getNumPartInCU())
1896  {
1897    uiInternalAddress = 0;
1898    uiExternalAddress = pcPic->getPicSym()->getCUOrderMap(pcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
1899  }
1900  UInt uiRealEndAddress = pcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress);
1901
1902  // Encode slice finish
1903  Bool bTerminateSlice = false;
1904  if (uiCUAddr+(pcCU->getPic()->getNumPartInCU()>>(uiDepth<<1)) == uiRealEndAddress)
1905  {
1906    bTerminateSlice = true;
1907  }
1908  UInt uiGranularityWidth = g_uiMaxCUWidth>>(pcSlice->getPPS()->getSliceGranularity());
1909  uiPosX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
1910  uiPosY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
1911  Bool granularityBoundary=((uiPosX+pcCU->getWidth(uiAbsPartIdx))%uiGranularityWidth==0||(uiPosX+pcCU->getWidth(uiAbsPartIdx)==uiWidth))
1912    &&((uiPosY+pcCU->getHeight(uiAbsPartIdx))%uiGranularityWidth==0||(uiPosY+pcCU->getHeight(uiAbsPartIdx)==uiHeight));
1913 
1914#if BURST_IPCM
1915  if(granularityBoundary && (!(pcCU->getIPCMFlag(uiAbsPartIdx) && ( pcCU->getNumSucIPCM() > 1 ))))
1916#else
1917  if(granularityBoundary)
1918#endif
1919  {
1920    // The 1-terminating bit is added to all streams, so don't add it here when it's 1.
1921    if (!bTerminateSlice)
1922      m_pcEntropyCoder->encodeTerminatingBit( bTerminateSlice ? 1 : 0 );
1923  }
1924 
1925  Int numberOfWrittenBits = 0;
1926  if (m_pcBitCounter)
1927  {
1928    numberOfWrittenBits = m_pcEntropyCoder->getNumberOfWrittenBits();
1929  }
1930 
1931  // Calculate slice end IF this CU puts us over slice bit size.
1932  unsigned iGranularitySize = pcCU->getPic()->getNumPartInCU()>>(pcSlice->getPPS()->getSliceGranularity()<<1);
1933  int iGranularityEnd = ((pcCU->getSCUAddr()+uiAbsPartIdx)/iGranularitySize)*iGranularitySize;
1934  if(iGranularityEnd<=pcSlice->getEntropySliceCurStartCUAddr()) 
1935  {
1936    iGranularityEnd+=max(iGranularitySize,(pcCU->getPic()->getNumPartInCU()>>(uiDepth<<1)));
1937  }
1938  // Set slice end parameter
1939  if(pcSlice->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE&&!pcSlice->getFinalized()&&pcSlice->getSliceBits()+numberOfWrittenBits>pcSlice->getSliceArgument()<<3) 
1940  {
1941    pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
1942    pcSlice->setSliceCurEndCUAddr(iGranularityEnd);
1943    return;
1944  }
1945  // Set entropy slice end parameter
1946  if(m_pcEncCfg->getUseSBACRD()) 
1947  {
1948    TEncBinCABAC *pppcRDSbacCoder = (TEncBinCABAC *) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
1949    UInt uiBinsCoded = pppcRDSbacCoder->getBinsCoded();
1950    if(pcSlice->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&!pcSlice->getFinalized()&&pcSlice->getEntropySliceCounter()+uiBinsCoded>pcSlice->getEntropySliceArgument())
1951    {
1952      pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
1953      return;
1954    }
1955  }
1956  else
1957  {
1958    if(pcSlice->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&!pcSlice->getFinalized()&&pcSlice->getEntropySliceCounter()+numberOfWrittenBits>pcSlice->getEntropySliceArgument()) 
1959    {
1960      pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
1961      return;
1962    }
1963  }
1964  if(granularityBoundary)
1965  {
1966    pcSlice->setSliceBits( (UInt)(pcSlice->getSliceBits() + numberOfWrittenBits) );
1967    if(m_pcEncCfg->getUseSBACRD()) 
1968    {
1969      TEncBinCABAC *pppcRDSbacCoder = (TEncBinCABAC *) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
1970      pcSlice->setEntropySliceCounter(pcSlice->getEntropySliceCounter()+pppcRDSbacCoder->getBinsCoded());
1971      pppcRDSbacCoder->setBinsCoded( 0 );
1972    }
1973    else 
1974    {
1975      pcSlice->setEntropySliceCounter(pcSlice->getEntropySliceCounter()+numberOfWrittenBits);
1976    }
1977    if (m_pcBitCounter)
1978    {
1979      m_pcEntropyCoder->resetBits();     
1980    }
1981  }
1982}
1983
1984/** Compute QP for each CU
1985 * \param pcCU Target CU
1986 * \param uiDepth CU depth
1987 * \returns quantization parameter
1988 */
1989Int TEncCu::xComputeQP( TComDataCU* pcCU, UInt uiDepth )
1990{
1991  Int iBaseQp = pcCU->getSlice()->getSliceQp();
1992  Int iQpOffset = 0;
1993  if ( m_pcEncCfg->getUseAdaptiveQP() )
1994  {
1995    TEncPic* pcEPic = dynamic_cast<TEncPic*>( pcCU->getPic() );
1996    UInt uiAQDepth = min( uiDepth, pcEPic->getMaxAQDepth()-1 );
1997    TEncPicQPAdaptationLayer* pcAQLayer = pcEPic->getAQLayer( uiAQDepth );
1998    UInt uiAQUPosX = pcCU->getCUPelX() / pcAQLayer->getAQPartWidth();
1999    UInt uiAQUPosY = pcCU->getCUPelY() / pcAQLayer->getAQPartHeight();
2000    UInt uiAQUStride = pcAQLayer->getAQPartStride();
2001    TEncQPAdaptationUnit* acAQU = pcAQLayer->getQPAdaptationUnit();
2002
2003    Double dMaxQScale = pow(2.0, m_pcEncCfg->getQPAdaptationRange()/6.0);
2004    Double dAvgAct = pcAQLayer->getAvgActivity();
2005    Double dCUAct = acAQU[uiAQUPosY * uiAQUStride + uiAQUPosX].getActivity();
2006    Double dNormAct = (dMaxQScale*dCUAct + dAvgAct) / (dCUAct + dMaxQScale*dAvgAct);
2007    Double dQpOffset = log(dNormAct) / log(2.0) * 6.0;
2008    iQpOffset = Int(floor( dQpOffset + 0.49999 ));
2009  }
2010#if H0736_AVC_STYLE_QP_RANGE
2011  return Clip3(-pcCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQp+iQpOffset );
2012#else
2013  return Clip3( MIN_QP, MAX_QP, iBaseQp+iQpOffset );
2014#endif
2015}
2016
2017/** encode a CU block recursively
2018 * \param pcCU
2019 * \param uiAbsPartIdx
2020 * \param uiDepth
2021 * \returns Void
2022 */
2023Void TEncCu::xEncodeCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2024{
2025  TComPic* pcPic = pcCU->getPic();
2026 
2027  Bool bBoundary = false;
2028  UInt uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
2029  UInt uiRPelX   = uiLPelX + (g_uiMaxCUWidth>>uiDepth)  - 1;
2030  UInt uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
2031  UInt uiBPelY   = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
2032 
2033#if BURST_IPCM
2034  if( getCheckBurstIPCMFlag() )
2035  {
2036    pcCU->setLastCUSucIPCMFlag( checkLastCUSucIPCM( pcCU, uiAbsPartIdx ));
2037    pcCU->setNumSucIPCM( countNumSucIPCM ( pcCU, uiAbsPartIdx ) );
2038  }
2039#endif
2040
2041  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
2042  // If slice start is within this cu...
2043  Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr() > pcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx && 
2044    pcSlice->getEntropySliceCurStartCUAddr() < pcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcPic->getNumPartInCU() >> (uiDepth<<1) );
2045  // We need to split, so don't try these modes.
2046  if(!bSliceStart&&( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2047  {
2048#if HHI_MPI
2049    if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 || uiDepth < pcCU->getTextureModeDepth( uiAbsPartIdx ) )
2050    {
2051#endif
2052
2053    m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
2054
2055#if HHI_MPI
2056    }
2057#endif
2058  }
2059  else
2060  {
2061    bBoundary = true;
2062  }
2063 
2064#if HHI_MPI
2065  if( uiDepth == pcCU->getTextureModeDepth( uiAbsPartIdx ) )
2066  {
2067    xSaveDepthWidthHeight( pcCU );
2068    pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
2069    pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
2070
2071    if( ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2072    {
2073      m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
2074    }
2075
2076    if( !pcCU->getSlice()->isIntra() )
2077    {
2078      m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
2079    }
2080
2081    if( pcCU->isSkipped( uiAbsPartIdx ) )
2082    {
2083      m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
2084      finishCU(pcCU,uiAbsPartIdx,uiDepth);
2085      xRestoreDepthWidthHeight( pcCU );
2086      return;
2087    }
2088
2089    m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
2090
2091    m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
2092
2093    // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
2094    m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
2095    xRestoreDepthWidthHeight( pcCU );
2096  }
2097#endif
2098
2099  if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < (g_uiMaxCUDepth-g_uiAddCUDepth) ) ) || bBoundary )
2100  {
2101    UInt uiQNumParts = ( pcPic->getNumPartInCU() >> (uiDepth<<1) )>>2;
2102    if( (g_uiMaxCUWidth>>uiDepth) == pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
2103    {
2104      setdQPFlag(true);
2105    }
2106#if BURST_IPCM
2107    pcCU->setNumSucIPCM(0);
2108    pcCU->setLastCUSucIPCMFlag(false);
2109#endif
2110    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
2111    {
2112      uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
2113      uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
2114      Bool bInSlice = pcCU->getSCUAddr()+uiAbsPartIdx+uiQNumParts>pcSlice->getEntropySliceCurStartCUAddr()&&pcCU->getSCUAddr()+uiAbsPartIdx<pcSlice->getEntropySliceCurEndCUAddr();
2115      if(bInSlice&&( uiLPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2116      {
2117        xEncodeCU( pcCU, uiAbsPartIdx, uiDepth+1 );
2118      }
2119    }
2120    return;
2121  }
2122 
2123  if( (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
2124  {
2125    setdQPFlag(true);
2126  }
2127#if HHI_MPI
2128  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
2129{
2130#endif
2131  if( !pcCU->getSlice()->isIntra() )
2132  {
2133    m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
2134  }
2135#if HHI_MPI
2136}
2137#endif
2138 
2139  if( pcCU->isSkipped( uiAbsPartIdx ) )
2140  {
2141#if OL_DEPTHLIMIT_A0044
2142    if(pcCU->getPartDumpFlag())
2143    {
2144      pcCU->updatePartInfo(0,uiDepth);
2145      pcCU->incrementPartInfo();
2146    }
2147#endif
2148    m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
2149#if LGE_ILLUCOMP_B0045
2150    m_pcEntropyCoder->encodeICFlag  ( pcCU, uiAbsPartIdx );
2151#endif
2152#if HHI_INTER_VIEW_RESIDUAL_PRED
2153    m_pcEntropyCoder->encodeResPredFlag( pcCU, uiAbsPartIdx, 0 );
2154#endif
2155    finishCU(pcCU,uiAbsPartIdx,uiDepth);
2156    return;
2157  }
2158#if HHI_MPI
2159  if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
2160  {
2161#endif
2162  m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
2163 
2164  m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
2165 
2166  if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
2167  {
2168    m_pcEntropyCoder->encodeIPCMInfo( pcCU, uiAbsPartIdx );
2169
2170    if(pcCU->getIPCMFlag(uiAbsPartIdx))
2171    {
2172      // Encode slice finish
2173      finishCU(pcCU,uiAbsPartIdx,uiDepth);
2174      return;
2175    }
2176  }
2177
2178  // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
2179  m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
2180#if LGE_ILLUCOMP_B0045
2181    m_pcEntropyCoder->encodeICFlag  ( pcCU, uiAbsPartIdx );
2182#endif
2183#if HHI_INTER_VIEW_RESIDUAL_PRED
2184    if( !pcCU->isIntra( uiAbsPartIdx ) )
2185    {
2186      m_pcEntropyCoder->encodeResPredFlag( pcCU, uiAbsPartIdx, 0 );
2187    }
2188#endif
2189#if HHI_MPI
2190  }
2191#endif
2192 
2193  // Encode Coefficients
2194  Bool bCodeDQP = getdQPFlag();
2195  m_pcEntropyCoder->encodeCoeff( pcCU, uiAbsPartIdx, uiDepth, pcCU->getWidth (uiAbsPartIdx), pcCU->getHeight(uiAbsPartIdx), bCodeDQP );
2196  setdQPFlag( bCodeDQP );
2197
2198  // --- write terminating bit ---
2199  finishCU(pcCU,uiAbsPartIdx,uiDepth);
2200}
2201
2202/** check RD costs for a CU block encoded with merge
2203 * \param rpcBestCU
2204 * \param rpcTempCU
2205 * \returns Void
2206 */
2207#if HHI_INTERVIEW_SKIP
2208Void TEncCu::xCheckRDCostMerge2Nx2N( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, Bool bSkipRes )
2209#else
2210Void TEncCu::xCheckRDCostMerge2Nx2N( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU )
2211#endif
2212{
2213  assert( rpcTempCU->getSlice()->getSliceType() != I_SLICE );
2214#if HHI_INTER_VIEW_MOTION_PRED
2215  TComMvField  cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
2216  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
2217#else
2218  TComMvField  cMvFieldNeighbours[MRG_MAX_NUM_CANDS << 1]; // double length for mv of both lists
2219  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
2220#endif
2221  Int numValidMergeCand = 0;
2222
2223#if HHI_INTER_VIEW_RESIDUAL_PRED
2224  Bool  bResPrdAvail  = rpcTempCU->getResPredAvail( 0 );
2225  Bool  bResPrdFlag   = rpcTempCU->getResPredFlag ( 0 );
2226#endif
2227#if LGE_ILLUCOMP_B0045
2228  Bool  bICFlag = rpcTempCU->getICFlag(0);
2229#endif
2230
2231#if HHI_INTER_VIEW_MOTION_PRED
2232  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS_MEM; ++ui )
2233#else
2234  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ++ui )
2235#endif
2236  {
2237    uhInterDirNeighbours[ui] = 0;
2238  }
2239  UChar uhDepth = rpcTempCU->getDepth( 0 );
2240
2241#if HHI_VSO
2242  if( m_pcRdCost->getUseRenModel() )
2243  {
2244    UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth ( );
2245    UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight( );
2246    Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
2247    UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
2248    m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2249  }
2250#endif
2251
2252  rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
2253  rpcTempCU->getInterMergeCandidates( 0, 0, uhDepth, cMvFieldNeighbours,uhInterDirNeighbours, numValidMergeCand );
2254
2255#if FAST_DECISION_FOR_MRG_RD_COST
2256  Bool bestIsSkip = false;
2257#endif
2258 
2259  for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
2260  {
2261    {
2262      TComYuv* pcPredYuvTemp = NULL;
2263#if LOSSLESS_CODING
2264      UInt iteration;
2265      if ( rpcTempCU->isLosslessCoded(0))
2266      {
2267        iteration = 1;
2268      }
2269      else 
2270      {
2271        iteration = 2;
2272      }
2273
2274#if HHI_INTERVIEW_SKIP
2275    for( UInt uiNoResidual = (bSkipRes ? 1:0); uiNoResidual < iteration; ++uiNoResidual )
2276#else
2277      for( UInt uiNoResidual = 0; uiNoResidual < iteration; ++uiNoResidual )
2278#endif
2279#else
2280#if HHI_INTERVIEW_SKIP
2281    for( UInt uiNoResidual = (bSkipRes ? 1:0); uiNoResidual < 2; ++uiNoResidual )
2282#else
2283      for( UInt uiNoResidual = 0; uiNoResidual < 2; ++uiNoResidual )
2284#endif
2285#endif
2286      {
2287#if FAST_DECISION_FOR_MRG_RD_COST
2288        if( !(bestIsSkip && uiNoResidual == 0) )
2289        {
2290#endif
2291          // set MC parameters
2292          rpcTempCU->setPredModeSubParts( MODE_SKIP, 0, uhDepth ); // interprets depth relative to LCU level
2293          rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
2294          rpcTempCU->setMergeFlagSubParts( true, 0, 0, uhDepth ); // interprets depth relative to LCU level
2295          rpcTempCU->setMergeIndexSubParts( uiMergeCand, 0, 0, uhDepth ); // interprets depth relative to LCU level
2296          rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
2297          rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
2298          rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
2299
2300#if HHI_INTER_VIEW_RESIDUAL_PRED
2301          rpcTempCU->setResPredAvailSubParts( bResPrdAvail, 0, 0, uhDepth );
2302          rpcTempCU->setResPredFlagSubParts ( bResPrdFlag,  0, 0, uhDepth );
2303#endif
2304#if LGE_ILLUCOMP_B0045
2305          rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uhDepth);
2306#endif
2307
2308          // do MC
2309#if HHI_INTERVIEW_SKIP
2310      if ( (uiNoResidual == 0) || bSkipRes )
2311#else
2312      if ( uiNoResidual == 0 )
2313#endif
2314        {
2315            m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
2316            // save pred adress
2317            pcPredYuvTemp = m_ppcPredYuvTemp[uhDepth];
2318
2319          }
2320          else
2321          {
2322#if FAST_DECISION_FOR_MRG_RD_COST
2323            if( bestIsSkip)
2324            {
2325              m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
2326              // save pred adress
2327              pcPredYuvTemp = m_ppcPredYuvTemp[uhDepth];
2328            }
2329            else
2330            {
2331#endif
2332              if ( pcPredYuvTemp != m_ppcPredYuvTemp[uhDepth])
2333              {
2334                //adress changes take best (old temp)
2335                pcPredYuvTemp = m_ppcPredYuvBest[uhDepth];
2336              }
2337#if FAST_DECISION_FOR_MRG_RD_COST
2338            }
2339#endif
2340          }
2341#if HHI_VSO
2342          if( m_pcRdCost->getUseRenModel() )
2343          { //Reset
2344            UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth    ();
2345            UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight   ();
2346            Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr ();
2347            UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride   ();
2348            m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2349          }
2350#endif
2351          // estimate residual and encode everything
2352          m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
2353            m_ppcOrigYuv    [uhDepth],
2354            pcPredYuvTemp,
2355            m_ppcResiYuvTemp[uhDepth],
2356            m_ppcResiYuvBest[uhDepth],
2357            m_ppcRecoYuvTemp[uhDepth],
2358#if HHI_INTER_VIEW_RESIDUAL_PRED
2359                                                     m_ppcResPredTmp [uhDepth],
2360#endif
2361            (uiNoResidual? true:false) );     
2362          Bool bQtRootCbf = rpcTempCU->getQtRootCbf(0) == 1;
2363
2364#if H0736_AVC_STYLE_QP_RANGE
2365          Int orgQP = rpcTempCU->getQP( 0 );
2366          xCheckDQP( rpcTempCU );
2367          xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
2368          rpcTempCU->initEstData( uhDepth, orgQP );
2369#else
2370          UInt uiOrgQP = rpcTempCU->getQP( 0 );
2371          xCheckDQP( rpcTempCU );
2372          xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
2373          rpcTempCU->initEstData( uhDepth, uiOrgQP );
2374#endif
2375
2376#if FAST_DECISION_FOR_MRG_RD_COST
2377          if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
2378          {
2379            bestIsSkip = rpcBestCU->getQtRootCbf(0) == 0;
2380          }
2381#endif
2382
2383          if (!bQtRootCbf)
2384            break;
2385#if FAST_DECISION_FOR_MRG_RD_COST
2386        }
2387#endif
2388      }
2389    }
2390  }
2391}
2392
2393#if AMP_MRG
2394#if HHI_INTERVIEW_SKIP
2395Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bSkipRes, Bool bUseMRG)
2396#else
2397Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bUseMRG)
2398#endif
2399#else
2400#if HHI_INTERVIEW_SKIP
2401Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize, Bool bSkipRes)
2402#else
2403Void TEncCu::xCheckRDCostInter( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize ePartSize )
2404#endif
2405#endif
2406{
2407  UChar uhDepth = rpcTempCU->getDepth( 0 );
2408 
2409#if HHI_VSO
2410  if( m_pcRdCost->getUseRenModel() )
2411  {
2412    UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth ( );
2413    UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight( );
2414    Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
2415    UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
2416    m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2417  }
2418#endif 
2419
2420  rpcTempCU->setDepthSubParts( uhDepth, 0 );
2421 
2422#if HHI_INTER_VIEW_RESIDUAL_PRED
2423  Bool  bResPrdAvail  = rpcTempCU->getResPredAvail( 0 );
2424  Bool  bResPrdFlag   = rpcTempCU->getResPredFlag ( 0 );
2425#endif
2426 
2427  rpcTempCU->setPartSizeSubParts  ( ePartSize,  0, uhDepth );
2428#if HHI_INTER_VIEW_RESIDUAL_PRED
2429  rpcTempCU->setResPredAvailSubParts( bResPrdAvail, 0, 0, uhDepth );
2430  rpcTempCU->setResPredFlagSubParts ( bResPrdFlag,  0, 0, uhDepth );
2431#endif
2432  rpcTempCU->setPredModeSubParts  ( MODE_INTER, 0, uhDepth );
2433 
2434#if HHI_INTER_VIEW_RESIDUAL_PRED
2435#if !LG_RESTRICTEDRESPRED_M24766
2436  if( rpcTempCU->getResPredFlag( 0 ) )
2437  { // subtract residual prediction from original in motion search
2438    m_ppcOrigYuv[uhDepth]->add( m_ppcResPredTmp [uhDepth], rpcTempCU->getWidth( 0 ), rpcTempCU->getHeight( 0 ), true );
2439  }
2440#endif
2441#endif
2442
2443#if AMP_MRG
2444  rpcTempCU->setMergeAMP (true);
2445  #if HHI_INTERVIEW_SKIP
2446#if LG_RESTRICTEDRESPRED_M24766
2447  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcResPredTmp[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes, bUseMRG  );
2448#else
2449  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes, bUseMRG  );
2450#endif
2451#else
2452  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], false, bUseMRG );
2453#endif
2454#else
2455  #if HHI_INTERVIEW_SKIP
2456  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes );
2457#else 
2458  m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth] );
2459#endif
2460#endif
2461
2462#if HHI_INTER_VIEW_RESIDUAL_PRED
2463#if !LG_RESTRICTEDRESPRED_M24766
2464  if( rpcTempCU->getResPredFlag( 0 ) )
2465  { // add residual prediction to original again
2466    m_ppcOrigYuv[uhDepth]->add( m_ppcResPredTmp [uhDepth], rpcTempCU->getWidth( 0 ), rpcTempCU->getHeight( 0 ) );
2467  }
2468#endif
2469#endif
2470
2471#if AMP_MRG
2472  if ( !rpcTempCU->getMergeAMP() )
2473  {
2474    return;
2475  }
2476#endif
2477
2478#if HHI_INTERVIEW_SKIP
2479  m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
2480                                             m_ppcOrigYuv[uhDepth],
2481                                             m_ppcPredYuvTemp[uhDepth],
2482                                             m_ppcResiYuvTemp[uhDepth],
2483                                             m_ppcResiYuvBest[uhDepth],
2484                                             m_ppcRecoYuvTemp[uhDepth],
2485#if HHI_INTER_VIEW_RESIDUAL_PRED
2486                                             m_ppcResPredTmp [uhDepth],
2487#endif
2488                                             bSkipRes );
2489#else
2490  m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
2491                                             m_ppcOrigYuv[uhDepth],
2492                                             m_ppcPredYuvTemp[uhDepth],
2493                                             m_ppcResiYuvTemp[uhDepth],
2494                                             m_ppcResiYuvBest[uhDepth],
2495                                             m_ppcRecoYuvTemp[uhDepth],
2496#if HHI_INTER_VIEW_RESIDUAL_PRED
2497                                             m_ppcResPredTmp [uhDepth],
2498#endif
2499                                             false );
2500#endif
2501#if HHI_VSO
2502  if( m_pcRdCost->getUseLambdaScaleVSO() )
2503  {
2504    rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2505  }
2506  else
2507#endif
2508  {
2509  rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2510  }
2511
2512  xCheckDQP( rpcTempCU );
2513  xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
2514}
2515
2516Void TEncCu::xCheckRDCostIntra( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, PartSize eSize )
2517{
2518  UInt uiDepth = rpcTempCU->getDepth( 0 );
2519 
2520#if HHI_VSO
2521  if( m_pcRdCost->getUseRenModel() )
2522  {
2523    UInt  uiWidth     = m_ppcOrigYuv[uiDepth]->getWidth   ();
2524    UInt  uiHeight    = m_ppcOrigYuv[uiDepth]->getHeight  ();
2525    Pel*  piSrc       = m_ppcOrigYuv[uiDepth]->getLumaAddr();
2526    UInt  uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride  ();
2527    m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2528  }
2529#endif
2530
2531  rpcTempCU->setPartSizeSubParts( eSize, 0, uiDepth );
2532  rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
2533 
2534  Bool bSeparateLumaChroma = true; // choose estimation mode
2535  Dist uiPreCalcDistC      = 0;
2536  if( !bSeparateLumaChroma )
2537  {
2538    m_pcPredSearch->preestChromaPredMode( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth] );
2539  }
2540  m_pcPredSearch  ->estIntraPredQT      ( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC, bSeparateLumaChroma );
2541
2542  m_ppcRecoYuvTemp[uiDepth]->copyToPicLuma(rpcTempCU->getPic()->getPicYuvRec(), rpcTempCU->getAddr(), rpcTempCU->getZorderIdxInCU() );
2543 
2544#if RWTH_SDC_DLT_B0036
2545  if( !rpcTempCU->getSDCFlag( 0 ) )
2546#endif
2547  m_pcPredSearch  ->estIntraPredChromaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC );
2548 
2549  m_pcEntropyCoder->resetBits();
2550  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
2551  m_pcEntropyCoder->encodePredMode( rpcTempCU, 0,          true );
2552  m_pcEntropyCoder->encodePartSize( rpcTempCU, 0, uiDepth, true );
2553  m_pcEntropyCoder->encodePredInfo( rpcTempCU, 0,          true );
2554  m_pcEntropyCoder->encodeIPCMInfo(rpcTempCU, 0, true );
2555
2556  // Encode Coefficients
2557  Bool bCodeDQP = getdQPFlag();
2558  m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0), bCodeDQP );
2559  setdQPFlag( bCodeDQP );
2560 
2561  if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
2562 
2563  rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
2564  if(m_pcEncCfg->getUseSBACRD())
2565  {
2566    rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
2567  }
2568#if HHI_VSO
2569  if( m_pcRdCost->getUseLambdaScaleVSO())
2570  {
2571    rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2572  }
2573  else
2574#endif
2575  {
2576  rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2577  }
2578 
2579  xCheckDQP( rpcTempCU );
2580  xCheckBestMode(rpcBestCU, rpcTempCU, uiDepth);
2581}
2582
2583/** Check R-D costs for a CU with PCM mode.
2584 * \param rpcBestCU pointer to best mode CU data structure
2585 * \param rpcTempCU pointer to testing mode CU data structure
2586 * \returns Void
2587 *
2588 * \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.
2589 */
2590Void TEncCu::xCheckIntraPCM( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU )
2591{
2592  UInt uiDepth = rpcTempCU->getDepth( 0 );
2593
2594  rpcTempCU->setIPCMFlag(0, true);
2595  rpcTempCU->setIPCMFlagSubParts (true, 0, rpcTempCU->getDepth(0));
2596  rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
2597  rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
2598
2599  m_pcPredSearch->IPCMSearch( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth]);
2600
2601  if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
2602
2603  m_pcEntropyCoder->resetBits();
2604  m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0,          true );
2605  m_pcEntropyCoder->encodePredMode ( rpcTempCU, 0,          true );
2606  m_pcEntropyCoder->encodePartSize ( rpcTempCU, 0, uiDepth, true );
2607  m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
2608
2609  if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
2610
2611  rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
2612  if(m_pcEncCfg->getUseSBACRD())
2613  {
2614    rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
2615  }
2616#if HHI_VSO
2617  if ( m_pcRdCost->getUseVSO() )
2618  {
2619    rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2620  }
2621  else
2622#endif
2623  { 
2624  rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2625  }
2626
2627  xCheckDQP( rpcTempCU );
2628  xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth );
2629}
2630
2631// check whether current try is the best
2632Void TEncCu::xCheckBestMode( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU )
2633{
2634  if( rpcTempCU->getTotalCost() < rpcBestCU->getTotalCost() )
2635  {
2636    TComYuv* pcYuv;
2637    UChar uhDepth = rpcBestCU->getDepth(0);
2638
2639    // Change Information data
2640    TComDataCU* pcCU = rpcBestCU;
2641    rpcBestCU = rpcTempCU;
2642    rpcTempCU = pcCU;
2643   
2644    // Change Prediction data
2645    pcYuv = m_ppcPredYuvBest[uhDepth];
2646    m_ppcPredYuvBest[uhDepth] = m_ppcPredYuvTemp[uhDepth];
2647    m_ppcPredYuvTemp[uhDepth] = pcYuv;
2648   
2649    // Change Reconstruction data
2650    pcYuv = m_ppcRecoYuvBest[uhDepth];
2651    m_ppcRecoYuvBest[uhDepth] = m_ppcRecoYuvTemp[uhDepth];
2652    m_ppcRecoYuvTemp[uhDepth] = pcYuv;
2653   
2654    pcYuv = NULL;
2655    pcCU  = NULL;
2656   
2657    if( m_bUseSBACRD )  // store temp best CI for next CU coding
2658      m_pppcRDSbacCoder[uhDepth][CI_TEMP_BEST]->store(m_pppcRDSbacCoder[uhDepth][CI_NEXT_BEST]);
2659  }
2660}
2661
2662/** check whether current try is the best with identifying the depth of current try
2663 * \param rpcBestCU
2664 * \param rpcTempCU
2665 * \returns Void
2666 */
2667Void TEncCu::xCheckBestMode( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, UInt uiDepth )
2668{
2669  if( rpcTempCU->getTotalCost() < rpcBestCU->getTotalCost() )
2670  {
2671    TComYuv* pcYuv;
2672    // Change Information data
2673    TComDataCU* pcCU = rpcBestCU;
2674    rpcBestCU = rpcTempCU;
2675    rpcTempCU = pcCU;
2676
2677    // Change Prediction data
2678    pcYuv = m_ppcPredYuvBest[uiDepth];
2679    m_ppcPredYuvBest[uiDepth] = m_ppcPredYuvTemp[uiDepth];
2680    m_ppcPredYuvTemp[uiDepth] = pcYuv;
2681
2682    // Change Reconstruction data
2683    pcYuv = m_ppcRecoYuvBest[uiDepth];
2684    m_ppcRecoYuvBest[uiDepth] = m_ppcRecoYuvTemp[uiDepth];
2685    m_ppcRecoYuvTemp[uiDepth] = pcYuv;
2686
2687    pcYuv = NULL;
2688    pcCU  = NULL;
2689
2690    if( m_bUseSBACRD )  // store temp best CI for next CU coding
2691      m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_NEXT_BEST]);
2692  }
2693}
2694
2695Void TEncCu::xCheckDQP( TComDataCU* pcCU )
2696{
2697  UInt uiDepth = pcCU->getDepth( 0 );
2698
2699  if( pcCU->getSlice()->getPPS()->getUseDQP() && (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() )
2700  {
2701    if ( pcCU->getCbf( 0, TEXT_LUMA, 0 ) || pcCU->getCbf( 0, TEXT_CHROMA_U, 0 ) || pcCU->getCbf( 0, TEXT_CHROMA_V, 0 ) )
2702    {
2703#if !RDO_WITHOUT_DQP_BITS
2704      m_pcEntropyCoder->resetBits();
2705      m_pcEntropyCoder->encodeQP( pcCU, 0, false );
2706      pcCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
2707      if(m_pcEncCfg->getUseSBACRD())
2708      {
2709        pcCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
2710      }
2711
2712      // GT: Change here??
2713#if HHI_VSO
2714      if ( m_pcRdCost->getUseVSO() )
2715      {
2716        pcCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
2717      }
2718      else
2719#endif
2720      {
2721      pcCU->getTotalCost() = m_pcRdCost->calcRdCost( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
2722      }   
2723#endif
2724    }
2725    else
2726    {
2727#if LOSSLESS_CODING
2728      if ((  ( pcCU->getRefQP( 0 ) != pcCU->getQP( 0 )) ) && (pcCU->getSlice()->getSPS()->getUseLossless()))
2729      {
2730        pcCU->getTotalCost() = MAX_DOUBLE;
2731      }
2732#endif
2733      pcCU->setQPSubParts( pcCU->getRefQP( 0 ), 0, uiDepth ); // set QP to default QP
2734    }
2735  }
2736}
2737
2738#if BURST_IPCM
2739/** Check whether the last CU shares the same root as the current CU and is IPCM or not. 
2740 * \param pcCU
2741 * \param uiCurAbsPartIdx
2742 * \returns Bool
2743 */
2744Bool TEncCu::checkLastCUSucIPCM( TComDataCU* pcCU, UInt uiCurAbsPartIdx )
2745{
2746  Bool lastCUSucIPCMFlag = false;
2747
2748  UInt curDepth = pcCU->getDepth(uiCurAbsPartIdx);
2749  UInt shift = ((pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx())->getSPS()->getMaxCUDepth() - curDepth)<<1);
2750  UInt startPartUnitIdx = ((uiCurAbsPartIdx&(0x03<<shift))>>shift);
2751
2752  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
2753  if( pcSlice->getEntropySliceCurStartCUAddr() == ( pcCU->getSCUAddr() + uiCurAbsPartIdx ) )
2754  {
2755    return false;
2756  }
2757
2758  if(curDepth > 0 && startPartUnitIdx > 0)
2759  {
2760    Int lastValidPartIdx = pcCU->getLastValidPartIdx((Int) uiCurAbsPartIdx );
2761
2762    if( lastValidPartIdx >= 0 )
2763    {
2764      if(( pcCU->getSliceStartCU( uiCurAbsPartIdx ) == pcCU->getSliceStartCU( (UInt) lastValidPartIdx ))
2765        && 
2766        ( pcCU->getDepth( uiCurAbsPartIdx ) == pcCU->getDepth( (UInt) lastValidPartIdx )) 
2767        && 
2768        pcCU->getIPCMFlag( (UInt) lastValidPartIdx ) )
2769      {
2770        lastCUSucIPCMFlag = true;
2771      }
2772    }
2773  }
2774
2775  return  lastCUSucIPCMFlag;
2776}
2777
2778/** Count the number of successive IPCM CUs sharing the same root.
2779 * \param pcCU
2780 * \param uiCurAbsPartIdx
2781 * \returns Int
2782 */
2783Int TEncCu::countNumSucIPCM ( TComDataCU* pcCU, UInt uiCurAbsPartIdx )
2784{
2785  Int numSucIPCM = 0;
2786  UInt CurDepth = pcCU->getDepth(uiCurAbsPartIdx);
2787
2788  if( pcCU->getIPCMFlag(uiCurAbsPartIdx) )
2789  {
2790    if(CurDepth == 0)
2791    {
2792       numSucIPCM = 1;
2793    }
2794    else 
2795    {
2796      TComPic* pcPic = pcCU->getPic();
2797      TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
2798      UInt qNumParts = ( pcPic->getNumPartInCU() >> ((CurDepth-1)<<1) )>>2;
2799
2800      Bool continueFlag = true;
2801      UInt absPartIdx = uiCurAbsPartIdx;
2802      UInt shift = ((pcSlice->getSPS()->getMaxCUDepth() - CurDepth)<<1);
2803      UInt startPartUnitIdx = ((uiCurAbsPartIdx&(0x03<<shift))>>shift);
2804
2805      for ( UInt partUnitIdx = startPartUnitIdx; partUnitIdx < 4 && continueFlag; partUnitIdx++, absPartIdx+=qNumParts )
2806      {
2807        UInt lPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[absPartIdx] ];
2808        UInt tPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[absPartIdx] ];
2809        Bool inSliceFlag = ( pcCU->getSCUAddr()+absPartIdx+qNumParts>pcSlice->getEntropySliceCurStartCUAddr() ) && ( pcCU->getSCUAddr()+absPartIdx < pcSlice->getEntropySliceCurEndCUAddr());
2810
2811        if( inSliceFlag && ( lPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( tPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2812        {
2813          UInt uiDepth = pcCU->getDepth(absPartIdx);
2814
2815          if( ( CurDepth == uiDepth) && pcCU->getIPCMFlag( absPartIdx ) )
2816          {
2817            numSucIPCM++;
2818          }
2819          else
2820          {
2821            continueFlag = false;
2822          }
2823        }
2824      }
2825    }
2826  }
2827
2828  return numSucIPCM;
2829}
2830#endif
2831
2832Void TEncCu::xCopyAMVPInfo (AMVPInfo* pSrc, AMVPInfo* pDst)
2833{
2834  pDst->iN = pSrc->iN;
2835  for (Int i = 0; i < pSrc->iN; i++)
2836  {
2837    pDst->m_acMvCand[i] = pSrc->m_acMvCand[i];
2838  }
2839}
2840Void TEncCu::xCopyYuv2Pic(TComPic* rpcPic, UInt uiCUAddr, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSrcDepth, TComDataCU* pcCU, UInt uiLPelX, UInt uiTPelY )
2841{
2842  UInt uiRPelX   = uiLPelX + (g_uiMaxCUWidth>>uiDepth)  - 1;
2843  UInt uiBPelY   = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
2844  TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
2845  Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr() > rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx && 
2846    pcSlice->getEntropySliceCurStartCUAddr() < rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) );
2847  Bool bSliceEnd   = pcSlice->getEntropySliceCurEndCUAddr() > rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx && 
2848    pcSlice->getEntropySliceCurEndCUAddr() < rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) );
2849  if(!bSliceEnd && !bSliceStart && ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2850  {
2851    UInt uiAbsPartIdxInRaster = g_auiZscanToRaster[uiAbsPartIdx];
2852    UInt uiSrcBlkWidth = rpcPic->getNumPartInWidth() >> (uiSrcDepth);
2853    UInt uiBlkWidth    = rpcPic->getNumPartInWidth() >> (uiDepth);
2854    UInt uiPartIdxX = ( ( uiAbsPartIdxInRaster % rpcPic->getNumPartInWidth() ) % uiSrcBlkWidth) / uiBlkWidth;
2855    UInt uiPartIdxY = ( ( uiAbsPartIdxInRaster / rpcPic->getNumPartInWidth() ) % uiSrcBlkWidth) / uiBlkWidth;
2856    UInt uiPartIdx = uiPartIdxY * ( uiSrcBlkWidth / uiBlkWidth ) + uiPartIdxX;
2857    m_ppcRecoYuvBest[uiSrcDepth]->copyToPicYuv( rpcPic->getPicYuvRec (), uiCUAddr, uiAbsPartIdx, uiDepth - uiSrcDepth, uiPartIdx);
2858  }
2859  else
2860  {
2861    UInt uiQNumParts = ( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) )>>2;
2862
2863    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
2864    {
2865      UInt uiSubCULPelX   = uiLPelX + ( g_uiMaxCUWidth >>(uiDepth+1) )*( uiPartUnitIdx &  1 );
2866      UInt uiSubCUTPelY   = uiTPelY + ( g_uiMaxCUHeight>>(uiDepth+1) )*( uiPartUnitIdx >> 1 );
2867
2868      Bool bInSlice = rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+uiQNumParts > pcSlice->getEntropySliceCurStartCUAddr() && 
2869        rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx < pcSlice->getEntropySliceCurEndCUAddr();
2870      if(bInSlice&&( uiSubCULPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiSubCUTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2871      {
2872        xCopyYuv2Pic( rpcPic, uiCUAddr, uiAbsPartIdx, uiDepth+1, uiSrcDepth, pcCU, uiSubCULPelX, uiSubCUTPelY );   // Copy Yuv data to picture Yuv
2873      }
2874    }
2875  }
2876}
2877
2878Void TEncCu::xCopyYuv2Tmp( UInt uiPartUnitIdx, UInt uiNextDepth )
2879{
2880  UInt uiCurrDepth = uiNextDepth - 1;
2881  m_ppcRecoYuvBest[uiNextDepth]->copyToPartYuv( m_ppcRecoYuvTemp[uiCurrDepth], uiPartUnitIdx );
2882}
2883
2884#if LOSSLESS_CODING
2885/** Function for filling the PCM buffer of a CU using its original sample array
2886 * \param pcCU pointer to current CU
2887 * \param pcOrgYuv pointer to original sample array
2888 * \returns Void
2889 */
2890Void TEncCu::xFillPCMBuffer     ( TComDataCU*& pCU, TComYuv* pOrgYuv )
2891{
2892
2893  UInt   width        = pCU->getWidth(0);
2894  UInt   height       = pCU->getHeight(0);
2895
2896  Pel*   pSrcY = pOrgYuv->getLumaAddr(0, width); 
2897  Pel*   pDstY = pCU->getPCMSampleY();
2898  UInt   srcStride = pOrgYuv->getStride();
2899
2900  for(Int y = 0; y < height; y++ )
2901  {
2902    for(Int x = 0; x < width; x++ )
2903    {
2904      pDstY[x] = pSrcY[x];
2905    }
2906    pDstY += width;
2907    pSrcY += srcStride;
2908  }
2909
2910  Pel* pSrcCb       = pOrgYuv->getCbAddr();
2911  Pel* pSrcCr       = pOrgYuv->getCrAddr();;
2912
2913  Pel* pDstCb       = pCU->getPCMSampleCb();
2914  Pel* pDstCr       = pCU->getPCMSampleCr();;
2915
2916  UInt srcStrideC = pOrgYuv->getCStride();
2917  UInt heightC   = height >> 1;
2918  UInt widthC    = width  >> 1;
2919
2920  for(Int y = 0; y < heightC; y++ )
2921  {
2922    for(Int x = 0; x < widthC; x++ )
2923    {
2924      pDstCb[x] = pSrcCb[x];
2925      pDstCr[x] = pSrcCr[x];
2926    }
2927    pDstCb += widthC;
2928    pDstCr += widthC;
2929    pSrcCb += srcStrideC;
2930    pSrcCr += srcStrideC;
2931  }
2932}
2933#endif
2934
2935#if ADAPTIVE_QP_SELECTION
2936/** Collect ARL statistics from one block
2937  */
2938Int TEncCu::xTuCollectARLStats(TCoeff* rpcCoeff, Int* rpcArlCoeff, Int NumCoeffInCU, Double* cSum, UInt* numSamples )
2939{
2940  for( Int n = 0; n < NumCoeffInCU; n++ )
2941  {
2942    Int u = abs( rpcCoeff[ n ] );
2943    Int absc = rpcArlCoeff[ n ];
2944
2945    if( u != 0 )
2946    {
2947      if( u < LEVEL_RANGE )
2948      {
2949        cSum[ u ] += ( Double )absc;
2950        numSamples[ u ]++;
2951      }
2952      else 
2953      {
2954        cSum[ LEVEL_RANGE ] += ( Double )absc - ( Double )( u << ARL_C_PRECISION );
2955        numSamples[ LEVEL_RANGE ]++;
2956      }
2957    }
2958  }
2959
2960  return 0;
2961}
2962
2963/** Collect ARL statistics from one LCU
2964 * \param pcCU
2965 */
2966Void TEncCu::xLcuCollectARLStats(TComDataCU* rpcCU )
2967{
2968  Double cSum[ LEVEL_RANGE + 1 ];     //: the sum of DCT coefficients corresponding to datatype and quantization output
2969  UInt numSamples[ LEVEL_RANGE + 1 ]; //: the number of coefficients corresponding to datatype and quantization output
2970
2971  TCoeff* pCoeffY = rpcCU->getCoeffY();
2972  Int* pArlCoeffY = rpcCU->getArlCoeffY();
2973
2974  UInt uiMinCUWidth = g_uiMaxCUWidth >> g_uiMaxCUDepth;
2975  UInt uiMinNumCoeffInCU = 1 << uiMinCUWidth;
2976
2977  memset( cSum, 0, sizeof( Double )*(LEVEL_RANGE+1) );
2978  memset( numSamples, 0, sizeof( UInt )*(LEVEL_RANGE+1) );
2979
2980  // Collect stats to cSum[][] and numSamples[][]
2981  for(Int i = 0; i < rpcCU->getTotalNumPart(); i ++ )
2982  {
2983    UInt uiTrIdx = rpcCU->getTransformIdx(i);
2984
2985    if(rpcCU->getPredictionMode(i) == MODE_INTER)
2986    if( rpcCU->getCbf( i, TEXT_LUMA, uiTrIdx ) )
2987    {
2988      xTuCollectARLStats(pCoeffY, pArlCoeffY, uiMinNumCoeffInCU, cSum, numSamples);
2989    }//Note that only InterY is processed. QP rounding is based on InterY data only.
2990   
2991    pCoeffY  += uiMinNumCoeffInCU;
2992    pArlCoeffY  += uiMinNumCoeffInCU;
2993  }
2994
2995  for(Int u=1; u<LEVEL_RANGE;u++)
2996  {
2997    m_pcTrQuant->getSliceSumC()[u] += cSum[ u ] ;
2998    m_pcTrQuant->getSliceNSamples()[u] += numSamples[ u ] ;
2999  }
3000  m_pcTrQuant->getSliceSumC()[LEVEL_RANGE] += cSum[ LEVEL_RANGE ] ;
3001  m_pcTrQuant->getSliceNSamples()[LEVEL_RANGE] += numSamples[ LEVEL_RANGE ] ;
3002}
3003#endif
3004
3005#if HHI_MPI
3006Void TEncCu::xCheckRDCostMvInheritance( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, UChar uhTextureModeDepth, Bool bSkipResidual, Bool bRecursiveCall )
3007{
3008  assert( rpcTempCU->getSlice()->getIsDepth() );
3009  TComDataCU *pcTextureCU = rpcTempCU->getSlice()->getTexturePic()->getCU( rpcTempCU->getAddr() );
3010
3011  const UChar uhDepth  = rpcTempCU->getDepth( 0 );
3012  const Int   iQP      = rpcTempCU->getQP( 0 );
3013  assert( bRecursiveCall == ( uhDepth != uhTextureModeDepth ) );
3014
3015#if !MTK_UNCONSTRAINED_MVI
3016  if( uhDepth == uhTextureModeDepth )
3017  {
3018    for( UInt ui = 0; ui < rpcTempCU->getTotalNumPart(); ui++ )
3019    {
3020      if( pcTextureCU->isIntra( rpcTempCU->getZorderIdxInCU() + ui ) )
3021      {
3022        return;
3023      }
3024    }
3025  }
3026#endif
3027
3028#if HHI_VSO
3029  if( m_pcRdCost->getUseRenModel() && !bRecursiveCall)
3030  {
3031    UInt  uiWidth     = m_ppcOrigYuv[uhDepth]->getWidth   ();
3032    UInt  uiHeight    = m_ppcOrigYuv[uhDepth]->getHeight  ();
3033    Pel*  piSrc       = m_ppcOrigYuv[uhDepth]->getLumaAddr();
3034    UInt  uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride  ();
3035    m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
3036  }
3037#endif
3038
3039  Bool bSplit = uhDepth < pcTextureCU->getDepth( rpcTempCU->getZorderIdxInCU() );
3040  if( bSplit )
3041  {
3042    const UChar       uhNextDepth   = uhDepth+1;
3043    TComDataCU* pcSubBestPartCU     = m_ppcBestCU[uhNextDepth];
3044    TComDataCU* pcSubTempPartCU     = m_ppcTempCU[uhNextDepth];
3045
3046    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
3047    {
3048      pcSubBestPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP );           // clear sub partition datas or init.
3049      pcSubTempPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP );           // clear sub partition datas or init.
3050
3051      TComSlice * pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
3052      Bool bInSlice = pcSubBestPartCU->getSCUAddr()+pcSubBestPartCU->getTotalNumPart()>pcSlice->getEntropySliceCurStartCUAddr()&&pcSubBestPartCU->getSCUAddr()<pcSlice->getEntropySliceCurEndCUAddr();
3053      if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
3054      {
3055        if( m_bUseSBACRD )
3056        {
3057          if ( 0 == uiPartUnitIdx) //initialize RD with previous depth buffer
3058          {
3059            m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhDepth][CI_CURR_BEST]);
3060          }
3061          else
3062          {
3063            m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
3064          }
3065        }
3066
3067        xCheckRDCostMvInheritance( pcSubBestPartCU, pcSubTempPartCU, uhTextureModeDepth, bSkipResidual, true );
3068
3069        rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );         // Keep best part data to current temporary data.
3070        xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
3071      }
3072      else if (bInSlice)
3073      {
3074        pcSubBestPartCU->copyToPic( uhNextDepth );
3075        rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );
3076      }
3077    }
3078
3079    if( uhDepth == uhTextureModeDepth )
3080    {
3081      xAddMVISignallingBits( rpcTempCU );
3082    }
3083
3084    // DQP stuff
3085    {
3086      if( (g_uiMaxCUWidth>>uhDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() && rpcTempCU->getSlice()->getPPS()->getUseDQP())
3087      {
3088        TComPic *pcPic = rpcTempCU->getPic();
3089        TComSlice *pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
3090        Bool bHasRedisual = false;
3091        for( UInt uiBlkIdx = 0; uiBlkIdx < rpcTempCU->getTotalNumPart(); uiBlkIdx ++)
3092        {
3093          if( ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(uiBlkIdx+rpcTempCU->getZorderIdxInCU()) == rpcTempCU->getSlice()->getEntropySliceCurStartCUAddr() ) &&
3094              ( rpcTempCU->getCbf( uiBlkIdx, TEXT_LUMA ) || rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_U ) || rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_V ) ) )
3095          {
3096            bHasRedisual = true;
3097            break;
3098          }
3099        }
3100
3101        UInt uiTargetPartIdx;
3102        if ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) != pcSlice->getEntropySliceCurStartCUAddr() )
3103        {
3104          uiTargetPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
3105        }
3106        else
3107        {
3108          uiTargetPartIdx = 0;
3109        }
3110        if ( ! bHasRedisual )
3111        {
3112  #if LOSSLESS_CODING
3113          if (((rpcTempCU->getQP(uiTargetPartIdx) != rpcTempCU->getRefQP(uiTargetPartIdx)) ) && (rpcTempCU->getSlice()->getSPS()->getUseLossless()))
3114          {
3115            rpcTempCU->getTotalCost() = MAX_DOUBLE;
3116          }
3117  #endif
3118          rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( uiTargetPartIdx ), 0, uhDepth ); // set QP to default QP
3119        }
3120      }
3121    }
3122
3123    if( m_bUseSBACRD )
3124    {
3125      m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->store(m_pppcRDSbacCoder[uhDepth][CI_TEMP_BEST]);
3126    }
3127  }
3128  else
3129  {
3130    rpcTempCU->setTextureModeDepthSubParts( uhTextureModeDepth, 0, uhDepth );
3131    rpcTempCU->copyTextureMotionDataFrom( pcTextureCU, uhDepth, rpcTempCU->getZorderIdxInCU() );
3132    rpcTempCU->setPartSizeSubParts( SIZE_NxN, 0, uhDepth );
3133    for( UInt ui = 0; ui < rpcTempCU->getTotalNumPart(); ui++ )
3134    {
3135      assert( rpcTempCU->getInterDir( ui ) != 0 );
3136      assert( rpcTempCU->getPredictionMode( ui ) != MODE_NONE );
3137    }
3138    rpcTempCU->setPredModeSubParts( bSkipResidual ? MODE_SKIP : MODE_INTER, 0, uhDepth );
3139    m_pcPredSearch->motionCompensation( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
3140
3141    // get Original YUV data from picture
3142    m_ppcOrigYuv[uhDepth]->copyFromPicYuv( rpcBestCU->getPic()->getPicYuvOrg(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
3143    m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
3144                                               m_ppcOrigYuv[uhDepth],
3145                                               m_ppcPredYuvTemp[uhDepth],
3146                                               m_ppcResiYuvTemp[uhDepth],
3147                                               m_ppcResiYuvBest[uhDepth],
3148                                               m_ppcRecoYuvTemp[uhDepth],
3149#if HHI_INTER_VIEW_RESIDUAL_PRED
3150                                               m_ppcResPredTmp [uhDepth],
3151#endif
3152                                               bSkipResidual );
3153
3154    if( uhDepth == uhTextureModeDepth )
3155    {
3156      xAddMVISignallingBits( rpcTempCU );
3157    }
3158    xCheckDQP( rpcTempCU );
3159  }
3160
3161#if HHI_VSO
3162  if( m_pcRdCost->getUseLambdaScaleVSO() )
3163  {
3164    rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
3165  }
3166  else
3167#endif
3168  {
3169    rpcTempCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
3170  }
3171
3172  if( rpcTempCU->getPredictionMode( 0 ) == MODE_SKIP && uhDepth == uhTextureModeDepth )
3173  {
3174    if( rpcTempCU->getSlice()->getPPS()->getUseDQP() && (g_uiMaxCUWidth>>uhDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
3175      rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( 0 ), 0, uhDepth ); // set QP to default QP
3176  }
3177  xCheckBestMode( rpcBestCU, rpcTempCU, uhDepth );
3178  rpcBestCU->copyToPic(uhDepth);                                                     // Copy Best data to Picture for next partition prediction.
3179
3180#if HHI_VSO
3181  if( !bSplit && bRecursiveCall && m_pcRdCost->getUseRenModel() )
3182  {
3183    UInt  uiWidth     = m_ppcRecoYuvBest[uhDepth]->getWidth   (   );
3184    UInt  uiHeight    = m_ppcRecoYuvBest[uhDepth]->getHeight  (   );
3185    UInt  uiSrcStride = m_ppcRecoYuvBest[uhDepth]->getStride  (   );
3186    Pel*  piSrc       = m_ppcRecoYuvBest[uhDepth]->getLumaAddr( 0 );
3187    m_pcRdCost->setRenModelData( rpcBestCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
3188  }
3189#endif
3190}
3191
3192Void TEncCu::xAddMVISignallingBits( TComDataCU* pcCU )
3193{
3194  const UChar uhDepth = pcCU->getTextureModeDepth( 0 );
3195  m_pcEntropyCoder->resetBits();
3196  xSaveDepthWidthHeight( pcCU );
3197  pcCU->setSizeSubParts( g_uiMaxCUWidth>>uhDepth, g_uiMaxCUHeight>>uhDepth, 0, uhDepth );
3198  pcCU->setDepthSubParts( uhDepth, 0 );
3199  pcCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth );
3200  pcCU->setMergeFlagSubParts( true, 0, 0, uhDepth );
3201  pcCU->setMergeIndexSubParts( HHI_MPI_MERGE_POS, 0, 0, uhDepth );
3202
3203  // check for skip mode
3204  {
3205    Bool bAllZero = true;
3206    for( UInt ui = 0; ui < pcCU->getTotalNumPart(); ui++ )
3207    {
3208      if( pcCU->getCbf( ui, TEXT_LUMA ) || pcCU->getCbf( ui, TEXT_CHROMA_U ) || pcCU->getCbf( ui, TEXT_CHROMA_V ) )
3209      {
3210        bAllZero = false;
3211        break;
3212      }
3213    }
3214    if( bAllZero )
3215      pcCU->setPredModeSubParts( MODE_SKIP, 0, uhDepth );
3216  }
3217
3218
3219  m_pcEntropyCoder->encodeSplitFlag( pcCU, 0, uhDepth, true );
3220  m_pcEntropyCoder->encodeSkipFlag( pcCU, 0, true );
3221
3222  if( pcCU->isSkipped( 0 ) )
3223  {
3224    m_pcEntropyCoder->encodeMergeIndex( pcCU, 0, 0, true );
3225#if LGE_ILLUCOMP_B0045
3226    m_pcEntropyCoder->encodeICFlag( pcCU, 0, true );
3227#endif
3228  }
3229  else
3230  {
3231    m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
3232    m_pcEntropyCoder->encodePartSize( pcCU, 0, uhDepth, true );
3233    // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
3234    m_pcEntropyCoder->encodePredInfo( pcCU, 0, true );
3235#if LGE_ILLUCOMP_B0045
3236    m_pcEntropyCoder->encodeICFlag( pcCU, 0,          true );
3237#endif
3238  }
3239  xRestoreDepthWidthHeight( pcCU );
3240
3241  pcCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits();
3242}
3243
3244Void TEncCu::xSaveDepthWidthHeight( TComDataCU* pcCU )
3245{
3246  const Int iSizeInUchar  = sizeof( UChar ) * pcCU->getTotalNumPart();
3247  memcpy( m_puhDepthSaved, pcCU->getDepth(), iSizeInUchar );
3248  memcpy( m_puhWidthSaved, pcCU->getWidth(), iSizeInUchar );
3249  memcpy( m_puhHeightSaved, pcCU->getHeight(), iSizeInUchar );
3250}
3251
3252Void TEncCu::xRestoreDepthWidthHeight( TComDataCU* pcCU )
3253{
3254  const Int iSizeInUchar  = sizeof( UChar ) * pcCU->getTotalNumPart();
3255  memcpy( pcCU->getDepth(), m_puhDepthSaved, iSizeInUchar );
3256  memcpy( pcCU->getWidth(), m_puhWidthSaved, iSizeInUchar );
3257  memcpy( pcCU->getHeight(), m_puhHeightSaved, iSizeInUchar );
3258}
3259#endif
3260
3261//! \}
Note: See TracBrowser for help on using the repository browser.