source: 3DVCSoftware/branches/HTM-11.2-dev2-MediaTek/source/Lib/TLibEncoder/TEncCu.cpp @ 1017

Last change on this file since 1017 was 1017, checked in by mediatek-htm, 10 years ago

JCT3V-I0099 FIX allow encoder only QTL

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