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

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

Merged dev1.

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