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

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

Cleanup of H_3D_FIX macro.

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