source: 3DVCSoftware/branches/HTM-14.1-update-dev1-HHI/source/Lib/TLibCommon/TComDataCU.cpp @ 1209

Last change on this file since 1209 was 1209, checked in by hhi, 9 years ago

Alignment and reactivation of DMM and depth encoder optimizations:

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