source: 3DVCSoftware/branches/HTM-4.0-Orange/source/Lib/TLibEncoder/TEncCu.cpp @ 112

Last change on this file since 112 was 112, checked in by orange, 12 years ago

joelb.jung@…
jct3v-a0044

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