source: 3DVCSoftware/branches/HTM-6.2-dev2-Qualcomm/source/Lib/TLibEncoder/TEncCu.cpp @ 373

Last change on this file since 373 was 373, checked in by zhang, 11 years ago

JCT3V-D0177: ARP

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