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

Last change on this file since 673 was 673, checked in by lg, 11 years ago

JCT3V-F0159; JCT3V-F0160
Bugfix is included. (JCT3V-F0158)

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