source: 3DVCSoftware/branches/HTM-DEV-2.0-dev0/source/Lib/TLibCommon/TComDataCU.cpp @ 601

Last change on this file since 601 was 601, checked in by tech, 11 years ago

Merged dev3: DEV-2.0-DEV3-KWU@589

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