source: 3DVCSoftware/branches/HTM-14.1-update-dev3/source/Lib/TLibEncoder/TEncCu.cpp @ 1270

Last change on this file since 1270 was 1270, checked in by tech, 9 years ago

Merged 14.1-update-dev4-Qualcomm@1266

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