source: 3DVCSoftware/branches/HTM-14.1-update-dev3-MediaTek2/source/Lib/TLibCommon/TComDataCU.cpp @ 1268

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

Reactivate MPI with the MACRO "NH_3D_TEXT_MERGE".

by Yi-Wen Chen (yiwen.chen@…)

  • Property svn:eol-style set to native
File size: 208.5 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2015, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     TComDataCU.cpp
35    \brief    CU data structure
36    \todo     not all entities are documented
37*/
38
39#include "TComDataCU.h"
40#include "TComTU.h"
41#include "TComPic.h"
42
43//! \ingroup TLibCommon
44//! \{
45
46// ====================================================================================================================
47// Constructor / destructor / create / destroy
48// ====================================================================================================================
49
50TComDataCU::TComDataCU()
51{
52  m_pcPic              = NULL;
53  m_pcSlice            = NULL;
54  m_puhDepth           = NULL;
55
56  m_skipFlag           = NULL;
57#if H_3D
58  m_bDISFlag           = NULL;
59  m_uiDISType          = NULL;
60#endif
61  m_pePartSize         = NULL;
62  m_pePredMode         = NULL;
63  m_CUTransquantBypass = NULL;
64  m_puhWidth           = NULL;
65  m_puhHeight          = NULL;
66  m_phQP               = NULL;
67  m_ChromaQpAdj        = NULL;
68  m_pbMergeFlag        = NULL;
69  m_puhMergeIndex      = NULL;
70  for(UInt i=0; i<MAX_NUM_CHANNEL_TYPE; i++)
71  {
72    m_puhIntraDir[i]     = NULL;
73  }
74  m_puhInterDir        = NULL;
75  m_puhTrIdx           = NULL;
76
77  for (UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
78  {
79    m_puhCbf[comp]                        = NULL;
80    m_crossComponentPredictionAlpha[comp] = NULL;
81    m_puhTransformSkip[comp]              = NULL;
82    m_pcTrCoeff[comp]                     = NULL;
83#if ADAPTIVE_QP_SELECTION
84    m_pcArlCoeff[comp]                    = NULL;
85#endif
86    m_pcIPCMSample[comp]                  = NULL;
87    m_explicitRdpcmMode[comp]             = NULL;
88  }
89#if ADAPTIVE_QP_SELECTION
90  m_ArlCoeffIsAliasedAllocation = false;
91#endif
92  m_pbIPCMFlag         = NULL;
93
94  m_pCtuAboveLeft      = NULL;
95  m_pCtuAboveRight     = NULL;
96  m_pCtuAbove          = NULL;
97  m_pCtuLeft           = NULL;
98
99  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
100  {
101    m_apcCUColocated[i]  = NULL;
102    m_apiMVPIdx[i]       = NULL;
103    m_apiMVPNum[i]       = NULL;
104  }
105
106#if H_3D_DIM
107  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
108  {
109    m_dimDeltaDC[i][0] = NULL; 
110    m_dimDeltaDC[i][1] = NULL;
111  }
112#if H_3D_DIM_DMM
113  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
114  {
115    m_dmmWedgeTabIdx[i] = NULL;
116  }
117#endif
118#if H_3D_DIM_SDC
119  m_pbSDCFlag             = NULL;
120  m_apSegmentDCOffset[0]  = NULL;
121  m_apSegmentDCOffset[1]  = NULL;
122#endif
123#endif
124
125  m_bDecSubCu          = false;
126
127#if NH_3D_NBDV
128  m_pDvInfo              = NULL;
129#endif
130#if NH_3D_VSP
131  m_piVSPFlag            = NULL;
132#endif
133#if NH_3D_SPIVMP
134  m_pbSPIVMPFlag         = NULL;
135#endif
136#if H_3D_ARP
137  m_puhARPW              = NULL;
138#endif
139#if H_3D_IC
140  m_pbICFlag             = NULL;
141#endif
142#if H_3D_INTER_SDC
143#endif
144#if H_3D_DBBP
145  m_pbDBBPFlag         = NULL;
146#endif
147
148}
149
150TComDataCU::~TComDataCU()
151{
152}
153
154Void TComDataCU::create( ChromaFormat chromaFormatIDC, UInt uiNumPartition, UInt uiWidth, UInt uiHeight, Bool bDecSubCu, Int unitSize
155#if ADAPTIVE_QP_SELECTION
156                        , TCoeff *pParentARLBuffer
157#endif
158                        )
159{
160  m_bDecSubCu = bDecSubCu;
161
162  m_pcPic              = NULL;
163  m_pcSlice            = NULL;
164  m_uiNumPartition     = uiNumPartition;
165  m_unitSize = unitSize;
166
167  if ( !bDecSubCu )
168  {
169    m_phQP               = (Char*     )xMalloc(Char,     uiNumPartition);
170    m_puhDepth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
171    m_puhWidth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
172    m_puhHeight          = (UChar*    )xMalloc(UChar,    uiNumPartition);
173
174    m_ChromaQpAdj        = new UChar[ uiNumPartition ];
175    m_skipFlag           = new Bool[ uiNumPartition ];
176#if H_3D
177    m_bDISFlag           = new Bool[ uiNumPartition ];
178    m_uiDISType          = (UInt*)xMalloc(UInt, uiNumPartition);
179#endif
180    m_pePartSize         = new Char[ uiNumPartition ];
181    memset( m_pePartSize, NUMBER_OF_PART_SIZES,uiNumPartition * sizeof( *m_pePartSize ) );
182    m_pePredMode         = new Char[ uiNumPartition ];
183    m_CUTransquantBypass = new Bool[ uiNumPartition ];
184
185    m_pbMergeFlag        = (Bool*  )xMalloc(Bool,   uiNumPartition);
186    m_puhMergeIndex      = (UChar* )xMalloc(UChar,  uiNumPartition);
187#if NH_3D_VSP
188    m_piVSPFlag          = (Char*  )xMalloc(Char,   uiNumPartition);
189#endif
190#if NH_3D_SPIVMP
191    m_pbSPIVMPFlag       = (Bool*  )xMalloc(Bool,   uiNumPartition);
192#endif
193
194    for (UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
195    {
196      m_puhIntraDir[ch] = (UChar* )xMalloc(UChar,  uiNumPartition);
197    }
198    m_puhInterDir        = (UChar* )xMalloc(UChar,  uiNumPartition);
199
200    m_puhTrIdx           = (UChar* )xMalloc(UChar,  uiNumPartition);
201
202    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
203    {
204      const RefPicList rpl=RefPicList(i);
205      m_apiMVPIdx[rpl]       = new Char[ uiNumPartition ];
206      m_apiMVPNum[rpl]       = new Char[ uiNumPartition ];
207      memset( m_apiMVPIdx[rpl], -1,uiNumPartition * sizeof( Char ) );
208    }
209
210#if NH_3D_NBDV
211    m_pDvInfo            = (DisInfo* )xMalloc(DisInfo,  uiNumPartition);
212#endif
213
214
215    for (UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
216    {
217      const ComponentID compID = ComponentID(comp);
218      const UInt chromaShift = getComponentScaleX(compID, chromaFormatIDC) + getComponentScaleY(compID, chromaFormatIDC);
219      const UInt totalSize   = (uiWidth * uiHeight) >> chromaShift;
220
221      m_crossComponentPredictionAlpha[compID] = (Char*  )xMalloc(Char,   uiNumPartition);
222      m_puhTransformSkip[compID]              = (UChar* )xMalloc(UChar,  uiNumPartition);
223      m_explicitRdpcmMode[compID]             = (UChar* )xMalloc(UChar,  uiNumPartition);
224      m_puhCbf[compID]                        = (UChar* )xMalloc(UChar,  uiNumPartition);
225      m_pcTrCoeff[compID]                     = (TCoeff*)xMalloc(TCoeff, totalSize);
226      memset( m_pcTrCoeff[compID], 0, (totalSize * sizeof( TCoeff )) );
227
228#if ADAPTIVE_QP_SELECTION
229      if( pParentARLBuffer != 0 )
230      {
231        m_pcArlCoeff[compID] = pParentARLBuffer;
232        m_ArlCoeffIsAliasedAllocation = true;
233        pParentARLBuffer += totalSize;
234      }
235      else
236      {
237        m_pcArlCoeff[compID] = (TCoeff*)xMalloc(TCoeff, totalSize);
238        m_ArlCoeffIsAliasedAllocation = false;
239      }
240#endif
241      m_pcIPCMSample[compID] = (Pel*   )xMalloc(Pel , totalSize);
242    }
243
244    m_pbIPCMFlag         = (Bool*  )xMalloc(Bool, uiNumPartition);
245
246    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
247    {
248      m_acCUMvField[i].create( uiNumPartition );
249    }
250
251#if H_3D_ARP
252    m_puhARPW            = new UChar[ uiNumPartition];
253#endif
254#if H_3D_IC
255    m_pbICFlag           = (Bool* )xMalloc(Bool,   uiNumPartition);
256#endif
257#if H_3D_DIM
258    for( Int i = 0; i < DIM_NUM_TYPE; i++ )
259    {
260      m_dimDeltaDC[i][0] = (Pel* )xMalloc(Pel, uiNumPartition); 
261      m_dimDeltaDC[i][1] = (Pel* )xMalloc(Pel, uiNumPartition);
262    }
263#if H_3D_DIM_DMM
264    for( Int i = 0; i < DMM_NUM_TYPE; i++ )
265    {
266      m_dmmWedgeTabIdx[i]    = (UInt*)xMalloc(UInt, uiNumPartition);
267    }
268#endif
269#if H_3D_DIM_SDC
270    m_pbSDCFlag             = (Bool*)xMalloc(Bool, uiNumPartition);
271    m_apSegmentDCOffset[0]  = (Pel*)xMalloc(Pel, uiNumPartition);
272    m_apSegmentDCOffset[1]  = (Pel*)xMalloc(Pel, uiNumPartition);
273#endif
274#endif
275#if H_3D_DBBP
276    m_pbDBBPFlag         = (Bool*  )xMalloc(Bool,   uiNumPartition);
277#endif
278
279  }
280  else
281  {
282    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
283    {
284      m_acCUMvField[i].setNumPartition(uiNumPartition );
285    }
286  }
287
288  // create motion vector fields
289
290  m_pCtuAboveLeft      = NULL;
291  m_pCtuAboveRight     = NULL;
292  m_pCtuAbove          = NULL;
293  m_pCtuLeft           = NULL;
294
295  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
296  {
297    m_apcCUColocated[i]  = NULL;
298  }
299}
300
301Void TComDataCU::destroy()
302{
303  // encoder-side buffer free
304  if ( !m_bDecSubCu )
305  {
306    if ( m_phQP )
307    {
308      xFree(m_phQP);
309      m_phQP = NULL;
310    }
311    if ( m_puhDepth )
312    {
313      xFree(m_puhDepth);
314      m_puhDepth = NULL;
315    }
316    if ( m_puhWidth )
317    {
318      xFree(m_puhWidth);
319      m_puhWidth = NULL;
320    }
321    if ( m_puhHeight )
322    {
323      xFree(m_puhHeight);
324      m_puhHeight = NULL;
325    }
326
327    if ( m_skipFlag )
328    {
329      delete[] m_skipFlag;
330      m_skipFlag = NULL;
331    }
332
333#if H_3D
334    if ( m_bDISFlag           ) { delete[] m_bDISFlag;   m_bDISFlag     = NULL; }
335    if ( m_uiDISType         ) { xFree(m_uiDISType);  m_uiDISType    = NULL; }
336#endif
337
338    if ( m_pePartSize )
339    {
340      delete[] m_pePartSize;
341      m_pePartSize = NULL;
342    }
343    if ( m_pePredMode )
344    {
345      delete[] m_pePredMode;
346      m_pePredMode = NULL;
347    }
348    if ( m_ChromaQpAdj )
349    {
350      delete[] m_ChromaQpAdj;
351      m_ChromaQpAdj = NULL;
352    }
353    if ( m_CUTransquantBypass )
354    {
355      delete[] m_CUTransquantBypass;
356      m_CUTransquantBypass = NULL;
357    }
358    if ( m_puhInterDir )
359    {
360      xFree(m_puhInterDir);
361      m_puhInterDir = NULL;
362    }
363    if ( m_pbMergeFlag )
364    {
365      xFree(m_pbMergeFlag);
366      m_pbMergeFlag = NULL;
367    }
368    if ( m_puhMergeIndex )
369    {
370      xFree(m_puhMergeIndex);
371      m_puhMergeIndex  = NULL;
372    }
373
374#if NH_3D_VSP
375    if ( m_piVSPFlag )
376    {
377      xFree(m_piVSPFlag);
378      m_piVSPFlag = NULL;
379    }
380#endif
381#if NH_3D_SPIVMP
382    if ( m_pbSPIVMPFlag       ) { xFree(m_pbSPIVMPFlag);           m_pbSPIVMPFlag         = NULL; }
383#endif
384
385
386    for (UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
387    {
388      xFree(m_puhIntraDir[ch]);
389      m_puhIntraDir[ch] = NULL;
390    }
391
392    if ( m_puhTrIdx )
393    {
394      xFree(m_puhTrIdx);
395      m_puhTrIdx = NULL;
396    }
397
398    for (UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
399    {
400      if ( m_crossComponentPredictionAlpha[comp] )
401      {
402        xFree(m_crossComponentPredictionAlpha[comp]);
403        m_crossComponentPredictionAlpha[comp] = NULL;
404      }
405      if ( m_puhTransformSkip[comp] )
406      {
407        xFree(m_puhTransformSkip[comp]);
408        m_puhTransformSkip[comp] = NULL;
409      }
410      if ( m_puhCbf[comp] )
411      {
412        xFree(m_puhCbf[comp]);
413        m_puhCbf[comp] = NULL;
414      }
415      if ( m_pcTrCoeff[comp] )
416      {
417        xFree(m_pcTrCoeff[comp]);
418        m_pcTrCoeff[comp] = NULL;
419      }
420      if ( m_explicitRdpcmMode[comp] )
421      {
422        xFree(m_explicitRdpcmMode[comp]);
423        m_explicitRdpcmMode[comp] = NULL;
424      }
425
426#if ADAPTIVE_QP_SELECTION
427      if (!m_ArlCoeffIsAliasedAllocation)
428      {
429        if ( m_pcArlCoeff[comp] )
430        {
431          xFree(m_pcArlCoeff[comp]);
432          m_pcArlCoeff[comp] = NULL;
433        }
434      }
435#endif
436
437      if ( m_pcIPCMSample[comp] )
438      {
439        xFree(m_pcIPCMSample[comp]);
440        m_pcIPCMSample[comp] = NULL;
441      }
442    }
443    if ( m_pbIPCMFlag )
444    {
445      xFree(m_pbIPCMFlag );
446      m_pbIPCMFlag = NULL;
447    }
448
449    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
450    {
451      const RefPicList rpl=RefPicList(i);
452      if ( m_apiMVPIdx[rpl] )
453      {
454        delete[] m_apiMVPIdx[rpl];
455        m_apiMVPIdx[rpl] = NULL;
456      }
457      if ( m_apiMVPNum[rpl] )
458      {
459        delete[] m_apiMVPNum[rpl];
460        m_apiMVPNum[rpl] = NULL;
461      }
462    }
463
464    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
465    {
466      const RefPicList rpl=RefPicList(i);
467      m_acCUMvField[rpl].destroy();
468    }
469#if NH_3D_NBDV
470    if ( m_pDvInfo            ) { xFree(m_pDvInfo);             m_pDvInfo           = NULL; }
471#endif
472
473
474#if H_3D_ARP
475    if ( m_puhARPW            ) { delete[] m_puhARPW;           m_puhARPW           = NULL; }
476#endif
477#if H_3D_IC
478    if ( m_pbICFlag           ) { xFree(m_pbICFlag);            m_pbICFlag          = NULL; }
479#endif
480
481#if H_3D_DIM
482    for( Int i = 0; i < DIM_NUM_TYPE; i++ )
483    {
484      if ( m_dimDeltaDC[i][0] ) { xFree( m_dimDeltaDC[i][0] ); m_dimDeltaDC[i][0] = NULL; }
485      if ( m_dimDeltaDC[i][1] ) { xFree( m_dimDeltaDC[i][1] ); m_dimDeltaDC[i][1] = NULL; }
486    }
487#if H_3D_DIM_DMM
488    for( Int i = 0; i < DMM_NUM_TYPE; i++ )
489    {
490      if ( m_dmmWedgeTabIdx[i] ) { xFree( m_dmmWedgeTabIdx[i] ); m_dmmWedgeTabIdx[i] = NULL; }
491    }
492#endif
493#if H_3D_DIM_SDC
494    if ( m_pbSDCFlag            ) { xFree(m_pbSDCFlag);             m_pbSDCFlag             = NULL; }
495    if ( m_apSegmentDCOffset[0] ) { xFree(m_apSegmentDCOffset[0]);  m_apSegmentDCOffset[0]  = NULL; }
496    if ( m_apSegmentDCOffset[1] ) { xFree(m_apSegmentDCOffset[1]);  m_apSegmentDCOffset[1]  = NULL; }
497#endif   
498#endif   
499#if H_3D_DBBP
500    if ( m_pbDBBPFlag         ) { xFree(m_pbDBBPFlag);          m_pbDBBPFlag        = NULL; }
501#endif
502
503  }
504
505  m_pcPic              = NULL;
506  m_pcSlice            = NULL;
507
508  m_pCtuAboveLeft      = NULL;
509  m_pCtuAboveRight     = NULL;
510  m_pCtuAbove          = NULL;
511  m_pCtuLeft           = NULL;
512
513
514  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
515  {
516    m_apcCUColocated[i]  = NULL;
517  }
518
519}
520
521Bool TComDataCU::CUIsFromSameTile            ( const TComDataCU *pCU /* Can be NULL */) const
522{
523  return pCU!=NULL &&
524         pCU->getSlice() != NULL &&
525         m_pcPic->getPicSym()->getTileIdxMap( pCU->getCtuRsAddr() ) == m_pcPic->getPicSym()->getTileIdxMap(getCtuRsAddr());
526}
527
528Bool TComDataCU::CUIsFromSameSliceAndTile    ( const TComDataCU *pCU /* Can be NULL */) const
529{
530  return pCU!=NULL &&
531         pCU->getSlice() != NULL &&
532         pCU->getSlice()->getSliceCurStartCtuTsAddr() == getSlice()->getSliceCurStartCtuTsAddr() &&
533         m_pcPic->getPicSym()->getTileIdxMap( pCU->getCtuRsAddr() ) == m_pcPic->getPicSym()->getTileIdxMap(getCtuRsAddr())
534         ;
535}
536
537Bool TComDataCU::CUIsFromSameSliceTileAndWavefrontRow( const TComDataCU *pCU /* Can be NULL */) const
538{
539  return CUIsFromSameSliceAndTile(pCU)
540         && (!getSlice()->getPPS()->getEntropyCodingSyncEnabledFlag() || getPic()->getCtu(getCtuRsAddr())->getCUPelY() == getPic()->getCtu(pCU->getCtuRsAddr())->getCUPelY());
541}
542
543Bool TComDataCU::isLastSubCUOfCtu(const UInt absPartIdx)
544{
545  const TComSPS &sps=*(getSlice()->getSPS());
546
547  const UInt picWidth = sps.getPicWidthInLumaSamples();
548  const UInt picHeight = sps.getPicHeightInLumaSamples();
549  const UInt granularityWidth = sps.getMaxCUWidth();
550
551  const UInt cuPosX = getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[absPartIdx] ];
552  const UInt cuPosY = getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[absPartIdx] ];
553
554  return (((cuPosX+getWidth( absPartIdx))%granularityWidth==0||(cuPosX+getWidth( absPartIdx)==picWidth ))
555       && ((cuPosY+getHeight(absPartIdx))%granularityWidth==0||(cuPosY+getHeight(absPartIdx)==picHeight)));
556}
557
558// ====================================================================================================================
559// Public member functions
560// ====================================================================================================================
561
562// --------------------------------------------------------------------------------------------------------------------
563// Initialization
564// --------------------------------------------------------------------------------------------------------------------
565
566/**
567 Initialize top-level CU: create internal buffers and set initial values before encoding the CTU.
568 
569 \param  pcPic       picture (TComPic) class pointer
570 \param  ctuRsAddr   CTU address in raster scan order
571 */
572Void TComDataCU::initCtu( TComPic* pcPic, UInt ctuRsAddr )
573{
574
575  const UInt maxCUWidth = pcPic->getPicSym()->getSPS().getMaxCUWidth();
576  const UInt maxCUHeight= pcPic->getPicSym()->getSPS().getMaxCUHeight();
577  m_pcPic              = pcPic;
578  m_pcSlice            = pcPic->getSlice(pcPic->getCurrSliceIdx());
579  m_ctuRsAddr          = ctuRsAddr;
580  m_uiCUPelX           = ( ctuRsAddr % pcPic->getFrameWidthInCtus() ) * maxCUWidth;
581  m_uiCUPelY           = ( ctuRsAddr / pcPic->getFrameWidthInCtus() ) * maxCUHeight;
582  m_absZIdxInCtu       = 0;
583  m_dTotalCost         = MAX_DOUBLE;
584  m_uiTotalDistortion  = 0;
585  m_uiTotalBits        = 0;
586  m_uiTotalBins        = 0;
587  m_uiNumPartition     = pcPic->getNumPartitionsInCtu();
588
589  memset( m_skipFlag          , false,                      m_uiNumPartition * sizeof( *m_skipFlag ) );
590
591#if H_3D
592    m_bDISFlag[ui]   = pcFrom->getDISFlag(ui);
593    m_uiDISType[ui]  = pcFrom->getDISType(ui);
594#endif
595
596  memset( m_pePartSize        , NUMBER_OF_PART_SIZES,       m_uiNumPartition * sizeof( *m_pePartSize ) );
597  memset( m_pePredMode        , NUMBER_OF_PREDICTION_MODES, m_uiNumPartition * sizeof( *m_pePredMode ) );
598  memset( m_CUTransquantBypass, false,                      m_uiNumPartition * sizeof( *m_CUTransquantBypass) );
599  memset( m_puhDepth          , 0,                          m_uiNumPartition * sizeof( *m_puhDepth ) );
600  memset( m_puhTrIdx          , 0,                          m_uiNumPartition * sizeof( *m_puhTrIdx ) );
601  memset( m_puhWidth          , maxCUWidth,                 m_uiNumPartition * sizeof( *m_puhWidth ) );
602  memset( m_puhHeight         , maxCUHeight,                m_uiNumPartition * sizeof( *m_puhHeight ) );
603
604#if H_3D_ARP
605    m_puhARPW   [ui] = pcFrom->getARPW( ui );
606#endif
607#if H_3D_IC
608    m_pbICFlag[ui]   =  pcFrom->m_pbICFlag[ui];
609#endif
610
611  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
612  {
613    const RefPicList rpl=RefPicList(i);
614    memset( m_apiMVPIdx[rpl]  , -1,                         m_uiNumPartition * sizeof( *m_apiMVPIdx[rpl] ) );
615    memset( m_apiMVPNum[rpl]  , -1,                         m_uiNumPartition * sizeof( *m_apiMVPNum[rpl] ) );
616  }
617  memset( m_phQP              , getSlice()->getSliceQp(),   m_uiNumPartition * sizeof( *m_phQP ) );
618  memset( m_ChromaQpAdj       , 0,                          m_uiNumPartition * sizeof( *m_ChromaQpAdj ) );
619  for(UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
620  {
621    memset( m_crossComponentPredictionAlpha[comp] , 0,                     m_uiNumPartition * sizeof( *m_crossComponentPredictionAlpha[comp] ) );
622    memset( m_puhTransformSkip[comp]              , 0,                     m_uiNumPartition * sizeof( *m_puhTransformSkip[comp]) );
623    memset( m_puhCbf[comp]                        , 0,                     m_uiNumPartition * sizeof( *m_puhCbf[comp] ) );
624    memset( m_explicitRdpcmMode[comp]             , NUMBER_OF_RDPCM_MODES, m_uiNumPartition * sizeof( *m_explicitRdpcmMode[comp] ) );
625  }
626  memset( m_pbMergeFlag       , false,                    m_uiNumPartition * sizeof( *m_pbMergeFlag ) );
627  memset( m_puhMergeIndex     , 0,                        m_uiNumPartition * sizeof( *m_puhMergeIndex ) );
628
629#if NH_3D_VSP
630  memset( m_piVSPFlag         , 0,                        m_uiNumPartition * sizeof( *m_piVSPFlag ) );
631#endif
632#if NH_3D_SPIVMP
633  memset( m_pbSPIVMPFlag      , 0,                     m_uiNumPartition * sizeof( *m_pbSPIVMPFlag ) );   
634#endif
635#if H_3D_DIM_SDC
636    m_pbSDCFlag[ui] = pcFrom->m_pbSDCFlag[ui];
637#endif
638#if H_3D_DBBP
639    m_pbDBBPFlag[ui] = pcFrom->m_pbDBBPFlag[ui];
640#endif
641#if H_3D
642    memset( m_bDISFlag          + firstElement, false,                    numElements * sizeof( *m_bDISFlag ) );
643    memset( m_uiDISType         + firstElement,     0,                    numElements * sizeof( *m_uiDISType) );
644#endif
645
646  for (UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
647  {
648    memset( m_puhIntraDir[ch] , ((ch==0) ? DC_IDX : 0),   m_uiNumPartition * sizeof( *(m_puhIntraDir[ch]) ) );
649  }
650
651#if H_3D_ARP
652    memset( m_puhARPW           + firstElement, 0,                        numElements * sizeof( UChar )         );
653#endif
654#if H_3D_IC
655    memset( m_pbICFlag          + firstElement, false,                    numElements * sizeof( *m_pbICFlag )   );
656#endif
657
658
659#if H_3D_DIM
660    for( Int i = 0; i < DIM_NUM_TYPE; i++ )
661    {
662      memset( m_dimDeltaDC[i][0] + firstElement, 0,                       numElements * sizeof( *m_dimDeltaDC[i][0] ) );
663      memset( m_dimDeltaDC[i][1] + firstElement, 0,                       numElements * sizeof( *m_dimDeltaDC[i][1] ) );
664    }
665#if H_3D_DIM_DMM
666    for( Int i = 0; i < DMM_NUM_TYPE; i++ )
667    {
668      memset( m_dmmWedgeTabIdx[i] + firstElement, 0,                      numElements * sizeof( *m_dmmWedgeTabIdx[i] ) );
669    }
670#endif
671#if H_3D_DIM_SDC
672    memset( m_pbSDCFlag             + firstElement,     0,                numElements * sizeof( *m_pbSDCFlag            ) );
673    memset( m_apSegmentDCOffset[0]  + firstElement,     0,                numElements * sizeof( *m_apSegmentDCOffset[0] ) );
674    memset( m_apSegmentDCOffset[1]  + firstElement,     0,                numElements * sizeof( *m_apSegmentDCOffset[1] ) );
675#endif
676    m_apDmmPredictor[0] = 0;
677    m_apDmmPredictor[1] = 0;
678#endif
679#if H_3D_DBBP
680    memset( m_pbDBBPFlag        + firstElement, false,                    numElements * sizeof( *m_pbDBBPFlag ) );
681#endif
682
683  memset( m_puhInterDir       , 0,                        m_uiNumPartition * sizeof( *m_puhInterDir ) );
684  memset( m_pbIPCMFlag        , false,                    m_uiNumPartition * sizeof( *m_pbIPCMFlag ) );
685
686  const UInt numCoeffY    = maxCUWidth*maxCUHeight;
687  for (UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
688  {
689    const UInt componentShift = m_pcPic->getComponentScaleX(ComponentID(comp)) + m_pcPic->getComponentScaleY(ComponentID(comp));
690    memset( m_pcTrCoeff[comp], 0, sizeof(TCoeff)* numCoeffY>>componentShift );
691#if ADAPTIVE_QP_SELECTION
692    memset( m_pcArlCoeff[comp], 0, sizeof(TCoeff)* numCoeffY>>componentShift );
693#endif
694  }
695
696  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
697  {
698    m_acCUMvField[i].clearMvField();
699  }
700
701  // Setting neighbor CU
702  m_pCtuLeft        = NULL;
703  m_pCtuAbove       = NULL;
704  m_pCtuAboveLeft   = NULL;
705  m_pCtuAboveRight  = NULL;
706
707
708  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
709  {
710    m_apcCUColocated[i]  = NULL;
711  }
712
713  UInt frameWidthInCtus = pcPic->getFrameWidthInCtus();
714  if ( m_ctuRsAddr % frameWidthInCtus )
715  {
716    m_pCtuLeft = pcPic->getCtu( m_ctuRsAddr - 1 );
717  }
718
719  if ( m_ctuRsAddr / frameWidthInCtus )
720  {
721    m_pCtuAbove = pcPic->getCtu( m_ctuRsAddr - frameWidthInCtus );
722  }
723
724  if ( m_pCtuLeft && m_pCtuAbove )
725  {
726    m_pCtuAboveLeft = pcPic->getCtu( m_ctuRsAddr - frameWidthInCtus - 1 );
727  }
728
729  if ( m_pCtuAbove && ( (m_ctuRsAddr%frameWidthInCtus) < (frameWidthInCtus-1) )  )
730  {
731    m_pCtuAboveRight = pcPic->getCtu( m_ctuRsAddr - frameWidthInCtus + 1 );
732  }
733
734  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
735  {
736    const RefPicList rpl=RefPicList(i);
737    if ( getSlice()->getNumRefIdx( rpl ) > 0 )
738    {
739      m_apcCUColocated[rpl] = getSlice()->getRefPic( rpl, 0)->getCtu( m_ctuRsAddr );
740    }
741  }
742}
743
744
745/** Initialize prediction data with enabling sub-CTU-level delta QP.
746*   - set CU width and CU height according to depth
747*   - set qp value according to input qp
748*   - set last-coded qp value according to input last-coded qp
749*
750* \param  uiDepth            depth of the current CU
751* \param  qp                 qp for the current CU
752* \param  bTransquantBypass  true for transquant bypass
753*/
754Void TComDataCU::initEstData( const UInt uiDepth, const Int qp, const Bool bTransquantBypass )
755{
756  m_dTotalCost         = MAX_DOUBLE;
757  m_uiTotalDistortion  = 0;
758  m_uiTotalBits        = 0;
759  m_uiTotalBins        = 0;
760
761  const UChar uhWidth  = getSlice()->getSPS()->getMaxCUWidth()  >> uiDepth;
762  const UChar uhHeight = getSlice()->getSPS()->getMaxCUHeight() >> uiDepth;
763
764  for (UInt ui = 0; ui < m_uiNumPartition; ui++)
765  {
766    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
767    {
768      const RefPicList rpl=RefPicList(i);
769      m_apiMVPIdx[rpl][ui]  = -1;
770      m_apiMVPNum[rpl][ui]  = -1;
771    }
772    m_puhDepth  [ui]    = uiDepth;
773    m_puhWidth  [ui]    = uhWidth;
774    m_puhHeight [ui]    = uhHeight;
775    m_puhTrIdx  [ui]    = 0;
776    for(UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
777    {
778      m_crossComponentPredictionAlpha[comp][ui] = 0;
779      m_puhTransformSkip             [comp][ui] = 0;
780      m_explicitRdpcmMode            [comp][ui] = NUMBER_OF_RDPCM_MODES;
781    }
782    m_skipFlag[ui]      = false;
783#if H_3D
784      m_bDISFlag[ui]   = false;
785      m_uiDISType[ui]  = 0;
786#endif
787    m_pePartSize[ui]    = NUMBER_OF_PART_SIZES;
788    m_pePredMode[ui]    = NUMBER_OF_PREDICTION_MODES;
789    m_CUTransquantBypass[ui] = bTransquantBypass;
790    m_pbIPCMFlag[ui]    = 0;
791    m_phQP[ui]          = qp;
792    m_ChromaQpAdj[ui]   = 0;
793    m_pbMergeFlag[ui]   = 0;
794    m_puhMergeIndex[ui] = 0;
795#if NH_3D_VSP
796    m_piVSPFlag[ui]     = 0;
797#endif
798#if NH_3D_SPIVMP
799    m_pbSPIVMPFlag[ui] = 0;
800#endif
801
802    for (UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
803    {
804      m_puhIntraDir[ch][ui] = ((ch==0) ? DC_IDX : 0);
805    }
806
807    m_puhInterDir[ui] = 0;
808    for (UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
809    {
810      m_puhCbf[comp][ui] = 0;
811    }
812#if H_3D_ARP
813      m_puhARPW[ui] = 0;
814#endif
815#if H_3D_IC
816      m_pbICFlag[ui]  = false;
817#endif
818
819
820#if H_3D_DIM
821      for( Int i = 0; i < DIM_NUM_TYPE; i++ )
822      {
823        m_dimDeltaDC[i][0] [ui] = 0;
824        m_dimDeltaDC[i][1] [ui] = 0;
825      }
826#if H_3D_DIM_DMM
827      for( Int i = 0; i < DMM_NUM_TYPE; i++ )
828      {
829        m_dmmWedgeTabIdx[i] [ui] = 0;
830      }
831#endif
832#if H_3D_DIM_SDC
833      m_pbSDCFlag           [ui] = false;
834      m_apSegmentDCOffset[0][ui] = 0;
835      m_apSegmentDCOffset[1][ui] = 0;
836#endif
837      m_apDmmPredictor[0] = 0;
838      m_apDmmPredictor[1] = 0;
839#endif
840#if H_3D_DBBP
841      m_pbDBBPFlag[ui] = false;
842#endif
843  }
844
845  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
846  {
847    m_acCUMvField[i].clearMvField();
848  }
849
850  const UInt numCoeffY = uhWidth*uhHeight;
851
852  for (UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
853  {
854    const ComponentID component = ComponentID(comp);
855    const UInt numCoeff = numCoeffY >> (getPic()->getComponentScaleX(component) + getPic()->getComponentScaleY(component));
856    memset( m_pcTrCoeff[comp],    0, numCoeff * sizeof( TCoeff ) );
857#if ADAPTIVE_QP_SELECTION
858    memset( m_pcArlCoeff[comp],   0, numCoeff * sizeof( TCoeff ) );
859#endif
860    memset( m_pcIPCMSample[comp], 0, numCoeff * sizeof( Pel) );
861  }
862}
863
864
865// initialize Sub partition
866Void TComDataCU::initSubCU( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, Int qp )
867{
868  assert( uiPartUnitIdx<4 );
869
870  UInt uiPartOffset = ( pcCU->getTotalNumPart()>>2 )*uiPartUnitIdx;
871
872  m_pcPic              = pcCU->getPic();
873  m_pcSlice            = pcCU->getSlice();
874  m_ctuRsAddr          = pcCU->getCtuRsAddr();
875  m_absZIdxInCtu       = pcCU->getZorderIdxInCtu() + uiPartOffset;
876
877  const UChar uhWidth  = getSlice()->getSPS()->getMaxCUWidth()  >> uiDepth;
878  const UChar uhHeight = getSlice()->getSPS()->getMaxCUHeight() >> uiDepth;
879
880  m_uiCUPelX           = pcCU->getCUPelX() + ( uhWidth )*( uiPartUnitIdx &  1 );
881  m_uiCUPelY           = pcCU->getCUPelY() + ( uhHeight)*( uiPartUnitIdx >> 1 );
882
883  m_dTotalCost         = MAX_DOUBLE;
884  m_uiTotalDistortion  = 0;
885  m_uiTotalBits        = 0;
886  m_uiTotalBins        = 0;
887  m_uiNumPartition     = pcCU->getTotalNumPart() >> 2;
888
889  Int iSizeInUchar = sizeof( UChar  ) * m_uiNumPartition;
890  Int iSizeInBool  = sizeof( Bool   ) * m_uiNumPartition;
891  Int sizeInChar = sizeof( Char  ) * m_uiNumPartition;
892
893  memset( m_phQP,              qp,  sizeInChar );
894  memset( m_pbMergeFlag,        0, iSizeInBool  );
895  memset( m_puhMergeIndex,      0, iSizeInUchar );
896#if NH_3D_VSP
897  memset( m_piVSPFlag,          0, sizeof( Char  ) * m_uiNumPartition );
898#endif
899#if NH_3D_SPIVMP
900  memset( m_pbSPIVMPFlag,       0, sizeof( Bool  ) * m_uiNumPartition );
901#endif
902
903  for (UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
904  {
905    memset( m_puhIntraDir[ch],  ((ch==0) ? DC_IDX : 0), iSizeInUchar );
906  }
907
908  memset( m_puhInterDir,        0, iSizeInUchar );
909  memset( m_puhTrIdx,           0, iSizeInUchar );
910
911  for(UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
912  {
913    memset( m_crossComponentPredictionAlpha[comp], 0, iSizeInUchar );
914    memset( m_puhTransformSkip[comp],              0, iSizeInUchar );
915    memset( m_puhCbf[comp],                        0, iSizeInUchar );
916    memset( m_explicitRdpcmMode[comp],             NUMBER_OF_RDPCM_MODES, iSizeInUchar );
917  }
918#if H_3D_ARP
919  memset( m_puhARPW,            0, iSizeInUchar  );
920#endif
921
922  memset( m_puhDepth,     uiDepth, iSizeInUchar );
923  memset( m_puhWidth,          uhWidth,  iSizeInUchar );
924  memset( m_puhHeight,         uhHeight, iSizeInUchar );
925  memset( m_pbIPCMFlag,        0, iSizeInBool  );
926#if H_3D_IC
927  memset( m_pbICFlag,          0, iSizeInBool  );
928#endif
929#if H_3D_DIM
930  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
931  {
932    memset( m_dimDeltaDC[i][0], 0, sizeof(Pel ) * m_uiNumPartition );
933    memset( m_dimDeltaDC[i][1], 0, sizeof(Pel ) * m_uiNumPartition );
934  }
935#if H_3D_DIM_DMM
936  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
937  {
938    memset( m_dmmWedgeTabIdx[i], 0, sizeof(UInt) * m_uiNumPartition );
939  }
940#endif
941#if H_3D_DIM_SDC
942  memset( m_pbSDCFlag,            0, sizeof(Bool) * m_uiNumPartition  );
943  memset( m_apSegmentDCOffset[0], 0, sizeof(Pel) * m_uiNumPartition   );
944  memset( m_apSegmentDCOffset[1], 0, sizeof(Pel) * m_uiNumPartition   );
945#endif
946  m_apDmmPredictor[0] = 0;
947  m_apDmmPredictor[1] = 0;
948#endif
949#if H_3D_DBBP
950  memset( m_pbDBBPFlag,         0, iSizeInBool  );
951#endif
952
953  for (UInt ui = 0; ui < m_uiNumPartition; ui++)
954  {
955    m_skipFlag[ui]   = false;
956#if H_3D
957    m_bDISFlag[ui]   = false;
958    m_uiDISType[ui]  = 0;
959#endif
960
961    m_pePartSize[ui] = NUMBER_OF_PART_SIZES;
962    m_pePredMode[ui] = NUMBER_OF_PREDICTION_MODES;
963    m_CUTransquantBypass[ui] = false;
964    m_ChromaQpAdj[ui] = 0;
965
966    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
967    {
968      const RefPicList rpl=RefPicList(i);
969      m_apiMVPIdx[rpl][ui] = -1;
970      m_apiMVPNum[rpl][ui] = -1;
971    }
972#if H_3D
973      m_bDISFlag[ui]    = pcCU->getDISFlag(uiPartOffset+ui);
974      m_uiDISType[ui]   = pcCU->getDISType(uiPartOffset+ui);
975#endif
976#if NH_3D_VSP
977    m_piVSPFlag[ui] = pcCU->m_piVSPFlag[uiPartOffset+ui];
978    m_pDvInfo[ ui ] = pcCU->m_pDvInfo[uiPartOffset+ui];
979#endif
980#if NH_3D_SPIVMP
981    m_pbSPIVMPFlag[ui]=pcCU->m_pbSPIVMPFlag[uiPartOffset+ui];
982#endif
983#if H_3D_ARP
984      m_puhARPW           [ui] = pcCU->getARPW( uiPartOffset+ui );
985#endif
986#if H_3D_IC
987      m_pbICFlag          [ui] = pcCU->m_pbICFlag[uiPartOffset+ui];
988#endif
989#if H_3D_DIM
990      for( Int i = 0; i < DIM_NUM_TYPE; i++ )
991      {
992        m_dimDeltaDC[i][0] [ui] = pcCU->m_dimDeltaDC[i][0] [uiPartOffset+ui];
993        m_dimDeltaDC[i][1] [ui] = pcCU->m_dimDeltaDC[i][1] [uiPartOffset+ui];
994      }
995#if H_3D_DIM_DMM
996      for( Int i = 0; i < DMM_NUM_TYPE; i++ )
997      {
998        m_dmmWedgeTabIdx[i] [ui] = pcCU->m_dmmWedgeTabIdx[i] [uiPartOffset+ui];
999      }
1000#endif
1001#if H_3D_DIM_SDC
1002      m_pbSDCFlag           [ui] = pcCU->m_pbSDCFlag            [ uiPartOffset + ui ];
1003      m_apSegmentDCOffset[0][ui] = pcCU->m_apSegmentDCOffset[0] [ uiPartOffset + ui ];
1004      m_apSegmentDCOffset[1][ui] = pcCU->m_apSegmentDCOffset[1] [ uiPartOffset + ui ];
1005#endif
1006#endif
1007#if H_3D_DBBP
1008      m_pbDBBPFlag[ui]=pcCU->m_pbDBBPFlag[uiPartOffset+ui];
1009#endif
1010  }
1011
1012  const UInt numCoeffY    = uhWidth*uhHeight;
1013  for (UInt ch=0; ch<MAX_NUM_COMPONENT; ch++)
1014  {
1015    const UInt componentShift = m_pcPic->getComponentScaleX(ComponentID(ch)) + m_pcPic->getComponentScaleY(ComponentID(ch));
1016    memset( m_pcTrCoeff[ch],  0, sizeof(TCoeff)*(numCoeffY>>componentShift) );
1017#if ADAPTIVE_QP_SELECTION
1018    memset( m_pcArlCoeff[ch], 0, sizeof(TCoeff)*(numCoeffY>>componentShift) );
1019#endif
1020    memset( m_pcIPCMSample[ch], 0, sizeof(Pel)* (numCoeffY>>componentShift) );
1021  }
1022
1023  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1024  {
1025    m_acCUMvField[i].clearMvField();
1026  }
1027
1028  m_pCtuLeft        = pcCU->getCtuLeft();
1029  m_pCtuAbove       = pcCU->getCtuAbove();
1030  m_pCtuAboveLeft   = pcCU->getCtuAboveLeft();
1031  m_pCtuAboveRight  = pcCU->getCtuAboveRight();
1032
1033  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1034  {
1035    m_apcCUColocated[i] = pcCU->getCUColocated(RefPicList(i));
1036  }
1037}
1038
1039Void TComDataCU::setOutsideCUPart( UInt uiAbsPartIdx, UInt uiDepth )
1040{
1041  const UInt     uiNumPartition = m_uiNumPartition >> (uiDepth << 1);
1042  const UInt     uiSizeInUchar  = sizeof( UChar  ) * uiNumPartition;
1043  const TComSPS &sps            = *(getSlice()->getSPS());
1044  const UChar    uhWidth        = sps.getMaxCUWidth()  >> uiDepth;
1045  const UChar    uhHeight       = sps.getMaxCUHeight() >> uiDepth;
1046  memset( m_puhDepth    + uiAbsPartIdx,     uiDepth,  uiSizeInUchar );
1047  memset( m_puhWidth    + uiAbsPartIdx,     uhWidth,  uiSizeInUchar );
1048  memset( m_puhHeight   + uiAbsPartIdx,     uhHeight, uiSizeInUchar );
1049}
1050
1051// --------------------------------------------------------------------------------------------------------------------
1052// Copy
1053// --------------------------------------------------------------------------------------------------------------------
1054
1055Void TComDataCU::copySubCU( TComDataCU* pcCU, UInt uiAbsPartIdx )
1056{
1057  UInt uiPart = uiAbsPartIdx;
1058
1059  m_pcPic              = pcCU->getPic();
1060  m_pcSlice            = pcCU->getSlice();
1061  m_ctuRsAddr          = pcCU->getCtuRsAddr();
1062  m_absZIdxInCtu       = uiAbsPartIdx;
1063
1064  m_uiCUPelX           = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
1065  m_uiCUPelY           = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
1066
1067  m_skipFlag=pcCU->getSkipFlag()          + uiPart;
1068#if H_3D
1069  m_bDISFlag     = pcCU->getDISFlag()     + uiPart;
1070  m_uiDISType    = pcCU->getDISType()     + uiPart;
1071#endif
1072
1073  m_phQP=pcCU->getQP()                    + uiPart;
1074  m_ChromaQpAdj = pcCU->getChromaQpAdj()  + uiPart;
1075  m_pePartSize = pcCU->getPartitionSize() + uiPart;
1076  m_pePredMode=pcCU->getPredictionMode()  + uiPart;
1077  m_CUTransquantBypass  = pcCU->getCUTransquantBypass()+uiPart;
1078#if NH_3D_NBDV
1079  m_pDvInfo             = pcCU->getDvInfo()           + uiPart;
1080#endif
1081
1082  m_pbMergeFlag         = pcCU->getMergeFlag()        + uiPart;
1083  m_puhMergeIndex       = pcCU->getMergeIndex()       + uiPart;
1084#if NH_3D_VSP
1085  m_piVSPFlag           = pcCU->getVSPFlag()          + uiPart;
1086#endif
1087#if NH_3D_SPIVMP
1088  m_pbSPIVMPFlag        = pcCU->getSPIVMPFlag()          + uiPart;
1089#endif
1090#if H_3D_ARP
1091  m_puhARPW             = pcCU->getARPW()             + uiPart;
1092#endif
1093#if H_3D_IC
1094  m_pbICFlag            = pcCU->getICFlag()           + uiPart;
1095#endif
1096
1097  for (UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
1098  {
1099    m_puhIntraDir[ch]   = pcCU->getIntraDir(ChannelType(ch)) + uiPart;
1100  }
1101
1102  m_puhInterDir         = pcCU->getInterDir()         + uiPart;
1103  m_puhTrIdx            = pcCU->getTransformIdx()     + uiPart;
1104
1105  for(UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
1106  {
1107    m_crossComponentPredictionAlpha[comp] = pcCU->getCrossComponentPredictionAlpha(ComponentID(comp)) + uiPart;
1108    m_puhTransformSkip[comp]              = pcCU->getTransformSkip(ComponentID(comp))                 + uiPart;
1109    m_puhCbf[comp]                        = pcCU->getCbf(ComponentID(comp))                           + uiPart;
1110    m_explicitRdpcmMode[comp]             = pcCU->getExplicitRdpcmMode(ComponentID(comp))             + uiPart;
1111  }
1112#if H_3D_DIM
1113  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
1114  {
1115    m_dimDeltaDC[i][0] = pcCU->getDimDeltaDC( i, 0 ) + uiPart;
1116    m_dimDeltaDC[i][1] = pcCU->getDimDeltaDC( i, 1 ) + uiPart;
1117  }
1118#if H_3D_DIM_DMM
1119  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
1120  {
1121    m_dmmWedgeTabIdx[i] = pcCU->getDmmWedgeTabIdx( i ) + uiPart;
1122  }
1123#endif
1124#if H_3D_DIM_SDC
1125  m_pbSDCFlag               = pcCU->getSDCFlag()              + uiPart;
1126  m_apSegmentDCOffset[0]    = pcCU->getSDCSegmentDCOffset(0)  + uiPart;
1127  m_apSegmentDCOffset[1]    = pcCU->getSDCSegmentDCOffset(1)  + uiPart;
1128#endif 
1129#endif 
1130#if H_3D_DBBP
1131  m_pbDBBPFlag              = pcCU->getDBBPFlag()         + uiPart;
1132#endif
1133
1134  m_puhDepth=pcCU->getDepth()                     + uiPart;
1135  m_puhWidth=pcCU->getWidth()                     + uiPart;
1136  m_puhHeight=pcCU->getHeight()                   + uiPart;
1137
1138  m_pbIPCMFlag         = pcCU->getIPCMFlag()        + uiPart;
1139
1140  m_pCtuAboveLeft      = pcCU->getCtuAboveLeft();
1141  m_pCtuAboveRight     = pcCU->getCtuAboveRight();
1142  m_pCtuAbove          = pcCU->getCtuAbove();
1143  m_pCtuLeft           = pcCU->getCtuLeft();
1144
1145  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1146  {
1147    const RefPicList rpl=RefPicList(i);
1148    m_apcCUColocated[rpl] = pcCU->getCUColocated(rpl);
1149    m_apiMVPIdx[rpl]=pcCU->getMVPIdx(rpl)  + uiPart;
1150    m_apiMVPNum[rpl]=pcCU->getMVPNum(rpl)  + uiPart;
1151  }
1152
1153  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1154  {
1155    const RefPicList rpl=RefPicList(i);
1156    m_acCUMvField[rpl].linkToWithOffset( pcCU->getCUMvField(rpl), uiPart );
1157  }
1158
1159  UInt uiMaxCuWidth=pcCU->getSlice()->getSPS()->getMaxCUWidth();
1160  UInt uiMaxCuHeight=pcCU->getSlice()->getSPS()->getMaxCUHeight();
1161
1162  UInt uiCoffOffset = uiMaxCuWidth*uiMaxCuHeight*uiAbsPartIdx/pcCU->getPic()->getNumPartitionsInCtu();
1163
1164  for (UInt ch=0; ch<MAX_NUM_COMPONENT; ch++)
1165  {
1166    const ComponentID component = ComponentID(ch);
1167    const UInt componentShift   = m_pcPic->getComponentScaleX(component) + m_pcPic->getComponentScaleY(component);
1168    const UInt offset           = uiCoffOffset >> componentShift;
1169    m_pcTrCoeff[ch] = pcCU->getCoeff(component) + offset;
1170#if ADAPTIVE_QP_SELECTION
1171    m_pcArlCoeff[ch] = pcCU->getArlCoeff(component) + offset;
1172#endif
1173    m_pcIPCMSample[ch] = pcCU->getPCMSample(component) + offset;
1174  }
1175}
1176
1177#if NH_3D_NBDV
1178Void TComDataCU::copyDVInfoFrom (TComDataCU* pcCU, UInt uiAbsPartIdx)
1179{
1180  m_pDvInfo            = pcCU->getDvInfo()                + uiAbsPartIdx;
1181}
1182#endif
1183
1184// Copy inter prediction info from the biggest CU
1185Void TComDataCU::copyInterPredInfoFrom    ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList
1186#if NH_3D_NBDV
1187  , Bool bNBDV
1188#endif
1189)
1190{
1191  m_pcPic              = pcCU->getPic();
1192  m_pcSlice            = pcCU->getSlice();
1193  m_ctuRsAddr          = pcCU->getCtuRsAddr();
1194  m_absZIdxInCtu       = uiAbsPartIdx;
1195
1196  Int iRastPartIdx     = g_auiZscanToRaster[uiAbsPartIdx];
1197  m_uiCUPelX           = pcCU->getCUPelX() + m_pcPic->getMinCUWidth ()*( iRastPartIdx % m_pcPic->getNumPartInCtuWidth() );
1198  m_uiCUPelY           = pcCU->getCUPelY() + m_pcPic->getMinCUHeight()*( iRastPartIdx / m_pcPic->getNumPartInCtuWidth() );
1199
1200  m_pCtuAboveLeft      = pcCU->getCtuAboveLeft();
1201  m_pCtuAboveRight     = pcCU->getCtuAboveRight();
1202  m_pCtuAbove          = pcCU->getCtuAbove();
1203  m_pCtuLeft           = pcCU->getCtuLeft();
1204
1205  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1206  {
1207    m_apcCUColocated[i]  = pcCU->getCUColocated(RefPicList(i));
1208  }
1209
1210  m_skipFlag           = pcCU->getSkipFlag ()             + uiAbsPartIdx;
1211#if H_3D
1212  m_bDISFlag           = pcCU->getDISFlag ()              + uiAbsPartIdx;
1213  m_uiDISType          = pcCU->getDISType()               + uiAbsPartIdx;
1214#endif
1215
1216  m_pePartSize         = pcCU->getPartitionSize ()        + uiAbsPartIdx;
1217#if NH_3D_NBDV
1218  if(bNBDV == true)
1219  {
1220    m_puhWidth           = pcCU->getWidth ()                + uiAbsPartIdx;
1221    m_puhHeight          = pcCU->getHeight()                + uiAbsPartIdx;
1222    m_puhDepth           = pcCU->getDepth ()                + uiAbsPartIdx;
1223  }
1224  else
1225  {
1226#endif
1227  m_pePredMode         = pcCU->getPredictionMode()        + uiAbsPartIdx;
1228  m_ChromaQpAdj        = pcCU->getChromaQpAdj()           + uiAbsPartIdx;
1229  m_CUTransquantBypass = pcCU->getCUTransquantBypass()    + uiAbsPartIdx;
1230  m_puhInterDir        = pcCU->getInterDir      ()        + uiAbsPartIdx;
1231
1232  m_puhDepth           = pcCU->getDepth ()                + uiAbsPartIdx;
1233  m_puhWidth           = pcCU->getWidth ()                + uiAbsPartIdx;
1234  m_puhHeight          = pcCU->getHeight()                + uiAbsPartIdx;
1235
1236  m_pbMergeFlag        = pcCU->getMergeFlag()             + uiAbsPartIdx;
1237  m_puhMergeIndex      = pcCU->getMergeIndex()            + uiAbsPartIdx;
1238#if NH_3D_VSP
1239  m_piVSPFlag          = pcCU->getVSPFlag()               + uiAbsPartIdx;
1240  m_pDvInfo            = pcCU->getDvInfo()                + uiAbsPartIdx;
1241#endif
1242#if NH_3D_SPIVMP
1243  m_pbSPIVMPFlag       = pcCU->getSPIVMPFlag()            + uiAbsPartIdx;
1244#endif
1245
1246  m_apiMVPIdx[eRefPicList] = pcCU->getMVPIdx(eRefPicList) + uiAbsPartIdx;
1247  m_apiMVPNum[eRefPicList] = pcCU->getMVPNum(eRefPicList) + uiAbsPartIdx;
1248#if H_3D_ARP
1249  m_puhARPW            = pcCU->getARPW()                  + uiAbsPartIdx;
1250#endif   
1251#if H_3D_DBBP
1252  m_pbDBBPFlag       = pcCU->getDBBPFlag()              + uiAbsPartIdx;
1253#endif
1254
1255  m_acCUMvField[ eRefPicList ].linkToWithOffset( pcCU->getCUMvField(eRefPicList), uiAbsPartIdx );
1256#if NH_3D_NBDV
1257  }
1258#endif
1259#if H_3D_IC
1260  m_pbICFlag           = pcCU->getICFlag()                + uiAbsPartIdx;
1261#endif
1262
1263}
1264
1265// Copy small CU to bigger CU.
1266// One of quarter parts overwritten by predicted sub part.
1267Void TComDataCU::copyPartFrom( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth )
1268{
1269  assert( uiPartUnitIdx<4 );
1270
1271  m_dTotalCost         += pcCU->getTotalCost();
1272  m_uiTotalDistortion  += pcCU->getTotalDistortion();
1273  m_uiTotalBits        += pcCU->getTotalBits();
1274
1275  UInt uiOffset         = pcCU->getTotalNumPart()*uiPartUnitIdx;
1276  const UInt numValidComp=pcCU->getPic()->getNumberValidComponents();
1277  const UInt numValidChan=pcCU->getPic()->getChromaFormat()==CHROMA_400 ? 1:2;
1278
1279  UInt uiNumPartition = pcCU->getTotalNumPart();
1280  Int iSizeInUchar  = sizeof( UChar ) * uiNumPartition;
1281  Int iSizeInBool   = sizeof( Bool  ) * uiNumPartition;
1282
1283  Int sizeInChar  = sizeof( Char ) * uiNumPartition;
1284  memcpy( m_skipFlag   + uiOffset, pcCU->getSkipFlag(),       sizeof( *m_skipFlag )   * uiNumPartition );
1285#if H_3D
1286  memcpy( m_bDISFlag   + uiOffset, pcCU->getDISFlag(),       sizeof( *m_bDISFlag )   * uiNumPartition );
1287  memcpy( m_uiDISType  + uiOffset, pcCU->getDISType(),       sizeof( *m_uiDISType )  * uiNumPartition);
1288#endif
1289  memcpy( m_phQP       + uiOffset, pcCU->getQP(),             sizeInChar                        );
1290  memcpy( m_pePartSize + uiOffset, pcCU->getPartitionSize(),  sizeof( *m_pePartSize ) * uiNumPartition );
1291  memcpy( m_pePredMode + uiOffset, pcCU->getPredictionMode(), sizeof( *m_pePredMode ) * uiNumPartition );
1292  memcpy( m_ChromaQpAdj + uiOffset, pcCU->getChromaQpAdj(),   sizeof( *m_ChromaQpAdj ) * uiNumPartition );
1293  memcpy( m_CUTransquantBypass + uiOffset, pcCU->getCUTransquantBypass(), sizeof( *m_CUTransquantBypass ) * uiNumPartition );
1294  memcpy( m_pbMergeFlag         + uiOffset, pcCU->getMergeFlag(),         iSizeInBool  );
1295  memcpy( m_puhMergeIndex       + uiOffset, pcCU->getMergeIndex(),        iSizeInUchar );
1296#if NH_3D_VSP
1297  memcpy( m_piVSPFlag           + uiOffset, pcCU->getVSPFlag(),           sizeof( Char ) * uiNumPartition );
1298  memcpy( m_pDvInfo             + uiOffset, pcCU->getDvInfo(),            sizeof( *m_pDvInfo ) * uiNumPartition );
1299#endif
1300#if NH_3D_SPIVMP
1301  memcpy( m_pbSPIVMPFlag        + uiOffset, pcCU->getSPIVMPFlag(),        sizeof( Bool ) * uiNumPartition );
1302#endif
1303
1304  for (UInt ch=0; ch<numValidChan; ch++)
1305  {
1306    memcpy( m_puhIntraDir[ch]   + uiOffset, pcCU->getIntraDir(ChannelType(ch)), iSizeInUchar );
1307  }
1308
1309  memcpy( m_puhInterDir         + uiOffset, pcCU->getInterDir(),          iSizeInUchar );
1310  memcpy( m_puhTrIdx            + uiOffset, pcCU->getTransformIdx(),      iSizeInUchar );
1311
1312  for(UInt comp=0; comp<numValidComp; comp++)
1313  {
1314    memcpy( m_crossComponentPredictionAlpha[comp] + uiOffset, pcCU->getCrossComponentPredictionAlpha(ComponentID(comp)), iSizeInUchar );
1315    memcpy( m_puhTransformSkip[comp]              + uiOffset, pcCU->getTransformSkip(ComponentID(comp))                , iSizeInUchar );
1316    memcpy( m_puhCbf[comp]                        + uiOffset, pcCU->getCbf(ComponentID(comp))                          , iSizeInUchar );
1317    memcpy( m_explicitRdpcmMode[comp]             + uiOffset, pcCU->getExplicitRdpcmMode(ComponentID(comp))            , iSizeInUchar );
1318  }
1319#if H_3D_DIM
1320  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
1321  {
1322    memcpy( m_dimDeltaDC[i][0] + uiOffset, pcCU->getDimDeltaDC( i, 0 ), sizeof(Pel ) * uiNumPartition );
1323    memcpy( m_dimDeltaDC[i][1] + uiOffset, pcCU->getDimDeltaDC( i, 1 ), sizeof(Pel ) * uiNumPartition );
1324  }
1325#if H_3D_DIM_DMM
1326  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
1327  {
1328    memcpy( m_dmmWedgeTabIdx[i] + uiOffset, pcCU->getDmmWedgeTabIdx( i ), sizeof(UInt) * uiNumPartition );
1329  }
1330#endif
1331#if H_3D_DIM_SDC
1332  memcpy( m_pbSDCFlag             + uiOffset, pcCU->getSDCFlag(),             iSizeInBool  );
1333  memcpy( m_apSegmentDCOffset[0]  + uiOffset, pcCU->getSDCSegmentDCOffset(0), sizeof( Pel ) * uiNumPartition);
1334  memcpy( m_apSegmentDCOffset[1]  + uiOffset, pcCU->getSDCSegmentDCOffset(1), sizeof( Pel ) * uiNumPartition);
1335#endif
1336#endif
1337#if H_3D_DBBP
1338  memcpy( m_pbDBBPFlag          + uiOffset, pcCU->getDBBPFlag(),          iSizeInBool  );
1339#endif
1340
1341  memcpy( m_puhDepth  + uiOffset, pcCU->getDepth(),  iSizeInUchar );
1342  memcpy( m_puhWidth  + uiOffset, pcCU->getWidth(),  iSizeInUchar );
1343  memcpy( m_puhHeight + uiOffset, pcCU->getHeight(), iSizeInUchar );
1344
1345  memcpy( m_pbIPCMFlag + uiOffset, pcCU->getIPCMFlag(), iSizeInBool );
1346
1347  m_pCtuAboveLeft      = pcCU->getCtuAboveLeft();
1348  m_pCtuAboveRight     = pcCU->getCtuAboveRight();
1349  m_pCtuAbove          = pcCU->getCtuAbove();
1350  m_pCtuLeft           = pcCU->getCtuLeft();
1351
1352  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1353  {
1354    const RefPicList rpl=RefPicList(i);
1355    memcpy( m_apiMVPIdx[rpl] + uiOffset, pcCU->getMVPIdx(rpl), iSizeInUchar );
1356    memcpy( m_apiMVPNum[rpl] + uiOffset, pcCU->getMVPNum(rpl), iSizeInUchar );
1357    m_apcCUColocated[rpl] = pcCU->getCUColocated(rpl);
1358  }
1359
1360  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1361  {
1362    const RefPicList rpl=RefPicList(i);
1363    m_acCUMvField[rpl].copyFrom( pcCU->getCUMvField( rpl ), pcCU->getTotalNumPart(), uiOffset );
1364  }
1365
1366  const UInt numCoeffY = (pcCU->getSlice()->getSPS()->getMaxCUWidth()*pcCU->getSlice()->getSPS()->getMaxCUHeight()) >> (uiDepth<<1);
1367  const UInt offsetY   = uiPartUnitIdx*numCoeffY;
1368  for (UInt ch=0; ch<numValidComp; ch++)
1369  {
1370    const ComponentID component = ComponentID(ch);
1371    const UInt componentShift   = m_pcPic->getComponentScaleX(component) + m_pcPic->getComponentScaleY(component);
1372    const UInt offset           = offsetY>>componentShift;
1373    memcpy( m_pcTrCoeff [ch] + offset, pcCU->getCoeff(component),    sizeof(TCoeff)*(numCoeffY>>componentShift) );
1374#if ADAPTIVE_QP_SELECTION
1375    memcpy( m_pcArlCoeff[ch] + offset, pcCU->getArlCoeff(component), sizeof(TCoeff)*(numCoeffY>>componentShift) );
1376#endif
1377    memcpy( m_pcIPCMSample[ch] + offset, pcCU->getPCMSample(component), sizeof(Pel)*(numCoeffY>>componentShift) );
1378  }
1379
1380#if H_3D_ARP
1381  memcpy( m_puhARPW             + uiOffset, pcCU->getARPW(),              iSizeInUchar );
1382#endif
1383#if H_3D_IC
1384  memcpy( m_pbICFlag            + uiOffset, pcCU->getICFlag(),            iSizeInBool );
1385#endif
1386
1387  m_uiTotalBins += pcCU->getTotalBins();
1388}
1389
1390// Copy current predicted part to a CU in picture.
1391// It is used to predict for next part
1392Void TComDataCU::copyToPic( UChar uhDepth )
1393{
1394  TComDataCU* pCtu = m_pcPic->getCtu( m_ctuRsAddr );
1395  const UInt numValidComp=pCtu->getPic()->getNumberValidComponents();
1396  const UInt numValidChan=pCtu->getPic()->getChromaFormat()==CHROMA_400 ? 1:2;
1397
1398  pCtu->getTotalCost()       = m_dTotalCost;
1399  pCtu->getTotalDistortion() = m_uiTotalDistortion;
1400  pCtu->getTotalBits()       = m_uiTotalBits;
1401
1402  Int iSizeInUchar  = sizeof( UChar ) * m_uiNumPartition;
1403  Int iSizeInBool   = sizeof( Bool  ) * m_uiNumPartition;
1404  Int sizeInChar  = sizeof( Char ) * m_uiNumPartition;
1405
1406  memcpy( pCtu->getSkipFlag() + m_absZIdxInCtu, m_skipFlag, sizeof( *m_skipFlag ) * m_uiNumPartition );
1407#if H_3D
1408  memcpy( rpcCU->getDISFlag()  + m_uiAbsIdxInLCU, m_bDISFlag,    sizeof( *m_bDISFlag )  * m_uiNumPartition );
1409  memcpy( rpcCU->getDISType()  + m_uiAbsIdxInLCU, m_uiDISType,   sizeof( *m_uiDISType ) * m_uiNumPartition );
1410#endif
1411
1412  memcpy( pCtu->getQP() + m_absZIdxInCtu, m_phQP, sizeInChar  );
1413#if NH_3D_NBDV
1414  memcpy( pCtu->getDvInfo() + m_absZIdxInCtu, m_pDvInfo, sizeof(* m_pDvInfo) * m_uiNumPartition );
1415#endif
1416
1417  memcpy( pCtu->getPartitionSize()  + m_absZIdxInCtu, m_pePartSize, sizeof( *m_pePartSize ) * m_uiNumPartition );
1418  memcpy( pCtu->getPredictionMode() + m_absZIdxInCtu, m_pePredMode, sizeof( *m_pePredMode ) * m_uiNumPartition );
1419  memcpy( pCtu->getChromaQpAdj() + m_absZIdxInCtu, m_ChromaQpAdj, sizeof( *m_ChromaQpAdj ) * m_uiNumPartition );
1420  memcpy( pCtu->getCUTransquantBypass()+ m_absZIdxInCtu, m_CUTransquantBypass, sizeof( *m_CUTransquantBypass ) * m_uiNumPartition );
1421  memcpy( pCtu->getMergeFlag()         + m_absZIdxInCtu, m_pbMergeFlag,         iSizeInBool  );
1422  memcpy( pCtu->getMergeIndex()        + m_absZIdxInCtu, m_puhMergeIndex,       iSizeInUchar );
1423#if NH_3D_VSP
1424  memcpy( pCtu->getVSPFlag()           + m_absZIdxInCtu, m_piVSPFlag,           sizeof( Char ) * m_uiNumPartition );
1425#endif
1426#if NH_3D_SPIVMP
1427  memcpy( pCtu->getSPIVMPFlag()        + m_absZIdxInCtu, m_pbSPIVMPFlag,        sizeof( Bool ) * m_uiNumPartition );
1428#endif
1429
1430for (UInt ch=0; ch<numValidChan; ch++)
1431  {
1432    memcpy( pCtu->getIntraDir(ChannelType(ch)) + m_absZIdxInCtu, m_puhIntraDir[ch], iSizeInUchar);
1433  }
1434
1435  memcpy( pCtu->getInterDir()          + m_absZIdxInCtu, m_puhInterDir,         iSizeInUchar );
1436  memcpy( pCtu->getTransformIdx()      + m_absZIdxInCtu, m_puhTrIdx,            iSizeInUchar );
1437
1438  for(UInt comp=0; comp<numValidComp; comp++)
1439  {
1440    memcpy( pCtu->getCrossComponentPredictionAlpha(ComponentID(comp)) + m_absZIdxInCtu, m_crossComponentPredictionAlpha[comp], iSizeInUchar );
1441    memcpy( pCtu->getTransformSkip(ComponentID(comp))                 + m_absZIdxInCtu, m_puhTransformSkip[comp],              iSizeInUchar );
1442    memcpy( pCtu->getCbf(ComponentID(comp))                           + m_absZIdxInCtu, m_puhCbf[comp],                        iSizeInUchar );
1443    memcpy( pCtu->getExplicitRdpcmMode(ComponentID(comp))             + m_absZIdxInCtu, m_explicitRdpcmMode[comp],             iSizeInUchar );
1444  }
1445
1446#if H_3D_DIM
1447  for( Int i = 0; i < DIM_NUM_TYPE; i++ )
1448  {
1449    memcpy( rpcCU->getDimDeltaDC( i, 0 ) + m_uiAbsIdxInLCU, m_dimDeltaDC[i][0], sizeof(Pel ) * m_uiNumPartition );
1450    memcpy( rpcCU->getDimDeltaDC( i, 1 ) + m_uiAbsIdxInLCU, m_dimDeltaDC[i][1], sizeof(Pel ) * m_uiNumPartition );
1451  }
1452#if H_3D_DIM_DMM
1453  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
1454  {
1455    memcpy( rpcCU->getDmmWedgeTabIdx( i ) + m_uiAbsIdxInLCU, m_dmmWedgeTabIdx[i], sizeof(UInt) * m_uiNumPartition );
1456  }
1457#endif
1458#if H_3D_DIM_SDC
1459  memcpy( rpcCU->getSDCFlag()             + m_uiAbsIdxInLCU, m_pbSDCFlag,      iSizeInBool  );
1460  memcpy( rpcCU->getSDCSegmentDCOffset(0) + m_uiAbsIdxInLCU, m_apSegmentDCOffset[0], sizeof( Pel ) * m_uiNumPartition);
1461  memcpy( rpcCU->getSDCSegmentDCOffset(1) + m_uiAbsIdxInLCU, m_apSegmentDCOffset[1], sizeof( Pel ) * m_uiNumPartition);
1462#endif
1463#endif
1464#if H_3D_DBBP
1465  memcpy( rpcCU->getDBBPFlag()          + m_uiAbsIdxInLCU, m_pbDBBPFlag,          iSizeInBool  );
1466#endif
1467
1468  memcpy( pCtu->getDepth()  + m_absZIdxInCtu, m_puhDepth,  iSizeInUchar );
1469  memcpy( pCtu->getWidth()  + m_absZIdxInCtu, m_puhWidth,  iSizeInUchar );
1470  memcpy( pCtu->getHeight() + m_absZIdxInCtu, m_puhHeight, iSizeInUchar );
1471
1472  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1473  {
1474    const RefPicList rpl=RefPicList(i);
1475    memcpy( pCtu->getMVPIdx(rpl) + m_absZIdxInCtu, m_apiMVPIdx[rpl], iSizeInUchar );
1476    memcpy( pCtu->getMVPNum(rpl) + m_absZIdxInCtu, m_apiMVPNum[rpl], iSizeInUchar );
1477  }
1478
1479  for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
1480  {
1481    const RefPicList rpl=RefPicList(i);
1482    m_acCUMvField[rpl].copyTo( pCtu->getCUMvField( rpl ), m_absZIdxInCtu );
1483  }
1484
1485  memcpy( pCtu->getIPCMFlag() + m_absZIdxInCtu, m_pbIPCMFlag,         iSizeInBool  );
1486
1487  const UInt numCoeffY    = (pCtu->getSlice()->getSPS()->getMaxCUWidth()*pCtu->getSlice()->getSPS()->getMaxCUHeight())>>(uhDepth<<1);
1488  const UInt offsetY      = m_absZIdxInCtu*m_pcPic->getMinCUWidth()*m_pcPic->getMinCUHeight();
1489  for (UInt comp=0; comp<numValidComp; comp++)
1490  {
1491    const ComponentID component = ComponentID(comp);
1492    const UInt componentShift   = m_pcPic->getComponentScaleX(component) + m_pcPic->getComponentScaleY(component);
1493    memcpy( pCtu->getCoeff(component)   + (offsetY>>componentShift), m_pcTrCoeff[component], sizeof(TCoeff)*(numCoeffY>>componentShift) );
1494#if ADAPTIVE_QP_SELECTION
1495    memcpy( pCtu->getArlCoeff(component) + (offsetY>>componentShift), m_pcArlCoeff[component], sizeof(TCoeff)*(numCoeffY>>componentShift) );
1496#endif
1497    memcpy( pCtu->getPCMSample(component) + (offsetY>>componentShift), m_pcIPCMSample[component], sizeof(Pel)*(numCoeffY>>componentShift) );
1498  }
1499
1500#if H_3D_ARP
1501  memcpy( rpcCU->getARPW()             + m_uiAbsIdxInLCU, m_puhARPW,             iSizeInUchar );
1502#endif
1503#if H_3D_IC
1504  memcpy( rpcCU->getICFlag()           + m_uiAbsIdxInLCU, m_pbICFlag,            iSizeInBool );
1505#endif
1506
1507  pCtu->getTotalBins() = m_uiTotalBins;
1508}
1509
1510#if H_3D
1511  memcpy( rpcCU->getDISFlag()  + uiPartOffset, m_bDISFlag,    sizeof( *m_bDISFlag )   * uiQNumPart );
1512  memcpy( rpcCU->getDISType()  + uiPartOffset, m_uiDISType,   sizeof( *m_uiDISType )  * uiQNumPart );
1513#endif
1514
1515#if H_3D_SPIVMP
1516  memcpy( rpcCU->getSPIVMPFlag()        + uiPartOffset, m_pbSPIVMPFlag,        sizeof(Bool) * uiQNumPart );
1517#endif
1518#if H_3D_DIM
1519  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
1520  {
1521    memcpy( rpcCU->getDimDeltaDC( i, 0 ) + uiPartOffset, m_dimDeltaDC[i][0], sizeof(Pel ) * uiQNumPart );
1522    memcpy( rpcCU->getDimDeltaDC( i, 1 ) + uiPartOffset, m_dimDeltaDC[i][1], sizeof(Pel ) * uiQNumPart );
1523  }
1524#if H_3D_DIM_DMM
1525  for( Int i = 0; i < DMM_NUM_TYPE; i++ )
1526  {
1527    memcpy( rpcCU->getDmmWedgeTabIdx( i ) + uiPartOffset, m_dmmWedgeTabIdx[i], sizeof(UInt) * uiQNumPart );
1528  }
1529#endif
1530#if H_3D_DIM_SDC
1531  memcpy( rpcCU->getSDCFlag()             + uiPartOffset, m_pbSDCFlag,      iSizeInBool  );
1532  memcpy( rpcCU->getSDCSegmentDCOffset(0) + uiPartOffset, m_apSegmentDCOffset[0], sizeof( Pel ) * uiQNumPart);
1533  memcpy( rpcCU->getSDCSegmentDCOffset(1) + uiPartOffset, m_apSegmentDCOffset[1], sizeof( Pel ) * uiQNumPart);
1534#endif
1535#endif
1536#if H_3D_DBBP
1537  memcpy( rpcCU->getDBBPFlag()          + uiPartOffset, m_pbDBBPFlag,          iSizeInBool  );
1538#endif
1539#if H_3D_ARP
1540  memcpy( rpcCU->getARPW()             + uiPartOffset, m_puhARPW,             iSizeInUchar );
1541#endif
1542#if H_3D_IC
1543  memcpy( rpcCU->getICFlag()           + uiPartOffset, m_pbICFlag,            iSizeInBool );
1544#endif
1545
1546
1547
1548// --------------------------------------------------------------------------------------------------------------------
1549// Other public functions
1550// --------------------------------------------------------------------------------------------------------------------
1551
1552TComDataCU* TComDataCU::getPULeft( UInt& uiLPartUnitIdx,
1553                                   UInt uiCurrPartUnitIdx,
1554                                   Bool bEnforceSliceRestriction,
1555                                   Bool bEnforceTileRestriction )
1556{
1557  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
1558  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[m_absZIdxInCtu];
1559  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
1560
1561  if ( !RasterAddress::isZeroCol( uiAbsPartIdx, numPartInCtuWidth ) )
1562  {
1563    uiLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx - 1 ];
1564    if ( RasterAddress::isEqualCol( uiAbsPartIdx, uiAbsZorderCUIdx, numPartInCtuWidth ) )
1565    {
1566      return m_pcPic->getCtu( getCtuRsAddr() );
1567    }
1568    else
1569    {
1570      uiLPartUnitIdx -= m_absZIdxInCtu;
1571      return this;
1572    }
1573  }
1574
1575  uiLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx + numPartInCtuWidth - 1 ];
1576  if ( (bEnforceSliceRestriction && !CUIsFromSameSlice(m_pCtuLeft)) || (bEnforceTileRestriction && !CUIsFromSameTile(m_pCtuLeft)) )
1577  {
1578    return NULL;
1579  }
1580  return m_pCtuLeft;
1581}
1582
1583
1584TComDataCU* TComDataCU::getPUAbove( UInt& uiAPartUnitIdx,
1585                                    UInt uiCurrPartUnitIdx,
1586                                    Bool bEnforceSliceRestriction,
1587                                    Bool planarAtCtuBoundary,
1588                                    Bool bEnforceTileRestriction )
1589{
1590  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
1591  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[m_absZIdxInCtu];
1592  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
1593
1594  if ( !RasterAddress::isZeroRow( uiAbsPartIdx, numPartInCtuWidth ) )
1595  {
1596    uiAPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx - numPartInCtuWidth ];
1597    if ( RasterAddress::isEqualRow( uiAbsPartIdx, uiAbsZorderCUIdx, numPartInCtuWidth ) )
1598    {
1599      return m_pcPic->getCtu( getCtuRsAddr() );
1600    }
1601    else
1602    {
1603      uiAPartUnitIdx -= m_absZIdxInCtu;
1604      return this;
1605    }
1606  }
1607
1608  if(planarAtCtuBoundary)
1609  {
1610    return NULL;
1611  }
1612
1613  uiAPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx + m_pcPic->getNumPartitionsInCtu() - numPartInCtuWidth ];
1614
1615  if ( (bEnforceSliceRestriction && !CUIsFromSameSlice(m_pCtuAbove)) || (bEnforceTileRestriction && !CUIsFromSameTile(m_pCtuAbove)) )
1616  {
1617    return NULL;
1618  }
1619  return m_pCtuAbove;
1620}
1621
1622TComDataCU* TComDataCU::getPUAboveLeft( UInt& uiALPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction )
1623{
1624  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
1625  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[m_absZIdxInCtu];
1626  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
1627
1628  if ( !RasterAddress::isZeroCol( uiAbsPartIdx, numPartInCtuWidth ) )
1629  {
1630    if ( !RasterAddress::isZeroRow( uiAbsPartIdx, numPartInCtuWidth ) )
1631    {
1632      uiALPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx - numPartInCtuWidth - 1 ];
1633      if ( RasterAddress::isEqualRowOrCol( uiAbsPartIdx, uiAbsZorderCUIdx, numPartInCtuWidth ) )
1634      {
1635        return m_pcPic->getCtu( getCtuRsAddr() );
1636      }
1637      else
1638      {
1639        uiALPartUnitIdx -= m_absZIdxInCtu;
1640        return this;
1641      }
1642    }
1643    uiALPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx + getPic()->getNumPartitionsInCtu() - numPartInCtuWidth - 1 ];
1644    if ( bEnforceSliceRestriction && !CUIsFromSameSliceAndTile(m_pCtuAbove) )
1645    {
1646      return NULL;
1647    }
1648    return m_pCtuAbove;
1649  }
1650
1651  if ( !RasterAddress::isZeroRow( uiAbsPartIdx, numPartInCtuWidth ) )
1652  {
1653    uiALPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx - 1 ];
1654    if ( bEnforceSliceRestriction && !CUIsFromSameSliceAndTile(m_pCtuLeft) )
1655    {
1656      return NULL;
1657    }
1658    return m_pCtuLeft;
1659  }
1660
1661  uiALPartUnitIdx = g_auiRasterToZscan[ m_pcPic->getNumPartitionsInCtu() - 1 ];
1662  if ( bEnforceSliceRestriction && !CUIsFromSameSliceAndTile(m_pCtuAboveLeft) )
1663  {
1664    return NULL;
1665  }
1666  return m_pCtuAboveLeft;
1667}
1668
1669TComDataCU* TComDataCU::getPUBelowLeft(UInt& uiBLPartUnitIdx,  UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset, Bool bEnforceSliceRestriction)
1670{
1671  UInt uiAbsPartIdxLB     = g_auiZscanToRaster[uiCurrPartUnitIdx];
1672  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
1673  UInt uiAbsZorderCUIdxLB = g_auiZscanToRaster[ m_absZIdxInCtu ] + ((m_puhHeight[0] / m_pcPic->getMinCUHeight()) - 1)*numPartInCtuWidth;
1674
1675  if( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxLB] + (m_pcPic->getPicSym()->getMinCUHeight() * uiPartUnitOffset)) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples())
1676  {
1677    uiBLPartUnitIdx = MAX_UINT;
1678    return NULL;
1679  }
1680
1681  if ( RasterAddress::lessThanRow( uiAbsPartIdxLB, m_pcPic->getNumPartInCtuHeight() - uiPartUnitOffset, numPartInCtuWidth ) )
1682  {
1683    if ( !RasterAddress::isZeroCol( uiAbsPartIdxLB, numPartInCtuWidth ) )
1684    {
1685      if ( uiCurrPartUnitIdx > g_auiRasterToZscan[ uiAbsPartIdxLB + uiPartUnitOffset * numPartInCtuWidth - 1 ] )
1686      {
1687        uiBLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxLB + uiPartUnitOffset * numPartInCtuWidth - 1 ];
1688        if ( RasterAddress::isEqualRowOrCol( uiAbsPartIdxLB, uiAbsZorderCUIdxLB, numPartInCtuWidth ) )
1689        {
1690          return m_pcPic->getCtu( getCtuRsAddr() );
1691        }
1692        else
1693        {
1694          uiBLPartUnitIdx -= m_absZIdxInCtu;
1695          return this;
1696        }
1697      }
1698      uiBLPartUnitIdx = MAX_UINT;
1699      return NULL;
1700    }
1701    uiBLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxLB + (1+uiPartUnitOffset) * numPartInCtuWidth - 1 ];
1702    if ( bEnforceSliceRestriction && !CUIsFromSameSliceAndTile(m_pCtuLeft) )
1703    {
1704      return NULL;
1705    }
1706    return m_pCtuLeft;
1707  }
1708
1709  uiBLPartUnitIdx = MAX_UINT;
1710  return NULL;
1711}
1712
1713TComDataCU* TComDataCU::getPUAboveRight(UInt&  uiARPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset, Bool bEnforceSliceRestriction)
1714{
1715  UInt uiAbsPartIdxRT     = g_auiZscanToRaster[uiCurrPartUnitIdx];
1716  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[ m_absZIdxInCtu ] + (m_puhWidth[0] / m_pcPic->getMinCUWidth()) - 1;
1717  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
1718
1719  if( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxRT] + (m_pcPic->getPicSym()->getMinCUHeight() * uiPartUnitOffset)) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )
1720  {
1721    uiARPartUnitIdx = MAX_UINT;
1722    return NULL;
1723  }
1724
1725  if ( RasterAddress::lessThanCol( uiAbsPartIdxRT, numPartInCtuWidth - uiPartUnitOffset, numPartInCtuWidth ) )
1726  {
1727    if ( !RasterAddress::isZeroRow( uiAbsPartIdxRT, numPartInCtuWidth ) )
1728    {
1729      if ( uiCurrPartUnitIdx > g_auiRasterToZscan[ uiAbsPartIdxRT - numPartInCtuWidth + uiPartUnitOffset ] )
1730      {
1731        uiARPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxRT - numPartInCtuWidth + uiPartUnitOffset ];
1732        if ( RasterAddress::isEqualRowOrCol( uiAbsPartIdxRT, uiAbsZorderCUIdx, numPartInCtuWidth ) )
1733        {
1734          return m_pcPic->getCtu( getCtuRsAddr() );
1735        }
1736        else
1737        {
1738          uiARPartUnitIdx -= m_absZIdxInCtu;
1739          return this;
1740        }
1741      }
1742      uiARPartUnitIdx = MAX_UINT;
1743      return NULL;
1744    }
1745
1746    uiARPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxRT + m_pcPic->getNumPartitionsInCtu() - numPartInCtuWidth + uiPartUnitOffset ];
1747    if ( bEnforceSliceRestriction && !CUIsFromSameSliceAndTile(m_pCtuAbove) )
1748    {
1749      return NULL;
1750    }
1751    return m_pCtuAbove;
1752  }
1753
1754  if ( !RasterAddress::isZeroRow( uiAbsPartIdxRT, numPartInCtuWidth ) )
1755  {
1756    uiARPartUnitIdx = MAX_UINT;
1757    return NULL;
1758  }
1759
1760  uiARPartUnitIdx = g_auiRasterToZscan[ m_pcPic->getNumPartitionsInCtu() - numPartInCtuWidth + uiPartUnitOffset-1 ];
1761  if ( bEnforceSliceRestriction && !CUIsFromSameSliceAndTile(m_pCtuAboveRight) )
1762  {
1763    return NULL;
1764  }
1765  return m_pCtuAboveRight;
1766}
1767
1768/** Get left QpMinCu
1769*\param   uiLPartUnitIdx
1770*\param   uiCurrAbsIdxInCtu
1771*\returns TComDataCU*   point of TComDataCU of left QpMinCu
1772*/
1773TComDataCU* TComDataCU::getQpMinCuLeft( UInt& uiLPartUnitIdx, UInt uiCurrAbsIdxInCtu )
1774{
1775  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
1776  const UInt maxCUDepth        = getSlice()->getSPS()->getMaxTotalCUDepth();
1777  const UInt maxCuDQPDepth     = getSlice()->getPPS()->getMaxCuDQPDepth();
1778  const UInt doubleDepthDifference = ((maxCUDepth - maxCuDQPDepth)<<1);
1779  UInt absZorderQpMinCUIdx = (uiCurrAbsIdxInCtu>>doubleDepthDifference)<<doubleDepthDifference;
1780  UInt absRorderQpMinCUIdx = g_auiZscanToRaster[absZorderQpMinCUIdx];
1781
1782  // check for left CTU boundary
1783  if ( RasterAddress::isZeroCol(absRorderQpMinCUIdx, numPartInCtuWidth) )
1784  {
1785    return NULL;
1786  }
1787
1788  // get index of left-CU relative to top-left corner of current quantization group
1789  uiLPartUnitIdx = g_auiRasterToZscan[absRorderQpMinCUIdx - 1];
1790
1791  // return pointer to current CTU
1792  return m_pcPic->getCtu( getCtuRsAddr() );
1793}
1794
1795/** Get Above QpMinCu
1796*\param   uiAPartUnitIdx
1797*\param   uiCurrAbsIdxInCtu
1798*\returns TComDataCU*   point of TComDataCU of above QpMinCu
1799*/
1800TComDataCU* TComDataCU::getQpMinCuAbove( UInt& uiAPartUnitIdx, UInt uiCurrAbsIdxInCtu )
1801{
1802  const UInt numPartInCtuWidth = m_pcPic->getNumPartInCtuWidth();
1803  const UInt maxCUDepth        = getSlice()->getSPS()->getMaxTotalCUDepth();
1804  const UInt maxCuDQPDepth     = getSlice()->getPPS()->getMaxCuDQPDepth();
1805  const UInt doubleDepthDifference = ((maxCUDepth - maxCuDQPDepth)<<1);
1806  UInt absZorderQpMinCUIdx = (uiCurrAbsIdxInCtu>>doubleDepthDifference)<<doubleDepthDifference;
1807  UInt absRorderQpMinCUIdx = g_auiZscanToRaster[absZorderQpMinCUIdx];
1808
1809  // check for top CTU boundary
1810  if ( RasterAddress::isZeroRow( absRorderQpMinCUIdx, numPartInCtuWidth) )
1811  {
1812    return NULL;
1813  }
1814
1815  // get index of top-CU relative to top-left corner of current quantization group
1816  uiAPartUnitIdx = g_auiRasterToZscan[absRorderQpMinCUIdx - numPartInCtuWidth];
1817
1818  // return pointer to current CTU
1819  return m_pcPic->getCtu( getCtuRsAddr() );
1820}
1821
1822
1823
1824/** Get reference QP from left QpMinCu or latest coded QP
1825*\param   uiCurrAbsIdxInCtu
1826*\returns Char   reference QP value
1827*/
1828Char TComDataCU::getRefQP( UInt uiCurrAbsIdxInCtu )
1829{
1830  UInt lPartIdx = MAX_UINT;
1831  UInt aPartIdx = MAX_UINT;
1832  TComDataCU* cULeft  = getQpMinCuLeft ( lPartIdx, m_absZIdxInCtu + uiCurrAbsIdxInCtu );
1833  TComDataCU* cUAbove = getQpMinCuAbove( aPartIdx, m_absZIdxInCtu + uiCurrAbsIdxInCtu );
1834  return (((cULeft? cULeft->getQP( lPartIdx ): getLastCodedQP( uiCurrAbsIdxInCtu )) + (cUAbove? cUAbove->getQP( aPartIdx ): getLastCodedQP( uiCurrAbsIdxInCtu )) + 1) >> 1);
1835}
1836
1837Int TComDataCU::getLastValidPartIdx( Int iAbsPartIdx )
1838{
1839  Int iLastValidPartIdx = iAbsPartIdx-1;
1840  while ( iLastValidPartIdx >= 0
1841       && getPredictionMode( iLastValidPartIdx ) == NUMBER_OF_PREDICTION_MODES )
1842  {
1843    UInt uiDepth = getDepth( iLastValidPartIdx );
1844    iLastValidPartIdx -= m_uiNumPartition>>(uiDepth<<1);
1845  }
1846  return iLastValidPartIdx;
1847}
1848
1849Char TComDataCU::getLastCodedQP( UInt uiAbsPartIdx )
1850{
1851  UInt uiQUPartIdxMask = ~((1<<((getSlice()->getSPS()->getMaxTotalCUDepth() - getSlice()->getPPS()->getMaxCuDQPDepth())<<1))-1);
1852  Int iLastValidPartIdx = getLastValidPartIdx( uiAbsPartIdx&uiQUPartIdxMask ); // A idx will be invalid if it is off the right or bottom edge of the picture.
1853  // If this CU is in the first CTU of the slice and there is no valid part before this one, use slice QP
1854  if ( getPic()->getPicSym()->getCtuTsToRsAddrMap(getSlice()->getSliceCurStartCtuTsAddr()) == getCtuRsAddr() && Int(getZorderIdxInCtu())+iLastValidPartIdx<0)
1855  {
1856    return getSlice()->getSliceQp();
1857  }
1858  else if ( iLastValidPartIdx >= 0 )
1859  {
1860    // If there is a valid part within the current Sub-CU, use it
1861    return getQP( iLastValidPartIdx );
1862  }
1863  else
1864  {
1865    if ( getZorderIdxInCtu() > 0 )
1866    {
1867      // If this wasn't the first sub-cu within the Ctu, explore the CTU itself.
1868      return getPic()->getCtu( getCtuRsAddr() )->getLastCodedQP( getZorderIdxInCtu() ); // TODO - remove this recursion
1869    }
1870    else if ( getPic()->getPicSym()->getCtuRsToTsAddrMap(getCtuRsAddr()) > 0
1871      && CUIsFromSameSliceTileAndWavefrontRow(getPic()->getCtu(getPic()->getPicSym()->getCtuTsToRsAddrMap(getPic()->getPicSym()->getCtuRsToTsAddrMap(getCtuRsAddr())-1))) )
1872    {
1873      // If this isn't the first Ctu (how can it be due to the first 'if'?), and the previous Ctu is from the same tile, examine the previous Ctu.
1874      return getPic()->getCtu( getPic()->getPicSym()->getCtuTsToRsAddrMap(getPic()->getPicSym()->getCtuRsToTsAddrMap(getCtuRsAddr())-1) )->getLastCodedQP( getPic()->getNumPartitionsInCtu() );  // TODO - remove this recursion
1875    }
1876    else
1877    {
1878      // No other options available - use the slice-level QP.
1879      return getSlice()->getSliceQp();
1880    }
1881  }
1882}
1883
1884
1885/** Check whether the CU is coded in lossless coding mode.
1886 * \param   absPartIdx
1887 * \returns true if the CU is coded in lossless coding mode; false if otherwise
1888 */
1889Bool TComDataCU::isLosslessCoded(UInt absPartIdx)
1890{
1891  return (getSlice()->getPPS()->getTransquantBypassEnableFlag() && getCUTransquantBypass (absPartIdx));
1892}
1893
1894
1895/** Get allowed chroma intra modes
1896*   - fills uiModeList with chroma intra modes
1897*
1898*\param   [in]  uiAbsPartIdx
1899*\param   [out] uiModeList pointer to chroma intra modes array
1900*/
1901Void TComDataCU::getAllowedChromaDir( UInt uiAbsPartIdx, UInt uiModeList[NUM_CHROMA_MODE] )
1902{
1903  uiModeList[0] = PLANAR_IDX;
1904  uiModeList[1] = VER_IDX;
1905  uiModeList[2] = HOR_IDX;
1906  uiModeList[3] = DC_IDX;
1907  uiModeList[4] = DM_CHROMA_IDX;
1908  assert(4<NUM_CHROMA_MODE);
1909
1910  UInt uiLumaMode = getIntraDir( CHANNEL_TYPE_LUMA, uiAbsPartIdx );
1911
1912  for( Int i = 0; i < NUM_CHROMA_MODE - 1; i++ )
1913  {
1914    if( uiLumaMode == uiModeList[i] )
1915    {
1916      uiModeList[i] = 34; // VER+8 mode
1917      break;
1918    }
1919  }
1920}
1921
1922/** Get most probable intra modes
1923*\param   uiAbsPartIdx    partition index
1924*\param   uiIntraDirPred  pointer to the array for MPM storage
1925*\param   compID          colour component ID
1926*\param   piMode          it is set with MPM mode in case both MPM are equal. It is used to restrict RD search at encode side.
1927*\returns Number of MPM
1928*/
1929Void TComDataCU::getIntraDirPredictor( UInt uiAbsPartIdx, Int uiIntraDirPred[NUM_MOST_PROBABLE_MODES], const ComponentID compID, Int* piMode  )
1930{
1931  TComDataCU* pcCULeft, *pcCUAbove;
1932  UInt        LeftPartIdx  = MAX_UINT;
1933  UInt        AbovePartIdx = MAX_UINT;
1934  Int         iLeftIntraDir, iAboveIntraDir;
1935  const TComSPS *sps=getSlice()->getSPS();
1936  const UInt partsPerMinCU = 1<<(2*(sps->getMaxTotalCUDepth() - sps->getLog2DiffMaxMinCodingBlockSize()));
1937
1938  const ChannelType chType = toChannelType(compID);
1939  const ChromaFormat chForm = getPic()->getChromaFormat();
1940  // Get intra direction of left PU
1941  pcCULeft = getPULeft( LeftPartIdx, m_absZIdxInCtu + uiAbsPartIdx );
1942
1943  if (isChroma(compID))
1944  {
1945    LeftPartIdx = getChromasCorrespondingPULumaIdx(LeftPartIdx, chForm, partsPerMinCU);
1946  }
1947  iLeftIntraDir  = pcCULeft ? ( pcCULeft->isIntra( LeftPartIdx ) ? pcCULeft->getIntraDir( chType, LeftPartIdx ) : DC_IDX ) : DC_IDX;
1948#if H_3D_DIM
1949  mapDepthModeToIntraDir( iLeftIntraDir );
1950#endif
1951
1952  // Get intra direction of above PU
1953  pcCUAbove = getPUAbove( AbovePartIdx, m_absZIdxInCtu + uiAbsPartIdx, true, true );
1954
1955  if (isChroma(compID))
1956  {
1957    AbovePartIdx = getChromasCorrespondingPULumaIdx(AbovePartIdx, chForm, partsPerMinCU);
1958  }
1959  iAboveIntraDir = pcCUAbove ? ( pcCUAbove->isIntra( AbovePartIdx ) ? pcCUAbove->getIntraDir( chType, AbovePartIdx ) : DC_IDX ) : DC_IDX;
1960#if H_3D_DIM
1961  mapDepthModeToIntraDir( iAboveIntraDir );
1962#endif
1963
1964
1965  if (isChroma(chType))
1966  {
1967    if (iLeftIntraDir  == DM_CHROMA_IDX)
1968    {
1969      iLeftIntraDir  = pcCULeft-> getIntraDir( CHANNEL_TYPE_LUMA, LeftPartIdx  );
1970    }
1971    if (iAboveIntraDir == DM_CHROMA_IDX)
1972    {
1973      iAboveIntraDir = pcCUAbove->getIntraDir( CHANNEL_TYPE_LUMA, AbovePartIdx );
1974    }
1975  }
1976
1977  assert (2<NUM_MOST_PROBABLE_MODES);
1978  if(iLeftIntraDir == iAboveIntraDir)
1979  {
1980    if( piMode )
1981    {
1982      *piMode = 1;
1983    }
1984
1985    if (iLeftIntraDir > 1) // angular modes
1986    {
1987      uiIntraDirPred[0] = iLeftIntraDir;
1988      uiIntraDirPred[1] = ((iLeftIntraDir + 29) % 32) + 2;
1989      uiIntraDirPred[2] = ((iLeftIntraDir - 1 ) % 32) + 2;
1990    }
1991    else //non-angular
1992    {
1993      uiIntraDirPred[0] = PLANAR_IDX;
1994      uiIntraDirPred[1] = DC_IDX;
1995      uiIntraDirPred[2] = VER_IDX;
1996    }
1997  }
1998  else
1999  {
2000    if( piMode )
2001    {
2002      *piMode = 2;
2003    }
2004    uiIntraDirPred[0] = iLeftIntraDir;
2005    uiIntraDirPred[1] = iAboveIntraDir;
2006
2007    if (iLeftIntraDir && iAboveIntraDir ) //both modes are non-planar
2008    {
2009      uiIntraDirPred[2] = PLANAR_IDX;
2010    }
2011    else
2012    {
2013      uiIntraDirPred[2] =  (iLeftIntraDir+iAboveIntraDir)<2? VER_IDX : DC_IDX;
2014    }
2015  }
2016  for (UInt i=0; i<NUM_MOST_PROBABLE_MODES; i++)
2017  {
2018    assert(uiIntraDirPred[i] < 35);
2019  }
2020}
2021
2022UInt TComDataCU::getCtxSplitFlag( UInt uiAbsPartIdx, UInt uiDepth )
2023{
2024  TComDataCU* pcTempCU;
2025  UInt        uiTempPartIdx;
2026  UInt        uiCtx;
2027  // Get left split flag
2028  pcTempCU = getPULeft( uiTempPartIdx, m_absZIdxInCtu + uiAbsPartIdx );
2029  uiCtx  = ( pcTempCU ) ? ( ( pcTempCU->getDepth( uiTempPartIdx ) > uiDepth ) ? 1 : 0 ) : 0;
2030
2031  // Get above split flag
2032  pcTempCU = getPUAbove( uiTempPartIdx, m_absZIdxInCtu + uiAbsPartIdx );
2033  uiCtx += ( pcTempCU ) ? ( ( pcTempCU->getDepth( uiTempPartIdx ) > uiDepth ) ? 1 : 0 ) : 0;
2034
2035  return uiCtx;
2036}
2037
2038UInt TComDataCU::getCtxQtCbf( TComTU &rTu, const ChannelType chType )
2039{
2040  const UInt transformDepth = rTu.GetTransformDepthRel();
2041
2042  if (isChroma(chType))
2043  {
2044    return transformDepth;
2045  }
2046  else
2047  {
2048    const UInt uiCtx = ( transformDepth == 0 ? 1 : 0 );
2049    return uiCtx;
2050  }
2051}
2052
2053UInt TComDataCU::getQuadtreeTULog2MinSizeInCU( UInt absPartIdx )
2054{
2055  UInt log2CbSize = g_aucConvertToBit[getWidth( absPartIdx )] + 2;
2056  PartSize  partSize  = getPartitionSize( absPartIdx );
2057  UInt quadtreeTUMaxDepth = isIntra( absPartIdx ) ? m_pcSlice->getSPS()->getQuadtreeTUMaxDepthIntra() : m_pcSlice->getSPS()->getQuadtreeTUMaxDepthInter();
2058  Int intraSplitFlag = ( isIntra( absPartIdx ) && partSize == SIZE_NxN ) ? 1 : 0;
2059  Int interSplitFlag = ((quadtreeTUMaxDepth == 1) && isInter( absPartIdx ) && (partSize != SIZE_2Nx2N) );
2060
2061  UInt log2MinTUSizeInCU = 0;
2062  if (log2CbSize < (m_pcSlice->getSPS()->getQuadtreeTULog2MinSize() + quadtreeTUMaxDepth - 1 + interSplitFlag + intraSplitFlag) )
2063  {
2064    // when fully making use of signaled TUMaxDepth + inter/intraSplitFlag, resulting luma TB size is < QuadtreeTULog2MinSize
2065    log2MinTUSizeInCU = m_pcSlice->getSPS()->getQuadtreeTULog2MinSize();
2066  }
2067  else
2068  {
2069    // when fully making use of signaled TUMaxDepth + inter/intraSplitFlag, resulting luma TB size is still >= QuadtreeTULog2MinSize
2070    log2MinTUSizeInCU = log2CbSize - ( quadtreeTUMaxDepth - 1 + interSplitFlag + intraSplitFlag); // stop when trafoDepth == hierarchy_depth = splitFlag
2071    if ( log2MinTUSizeInCU > m_pcSlice->getSPS()->getQuadtreeTULog2MaxSize())
2072    {
2073      // when fully making use of signaled TUMaxDepth + inter/intraSplitFlag, resulting luma TB size is still > QuadtreeTULog2MaxSize
2074      log2MinTUSizeInCU = m_pcSlice->getSPS()->getQuadtreeTULog2MaxSize();
2075    }
2076  }
2077  return log2MinTUSizeInCU;
2078}
2079
2080UInt TComDataCU::getCtxSkipFlag( UInt uiAbsPartIdx )
2081{
2082  TComDataCU* pcTempCU;
2083  UInt        uiTempPartIdx;
2084  UInt        uiCtx = 0;
2085
2086  // Get BCBP of left PU
2087  pcTempCU = getPULeft( uiTempPartIdx, m_absZIdxInCtu + uiAbsPartIdx );
2088  uiCtx    = ( pcTempCU ) ? pcTempCU->isSkipped( uiTempPartIdx ) : 0;
2089
2090  // Get BCBP of above PU
2091  pcTempCU = getPUAbove( uiTempPartIdx, m_absZIdxInCtu + uiAbsPartIdx );
2092  uiCtx   += ( pcTempCU ) ? pcTempCU->isSkipped( uiTempPartIdx ) : 0;
2093
2094  return uiCtx;
2095}
2096#if H_3D_ARP
2097UInt TComDataCU::getCTXARPWFlag( UInt uiAbsPartIdx )
2098{
2099  TComDataCU* pcTempCU;
2100  UInt        uiTempPartIdx;
2101  UInt        uiCtx = 0;
2102 
2103  pcTempCU = getPULeft( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
2104  uiCtx    = ( pcTempCU ) ? ((pcTempCU->getARPW( uiTempPartIdx )==0)?0:1) : 0;
2105    return uiCtx;
2106}
2107#endif
2108#if H_3D_DBBP
2109Pel* TComDataCU::getVirtualDepthBlock(UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt& uiDepthStride)
2110{
2111  // get coded and reconstructed depth view
2112  TComPicYuv* depthPicYuv = NULL;
2113  Pel* pDepthPels = NULL;
2114 
2115  // DBBP is a texture coding tool
2116  if( getSlice()->getIsDepth() )
2117  {
2118    return NULL;
2119  } 
2120#if H_3D_FCO
2121  TComPic* depthPic = getSlice()->getIvPic(true, getSlice()->getViewIndex() );
2122 
2123  if( depthPic && depthPic->getPicYuvRec() != NULL && depthPic->getIsDepth() )  // depth first
2124  {
2125    depthPicYuv = depthPic->getPicYuvRec();
2126    depthPicYuv->extendPicBorder();
2127   
2128    // get collocated depth block for current CU
2129    uiDepthStride = depthPicYuv->getStride();
2130    pDepthPels    = depthPicYuv->getLumaAddr( getAddr(), uiAbsPartIdx );
2131  }
2132  else  // texture first
2133#else
2134  {
2135    DisInfo DvInfo = getDvInfo(uiAbsPartIdx);
2136   
2137    TComPic* baseDepthPic = getSlice()->getIvPic (true, DvInfo.m_aVIdxCan);
2138   
2139    if( baseDepthPic == NULL || baseDepthPic->getPicYuvRec() == NULL )
2140    {
2141      return NULL;
2142    }
2143   
2144    depthPicYuv   = baseDepthPic->getPicYuvRec();
2145    depthPicYuv->extendPicBorder();
2146    uiDepthStride = depthPicYuv->getStride();
2147   
2148    Int iBlkX = ( getAddr() % baseDepthPic->getFrameWidthInCU() ) * g_uiMaxCUWidth  + g_auiRasterToPelX[ g_auiZscanToRaster[ getZorderIdxInCU()+uiAbsPartIdx ] ];
2149    Int iBlkY = ( getAddr() / baseDepthPic->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ getZorderIdxInCU()+uiAbsPartIdx ] ];
2150   
2151    Int iPictureWidth  = depthPicYuv->getWidth();
2152    Int iPictureHeight = depthPicYuv->getHeight();
2153   
2154   
2155    Bool depthRefineFlag = false;
2156#if NH_3D_NBDV_REF
2157    depthRefineFlag = m_pcSlice->getDepthRefinementFlag();
2158#endif // NH_3D_NBDV_REF
2159   
2160    TComMv cDv = depthRefineFlag ? DvInfo.m_acDoNBDV : DvInfo.m_acNBDV;
2161    if( depthRefineFlag )
2162    {
2163      cDv.setVer(0);
2164    }
2165   
2166    Int depthPosX = Clip3(0,   iPictureWidth - 1,  iBlkX + ((cDv.getHor()+2)>>2));
2167    Int depthPosY = Clip3(0,   iPictureHeight - 1, iBlkY + ((cDv.getVer()+2)>>2));
2168   
2169    pDepthPels = depthPicYuv->getLumaAddr() + depthPosX + depthPosY * uiDepthStride;
2170  }
2171#endif
2172 
2173  AOF( depthPicYuv != NULL );
2174  AOF( pDepthPels != NULL );
2175  AOF( uiDepthStride != 0 );
2176 
2177  return pDepthPels;
2178}
2179#endif
2180
2181#if H_3D_DBBP
2182Void TComDataCU::setDBBPFlagSubParts ( Bool bDBBPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2183{
2184  setSubPart( bDBBPFlag, m_pbDBBPFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
2185}
2186#endif
2187
2188#if H_3D_DIM_SDC
2189UInt TComDataCU::getCtxSDCFlag( UInt uiAbsPartIdx )
2190{
2191  return 0;
2192}
2193
2194#endif
2195
2196
2197UInt TComDataCU::getCtxInterDir( UInt uiAbsPartIdx )
2198{
2199  return getDepth( uiAbsPartIdx );
2200}
2201
2202
2203UChar TComDataCU::getQtRootCbf( UInt uiIdx )
2204{
2205  const UInt numberValidComponents = getPic()->getNumberValidComponents();
2206  return getCbf( uiIdx, COMPONENT_Y, 0 )
2207          || ((numberValidComponents > COMPONENT_Cb) && getCbf( uiIdx, COMPONENT_Cb, 0 ))
2208          || ((numberValidComponents > COMPONENT_Cr) && getCbf( uiIdx, COMPONENT_Cr, 0 ));
2209}
2210
2211Void TComDataCU::setCbfSubParts( const UInt uiCbf[MAX_NUM_COMPONENT], UInt uiAbsPartIdx, UInt uiDepth )
2212{
2213  UInt uiCurrPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2214  for(UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
2215  {
2216    memset( m_puhCbf[comp] + uiAbsPartIdx, uiCbf[comp], sizeof( UChar ) * uiCurrPartNumb );
2217  }
2218}
2219
2220Void TComDataCU::setCbfSubParts( UInt uiCbf, ComponentID compID, UInt uiAbsPartIdx, UInt uiDepth )
2221{
2222  UInt uiCurrPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2223  memset( m_puhCbf[compID] + uiAbsPartIdx, uiCbf, sizeof( UChar ) * uiCurrPartNumb );
2224}
2225
2226/** Sets a coded block flag for all sub-partitions of a partition
2227 * \param uiCbf          The value of the coded block flag to be set
2228 * \param compID
2229 * \param uiAbsPartIdx
2230 * \param uiPartIdx
2231 * \param uiDepth
2232 */
2233Void TComDataCU::setCbfSubParts ( UInt uiCbf, ComponentID compID, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2234{
2235  setSubPart<UChar>( uiCbf, m_puhCbf[compID], uiAbsPartIdx, uiDepth, uiPartIdx );
2236}
2237
2238Void TComDataCU::setCbfPartRange ( UInt uiCbf, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
2239{
2240  memset((m_puhCbf[compID] + uiAbsPartIdx), uiCbf, (sizeof(UChar) * uiCoveredPartIdxes));
2241}
2242
2243Void TComDataCU::bitwiseOrCbfPartRange( UInt uiCbf, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
2244{
2245  const UInt stopAbsPartIdx = uiAbsPartIdx + uiCoveredPartIdxes;
2246
2247  for (UInt subPartIdx = uiAbsPartIdx; subPartIdx < stopAbsPartIdx; subPartIdx++)
2248  {
2249    m_puhCbf[compID][subPartIdx] |= uiCbf;
2250  }
2251}
2252
2253Void TComDataCU::setDepthSubParts( UInt uiDepth, UInt uiAbsPartIdx )
2254{
2255  UInt uiCurrPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2256  memset( m_puhDepth + uiAbsPartIdx, uiDepth, sizeof(UChar)*uiCurrPartNumb );
2257}
2258
2259Bool TComDataCU::isFirstAbsZorderIdxInDepth (UInt uiAbsPartIdx, UInt uiDepth)
2260{
2261  UInt uiPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2262  return (((m_absZIdxInCtu + uiAbsPartIdx)% uiPartNumb) == 0);
2263}
2264
2265Void TComDataCU::setPartSizeSubParts( PartSize eMode, UInt uiAbsPartIdx, UInt uiDepth )
2266{
2267  assert( sizeof( *m_pePartSize) == 1 );
2268  memset( m_pePartSize + uiAbsPartIdx, eMode, m_pcPic->getNumPartitionsInCtu() >> ( 2 * uiDepth ) );
2269}
2270
2271Void TComDataCU::setCUTransquantBypassSubParts( Bool flag, UInt uiAbsPartIdx, UInt uiDepth )
2272{
2273  memset( m_CUTransquantBypass + uiAbsPartIdx, flag, m_pcPic->getNumPartitionsInCtu() >> ( 2 * uiDepth ) );
2274}
2275
2276Void TComDataCU::setSkipFlagSubParts( Bool skip, UInt absPartIdx, UInt depth )
2277{
2278  assert( sizeof( *m_skipFlag) == 1 );
2279  memset( m_skipFlag + absPartIdx, skip, m_pcPic->getNumPartitionsInCtu() >> ( 2 * depth ) );
2280}
2281
2282#if H_3D
2283Void TComDataCU::setDISFlagSubParts( Bool bDIS, UInt absPartIdx, UInt depth )
2284{
2285    assert( sizeof( *m_bDISFlag) == 1 );
2286    memset( m_bDISFlag + absPartIdx, bDIS, m_pcPic->getNumPartInCU() >> ( 2 * depth ) );
2287}
2288
2289Void TComDataCU::setDISTypeSubParts(UInt uiDISType, UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth )
2290{
2291    setSubPartT( uiDISType, m_uiDISType, uiAbsPartIdx, uiDepth, uiPUIdx );
2292}
2293#endif
2294
2295Void TComDataCU::setPredModeSubParts( PredMode eMode, UInt uiAbsPartIdx, UInt uiDepth )
2296{
2297  assert( sizeof( *m_pePredMode) == 1 );
2298  memset( m_pePredMode + uiAbsPartIdx, eMode, m_pcPic->getNumPartitionsInCtu() >> ( 2 * uiDepth ) );
2299}
2300
2301Void TComDataCU::setChromaQpAdjSubParts( UChar val, Int absPartIdx, Int depth )
2302{
2303  assert( sizeof(*m_ChromaQpAdj) == 1 );
2304  memset( m_ChromaQpAdj + absPartIdx, val, m_pcPic->getNumPartitionsInCtu() >> ( 2 * depth ) );
2305}
2306
2307Void TComDataCU::setQPSubCUs( Int qp, UInt absPartIdx, UInt depth, Bool &foundNonZeroCbf )
2308{
2309  UInt currPartNumb = m_pcPic->getNumPartitionsInCtu() >> (depth << 1);
2310  UInt currPartNumQ = currPartNumb >> 2;
2311  const UInt numValidComp = m_pcPic->getNumberValidComponents();
2312
2313  if(!foundNonZeroCbf)
2314  {
2315    if(getDepth(absPartIdx) > depth)
2316    {
2317      for ( UInt partUnitIdx = 0; partUnitIdx < 4; partUnitIdx++ )
2318      {
2319        setQPSubCUs( qp, absPartIdx+partUnitIdx*currPartNumQ, depth+1, foundNonZeroCbf );
2320      }
2321    }
2322    else
2323    {
2324      if(getCbf( absPartIdx, COMPONENT_Y ) || (numValidComp>COMPONENT_Cb && getCbf( absPartIdx, COMPONENT_Cb )) || (numValidComp>COMPONENT_Cr && getCbf( absPartIdx, COMPONENT_Cr) ) )
2325      {
2326        foundNonZeroCbf = true;
2327      }
2328      else
2329      {
2330        setQPSubParts(qp, absPartIdx, depth);
2331      }
2332    }
2333  }
2334}
2335
2336Void TComDataCU::setQPSubParts( Int qp, UInt uiAbsPartIdx, UInt uiDepth )
2337{
2338  const UInt numPart = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2339  memset(m_phQP+uiAbsPartIdx, qp, numPart);
2340}
2341
2342Void TComDataCU::setIntraDirSubParts( const ChannelType channelType, const UInt dir, const UInt absPartIdx, const UInt depth )
2343{
2344  UInt numPart = m_pcPic->getNumPartitionsInCtu() >> (depth << 1);
2345  memset( m_puhIntraDir[channelType] + absPartIdx, dir,sizeof(UChar)*numPart );
2346}
2347
2348template<typename T>
2349Void TComDataCU::setSubPart( T uiParameter, T* puhBaseCtu, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx )
2350{
2351  assert( sizeof(T) == 1 ); // Using memset() works only for types of size 1
2352
2353  UInt uiCurrPartNumQ = (m_pcPic->getNumPartitionsInCtu() >> (2 * uiCUDepth)) >> 2;
2354  switch ( m_pePartSize[ uiCUAddr ] )
2355  {
2356    case SIZE_2Nx2N:
2357      memset( puhBaseCtu + uiCUAddr, uiParameter, 4 * uiCurrPartNumQ );
2358      break;
2359    case SIZE_2NxN:
2360      memset( puhBaseCtu + uiCUAddr, uiParameter, 2 * uiCurrPartNumQ );
2361      break;
2362    case SIZE_Nx2N:
2363      memset( puhBaseCtu + uiCUAddr, uiParameter, uiCurrPartNumQ );
2364      memset( puhBaseCtu + uiCUAddr + 2 * uiCurrPartNumQ, uiParameter, uiCurrPartNumQ );
2365      break;
2366    case SIZE_NxN:
2367      memset( puhBaseCtu + uiCUAddr, uiParameter, uiCurrPartNumQ );
2368      break;
2369    case SIZE_2NxnU:
2370      if ( uiPUIdx == 0 )
2371      {
2372        memset( puhBaseCtu + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 1) );
2373        memset( puhBaseCtu + uiCUAddr + uiCurrPartNumQ, uiParameter, (uiCurrPartNumQ >> 1) );
2374      }
2375      else if ( uiPUIdx == 1 )
2376      {
2377        memset( puhBaseCtu + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 1) );
2378        memset( puhBaseCtu + uiCUAddr + uiCurrPartNumQ, uiParameter, ((uiCurrPartNumQ >> 1) + (uiCurrPartNumQ << 1)) );
2379      }
2380      else
2381      {
2382        assert(0);
2383      }
2384      break;
2385    case SIZE_2NxnD:
2386      if ( uiPUIdx == 0 )
2387      {
2388        memset( puhBaseCtu + uiCUAddr, uiParameter, ((uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1)) );
2389        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1) + uiCurrPartNumQ, uiParameter, (uiCurrPartNumQ >> 1) );
2390      }
2391      else if ( uiPUIdx == 1 )
2392      {
2393        memset( puhBaseCtu + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 1) );
2394        memset( puhBaseCtu + uiCUAddr + uiCurrPartNumQ, uiParameter, (uiCurrPartNumQ >> 1) );
2395      }
2396      else
2397      {
2398        assert(0);
2399      }
2400      break;
2401    case SIZE_nLx2N:
2402      if ( uiPUIdx == 0 )
2403      {
2404        memset( puhBaseCtu + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 2) );
2405        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );
2406        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1), uiParameter, (uiCurrPartNumQ >> 2) );
2407        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );
2408      }
2409      else if ( uiPUIdx == 1 )
2410      {
2411        memset( puhBaseCtu + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 2) );
2412        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)) );
2413        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1), uiParameter, (uiCurrPartNumQ >> 2) );
2414        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)) );
2415      }
2416      else
2417      {
2418        assert(0);
2419      }
2420      break;
2421    case SIZE_nRx2N:
2422      if ( uiPUIdx == 0 )
2423      {
2424        memset( puhBaseCtu + uiCUAddr, uiParameter, (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)) );
2425        memset( puhBaseCtu + uiCUAddr + uiCurrPartNumQ + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );
2426        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1), uiParameter, (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)) );
2427        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1) + uiCurrPartNumQ + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );
2428      }
2429      else if ( uiPUIdx == 1 )
2430      {
2431        memset( puhBaseCtu + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 2) );
2432        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );
2433        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1), uiParameter, (uiCurrPartNumQ >> 2) );
2434        memset( puhBaseCtu + uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );
2435      }
2436      else
2437      {
2438        assert(0);
2439      }
2440      break;
2441    default:
2442      assert( 0 );
2443      break;
2444  }
2445}
2446
2447#if H_3D_DIM_SDC
2448Void TComDataCU::setSDCFlagSubParts ( Bool bSDCFlag, UInt uiAbsPartIdx, UInt uiDepth )
2449{
2450  assert( sizeof( *m_pbSDCFlag) == 1 );
2451  memset( m_pbSDCFlag + uiAbsPartIdx, bSDCFlag, m_pcPic->getNumPartInCU() >> ( 2 * uiDepth ) );
2452}
2453
2454Bool TComDataCU::getSDCAvailable( UInt uiAbsPartIdx )
2455{
2456  // check general CU information
2457  if( !getSlice()->getIsDepth() || !isIntra(uiAbsPartIdx) || getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N )
2458  {
2459    return false;
2460  }
2461
2462  if( isDimMode( getLumaIntraDir( uiAbsPartIdx ) ) )
2463  {
2464    return true;
2465  }
2466 
2467  if( getLumaIntraDir( uiAbsPartIdx ) < NUM_INTRA_MODE )
2468  {
2469    return true;
2470  }
2471
2472  return false;
2473  // check prediction mode
2474  UInt uiLumaPredMode = getLumaIntraDir( uiAbsPartIdx ); 
2475  if( uiLumaPredMode == PLANAR_IDX || ( getDimType( uiLumaPredMode ) == DMM1_IDX  ) )
2476    return true;
2477 
2478  // else
2479  return false;
2480}
2481#endif
2482
2483Void TComDataCU::setMergeFlagSubParts ( Bool bMergeFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2484{
2485  setSubPart( bMergeFlag, m_pbMergeFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
2486}
2487
2488Void TComDataCU::setMergeIndexSubParts ( UInt uiMergeIndex, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2489{
2490  setSubPart<UChar>( uiMergeIndex, m_puhMergeIndex, uiAbsPartIdx, uiDepth, uiPartIdx );
2491}
2492
2493#if NH_3D_SPIVMP
2494Void TComDataCU::setSPIVMPFlagSubParts( Bool bSPIVMPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2495{
2496  setSubPart<Bool>( bSPIVMPFlag, m_pbSPIVMPFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
2497}
2498#endif
2499
2500#if NH_3D_VSP
2501Void TComDataCU::setVSPFlagSubParts( Char iVSPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2502{
2503  setSubPart<Char>( iVSPFlag, m_piVSPFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
2504}
2505template<typename T>
2506Void TComDataCU::setSubPartT( T uiParameter, T* puhBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx )
2507{
2508  UInt uiCurrPartNumQ = (m_pcPic->getNumPartitionsInCtu() >> (2 * uiCUDepth)) >> 2;
2509  switch ( m_pePartSize[ uiCUAddr ] )
2510  {
2511  case SIZE_2Nx2N:
2512    for (UInt ui = 0; ui < 4 * uiCurrPartNumQ; ui++)
2513      puhBaseLCU[uiCUAddr + ui] = uiParameter;
2514
2515    break;
2516  case SIZE_2NxN:
2517    for (UInt ui = 0; ui < 2 * uiCurrPartNumQ; ui++)
2518      puhBaseLCU[uiCUAddr + ui] = uiParameter;
2519    break;
2520  case SIZE_Nx2N:
2521    for (UInt ui = 0; ui < uiCurrPartNumQ; ui++)
2522      puhBaseLCU[uiCUAddr + ui] = uiParameter;
2523    for (UInt ui = 0; ui < uiCurrPartNumQ; ui++)
2524      puhBaseLCU[uiCUAddr + 2 * uiCurrPartNumQ + ui] = uiParameter;
2525    break;
2526  case SIZE_NxN:
2527    for (UInt ui = 0; ui < uiCurrPartNumQ; ui++)
2528      puhBaseLCU[uiCUAddr + ui] = uiParameter;
2529    break;
2530  case SIZE_2NxnU:
2531    if ( uiPUIdx == 0 )
2532    {
2533      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 1); ui++)
2534        puhBaseLCU[uiCUAddr + ui] = uiParameter;
2535      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 1); ui++)
2536        puhBaseLCU[uiCUAddr + uiCurrPartNumQ + ui] = uiParameter;
2537
2538    }
2539    else if ( uiPUIdx == 1 )
2540    {
2541      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 1); ui++)
2542        puhBaseLCU[uiCUAddr + ui] = uiParameter;
2543      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 1) + (uiCurrPartNumQ << 1); ui++)
2544        puhBaseLCU[uiCUAddr + uiCurrPartNumQ + ui] = uiParameter;
2545
2546    }
2547    else
2548    {
2549      assert(0);
2550    }
2551    break;
2552  case SIZE_2NxnD:
2553    if ( uiPUIdx == 0 )
2554    {
2555      for (UInt ui = 0; ui < ((uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1)); ui++)
2556        puhBaseLCU[uiCUAddr + ui] = uiParameter;
2557      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 1); ui++)
2558        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + uiCurrPartNumQ + ui] = uiParameter;
2559
2560    }
2561    else if ( uiPUIdx == 1 )
2562    {
2563      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 1); ui++)
2564        puhBaseLCU[uiCUAddr + ui] = uiParameter;
2565      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 1); ui++)
2566        puhBaseLCU[uiCUAddr + uiCurrPartNumQ + ui] = uiParameter;
2567
2568    }
2569    else
2570    {
2571      assert(0);
2572    }
2573    break;
2574  case SIZE_nLx2N:
2575    if ( uiPUIdx == 0 )
2576    {
2577      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2578        puhBaseLCU[uiCUAddr + ui] = uiParameter;
2579      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2580        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ >> 1) + ui] = uiParameter;
2581      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2582        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + ui] = uiParameter;
2583      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2584        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1) + ui] = uiParameter;
2585
2586    }
2587    else if ( uiPUIdx == 1 )
2588    {
2589      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2590        puhBaseLCU[uiCUAddr + ui] = uiParameter;
2591      for (UInt ui = 0; ui < (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)); ui++)
2592        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ >> 1) + ui] = uiParameter;
2593      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2594        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + ui] = uiParameter;
2595      for (UInt ui = 0; ui < (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)); ui++)
2596        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1) + ui] = uiParameter;
2597
2598    }
2599    else
2600    {
2601      assert(0);
2602    }
2603    break;
2604  case SIZE_nRx2N:
2605    if ( uiPUIdx == 0 )
2606    {
2607      for (UInt ui = 0; ui < (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)); ui++)
2608        puhBaseLCU[uiCUAddr + ui] = uiParameter;
2609      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2610        puhBaseLCU[uiCUAddr + uiCurrPartNumQ + (uiCurrPartNumQ >> 1) + ui] = uiParameter;
2611      for (UInt ui = 0; ui < (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)); ui++)
2612        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + ui] = uiParameter;
2613      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2614        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + uiCurrPartNumQ + (uiCurrPartNumQ >> 1) + ui] = uiParameter;
2615
2616    }
2617    else if ( uiPUIdx == 1 )
2618    {
2619      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2620        puhBaseLCU[uiCUAddr + ui] = uiParameter;
2621      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2622        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ >> 1) + ui] = uiParameter;
2623      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2624        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + ui] = uiParameter;
2625      for (UInt ui = 0; ui < (uiCurrPartNumQ >> 2); ui++)
2626        puhBaseLCU[uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1) + ui] = uiParameter;
2627
2628    }
2629    else
2630    {
2631      assert(0);
2632    }
2633    break;
2634  default:
2635    assert( 0 );
2636  }
2637
2638}
2639#endif
2640
2641Void TComDataCU::setInterDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2642{
2643  setSubPart<UChar>( uiDir, m_puhInterDir, uiAbsPartIdx, uiDepth, uiPartIdx );
2644}
2645
2646Void TComDataCU::setMVPIdxSubParts( Int iMVPIdx, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2647{
2648  setSubPart<Char>( iMVPIdx, m_apiMVPIdx[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
2649}
2650
2651Void TComDataCU::setMVPNumSubParts( Int iMVPNum, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2652{
2653  setSubPart<Char>( iMVPNum, m_apiMVPNum[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
2654}
2655
2656
2657Void TComDataCU::setTrIdxSubParts( UInt uiTrIdx, UInt uiAbsPartIdx, UInt uiDepth )
2658{
2659  UInt uiCurrPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2660
2661  memset( m_puhTrIdx + uiAbsPartIdx, uiTrIdx, sizeof(UChar)*uiCurrPartNumb );
2662}
2663
2664Void TComDataCU::setTransformSkipSubParts( const UInt useTransformSkip[MAX_NUM_COMPONENT], UInt uiAbsPartIdx, UInt uiDepth )
2665{
2666  UInt uiCurrPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2667
2668  for(UInt i=0; i<MAX_NUM_COMPONENT; i++)
2669  {
2670    memset( m_puhTransformSkip[i] + uiAbsPartIdx, useTransformSkip[i], sizeof( UChar ) * uiCurrPartNumb );
2671  }
2672}
2673
2674Void TComDataCU::setTransformSkipSubParts( UInt useTransformSkip, ComponentID compID, UInt uiAbsPartIdx, UInt uiDepth)
2675{
2676  UInt uiCurrPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2677
2678  memset( m_puhTransformSkip[compID] + uiAbsPartIdx, useTransformSkip, sizeof( UChar ) * uiCurrPartNumb );
2679}
2680
2681Void TComDataCU::setTransformSkipPartRange ( UInt useTransformSkip, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
2682{
2683  memset((m_puhTransformSkip[compID] + uiAbsPartIdx), useTransformSkip, (sizeof(UChar) * uiCoveredPartIdxes));
2684}
2685
2686Void TComDataCU::setCrossComponentPredictionAlphaPartRange( Char alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
2687{
2688  memset((m_crossComponentPredictionAlpha[compID] + uiAbsPartIdx), alphaValue, (sizeof(Char) * uiCoveredPartIdxes));
2689}
2690
2691Void TComDataCU::setExplicitRdpcmModePartRange ( UInt rdpcmMode, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
2692{
2693  memset((m_explicitRdpcmMode[compID] + uiAbsPartIdx), rdpcmMode, (sizeof(UChar) * uiCoveredPartIdxes));
2694}
2695
2696Void TComDataCU::setSizeSubParts( UInt uiWidth, UInt uiHeight, UInt uiAbsPartIdx, UInt uiDepth )
2697{
2698  UInt uiCurrPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
2699
2700  memset( m_puhWidth  + uiAbsPartIdx, uiWidth,  sizeof(UChar)*uiCurrPartNumb );
2701  memset( m_puhHeight + uiAbsPartIdx, uiHeight, sizeof(UChar)*uiCurrPartNumb );
2702}
2703
2704UChar TComDataCU::getNumPartitions(const UInt uiAbsPartIdx)
2705{
2706  UChar iNumPart = 0;
2707
2708  switch ( m_pePartSize[uiAbsPartIdx] )
2709  {
2710    case SIZE_2Nx2N:    iNumPart = 1; break;
2711    case SIZE_2NxN:     iNumPart = 2; break;
2712    case SIZE_Nx2N:     iNumPart = 2; break;
2713    case SIZE_NxN:      iNumPart = 4; break;
2714    case SIZE_2NxnU:    iNumPart = 2; break;
2715    case SIZE_2NxnD:    iNumPart = 2; break;
2716    case SIZE_nLx2N:    iNumPart = 2; break;
2717    case SIZE_nRx2N:    iNumPart = 2; break;
2718    default:            assert (0);   break;
2719  }
2720
2721  return  iNumPart;
2722}
2723
2724// This is for use by a leaf/sub CU object only, with no additional AbsPartIdx
2725#if H_3D_IC | NH_3D_VSP
2726Void TComDataCU::getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx, Bool bLCU)
2727{
2728  UInt uiNumPartition  = bLCU ? (getWidth(uiAbsPartIdx)*getHeight(uiAbsPartIdx) >> 4) : m_uiNumPartition;
2729  UInt  uiTmpAbsPartIdx  = bLCU ? uiAbsPartIdx : 0;
2730
2731  switch ( m_pePartSize[uiTmpAbsPartIdx] )
2732  {
2733  case SIZE_2NxN:
2734    riWidth = getWidth( uiTmpAbsPartIdx );      riHeight = getHeight( uiTmpAbsPartIdx ) >> 1; ruiPartAddr = ( uiPartIdx == 0 )? 0 : uiNumPartition >> 1;
2735    break;
2736  case SIZE_Nx2N:
2737    riWidth = getWidth( uiTmpAbsPartIdx ) >> 1; riHeight = getHeight( uiTmpAbsPartIdx );      ruiPartAddr = ( uiPartIdx == 0 )? 0 : uiNumPartition >> 2;
2738    break;
2739  case SIZE_NxN:
2740    riWidth = getWidth( uiTmpAbsPartIdx ) >> 1; riHeight = getHeight( uiTmpAbsPartIdx ) >> 1; ruiPartAddr = ( uiNumPartition >> 2 ) * uiPartIdx;
2741    break;
2742  case SIZE_2NxnU:
2743    riWidth     = getWidth( uiTmpAbsPartIdx );
2744    riHeight    = ( uiPartIdx == 0 ) ?  getHeight( uiTmpAbsPartIdx ) >> 2 : ( getHeight( uiTmpAbsPartIdx ) >> 2 ) + ( getHeight( uiTmpAbsPartIdx ) >> 1 );
2745    ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : uiNumPartition >> 3;
2746    break;
2747  case SIZE_2NxnD:
2748    riWidth     = getWidth( uiTmpAbsPartIdx );
2749    riHeight    = ( uiPartIdx == 0 ) ?  ( getHeight( uiTmpAbsPartIdx ) >> 2 ) + ( getHeight( uiTmpAbsPartIdx ) >> 1 ) : getHeight( uiTmpAbsPartIdx ) >> 2;
2750    ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : (uiNumPartition >> 1) + (uiNumPartition >> 3);
2751    break;
2752  case SIZE_nLx2N:
2753    riWidth     = ( uiPartIdx == 0 ) ? getWidth( uiTmpAbsPartIdx ) >> 2 : ( getWidth( uiTmpAbsPartIdx ) >> 2 ) + ( getWidth( uiTmpAbsPartIdx ) >> 1 );
2754    riHeight    = getHeight( uiTmpAbsPartIdx );
2755    ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : uiNumPartition >> 4;
2756    break;
2757  case SIZE_nRx2N:
2758    riWidth     = ( uiPartIdx == 0 ) ? ( getWidth( uiTmpAbsPartIdx ) >> 2 ) + ( getWidth( uiTmpAbsPartIdx ) >> 1 ) : getWidth( uiTmpAbsPartIdx ) >> 2;
2759    riHeight    = getHeight( uiTmpAbsPartIdx );
2760    ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : (uiNumPartition >> 2) + (uiNumPartition >> 4);
2761    break;
2762  default:
2763    assert ( m_pePartSize[uiTmpAbsPartIdx] == SIZE_2Nx2N ); 
2764    riWidth = getWidth( uiTmpAbsPartIdx );      riHeight = getHeight( uiTmpAbsPartIdx );      ruiPartAddr = 0;
2765    break;
2766  }
2767}
2768#else
2769
2770Void TComDataCU::getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight )
2771{
2772  switch ( m_pePartSize[0] )
2773  {
2774    case SIZE_2NxN:
2775      riWidth = getWidth(0);      riHeight = getHeight(0) >> 1; ruiPartAddr = ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1;
2776      break;
2777    case SIZE_Nx2N:
2778      riWidth = getWidth(0) >> 1; riHeight = getHeight(0);      ruiPartAddr = ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 2;
2779      break;
2780    case SIZE_NxN:
2781      riWidth = getWidth(0) >> 1; riHeight = getHeight(0) >> 1; ruiPartAddr = ( m_uiNumPartition >> 2 ) * uiPartIdx;
2782      break;
2783    case SIZE_2NxnU:
2784      riWidth     = getWidth(0);
2785      riHeight    = ( uiPartIdx == 0 ) ?  getHeight(0) >> 2 : ( getHeight(0) >> 2 ) + ( getHeight(0) >> 1 );
2786      ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : m_uiNumPartition >> 3;
2787      break;
2788    case SIZE_2NxnD:
2789      riWidth     = getWidth(0);
2790      riHeight    = ( uiPartIdx == 0 ) ?  ( getHeight(0) >> 2 ) + ( getHeight(0) >> 1 ) : getHeight(0) >> 2;
2791      ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : (m_uiNumPartition >> 1) + (m_uiNumPartition >> 3);
2792      break;
2793    case SIZE_nLx2N:
2794      riWidth     = ( uiPartIdx == 0 ) ? getWidth(0) >> 2 : ( getWidth(0) >> 2 ) + ( getWidth(0) >> 1 );
2795      riHeight    = getHeight(0);
2796      ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : m_uiNumPartition >> 4;
2797      break;
2798    case SIZE_nRx2N:
2799      riWidth     = ( uiPartIdx == 0 ) ? ( getWidth(0) >> 2 ) + ( getWidth(0) >> 1 ) : getWidth(0) >> 2;
2800      riHeight    = getHeight(0);
2801      ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : (m_uiNumPartition >> 2) + (m_uiNumPartition >> 4);
2802      break;
2803    default:
2804      assert ( m_pePartSize[0] == SIZE_2Nx2N );
2805      riWidth = getWidth(0);      riHeight = getHeight(0);      ruiPartAddr = 0;
2806      break;
2807  }
2808}
2809#endif
2810
2811
2812Void TComDataCU::getMvField ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList, TComMvField& rcMvField )
2813{
2814  if ( pcCU == NULL )  // OUT OF BOUNDARY
2815  {
2816    TComMv  cZeroMv;
2817    rcMvField.setMvField( cZeroMv, NOT_VALID );
2818    return;
2819  }
2820
2821  TComCUMvField*  pcCUMvField = pcCU->getCUMvField( eRefPicList );
2822  rcMvField.setMvField( pcCUMvField->getMv( uiAbsPartIdx ), pcCUMvField->getRefIdx( uiAbsPartIdx ) );
2823}
2824
2825Void TComDataCU::deriveLeftRightTopIdxGeneral ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT )
2826{
2827  ruiPartIdxLT = m_absZIdxInCtu + uiAbsPartIdx;
2828  UInt uiPUWidth = 0;
2829
2830  switch ( m_pePartSize[uiAbsPartIdx] )
2831  {
2832    case SIZE_2Nx2N: uiPUWidth = m_puhWidth[uiAbsPartIdx];  break;
2833    case SIZE_2NxN:  uiPUWidth = m_puhWidth[uiAbsPartIdx];   break;
2834    case SIZE_Nx2N:  uiPUWidth = m_puhWidth[uiAbsPartIdx]  >> 1;  break;
2835    case SIZE_NxN:   uiPUWidth = m_puhWidth[uiAbsPartIdx]  >> 1; break;
2836    case SIZE_2NxnU:   uiPUWidth = m_puhWidth[uiAbsPartIdx]; break;
2837    case SIZE_2NxnD:   uiPUWidth = m_puhWidth[uiAbsPartIdx]; break;
2838    case SIZE_nLx2N:
2839      if ( uiPartIdx == 0 )
2840      {
2841        uiPUWidth = m_puhWidth[uiAbsPartIdx]  >> 2;
2842      }
2843      else if ( uiPartIdx == 1 )
2844      {
2845        uiPUWidth = (m_puhWidth[uiAbsPartIdx]  >> 1) + (m_puhWidth[uiAbsPartIdx]  >> 2);
2846      }
2847      else
2848      {
2849        assert(0);
2850      }
2851      break;
2852    case SIZE_nRx2N:
2853      if ( uiPartIdx == 0 )
2854      {
2855        uiPUWidth = (m_puhWidth[uiAbsPartIdx]  >> 1) + (m_puhWidth[uiAbsPartIdx]  >> 2);
2856      }
2857      else if ( uiPartIdx == 1 )
2858      {
2859        uiPUWidth = m_puhWidth[uiAbsPartIdx]  >> 2;
2860      }
2861      else
2862      {
2863        assert(0);
2864      }
2865      break;
2866    default:
2867      assert (0);
2868      break;
2869  }
2870
2871  ruiPartIdxRT = g_auiRasterToZscan [g_auiZscanToRaster[ ruiPartIdxLT ] + uiPUWidth / m_pcPic->getMinCUWidth() - 1 ];
2872}
2873
2874Void TComDataCU::deriveLeftBottomIdxGeneral( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB )
2875{
2876  UInt uiPUHeight = 0;
2877  switch ( m_pePartSize[uiAbsPartIdx] )
2878  {
2879    case SIZE_2Nx2N: uiPUHeight = m_puhHeight[uiAbsPartIdx];    break;
2880    case SIZE_2NxN:  uiPUHeight = m_puhHeight[uiAbsPartIdx] >> 1;    break;
2881    case SIZE_Nx2N:  uiPUHeight = m_puhHeight[uiAbsPartIdx];  break;
2882    case SIZE_NxN:   uiPUHeight = m_puhHeight[uiAbsPartIdx] >> 1;    break;
2883    case SIZE_2NxnU:
2884      if ( uiPartIdx == 0 )
2885      {
2886        uiPUHeight = m_puhHeight[uiAbsPartIdx] >> 2;
2887      }
2888      else if ( uiPartIdx == 1 )
2889      {
2890        uiPUHeight = (m_puhHeight[uiAbsPartIdx] >> 1) + (m_puhHeight[uiAbsPartIdx] >> 2);
2891      }
2892      else
2893      {
2894        assert(0);
2895      }
2896      break;
2897    case SIZE_2NxnD:
2898      if ( uiPartIdx == 0 )
2899      {
2900        uiPUHeight = (m_puhHeight[uiAbsPartIdx] >> 1) + (m_puhHeight[uiAbsPartIdx] >> 2);
2901      }
2902      else if ( uiPartIdx == 1 )
2903      {
2904        uiPUHeight = m_puhHeight[uiAbsPartIdx] >> 2;
2905      }
2906      else
2907      {
2908        assert(0);
2909      }
2910      break;
2911    case SIZE_nLx2N: uiPUHeight = m_puhHeight[uiAbsPartIdx];  break;
2912    case SIZE_nRx2N: uiPUHeight = m_puhHeight[uiAbsPartIdx];  break;
2913    default:
2914      assert (0);
2915      break;
2916  }
2917
2918  ruiPartIdxLB      = g_auiRasterToZscan [g_auiZscanToRaster[ m_absZIdxInCtu + uiAbsPartIdx ] + ((uiPUHeight / m_pcPic->getMinCUHeight()) - 1)*m_pcPic->getNumPartInCtuWidth()];
2919}
2920
2921Void TComDataCU::deriveLeftRightTopIdx ( UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT )
2922{
2923  ruiPartIdxLT = m_absZIdxInCtu;
2924  ruiPartIdxRT = g_auiRasterToZscan [g_auiZscanToRaster[ ruiPartIdxLT ] + m_puhWidth[0] / m_pcPic->getMinCUWidth() - 1 ];
2925
2926  switch ( m_pePartSize[0] )
2927  {
2928    case SIZE_2Nx2N:                                                                                                                                break;
2929    case SIZE_2NxN:
2930      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1; ruiPartIdxRT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1;
2931      break;
2932    case SIZE_Nx2N:
2933      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 2; ruiPartIdxRT -= ( uiPartIdx == 1 )? 0 : m_uiNumPartition >> 2;
2934      break;
2935    case SIZE_NxN:
2936      ruiPartIdxLT += ( m_uiNumPartition >> 2 ) * uiPartIdx;         ruiPartIdxRT +=  ( m_uiNumPartition >> 2 ) * ( uiPartIdx - 1 );
2937      break;
2938    case SIZE_2NxnU:
2939      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 3;
2940      ruiPartIdxRT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 3;
2941      break;
2942    case SIZE_2NxnD:
2943      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : ( m_uiNumPartition >> 1 ) + ( m_uiNumPartition >> 3 );
2944      ruiPartIdxRT += ( uiPartIdx == 0 )? 0 : ( m_uiNumPartition >> 1 ) + ( m_uiNumPartition >> 3 );
2945      break;
2946    case SIZE_nLx2N:
2947      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 4;
2948      ruiPartIdxRT -= ( uiPartIdx == 1 )? 0 : ( m_uiNumPartition >> 2 ) + ( m_uiNumPartition >> 4 );
2949      break;
2950    case SIZE_nRx2N:
2951      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : ( m_uiNumPartition >> 2 ) + ( m_uiNumPartition >> 4 );
2952      ruiPartIdxRT -= ( uiPartIdx == 1 )? 0 : m_uiNumPartition >> 4;
2953      break;
2954    default:
2955      assert (0);
2956      break;
2957  }
2958
2959}
2960
2961Void TComDataCU::deriveLeftBottomIdx( UInt  uiPartIdx,      UInt&      ruiPartIdxLB )
2962{
2963  ruiPartIdxLB      = g_auiRasterToZscan [g_auiZscanToRaster[ m_absZIdxInCtu ] + ( ((m_puhHeight[0] / m_pcPic->getMinCUHeight())>>1) - 1)*m_pcPic->getNumPartInCtuWidth()];
2964
2965  switch ( m_pePartSize[0] )
2966  {
2967    case SIZE_2Nx2N:
2968      ruiPartIdxLB += m_uiNumPartition >> 1;
2969      break;
2970    case SIZE_2NxN:
2971      ruiPartIdxLB += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1;
2972      break;
2973    case SIZE_Nx2N:
2974      ruiPartIdxLB += ( uiPartIdx == 0 )? m_uiNumPartition >> 1 : (m_uiNumPartition >> 2)*3;
2975      break;
2976    case SIZE_NxN:
2977      ruiPartIdxLB += ( m_uiNumPartition >> 2 ) * uiPartIdx;
2978      break;
2979    case SIZE_2NxnU:
2980      ruiPartIdxLB += ( uiPartIdx == 0 ) ? -((Int)m_uiNumPartition >> 3) : m_uiNumPartition >> 1;
2981      break;
2982    case SIZE_2NxnD:
2983      ruiPartIdxLB += ( uiPartIdx == 0 ) ? (m_uiNumPartition >> 2) + (m_uiNumPartition >> 3): m_uiNumPartition >> 1;
2984      break;
2985    case SIZE_nLx2N:
2986      ruiPartIdxLB += ( uiPartIdx == 0 ) ? m_uiNumPartition >> 1 : (m_uiNumPartition >> 1) + (m_uiNumPartition >> 4);
2987      break;
2988    case SIZE_nRx2N:
2989      ruiPartIdxLB += ( uiPartIdx == 0 ) ? m_uiNumPartition >> 1 : (m_uiNumPartition >> 1) + (m_uiNumPartition >> 2) + (m_uiNumPartition >> 4);
2990      break;
2991    default:
2992      assert (0);
2993      break;
2994  }
2995}
2996
2997/** Derive the partition index of neighbouring bottom right block
2998 * \param [in]  uiPartIdx     current partition index
2999 * \param [out] ruiPartIdxRB  partition index of neighbouring bottom right block
3000 */
3001Void TComDataCU::deriveRightBottomIdx( UInt uiPartIdx, UInt &ruiPartIdxRB )
3002{
3003  ruiPartIdxRB      = g_auiRasterToZscan [g_auiZscanToRaster[ m_absZIdxInCtu ] + ( ((m_puhHeight[0] / m_pcPic->getMinCUHeight())>>1) - 1)*m_pcPic->getNumPartInCtuWidth() +  m_puhWidth[0] / m_pcPic->getMinCUWidth() - 1];
3004
3005  switch ( m_pePartSize[0] )
3006  {
3007    case SIZE_2Nx2N:
3008      ruiPartIdxRB += m_uiNumPartition >> 1;
3009      break;
3010    case SIZE_2NxN:
3011      ruiPartIdxRB += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1;
3012      break;
3013    case SIZE_Nx2N:
3014      ruiPartIdxRB += ( uiPartIdx == 0 )? m_uiNumPartition >> 2 : (m_uiNumPartition >> 1);
3015      break;
3016    case SIZE_NxN:
3017      ruiPartIdxRB += ( m_uiNumPartition >> 2 ) * ( uiPartIdx - 1 );
3018      break;
3019    case SIZE_2NxnU:
3020      ruiPartIdxRB += ( uiPartIdx == 0 ) ? -((Int)m_uiNumPartition >> 3) : m_uiNumPartition >> 1;
3021      break;
3022    case SIZE_2NxnD:
3023      ruiPartIdxRB += ( uiPartIdx == 0 ) ? (m_uiNumPartition >> 2) + (m_uiNumPartition >> 3): m_uiNumPartition >> 1;
3024      break;
3025    case SIZE_nLx2N:
3026      ruiPartIdxRB += ( uiPartIdx == 0 ) ? (m_uiNumPartition >> 3) + (m_uiNumPartition >> 4): m_uiNumPartition >> 1;
3027      break;
3028    case SIZE_nRx2N:
3029      ruiPartIdxRB += ( uiPartIdx == 0 ) ? (m_uiNumPartition >> 2) + (m_uiNumPartition >> 3) + (m_uiNumPartition >> 4) : m_uiNumPartition >> 1;
3030      break;
3031    default:
3032      assert (0);
3033      break;
3034  }
3035}
3036
3037Bool TComDataCU::hasEqualMotion( UInt uiAbsPartIdx, TComDataCU* pcCandCU, UInt uiCandAbsPartIdx )
3038{
3039  if ( getInterDir( uiAbsPartIdx ) != pcCandCU->getInterDir( uiCandAbsPartIdx ) )
3040  {
3041    return false;
3042  }
3043
3044  for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
3045  {
3046    if ( getInterDir( uiAbsPartIdx ) & ( 1 << uiRefListIdx ) )
3047    {
3048      if ( getCUMvField( RefPicList( uiRefListIdx ) )->getMv( uiAbsPartIdx )     != pcCandCU->getCUMvField( RefPicList( uiRefListIdx ) )->getMv( uiCandAbsPartIdx ) ||
3049        getCUMvField( RefPicList( uiRefListIdx ) )->getRefIdx( uiAbsPartIdx ) != pcCandCU->getCUMvField( RefPicList( uiRefListIdx ) )->getRefIdx( uiCandAbsPartIdx ) )
3050      {
3051        return false;
3052      }
3053    }
3054  }
3055
3056  return true;
3057}
3058
3059#if NH_3D_VSP
3060/** Add a VSP merging candidate
3061 * \Inputs
3062 * \param uiPUIdx: PU index within a CU
3063 * \param ucVspMergePos: Specify the VSP merge candidate position
3064 * \param mrgCandIdx: Target merge candidate index. At encoder, it is set equal to -1, such that the whole merge candidate list will be constructed.
3065 * \param pDinfo: The "disparity information" derived from neighboring blocks. Type 1 MV.
3066 * \param uiCount: The next position to add VSP merge candidate
3067 *
3068 * \Outputs
3069 * \param uiCount: The next position to add merge candidate. Will be updated if VSP is successfully added
3070 * \param abCandIsInter: abCandIsInter[iCount] tells that VSP candidate is an Inter candidate, if VSP is successfully added
3071 * \param pcMvFieldNeighbours:   Return combined motion information, then stored to a global buffer
3072 *                                    1) the "disparity vector". Type 1 MV. To be used to fetch a depth block.
3073 *                                    2) the ref index /list.    Type 2 reference picture pointer, typically for texture
3074 * \param puhInterDirNeighbours: Indicate the VSP prediction direction.
3075 * \param vspFlag: vspFlag[iCount] will be set (equal to 1), if VSP is successfully added. To be used to indicate the actual position of the VSP candidate
3076 *
3077 * \Return
3078 *   true:  if the VSP candidate is added at the target position
3079 *   false: otherwise
3080 */
3081inline Bool TComDataCU::xAddVspCand( Int mrgCandIdx, DisInfo* pDInfo, Int& iCount)
3082{
3083  if ( m_pcSlice->getViewIndex() == 0 || !m_pcSlice->getViewSynthesisPredFlag( ) || m_pcSlice->getIsDepth() || pDInfo->m_aVIdxCan == -1)
3084  {
3085    return false;
3086  }
3087
3088  Int refViewIdx = pDInfo->m_aVIdxCan;
3089  TComPic* picDepth = getSlice()->getIvPic( true, refViewIdx );
3090
3091  if( picDepth == NULL ) // No depth reference avail
3092  {
3093    // Is this allowed to happen? When not an assertion should be added here!
3094    return false;
3095  }
3096
3097  TComMvField mvVSP[2];
3098  UChar dirVSP;
3099  Bool  refViewAvailFlag = false;
3100  UChar predFlag[2]      = {0, 0};
3101
3102  for( Int iRefListIdX = 0; iRefListIdX < 2 && !refViewAvailFlag; iRefListIdX++ )
3103  {
3104    RefPicList eRefPicListX = RefPicList( iRefListIdX );
3105    for ( Int i = 0; i < m_pcSlice->getNumRefIdx(eRefPicListX) && !refViewAvailFlag; i++ )
3106    {
3107      Int viewIdxRefInListX = m_pcSlice->getRefPic(eRefPicListX, i)->getViewIndex();
3108      if ( viewIdxRefInListX == refViewIdx )
3109      {
3110        refViewAvailFlag      = true;
3111        predFlag[iRefListIdX] = 1;
3112        mvVSP[0+iRefListIdX].setMvField( pDInfo->m_acNBDV, i );
3113#if NH_3D_NBDV
3114        mvVSP[0+iRefListIdX].getMv().setIDVFlag (false);
3115#endif
3116      }
3117    }
3118  }
3119
3120  dirVSP = (predFlag[0] | (predFlag[1] << 1));
3121  m_mergCands[MRG_VSP].setCand( mvVSP, dirVSP, true
3122#if NH_3D_SPIVMP
3123    , false
3124#endif
3125    );
3126  if ( mrgCandIdx == iCount )
3127  {
3128    return true;
3129  }
3130
3131  iCount++;
3132
3133  return false;
3134}
3135#endif
3136
3137#if NH_3D_IV_MERGE
3138inline Bool TComDataCU::xAddIvMRGCand( Int mrgCandIdx, Int& iCount, Int* ivCandDir, TComMv* ivCandMv, Int* ivCandRefIdx )
3139{
3140  for(Int iLoop = 0; iLoop < 2; iLoop ++ ) 
3141  {
3142    /// iLoop = 0 --> IvMCShift
3143    /// iLoop = 1 --> IvDCShift  (Derived from IvDC)
3144    if(ivCandDir[iLoop + 2])
3145    {
3146      TComMvField tmpMV[2];
3147      UChar tmpDir = ivCandDir[iLoop + 2];
3148      if( ( ivCandDir[iLoop + 2] & 1 ) == 1 )
3149      {
3150        tmpMV[0].setMvField( ivCandMv[ (iLoop<<1) + 4 ], ivCandRefIdx[ (iLoop<<1) + 4 ] ); 
3151      }
3152      if( ( ivCandDir[iLoop + 2] & 2 ) == 2 )
3153      {
3154        tmpMV[1].setMvField( ivCandMv[ (iLoop<<1) + 5 ], ivCandRefIdx[ (iLoop<<1) + 5 ] );
3155      }
3156     
3157      // Prune IvMC vs. IvMcShift
3158      Bool bRemove = false;     
3159      if( !iLoop && ivCandDir[0] > 0)
3160      {
3161        if(tmpDir == m_mergCands[MRG_IVMC].m_uDir && m_mergCands[MRG_IVMC].m_cMvField[0]==tmpMV[0] && m_mergCands[MRG_IVMC].m_cMvField[1]==tmpMV[1])
3162        {
3163            bRemove                         = true;
3164        }
3165      }
3166      if(!bRemove)
3167      {
3168#if NH_3D_NBDV
3169        if(iLoop) // For IvMcShift candidate
3170        {
3171          tmpMV[0].getMv().setIDVFlag (false);
3172          tmpMV[1].getMv().setIDVFlag (false);
3173        }
3174#endif
3175        m_mergCands[MRG_IVSHIFT].setCand(tmpMV, tmpDir, false, false);
3176        if( mrgCandIdx == iCount )
3177        {
3178          return true;
3179        }
3180        iCount++;
3181      }
3182      break;
3183    }
3184  }
3185  return false;
3186} 
3187
3188#endif
3189#if NH_3D_MLC
3190/** Construct a extended list of merging candidates
3191 * \param pcMvFieldNeighbours
3192 * \param puhInterDirNeighbours
3193 * \param vspFlag
3194 * \param pbSPIVMPFlag
3195 * \param numValidMergeCand
3196 */
3197Void TComDataCU::buildMCL(TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours
3198#if NH_3D_VSP
3199  , Int* vspFlag
3200#endif
3201#if NH_3D_SPIVMP
3202  , Bool* pbSPIVMPFlag
3203#endif
3204  , Int& numValidMergeCand
3205  )
3206{
3207  if (!( getSlice()->getIsDepth() || getSlice()->getViewIndex()>0))
3208  {
3209    return;
3210  }
3211
3212  Int iCount = 0;
3213  TComMv cZeroMv;
3214
3215  // init temporal list
3216  TComMvField extMergeCandList[MRG_MAX_NUM_CANDS_MEM << 1];
3217  UChar uhInterDirNeighboursExt[MRG_MAX_NUM_CANDS_MEM];
3218  for( UInt ui = 0; ui < getSlice()->getMaxNumMergeCand(); ++ui )
3219  {
3220    uhInterDirNeighboursExt[ui] = puhInterDirNeighbours[ui];
3221    extMergeCandList[ui<<1].setMvField(cZeroMv, NOT_VALID);
3222    extMergeCandList[(ui<<1)+1].setMvField(cZeroMv, NOT_VALID);
3223#if NH_3D_VSP
3224    vspFlag[ui] = 0;
3225#endif
3226  }
3227
3228  // insert MPI ... IvShift candidate to extMergeCandList
3229  for (Int i=0; i<=MRG_IVSHIFT; i++)
3230  {
3231    if (m_mergCands[i].m_bAvailable)
3232    {
3233      m_mergCands[i].getCand(iCount, extMergeCandList, uhInterDirNeighboursExt
3234#if NH_3D_VSP
3235        , vspFlag
3236#endif
3237#if NH_3D_SPIVMP
3238        , pbSPIVMPFlag
3239#endif
3240        );
3241      iCount++;
3242      if (iCount >= getSlice()->getMaxNumMergeCand())
3243        break;
3244    }
3245  }
3246
3247  Int iCountBase = m_numSpatialCands;
3248  // insert remaining base candidates to extMergeCandList
3249  while (iCount < getSlice()->getMaxNumMergeCand() && iCountBase < getSlice()->getMaxNumMergeCand())
3250  {
3251    uhInterDirNeighboursExt[iCount] = puhInterDirNeighbours[iCountBase];
3252    extMergeCandList[iCount<<1].setMvField(pcMvFieldNeighbours[iCountBase<<1].getMv(), pcMvFieldNeighbours[iCountBase<<1].getRefIdx());
3253    if ( getSlice()->isInterB() )
3254    {
3255      extMergeCandList[(iCount<<1)+1].setMvField(pcMvFieldNeighbours[(iCountBase<<1)+1].getMv(), pcMvFieldNeighbours[(iCountBase<<1)+1].getRefIdx());
3256    }
3257    iCountBase++;
3258    iCount++;
3259  }
3260
3261  for( UInt ui = 0; ui < getSlice()->getMaxNumMergeCand(); ui++ )
3262  {
3263    puhInterDirNeighbours[ui] = 0;
3264    pcMvFieldNeighbours[ui<<1].setMvField(cZeroMv, NOT_VALID);
3265    pcMvFieldNeighbours[(ui<<1)+1].setMvField(cZeroMv, NOT_VALID);
3266  }
3267  // copy extMergeCandList to output
3268  for( UInt ui = 0; ui < getSlice()->getMaxNumMergeCand(); ui++ )
3269  {
3270    puhInterDirNeighbours[ui] = uhInterDirNeighboursExt[ui];
3271    pcMvFieldNeighbours[ui<<1].setMvField(extMergeCandList[ui<<1].getMv(), extMergeCandList[ui<<1].getRefIdx());
3272    if ( getSlice()->isInterB() )
3273      pcMvFieldNeighbours[(ui<<1)+1].setMvField(extMergeCandList[(ui<<1)+1].getMv(), extMergeCandList[(ui<<1)+1].getRefIdx());
3274  }
3275  numValidMergeCand = iCount;
3276  assert(iCount == getSlice()->getMaxNumMergeCand());
3277}
3278
3279
3280
3281/** Derive 3D merge candidates
3282 * \param uiAbsPartIdx
3283 * \param uiPUIdx
3284 * \param pcMvFieldNeighbours
3285 * \param puhInterDirNeighbours
3286 * \param pcMvFieldSP
3287 * \param puhInterDirNeighbours
3288 * \param numValidMergeCand
3289 */
3290Void TComDataCU::xGetInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours
3291#if NH_3D_SPIVMP
3292      , TComMvField* pcMvFieldSP, UChar* puhInterDirSP
3293#endif
3294      , Int& numValidMergeCand, Int mrgCandIdx
3295)
3296{
3297#if NH_3D_IV_MERGE
3298  TComMv cZeroMv;
3299  TComMvField tmpMV[2]; 
3300#endif
3301
3302  //////////////////////////////////
3303  //////// GET DISPARITIES  ////////
3304  //////////////////////////////////
3305#if NH_3D_IV_MERGE
3306  DisInfo cDisInfo = getDvInfo(uiAbsPartIdx);
3307  m_cDefaultDisInfo = cDisInfo;
3308#elif NH_3D_VSP
3309  // for xAddVspCand()
3310  DisInfo cDisInfo = getDvInfo(uiAbsPartIdx);
3311#endif
3312
3313  if (!( getSlice()->getIsDepth() || getSlice()->getViewIndex()>0))
3314  {
3315    return;
3316  }
3317  numValidMergeCand = getSlice()->getMaxNumMergeCand();
3318  //////////////////////////////////
3319  //////// DERIVE LOCATIONS ////////
3320  //////////////////////////////////
3321  // compute the location of the current PU
3322  Int xP, yP, nPSW, nPSH;
3323  this->getPartPosition(uiPUIdx, xP, yP, nPSW, nPSH);
3324
3325  Int iCount = 0;
3326  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
3327  deriveLeftRightTopIdxGeneral( uiAbsPartIdx, uiPUIdx, uiPartIdxLT, uiPartIdxRT );
3328  deriveLeftBottomIdxGeneral  ( uiAbsPartIdx, uiPUIdx, uiPartIdxLB );
3329#if NH_3D_TEXT_MERGE
3330  Bool bMPIFlag   = getSlice()->getMpiFlag(); 
3331  Int  tmpDir;
3332#endif
3333#if NH_3D_IV_MERGE || NH_3D_TEXT_MERGE
3334  Bool bIsDepth = getSlice()->getIsDepth();
3335#endif
3336
3337#if H_3D_IC
3338  Bool bICFlag = getICFlag(uiAbsPartIdx);
3339#endif
3340#if H_3D_ARP
3341  Bool bARPFlag = getARPW(uiAbsPartIdx) > 0;
3342#endif
3343#if H_3D_DBBP
3344  Bool bDBBPFlag = getDBBPFlag(uiAbsPartIdx);
3345  assert(bDBBPFlag == getDBBPFlag(0)); 
3346#endif
3347
3348#if NH_3D_NBDV
3349  for(Int i = 0; i < MRG_MAX_NUM_CANDS_MEM; i++) 
3350  {
3351    pcMFieldNeighbours[i<<1    ].getMv().setIDVFlag (false);
3352    pcMFieldNeighbours[(i<<1)+1].getMv().setIDVFlag (false);
3353  }
3354#endif
3355  // init containers
3356  for (Int i = 0; i<MRG_IVSHIFT+1; i++)
3357    m_mergCands[i].init();
3358
3359  m_numSpatialCands = 0;
3360
3361  //////////////////////////////////
3362  ///////// GET VSP FLAGS //////////
3363  //////////////////////////////////
3364  //left
3365  UInt uiLeftPartIdx = 0;
3366  TComDataCU* pcCULeft = 0;
3367  pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB ); 
3368
3369  if (getAvailableFlagA1())
3370  {
3371    m_mergCands[MRG_A1].setCand( &pcMFieldNeighbours[m_numSpatialCands<<1], puhInterDirNeighbours[m_numSpatialCands]
3372#if NH_3D_VSP
3373    , (pcCULeft->getVSPFlag(uiLeftPartIdx) != 0
3374#if H_3D_IC
3375      && !bICFlag
3376#endif
3377#if H_3D_ARP
3378      && !bARPFlag
3379#endif
3380#if H_3D_DBBP
3381      && !bDBBPFlag
3382#endif
3383      )
3384#endif
3385#if NH_3D_SPIVMP
3386      , false
3387#endif
3388      ); 
3389    m_numSpatialCands++;
3390  }
3391
3392  // above
3393  if (getAvailableFlagB1())
3394  {
3395    m_mergCands[MRG_B1].setCand( &pcMFieldNeighbours[m_numSpatialCands<<1], puhInterDirNeighbours[m_numSpatialCands]
3396#if NH_3D_VSP
3397    , false
3398#endif
3399#if NH_3D_SPIVMP
3400      , false
3401#endif
3402      ); 
3403    m_numSpatialCands++;
3404  }
3405
3406  // above right
3407  if (getAvailableFlagB0())
3408  {
3409    m_mergCands[MRG_B0].setCand( &pcMFieldNeighbours[m_numSpatialCands<<1], puhInterDirNeighbours[m_numSpatialCands]
3410#if NH_3D_VSP
3411    , false
3412#endif
3413#if NH_3D_SPIVMP
3414      , false
3415#endif
3416      ); 
3417    m_numSpatialCands++;
3418  }
3419
3420  // left bottom
3421  if (getAvailableFlagA0())
3422  {
3423    m_mergCands[MRG_A0].setCand( &pcMFieldNeighbours[m_numSpatialCands<<1], puhInterDirNeighbours[m_numSpatialCands]
3424#if NH_3D_VSP
3425    , false
3426#endif
3427#if NH_3D_SPIVMP
3428      , false
3429#endif
3430      ); 
3431    m_numSpatialCands++;
3432  }
3433
3434  // above left
3435  if (getAvailableFlagB2())
3436  {
3437    m_mergCands[MRG_B2].setCand( &pcMFieldNeighbours[m_numSpatialCands<<1], puhInterDirNeighbours[m_numSpatialCands]
3438#if NH_3D_VSP
3439    , false
3440#endif
3441#if NH_3D_SPIVMP
3442      , false
3443#endif
3444      ); 
3445    m_numSpatialCands++;
3446  }
3447
3448
3449#if NH_3D_TEXT_MERGE
3450
3451  /////////////////////////////////////////////
3452  //////// TEXTURE MERGE CANDIDATE (T) ////////
3453  /////////////////////////////////////////////
3454
3455  bMPIFlag &= (nPSW + nPSH > 12);
3456  if( bMPIFlag)
3457  {
3458    tmpMV[0].setMvField( cZeroMv, NOT_VALID );
3459    tmpMV[1].setMvField( cZeroMv, NOT_VALID );
3460    tmpDir        =  0;
3461
3462    Bool bSPIVMPFlag = false;
3463
3464    TComPic * pcTexPic = m_pcSlice->getTexturePic();
3465#if H_3D_FCO
3466    if (pcTexPic && pcTexPic->getReconMark())
3467    {
3468#endif   
3469      TComPicYuv*   pcTexRec = pcTexPic->getPicYuvRec  ();
3470      UInt          uiPartAddr;
3471      Int           iWidth, iHeight;
3472      Int           iCurrPosX, iCurrPosY;
3473
3474      this->getPartIndexAndSize( uiPUIdx, uiPartAddr, iWidth, iHeight );
3475      pcTexRec->getTopLeftSamplePos( this->getCtuRsAddr(), this->getZorderIdxInCtu() + uiPartAddr, iCurrPosX, iCurrPosY );
3476
3477      Int iPUWidth, iPUHeight, iNumPart, iNumPartLine;
3478      this->getSPPara(iWidth, iHeight, iNumPart, iNumPartLine, iPUWidth, iPUHeight);
3479
3480      for (Int i=0; i<iNumPart; i++)
3481      {
3482        puhInterDirSP[i] = 0;
3483        pcMvFieldSP[2*i].getMv().set(0, 0);
3484        pcMvFieldSP[2*i+1].getMv().set(0, 0);
3485        pcMvFieldSP[2*i].setRefIdx(-1);
3486        pcMvFieldSP[2*i+1].setRefIdx(-1);
3487      }
3488
3489      Int         iTexCUAddr;
3490      Int         iTexAbsPartIdx;
3491      TComDataCU* pcTexCU;
3492      Int iPartition = 0;
3493      Int iInterDirSaved = 0;
3494      TComMvField cMvFieldSaved[2];
3495
3496      Int iOffsetX = iPUWidth/2;;
3497      Int iOffsetY = iPUHeight/2;
3498
3499      Int         iTexPosX, iTexPosY;
3500#if NH_3D_INTEGER_MV_DEPTH
3501      const TComMv cMvRounding( 1 << ( 2 - 1 ), 1 << ( 2 - 1 ) );
3502#endif
3503      Int         iCenterPosX = iCurrPosX + ( ( iWidth /  iPUWidth ) >> 1 )  * iPUWidth + ( iPUWidth >> 1 );
3504      Int         iCenterPosY = iCurrPosY + ( ( iHeight /  iPUHeight ) >> 1 )  * iPUHeight + (iPUHeight >> 1);
3505      Int         iTexCenterCUAddr, iTexCenterAbsPartIdx;
3506
3507      if(iWidth == iPUWidth && iHeight == iPUHeight)
3508      {
3509        iCenterPosX = iCurrPosX + (iWidth >> 1);
3510        iCenterPosY = iCurrPosY + (iHeight >> 1);
3511      }
3512
3513      // derivation of center motion parameters from the collocated texture CU
3514
3515      pcTexRec->getCUAddrAndPartIdx( iCenterPosX , iCenterPosY , iTexCenterCUAddr, iTexCenterAbsPartIdx );
3516      TComDataCU* pcDefaultCU    = pcTexPic->getCtu( iTexCenterCUAddr );
3517
3518      if( pcDefaultCU->getPredictionMode( iTexCenterAbsPartIdx ) != MODE_INTRA )
3519      {
3520        for( UInt uiCurrRefListId = 0; uiCurrRefListId < 2; uiCurrRefListId++ )
3521        {
3522          RefPicList  eCurrRefPicList = RefPicList( uiCurrRefListId );
3523
3524          TComMvField cDefaultMvField;
3525          pcDefaultCU->getMvField( pcDefaultCU, iTexCenterAbsPartIdx, eCurrRefPicList, cDefaultMvField );
3526          Int         iDefaultRefIdx     = cDefaultMvField.getRefIdx();
3527          if (iDefaultRefIdx >= 0)
3528          {
3529            Int iDefaultRefPOC = pcDefaultCU->getSlice()->getRefPOC(eCurrRefPicList, iDefaultRefIdx);
3530            for (Int iRefPicList = 0; iRefPicList < m_pcSlice->getNumRefIdx( eCurrRefPicList ); iRefPicList++)
3531            {
3532              if (iDefaultRefPOC == m_pcSlice->getRefPOC(eCurrRefPicList, iRefPicList))
3533              {
3534                bSPIVMPFlag = true;
3535#if NH_3D_INTEGER_MV_DEPTH
3536                TComMv cMv = cDefaultMvField.getMv() + cMvRounding;
3537                cMv >>= 2;
3538#else
3539                TComMv cMv = cDefaultMvField.getMv();
3540#endif
3541                cMvFieldSaved[eCurrRefPicList].setMvField(cMv, iRefPicList) ;
3542                break;
3543              }
3544            }
3545          }
3546        }
3547      }
3548      if ( bSPIVMPFlag == true )
3549      {   
3550        iInterDirSaved = (cMvFieldSaved[0].getRefIdx()!=-1 ? 1: 0) + (cMvFieldSaved[1].getRefIdx()!=-1 ? 2: 0);
3551        tmpDir = iInterDirSaved;
3552        tmpMV[0] = cMvFieldSaved[0];
3553        tmpMV[1] = cMvFieldSaved[1];
3554      }
3555
3556      if ( iInterDirSaved != 0 )
3557      {
3558        for (Int i=iCurrPosY; i < iCurrPosY + iHeight; i += iPUHeight)
3559        {
3560          for (Int j = iCurrPosX; j < iCurrPosX + iWidth; j += iPUWidth)
3561          {
3562            iTexPosX     = j + iOffsetX;
3563            iTexPosY     = i + iOffsetY; 
3564            pcTexRec->getCUAddrAndPartIdx( iTexPosX, iTexPosY, iTexCUAddr, iTexAbsPartIdx );
3565            pcTexCU  = pcTexPic->getCtu( iTexCUAddr );
3566
3567            if( pcTexCU && !pcTexCU->isIntra(iTexAbsPartIdx) )
3568            {
3569              for( UInt uiCurrRefListId = 0; uiCurrRefListId < 2; uiCurrRefListId++ )
3570              {
3571                RefPicList  eCurrRefPicList = RefPicList( uiCurrRefListId );
3572                TComMvField cTexMvField;
3573                pcTexCU->getMvField( pcTexCU, iTexAbsPartIdx, eCurrRefPicList, cTexMvField );
3574                Int iValidDepRef = getPic()->isTextRefValid( eCurrRefPicList, cTexMvField.getRefIdx() );
3575                if( (cTexMvField.getRefIdx()>=0) && ( iValidDepRef >= 0 ) )
3576                {
3577#if NH_3D_INTEGER_MV_DEPTH
3578                  TComMv cMv = cTexMvField.getMv() + cMvRounding;
3579                  cMv >>=2;         
3580#else
3581                  TComMv cMv = cTexMvField.getMv();
3582#endif         
3583                  pcMvFieldSP[2*iPartition + uiCurrRefListId].setMvField(cMv, iValidDepRef);
3584                }
3585              }
3586            }
3587            puhInterDirSP[iPartition] = (pcMvFieldSP[2*iPartition].getRefIdx()!=-1 ? 1: 0) + (pcMvFieldSP[2*iPartition+1].getRefIdx()!=-1 ? 2: 0);
3588            if (puhInterDirSP[iPartition] == 0)
3589            {
3590              if (iInterDirSaved != 0)
3591              {
3592                puhInterDirSP[iPartition] = iInterDirSaved;
3593                pcMvFieldSP[2*iPartition] = cMvFieldSaved[0];
3594                pcMvFieldSP[2*iPartition + 1] = cMvFieldSaved[1];
3595              }
3596            }
3597
3598            iPartition ++;
3599          }
3600        }
3601      }
3602#if H_3D_FCO
3603    }
3604#endif
3605    if( tmpDir != 0 )
3606    {
3607      Int iCnloop = 0;
3608      for(iCnloop = 0; iCnloop < 2; iCnloop ++)
3609      {
3610        if ( !m_mergCands[MRG_A1+iCnloop].m_bAvailable )  // prunning to A1, B1
3611        {
3612          continue;
3613        }
3614        if (tmpDir == m_mergCands[MRG_A1+iCnloop].m_uDir && tmpMV[0]==m_mergCands[MRG_A1+iCnloop].m_cMvField[0] && tmpMV[1]==m_mergCands[MRG_A1+iCnloop].m_cMvField[1])
3615        {
3616          m_mergCands[MRG_A1+iCnloop].m_bAvailable = false;
3617          break;
3618        }     
3619      }
3620      m_mergCands[MRG_T].setCand( tmpMV, tmpDir, false, bSPIVMPFlag);
3621
3622      if ( mrgCandIdx == iCount )
3623      {
3624        return;
3625      }
3626      iCount ++;
3627    }
3628  }
3629#endif
3630
3631#if NH_3D_IV_MERGE
3632  /////////////////////////////////////////////////////////////////
3633  //////// DERIVE IvMC, IvMCShift,IvDCShift, IvDC  Candidates /////
3634  /////////////////////////////////////////////////////////////////
3635
3636  // { IvMCL0, IvMCL1, IvDCL0, IvDCL1, IvMCL0Shift, IvMCL1Shift, IvDCL0Shift, IvDCL1Shift }; 
3637  // An enumerator would be appropriate here!
3638  TComMv ivCandMv    [8];
3639  Int    ivCandRefIdx[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
3640
3641  // { IvMC, IvDC, IvMCShift, IvDCShift }; 
3642  Int    ivCandDir   [4] = {0, 0, 0, 0};
3643
3644  Bool ivMvPredFlag   = getSlice()->getIvMvPredFlag();
3645
3646  ivMvPredFlag &= (nPSW + nPSH > 12);
3647  if ( ivMvPredFlag && cDisInfo.m_aVIdxCan!=-1)
3648  {
3649#if H_3D_IC
3650    getInterViewMergeCands(uiPUIdx, ivCandRefIdx, ivCandMv, &cDisInfo, ivCandDir , bIsDepth, pcMvFieldSP, puhInterDirSP, bICFlag );
3651#else
3652    getInterViewMergeCands(uiPUIdx, ivCandRefIdx, ivCandMv, &cDisInfo, ivCandDir , bIsDepth, pcMvFieldSP, puhInterDirSP, false );
3653#endif
3654  } 
3655
3656  ///////////////////////////////////////////////
3657  //////// INTER VIEW MOTION COMP(IvMC) /////////
3658  ///////////////////////////////////////////////
3659  if( getSlice()->getIsDepth() )
3660  {
3661    ivCandDir[1] = ivCandDir[2] = ivCandDir[3] = 0;
3662  }
3663
3664  if( ivCandDir[0] )
3665  {
3666    tmpMV[0].setMvField( cZeroMv, NOT_VALID );
3667    tmpMV[1].setMvField( cZeroMv, NOT_VALID );
3668
3669    if( ( ivCandDir[0] & 1 ) == 1 )
3670    {
3671      tmpMV[0].setMvField( ivCandMv[ 0 ], ivCandRefIdx[ 0 ] );
3672    }
3673    if( ( ivCandDir[0] & 2 ) == 2 )
3674    {
3675      tmpMV[1].setMvField( ivCandMv[ 1 ], ivCandRefIdx[ 1 ] );
3676    }
3677
3678    Bool bRemoveSpa = false; //pruning
3679
3680    if (!bIsDepth)
3681    {
3682      for(Int i = 0; i < 2; i ++)
3683      {
3684        if ( !m_mergCands[MRG_A1 + i].m_bAvailable ) // prunning to A1, B1
3685        {
3686          continue;
3687        }
3688        if (ivCandDir[0] == m_mergCands[MRG_A1+i].m_uDir && tmpMV[0]==m_mergCands[MRG_A1+i].m_cMvField[0] && tmpMV[1]==m_mergCands[MRG_A1+i].m_cMvField[1])
3689        {
3690          m_mergCands[MRG_A1+i].m_bAvailable = false;
3691          break;
3692        }     
3693      }
3694    }
3695    if (bIsDepth)
3696    {
3697      if (m_mergCands[MRG_T].m_bAvailable && ivCandDir[0] == m_mergCands[MRG_T].m_uDir && tmpMV[0]==m_mergCands[MRG_T].m_cMvField[0] && tmpMV[1]==m_mergCands[MRG_T].m_cMvField[1])
3698      {
3699        bRemoveSpa                      = true;
3700      }
3701    }
3702    if (!bRemoveSpa)
3703    {
3704      Bool spiMvpFlag = false;
3705      if(!m_pcSlice->getIsDepth())
3706      {
3707        spiMvpFlag = true;
3708      }
3709#if H_3D_DBBP
3710      spiMvpFlag &= !bDBBPFlag;
3711#endif
3712
3713      m_mergCands[MRG_IVMC].setCand( tmpMV, ivCandDir[0], false, spiMvpFlag);
3714
3715      if ( mrgCandIdx == iCount )
3716      {
3717        return;
3718      }
3719      iCount ++;
3720    }
3721  } 
3722
3723  // early termination
3724  if (iCount == getSlice()->getMaxNumMergeCand()) 
3725  {
3726    return;
3727  }
3728#endif
3729
3730  iCount += m_mergCands[MRG_A1].m_bAvailable + m_mergCands[MRG_B1].m_bAvailable;
3731
3732#if NH_3D_VSP
3733  /////////////////////////////////////////////////
3734  //////// VIEW SYNTHESIS PREDICTION (VSP) ////////
3735  /////////////////////////////////////////////////
3736  if (iCount<getSlice()->getMaxNumMergeCand())
3737  {
3738    if (
3739      (!getAvailableFlagA1() || !(pcCULeft->getVSPFlag(uiLeftPartIdx) != 0)) &&
3740#if H_3D_IC
3741      !bICFlag &&
3742#endif
3743#if H_3D_ARP
3744      !bARPFlag &&
3745#endif
3746#if H_3D
3747      (nPSW + nPSH > 12) &&
3748#endif
3749#if H_3D_DBBP
3750      !bDBBPFlag &&
3751#endif
3752      xAddVspCand( mrgCandIdx, &cDisInfo, iCount ) )
3753    {
3754      return;
3755    }
3756
3757    // early termination
3758    if (iCount == getSlice()->getMaxNumMergeCand())
3759    {
3760      return;
3761    }
3762  }
3763#endif
3764
3765  iCount += m_mergCands[MRG_B0].m_bAvailable;
3766
3767#if NH_3D_IV_MERGE
3768  /////////////////////////////////////////////
3769  //////// INTER VIEW DISP COMP (IvDC) ////////
3770  /////////////////////////////////////////////
3771  if( ivCandDir[1] && iCount < getSlice()->getMaxNumMergeCand() && !getSlice()->getIsDepth() )
3772  {
3773    assert(iCount < getSlice()->getMaxNumMergeCand());
3774
3775    tmpMV[0].setMvField( cZeroMv, NOT_VALID );
3776    tmpMV[1].setMvField( cZeroMv, NOT_VALID );
3777    if( ( ivCandDir[1] & 1 ) == 1 )
3778    {
3779      tmpMV[0].setMvField( ivCandMv[ 2 ], ivCandRefIdx[ 2 ] );
3780    }
3781    if( ( ivCandDir[1] & 2 ) == 2 )
3782    {
3783      tmpMV[1].setMvField( ivCandMv[ 3 ], ivCandRefIdx[ 3 ] );
3784    }
3785
3786    Bool bRemoveSpa = false; //pruning to A1, B1
3787    for(Int i = 0; i < 2; i ++)
3788    {
3789      if ( !m_mergCands[MRG_A1+i].m_bAvailable ) 
3790      {
3791        continue;
3792      }
3793      if (ivCandDir[1] == m_mergCands[MRG_A1+i].m_uDir && tmpMV[0]==m_mergCands[MRG_A1+i].m_cMvField[0] && tmpMV[1]==m_mergCands[MRG_A1+i].m_cMvField[1])
3794      {
3795        bRemoveSpa                      = true;
3796        break;
3797      }     
3798    }
3799    if(!bRemoveSpa)
3800    {
3801#if NH_3D_NBDV
3802      tmpMV[0].getMv().setIDVFlag (false);
3803      tmpMV[1].getMv().setIDVFlag (false);
3804#endif
3805      m_mergCands[MRG_IVDC].setCand( tmpMV, ivCandDir[1], false, false);
3806
3807      if ( mrgCandIdx == iCount )
3808        return;
3809      iCount ++;
3810
3811      // early termination
3812      if (iCount == getSlice()->getMaxNumMergeCand()) 
3813      {
3814        return;
3815      }
3816    }
3817  } 
3818#endif // H_3D_IV_MERGE
3819
3820  iCount += m_mergCands[MRG_A0].m_bAvailable + m_mergCands[MRG_B2].m_bAvailable;
3821
3822#if NH_3D_IV_MERGE
3823  ////////////////////////////////////////////////////
3824  //////// SHIFTED IV (IvMCShift + IvDCShift) ////////
3825  ////////////////////////////////////////////////////
3826  if(  ivMvPredFlag && iCount < getSlice()->getMaxNumMergeCand() && !getSlice()->getIsDepth() ) 
3827  {
3828    if(xAddIvMRGCand( mrgCandIdx,  iCount, ivCandDir, ivCandMv, ivCandRefIdx ) )
3829    {
3830      return;
3831    }
3832    //early termination
3833    if (iCount == getSlice()->getMaxNumMergeCand()) 
3834    {
3835      return;
3836    }
3837  }
3838#endif
3839}
3840#endif
3841
3842//! Construct a list of merging candidates
3843Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx )
3844{
3845  UInt uiAbsPartAddr = m_absZIdxInCtu + uiAbsPartIdx;
3846#if NH_3D_MLC
3847  Bool abCandIsInter[ MRG_MAX_NUM_CANDS_MEM ];
3848#else
3849  Bool abCandIsInter[ MRG_MAX_NUM_CANDS ];
3850#endif
3851  for( UInt ui = 0; ui < getSlice()->getMaxNumMergeCand(); ++ui )
3852  {
3853    abCandIsInter[ui] = false;
3854    pcMvFieldNeighbours[ ( ui << 1 )     ].setRefIdx(NOT_VALID);
3855    pcMvFieldNeighbours[ ( ui << 1 ) + 1 ].setRefIdx(NOT_VALID);
3856  }
3857  numValidMergeCand = getSlice()->getMaxNumMergeCand();
3858  // compute the location of the current PU
3859  Int xP, yP, nPSW, nPSH;
3860  this->getPartPosition(uiPUIdx, xP, yP, nPSW, nPSH);
3861
3862  Int iCount = 0;
3863
3864  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
3865  PartSize cCurPS = getPartitionSize( uiAbsPartIdx );
3866  deriveLeftRightTopIdxGeneral( uiAbsPartIdx, uiPUIdx, uiPartIdxLT, uiPartIdxRT );
3867  deriveLeftBottomIdxGeneral( uiAbsPartIdx, uiPUIdx, uiPartIdxLB );
3868
3869  //left
3870  UInt uiLeftPartIdx = 0;
3871  TComDataCU* pcCULeft = 0;
3872  pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB );
3873
3874  Bool isAvailableA1 = pcCULeft &&
3875                       pcCULeft->isDiffMER(xP -1, yP+nPSH-1, xP, yP) &&
3876                       !( uiPUIdx == 1 && (cCurPS == SIZE_Nx2N || cCurPS == SIZE_nLx2N || cCurPS == SIZE_nRx2N) ) &&
3877                       pcCULeft->isInter( uiLeftPartIdx ) ;
3878
3879  if ( isAvailableA1 )
3880  {
3881#if NH_3D_MLC
3882    m_bAvailableFlagA1 = 1;
3883#endif
3884    abCandIsInter[iCount] = true;
3885    // get Inter Dir
3886    puhInterDirNeighbours[iCount] = pcCULeft->getInterDir( uiLeftPartIdx );
3887    // get Mv from Left
3888    pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3889    if ( getSlice()->isInterB() )
3890    {
3891      pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3892    }
3893    if ( mrgCandIdx == iCount )
3894    {
3895      return;
3896    }
3897    iCount ++;
3898  }
3899
3900  // early termination
3901  if (iCount == getSlice()->getMaxNumMergeCand())
3902  {
3903    return;
3904  }
3905  // above
3906  UInt uiAbovePartIdx = 0;
3907  TComDataCU* pcCUAbove = 0;
3908  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT );
3909
3910  Bool isAvailableB1 = pcCUAbove &&
3911                       pcCUAbove->isDiffMER(xP+nPSW-1, yP-1, xP, yP) &&
3912                       !( uiPUIdx == 1 && (cCurPS == SIZE_2NxN || cCurPS == SIZE_2NxnU || cCurPS == SIZE_2NxnD) ) &&
3913                       pcCUAbove->isInter( uiAbovePartIdx );
3914
3915  if ( isAvailableB1 && (!isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAbove, uiAbovePartIdx ) ) )
3916  {
3917#if NH_3D_MLC
3918    m_bAvailableFlagB1 = 1;
3919#endif
3920    abCandIsInter[iCount] = true;
3921    // get Inter Dir
3922    puhInterDirNeighbours[iCount] = pcCUAbove->getInterDir( uiAbovePartIdx );
3923    // get Mv from Left
3924    pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3925    if ( getSlice()->isInterB() )
3926    {
3927      pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3928    }
3929    if ( mrgCandIdx == iCount )
3930    {
3931      return;
3932    }
3933    iCount ++;
3934  }
3935  // early termination
3936  if (iCount == getSlice()->getMaxNumMergeCand())
3937  {
3938    return;
3939  }
3940
3941  // above right
3942  UInt uiAboveRightPartIdx = 0;
3943  TComDataCU* pcCUAboveRight = 0;
3944  pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT );
3945
3946  Bool isAvailableB0 = pcCUAboveRight &&
3947                       pcCUAboveRight->isDiffMER(xP+nPSW, yP-1, xP, yP) &&
3948                       pcCUAboveRight->isInter( uiAboveRightPartIdx );
3949
3950  if ( isAvailableB0 && ( !isAvailableB1 || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
3951  {
3952#if NH_3D_MLC
3953    m_bAvailableFlagB0 = 1;
3954#endif
3955    abCandIsInter[iCount] = true;
3956    // get Inter Dir
3957    puhInterDirNeighbours[iCount] = pcCUAboveRight->getInterDir( uiAboveRightPartIdx );
3958    // get Mv from Left
3959    pcCUAboveRight->getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3960    if ( getSlice()->isInterB() )
3961    {
3962      pcCUAboveRight->getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3963    }
3964    if ( mrgCandIdx == iCount )
3965    {
3966      return;
3967    }
3968    iCount ++;
3969  }
3970  // early termination
3971  if (iCount == getSlice()->getMaxNumMergeCand())
3972  {
3973    return;
3974  }
3975
3976  //left bottom
3977  UInt uiLeftBottomPartIdx = 0;
3978  TComDataCU* pcCULeftBottom = 0;
3979  pcCULeftBottom = this->getPUBelowLeft( uiLeftBottomPartIdx, uiPartIdxLB );
3980
3981  Bool isAvailableA0 = pcCULeftBottom &&
3982                       pcCULeftBottom->isDiffMER(xP-1, yP+nPSH, xP, yP) &&
3983                       pcCULeftBottom->isInter( uiLeftBottomPartIdx ) ;
3984
3985  if ( isAvailableA0 && ( !isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
3986  {
3987#if NH_3D_MLC
3988    m_bAvailableFlagA0 = 1;
3989#endif
3990    abCandIsInter[iCount] = true;
3991    // get Inter Dir
3992    puhInterDirNeighbours[iCount] = pcCULeftBottom->getInterDir( uiLeftBottomPartIdx );
3993    // get Mv from Left
3994    pcCULeftBottom->getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3995    if ( getSlice()->isInterB() )
3996    {
3997      pcCULeftBottom->getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3998    }
3999    if ( mrgCandIdx == iCount )
4000    {
4001      return;
4002    }
4003    iCount ++;
4004  }
4005  // early termination
4006  if (iCount == getSlice()->getMaxNumMergeCand())
4007  {
4008    return;
4009  }
4010
4011  // above left
4012  if( iCount < 4 )
4013  {
4014    UInt uiAboveLeftPartIdx = 0;
4015    TComDataCU* pcCUAboveLeft = 0;
4016    pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr );
4017
4018    Bool isAvailableB2 = pcCUAboveLeft &&
4019                         pcCUAboveLeft->isDiffMER(xP-1, yP-1, xP, yP) &&
4020                         pcCUAboveLeft->isInter( uiAboveLeftPartIdx );
4021
4022    if ( isAvailableB2 && ( !isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
4023        && ( !isAvailableB1 || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) ) )
4024    {
4025#if NH_3D_MLC
4026      m_bAvailableFlagB2 = 1;
4027#endif
4028      abCandIsInter[iCount] = true;
4029      // get Inter Dir
4030      puhInterDirNeighbours[iCount] = pcCUAboveLeft->getInterDir( uiAboveLeftPartIdx );
4031      // get Mv from Left
4032      pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
4033      if ( getSlice()->isInterB() )
4034      {
4035        pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
4036      }
4037      if ( mrgCandIdx == iCount )
4038      {
4039        return;
4040      }
4041      iCount ++;
4042    }
4043  }
4044  // early termination
4045  if (iCount == getSlice()->getMaxNumMergeCand())
4046  {
4047    return;
4048  }
4049
4050  if ( getSlice()->getEnableTMVPFlag() )
4051  {
4052    //>> MTK colocated-RightBottom
4053    UInt uiPartIdxRB;
4054
4055    deriveRightBottomIdx( uiPUIdx, uiPartIdxRB );
4056
4057    UInt uiAbsPartIdxTmp = g_auiZscanToRaster[uiPartIdxRB];
4058    const UInt numPartInCtuWidth  = m_pcPic->getNumPartInCtuWidth();
4059    const UInt numPartInCtuHeight = m_pcPic->getNumPartInCtuHeight();
4060
4061    TComMv cColMv;
4062    Int iRefIdx;
4063    Int ctuRsAddr = -1;
4064
4065    if (   ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth () ) < m_pcSlice->getSPS()->getPicWidthInLumaSamples () )  // image boundary check
4066        && ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() ) < m_pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
4067    {
4068      if ( ( uiAbsPartIdxTmp % numPartInCtuWidth < numPartInCtuWidth - 1 ) &&           // is not at the last column of CTU
4069        ( uiAbsPartIdxTmp / numPartInCtuWidth < numPartInCtuHeight - 1 ) )              // is not at the last row    of CTU
4070      {
4071        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + numPartInCtuWidth + 1 ];
4072        ctuRsAddr = getCtuRsAddr();
4073      }
4074      else if ( uiAbsPartIdxTmp % numPartInCtuWidth < numPartInCtuWidth - 1 )           // is not at the last column of CTU But is last row of CTU
4075      {
4076        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdxTmp + numPartInCtuWidth + 1) % m_pcPic->getNumPartitionsInCtu() ];
4077      }
4078      else if ( uiAbsPartIdxTmp / numPartInCtuWidth < numPartInCtuHeight - 1 )          // is not at the last row of CTU But is last column of CTU
4079      {
4080        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + 1 ];
4081        ctuRsAddr = getCtuRsAddr() + 1;
4082      }
4083      else //is the right bottom corner of CTU
4084      {
4085        uiAbsPartAddr = 0;
4086      }
4087    }
4088
4089    iRefIdx = 0;
4090
4091    Bool bExistMV = false;
4092    UInt uiPartIdxCenter;
4093    Int dir = 0;
4094    UInt uiArrayAddr = iCount;
4095    xDeriveCenterIdx( uiPUIdx, uiPartIdxCenter );
4096    bExistMV = ctuRsAddr >= 0 && xGetColMVP( REF_PIC_LIST_0, ctuRsAddr, uiAbsPartAddr, cColMv, iRefIdx );
4097    if( bExistMV == false )
4098    {
4099      bExistMV = xGetColMVP( REF_PIC_LIST_0, getCtuRsAddr(), uiPartIdxCenter,  cColMv, iRefIdx );
4100    }
4101    if( bExistMV )
4102    {
4103      dir |= 1;
4104      pcMvFieldNeighbours[ 2 * uiArrayAddr ].setMvField( cColMv, iRefIdx );
4105    }
4106
4107    if ( getSlice()->isInterB() )
4108    {
4109#if H_3D_TMVP
4110      iRefIdx = 0;
4111#endif
4112      bExistMV = ctuRsAddr >= 0 && xGetColMVP( REF_PIC_LIST_1, ctuRsAddr, uiAbsPartAddr, cColMv, iRefIdx);
4113      if( bExistMV == false )
4114      {
4115        bExistMV = xGetColMVP( REF_PIC_LIST_1, getCtuRsAddr(), uiPartIdxCenter, cColMv, iRefIdx );
4116      }
4117      if( bExistMV )
4118      {
4119        dir |= 2;
4120        pcMvFieldNeighbours[ 2 * uiArrayAddr + 1 ].setMvField( cColMv, iRefIdx );
4121      }
4122    }
4123
4124    if (dir != 0)
4125    {
4126      puhInterDirNeighbours[uiArrayAddr] = dir;
4127      abCandIsInter[uiArrayAddr] = true;
4128#if NH_3D_NBDV
4129      pcMvFieldNeighbours[iCount<<1    ].getMv().setIDVFlag (false);
4130      pcMvFieldNeighbours[(iCount<<1)+1].getMv().setIDVFlag (false);
4131#endif
4132
4133      if ( mrgCandIdx == iCount )
4134      {
4135        return;
4136      }
4137      iCount++;
4138    }
4139  }
4140  // early termination
4141  if (iCount == getSlice()->getMaxNumMergeCand())
4142  {
4143    return;
4144  }
4145
4146  UInt uiArrayAddr = iCount;
4147  UInt uiCutoff = uiArrayAddr;
4148
4149#if NH_3D_MLC
4150  if ( getSlice()->isInterB() && iCount<5)
4151#else
4152  if ( getSlice()->isInterB() )
4153#endif
4154  {
4155    static const UInt NUM_PRIORITY_LIST=12;
4156    static const UInt uiPriorityList0[NUM_PRIORITY_LIST] = {0 , 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3};
4157    static const UInt uiPriorityList1[NUM_PRIORITY_LIST] = {1 , 0, 2, 0, 2, 1, 3, 0, 3, 1, 3, 2};
4158
4159    for (Int idx=0; idx<uiCutoff*(uiCutoff-1) && uiArrayAddr!= getSlice()->getMaxNumMergeCand(); idx++)
4160    {
4161      assert(idx<NUM_PRIORITY_LIST);
4162      Int i = uiPriorityList0[idx];
4163      Int j = uiPriorityList1[idx];
4164      if (abCandIsInter[i] && abCandIsInter[j]&& (puhInterDirNeighbours[i]&0x1)&&(puhInterDirNeighbours[j]&0x2))
4165      {
4166        abCandIsInter[uiArrayAddr] = true;
4167        puhInterDirNeighbours[uiArrayAddr] = 3;
4168
4169        // get Mv from cand[i] and cand[j]
4170        pcMvFieldNeighbours[uiArrayAddr << 1].setMvField(pcMvFieldNeighbours[i<<1].getMv(), pcMvFieldNeighbours[i<<1].getRefIdx());
4171        pcMvFieldNeighbours[( uiArrayAddr << 1 ) + 1].setMvField(pcMvFieldNeighbours[(j<<1)+1].getMv(), pcMvFieldNeighbours[(j<<1)+1].getRefIdx());
4172
4173        Int iRefPOCL0 = m_pcSlice->getRefPOC( REF_PIC_LIST_0, pcMvFieldNeighbours[(uiArrayAddr<<1)].getRefIdx() );
4174        Int iRefPOCL1 = m_pcSlice->getRefPOC( REF_PIC_LIST_1, pcMvFieldNeighbours[(uiArrayAddr<<1)+1].getRefIdx() );
4175        if (iRefPOCL0 == iRefPOCL1 && pcMvFieldNeighbours[(uiArrayAddr<<1)].getMv() == pcMvFieldNeighbours[(uiArrayAddr<<1)+1].getMv())
4176        {
4177          abCandIsInter[uiArrayAddr] = false;
4178        }
4179        else
4180        {
4181          uiArrayAddr++;
4182        }
4183      }
4184    }
4185  }
4186  // early termination
4187  if (uiArrayAddr == getSlice()->getMaxNumMergeCand())
4188  {
4189    return;
4190  }
4191
4192  Int iNumRefIdx = (getSlice()->isInterB()) ? min(m_pcSlice->getNumRefIdx(REF_PIC_LIST_0), m_pcSlice->getNumRefIdx(REF_PIC_LIST_1)) : m_pcSlice->getNumRefIdx(REF_PIC_LIST_0);
4193
4194  Int r = 0;
4195  Int refcnt = 0;
4196  while (uiArrayAddr < getSlice()->getMaxNumMergeCand())
4197  {
4198    abCandIsInter[uiArrayAddr] = true;
4199    puhInterDirNeighbours[uiArrayAddr] = 1;
4200    pcMvFieldNeighbours[uiArrayAddr << 1].setMvField( TComMv(0, 0), r);
4201
4202    if ( getSlice()->isInterB() )
4203    {
4204      puhInterDirNeighbours[uiArrayAddr] = 3;
4205      pcMvFieldNeighbours[(uiArrayAddr << 1) + 1].setMvField(TComMv(0, 0), r);
4206    }
4207    uiArrayAddr++;
4208
4209    if ( refcnt == iNumRefIdx - 1 )
4210    {
4211      r = 0;
4212    }
4213    else
4214    {
4215      ++r;
4216      ++refcnt;
4217    }
4218  }
4219  numValidMergeCand = uiArrayAddr;
4220}
4221
4222/** Check whether the current PU and a spatial neighboring PU are in a same ME region.
4223 * \param xN, yN   location of the upper-left corner pixel of a neighboring PU
4224 * \param xP, yP   location of the upper-left corner pixel of the current PU
4225 */
4226Bool TComDataCU::isDiffMER(Int xN, Int yN, Int xP, Int yP)
4227{
4228
4229  UInt plevel = this->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() + 2;
4230  if ((xN>>plevel)!= (xP>>plevel))
4231  {
4232    return true;
4233  }
4234  if ((yN>>plevel)!= (yP>>plevel))
4235  {
4236    return true;
4237  }
4238  return false;
4239}
4240
4241/** Calculate the location of upper-left corner pixel and size of the current PU.
4242 * \param partIdx       PU index within a CU
4243 * \param xP, yP        location of the upper-left corner pixel of the current PU
4244 * \param nPSW, nPSH    size of the current PU
4245 */
4246Void TComDataCU::getPartPosition( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH)
4247{
4248  UInt col = m_uiCUPelX;
4249  UInt row = m_uiCUPelY;
4250
4251  switch ( m_pePartSize[0] )
4252  {
4253  case SIZE_2NxN:
4254    nPSW = getWidth(0);
4255    nPSH = getHeight(0) >> 1;
4256    xP   = col;
4257    yP   = (partIdx ==0)? row: row + nPSH;
4258    break;
4259  case SIZE_Nx2N:
4260    nPSW = getWidth(0) >> 1;
4261    nPSH = getHeight(0);
4262    xP   = (partIdx ==0)? col: col + nPSW;
4263    yP   = row;
4264    break;
4265  case SIZE_NxN:
4266    nPSW = getWidth(0) >> 1;
4267    nPSH = getHeight(0) >> 1;
4268    xP   = col + (partIdx&0x1)*nPSW;
4269    yP   = row + (partIdx>>1)*nPSH;
4270    break;
4271  case SIZE_2NxnU:
4272    nPSW = getWidth(0);
4273    nPSH = ( partIdx == 0 ) ?  getHeight(0) >> 2 : ( getHeight(0) >> 2 ) + ( getHeight(0) >> 1 );
4274    xP   = col;
4275    yP   = (partIdx ==0)? row: row + getHeight(0) - nPSH;
4276
4277    break;
4278  case SIZE_2NxnD:
4279    nPSW = getWidth(0);
4280    nPSH = ( partIdx == 0 ) ?  ( getHeight(0) >> 2 ) + ( getHeight(0) >> 1 ) : getHeight(0) >> 2;
4281    xP   = col;
4282    yP   = (partIdx ==0)? row: row + getHeight(0) - nPSH;
4283    break;
4284  case SIZE_nLx2N:
4285    nPSW = ( partIdx == 0 ) ? getWidth(0) >> 2 : ( getWidth(0) >> 2 ) + ( getWidth(0) >> 1 );
4286    nPSH = getHeight(0);
4287    xP   = (partIdx ==0)? col: col + getWidth(0) - nPSW;
4288    yP   = row;
4289    break;
4290  case SIZE_nRx2N:
4291    nPSW = ( partIdx == 0 ) ? ( getWidth(0) >> 2 ) + ( getWidth(0) >> 1 ) : getWidth(0) >> 2;
4292    nPSH = getHeight(0);
4293    xP   = (partIdx ==0)? col: col + getWidth(0) - nPSW;
4294    yP   = row;
4295    break;
4296  default:
4297    assert ( m_pePartSize[0] == SIZE_2Nx2N );
4298    nPSW = getWidth(0);
4299    nPSH = getHeight(0);
4300    xP   = col ;
4301    yP   = row ;
4302
4303    break;
4304  }
4305}
4306
4307/** Constructs a list of candidates for AMVP
4308 * \param uiPartIdx
4309 * \param uiPartAddr
4310 * \param eRefPicList
4311 * \param iRefIdx
4312 * \param pInfo
4313 */
4314Void TComDataCU::fillMvpCand ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo )
4315{
4316  TComMv cMvPred;
4317  Bool bAddedSmvp = false;
4318
4319  pInfo->iN = 0;
4320  if (iRefIdx < 0)
4321  {
4322    return;
4323  }
4324
4325  //-- Get Spatial MV
4326  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
4327  const UInt numPartInCtuWidth  = m_pcPic->getNumPartInCtuWidth();
4328  const UInt numPartInCtuHeight = m_pcPic->getNumPartInCtuHeight();
4329  Bool bAdded = false;
4330
4331  deriveLeftRightTopIdx( uiPartIdx, uiPartIdxLT, uiPartIdxRT );
4332  deriveLeftBottomIdx( uiPartIdx, uiPartIdxLB );
4333
4334  TComDataCU* tmpCU = NULL;
4335  UInt idx;
4336  tmpCU = getPUBelowLeft(idx, uiPartIdxLB);
4337  bAddedSmvp = (tmpCU != NULL) && (tmpCU->isInter(idx));
4338
4339  if (!bAddedSmvp)
4340  {
4341    tmpCU = getPULeft(idx, uiPartIdxLB);
4342    bAddedSmvp = (tmpCU != NULL) && (tmpCU->isInter(idx));
4343  }
4344
4345  // Left predictor search
4346  bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_BELOW_LEFT);
4347  if (!bAdded)
4348  {
4349    bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_LEFT );
4350  }
4351
4352  if(!bAdded)
4353  {
4354    bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_BELOW_LEFT);
4355    if (!bAdded)
4356    {
4357      xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_LEFT );
4358    }
4359  }
4360
4361  // Above predictor search
4362  bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE_RIGHT);
4363
4364  if (!bAdded)
4365  {
4366    bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE);
4367  }
4368
4369  if(!bAdded)
4370  {
4371    xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
4372  }
4373
4374  if(!bAddedSmvp)
4375  {
4376    bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE_RIGHT);
4377    if (!bAdded)
4378    {
4379      bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE);
4380    }
4381
4382    if(!bAdded)
4383    {
4384      xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
4385    }
4386  }
4387
4388  if ( pInfo->iN == 2 )
4389  {
4390    if ( pInfo->m_acMvCand[ 0 ] == pInfo->m_acMvCand[ 1 ] )
4391    {
4392      pInfo->iN = 1;
4393    }
4394  }
4395
4396  if ( getSlice()->getEnableTMVPFlag() )
4397  {
4398    // Get Temporal Motion Predictor
4399    Int iRefIdx_Col = iRefIdx;
4400    TComMv cColMv;
4401    UInt uiPartIdxRB;
4402    UInt uiAbsPartIdx;
4403    UInt uiAbsPartAddr;
4404
4405    deriveRightBottomIdx( uiPartIdx, uiPartIdxRB );
4406    uiAbsPartAddr = m_absZIdxInCtu + uiPartAddr;
4407
4408    //----  co-located RightBottom Temporal Predictor (H) ---//
4409    uiAbsPartIdx = g_auiZscanToRaster[uiPartIdxRB];
4410    Int ctuRsAddr = -1;
4411    if (  ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdx] + m_pcPic->getMinCUWidth () ) < m_pcSlice->getSPS()->getPicWidthInLumaSamples () )  // image boundary check
4412       && ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdx] + m_pcPic->getMinCUHeight() ) < m_pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
4413    {
4414      if ( ( uiAbsPartIdx % numPartInCtuWidth < numPartInCtuWidth - 1 ) &&  // is not at the last column of CTU
4415           ( uiAbsPartIdx / numPartInCtuWidth < numPartInCtuHeight - 1 ) )  // is not at the last row    of CTU
4416      {
4417        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdx + numPartInCtuWidth + 1 ];
4418        ctuRsAddr = getCtuRsAddr();
4419      }
4420      else if ( uiAbsPartIdx % numPartInCtuWidth < numPartInCtuWidth - 1 )  // is not at the last column of CTU But is last row of CTU
4421      {
4422        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdx + numPartInCtuWidth + 1) % m_pcPic->getNumPartitionsInCtu() ];
4423      }
4424      else if ( uiAbsPartIdx / numPartInCtuWidth < numPartInCtuHeight - 1 ) // is not at the last row of CTU But is last column of CTU
4425      {
4426        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdx + 1 ];
4427        ctuRsAddr = getCtuRsAddr() + 1;
4428      }
4429      else //is the right bottom corner of CTU
4430      {
4431        uiAbsPartAddr = 0;
4432      }
4433    }
4434    if ( ctuRsAddr >= 0 && xGetColMVP( eRefPicList, ctuRsAddr, uiAbsPartAddr, cColMv, iRefIdx_Col
4435#if H_3D_TMVP
4436         , 0
4437#endif
4438 ) )
4439    {
4440      pInfo->m_acMvCand[pInfo->iN++] = cColMv;
4441    }
4442    else
4443    {
4444      UInt uiPartIdxCenter;
4445      xDeriveCenterIdx( uiPartIdx, uiPartIdxCenter );
4446      if (xGetColMVP( eRefPicList, getCtuRsAddr(), uiPartIdxCenter,  cColMv, iRefIdx_Col
4447#if H_3D_TMVP
4448         , 0
4449#endif
4450))
4451      {
4452        pInfo->m_acMvCand[pInfo->iN++] = cColMv;
4453      }
4454    }
4455    //----  co-located RightBottom Temporal Predictor  ---//
4456  }
4457
4458  if (pInfo->iN > AMVP_MAX_NUM_CANDS)
4459  {
4460    pInfo->iN = AMVP_MAX_NUM_CANDS;
4461  }
4462
4463  while (pInfo->iN < AMVP_MAX_NUM_CANDS)
4464  {
4465    pInfo->m_acMvCand[pInfo->iN].set(0,0);
4466    pInfo->iN++;
4467  }
4468  return ;
4469}
4470
4471
4472Bool TComDataCU::isBipredRestriction(UInt puIdx)
4473{
4474  Int width = 0;
4475  Int height = 0;
4476  UInt partAddr;
4477
4478#if H_3D_DBBP
4479  if( getDBBPFlag(0) )
4480  {
4481    return true;
4482  }
4483#endif
4484
4485  getPartIndexAndSize( puIdx, partAddr, width, height );
4486  if ( getWidth(0) == 8 && (width < 8 || height < 8) )
4487  {
4488    return true;
4489  }
4490  return false;
4491}
4492
4493
4494Void TComDataCU::clipMv    (TComMv&  rcMv)
4495{
4496  const TComSPS &sps=*(m_pcSlice->getSPS());
4497  Int  iMvShift = 2;
4498#if NH_3D_INTEGER_MV_DEPTH
4499  if( getSlice()->getIsDepth() )
4500    iMvShift = 0;
4501#endif
4502
4503  Int iOffset = 8;
4504  Int iHorMax = ( sps.getPicWidthInLumaSamples() + iOffset - (Int)m_uiCUPelX - 1 ) << iMvShift;
4505  Int iHorMin = (      -(Int)sps.getMaxCUWidth() - iOffset - (Int)m_uiCUPelX + 1 ) << iMvShift;
4506
4507  Int iVerMax = ( sps.getPicHeightInLumaSamples() + iOffset - (Int)m_uiCUPelY - 1 ) << iMvShift;
4508  Int iVerMin = (      -(Int)sps.getMaxCUHeight() - iOffset - (Int)m_uiCUPelY + 1 ) << iMvShift;
4509
4510  rcMv.setHor( min (iHorMax, max (iHorMin, rcMv.getHor())) );
4511  rcMv.setVer( min (iVerMax, max (iVerMin, rcMv.getVer())) );
4512}
4513
4514#if NH_MV
4515Void TComDataCU::checkMvVertRest (TComMv&  rcMv,  RefPicList eRefPicList, int iRefIdx )
4516{
4517  if ( getSlice()->getSPS()->getInterViewMvVertConstraintFlag() )
4518  {
4519    if ( getSlice()->getRefPic( eRefPicList, iRefIdx )->getPOC() == getSlice()->getPOC() )
4520    {
4521        //When inter_view_mv_vert_constraint_flag is equal to 1,
4522        //the vertical component of the motion vectors used for inter-layer prediction
4523        //shall be equal to or less than 56 in units of luma samples
4524        assert ( rcMv.getVer() <= (56<<2) );
4525    }
4526  }
4527}
4528#endif
4529
4530UInt TComDataCU::getIntraSizeIdx(UInt uiAbsPartIdx)
4531{
4532  UInt uiShift = ( m_pePartSize[uiAbsPartIdx]==SIZE_NxN ? 1 : 0 );
4533
4534  UChar uiWidth = m_puhWidth[uiAbsPartIdx]>>uiShift;
4535  UInt  uiCnt = 0;
4536  while( uiWidth )
4537  {
4538    uiCnt++;
4539    uiWidth>>=1;
4540  }
4541  uiCnt-=2;
4542  return uiCnt > 6 ? 6 : uiCnt;
4543}
4544
4545Void TComDataCU::clearCbf( UInt uiIdx, ComponentID compID, UInt uiNumParts )
4546{
4547  memset( &m_puhCbf[compID][uiIdx], 0, sizeof(UChar)*uiNumParts);
4548}
4549
4550/** Set a I_PCM flag for all sub-partitions of a partition.
4551 * \param bIpcmFlag I_PCM flag
4552 * \param uiAbsPartIdx patition index
4553 * \param uiDepth CU depth
4554 * \returns Void
4555 */
4556Void TComDataCU::setIPCMFlagSubParts  (Bool bIpcmFlag, UInt uiAbsPartIdx, UInt uiDepth)
4557{
4558  UInt uiCurrPartNumb = m_pcPic->getNumPartitionsInCtu() >> (uiDepth << 1);
4559
4560  memset(m_pbIPCMFlag + uiAbsPartIdx, bIpcmFlag, sizeof(Bool)*uiCurrPartNumb );
4561}
4562
4563/** Test whether the block at uiPartIdx is skipped.
4564 * \param uiPartIdx Partition index
4565 * \returns true if the current the block is skipped
4566 */
4567Bool TComDataCU::isSkipped( UInt uiPartIdx )
4568{
4569  return ( getSkipFlag( uiPartIdx ) );
4570}
4571
4572#if H_3D_IC
4573Bool TComDataCU::isIC( UInt uiPartIdx )
4574{
4575    if ( m_pcSlice->isIntra () )
4576    {
4577        return false;
4578    }
4579    return ( ( getSkipFlag(uiPartIdx) || getPredictionMode(uiPartIdx) == MODE_INTER) && getICFlag( uiPartIdx ) && isICFlagRequired( uiPartIdx ) );
4580}
4581#endif
4582
4583// ====================================================================================================================
4584// Protected member functions
4585// ====================================================================================================================
4586
4587Bool TComDataCU::xAddMVPCand( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir )
4588{
4589  TComDataCU* pcTmpCU = NULL;
4590  UInt uiIdx;
4591  switch( eDir )
4592  {
4593    case MD_LEFT:
4594    {
4595      pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx);
4596      break;
4597    }
4598    case MD_ABOVE:
4599    {
4600      pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx);
4601      break;
4602    }
4603    case MD_ABOVE_RIGHT:
4604    {
4605      pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx);
4606      break;
4607    }
4608    case MD_BELOW_LEFT:
4609    {
4610      pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx);
4611      break;
4612    }
4613    case MD_ABOVE_LEFT:
4614    {
4615      pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx);
4616      break;
4617    }
4618    default:
4619    {
4620      break;
4621    }
4622  }
4623
4624  if ( pcTmpCU == NULL )
4625  {
4626    return false;
4627  }
4628
4629  if ( pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0 && m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC() == pcTmpCU->getSlice()->getRefPOC( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ))
4630  {
4631    TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
4632
4633    pInfo->m_acMvCand[ pInfo->iN++] = cMvPred;
4634    return true;
4635  }
4636
4637  RefPicList eRefPicList2nd = REF_PIC_LIST_0;
4638  if(       eRefPicList == REF_PIC_LIST_0 )
4639  {
4640    eRefPicList2nd = REF_PIC_LIST_1;
4641  }
4642  else if ( eRefPicList == REF_PIC_LIST_1)
4643  {
4644    eRefPicList2nd = REF_PIC_LIST_0;
4645  }
4646
4647
4648  Int iCurrRefPOC = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC();
4649  Int iNeibRefPOC;
4650
4651
4652  if( pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) >= 0 )
4653  {
4654    iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) );
4655    if( iNeibRefPOC == iCurrRefPOC ) // Same Reference Frame But Diff List//
4656    {
4657      TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
4658      pInfo->m_acMvCand[ pInfo->iN++] = cMvPred;
4659      return true;
4660    }
4661  }
4662  return false;
4663}
4664
4665/**
4666 * \param pInfo
4667 * \param eRefPicList
4668 * \param iRefIdx
4669 * \param uiPartUnitIdx
4670 * \param eDir
4671 * \returns Bool
4672 */
4673Bool TComDataCU::xAddMVPCandOrder( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir )
4674{
4675  TComDataCU* pcTmpCU = NULL;
4676  UInt uiIdx;
4677  switch( eDir )
4678  {
4679  case MD_LEFT:
4680    {
4681      pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx);
4682      break;
4683    }
4684  case MD_ABOVE:
4685    {
4686      pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx);
4687      break;
4688    }
4689  case MD_ABOVE_RIGHT:
4690    {
4691      pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx);
4692      break;
4693    }
4694  case MD_BELOW_LEFT:
4695    {
4696      pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx);
4697      break;
4698    }
4699  case MD_ABOVE_LEFT:
4700    {
4701      pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx);
4702      break;
4703    }
4704  default:
4705    {
4706      break;
4707    }
4708  }
4709
4710  if ( pcTmpCU == NULL )
4711  {
4712    return false;
4713  }
4714
4715  RefPicList eRefPicList2nd = REF_PIC_LIST_0;
4716  if(       eRefPicList == REF_PIC_LIST_0 )
4717  {
4718    eRefPicList2nd = REF_PIC_LIST_1;
4719  }
4720  else if ( eRefPicList == REF_PIC_LIST_1)
4721  {
4722    eRefPicList2nd = REF_PIC_LIST_0;
4723  }
4724
4725  Int iCurrPOC = m_pcSlice->getPOC();
4726  Int iCurrRefPOC = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC();
4727  Int iNeibPOC = iCurrPOC;
4728  Int iNeibRefPOC;
4729  Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getIsLongTerm();
4730  Bool bIsNeibRefLongTerm = false;
4731
4732  //---------------  V1 (END) ------------------//
4733  if( pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0)
4734  {
4735    iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) );
4736    TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
4737    TComMv rcMv;
4738
4739    bIsNeibRefLongTerm = pcTmpCU->getSlice()->getRefPic( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) )->getIsLongTerm();
4740    if ( bIsCurrRefLongTerm == bIsNeibRefLongTerm )
4741    {
4742      if ( bIsCurrRefLongTerm || bIsNeibRefLongTerm )
4743      {
4744        rcMv = cMvPred;
4745      }
4746      else
4747      {
4748        Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
4749        if ( iScale == 4096 )
4750        {
4751          rcMv = cMvPred;
4752        }
4753        else
4754        {
4755          rcMv = cMvPred.scaleMv( iScale );
4756        }
4757      }
4758
4759      pInfo->m_acMvCand[ pInfo->iN++] = rcMv;
4760      return true;
4761    }
4762  }
4763  //---------------------- V2(END) --------------------//
4764  if( pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) >= 0)
4765  {
4766    iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) );
4767    TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
4768    TComMv rcMv;
4769
4770    bIsNeibRefLongTerm = pcTmpCU->getSlice()->getRefPic( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) )->getIsLongTerm();
4771    if ( bIsCurrRefLongTerm == bIsNeibRefLongTerm )
4772    {
4773      if ( bIsCurrRefLongTerm || bIsNeibRefLongTerm )
4774      {
4775        rcMv = cMvPred;
4776      }
4777      else
4778      {
4779        Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
4780        if ( iScale == 4096 )
4781        {
4782          rcMv = cMvPred;
4783        }
4784        else
4785        {
4786          rcMv = cMvPred.scaleMv( iScale );
4787        }
4788      }
4789
4790      pInfo->m_acMvCand[ pInfo->iN++] = rcMv;
4791      return true;
4792    }
4793  }
4794  //---------------------- V3(END) --------------------//
4795  return false;
4796}
4797
4798Bool TComDataCU::xGetColMVP( RefPicList eRefPicList, Int ctuRsAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx
4799#if H_3D_TMVP
4800  , Bool bMRG
4801#endif
4802)
4803{
4804  UInt uiAbsPartAddr = uiPartUnitIdx;
4805
4806  RefPicList  eColRefPicList;
4807  Int iColPOC, iColRefPOC, iCurrPOC, iCurrRefPOC, iScale;
4808  TComMv cColMv;
4809
4810  // use coldir.
4811  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
4812  TComDataCU *pColCtu = pColPic->getCtu( ctuRsAddr );
4813  if(pColCtu->getPic()==0||pColCtu->getPartitionSize(uiPartUnitIdx)==NUMBER_OF_PART_SIZES)
4814  {
4815    return false;
4816  }
4817  iCurrPOC = m_pcSlice->getPOC();
4818  iColPOC = pColCtu->getSlice()->getPOC();
4819
4820  if (!pColCtu->isInter(uiAbsPartAddr))
4821  {
4822    return false;
4823  }
4824
4825  eColRefPicList = getSlice()->getCheckLDC() ? eRefPicList : RefPicList(getSlice()->getColFromL0Flag());
4826
4827  Int iColRefIdx = pColCtu->getCUMvField(RefPicList(eColRefPicList))->getRefIdx(uiAbsPartAddr);
4828
4829  if (iColRefIdx < 0 )
4830  {
4831    eColRefPicList = RefPicList(1 - eColRefPicList);
4832    iColRefIdx = pColCtu->getCUMvField(RefPicList(eColRefPicList))->getRefIdx(uiAbsPartAddr);
4833
4834    if (iColRefIdx < 0 )
4835    {
4836      return false;
4837    }
4838  }
4839
4840  // Scale the vector.
4841  iColRefPOC = pColCtu->getSlice()->getRefPOC(eColRefPicList, iColRefIdx);
4842  cColMv = pColCtu->getCUMvField(eColRefPicList)->getMv(uiAbsPartAddr);
4843
4844  iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
4845
4846  Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getIsLongTerm();
4847  Bool bIsColRefLongTerm = pColCtu->getSlice()->getIsUsedAsLongTerm(eColRefPicList, iColRefIdx);
4848
4849  if ( bIsCurrRefLongTerm != bIsColRefLongTerm )
4850  {
4851#if H_3D_TMVP
4852    Int iAlterRefIdx  = m_pcSlice->getAlterRefIdx(eRefPicList);
4853    if(bMRG && iAlterRefIdx > 0)
4854    {
4855      riRefIdx = iAlterRefIdx;
4856      bIsCurrRefLongTerm = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getIsLongTerm();
4857      iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
4858      assert(bIsCurrRefLongTerm == bIsColRefLongTerm);
4859    }
4860    else
4861    {
4862#endif
4863    return false;
4864#if H_3D_TMVP
4865    }
4866#endif
4867  }
4868
4869  if ( bIsCurrRefLongTerm || bIsColRefLongTerm )
4870  {
4871#if H_3D_TMVP
4872    Int iCurrViewId    = m_pcSlice->getViewId (); 
4873    Int iCurrRefViewId = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewId (); 
4874    Int iColViewId     = pColCU->getSlice()->getViewId(); 
4875    Int iColRefViewId  = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewId(); 
4876    iScale = 4096;
4877    if ( iCurrRefViewId != iCurrViewId && iColViewId != iColRefViewId )
4878    {
4879      iScale = xGetDistScaleFactor( iCurrViewId, iCurrRefViewId, iColViewId, iColRefViewId );
4880    }
4881    if ( bMRG && iScale != 4096 && m_pcSlice->getIvMvScalingFlag( ) ) 
4882    {
4883      rcMv = cColMv.scaleMv( iScale );
4884    }
4885    else
4886    {
4887#endif
4888    rcMv = cColMv;
4889#if H_3D_TMVP
4890    }
4891#endif
4892  }
4893  else
4894  {
4895    iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
4896    if ( iScale == 4096 )
4897    {
4898      rcMv = cColMv;
4899    }
4900    else
4901    {
4902      rcMv = cColMv.scaleMv( iScale );
4903    }
4904  }
4905
4906  return true;
4907}
4908
4909Int TComDataCU::xGetDistScaleFactor(Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC)
4910{
4911  Int iDiffPocD = iColPOC - iColRefPOC;
4912  Int iDiffPocB = iCurrPOC - iCurrRefPOC;
4913
4914  if( iDiffPocD == iDiffPocB )
4915  {
4916    return 4096;
4917  }
4918  else
4919  {
4920    Int iTDB      = Clip3( -128, 127, iDiffPocB );
4921    Int iTDD      = Clip3( -128, 127, iDiffPocD );
4922    Int iX        = (0x4000 + abs(iTDD/2)) / iTDD;
4923    Int iScale    = Clip3( -4096, 4095, (iTDB * iX + 32) >> 6 );
4924    return iScale;
4925  }
4926}
4927
4928Void TComDataCU::xDeriveCenterIdx( UInt uiPartIdx, UInt& ruiPartIdxCenter )
4929{
4930  UInt uiPartAddr;
4931  Int  iPartWidth;
4932  Int  iPartHeight;
4933  getPartIndexAndSize( uiPartIdx, uiPartAddr, iPartWidth, iPartHeight);
4934
4935  ruiPartIdxCenter = m_absZIdxInCtu+uiPartAddr; // partition origin.
4936  ruiPartIdxCenter = g_auiRasterToZscan[ g_auiZscanToRaster[ ruiPartIdxCenter ]
4937                                        + ( iPartHeight/m_pcPic->getMinCUHeight()  )/2*m_pcPic->getNumPartInCtuWidth()
4938                                        + ( iPartWidth/m_pcPic->getMinCUWidth()  )/2];
4939}
4940
4941#if NH_3D
4942Void TComDataCU::compressMV(Int scale)
4943{
4944   Int scaleFactor = (4 / scale ) * AMVP_DECIMATION_FACTOR / m_unitSize;
4945#else
4946Void TComDataCU::compressMV()
4947{
4948  Int scaleFactor = 4 * AMVP_DECIMATION_FACTOR / m_unitSize;
4949#endif
4950  if (scaleFactor > 0)
4951  {
4952    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
4953    {
4954      m_acCUMvField[i].compress(m_pePredMode, scaleFactor);
4955    }
4956  }
4957}
4958
4959UInt TComDataCU::getCoefScanIdx(const UInt uiAbsPartIdx, const UInt uiWidth, const UInt uiHeight, const ComponentID compID) const
4960{
4961  //------------------------------------------------
4962
4963  //this mechanism is available for intra only
4964
4965  if (!isIntra(uiAbsPartIdx))
4966  {
4967    return SCAN_DIAG;
4968  }
4969
4970  //------------------------------------------------
4971
4972  //check that MDCS can be used for this TU
4973
4974  const ChromaFormat format = getPic()->getChromaFormat();
4975
4976  const UInt maximumWidth  = MDCS_MAXIMUM_WIDTH  >> getComponentScaleX(compID, format);
4977  const UInt maximumHeight = MDCS_MAXIMUM_HEIGHT >> getComponentScaleY(compID, format);
4978
4979  if ((uiWidth > maximumWidth) || (uiHeight > maximumHeight))
4980  {
4981    return SCAN_DIAG;
4982  }
4983
4984  //------------------------------------------------
4985
4986  //otherwise, select the appropriate mode
4987
4988  UInt uiDirMode  = getIntraDir(toChannelType(compID), uiAbsPartIdx);
4989
4990#if H_3D_DIM
4991    mapDepthModeToIntraDir( uiDirMode );
4992#endif
4993
4994  if (uiDirMode==DM_CHROMA_IDX)
4995  {
4996    const TComSPS *sps=getSlice()->getSPS();
4997    const UInt partsPerMinCU = 1<<(2*(sps->getMaxTotalCUDepth() - sps->getLog2DiffMaxMinCodingBlockSize()));
4998    uiDirMode = getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, getPic()->getChromaFormat(), partsPerMinCU));
4999#if H_3D_DIM
5000      mapDepthModeToIntraDir( uiDirMode );
5001#endif
5002  }
5003
5004  if (isChroma(compID) && (format == CHROMA_422))
5005  {
5006    uiDirMode = g_chroma422IntraAngleMappingTable[uiDirMode];
5007  }
5008
5009  //------------------
5010
5011  if      (abs((Int)uiDirMode - VER_IDX) <= MDCS_ANGLE_LIMIT)
5012  {
5013    return SCAN_HOR;
5014  }
5015  else if (abs((Int)uiDirMode - HOR_IDX) <= MDCS_ANGLE_LIMIT)
5016  {
5017    return SCAN_VER;
5018  }
5019  else
5020  {
5021    return SCAN_DIAG;
5022  }
5023}
5024
5025#if NH_3D_VSO
5026Void TComDataCU::getPosInPic( UInt uiAbsPartIndex, Int& riPosX, Int& riPosY ) const
5027{
5028  riPosX = g_auiRasterToPelX[g_auiZscanToRaster[uiAbsPartIndex]] + getCUPelX();
5029  riPosY = g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIndex]] + getCUPelY(); 
5030}
5031#endif
5032
5033#if NH_3D_IV_MERGE
5034Void TComDataCU::getDispforDepth (UInt uiPartIdx, UInt uiPartAddr, DisInfo* pDisp)
5035{
5036  assert(getPartitionSize( uiPartAddr ) == SIZE_2Nx2N);
5037
5038  TComMv cMv; 
5039  if ( getSlice()->getDefaultRefViewIdxAvailableFlag() )
5040  {
5041    Int iViewIdx = getSlice()->getDefaultRefViewIdx();
5042    pDisp->m_aVIdxCan = iViewIdx;
5043    Int iDisp     = getSlice()->getDepthToDisparityB( iViewIdx )[ (Int64) (1 << ( getSlice()->getSPS()->getBitDepth(CHANNEL_TYPE_LUMA) - 1 )) ];
5044
5045    cMv.setHor(iDisp);
5046    cMv.setVer(0);
5047    pDisp->m_acNBDV = cMv;
5048    pDisp->m_aVIdxCan = iViewIdx;
5049  }
5050}
5051#endif
5052
5053#if H_3D
5054Bool TComDataCU::getNeighDepth ( UInt uiPartIdx, UInt uiPartAddr, Pel* pNeighDepth, Int index )
5055{
5056  UInt  uiPartIdxLT, uiPartIdxRT;
5057  this->deriveLeftRightTopIdxAdi( uiPartIdxLT, uiPartIdxRT, 0, 0 );
5058  UInt uiMidPart, uiPartNeighbor; 
5059  TComDataCU* pcCUNeighbor;
5060  Bool bDepAvail = false;
5061  Pel *pDepth  = this->getPic()->getPicYuvRec()->getLumaAddr();
5062  Int iDepStride =  this->getPic()->getPicYuvRec()->getStride();
5063
5064  Int xP, yP, nPSW, nPSH;
5065  this->getPartPosition( uiPartIdx, xP, yP, nPSW, nPSH );
5066
5067  switch( index )
5068  {
5069  case 0: // Mid Left
5070    uiMidPart = g_auiZscanToRaster[uiPartIdxLT] + (nPSH>>1) / this->getPic()->getMinCUHeight() * this->getPic()->getNumPartInWidth();
5071    pcCUNeighbor = this->getPULeft( uiPartNeighbor, g_auiRasterToZscan[uiMidPart] );
5072    if ( pcCUNeighbor )
5073    {
5074      if( !this->getSlice()->getPPS()->getConstrainedIntraPred() )
5075      {
5076        *pNeighDepth = pDepth[ (yP+(nPSH>>1)) * iDepStride + (xP-1) ];
5077        bDepAvail = true;
5078      }
5079      else if ( pcCUNeighbor->getPredictionMode( uiPartNeighbor ) == MODE_INTRA )
5080      {
5081        *pNeighDepth = pDepth[ (yP+(nPSH>>1)) * iDepStride + (xP-1) ];
5082        bDepAvail = true;
5083      }
5084    }
5085    break;
5086  case 1: // Mid Above
5087    uiMidPart = g_auiZscanToRaster[uiPartIdxLT] + (nPSW>>1) / this->getPic()->getMinCUWidth();
5088    pcCUNeighbor = this->getPUAbove( uiPartNeighbor, g_auiRasterToZscan[uiMidPart] );
5089    if( pcCUNeighbor )
5090    {
5091      if( !this->getSlice()->getPPS()->getConstrainedIntraPred() )
5092      {
5093        *pNeighDepth = pDepth[ (yP-1) * iDepStride + (xP + (nPSW>>1)) ];
5094        bDepAvail = true;
5095      }
5096      else if ( pcCUNeighbor->getPredictionMode( uiPartNeighbor ) == MODE_INTRA )
5097      {
5098        *pNeighDepth = pDepth[ (yP-1) * iDepStride + (xP + (nPSW>>1)) ];
5099        bDepAvail = true;
5100      }
5101    }
5102    break;
5103  default:
5104    break;
5105  }
5106
5107  return bDepAvail;
5108}
5109#endif
5110#if NH_3D_NBDV
5111//Notes from QC:
5112//TBD#1: DoNBDV related contributions are just partially integrated under the marco of NH_3D_NBDV_REF, remove this comment once DoNBDV and BVSP are done
5113//TBD#2: set of DvMCP values need to be done as part of inter-view motion prediction process. Remove this comment once merge related integration is done
5114//To be checked: Parallel Merge features for NBDV, related to DV_DERIVATION_PARALLEL_B0096 and LGE_IVMP_PARALLEL_MERGE_B0136 are not integrated. The need of these features due to the adoption of CU-based NBDV is not clear. We need confirmation on this, especially by proponents
5115Void TComDataCU::getDisMvpCandNBDV( DisInfo* pDInfo
5116#if NH_3D_NBDV_REF
5117, Bool bDepthRefine
5118#endif
5119)
5120{
5121  //// ******* Init variables ******* /////
5122  // Init disparity struct for results
5123  pDInfo->m_aVIdxCan = -1;
5124
5125  // Init struct for disparities from MCP neighboring blocks
5126  IDVInfo cIDVInfo;
5127  cIDVInfo.m_bFound = false; 
5128  UInt uiPartIdx = 0;
5129  UInt uiPartAddr = 0;
5130  for (UInt iCurDvMcpCand = 0; iCurDvMcpCand < IDV_CANDS; iCurDvMcpCand++)
5131  {
5132    for (UInt iList = 0; iList < 2; iList++)
5133    {
5134      cIDVInfo.m_acMvCand[iList][iCurDvMcpCand].setZero();
5135      cIDVInfo.m_aVIdxCan[iList][iCurDvMcpCand] = 0; 
5136      cIDVInfo.m_bAvailab[iList][iCurDvMcpCand] = false; 
5137    }
5138  }
5139#if NH_3D_NBDV_REF
5140  if( !m_pcSlice->getDepthRefinementFlag( ) )
5141  {
5142    bDepthRefine = false;
5143  }
5144#endif
5145  // Get Positions 
5146  PartSize eCUMode    = getPartitionSize( uiPartAddr );   
5147  assert(eCUMode == SIZE_2Nx2N);
5148  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB; 
5149
5150  deriveLeftRightTopIdxGeneral(uiPartAddr, uiPartIdx, uiPartIdxLT, uiPartIdxRT );
5151  deriveLeftBottomIdxGeneral  (uiPartAddr, uiPartIdx, uiPartIdxLB );
5152
5153  //// ******* Get disparity from temporal neighboring blocks ******* /////
5154  if ( getSlice()->getEnableTMVPFlag() )
5155  {
5156    TComMv cColMv;
5157    Int iTargetViewIdx = 0;
5158    Int iTStartViewIdx = 0;   
5159
5160    ///*** Derive center position ***
5161    UInt uiPartIdxCenter;
5162    Int  uiLCUIdx = getCtuRsAddr();
5163    xDeriveCenterIdx(uiPartIdx, uiPartIdxCenter );
5164
5165    ///*** Search temporal candidate pictures for disparity vector ***
5166    const Int iNumCandPics = getPic()->getNumDdvCandPics();
5167    for(Int curCandPic = 0; curCandPic < iNumCandPics; curCandPic++)
5168    {
5169      RefPicList eCurRefPicList   = REF_PIC_LIST_0 ;
5170      Int        curCandPicRefIdx = 0;
5171      if( curCandPic == 0 ) 
5172      { 
5173        eCurRefPicList   = RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0);
5174        curCandPicRefIdx = getSlice()->getColRefIdx();
5175      }
5176      else                 
5177      {
5178        eCurRefPicList   = getPic()->getRapRefList();
5179        curCandPicRefIdx = getPic()->getRapRefIdx();
5180      }
5181
5182      Bool bCheck = xGetColDisMV( curCandPic, eCurRefPicList, curCandPicRefIdx, uiLCUIdx,   uiPartIdxCenter,  cColMv, iTargetViewIdx, iTStartViewIdx );
5183
5184      if( bCheck )
5185      {
5186        pDInfo->m_acNBDV = cColMv;
5187        pDInfo->m_aVIdxCan  = iTargetViewIdx;
5188
5189#if NH_3D_NBDV_REF
5190        TComPic* picDepth = NULL;   
5191#if H_3D_FCO_VSP_DONBDV_E0163
5192        picDepth  = getSlice()->getIvPic(true, getSlice()->getViewIndex() );
5193        if ( picDepth->getPicYuvRec() != NULL  ) 
5194        {
5195          cColMv.setZero();
5196        }
5197        else // Go back with virtual depth
5198        {
5199          picDepth = getSlice()->getIvPic( true, iTargetViewIdx );
5200        }
5201
5202        assert(picDepth != NULL);
5203#else
5204        picDepth = getSlice()->getIvPic( true, iTargetViewIdx );
5205#endif
5206        if (picDepth && bDepthRefine)
5207        {
5208          estimateDVFromDM(iTargetViewIdx, uiPartIdx, picDepth, uiPartAddr, &cColMv );
5209        }
5210        pDInfo->m_acDoNBDV  = cColMv;
5211#endif //NH_3D_NBDV_REF
5212        return;
5213      }
5214    }
5215  } 
5216
5217  UInt uiIdx = 0;
5218  Bool        bCheckMcpDv = false;   
5219  TComDataCU* pcTmpCU     = NULL;
5220
5221  //// ******* Get disparity from left block ******* /////
5222  pcTmpCU = getPULeft(uiIdx, uiPartIdxLB, true, false);
5223  bCheckMcpDv = true; 
5224  if ( xCheckSpatialNBDV( pcTmpCU, uiIdx, pDInfo, bCheckMcpDv, &cIDVInfo, DVFROM_LEFT
5225#if NH_3D_NBDV_REF
5226    , bDepthRefine
5227#endif
5228    ) )
5229    return;
5230
5231  //// ******* Get disparity from above block ******* /////
5232  pcTmpCU = getPUAbove(uiIdx, uiPartIdxRT, true, false, true);
5233  if(pcTmpCU != NULL )
5234  {
5235    bCheckMcpDv = ( ( getCtuRsAddr() - pcTmpCU->getCtuRsAddr() ) == 0);
5236    if ( xCheckSpatialNBDV( pcTmpCU, uiIdx, pDInfo, bCheckMcpDv, &cIDVInfo, DVFROM_ABOVE
5237#if NH_3D_NBDV_REF
5238      , bDepthRefine
5239#endif
5240      ) )
5241      return;
5242  }
5243
5244  //// ******* Search MCP blocks ******* /////
5245  if( cIDVInfo.m_bFound ) 
5246  {
5247    for( Int curPos = 0 ; curPos < IDV_CANDS ; curPos++ ) 
5248    {
5249      for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
5250      {
5251        if( cIDVInfo.m_bAvailab[iList][curPos] )
5252        {
5253          TComMv cDispVec = cIDVInfo.m_acMvCand[iList][ curPos ];
5254          pDInfo->m_acNBDV = cDispVec;
5255          pDInfo->m_aVIdxCan = cIDVInfo.m_aVIdxCan[iList][ curPos ];
5256#if NH_3D_NBDV_REF
5257#if H_3D_FCO_VSP_DONBDV_E0163
5258          TComPic* picDepth  = NULL;
5259
5260          picDepth  = getSlice()->getIvPic(true, getSlice()->getViewIndex() );
5261          if ( picDepth->getPicYuvRec() != NULL ) 
5262          {
5263            cDispVec.setZero();
5264          }
5265          else // Go back with virtual depth
5266          {
5267            picDepth = getSlice()->getIvPic( true, pDInfo->m_aVIdxCan );
5268          }
5269
5270          assert(picDepth != NULL);
5271#else
5272          TComPic* picDepth = getSlice()->getIvPic( true, pDInfo->m_aVIdxCan );
5273#endif
5274
5275          if (picDepth && bDepthRefine)
5276          {
5277            estimateDVFromDM (pDInfo->m_aVIdxCan, uiPartIdx, picDepth, uiPartAddr, &cDispVec);
5278          }
5279          pDInfo->m_acDoNBDV = cDispVec;
5280#endif
5281          return;
5282        }
5283      }
5284    }
5285  }
5286
5287  TComMv defaultDV(0, 0);
5288  pDInfo->m_acNBDV = defaultDV;
5289
5290  if (getSlice()->getDefaultRefViewIdxAvailableFlag())
5291  {
5292    pDInfo->m_aVIdxCan = getSlice()->getDefaultRefViewIdx();
5293
5294#if NH_3D_NBDV_REF
5295    TComPic* picDepth = NULL;
5296#if H_3D_FCO_VSP_DONBDV_E0163
5297    picDepth  = getSlice()->getIvPic(true, getSlice()->getViewIndex() );
5298    if ( picDepth->getPicYuvRec() != NULL ) 
5299    {
5300      defaultDV.setZero();
5301    }
5302    else // Go back with virtual depth
5303    {
5304      picDepth = getSlice()->getIvPic( true, getSlice()->getDefaultRefViewIdx());
5305    }
5306
5307    assert(picDepth != NULL);
5308#else
5309    picDepth = getSlice()->getIvPic( true, getSlice()->getDefaultRefViewIdx());
5310#endif
5311    if (picDepth && bDepthRefine)
5312    {
5313      estimateDVFromDM(getSlice()->getDefaultRefViewIdx(), uiPartIdx, picDepth, uiPartAddr, &defaultDV ); // from base view
5314    }
5315    pDInfo->m_acDoNBDV = defaultDV;
5316#endif
5317  }
5318}
5319
5320#if NH_3D_NBDV_REF
5321Pel TComDataCU::getMcpFromDM(TComPicYuv* pcBaseViewDepthPicYuv, TComMv* mv, Int iBlkX, Int iBlkY, Int iBlkWidth, Int iBlkHeight, Int* aiShiftLUT )
5322{
5323  Int iPictureWidth  = pcBaseViewDepthPicYuv->getWidth(COMPONENT_Y);
5324  Int iPictureHeight = pcBaseViewDepthPicYuv->getHeight(COMPONENT_Y);
5325
5326  Int depthStartPosX = Clip3(0,   iPictureWidth - 1,  iBlkX + ((mv->getHor()+2)>>2));
5327  Int depthStartPosY = Clip3(0,   iPictureHeight - 1, iBlkY + ((mv->getVer()+2)>>2));
5328  Int depthEndPosX   = Clip3(0,   iPictureWidth - 1,  iBlkX + iBlkWidth - 1 + ((mv->getHor()+2)>>2));
5329  Int depthEndPosY   = Clip3(0,   iPictureHeight - 1, iBlkY + iBlkHeight - 1 + ((mv->getVer()+2)>>2));
5330
5331  Pel* depthTL  = pcBaseViewDepthPicYuv->getAddr(COMPONENT_Y);
5332  Int depStride =  pcBaseViewDepthPicYuv->getStride(COMPONENT_Y);
5333
5334  Pel  maxDepthVal = 0;
5335  maxDepthVal = std::max( maxDepthVal, depthTL[ (depthStartPosY) * depStride + depthStartPosX ]);      // Left Top
5336  maxDepthVal = std::max( maxDepthVal, depthTL[ (depthEndPosY)   * depStride + depthStartPosX ]);      // Left Bottom
5337  maxDepthVal = std::max( maxDepthVal, depthTL[ (depthStartPosY) * depStride + depthEndPosX   ]);      // Right Top
5338  maxDepthVal = std::max( maxDepthVal, depthTL[ (depthEndPosY)   * depStride + depthEndPosX   ]);      // Right Bottom
5339
5340  return aiShiftLUT[ maxDepthVal ];
5341}
5342
5343Void TComDataCU::estimateDVFromDM(Int refViewIdx, UInt uiPartIdx, TComPic* picDepth, UInt uiPartAddr, TComMv* cMvPred )
5344{
5345  if (picDepth)
5346  {
5347    UInt uiAbsPartAddrCurrCU = m_absZIdxInCtu + uiPartAddr;
5348    Int iWidth, iHeight;
5349    getPartIndexAndSize( uiPartIdx, uiPartAddr, iWidth, iHeight ); // The modified value of uiPartAddr won't be used any more
5350
5351    TComPicYuv* pcBaseViewDepthPicYuv = picDepth->getPicYuvRec();
5352    const TComSPS   &sps =*(getSlice()->getSPS());
5353    Int iBlkX = ( getCtuRsAddr() % picDepth->getFrameWidthInCtus() ) * sps.getMaxCUWidth()  + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartAddrCurrCU ] ];
5354    Int iBlkY = ( getCtuRsAddr() / picDepth->getFrameWidthInCtus() ) * sps.getMaxCUHeight() + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartAddrCurrCU ] ];
5355
5356    Int* aiShiftLUT = getSlice()->getDepthToDisparityB(refViewIdx );
5357
5358    Pel iDisp = getMcpFromDM( pcBaseViewDepthPicYuv, cMvPred, iBlkX, iBlkY, iWidth, iHeight, aiShiftLUT );
5359    cMvPred->setHor( iDisp );
5360  }
5361}
5362#endif //NH_3D_NBDV_REF
5363
5364
5365Bool TComDataCU::xCheckSpatialNBDV( TComDataCU* pcTmpCU, UInt uiIdx, DisInfo* pNbDvInfo, Bool bSearchForMvpDv, IDVInfo* paIDVInfo, UInt uiMvpDvPos
5366#if NH_3D_NBDV_REF
5367, Bool bDepthRefine
5368#endif
5369)
5370{
5371  if( pcTmpCU != NULL && !pcTmpCU->isIntra( uiIdx ) )
5372  {
5373    Bool bTmpIsSkipped = pcTmpCU->isSkipped( uiIdx );
5374    for(Int iList = 0; iList < (getSlice()->isInterB() ? 2: 1); iList ++)
5375    {
5376      RefPicList eRefPicList = RefPicList(iList);
5377      Int      refId = pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ;
5378      TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
5379
5380      if( refId >= 0)
5381      {
5382        Int refViewIdx  = pcTmpCU->getSlice()->getRefPic(eRefPicList, refId)->getViewIndex();
5383        if (refViewIdx != m_pcSlice->getViewIndex()) 
5384        {
5385          pNbDvInfo->m_acNBDV = cMvPred;
5386          pNbDvInfo->m_aVIdxCan = refViewIdx;
5387