source: 3DVCSoftware/branches/HTM-8.2-dev3-Samsung/source/Lib/TLibCommon/TComDataCU.cpp @ 697

Last change on this file since 697 was 697, checked in by samsung-htm, 11 years ago

Integration of F0147: DMM simplification and signalling

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