source: 3DVCSoftware/branches/HTM-3.0-LG/source/Lib/TLibCommon/TComDataCU.cpp @ 141

Last change on this file since 141 was 62, checked in by lg, 13 years ago
  • Property svn:eol-style set to native
File size: 224.3 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license. 
5 *
6 * Copyright (c) 2010-2012, 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#include "TComDepthMapGenerator.h"
42#include "TComResidualGenerator.h"
43
44//! \ingroup TLibCommon
45//! \{
46
47#if ADAPTIVE_QP_SELECTION
48Int * TComDataCU::m_pcGlbArlCoeffY  = NULL;
49Int * TComDataCU::m_pcGlbArlCoeffCb = NULL;
50Int * TComDataCU::m_pcGlbArlCoeffCr = NULL;
51#endif
52
53// ====================================================================================================================
54// Constructor / destructor / create / destroy
55// ====================================================================================================================
56
57TComDataCU::TComDataCU()
58{
59  m_pcPic              = NULL;
60  m_pcSlice            = NULL;
61  m_puhDepth           = NULL;
62#if HHI_MPI
63  m_piTextureModeDepth = NULL;
64#endif
65 
66  m_pePartSize         = NULL;
67#if HHI_INTERVIEW_SKIP
68  m_pbRenderable       = NULL;
69#endif
70  m_pePredMode         = NULL;
71  m_puiAlfCtrlFlag     = NULL;
72  m_puiTmpAlfCtrlFlag  = NULL;
73  m_puhWidth           = NULL;
74  m_puhHeight          = NULL;
75  m_phQP               = NULL;
76  m_pbMergeFlag        = NULL;
77  m_puhMergeIndex      = NULL;
78  m_puhLumaIntraDir    = NULL;
79  m_puhChromaIntraDir  = NULL;
80  m_puhInterDir        = NULL;
81  m_puhTrIdx           = NULL;
82#if NSQT_MOD2
83  m_nsqtPartIdx        = NULL;
84#endif
85  m_puhCbf[0]          = NULL;
86  m_puhCbf[1]          = NULL;
87  m_puhCbf[2]          = NULL;
88  m_pcTrCoeffY         = NULL;
89  m_pcTrCoeffCb        = NULL;
90  m_pcTrCoeffCr        = NULL;
91#if ADAPTIVE_QP_SELECTION 
92  m_pcArlCoeffY        = NULL;
93  m_pcArlCoeffCb       = NULL;
94  m_pcArlCoeffCr       = NULL;
95#endif
96 
97  m_pbIPCMFlag         = NULL;
98  m_pcIPCMSampleY      = NULL;
99  m_pcIPCMSampleCb     = NULL;
100  m_pcIPCMSampleCr     = NULL;
101
102  m_pcPattern          = NULL;
103 
104  m_pcCUAboveLeft      = NULL;
105  m_pcCUAboveRight     = NULL;
106  m_pcCUAbove          = NULL;
107  m_pcCULeft           = NULL;
108 
109  m_apcCUColocated[0]  = NULL;
110  m_apcCUColocated[1]  = NULL;
111 
112  m_apiMVPIdx[0]       = NULL;
113  m_apiMVPIdx[1]       = NULL;
114  m_apiMVPNum[0]       = NULL;
115  m_apiMVPNum[1]       = NULL;
116 
117  m_bDecSubCu          = false;
118  m_uiSliceStartCU        = 0;
119  m_uiEntropySliceStartCU = 0;
120
121#if HHI_DMM_WEDGE_INTRA
122  m_puiWedgeFullTabIdx       = NULL;
123  m_piWedgeFullDeltaDC1      = NULL;
124  m_piWedgeFullDeltaDC2      = NULL;
125
126  m_puiWedgePredDirTabIdx    = NULL;
127  m_piWedgePredDirDeltaDC1   = NULL;
128  m_piWedgePredDirDeltaDC2   = NULL;
129  m_piWedgePredDirDeltaEnd   = NULL;
130#endif
131#if HHI_DMM_PRED_TEX
132  m_puiWedgePredTexTabIdx    = NULL;
133  m_piWedgePredTexDeltaDC1   = NULL;
134  m_piWedgePredTexDeltaDC2   = NULL;
135
136  m_piContourPredTexDeltaDC1 = NULL;
137  m_piContourPredTexDeltaDC2 = NULL;
138#endif
139#if HHI_INTER_VIEW_RESIDUAL_PRED
140  m_pbResPredAvailable = NULL;
141  m_pbResPredFlag      = NULL;
142#endif
143}
144
145TComDataCU::~TComDataCU()
146{
147}
148
149Void TComDataCU::create(UInt uiNumPartition, UInt uiWidth, UInt uiHeight, Bool bDecSubCu, Int unitSize
150#if ADAPTIVE_QP_SELECTION
151                        , Bool bGlobalRMARLBuffer
152#endif                                             
153                        )
154{
155  m_bDecSubCu = bDecSubCu;
156 
157  m_pcPic              = NULL;
158  m_pcSlice            = NULL;
159  m_uiNumPartition     = uiNumPartition;
160  m_unitSize = unitSize;
161 
162  if ( !bDecSubCu )
163  {
164#if H0736_AVC_STYLE_QP_RANGE
165    m_phQP               = (Char*     )xMalloc(Char,     uiNumPartition);
166#else
167    m_phQP               = (UChar*    )xMalloc(UChar,    uiNumPartition);
168#endif
169    m_puhDepth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
170#if HHI_MPI
171    m_piTextureModeDepth = (Int*      )xMalloc(Int,      uiNumPartition);
172#endif
173    m_puhWidth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
174    m_puhHeight          = (UChar*    )xMalloc(UChar,    uiNumPartition);
175    m_pePartSize         = new Char[ uiNumPartition ];
176#if HHI_INTERVIEW_SKIP
177    m_pbRenderable        = (Bool*  )xMalloc(Bool,   uiNumPartition);
178#endif
179    memset( m_pePartSize, SIZE_NONE,uiNumPartition * sizeof( *m_pePartSize ) );
180    m_pePredMode         = new Char[ uiNumPartition ];
181   
182    m_puiAlfCtrlFlag     = new Bool[ uiNumPartition ];
183   
184    m_pbMergeFlag        = (Bool*  )xMalloc(Bool,   uiNumPartition);
185    m_puhMergeIndex      = (UChar* )xMalloc(UChar,  uiNumPartition);
186#if HHI_INTER_VIEW_RESIDUAL_PRED
187    m_pbResPredAvailable = (Bool*  )xMalloc(Bool,   uiNumPartition);
188    m_pbResPredFlag      = (Bool*  )xMalloc(Bool,   uiNumPartition);
189#endif
190    m_puhLumaIntraDir    = (UChar* )xMalloc(UChar,  uiNumPartition);
191    m_puhChromaIntraDir  = (UChar* )xMalloc(UChar,  uiNumPartition);
192    m_puhInterDir        = (UChar* )xMalloc(UChar,  uiNumPartition);
193   
194    m_puhTrIdx           = (UChar* )xMalloc(UChar,  uiNumPartition);
195    m_nsqtPartIdx        = (UChar* )xMalloc(UChar,  uiNumPartition);
196   
197    m_puhCbf[0]          = (UChar* )xMalloc(UChar,  uiNumPartition);
198    m_puhCbf[1]          = (UChar* )xMalloc(UChar,  uiNumPartition);
199    m_puhCbf[2]          = (UChar* )xMalloc(UChar,  uiNumPartition);
200   
201    m_apiMVPIdx[0]       = new Char[ uiNumPartition ];
202    m_apiMVPIdx[1]       = new Char[ uiNumPartition ];
203    m_apiMVPNum[0]       = new Char[ uiNumPartition ];
204    m_apiMVPNum[1]       = new Char[ uiNumPartition ];
205    memset( m_apiMVPIdx[0], -1,uiNumPartition * sizeof( Char ) );
206    memset( m_apiMVPIdx[1], -1,uiNumPartition * sizeof( Char ) );
207   
208    m_pcTrCoeffY         = (TCoeff*)xMalloc(TCoeff, uiWidth*uiHeight);
209    m_pcTrCoeffCb        = (TCoeff*)xMalloc(TCoeff, uiWidth*uiHeight/4);
210    m_pcTrCoeffCr        = (TCoeff*)xMalloc(TCoeff, uiWidth*uiHeight/4);
211    memset( m_pcTrCoeffY, 0,uiWidth*uiHeight * sizeof( TCoeff ) );
212    memset( m_pcTrCoeffCb, 0,uiWidth*uiHeight/4 * sizeof( TCoeff ) );
213    memset( m_pcTrCoeffCr, 0,uiWidth*uiHeight/4 * sizeof( TCoeff ) );
214#if ADAPTIVE_QP_SELECTION   
215    if( bGlobalRMARLBuffer )
216    {
217      if( m_pcGlbArlCoeffY == NULL )
218      {
219        m_pcGlbArlCoeffY   = (Int*)xMalloc(Int, uiWidth*uiHeight);
220        m_pcGlbArlCoeffCb  = (Int*)xMalloc(Int, uiWidth*uiHeight/4);
221        m_pcGlbArlCoeffCr  = (Int*)xMalloc(Int, uiWidth*uiHeight/4);
222      }
223      m_pcArlCoeffY        = m_pcGlbArlCoeffY;
224      m_pcArlCoeffCb       = m_pcGlbArlCoeffCb;
225      m_pcArlCoeffCr       = m_pcGlbArlCoeffCr;
226    }
227    else
228    {
229      m_pcArlCoeffY        = (Int*)xMalloc(Int, uiWidth*uiHeight);
230      m_pcArlCoeffCb       = (Int*)xMalloc(Int, uiWidth*uiHeight/4);
231      m_pcArlCoeffCr       = (Int*)xMalloc(Int, uiWidth*uiHeight/4);
232    }
233#endif
234   
235    m_pbIPCMFlag         = (Bool*  )xMalloc(Bool, uiNumPartition);
236    m_pcIPCMSampleY      = (Pel*   )xMalloc(Pel , uiWidth*uiHeight);
237    m_pcIPCMSampleCb     = (Pel*   )xMalloc(Pel , uiWidth*uiHeight/4);
238    m_pcIPCMSampleCr     = (Pel*   )xMalloc(Pel , uiWidth*uiHeight/4);
239
240    m_acCUMvField[0].create( uiNumPartition );
241    m_acCUMvField[1].create( uiNumPartition );
242   
243#if HHI_DMM_WEDGE_INTRA
244    m_puiWedgeFullTabIdx       = (UInt*)xMalloc(UInt, uiNumPartition);
245    m_piWedgeFullDeltaDC1      = (Int* )xMalloc(Int,  uiNumPartition);
246    m_piWedgeFullDeltaDC2      = (Int* )xMalloc(Int,  uiNumPartition);
247
248    m_puiWedgePredDirTabIdx    = (UInt*)xMalloc(UInt, uiNumPartition);
249    m_piWedgePredDirDeltaDC1   = (Int* )xMalloc(Int,  uiNumPartition);
250    m_piWedgePredDirDeltaDC2   = (Int* )xMalloc(Int,  uiNumPartition);
251    m_piWedgePredDirDeltaEnd   = (Int* )xMalloc(Int,  uiNumPartition);
252#endif
253#if HHI_DMM_PRED_TEX
254    m_puiWedgePredTexTabIdx    = (UInt*)xMalloc(UInt, uiNumPartition);
255    m_piWedgePredTexDeltaDC1   = (Int* )xMalloc(Int,  uiNumPartition);
256    m_piWedgePredTexDeltaDC2   = (Int* )xMalloc(Int,  uiNumPartition);
257
258    m_piContourPredTexDeltaDC1 = (Int* )xMalloc(Int,  uiNumPartition);
259    m_piContourPredTexDeltaDC2 = (Int* )xMalloc(Int,  uiNumPartition);
260#endif
261  }
262  else
263  {
264    m_acCUMvField[0].setNumPartition(uiNumPartition );
265    m_acCUMvField[1].setNumPartition(uiNumPartition );
266  }
267 
268  m_uiSliceStartCU        = (UInt*  )xMalloc(UInt, uiNumPartition);
269  m_uiEntropySliceStartCU = (UInt*  )xMalloc(UInt, uiNumPartition);
270 
271  // create pattern memory
272  m_pcPattern            = (TComPattern*)xMalloc(TComPattern, 1);
273 
274  // create motion vector fields
275 
276  m_pcCUAboveLeft      = NULL;
277  m_pcCUAboveRight     = NULL;
278  m_pcCUAbove          = NULL;
279  m_pcCULeft           = NULL;
280 
281  m_apcCUColocated[0]  = NULL;
282  m_apcCUColocated[1]  = NULL;
283}
284
285Void TComDataCU::destroy()
286{
287  m_pcPic              = NULL;
288  m_pcSlice            = NULL;
289 
290  if ( m_pcPattern )
291  { 
292    xFree(m_pcPattern);
293    m_pcPattern = NULL;
294  }
295 
296  // encoder-side buffer free
297  if ( !m_bDecSubCu )
298  {
299    if ( m_phQP               ) { xFree(m_phQP);                m_phQP              = NULL; }
300    if ( m_puhDepth           ) { xFree(m_puhDepth);            m_puhDepth          = NULL; }
301#if HHI_MPI
302    if ( m_piTextureModeDepth ) { xFree(m_piTextureModeDepth);  m_piTextureModeDepth= NULL; }
303#endif
304    if ( m_puhWidth           ) { xFree(m_puhWidth);            m_puhWidth          = NULL; }
305    if ( m_puhHeight          ) { xFree(m_puhHeight);           m_puhHeight         = NULL; }
306    if ( m_pePartSize         ) { delete[] m_pePartSize;        m_pePartSize        = NULL; }
307#if HHI_INTERVIEW_SKIP
308    if ( m_pbRenderable        ) { xFree(m_pbRenderable);         m_pbRenderable       = NULL; }
309#endif
310    if ( m_pePredMode         ) { delete[] m_pePredMode;        m_pePredMode        = NULL; }
311    if ( m_puhCbf[0]          ) { xFree(m_puhCbf[0]);           m_puhCbf[0]         = NULL; }
312    if ( m_puhCbf[1]          ) { xFree(m_puhCbf[1]);           m_puhCbf[1]         = NULL; }
313    if ( m_puhCbf[2]          ) { xFree(m_puhCbf[2]);           m_puhCbf[2]         = NULL; }
314    if ( m_puiAlfCtrlFlag     ) { delete[] m_puiAlfCtrlFlag;    m_puiAlfCtrlFlag    = NULL; }
315    if ( m_puhInterDir        ) { xFree(m_puhInterDir);         m_puhInterDir       = NULL; }
316    if ( m_pbMergeFlag        ) { xFree(m_pbMergeFlag);         m_pbMergeFlag       = NULL; }
317    if ( m_puhMergeIndex      ) { xFree(m_puhMergeIndex);       m_puhMergeIndex     = NULL; }
318#if HHI_INTER_VIEW_RESIDUAL_PRED
319    if ( m_pbResPredAvailable ) { xFree(m_pbResPredAvailable);  m_pbResPredAvailable= NULL; }
320    if ( m_pbResPredFlag      ) { xFree(m_pbResPredFlag);       m_pbResPredFlag     = NULL; }
321#endif
322    if ( m_puhLumaIntraDir    ) { xFree(m_puhLumaIntraDir);     m_puhLumaIntraDir   = NULL; }
323    if ( m_puhChromaIntraDir  ) { xFree(m_puhChromaIntraDir);   m_puhChromaIntraDir = NULL; }
324    if ( m_puhTrIdx           ) { xFree(m_puhTrIdx);            m_puhTrIdx          = NULL; }
325    if ( m_nsqtPartIdx        ) { xFree(m_nsqtPartIdx);         m_nsqtPartIdx       = NULL; }
326    if ( m_pcTrCoeffY         ) { xFree(m_pcTrCoeffY);          m_pcTrCoeffY        = NULL; }
327    if ( m_pcTrCoeffCb        ) { xFree(m_pcTrCoeffCb);         m_pcTrCoeffCb       = NULL; }
328    if ( m_pcTrCoeffCr        ) { xFree(m_pcTrCoeffCr);         m_pcTrCoeffCr       = NULL; }
329#if ADAPTIVE_QP_SELECTION
330    if ( m_pcGlbArlCoeffY     ) { xFree(m_pcGlbArlCoeffY);      m_pcGlbArlCoeffY    = NULL; }
331    if ( m_pcGlbArlCoeffCb    ) { xFree(m_pcGlbArlCoeffCb);     m_pcGlbArlCoeffCb   = NULL; }
332    if ( m_pcGlbArlCoeffCr    ) { xFree(m_pcGlbArlCoeffCr);     m_pcGlbArlCoeffCr   = NULL; }
333#endif
334    if ( m_pbIPCMFlag         ) { xFree(m_pbIPCMFlag   );       m_pbIPCMFlag        = NULL; }
335    if ( m_pcIPCMSampleY      ) { xFree(m_pcIPCMSampleY);       m_pcIPCMSampleY     = NULL; }
336    if ( m_pcIPCMSampleCb     ) { xFree(m_pcIPCMSampleCb);      m_pcIPCMSampleCb    = NULL; }
337    if ( m_pcIPCMSampleCr     ) { xFree(m_pcIPCMSampleCr);      m_pcIPCMSampleCr    = NULL; }
338    if ( m_apiMVPIdx[0]       ) { delete[] m_apiMVPIdx[0];      m_apiMVPIdx[0]      = NULL; }
339    if ( m_apiMVPIdx[1]       ) { delete[] m_apiMVPIdx[1];      m_apiMVPIdx[1]      = NULL; }
340    if ( m_apiMVPNum[0]       ) { delete[] m_apiMVPNum[0];      m_apiMVPNum[0]      = NULL; }
341    if ( m_apiMVPNum[1]       ) { delete[] m_apiMVPNum[1];      m_apiMVPNum[1]      = NULL; }
342   
343#if HHI_DMM_WEDGE_INTRA
344    if ( m_puiWedgeFullTabIdx       ) { xFree(m_puiWedgeFullTabIdx      ); m_puiWedgeFullTabIdx       = NULL; }
345    if ( m_piWedgeFullDeltaDC1      ) { xFree(m_piWedgeFullDeltaDC1     ); m_piWedgeFullDeltaDC1      = NULL; }
346    if ( m_piWedgeFullDeltaDC2      ) { xFree(m_piWedgeFullDeltaDC2     ); m_piWedgeFullDeltaDC2      = NULL; }
347
348    if ( m_puiWedgePredDirTabIdx    ) { xFree(m_puiWedgePredDirTabIdx   ); m_puiWedgePredDirTabIdx    = NULL; }
349    if ( m_piWedgePredDirDeltaEnd   ) { xFree(m_piWedgePredDirDeltaEnd  ); m_piWedgePredDirDeltaEnd   = NULL; }
350    if ( m_piWedgePredDirDeltaDC1   ) { xFree(m_piWedgePredDirDeltaDC1  ); m_piWedgePredDirDeltaDC1   = NULL; }
351    if ( m_piWedgePredDirDeltaDC2   ) { xFree(m_piWedgePredDirDeltaDC2  ); m_piWedgePredDirDeltaDC2   = NULL; }
352#endif
353#if HHI_DMM_PRED_TEX
354    if ( m_puiWedgePredTexTabIdx    ) { xFree(m_puiWedgePredTexTabIdx   ); m_puiWedgePredTexTabIdx    = NULL; }
355    if ( m_piWedgePredTexDeltaDC1   ) { xFree(m_piWedgePredTexDeltaDC1  ); m_piWedgePredTexDeltaDC1   = NULL; }
356    if ( m_piWedgePredTexDeltaDC2   ) { xFree(m_piWedgePredTexDeltaDC2  ); m_piWedgePredTexDeltaDC2   = NULL; }
357
358    if ( m_piContourPredTexDeltaDC1 ) { xFree(m_piContourPredTexDeltaDC1); m_piContourPredTexDeltaDC1 = NULL; }
359    if ( m_piContourPredTexDeltaDC2 ) { xFree(m_piContourPredTexDeltaDC2); m_piContourPredTexDeltaDC2 = NULL; }
360#endif   
361    m_acCUMvField[0].destroy();
362    m_acCUMvField[1].destroy();
363   
364  }
365 
366  m_pcCUAboveLeft       = NULL;
367  m_pcCUAboveRight      = NULL;
368  m_pcCUAbove           = NULL;
369  m_pcCULeft            = NULL;
370 
371  m_apcCUColocated[0]   = NULL;
372  m_apcCUColocated[1]   = NULL;
373
374  if( m_uiSliceStartCU )
375  {
376    xFree(m_uiSliceStartCU);
377    m_uiSliceStartCU=NULL;
378  }
379  if(m_uiEntropySliceStartCU )
380  {
381    xFree(m_uiEntropySliceStartCU);
382    m_uiEntropySliceStartCU=NULL;
383  }
384}
385
386const NDBFBlockInfo& NDBFBlockInfo::operator= (const NDBFBlockInfo& src)
387{
388  this->tileID = src.tileID;
389  this->sliceID= src.sliceID;
390  this->startSU= src.startSU;
391  this->endSU  = src.endSU;
392  this->widthSU= src.widthSU;
393  this->heightSU=src.heightSU;
394  this->posX   = src.posX;
395  this->posY   = src.posY;
396  this->width  = src.width;
397  this->height = src.height;
398  ::memcpy(this->isBorderAvailable, src.isBorderAvailable, sizeof(Bool)*((Int)NUM_SGU_BORDER));
399#if LCU_SYNTAX_ALF
400  this->allBordersAvailable = src.allBordersAvailable;
401#endif
402
403  return *this;
404}
405
406
407// ====================================================================================================================
408// Public member functions
409// ====================================================================================================================
410
411// --------------------------------------------------------------------------------------------------------------------
412// Initialization
413// --------------------------------------------------------------------------------------------------------------------
414
415/**
416 - initialize top-level CU
417 - internal buffers are already created
418 - set values before encoding a CU
419 .
420 \param  pcPic     picture (TComPic) class pointer
421 \param  iCUAddr   CU address
422 */
423Void TComDataCU::initCU( TComPic* pcPic, UInt iCUAddr )
424{
425
426  m_pcPic              = pcPic;
427  m_pcSlice            = pcPic->getSlice(pcPic->getCurrSliceIdx());
428  m_uiCUAddr           = iCUAddr;
429  m_uiCUPelX           = ( iCUAddr % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth;
430  m_uiCUPelY           = ( iCUAddr / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight;
431  m_uiAbsIdxInLCU      = 0;
432  m_dTotalCost         = MAX_DOUBLE;
433  m_uiTotalDistortion  = 0;
434  m_uiTotalBits        = 0;
435  m_uiTotalBins        = 0;
436  m_uiNumPartition     = pcPic->getNumPartInCU();
437#if BURST_IPCM
438  m_numSucIPCM       = 0;
439  m_lastCUSucIPCMFlag   = false;
440#endif
441
442  for(int i=0; i<pcPic->getNumPartInCU(); i++) 
443  {
444    if(pcPic->getPicSym()->getInverseCUOrderMap(iCUAddr)*pcPic->getNumPartInCU()+i>=getSlice()->getSliceCurStartCUAddr())
445    {
446      m_uiSliceStartCU[i]=getSlice()->getSliceCurStartCUAddr();
447    }
448    else
449    {
450      m_uiSliceStartCU[i]=pcPic->getCU(getAddr())->m_uiSliceStartCU[i];
451    }
452  }
453  for(int i=0; i<pcPic->getNumPartInCU(); i++) 
454  {
455    if(pcPic->getPicSym()->getInverseCUOrderMap(iCUAddr)*pcPic->getNumPartInCU()+i>=getSlice()->getEntropySliceCurStartCUAddr())
456    {
457      m_uiEntropySliceStartCU[i]=getSlice()->getEntropySliceCurStartCUAddr();
458    }
459    else
460    {
461      m_uiEntropySliceStartCU[i]=pcPic->getCU(getAddr())->m_uiEntropySliceStartCU[i];
462    }
463  }
464
465  Int partStartIdx = getSlice()->getEntropySliceCurStartCUAddr() - pcPic->getPicSym()->getInverseCUOrderMap(iCUAddr) * pcPic->getNumPartInCU();
466
467  Int numElements = min<Int>( partStartIdx, m_uiNumPartition );
468  for ( Int ui = 0; ui < numElements; ui++ )
469  {
470    TComDataCU * pcFrom = pcPic->getCU(getAddr());
471    m_pePartSize[ui] = pcFrom->getPartitionSize(ui);
472    m_pePredMode[ui] = pcFrom->getPredictionMode(ui);
473    m_puhDepth[ui] = pcFrom->getDepth(ui);
474#if HHI_MPI
475    m_piTextureModeDepth[ui] = pcFrom->getTextureModeDepth(ui);
476#endif
477    m_puhWidth  [ui] = pcFrom->getWidth(ui);
478    m_puhHeight [ui] = pcFrom->getHeight(ui);
479    m_puhTrIdx  [ui] = pcFrom->getTransformIdx(ui);
480    m_nsqtPartIdx[ui] = pcFrom->getNSQTPartIdx(ui);
481    m_apiMVPIdx[0][ui] = pcFrom->m_apiMVPIdx[0][ui];;
482    m_apiMVPIdx[1][ui] = pcFrom->m_apiMVPIdx[1][ui];
483    m_apiMVPNum[0][ui] = pcFrom->m_apiMVPNum[0][ui];
484    m_apiMVPNum[1][ui] = pcFrom->m_apiMVPNum[1][ui];
485    m_phQP[ui]=pcFrom->m_phQP[ui];
486    m_puiAlfCtrlFlag[ui]=pcFrom->m_puiAlfCtrlFlag[ui];
487    m_pbMergeFlag[ui]=pcFrom->m_pbMergeFlag[ui];
488    m_puhMergeIndex[ui]=pcFrom->m_puhMergeIndex[ui];
489    m_puhLumaIntraDir[ui]=pcFrom->m_puhLumaIntraDir[ui];
490    m_puhChromaIntraDir[ui]=pcFrom->m_puhChromaIntraDir[ui];
491    m_puhInterDir[ui]=pcFrom->m_puhInterDir[ui];
492    m_puhCbf[0][ui]=pcFrom->m_puhCbf[0][ui];
493    m_puhCbf[1][ui]=pcFrom->m_puhCbf[1][ui];
494    m_puhCbf[2][ui]=pcFrom->m_puhCbf[2][ui];
495    m_pbIPCMFlag[ui] = pcFrom->m_pbIPCMFlag[ui];
496  }
497 
498  Int firstElement = max<Int>( partStartIdx, 0 );
499  numElements = m_uiNumPartition - firstElement;
500 
501  if ( numElements > 0 )
502  {
503    memset( m_pePartSize        + firstElement, SIZE_NONE,                numElements * sizeof( *m_pePartSize ) );
504    memset( m_pePredMode        + firstElement, MODE_NONE,                numElements * sizeof( *m_pePredMode ) );
505    memset( m_puhDepth          + firstElement, 0,                        numElements * sizeof( *m_puhDepth ) );
506#if HHI_MPI
507    memset( m_piTextureModeDepth+ firstElement,-1,                        numElements * sizeof( *m_piTextureModeDepth ) );
508#endif
509    memset( m_puhTrIdx          + firstElement, 0,                        numElements * sizeof( *m_puhTrIdx ) );
510    memset( m_nsqtPartIdx       + firstElement, 0,                        numElements * sizeof( *m_nsqtPartIdx) );
511    memset( m_puhWidth          + firstElement, g_uiMaxCUWidth,           numElements * sizeof( *m_puhWidth ) );
512    memset( m_puhHeight         + firstElement, g_uiMaxCUHeight,          numElements * sizeof( *m_puhHeight ) );
513    memset( m_apiMVPIdx[0]      + firstElement, -1,                       numElements * sizeof( *m_apiMVPIdx[0] ) );
514    memset( m_apiMVPIdx[1]      + firstElement, -1,                       numElements * sizeof( *m_apiMVPIdx[1] ) );
515    memset( m_apiMVPNum[0]      + firstElement, -1,                       numElements * sizeof( *m_apiMVPNum[0] ) );
516    memset( m_apiMVPNum[1]      + firstElement, -1,                       numElements * sizeof( *m_apiMVPNum[1] ) );
517    memset( m_phQP              + firstElement, getSlice()->getSliceQp(), numElements * sizeof( *m_phQP ) );
518    memset( m_puiAlfCtrlFlag    + firstElement, false,                    numElements * sizeof( *m_puiAlfCtrlFlag ) );
519    memset( m_pbMergeFlag       + firstElement, false,                    numElements * sizeof( *m_pbMergeFlag ) );
520    memset( m_puhMergeIndex     + firstElement, 0,                        numElements * sizeof( *m_puhMergeIndex ) );
521    memset( m_puhLumaIntraDir   + firstElement, 2,                        numElements * sizeof( *m_puhLumaIntraDir ) );
522    memset( m_puhChromaIntraDir + firstElement, 0,                        numElements * sizeof( *m_puhChromaIntraDir ) );
523    memset( m_puhInterDir       + firstElement, 0,                        numElements * sizeof( *m_puhInterDir ) );
524    memset( m_puhCbf[0]         + firstElement, 0,                        numElements * sizeof( *m_puhCbf[0] ) );
525    memset( m_puhCbf[1]         + firstElement, 0,                        numElements * sizeof( *m_puhCbf[1] ) );
526    memset( m_puhCbf[2]         + firstElement, 0,                        numElements * sizeof( *m_puhCbf[2] ) );
527    memset( m_pbIPCMFlag        + firstElement, false,                    numElements * sizeof( *m_pbIPCMFlag ) );
528
529#if HHI_DMM_WEDGE_INTRA
530    memset( m_puiWedgeFullTabIdx       + firstElement, 0, sizeof( UInt ) * numElements );
531    memset( m_piWedgeFullDeltaDC1      + firstElement, 0, sizeof( Int  ) * numElements );
532    memset( m_piWedgeFullDeltaDC2      + firstElement, 0, sizeof( Int  ) * numElements );
533
534    memset( m_puiWedgePredDirTabIdx    + firstElement, 0, sizeof( UInt ) * numElements );
535    memset( m_piWedgePredDirDeltaDC1   + firstElement, 0, sizeof( Int  ) * numElements );
536    memset( m_piWedgePredDirDeltaDC2   + firstElement, 0, sizeof( Int  ) * numElements );
537    memset( m_piWedgePredDirDeltaEnd   + firstElement, 0, sizeof( Int  ) * numElements );
538#endif
539#if HHI_DMM_PRED_TEX
540    memset( m_puiWedgePredTexTabIdx    + firstElement, 0, sizeof( UInt ) * numElements );
541    memset( m_piWedgePredTexDeltaDC1   + firstElement, 0, sizeof( Int  ) * numElements );
542    memset( m_piWedgePredTexDeltaDC2   + firstElement, 0, sizeof( Int  ) * numElements );
543
544    memset( m_piContourPredTexDeltaDC1 + firstElement, 0, sizeof( Int  ) * numElements );
545    memset( m_piContourPredTexDeltaDC2 + firstElement, 0, sizeof( Int  ) * numElements );
546#endif
547#if HHI_INTERVIEW_SKIP
548    memset (m_pbRenderable             + firstElement, false, sizeof( Bool ) * numElements) ;
549#endif
550#if HHI_INTER_VIEW_RESIDUAL_PRED
551    memset( m_pbResPredAvailable       + firstElement, 0    , sizeof( Bool ) * numElements );
552    memset( m_pbResPredFlag            + firstElement, 0    , sizeof( Bool ) * numElements );
553#endif
554  }
555 
556  UInt uiTmp = g_uiMaxCUWidth*g_uiMaxCUHeight;
557  if ( 0 >= partStartIdx ) 
558  {
559    m_acCUMvField[0].clearMvField();
560    m_acCUMvField[1].clearMvField();
561    memset( m_pcTrCoeffY , 0, sizeof( TCoeff ) * uiTmp );
562#if ADAPTIVE_QP_SELECTION
563    memset( m_pcArlCoeffY , 0, sizeof( Int ) * uiTmp ); 
564#endif
565    memset( m_pcIPCMSampleY , 0, sizeof( Pel ) * uiTmp );
566    uiTmp  >>= 2;
567    memset( m_pcTrCoeffCb, 0, sizeof( TCoeff ) * uiTmp );
568    memset( m_pcTrCoeffCr, 0, sizeof( TCoeff ) * uiTmp );
569#if ADAPTIVE_QP_SELECTION 
570    memset( m_pcArlCoeffCb, 0, sizeof( Int ) * uiTmp );
571    memset( m_pcArlCoeffCr, 0, sizeof( Int ) * uiTmp );
572#endif
573    memset( m_pcIPCMSampleCb , 0, sizeof( Pel ) * uiTmp );
574    memset( m_pcIPCMSampleCr , 0, sizeof( Pel ) * uiTmp );
575  }
576  else 
577  {
578    TComDataCU * pcFrom = pcPic->getCU(getAddr());
579    m_acCUMvField[0].copyFrom(&pcFrom->m_acCUMvField[0],m_uiNumPartition,0);
580    m_acCUMvField[1].copyFrom(&pcFrom->m_acCUMvField[1],m_uiNumPartition,0);
581    for(int i=0; i<uiTmp; i++) 
582    {
583      m_pcTrCoeffY[i]=pcFrom->m_pcTrCoeffY[i];
584#if ADAPTIVE_QP_SELECTION
585      m_pcArlCoeffY[i]=pcFrom->m_pcArlCoeffY[i];
586#endif
587      m_pcIPCMSampleY[i]=pcFrom->m_pcIPCMSampleY[i];
588    }
589    for(int i=0; i<(uiTmp>>2); i++) 
590    {
591      m_pcTrCoeffCb[i]=pcFrom->m_pcTrCoeffCb[i];
592      m_pcTrCoeffCr[i]=pcFrom->m_pcTrCoeffCr[i];
593#if ADAPTIVE_QP_SELECTION
594      m_pcArlCoeffCb[i]=pcFrom->m_pcArlCoeffCb[i];
595      m_pcArlCoeffCr[i]=pcFrom->m_pcArlCoeffCr[i];
596#endif
597      m_pcIPCMSampleCb[i]=pcFrom->m_pcIPCMSampleCb[i];
598      m_pcIPCMSampleCr[i]=pcFrom->m_pcIPCMSampleCr[i];
599    }
600  }
601
602  // Setting neighbor CU
603  m_pcCULeft        = NULL;
604  m_pcCUAbove       = NULL;
605  m_pcCUAboveLeft   = NULL;
606  m_pcCUAboveRight  = NULL;
607
608  m_apcCUColocated[0] = NULL;
609  m_apcCUColocated[1] = NULL;
610
611  UInt uiWidthInCU = pcPic->getFrameWidthInCU();
612  if ( m_uiCUAddr % uiWidthInCU )
613  {
614    m_pcCULeft = pcPic->getCU( m_uiCUAddr - 1 );
615  }
616
617  if ( m_uiCUAddr / uiWidthInCU )
618  {
619    m_pcCUAbove = pcPic->getCU( m_uiCUAddr - uiWidthInCU );
620  }
621
622  if ( m_pcCULeft && m_pcCUAbove )
623  {
624    m_pcCUAboveLeft = pcPic->getCU( m_uiCUAddr - uiWidthInCU - 1 );
625  }
626
627  if ( m_pcCUAbove && ( (m_uiCUAddr%uiWidthInCU) < (uiWidthInCU-1) )  )
628  {
629    m_pcCUAboveRight = pcPic->getCU( m_uiCUAddr - uiWidthInCU + 1 );
630  }
631
632  if ( getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 )
633  {
634    m_apcCUColocated[0] = getSlice()->getRefPic( REF_PIC_LIST_0, 0)->getCU( m_uiCUAddr );
635  }
636
637  if ( getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 )
638  {
639    m_apcCUColocated[1] = getSlice()->getRefPic( REF_PIC_LIST_1, 0)->getCU( m_uiCUAddr );
640  }
641}
642
643#if H0736_AVC_STYLE_QP_RANGE
644/** initialize prediction data with enabling sub-LCU-level delta QP
645*\param  uiDepth  depth of the current CU
646*\param  qp     qp for the current CU
647*- set CU width and CU height according to depth
648*- set qp value according to input qp
649*- set last-coded qp value according to input last-coded qp
650*/
651Void TComDataCU::initEstData( UInt uiDepth, Int qp )
652#else
653/** initialize prediction data with enabling sub-LCU-level delta QP
654*\param  uiDepth  depth of the current CU
655*\param  uiQP     QP for the current CU
656*- set CU width and CU height according to depth
657*- set QP value according to input QP
658*- set last-coded QP value according to input last-coded QP
659*/
660Void TComDataCU::initEstData( UInt uiDepth, UInt uiQP )
661#endif
662{
663  m_dTotalCost         = MAX_DOUBLE;
664  m_uiTotalDistortion  = 0;
665  m_uiTotalBits        = 0;
666  m_uiTotalBins        = 0;
667
668  UChar uhWidth  = g_uiMaxCUWidth  >> uiDepth;
669  UChar uhHeight = g_uiMaxCUHeight >> uiDepth;
670
671  for (UInt ui = 0; ui < m_uiNumPartition; ui++)
672  {
673    if(getPic()->getPicSym()->getInverseCUOrderMap(getAddr())*m_pcPic->getNumPartInCU()+m_uiAbsIdxInLCU+ui >= getSlice()->getEntropySliceCurStartCUAddr())
674    {
675#if HHI_INTERVIEW_SKIP
676      m_pbRenderable[ui]=  0 ;
677#endif
678      m_apiMVPIdx[0][ui] = -1;
679      m_apiMVPIdx[1][ui] = -1;
680      m_apiMVPNum[0][ui] = -1;
681      m_apiMVPNum[1][ui] = -1;
682      m_puhDepth  [ui] = uiDepth;
683      m_puhWidth  [ui] = uhWidth;
684      m_puhHeight [ui] = uhHeight;
685      m_puhTrIdx  [ui] = 0;
686#if HHI_MPI
687      m_piTextureModeDepth[ui] = -1;
688#endif
689      m_nsqtPartIdx[ui] = 0;
690      m_pePartSize[ui] = SIZE_NONE;
691      m_pePredMode[ui] = MODE_NONE;
692      m_pbIPCMFlag[ui] = 0;
693#if H0736_AVC_STYLE_QP_RANGE
694      m_phQP[ui] = qp;
695#else
696      m_phQP[ui] = uiQP;
697#endif
698      m_puiAlfCtrlFlag[ui]= false;
699      m_pbMergeFlag[ui] = 0;
700      m_puhMergeIndex[ui] = 0;
701#if HHI_INTER_VIEW_RESIDUAL_PRED
702      m_pbResPredAvailable[ui] = 0;
703      m_pbResPredFlag[ui]      = 0;
704#endif
705      m_puhLumaIntraDir[ui] = 2;
706      m_puhChromaIntraDir[ui] = 0;
707      m_puhInterDir[ui] = 0;
708      m_puhCbf[0][ui] = 0;
709      m_puhCbf[1][ui] = 0;
710      m_puhCbf[2][ui] = 0;
711#if HHI_DMM_WEDGE_INTRA
712    m_puiWedgeFullTabIdx      [ui] = 0;
713    m_piWedgeFullDeltaDC1     [ui] = 0;
714    m_piWedgeFullDeltaDC2     [ui] = 0;
715
716    m_puiWedgePredDirTabIdx   [ui] = 0;
717    m_piWedgePredDirDeltaDC1  [ui] = 0;
718    m_piWedgePredDirDeltaDC2  [ui] = 0;
719    m_piWedgePredDirDeltaEnd  [ui] = 0;
720#endif
721#if HHI_DMM_PRED_TEX
722    m_puiWedgePredTexTabIdx   [ui] = 0;
723    m_piWedgePredTexDeltaDC1  [ui] = 0;
724    m_piWedgePredTexDeltaDC2  [ui] = 0;
725
726    m_piContourPredTexDeltaDC1[ui] = 0;
727    m_piContourPredTexDeltaDC2[ui] = 0;
728#endif
729    }
730  }
731
732  UInt uiTmp = uhWidth*uhHeight;
733
734  if(getPic()->getPicSym()->getInverseCUOrderMap(getAddr())*m_pcPic->getNumPartInCU()+m_uiAbsIdxInLCU >= getSlice()->getEntropySliceCurStartCUAddr())
735  {
736    m_acCUMvField[0].clearMvField();
737    m_acCUMvField[1].clearMvField();
738    uiTmp = uhWidth*uhHeight;
739   
740    memset( m_pcTrCoeffY,    0, uiTmp * sizeof( *m_pcTrCoeffY    ) );
741#if ADAPTIVE_QP_SELECTION
742    memset( m_pcArlCoeffY ,  0, uiTmp * sizeof( *m_pcArlCoeffY   ) );
743#endif
744    memset( m_pcIPCMSampleY, 0, uiTmp * sizeof( *m_pcIPCMSampleY ) );
745
746    uiTmp>>=2;
747    memset( m_pcTrCoeffCb,    0, uiTmp * sizeof( *m_pcTrCoeffCb    ) );
748    memset( m_pcTrCoeffCr,    0, uiTmp * sizeof( *m_pcTrCoeffCr    ) );
749#if ADAPTIVE_QP_SELECTION 
750    memset( m_pcArlCoeffCb,   0, uiTmp * sizeof( *m_pcArlCoeffCb   ) );
751    memset( m_pcArlCoeffCr,   0, uiTmp * sizeof( *m_pcArlCoeffCr   ) );
752#endif
753    memset( m_pcIPCMSampleCb, 0, uiTmp * sizeof( *m_pcIPCMSampleCb ) );
754    memset( m_pcIPCMSampleCr, 0, uiTmp * sizeof( *m_pcIPCMSampleCr ) );
755  }
756}
757
758
759// initialize Sub partition
760#if H0736_AVC_STYLE_QP_RANGE
761Void TComDataCU::initSubCU( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, Int qp )
762#else
763Void TComDataCU::initSubCU( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, UInt uiQP )
764#endif
765{
766  assert( uiPartUnitIdx<4 );
767
768  UInt uiPartOffset = ( pcCU->getTotalNumPart()>>2 )*uiPartUnitIdx;
769
770  m_pcPic              = pcCU->getPic();
771  m_pcSlice            = m_pcPic->getSlice(m_pcPic->getCurrSliceIdx());
772  m_uiCUAddr           = pcCU->getAddr();
773  m_uiAbsIdxInLCU      = pcCU->getZorderIdxInCU() + uiPartOffset;
774
775  m_uiCUPelX           = pcCU->getCUPelX() + ( g_uiMaxCUWidth>>uiDepth  )*( uiPartUnitIdx &  1 );
776  m_uiCUPelY           = pcCU->getCUPelY() + ( g_uiMaxCUHeight>>uiDepth  )*( uiPartUnitIdx >> 1 );
777
778  m_dTotalCost         = MAX_DOUBLE;
779  m_uiTotalDistortion  = 0;
780  m_uiTotalBits        = 0;
781  m_uiTotalBins        = 0;
782  m_uiNumPartition     = pcCU->getTotalNumPart() >> 2;
783
784#if BURST_IPCM
785  m_numSucIPCM       = 0;
786  m_lastCUSucIPCMFlag   = false;
787#endif
788
789  Int iSizeInUchar = sizeof( UChar  ) * m_uiNumPartition;
790  Int iSizeInBool  = sizeof( Bool   ) * m_uiNumPartition;
791
792#if H0736_AVC_STYLE_QP_RANGE
793  Int sizeInChar = sizeof( Char  ) * m_uiNumPartition;
794  memset( m_phQP,              qp,  sizeInChar );
795#else
796  memset( m_phQP,              uiQP, iSizeInUchar );
797#endif
798
799  memset( m_puiAlfCtrlFlag,     0, iSizeInBool );
800  memset( m_pbMergeFlag,        0, iSizeInBool  );
801#if HHI_INTERVIEW_SKIP
802  memset( m_pbRenderable,        0, iSizeInBool  );
803#endif
804  memset( m_puhMergeIndex,      0, iSizeInUchar );
805#if HHI_INTER_VIEW_RESIDUAL_PRED
806  memset( m_pbResPredAvailable, 0, iSizeInBool  );
807  memset( m_pbResPredFlag,      0, iSizeInBool  );
808#endif
809  memset( m_puhLumaIntraDir,    2, iSizeInUchar );
810  memset( m_puhChromaIntraDir,  0, iSizeInUchar );
811  memset( m_puhInterDir,        0, iSizeInUchar );
812  memset( m_puhTrIdx,           0, iSizeInUchar );
813  memset( m_puhCbf[0],          0, iSizeInUchar );
814  memset( m_puhCbf[1],          0, iSizeInUchar );
815  memset( m_puhCbf[2],          0, iSizeInUchar );
816  memset( m_puhDepth,     uiDepth, iSizeInUchar );
817#if HHI_MPI
818  memset( m_piTextureModeDepth, -1, sizeof( Int ) * m_uiNumPartition );
819#endif
820
821#if HHI_DMM_WEDGE_INTRA
822  memset( m_puiWedgeFullTabIdx,       0, sizeof( UInt ) * m_uiNumPartition );
823  memset( m_piWedgeFullDeltaDC1,      0, sizeof( Int  ) * m_uiNumPartition );
824  memset( m_piWedgeFullDeltaDC2,      0, sizeof( Int  ) * m_uiNumPartition );
825
826  memset( m_puiWedgePredDirTabIdx,    0, sizeof( UInt ) * m_uiNumPartition );
827  memset( m_piWedgePredDirDeltaDC1,   0, sizeof( Int  ) * m_uiNumPartition );
828  memset( m_piWedgePredDirDeltaDC2,   0, sizeof( Int  ) * m_uiNumPartition );
829  memset( m_piWedgePredDirDeltaEnd,   0, sizeof( Int  ) * m_uiNumPartition );
830#endif
831#if HHI_DMM_PRED_TEX
832  memset( m_puiWedgePredTexTabIdx,    0, sizeof( UInt ) * m_uiNumPartition );
833  memset( m_piWedgePredTexDeltaDC1,   0, sizeof( Int  ) * m_uiNumPartition );
834  memset( m_piWedgePredTexDeltaDC2,   0, sizeof( Int  ) * m_uiNumPartition );
835
836  memset( m_piContourPredTexDeltaDC1, 0, sizeof( Int  ) * m_uiNumPartition );
837  memset( m_piContourPredTexDeltaDC2, 0, sizeof( Int  ) * m_uiNumPartition );
838#endif   
839
840  UChar uhWidth  = g_uiMaxCUWidth  >> uiDepth;
841  UChar uhHeight = g_uiMaxCUHeight >> uiDepth;
842  memset( m_puhWidth,          uhWidth,  iSizeInUchar );
843  memset( m_puhHeight,         uhHeight, iSizeInUchar );
844  memset( m_pbIPCMFlag,        0, iSizeInBool  );
845  for (UInt ui = 0; ui < m_uiNumPartition; ui++)
846  {
847    m_pePartSize[ui] = SIZE_NONE;
848    m_pePredMode[ui] = MODE_NONE;
849#if HHI_INTERVIEW_SKIP
850    m_pbRenderable[ui]=  0 ;
851#endif
852    m_apiMVPIdx[0][ui] = -1;
853    m_apiMVPIdx[1][ui] = -1;
854    m_apiMVPNum[0][ui] = -1;
855    m_apiMVPNum[1][ui] = -1;
856    if(m_pcPic->getPicSym()->getInverseCUOrderMap(getAddr())*m_pcPic->getNumPartInCU()+m_uiAbsIdxInLCU+ui<getSlice()->getEntropySliceCurStartCUAddr())
857    {
858      m_apiMVPIdx[0][ui] = pcCU->m_apiMVPIdx[0][uiPartOffset+ui];
859      m_apiMVPIdx[1][ui] = pcCU->m_apiMVPIdx[1][uiPartOffset+ui];;
860      m_apiMVPNum[0][ui] = pcCU->m_apiMVPNum[0][uiPartOffset+ui];;
861      m_apiMVPNum[1][ui] = pcCU->m_apiMVPNum[1][uiPartOffset+ui];;
862      m_puhDepth  [ui] = pcCU->getDepth(uiPartOffset+ui);
863#if HHI_MPI
864      m_piTextureModeDepth[ui] = pcCU->getTextureModeDepth(uiPartOffset+ui);
865#endif
866      m_puhWidth  [ui] = pcCU->getWidth(uiPartOffset+ui);
867      m_puhHeight  [ui] = pcCU->getHeight(uiPartOffset+ui);
868      m_puhTrIdx  [ui] = pcCU->getTransformIdx(uiPartOffset+ui);
869      m_nsqtPartIdx[ui] = pcCU->getNSQTPartIdx(uiPartOffset+ui);
870      m_pePartSize[ui] = pcCU->getPartitionSize(uiPartOffset+ui);
871      m_pePredMode[ui] = pcCU->getPredictionMode(uiPartOffset+ui);
872      m_pbIPCMFlag[ui]=pcCU->m_pbIPCMFlag[uiPartOffset+ui];
873      m_phQP[ui] = pcCU->m_phQP[uiPartOffset+ui];
874      m_puiAlfCtrlFlag[ui]=pcCU->m_puiAlfCtrlFlag[uiPartOffset+ui];
875      m_pbMergeFlag[ui]=pcCU->m_pbMergeFlag[uiPartOffset+ui];
876      m_puhMergeIndex[ui]=pcCU->m_puhMergeIndex[uiPartOffset+ui];
877      m_puhLumaIntraDir[ui]=pcCU->m_puhLumaIntraDir[uiPartOffset+ui];
878      m_puhChromaIntraDir[ui]=pcCU->m_puhChromaIntraDir[uiPartOffset+ui];
879      m_puhInterDir[ui]=pcCU->m_puhInterDir[uiPartOffset+ui];
880      m_puhCbf[0][ui]=pcCU->m_puhCbf[0][uiPartOffset+ui];
881      m_puhCbf[1][ui]=pcCU->m_puhCbf[1][uiPartOffset+ui];
882      m_puhCbf[2][ui]=pcCU->m_puhCbf[2][uiPartOffset+ui];
883
884#if HHI_DMM_WEDGE_INTRA
885      m_puiWedgeFullTabIdx      [ui]=pcCU->getWedgeFullTabIdx       (uiPartOffset+ui);
886      m_piWedgeFullDeltaDC1     [ui]=pcCU->getWedgeFullDeltaDC1     (uiPartOffset+ui);
887      m_piWedgeFullDeltaDC2     [ui]=pcCU->getWedgeFullDeltaDC2     (uiPartOffset+ui);
888
889      m_puiWedgePredDirTabIdx   [ui]=pcCU->getWedgePredDirTabIdx    (uiPartOffset+ui);
890      m_piWedgePredDirDeltaDC1  [ui]=pcCU->getWedgePredDirDeltaDC1  (uiPartOffset+ui);
891      m_piWedgePredDirDeltaDC2  [ui]=pcCU->getWedgePredDirDeltaDC2  (uiPartOffset+ui);
892      m_piWedgePredDirDeltaEnd  [ui]=pcCU->getWedgePredDirDeltaEnd  (uiPartOffset+ui);
893#endif
894#if HHI_DMM_PRED_TEX
895      m_puiWedgePredTexTabIdx   [ui]=pcCU->getWedgePredTexTabIdx    (uiPartOffset+ui);
896      m_piWedgePredTexDeltaDC1  [ui]=pcCU->getWedgePredTexDeltaDC1  (uiPartOffset+ui);
897      m_piWedgePredTexDeltaDC2  [ui]=pcCU->getWedgePredTexDeltaDC2  (uiPartOffset+ui);
898
899      m_piContourPredTexDeltaDC1[ui]=pcCU->getContourPredTexDeltaDC1(uiPartOffset+ui);
900      m_piContourPredTexDeltaDC2[ui]=pcCU->getContourPredTexDeltaDC2(uiPartOffset+ui);
901#endif   
902#if HHI_INTER_VIEW_RESIDUAL_PRED
903      m_pbResPredAvailable[ui] = pcCU->m_pbResPredAvailable[ uiPartOffset + ui ];
904      m_pbResPredFlag     [ui] = pcCU->m_pbResPredFlag     [ uiPartOffset + ui ];
905#endif
906    }
907  }
908  UInt uiTmp = uhWidth*uhHeight;
909  memset( m_pcTrCoeffY , 0, sizeof(TCoeff)*uiTmp );
910#if ADAPTIVE_QP_SELECTION 
911  memset( m_pcArlCoeffY , 0, sizeof(Int)*uiTmp );
912#endif
913  memset( m_pcIPCMSampleY , 0, sizeof( Pel ) * uiTmp );
914  uiTmp >>= 2;
915  memset( m_pcTrCoeffCb, 0, sizeof(TCoeff)*uiTmp );
916  memset( m_pcTrCoeffCr, 0, sizeof(TCoeff)*uiTmp );
917#if ADAPTIVE_QP_SELECTION
918  memset( m_pcArlCoeffCb, 0, sizeof(Int)*uiTmp );
919  memset( m_pcArlCoeffCr, 0, sizeof(Int)*uiTmp );
920#endif
921  memset( m_pcIPCMSampleCb , 0, sizeof( Pel ) * uiTmp );
922  memset( m_pcIPCMSampleCr , 0, sizeof( Pel ) * uiTmp );
923  m_acCUMvField[0].clearMvField();
924  m_acCUMvField[1].clearMvField();
925
926  if(m_pcPic->getPicSym()->getInverseCUOrderMap(getAddr())*m_pcPic->getNumPartInCU()+m_uiAbsIdxInLCU<getSlice()->getEntropySliceCurStartCUAddr())
927  {
928    // Part of this CU contains data from an older slice. Now copy in that data.
929    UInt uiMaxCuWidth=pcCU->getSlice()->getSPS()->getMaxCUWidth();
930    UInt uiMaxCuHeight=pcCU->getSlice()->getSPS()->getMaxCUHeight();
931    TComDataCU * bigCU = getPic()->getCU(getAddr());
932    Int minui = uiPartOffset;
933    minui = -minui;
934    pcCU->m_acCUMvField[0].copyTo(&m_acCUMvField[0],minui,uiPartOffset,m_uiNumPartition);
935    pcCU->m_acCUMvField[1].copyTo(&m_acCUMvField[1],minui,uiPartOffset,m_uiNumPartition);
936    UInt uiCoffOffset = uiMaxCuWidth*uiMaxCuHeight*m_uiAbsIdxInLCU/pcCU->getPic()->getNumPartInCU();
937    uiTmp = uhWidth*uhHeight;
938    for(int i=0; i<uiTmp; i++) 
939    {
940      m_pcTrCoeffY[i]=bigCU->m_pcTrCoeffY[uiCoffOffset+i];
941#if ADAPTIVE_QP_SELECTION
942      m_pcArlCoeffY[i]=bigCU->m_pcArlCoeffY[uiCoffOffset+i];
943#endif
944      m_pcIPCMSampleY[i]=bigCU->m_pcIPCMSampleY[uiCoffOffset+i];
945    }
946    uiTmp>>=2;
947    uiCoffOffset>>=2;
948    for(int i=0; i<uiTmp; i++) 
949    {
950      m_pcTrCoeffCr[i]=bigCU->m_pcTrCoeffCr[uiCoffOffset+i];
951      m_pcTrCoeffCb[i]=bigCU->m_pcTrCoeffCb[uiCoffOffset+i];
952#if ADAPTIVE_QP_SELECTION
953      m_pcArlCoeffCr[i]=bigCU->m_pcArlCoeffCr[uiCoffOffset+i];
954      m_pcArlCoeffCb[i]=bigCU->m_pcArlCoeffCb[uiCoffOffset+i];
955#endif
956      m_pcIPCMSampleCb[i]=bigCU->m_pcIPCMSampleCb[uiCoffOffset+i];
957      m_pcIPCMSampleCr[i]=bigCU->m_pcIPCMSampleCr[uiCoffOffset+i];
958    }
959  }
960
961  m_pcCULeft        = pcCU->getCULeft();
962  m_pcCUAbove       = pcCU->getCUAbove();
963  m_pcCUAboveLeft   = pcCU->getCUAboveLeft();
964  m_pcCUAboveRight  = pcCU->getCUAboveRight();
965
966  m_apcCUColocated[0] = pcCU->getCUColocated(REF_PIC_LIST_0);
967  m_apcCUColocated[1] = pcCU->getCUColocated(REF_PIC_LIST_1);
968  memcpy(m_uiSliceStartCU,pcCU->m_uiSliceStartCU+uiPartOffset,sizeof(UInt)*m_uiNumPartition);
969  memcpy(m_uiEntropySliceStartCU,pcCU->m_uiEntropySliceStartCU+uiPartOffset,sizeof(UInt)*m_uiNumPartition);
970}
971
972Void TComDataCU::setOutsideCUPart( UInt uiAbsPartIdx, UInt uiDepth )
973{
974  UInt uiNumPartition = m_uiNumPartition >> (uiDepth << 1);
975  UInt uiSizeInUchar = sizeof( UChar  ) * uiNumPartition;
976
977  UChar uhWidth  = g_uiMaxCUWidth  >> uiDepth;
978  UChar uhHeight = g_uiMaxCUHeight >> uiDepth;
979  memset( m_puhDepth    + uiAbsPartIdx,     uiDepth,  uiSizeInUchar );
980  memset( m_puhWidth    + uiAbsPartIdx,     uhWidth,  uiSizeInUchar );
981  memset( m_puhHeight   + uiAbsPartIdx,     uhHeight, uiSizeInUchar );
982}
983
984// --------------------------------------------------------------------------------------------------------------------
985// Copy
986// --------------------------------------------------------------------------------------------------------------------
987
988Void TComDataCU::copySubCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
989{
990  UInt uiPart = uiAbsPartIdx;
991 
992  m_pcPic              = pcCU->getPic();
993  m_pcSlice            = pcCU->getSlice();
994  m_uiCUAddr           = pcCU->getAddr();
995  m_uiAbsIdxInLCU      = uiAbsPartIdx;
996 
997  m_uiCUPelX           = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
998  m_uiCUPelY           = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
999 
1000  UInt uiWidth         = g_uiMaxCUWidth  >> uiDepth;
1001  UInt uiHeight        = g_uiMaxCUHeight >> uiDepth;
1002 
1003  m_phQP=pcCU->getQP()                    + uiPart;
1004  m_pePartSize = pcCU->getPartitionSize() + uiPart;
1005#if HHI_INTERVIEW_SKIP
1006  m_pbRenderable         = pcCU->getRenderable()        + uiPart;
1007
1008#endif
1009  m_pePredMode=pcCU->getPredictionMode()  + uiPart;
1010 
1011  m_pbMergeFlag         = pcCU->getMergeFlag()        + uiPart;
1012  m_puhMergeIndex       = pcCU->getMergeIndex()       + uiPart;
1013#if HHI_INTER_VIEW_RESIDUAL_PRED
1014  m_pbResPredAvailable  = pcCU->getResPredAvail()     + uiPart;
1015  m_pbResPredFlag       = pcCU->getResPredFlag ()     + uiPart;
1016#endif
1017  m_puhLumaIntraDir     = pcCU->getLumaIntraDir()     + uiPart;
1018  m_puhChromaIntraDir   = pcCU->getChromaIntraDir()   + uiPart;
1019  m_puhInterDir         = pcCU->getInterDir()         + uiPart;
1020  m_puhTrIdx            = pcCU->getTransformIdx()     + uiPart;
1021  m_nsqtPartIdx         = pcCU->getNSQTPartIdx()      + uiPart;
1022 
1023  m_puhCbf[0]= pcCU->getCbf(TEXT_LUMA)            + uiPart;
1024  m_puhCbf[1]= pcCU->getCbf(TEXT_CHROMA_U)        + uiPart;
1025  m_puhCbf[2]= pcCU->getCbf(TEXT_CHROMA_V)        + uiPart;
1026 
1027  m_puhDepth=pcCU->getDepth()                     + uiPart;
1028  m_puhWidth=pcCU->getWidth()                     + uiPart;
1029  m_puhHeight=pcCU->getHeight()                   + uiPart;
1030#if HHI_MPI
1031  m_piTextureModeDepth=pcCU->getTextureModeDepth()+ uiPart;
1032#endif
1033 
1034  m_apiMVPIdx[0]=pcCU->getMVPIdx(REF_PIC_LIST_0)  + uiPart;
1035  m_apiMVPIdx[1]=pcCU->getMVPIdx(REF_PIC_LIST_1)  + uiPart;
1036  m_apiMVPNum[0]=pcCU->getMVPNum(REF_PIC_LIST_0)  + uiPart;
1037  m_apiMVPNum[1]=pcCU->getMVPNum(REF_PIC_LIST_1)  + uiPart;
1038 
1039  m_pbIPCMFlag         = pcCU->getIPCMFlag()        + uiPart;
1040
1041  m_pcCUAboveLeft      = pcCU->getCUAboveLeft();
1042  m_pcCUAboveRight     = pcCU->getCUAboveRight();
1043  m_pcCUAbove          = pcCU->getCUAbove();
1044  m_pcCULeft           = pcCU->getCULeft();
1045 
1046  m_apcCUColocated[0] = pcCU->getCUColocated(REF_PIC_LIST_0);
1047  m_apcCUColocated[1] = pcCU->getCUColocated(REF_PIC_LIST_1);
1048 
1049  UInt uiTmp = uiWidth*uiHeight;
1050  UInt uiMaxCuWidth=pcCU->getSlice()->getSPS()->getMaxCUWidth();
1051  UInt uiMaxCuHeight=pcCU->getSlice()->getSPS()->getMaxCUHeight();
1052 
1053  UInt uiCoffOffset = uiMaxCuWidth*uiMaxCuHeight*uiAbsPartIdx/pcCU->getPic()->getNumPartInCU();
1054 
1055  m_pcTrCoeffY = pcCU->getCoeffY() + uiCoffOffset;
1056#if ADAPTIVE_QP_SELECTION
1057  m_pcArlCoeffY= pcCU->getArlCoeffY() + uiCoffOffset; 
1058#endif
1059  m_pcIPCMSampleY = pcCU->getPCMSampleY() + uiCoffOffset;
1060
1061  uiTmp >>= 2;
1062  uiCoffOffset >>=2;
1063  m_pcTrCoeffCb=pcCU->getCoeffCb() + uiCoffOffset;
1064  m_pcTrCoeffCr=pcCU->getCoeffCr() + uiCoffOffset;
1065#if ADAPTIVE_QP_SELECTION 
1066  m_pcArlCoeffCb=pcCU->getArlCoeffCb() + uiCoffOffset;
1067  m_pcArlCoeffCr=pcCU->getArlCoeffCr() + uiCoffOffset;
1068#endif
1069  m_pcIPCMSampleCb = pcCU->getPCMSampleCb() + uiCoffOffset;
1070  m_pcIPCMSampleCr = pcCU->getPCMSampleCr() + uiCoffOffset;
1071
1072  m_acCUMvField[0].linkToWithOffset( pcCU->getCUMvField(REF_PIC_LIST_0), uiPart );
1073  m_acCUMvField[1].linkToWithOffset( pcCU->getCUMvField(REF_PIC_LIST_1), uiPart );
1074  memcpy(m_uiSliceStartCU,pcCU->m_uiSliceStartCU+uiPart,sizeof(UInt)*m_uiNumPartition);
1075  memcpy(m_uiEntropySliceStartCU,pcCU->m_uiEntropySliceStartCU+uiPart,sizeof(UInt)*m_uiNumPartition);
1076
1077#if HHI_DMM_WEDGE_INTRA
1078  m_puiWedgeFullTabIdx       = pcCU->getWedgeFullTabIdx()        + uiPart;   
1079  m_piWedgeFullDeltaDC1      = pcCU->getWedgeFullDeltaDC1()      + uiPart;   
1080  m_piWedgeFullDeltaDC2      = pcCU->getWedgeFullDeltaDC2()      + uiPart;   
1081
1082  m_puiWedgePredDirTabIdx    = pcCU->getWedgePredDirTabIdx()     + uiPart;   
1083  m_piWedgePredDirDeltaDC1   = pcCU->getWedgePredDirDeltaDC1()   + uiPart;   
1084  m_piWedgePredDirDeltaDC2   = pcCU->getWedgePredDirDeltaDC2()   + uiPart;   
1085  m_piWedgePredDirDeltaEnd   = pcCU->getWedgePredDirDeltaEnd()   + uiPart;
1086#endif
1087#if HHI_DMM_PRED_TEX
1088  m_puiWedgePredTexTabIdx    = pcCU->getWedgePredTexTabIdx()     + uiPart;   
1089  m_piWedgePredTexDeltaDC1   = pcCU->getWedgePredTexDeltaDC1()   + uiPart;   
1090  m_piWedgePredTexDeltaDC2   = pcCU->getWedgePredTexDeltaDC2()   + uiPart;   
1091
1092  m_piContourPredTexDeltaDC1 = pcCU->getContourPredTexDeltaDC1() + uiPart;   
1093  m_piContourPredTexDeltaDC2 = pcCU->getContourPredTexDeltaDC2() + uiPart;   
1094#endif
1095}
1096
1097// Copy inter prediction info from the biggest CU
1098Void TComDataCU::copyInterPredInfoFrom    ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList )
1099{
1100  m_pcPic              = pcCU->getPic();
1101  m_pcSlice            = pcCU->getSlice();
1102  m_uiCUAddr           = pcCU->getAddr();
1103  m_uiAbsIdxInLCU      = uiAbsPartIdx;
1104 
1105  Int iRastPartIdx     = g_auiZscanToRaster[uiAbsPartIdx];
1106  m_uiCUPelX           = pcCU->getCUPelX() + m_pcPic->getMinCUWidth ()*( iRastPartIdx % m_pcPic->getNumPartInWidth() );
1107  m_uiCUPelY           = pcCU->getCUPelY() + m_pcPic->getMinCUHeight()*( iRastPartIdx / m_pcPic->getNumPartInWidth() );
1108 
1109  m_pcCUAboveLeft      = pcCU->getCUAboveLeft();
1110  m_pcCUAboveRight     = pcCU->getCUAboveRight();
1111  m_pcCUAbove          = pcCU->getCUAbove();
1112  m_pcCULeft           = pcCU->getCULeft();
1113 
1114  m_apcCUColocated[0]  = pcCU->getCUColocated(REF_PIC_LIST_0);
1115  m_apcCUColocated[1]  = pcCU->getCUColocated(REF_PIC_LIST_1);
1116 
1117  m_pePartSize         = pcCU->getPartitionSize ()        + uiAbsPartIdx;
1118#if HHI_INTERVIEW_SKIP
1119  m_pbRenderable         = pcCU->getRenderable()        + uiAbsPartIdx;
1120
1121#endif
1122  m_pePredMode         = pcCU->getPredictionMode()        + uiAbsPartIdx;
1123  m_puhInterDir        = pcCU->getInterDir      ()        + uiAbsPartIdx;
1124 
1125  m_puhDepth           = pcCU->getDepth ()                + uiAbsPartIdx;
1126  m_puhWidth           = pcCU->getWidth ()                + uiAbsPartIdx;
1127  m_puhHeight          = pcCU->getHeight()                + uiAbsPartIdx;
1128 
1129  m_pbMergeFlag        = pcCU->getMergeFlag()             + uiAbsPartIdx;
1130  m_puhMergeIndex      = pcCU->getMergeIndex()            + uiAbsPartIdx;
1131#if HHI_INTER_VIEW_RESIDUAL_PRED
1132  m_pbResPredAvailable = pcCU->getResPredAvail()          + uiAbsPartIdx;
1133  m_pbResPredFlag      = pcCU->getResPredFlag ()          + uiAbsPartIdx;
1134#endif
1135  m_apiMVPIdx[eRefPicList] = pcCU->getMVPIdx(eRefPicList) + uiAbsPartIdx;
1136  m_apiMVPNum[eRefPicList] = pcCU->getMVPNum(eRefPicList) + uiAbsPartIdx;
1137 
1138  m_acCUMvField[ eRefPicList ].linkToWithOffset( pcCU->getCUMvField(eRefPicList), uiAbsPartIdx );
1139#if HHI_MPI
1140  m_piTextureModeDepth = pcCU->getTextureModeDepth() + uiAbsPartIdx;
1141#endif
1142
1143  memcpy(m_uiSliceStartCU,pcCU->m_uiSliceStartCU+uiAbsPartIdx,sizeof(UInt)*m_uiNumPartition);
1144  memcpy(m_uiEntropySliceStartCU,pcCU->m_uiEntropySliceStartCU+uiAbsPartIdx,sizeof(UInt)*m_uiNumPartition);
1145}
1146
1147// Copy small CU to bigger CU.
1148// One of quarter parts overwritten by predicted sub part.
1149Void TComDataCU::copyPartFrom( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth )
1150{
1151  assert( uiPartUnitIdx<4 );
1152 
1153  m_dTotalCost         += pcCU->getTotalCost();
1154  m_uiTotalDistortion  += pcCU->getTotalDistortion();
1155  m_uiTotalBits        += pcCU->getTotalBits();
1156 
1157  UInt uiOffset         = pcCU->getTotalNumPart()*uiPartUnitIdx;
1158 
1159  UInt uiNumPartition = pcCU->getTotalNumPart();
1160  Int iSizeInUchar  = sizeof( UChar ) * uiNumPartition;
1161  Int iSizeInBool   = sizeof( Bool  ) * uiNumPartition;
1162 
1163#if H0736_AVC_STYLE_QP_RANGE
1164  Int sizeInChar  = sizeof( Char ) * uiNumPartition;
1165  memcpy( m_phQP       + uiOffset, pcCU->getQP(),             sizeInChar                        );
1166#else
1167  memcpy( m_phQP       + uiOffset, pcCU->getQP(),             iSizeInUchar                        );
1168#endif
1169  memcpy( m_pePartSize + uiOffset, pcCU->getPartitionSize(),  sizeof( *m_pePartSize ) * uiNumPartition );
1170  memcpy( m_pePredMode + uiOffset, pcCU->getPredictionMode(), sizeof( *m_pePredMode ) * uiNumPartition );
1171  #if HHI_INTERVIEW_SKIP
1172  memcpy( m_pbRenderable + uiOffset, pcCU->getRenderable(),         iSizeInBool  );
1173#endif
1174  memcpy( m_puiAlfCtrlFlag      + uiOffset, pcCU->getAlfCtrlFlag(),       iSizeInBool  );
1175  memcpy( m_pbMergeFlag         + uiOffset, pcCU->getMergeFlag(),         iSizeInBool  );
1176  memcpy( m_puhMergeIndex       + uiOffset, pcCU->getMergeIndex(),        iSizeInUchar );
1177#if HHI_INTER_VIEW_RESIDUAL_PRED
1178  memcpy( m_pbResPredAvailable  + uiOffset, pcCU->getResPredAvail(),      iSizeInBool  );
1179  memcpy( m_pbResPredFlag       + uiOffset, pcCU->getResPredFlag(),       iSizeInBool  );
1180#endif
1181  memcpy( m_puhLumaIntraDir     + uiOffset, pcCU->getLumaIntraDir(),      iSizeInUchar );
1182  memcpy( m_puhChromaIntraDir   + uiOffset, pcCU->getChromaIntraDir(),    iSizeInUchar );
1183  memcpy( m_puhInterDir         + uiOffset, pcCU->getInterDir(),          iSizeInUchar );
1184  memcpy( m_puhTrIdx            + uiOffset, pcCU->getTransformIdx(),      iSizeInUchar );
1185  memcpy( m_nsqtPartIdx         + uiOffset, pcCU->getNSQTPartIdx(),       iSizeInUchar );
1186 
1187  memcpy( m_puhCbf[0] + uiOffset, pcCU->getCbf(TEXT_LUMA)    , iSizeInUchar );
1188  memcpy( m_puhCbf[1] + uiOffset, pcCU->getCbf(TEXT_CHROMA_U), iSizeInUchar );
1189  memcpy( m_puhCbf[2] + uiOffset, pcCU->getCbf(TEXT_CHROMA_V), iSizeInUchar );
1190 
1191  memcpy( m_puhDepth  + uiOffset, pcCU->getDepth(),  iSizeInUchar );
1192  memcpy( m_puhWidth  + uiOffset, pcCU->getWidth(),  iSizeInUchar );
1193  memcpy( m_puhHeight + uiOffset, pcCU->getHeight(), iSizeInUchar );
1194 
1195  memcpy( m_apiMVPIdx[0] + uiOffset, pcCU->getMVPIdx(REF_PIC_LIST_0), iSizeInUchar );
1196  memcpy( m_apiMVPIdx[1] + uiOffset, pcCU->getMVPIdx(REF_PIC_LIST_1), iSizeInUchar );
1197  memcpy( m_apiMVPNum[0] + uiOffset, pcCU->getMVPNum(REF_PIC_LIST_0), iSizeInUchar );
1198  memcpy( m_apiMVPNum[1] + uiOffset, pcCU->getMVPNum(REF_PIC_LIST_1), iSizeInUchar );
1199 
1200  memcpy( m_pbIPCMFlag + uiOffset, pcCU->getIPCMFlag(), iSizeInBool );
1201
1202  m_pcCUAboveLeft      = pcCU->getCUAboveLeft();
1203  m_pcCUAboveRight     = pcCU->getCUAboveRight();
1204  m_pcCUAbove          = pcCU->getCUAbove();
1205  m_pcCULeft           = pcCU->getCULeft();
1206 
1207  m_apcCUColocated[0] = pcCU->getCUColocated(REF_PIC_LIST_0);
1208  m_apcCUColocated[1] = pcCU->getCUColocated(REF_PIC_LIST_1);
1209 
1210  m_acCUMvField[0].copyFrom( pcCU->getCUMvField( REF_PIC_LIST_0 ), pcCU->getTotalNumPart(), uiOffset );
1211  m_acCUMvField[1].copyFrom( pcCU->getCUMvField( REF_PIC_LIST_1 ), pcCU->getTotalNumPart(), uiOffset );
1212 
1213  UInt uiTmp  = g_uiMaxCUWidth*g_uiMaxCUHeight >> (uiDepth<<1);
1214  UInt uiTmp2 = uiPartUnitIdx*uiTmp;
1215  memcpy( m_pcTrCoeffY  + uiTmp2, pcCU->getCoeffY(),  sizeof(TCoeff)*uiTmp );
1216#if ADAPTIVE_QP_SELECTION
1217  memcpy( m_pcArlCoeffY  + uiTmp2, pcCU->getArlCoeffY(),  sizeof(Int)*uiTmp );
1218#endif
1219  memcpy( m_pcIPCMSampleY + uiTmp2 , pcCU->getPCMSampleY(), sizeof(Pel) * uiTmp );
1220
1221  uiTmp >>= 2; uiTmp2>>= 2;
1222  memcpy( m_pcTrCoeffCb + uiTmp2, pcCU->getCoeffCb(), sizeof(TCoeff)*uiTmp );
1223  memcpy( m_pcTrCoeffCr + uiTmp2, pcCU->getCoeffCr(), sizeof(TCoeff)*uiTmp );
1224#if ADAPTIVE_QP_SELECTION
1225  memcpy( m_pcArlCoeffCb + uiTmp2, pcCU->getArlCoeffCb(), sizeof(Int)*uiTmp );
1226  memcpy( m_pcArlCoeffCr + uiTmp2, pcCU->getArlCoeffCr(), sizeof(Int)*uiTmp );
1227#endif
1228  memcpy( m_pcIPCMSampleCb + uiTmp2 , pcCU->getPCMSampleCb(), sizeof(Pel) * uiTmp );
1229  memcpy( m_pcIPCMSampleCr + uiTmp2 , pcCU->getPCMSampleCr(), sizeof(Pel) * uiTmp );
1230  m_uiTotalBins += pcCU->getTotalBins();
1231  memcpy( m_uiSliceStartCU        + uiOffset, pcCU->m_uiSliceStartCU,        sizeof( UInt ) * uiNumPartition  );
1232  memcpy( m_uiEntropySliceStartCU + uiOffset, pcCU->m_uiEntropySliceStartCU, sizeof( UInt ) * uiNumPartition  );
1233
1234#if HHI_DMM_WEDGE_INTRA
1235  memcpy( m_puiWedgeFullTabIdx       + uiOffset, pcCU->getWedgeFullTabIdx(),        sizeof( UInt ) * uiNumPartition );
1236  memcpy( m_piWedgeFullDeltaDC1      + uiOffset, pcCU->getWedgeFullDeltaDC1(),      sizeof( Int  ) * uiNumPartition );
1237  memcpy( m_piWedgeFullDeltaDC2      + uiOffset, pcCU->getWedgeFullDeltaDC2(),      sizeof( Int  ) * uiNumPartition );
1238
1239  memcpy( m_puiWedgePredDirTabIdx    + uiOffset, pcCU->getWedgePredDirTabIdx(),     sizeof( UInt ) * uiNumPartition );
1240  memcpy( m_piWedgePredDirDeltaDC1   + uiOffset, pcCU->getWedgePredDirDeltaDC1(),   sizeof( Int  ) * uiNumPartition );
1241  memcpy( m_piWedgePredDirDeltaDC2   + uiOffset, pcCU->getWedgePredDirDeltaDC2(),   sizeof( Int  ) * uiNumPartition );
1242  memcpy( m_piWedgePredDirDeltaEnd   + uiOffset, pcCU->getWedgePredDirDeltaEnd(),   sizeof( Int  ) * uiNumPartition );
1243#endif
1244#if HHI_DMM_PRED_TEX
1245  memcpy( m_puiWedgePredTexTabIdx    + uiOffset, pcCU->getWedgePredTexTabIdx(),     sizeof( UInt ) * uiNumPartition );
1246  memcpy( m_piWedgePredTexDeltaDC1   + uiOffset, pcCU->getWedgePredTexDeltaDC1(),   sizeof( Int  ) * uiNumPartition );
1247  memcpy( m_piWedgePredTexDeltaDC2   + uiOffset, pcCU->getWedgePredTexDeltaDC2(),   sizeof( Int  ) * uiNumPartition );
1248
1249  memcpy( m_piContourPredTexDeltaDC1 + uiOffset, pcCU->getContourPredTexDeltaDC1(), sizeof( Int  ) * uiNumPartition );
1250  memcpy( m_piContourPredTexDeltaDC2 + uiOffset, pcCU->getContourPredTexDeltaDC2(), sizeof( Int  ) * uiNumPartition );
1251#endif
1252#if HHI_MPI
1253  memcpy( m_piTextureModeDepth + uiOffset, pcCU->getTextureModeDepth(), sizeof( Int ) * uiNumPartition );
1254#endif
1255}
1256
1257// Copy current predicted part to a CU in picture.
1258// It is used to predict for next part
1259Void TComDataCU::copyToPic( UChar uhDepth )
1260{
1261  TComDataCU*& rpcCU = m_pcPic->getCU( m_uiCUAddr );
1262 
1263  rpcCU->getTotalCost()       = m_dTotalCost;
1264  rpcCU->getTotalDistortion() = m_uiTotalDistortion;
1265  rpcCU->getTotalBits()       = m_uiTotalBits;
1266 
1267  Int iSizeInUchar  = sizeof( UChar ) * m_uiNumPartition;
1268  Int iSizeInBool   = sizeof( Bool  ) * m_uiNumPartition;
1269 
1270#if H0736_AVC_STYLE_QP_RANGE
1271  Int sizeInChar  = sizeof( Char ) * m_uiNumPartition;
1272  memcpy( rpcCU->getQP() + m_uiAbsIdxInLCU, m_phQP, sizeInChar  );
1273#else
1274  memcpy( rpcCU->getQP() + m_uiAbsIdxInLCU, m_phQP, iSizeInUchar );
1275#endif
1276
1277  memcpy( rpcCU->getPartitionSize()  + m_uiAbsIdxInLCU, m_pePartSize, sizeof( *m_pePartSize ) * m_uiNumPartition );
1278#if HHI_INTERVIEW_SKIP
1279  memcpy( rpcCU->getRenderable()         + m_uiAbsIdxInLCU, m_pbRenderable,         iSizeInBool  );
1280#endif
1281  memcpy( rpcCU->getPredictionMode() + m_uiAbsIdxInLCU, m_pePredMode, sizeof( *m_pePredMode ) * m_uiNumPartition );
1282 
1283  memcpy( rpcCU->getAlfCtrlFlag()    + m_uiAbsIdxInLCU, m_puiAlfCtrlFlag,    iSizeInBool  );
1284 
1285  memcpy( rpcCU->getMergeFlag()         + m_uiAbsIdxInLCU, m_pbMergeFlag,         iSizeInBool  );
1286  memcpy( rpcCU->getMergeIndex()        + m_uiAbsIdxInLCU, m_puhMergeIndex,       iSizeInUchar );
1287#if HHI_INTER_VIEW_RESIDUAL_PRED
1288  memcpy( rpcCU->getResPredAvail()      + m_uiAbsIdxInLCU, m_pbResPredAvailable,  iSizeInBool  );
1289  memcpy( rpcCU->getResPredFlag()       + m_uiAbsIdxInLCU, m_pbResPredFlag,       iSizeInBool  );
1290#endif
1291  memcpy( rpcCU->getLumaIntraDir()      + m_uiAbsIdxInLCU, m_puhLumaIntraDir,     iSizeInUchar );
1292  memcpy( rpcCU->getChromaIntraDir()    + m_uiAbsIdxInLCU, m_puhChromaIntraDir,   iSizeInUchar );
1293  memcpy( rpcCU->getInterDir()          + m_uiAbsIdxInLCU, m_puhInterDir,         iSizeInUchar );
1294  memcpy( rpcCU->getTransformIdx()      + m_uiAbsIdxInLCU, m_puhTrIdx,            iSizeInUchar );
1295  memcpy( rpcCU->getNSQTPartIdx()       + m_uiAbsIdxInLCU, m_nsqtPartIdx,         iSizeInUchar );
1296 
1297  memcpy( rpcCU->getCbf(TEXT_LUMA)     + m_uiAbsIdxInLCU, m_puhCbf[0], iSizeInUchar );
1298  memcpy( rpcCU->getCbf(TEXT_CHROMA_U) + m_uiAbsIdxInLCU, m_puhCbf[1], iSizeInUchar );
1299  memcpy( rpcCU->getCbf(TEXT_CHROMA_V) + m_uiAbsIdxInLCU, m_puhCbf[2], iSizeInUchar );
1300 
1301  memcpy( rpcCU->getDepth()  + m_uiAbsIdxInLCU, m_puhDepth,  iSizeInUchar );
1302  memcpy( rpcCU->getWidth()  + m_uiAbsIdxInLCU, m_puhWidth,  iSizeInUchar );
1303  memcpy( rpcCU->getHeight() + m_uiAbsIdxInLCU, m_puhHeight, iSizeInUchar );
1304 
1305  memcpy( rpcCU->getMVPIdx(REF_PIC_LIST_0) + m_uiAbsIdxInLCU, m_apiMVPIdx[0], iSizeInUchar );
1306  memcpy( rpcCU->getMVPIdx(REF_PIC_LIST_1) + m_uiAbsIdxInLCU, m_apiMVPIdx[1], iSizeInUchar );
1307  memcpy( rpcCU->getMVPNum(REF_PIC_LIST_0) + m_uiAbsIdxInLCU, m_apiMVPNum[0], iSizeInUchar );
1308  memcpy( rpcCU->getMVPNum(REF_PIC_LIST_1) + m_uiAbsIdxInLCU, m_apiMVPNum[1], iSizeInUchar );
1309 
1310  m_acCUMvField[0].copyTo( rpcCU->getCUMvField( REF_PIC_LIST_0 ), m_uiAbsIdxInLCU );
1311  m_acCUMvField[1].copyTo( rpcCU->getCUMvField( REF_PIC_LIST_1 ), m_uiAbsIdxInLCU );
1312 
1313  memcpy( rpcCU->getIPCMFlag() + m_uiAbsIdxInLCU, m_pbIPCMFlag,         iSizeInBool  );
1314
1315  UInt uiTmp  = (g_uiMaxCUWidth*g_uiMaxCUHeight)>>(uhDepth<<1);
1316  UInt uiTmp2 = m_uiAbsIdxInLCU*m_pcPic->getMinCUWidth()*m_pcPic->getMinCUHeight();
1317  memcpy( rpcCU->getCoeffY()  + uiTmp2, m_pcTrCoeffY,  sizeof(TCoeff)*uiTmp  );
1318#if ADAPTIVE_QP_SELECTION 
1319  memcpy( rpcCU->getArlCoeffY()  + uiTmp2, m_pcArlCoeffY,  sizeof(Int)*uiTmp  );
1320#endif
1321  memcpy( rpcCU->getPCMSampleY() + uiTmp2 , m_pcIPCMSampleY, sizeof(Pel)*uiTmp );
1322
1323  uiTmp >>= 2; uiTmp2 >>= 2;
1324  memcpy( rpcCU->getCoeffCb() + uiTmp2, m_pcTrCoeffCb, sizeof(TCoeff)*uiTmp  );
1325  memcpy( rpcCU->getCoeffCr() + uiTmp2, m_pcTrCoeffCr, sizeof(TCoeff)*uiTmp  );
1326#if ADAPTIVE_QP_SELECTION
1327  memcpy( rpcCU->getArlCoeffCb() + uiTmp2, m_pcArlCoeffCb, sizeof(Int)*uiTmp  );
1328  memcpy( rpcCU->getArlCoeffCr() + uiTmp2, m_pcArlCoeffCr, sizeof(Int)*uiTmp  );
1329#endif
1330  memcpy( rpcCU->getPCMSampleCb() + uiTmp2 , m_pcIPCMSampleCb, sizeof( Pel ) * uiTmp );
1331  memcpy( rpcCU->getPCMSampleCr() + uiTmp2 , m_pcIPCMSampleCr, sizeof( Pel ) * uiTmp );
1332  rpcCU->getTotalBins() = m_uiTotalBins;
1333  memcpy( rpcCU->m_uiSliceStartCU        + m_uiAbsIdxInLCU, m_uiSliceStartCU,        sizeof( UInt ) * m_uiNumPartition  );
1334  memcpy( rpcCU->m_uiEntropySliceStartCU + m_uiAbsIdxInLCU, m_uiEntropySliceStartCU, sizeof( UInt ) * m_uiNumPartition  );
1335
1336#if HHI_DMM_WEDGE_INTRA
1337  memcpy( rpcCU->getWedgeFullTabIdx()        + m_uiAbsIdxInLCU, m_puiWedgeFullTabIdx,       sizeof( UInt ) * m_uiNumPartition );
1338  memcpy( rpcCU->getWedgeFullDeltaDC1()      + m_uiAbsIdxInLCU, m_piWedgeFullDeltaDC1,      sizeof( Int  ) * m_uiNumPartition );
1339  memcpy( rpcCU->getWedgeFullDeltaDC2()      + m_uiAbsIdxInLCU, m_piWedgeFullDeltaDC2,      sizeof( Int  ) * m_uiNumPartition );
1340
1341  memcpy( rpcCU->getWedgePredDirTabIdx()     + m_uiAbsIdxInLCU, m_puiWedgePredDirTabIdx,    sizeof( UInt ) * m_uiNumPartition );
1342  memcpy( rpcCU->getWedgePredDirDeltaDC1()   + m_uiAbsIdxInLCU, m_piWedgePredDirDeltaDC1,   sizeof( Int  ) * m_uiNumPartition );
1343  memcpy( rpcCU->getWedgePredDirDeltaDC2()   + m_uiAbsIdxInLCU, m_piWedgePredDirDeltaDC2,   sizeof( Int  ) * m_uiNumPartition );
1344  memcpy( rpcCU->getWedgePredDirDeltaEnd()   + m_uiAbsIdxInLCU, m_piWedgePredDirDeltaEnd,   sizeof( Int  ) * m_uiNumPartition );
1345#endif
1346#if HHI_DMM_PRED_TEX
1347  memcpy( rpcCU->getWedgePredTexTabIdx()     + m_uiAbsIdxInLCU, m_puiWedgePredTexTabIdx,    sizeof( UInt ) * m_uiNumPartition );
1348  memcpy( rpcCU->getWedgePredTexDeltaDC1()   + m_uiAbsIdxInLCU, m_piWedgePredTexDeltaDC1,   sizeof( Int  ) * m_uiNumPartition );
1349  memcpy( rpcCU->getWedgePredTexDeltaDC2()   + m_uiAbsIdxInLCU, m_piWedgePredTexDeltaDC2,   sizeof( Int  ) * m_uiNumPartition );
1350
1351  memcpy( rpcCU->getContourPredTexDeltaDC1() + m_uiAbsIdxInLCU, m_piContourPredTexDeltaDC1, sizeof( Int  ) * m_uiNumPartition );
1352  memcpy( rpcCU->getContourPredTexDeltaDC2() + m_uiAbsIdxInLCU, m_piContourPredTexDeltaDC2, sizeof( Int  ) * m_uiNumPartition );
1353#endif
1354#if HHI_MPI
1355  memcpy( rpcCU->getTextureModeDepth() + m_uiAbsIdxInLCU, m_piTextureModeDepth, sizeof( Int ) * m_uiNumPartition );
1356#endif
1357}
1358
1359Void TComDataCU::copyToPic( UChar uhDepth, UInt uiPartIdx, UInt uiPartDepth )
1360{
1361  TComDataCU*&  rpcCU       = m_pcPic->getCU( m_uiCUAddr );
1362  UInt          uiQNumPart  = m_uiNumPartition>>(uiPartDepth<<1);
1363 
1364  UInt uiPartStart          = uiPartIdx*uiQNumPart;
1365  UInt uiPartOffset         = m_uiAbsIdxInLCU + uiPartStart;
1366 
1367  rpcCU->getTotalCost()       = m_dTotalCost;
1368  rpcCU->getTotalDistortion() = m_uiTotalDistortion;
1369  rpcCU->getTotalBits()       = m_uiTotalBits;
1370 
1371  Int iSizeInUchar  = sizeof( UChar  ) * uiQNumPart;
1372  Int iSizeInBool   = sizeof( Bool   ) * uiQNumPart;
1373 
1374#if H0736_AVC_STYLE_QP_RANGE
1375  Int sizeInChar  = sizeof( Char ) * uiQNumPart;
1376  memcpy( rpcCU->getQP() + uiPartOffset, m_phQP, sizeInChar );
1377#else
1378  memcpy( rpcCU->getQP() + uiPartOffset, m_phQP, iSizeInUchar );
1379#endif 
1380  memcpy( rpcCU->getPartitionSize()  + uiPartOffset, m_pePartSize, sizeof( *m_pePartSize ) * uiQNumPart );
1381#if HHI_INTERVIEW_SKIP
1382  memcpy( rpcCU->getRenderable()         + uiPartOffset, m_pbRenderable,         iSizeInBool  );
1383#endif
1384  memcpy( rpcCU->getPredictionMode() + uiPartOffset, m_pePredMode, sizeof( *m_pePredMode ) * uiQNumPart );
1385 
1386  memcpy( rpcCU->getAlfCtrlFlag()       + uiPartOffset, m_puiAlfCtrlFlag,      iSizeInBool  );
1387  memcpy( rpcCU->getMergeFlag()         + uiPartOffset, m_pbMergeFlag,         iSizeInBool  );
1388  memcpy( rpcCU->getMergeIndex()        + uiPartOffset, m_puhMergeIndex,       iSizeInUchar );
1389#if HHI_INTER_VIEW_RESIDUAL_PRED
1390  memcpy( rpcCU->getResPredAvail()      + uiPartOffset, m_pbResPredAvailable,  iSizeInBool  );
1391  memcpy( rpcCU->getResPredFlag()       + uiPartOffset, m_pbResPredFlag,       iSizeInBool  );
1392#endif
1393  memcpy( rpcCU->getLumaIntraDir()      + uiPartOffset, m_puhLumaIntraDir,     iSizeInUchar );
1394  memcpy( rpcCU->getChromaIntraDir()    + uiPartOffset, m_puhChromaIntraDir,   iSizeInUchar );
1395  memcpy( rpcCU->getInterDir()          + uiPartOffset, m_puhInterDir,         iSizeInUchar );
1396  memcpy( rpcCU->getTransformIdx()      + uiPartOffset, m_puhTrIdx,            iSizeInUchar );
1397  memcpy( rpcCU->getNSQTPartIdx()       + uiPartOffset, m_nsqtPartIdx,         iSizeInUchar );
1398 
1399  memcpy( rpcCU->getCbf(TEXT_LUMA)     + uiPartOffset, m_puhCbf[0], iSizeInUchar );
1400  memcpy( rpcCU->getCbf(TEXT_CHROMA_U) + uiPartOffset, m_puhCbf[1], iSizeInUchar );
1401  memcpy( rpcCU->getCbf(TEXT_CHROMA_V) + uiPartOffset, m_puhCbf[2], iSizeInUchar );
1402 
1403  memcpy( rpcCU->getDepth()  + uiPartOffset, m_puhDepth,  iSizeInUchar );
1404  memcpy( rpcCU->getWidth()  + uiPartOffset, m_puhWidth,  iSizeInUchar );
1405  memcpy( rpcCU->getHeight() + uiPartOffset, m_puhHeight, iSizeInUchar );
1406 
1407  memcpy( rpcCU->getMVPIdx(REF_PIC_LIST_0) + uiPartOffset, m_apiMVPIdx[0], iSizeInUchar );
1408  memcpy( rpcCU->getMVPIdx(REF_PIC_LIST_1) + uiPartOffset, m_apiMVPIdx[1], iSizeInUchar );
1409  memcpy( rpcCU->getMVPNum(REF_PIC_LIST_0) + uiPartOffset, m_apiMVPNum[0], iSizeInUchar );
1410  memcpy( rpcCU->getMVPNum(REF_PIC_LIST_1) + uiPartOffset, m_apiMVPNum[1], iSizeInUchar );
1411  m_acCUMvField[0].copyTo( rpcCU->getCUMvField( REF_PIC_LIST_0 ), m_uiAbsIdxInLCU, uiPartStart, uiQNumPart );
1412  m_acCUMvField[1].copyTo( rpcCU->getCUMvField( REF_PIC_LIST_1 ), m_uiAbsIdxInLCU, uiPartStart, uiQNumPart );
1413 
1414  memcpy( rpcCU->getIPCMFlag() + uiPartOffset, m_pbIPCMFlag,         iSizeInBool  );
1415
1416  UInt uiTmp  = (g_uiMaxCUWidth*g_uiMaxCUHeight)>>((uhDepth+uiPartDepth)<<1);
1417  UInt uiTmp2 = uiPartOffset*m_pcPic->getMinCUWidth()*m_pcPic->getMinCUHeight();
1418  memcpy( rpcCU->getCoeffY()  + uiTmp2, m_pcTrCoeffY,  sizeof(TCoeff)*uiTmp  );
1419#if ADAPTIVE_QP_SELECTION
1420  memcpy( rpcCU->getArlCoeffY()  + uiTmp2, m_pcArlCoeffY,  sizeof(Int)*uiTmp  );
1421#endif
1422 
1423  memcpy( rpcCU->getPCMSampleY() + uiTmp2 , m_pcIPCMSampleY, sizeof( Pel ) * uiTmp );
1424
1425  uiTmp >>= 2; uiTmp2 >>= 2;
1426  memcpy( rpcCU->getCoeffCb() + uiTmp2, m_pcTrCoeffCb, sizeof(TCoeff)*uiTmp  );
1427  memcpy( rpcCU->getCoeffCr() + uiTmp2, m_pcTrCoeffCr, sizeof(TCoeff)*uiTmp  );
1428#if ADAPTIVE_QP_SELECTION
1429  memcpy( rpcCU->getArlCoeffCb() + uiTmp2, m_pcArlCoeffCb, sizeof(Int)*uiTmp  );
1430  memcpy( rpcCU->getArlCoeffCr() + uiTmp2, m_pcArlCoeffCr, sizeof(Int)*uiTmp  );
1431#endif
1432
1433  memcpy( rpcCU->getPCMSampleCb() + uiTmp2 , m_pcIPCMSampleCb, sizeof( Pel ) * uiTmp );
1434  memcpy( rpcCU->getPCMSampleCr() + uiTmp2 , m_pcIPCMSampleCr, sizeof( Pel ) * uiTmp );
1435  rpcCU->getTotalBins() = m_uiTotalBins;
1436  memcpy( rpcCU->m_uiSliceStartCU        + uiPartOffset, m_uiSliceStartCU,        sizeof( UInt ) * uiQNumPart  );
1437  memcpy( rpcCU->m_uiEntropySliceStartCU + uiPartOffset, m_uiEntropySliceStartCU, sizeof( UInt ) * uiQNumPart  );
1438
1439#if HHI_DMM_WEDGE_INTRA
1440  memcpy( rpcCU->getWedgeFullTabIdx()        + uiPartOffset, m_puiWedgeFullTabIdx,       sizeof( UInt ) * uiQNumPart );
1441  memcpy( rpcCU->getWedgeFullDeltaDC1()      + uiPartOffset, m_piWedgeFullDeltaDC1,      sizeof( Int  ) * uiQNumPart );
1442  memcpy( rpcCU->getWedgeFullDeltaDC2()      + uiPartOffset, m_piWedgeFullDeltaDC2,      sizeof( Int  ) * uiQNumPart );
1443
1444  memcpy( rpcCU->getWedgePredDirTabIdx()     + uiPartOffset, m_puiWedgePredDirTabIdx,    sizeof( UInt ) * uiQNumPart );
1445  memcpy( rpcCU->getWedgePredDirDeltaDC1()   + uiPartOffset, m_piWedgePredDirDeltaDC1,   sizeof( Int  ) * uiQNumPart );
1446  memcpy( rpcCU->getWedgePredDirDeltaDC2()   + uiPartOffset, m_piWedgePredDirDeltaDC2,   sizeof( Int  ) * uiQNumPart );
1447  memcpy( rpcCU->getWedgePredDirDeltaEnd()   + uiPartOffset, m_piWedgePredDirDeltaEnd,   sizeof( Int  ) * uiQNumPart );
1448#endif
1449#if HHI_DMM_PRED_TEX
1450  memcpy( rpcCU->getWedgePredTexTabIdx()     + uiPartOffset, m_puiWedgePredTexTabIdx,    sizeof( UInt ) * uiQNumPart );
1451  memcpy( rpcCU->getWedgePredTexDeltaDC1()   + uiPartOffset, m_piWedgePredTexDeltaDC1,   sizeof( Int  ) * uiQNumPart );
1452  memcpy( rpcCU->getWedgePredTexDeltaDC2()   + uiPartOffset, m_piWedgePredTexDeltaDC2,   sizeof( Int  ) * uiQNumPart );
1453
1454  memcpy( rpcCU->getContourPredTexDeltaDC1() + uiPartOffset, m_piContourPredTexDeltaDC1, sizeof( Int  ) * uiQNumPart );
1455  memcpy( rpcCU->getContourPredTexDeltaDC2() + uiPartOffset, m_piContourPredTexDeltaDC2, sizeof( Int  ) * uiQNumPart );
1456#endif
1457#if HHI_MPI
1458  memcpy( rpcCU->getTextureModeDepth() + uiPartOffset, m_piTextureModeDepth, sizeof( Int ) * uiQNumPart  );
1459#endif
1460}
1461
1462// --------------------------------------------------------------------------------------------------------------------
1463// Other public functions
1464// --------------------------------------------------------------------------------------------------------------------
1465
1466TComDataCU* TComDataCU::getPULeft( UInt& uiLPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction, Bool bEnforceEntropySliceRestriction
1467                                 , Bool bEnforceTileRestriction
1468                                 )
1469{
1470  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
1471  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[m_uiAbsIdxInLCU];
1472  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
1473 
1474  if ( !RasterAddress::isZeroCol( uiAbsPartIdx, uiNumPartInCUWidth ) )
1475  {
1476    uiLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx - 1 ];
1477    if ( RasterAddress::isEqualCol( uiAbsPartIdx, uiAbsZorderCUIdx, uiNumPartInCUWidth ) )
1478    {
1479      TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
1480      if ((bEnforceSliceRestriction        && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx)))
1481        ||(bEnforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx))))
1482      {
1483        return NULL;
1484      }
1485      return m_pcPic->getCU( getAddr() );
1486    }
1487    else
1488    {
1489      uiLPartUnitIdx -= m_uiAbsIdxInLCU;
1490      if ((bEnforceSliceRestriction        && (this->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx) || m_pcSlice==NULL))
1491        ||(bEnforceEntropySliceRestriction && (this->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx) || m_pcSlice==NULL)))
1492      {
1493        return NULL;
1494      }
1495      return this;
1496    }
1497  }
1498 
1499  uiLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx + uiNumPartInCUWidth - 1 ];
1500
1501
1502  if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || m_pcCULeft->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)))
1503      ||
1504       (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || m_pcCULeft->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)))
1505      ||
1506#if !REMOVE_TILE_DEPENDENCE
1507       (bEnforceTileRestriction && ( m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))  )  )
1508#else
1509       (bEnforceTileRestriction && ( m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))  )  )
1510#endif
1511      )
1512  {
1513    return NULL;
1514  }
1515  return m_pcCULeft;
1516}
1517
1518
1519TComDataCU* TComDataCU::getPUAbove( UInt& uiAPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction, Bool bEnforceEntropySliceRestriction, Bool MotionDataCompresssion
1520                                  , Bool planarAtLCUBoundary
1521                                  , Bool bEnforceTileRestriction
1522                                  )
1523{
1524  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
1525  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[m_uiAbsIdxInLCU];
1526  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
1527 
1528  if ( !RasterAddress::isZeroRow( uiAbsPartIdx, uiNumPartInCUWidth ) )
1529  {
1530    uiAPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx - uiNumPartInCUWidth ];
1531    if ( RasterAddress::isEqualRow( uiAbsPartIdx, uiAbsZorderCUIdx, uiNumPartInCUWidth ) )
1532    {
1533      TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
1534      if ((bEnforceSliceRestriction        && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiAPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx)))
1535        ||(bEnforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiAPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx))))
1536      {
1537        return NULL;
1538      }
1539      return m_pcPic->getCU( getAddr() );
1540    }
1541    else
1542    {
1543      uiAPartUnitIdx -= m_uiAbsIdxInLCU;
1544      if ((bEnforceSliceRestriction        && (this->getSCUAddr()+uiAPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx) || m_pcSlice==NULL))
1545        ||(bEnforceEntropySliceRestriction && (this->getSCUAddr()+uiAPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx) || m_pcSlice==NULL)))
1546      {
1547        return NULL;
1548      }
1549      return this;
1550    }
1551  }
1552
1553  if(planarAtLCUBoundary)
1554  {
1555    return NULL;
1556  }
1557 
1558  uiAPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx + m_pcPic->getNumPartInCU() - uiNumPartInCUWidth ];
1559  if(MotionDataCompresssion)
1560  {
1561    uiAPartUnitIdx = g_motionRefer[uiAPartUnitIdx];
1562  }
1563
1564  if ( (bEnforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || m_pcCUAbove->getSCUAddr()+uiAPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)))
1565      ||
1566       (bEnforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || m_pcCUAbove->getSCUAddr()+uiAPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)))
1567      ||
1568#if !REMOVE_TILE_DEPENDENCE
1569       (bEnforceTileRestriction &&(m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))))
1570#else
1571       (bEnforceTileRestriction &&(m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))))
1572#endif
1573      )
1574  {
1575    return NULL;
1576  }
1577  return m_pcCUAbove;
1578}
1579
1580TComDataCU* TComDataCU::getPUAboveLeft( UInt& uiALPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction, Bool bEnforceEntropySliceRestriction, Bool MotionDataCompresssion )
1581{
1582  UInt uiAbsPartIdx       = g_auiZscanToRaster[uiCurrPartUnitIdx];
1583  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[m_uiAbsIdxInLCU];
1584  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
1585 
1586  if ( !RasterAddress::isZeroCol( uiAbsPartIdx, uiNumPartInCUWidth ) )
1587  {
1588    if ( !RasterAddress::isZeroRow( uiAbsPartIdx, uiNumPartInCUWidth ) )
1589    {
1590      uiALPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx - uiNumPartInCUWidth - 1 ];
1591      if ( RasterAddress::isEqualRowOrCol( uiAbsPartIdx, uiAbsZorderCUIdx, uiNumPartInCUWidth ) )
1592      {
1593        TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
1594        if ((bEnforceSliceRestriction        && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx)))
1595          ||(bEnforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)))) 
1596        {
1597          return NULL;
1598        }
1599        return m_pcPic->getCU( getAddr() );
1600      }
1601      else
1602      {
1603        uiALPartUnitIdx -= m_uiAbsIdxInLCU;
1604        if ((bEnforceSliceRestriction        && (this->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx) || m_pcSlice==NULL))
1605          ||(bEnforceEntropySliceRestriction && (this->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx) || m_pcSlice==NULL)))
1606        {
1607          return NULL;
1608        }
1609        return this;
1610      }
1611    }
1612    uiALPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx + getPic()->getNumPartInCU() - uiNumPartInCUWidth - 1 ];
1613    if(MotionDataCompresssion)
1614    {
1615      uiALPartUnitIdx = g_motionRefer[uiALPartUnitIdx];
1616    }
1617  if ( (bEnforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || 
1618       m_pcCUAbove->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
1619#if !REMOVE_TILE_DEPENDENCE
1620       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1621#else
1622       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1623#endif
1624       ))||
1625       (bEnforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || 
1626       m_pcCUAbove->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
1627#if !REMOVE_TILE_DEPENDENCE
1628       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1629#else
1630       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1631#endif
1632       ))
1633     )
1634    {
1635      return NULL;
1636    }
1637    return m_pcCUAbove;
1638  }
1639 
1640  if ( !RasterAddress::isZeroRow( uiAbsPartIdx, uiNumPartInCUWidth ) )
1641  {
1642    uiALPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdx - 1 ];
1643  if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || 
1644       m_pcCULeft->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
1645#if !REMOVE_TILE_DEPENDENCE
1646       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1647#else
1648       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1649#endif
1650       ))||
1651       (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || 
1652       m_pcCULeft->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
1653#if !REMOVE_TILE_DEPENDENCE
1654       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1655#else
1656       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1657#endif
1658       ))
1659     )
1660    {
1661      return NULL;
1662    }
1663    return m_pcCULeft;
1664  }
1665 
1666  uiALPartUnitIdx = g_auiRasterToZscan[ m_pcPic->getNumPartInCU() - 1 ];
1667  if(MotionDataCompresssion)
1668  {
1669    uiALPartUnitIdx = g_motionRefer[uiALPartUnitIdx];
1670  }
1671  if ( (bEnforceSliceRestriction && (m_pcCUAboveLeft==NULL || m_pcCUAboveLeft->getSlice()==NULL || 
1672       m_pcCUAboveLeft->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
1673#if !REMOVE_TILE_DEPENDENCE
1674       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveLeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1675#else
1676       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveLeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1677#endif
1678       ))||
1679       (bEnforceEntropySliceRestriction && (m_pcCUAboveLeft==NULL || m_pcCUAboveLeft->getSlice()==NULL || 
1680       m_pcCUAboveLeft->getSCUAddr()+uiALPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
1681#if !REMOVE_TILE_DEPENDENCE
1682       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveLeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1683#else
1684       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveLeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1685#endif
1686       ))
1687     )
1688  {
1689    return NULL;
1690  }
1691  return m_pcCUAboveLeft;
1692}
1693
1694TComDataCU* TComDataCU::getPUAboveRight( UInt& uiARPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction, Bool bEnforceEntropySliceRestriction, Bool MotionDataCompresssion )
1695{
1696  UInt uiAbsPartIdxRT     = g_auiZscanToRaster[uiCurrPartUnitIdx];
1697  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[ m_uiAbsIdxInLCU ] + m_puhWidth[0] / m_pcPic->getMinCUWidth() - 1;
1698  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
1699 
1700  if( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxRT] + m_pcPic->getMinCUWidth() ) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )
1701  {
1702    uiARPartUnitIdx = MAX_UINT;
1703    return NULL;
1704  }
1705 
1706  if ( RasterAddress::lessThanCol( uiAbsPartIdxRT, uiNumPartInCUWidth - 1, uiNumPartInCUWidth ) )
1707  {
1708    if ( !RasterAddress::isZeroRow( uiAbsPartIdxRT, uiNumPartInCUWidth ) )
1709    {
1710      if ( uiCurrPartUnitIdx > g_auiRasterToZscan[ uiAbsPartIdxRT - uiNumPartInCUWidth + 1 ] )
1711      {
1712        uiARPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxRT - uiNumPartInCUWidth + 1 ];
1713        if ( RasterAddress::isEqualRowOrCol( uiAbsPartIdxRT, uiAbsZorderCUIdx, uiNumPartInCUWidth ) )
1714        {
1715          TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
1716          if ((bEnforceSliceRestriction        && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx)))
1717            ||(bEnforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx))))
1718          {
1719            return NULL;
1720          }
1721          return m_pcPic->getCU( getAddr() );
1722        }
1723        else
1724        {
1725          uiARPartUnitIdx -= m_uiAbsIdxInLCU;
1726          if ((bEnforceSliceRestriction        && (this->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx) || m_pcSlice==NULL))
1727            ||(bEnforceEntropySliceRestriction && (this->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx) || m_pcSlice==NULL)))
1728          {
1729            return NULL;
1730          }
1731          return this;
1732        }
1733      }
1734      uiARPartUnitIdx = MAX_UINT;
1735      return NULL;
1736    }
1737    uiARPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxRT + m_pcPic->getNumPartInCU() - uiNumPartInCUWidth + 1 ];
1738    if(MotionDataCompresssion)
1739    {
1740      uiARPartUnitIdx = g_motionRefer[uiARPartUnitIdx];
1741    }
1742
1743  if ( (bEnforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || 
1744       m_pcCUAbove->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
1745#if !REMOVE_TILE_DEPENDENCE
1746       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1747#else
1748       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1749#endif
1750       ))||
1751       (bEnforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || 
1752       m_pcCUAbove->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
1753#if !REMOVE_TILE_DEPENDENCE
1754       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1755#else
1756       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1757#endif
1758       ))
1759     )
1760    {
1761      return NULL;
1762    }
1763    return m_pcCUAbove;
1764  }
1765 
1766  if ( !RasterAddress::isZeroRow( uiAbsPartIdxRT, uiNumPartInCUWidth ) )
1767  {
1768    uiARPartUnitIdx = MAX_UINT;
1769    return NULL;
1770  }
1771 
1772  uiARPartUnitIdx = g_auiRasterToZscan[ m_pcPic->getNumPartInCU() - uiNumPartInCUWidth ];
1773  if(MotionDataCompresssion)
1774  {
1775    uiARPartUnitIdx = g_motionRefer[uiARPartUnitIdx];
1776  }
1777  if ( (bEnforceSliceRestriction && (m_pcCUAboveRight==NULL || m_pcCUAboveRight->getSlice()==NULL ||
1778       m_pcPic->getPicSym()->getInverseCUOrderMap( m_pcCUAboveRight->getAddr()) > m_pcPic->getPicSym()->getInverseCUOrderMap( getAddr()) ||
1779       m_pcCUAboveRight->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
1780#if !REMOVE_TILE_DEPENDENCE
1781       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1782#else
1783       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1784#endif
1785       ))||
1786       (bEnforceEntropySliceRestriction && (m_pcCUAboveRight==NULL || m_pcCUAboveRight->getSlice()==NULL || 
1787       m_pcPic->getPicSym()->getInverseCUOrderMap( m_pcCUAboveRight->getAddr()) > m_pcPic->getPicSym()->getInverseCUOrderMap( getAddr()) ||
1788       m_pcCUAboveRight->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
1789#if !REMOVE_TILE_DEPENDENCE
1790       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1791#else
1792       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1793#endif
1794       ))
1795     )
1796  {
1797    return NULL;
1798  }
1799  return m_pcCUAboveRight;
1800}
1801
1802TComDataCU* TComDataCU::getPUBelowLeft( UInt& uiBLPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction, Bool bEnforceEntropySliceRestriction )
1803{
1804  UInt uiAbsPartIdxLB     = g_auiZscanToRaster[uiCurrPartUnitIdx];
1805  UInt uiAbsZorderCUIdxLB = g_auiZscanToRaster[ m_uiAbsIdxInLCU ] + (m_puhHeight[0] / m_pcPic->getMinCUHeight() - 1)*m_pcPic->getNumPartInWidth();
1806  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
1807 
1808  if( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxLB] + m_pcPic->getMinCUHeight() ) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
1809  {
1810    uiBLPartUnitIdx = MAX_UINT;
1811    return NULL;
1812  }
1813 
1814  if ( RasterAddress::lessThanRow( uiAbsPartIdxLB, m_pcPic->getNumPartInHeight() - 1, uiNumPartInCUWidth ) )
1815  {
1816    if ( !RasterAddress::isZeroCol( uiAbsPartIdxLB, uiNumPartInCUWidth ) )
1817    {
1818      if ( uiCurrPartUnitIdx > g_auiRasterToZscan[ uiAbsPartIdxLB + uiNumPartInCUWidth - 1 ] )
1819      {
1820        uiBLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxLB + uiNumPartInCUWidth - 1 ];
1821        if ( RasterAddress::isEqualRowOrCol( uiAbsPartIdxLB, uiAbsZorderCUIdxLB, uiNumPartInCUWidth ) )
1822        {
1823          TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
1824          if ((bEnforceSliceRestriction        && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx)))
1825            ||(bEnforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx))))
1826          {
1827            return NULL;
1828          }
1829          return m_pcPic->getCU( getAddr() );
1830        }
1831        else
1832        {
1833          uiBLPartUnitIdx -= m_uiAbsIdxInLCU;
1834          if ((bEnforceSliceRestriction        && (this->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx) || m_pcSlice==NULL))
1835            ||(bEnforceEntropySliceRestriction && (this->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx) || m_pcSlice==NULL)))
1836          {
1837            return NULL;
1838          }
1839          return this;
1840        }
1841      }
1842      uiBLPartUnitIdx = MAX_UINT;
1843      return NULL;
1844    }
1845    uiBLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxLB + uiNumPartInCUWidth*2 - 1 ];
1846  if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || 
1847       m_pcCULeft->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
1848#if !REMOVE_TILE_DEPENDENCE
1849       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1850#else
1851       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1852#endif
1853       ))||
1854       (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || 
1855       m_pcCULeft->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
1856#if !REMOVE_TILE_DEPENDENCE
1857       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1858#else
1859       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1860#endif
1861       ))
1862     )
1863    {
1864      return NULL;
1865    }
1866    return m_pcCULeft;
1867  }
1868 
1869  uiBLPartUnitIdx = MAX_UINT;
1870  return NULL;
1871}
1872
1873TComDataCU* TComDataCU::getPUBelowLeftAdi(UInt& uiBLPartUnitIdx, UInt uiPuHeight,  UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset, Bool bEnforceSliceRestriction, Bool bEnforceEntropySliceRestriction )
1874{
1875  UInt uiAbsPartIdxLB     = g_auiZscanToRaster[uiCurrPartUnitIdx];
1876  UInt uiAbsZorderCUIdxLB = g_auiZscanToRaster[ m_uiAbsIdxInLCU ] + ((m_puhHeight[0] / m_pcPic->getMinCUHeight()) - 1)*m_pcPic->getNumPartInWidth();
1877  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
1878 
1879  if( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxLB] + (m_pcPic->getPicSym()->getMinCUHeight() * uiPartUnitOffset)) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples())
1880  {
1881    uiBLPartUnitIdx = MAX_UINT;
1882    return NULL;
1883  }
1884 
1885  if ( RasterAddress::lessThanRow( uiAbsPartIdxLB, m_pcPic->getNumPartInHeight() - uiPartUnitOffset, uiNumPartInCUWidth ) )
1886  {
1887    if ( !RasterAddress::isZeroCol( uiAbsPartIdxLB, uiNumPartInCUWidth ) )
1888    {
1889      if ( uiCurrPartUnitIdx > g_auiRasterToZscan[ uiAbsPartIdxLB + uiPartUnitOffset * uiNumPartInCUWidth - 1 ] )
1890      {
1891        uiBLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxLB + uiPartUnitOffset * uiNumPartInCUWidth - 1 ];
1892        if ( RasterAddress::isEqualRowOrCol( uiAbsPartIdxLB, uiAbsZorderCUIdxLB, uiNumPartInCUWidth ) )
1893        {
1894          TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
1895          if ((bEnforceSliceRestriction        && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx)))
1896            ||(bEnforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx))))
1897          {
1898            return NULL;
1899          }
1900          return m_pcPic->getCU( getAddr() );
1901        }
1902        else
1903        {
1904          uiBLPartUnitIdx -= m_uiAbsIdxInLCU;
1905          if ((bEnforceSliceRestriction        && (this->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiCurrPartUnitIdx) || m_pcSlice==NULL))
1906            ||(bEnforceEntropySliceRestriction && (this->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx) || m_pcSlice==NULL)))
1907          {
1908            return NULL;
1909          }
1910          return this;
1911        }
1912      }
1913      uiBLPartUnitIdx = MAX_UINT;
1914      return NULL;
1915    }
1916    uiBLPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxLB + (1+uiPartUnitOffset) * uiNumPartInCUWidth - 1 ];
1917  if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || 
1918       m_pcCULeft->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
1919#if !REMOVE_TILE_DEPENDENCE
1920       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1921#else
1922       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1923#endif
1924       ))||
1925       (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || 
1926       m_pcCULeft->getSCUAddr()+uiBLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
1927#if !REMOVE_TILE_DEPENDENCE
1928       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1929#else
1930       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1931#endif
1932       ))
1933     )
1934    {
1935      return NULL;
1936    }
1937    return m_pcCULeft;
1938  }
1939 
1940  uiBLPartUnitIdx = MAX_UINT;
1941  return NULL;
1942}
1943
1944TComDataCU* TComDataCU::getPUAboveRightAdi(UInt&  uiARPartUnitIdx, UInt uiPuWidth, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset, Bool bEnforceSliceRestriction, Bool bEnforceEntropySliceRestriction )
1945{
1946  UInt uiAbsPartIdxRT     = g_auiZscanToRaster[uiCurrPartUnitIdx];
1947  UInt uiAbsZorderCUIdx   = g_auiZscanToRaster[ m_uiAbsIdxInLCU ] + (m_puhWidth[0] / m_pcPic->getMinCUWidth()) - 1;
1948  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
1949 
1950  if( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxRT] + (m_pcPic->getPicSym()->getMinCUHeight() * uiPartUnitOffset)) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )
1951  {
1952    uiARPartUnitIdx = MAX_UINT;
1953    return NULL;
1954  }
1955 
1956  if ( RasterAddress::lessThanCol( uiAbsPartIdxRT, uiNumPartInCUWidth - uiPartUnitOffset, uiNumPartInCUWidth ) )
1957  {
1958    if ( !RasterAddress::isZeroRow( uiAbsPartIdxRT, uiNumPartInCUWidth ) )
1959    {
1960      if ( uiCurrPartUnitIdx > g_auiRasterToZscan[ uiAbsPartIdxRT - uiNumPartInCUWidth + uiPartUnitOffset ] )
1961      {
1962        uiARPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxRT - uiNumPartInCUWidth + uiPartUnitOffset ];
1963        if ( RasterAddress::isEqualRowOrCol( uiAbsPartIdxRT, uiAbsZorderCUIdx, uiNumPartInCUWidth ) )
1964        {
1965          TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
1966          if ((bEnforceSliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)))
1967           ||( bEnforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx))))
1968
1969          {
1970            return NULL;
1971          }
1972          return m_pcPic->getCU( getAddr() );
1973        }
1974        else
1975        {
1976          uiARPartUnitIdx -= m_uiAbsIdxInLCU;
1977          if ((bEnforceSliceRestriction && (this->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx) || m_pcSlice==NULL))
1978            ||(bEnforceEntropySliceRestriction && (this->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx) || m_pcSlice==NULL)))
1979          {
1980            return NULL;
1981          }
1982          return this;
1983        }
1984      }
1985      uiARPartUnitIdx = MAX_UINT;
1986      return NULL;
1987    }
1988    uiARPartUnitIdx = g_auiRasterToZscan[ uiAbsPartIdxRT + m_pcPic->getNumPartInCU() - uiNumPartInCUWidth + uiPartUnitOffset ];
1989  if ( (bEnforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || 
1990       m_pcCUAbove->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
1991#if !REMOVE_TILE_DEPENDENCE
1992       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1993#else
1994       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
1995#endif
1996       ))||
1997       (bEnforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || 
1998       m_pcCUAbove->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
1999#if !REMOVE_TILE_DEPENDENCE
2000       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2001#else
2002       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2003#endif
2004       ))
2005     )
2006    {
2007      return NULL;
2008    }
2009    return m_pcCUAbove;
2010  }
2011 
2012  if ( !RasterAddress::isZeroRow( uiAbsPartIdxRT, uiNumPartInCUWidth ) )
2013  {
2014    uiARPartUnitIdx = MAX_UINT;
2015    return NULL;
2016  }
2017 
2018  uiARPartUnitIdx = g_auiRasterToZscan[ m_pcPic->getNumPartInCU() - uiNumPartInCUWidth + uiPartUnitOffset-1 ];
2019  if ( (bEnforceSliceRestriction && (m_pcCUAboveRight==NULL || m_pcCUAboveRight->getSlice()==NULL ||
2020       m_pcPic->getPicSym()->getInverseCUOrderMap( m_pcCUAboveRight->getAddr()) > m_pcPic->getPicSym()->getInverseCUOrderMap( getAddr()) ||
2021       m_pcCUAboveRight->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrPartUnitIdx)||
2022#if !REMOVE_TILE_DEPENDENCE
2023       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2024#else
2025       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2026#endif
2027       ))||
2028       (bEnforceEntropySliceRestriction && (m_pcCUAboveRight==NULL || m_pcCUAboveRight->getSlice()==NULL || 
2029       m_pcPic->getPicSym()->getInverseCUOrderMap( m_pcCUAboveRight->getAddr()) > m_pcPic->getPicSym()->getInverseCUOrderMap( getAddr()) ||
2030       m_pcCUAboveRight->getSCUAddr()+uiARPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrPartUnitIdx)||
2031#if !REMOVE_TILE_DEPENDENCE
2032       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2033#else
2034       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAboveRight->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2035#endif
2036       ))
2037     )
2038  {
2039    return NULL;
2040  }
2041  return m_pcCUAboveRight;
2042}
2043
2044/** Get left QpMinCu
2045*\param   uiLPartUnitIdx
2046*\param   uiCurrAbsIdxInLCU
2047*\param   bEnforceSliceRestriction
2048*\param   bEnforceEntropySliceRestriction
2049*\returns TComDataCU*   point of TComDataCU of left QpMinCu
2050*/
2051TComDataCU* TComDataCU::getQpMinCuLeft( UInt& uiLPartUnitIdx, UInt uiCurrAbsIdxInLCU, Bool bEnforceSliceRestriction, Bool bEnforceEntropySliceRestriction)
2052{
2053  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
2054
2055  UInt uiAbsRorderQpMinCUIdx   = g_auiZscanToRaster[(uiCurrAbsIdxInLCU>>(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1))];
2056  UInt uiNumPartInQpMinCUWidth = getSlice()->getPPS()->getMinCuDQPSize()>>2;
2057
2058  UInt uiAbsZorderQpMinCUIdx   = (uiCurrAbsIdxInLCU>>(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1));
2059  if( (uiCurrAbsIdxInLCU != uiAbsZorderQpMinCUIdx) && 
2060    ((bEnforceSliceRestriction && (m_pcPic->getCU( getAddr() )->getSliceStartCU(uiCurrAbsIdxInLCU) != m_pcPic->getCU( getAddr() )->getSliceStartCU (uiAbsZorderQpMinCUIdx))) ||
2061    (bEnforceEntropySliceRestriction &&(m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiCurrAbsIdxInLCU) != m_pcPic->getCU( getAddr() )->getEntropySliceStartCU (uiAbsZorderQpMinCUIdx)) )) )
2062  {
2063    return NULL;
2064  }
2065
2066  if ( !RasterAddress::isZeroCol( uiAbsRorderQpMinCUIdx, uiNumPartInCUWidth ) )
2067  {
2068    uiLPartUnitIdx = g_auiRasterToZscan[ uiAbsRorderQpMinCUIdx - uiNumPartInQpMinCUWidth ];
2069    TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
2070    if ((bEnforceSliceRestriction        && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (uiAbsZorderQpMinCUIdx)))
2071      ||(bEnforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiAbsZorderQpMinCUIdx))))
2072    {
2073      return NULL;
2074    }
2075    return m_pcPic->getCU( getAddr() );
2076  }
2077
2078  uiLPartUnitIdx = g_auiRasterToZscan[ uiAbsRorderQpMinCUIdx + uiNumPartInCUWidth - uiNumPartInQpMinCUWidth ];
2079
2080  if ( (bEnforceSliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || 
2081       m_pcCULeft->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(uiAbsZorderQpMinCUIdx)||
2082#if !REMOVE_TILE_DEPENDENCE
2083       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2084#else
2085       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2086#endif
2087       ))||
2088       (bEnforceEntropySliceRestriction && (m_pcCULeft==NULL || m_pcCULeft->getSlice()==NULL || 
2089       m_pcCULeft->getSCUAddr()+uiLPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiAbsZorderQpMinCUIdx)||
2090#if !REMOVE_TILE_DEPENDENCE
2091       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2092#else
2093       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCULeft->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2094#endif
2095       ))
2096     )
2097  {
2098    return NULL;
2099  }
2100
2101#if H0204_QP_PREDICTION
2102  if ( m_pcCULeft && m_pcCULeft->getAddr() != getAddr() )
2103  {
2104    return NULL;
2105  }
2106#endif
2107
2108  return m_pcCULeft;
2109}
2110
2111#if H0204_QP_PREDICTION
2112/** Get Above QpMinCu
2113*\param   aPartUnitIdx
2114*\param   currAbsIdxInLCU
2115*\param   enforceSliceRestriction
2116*\param   enforceEntropySliceRestriction
2117*\returns TComDataCU*   point of TComDataCU of above QpMinCu
2118*/
2119TComDataCU* TComDataCU::getQpMinCuAbove( UInt& aPartUnitIdx, UInt currAbsIdxInLCU, Bool enforceSliceRestriction, Bool enforceEntropySliceRestriction )
2120{
2121  UInt numPartInCUWidth = m_pcPic->getNumPartInWidth();
2122
2123  UInt absRorderQpMinCUIdx   = g_auiZscanToRaster[(currAbsIdxInLCU>>(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1))];
2124 
2125  UInt absZorderQpMinCUIdx   = (currAbsIdxInLCU>>(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))<<(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1));
2126  if( (currAbsIdxInLCU != absZorderQpMinCUIdx) && 
2127     ((enforceSliceRestriction        && (m_pcPic->getCU( getAddr() )->getSliceStartCU(currAbsIdxInLCU) != m_pcPic->getCU( getAddr() )->getSliceStartCU (absZorderQpMinCUIdx)))
2128    ||(enforceEntropySliceRestriction && (m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(currAbsIdxInLCU) != m_pcPic->getCU( getAddr() )->getEntropySliceStartCU (absZorderQpMinCUIdx)) )) )
2129  {
2130    return NULL;
2131  }
2132
2133  if ( !RasterAddress::isZeroRow( absRorderQpMinCUIdx, numPartInCUWidth ) )
2134  {
2135    aPartUnitIdx = g_auiRasterToZscan[ absRorderQpMinCUIdx - numPartInCUWidth ];
2136    TComDataCU* pcTempReconCU = m_pcPic->getCU( getAddr() );
2137    if ((enforceSliceRestriction        && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+aPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU       (absZorderQpMinCUIdx)))
2138      ||(enforceEntropySliceRestriction && (pcTempReconCU==NULL || pcTempReconCU->getSlice() == NULL || pcTempReconCU->getSCUAddr()+aPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(absZorderQpMinCUIdx))))
2139    {
2140      return NULL;
2141    }
2142    return m_pcPic->getCU( getAddr() );
2143  }
2144 
2145  aPartUnitIdx = g_auiRasterToZscan[ absRorderQpMinCUIdx + m_pcPic->getNumPartInCU() - numPartInCUWidth ];
2146
2147  if ( (enforceSliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || 
2148       m_pcCUAbove->getSCUAddr()+aPartUnitIdx < m_pcPic->getCU( getAddr() )->getSliceStartCU(absZorderQpMinCUIdx)||
2149#if !REMOVE_TILE_DEPENDENCE
2150       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2151#else
2152       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2153#endif
2154       ))||
2155       (enforceEntropySliceRestriction && (m_pcCUAbove==NULL || m_pcCUAbove->getSlice()==NULL || 
2156       m_pcCUAbove->getSCUAddr()+aPartUnitIdx < m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(absZorderQpMinCUIdx)||
2157#if !REMOVE_TILE_DEPENDENCE
2158       (m_pcPic->getPicSym()->getTileBoundaryIndependenceIdr() && m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2159#else
2160       (m_pcPic->getPicSym()->getTileIdxMap( m_pcCUAbove->getAddr() ) != m_pcPic->getPicSym()->getTileIdxMap(getAddr()))
2161#endif
2162       ))
2163     )
2164  {
2165    return NULL;
2166  }
2167
2168  if ( m_pcCUAbove && m_pcCUAbove->getAddr() != getAddr() )
2169  {
2170    return NULL;
2171  }
2172
2173  return m_pcCUAbove;
2174}
2175#endif
2176
2177#if H0736_AVC_STYLE_QP_RANGE
2178/** Get reference QP from left QpMinCu or latest coded QP
2179*\param   uiCurrAbsIdxInLCU
2180*\returns Char   reference QP value
2181*/
2182Char TComDataCU::getRefQP( UInt uiCurrAbsIdxInLCU )
2183#else
2184/** Get reference QP from left QpMinCu or latest coded QP
2185*\param   uiCurrAbsIdxInLCU
2186*\returns UChar   reference QP value
2187*/
2188UChar TComDataCU::getRefQP( UInt uiCurrAbsIdxInLCU )
2189#endif
2190{
2191#if H0204_QP_PREDICTION
2192  UInt        lPartIdx, aPartIdx;
2193  TComDataCU* cULeft  = getQpMinCuLeft ( lPartIdx, m_uiAbsIdxInLCU + uiCurrAbsIdxInLCU );
2194  TComDataCU* cUAbove = getQpMinCuAbove( aPartIdx, m_uiAbsIdxInLCU + uiCurrAbsIdxInLCU );
2195  return (((cULeft? cULeft->getQP( lPartIdx ): getLastCodedQP( uiCurrAbsIdxInLCU )) + (cUAbove? cUAbove->getQP( aPartIdx ): getLastCodedQP( uiCurrAbsIdxInLCU )) + 1) >> 1);
2196#else
2197  // Left CU
2198  TComDataCU* pcCULeft;
2199  UInt        uiLPartIdx;
2200  pcCULeft = getQpMinCuLeft( uiLPartIdx, m_uiAbsIdxInLCU + uiCurrAbsIdxInLCU );
2201  if ( pcCULeft )
2202  {
2203    return pcCULeft->getQP(uiLPartIdx);
2204  }
2205  // Last QP
2206  return getLastCodedQP( uiCurrAbsIdxInLCU );
2207#endif
2208}
2209
2210Int TComDataCU::getLastValidPartIdx( Int iAbsPartIdx )
2211{
2212  Int iLastValidPartIdx = iAbsPartIdx-1;
2213  while ( iLastValidPartIdx >= 0
2214       && getPredictionMode( iLastValidPartIdx ) == MODE_NONE )
2215  {
2216    UInt uiDepth = getDepth( iLastValidPartIdx );
2217    iLastValidPartIdx -= m_uiNumPartition>>(uiDepth<<1);
2218  }
2219  return iLastValidPartIdx;
2220}
2221
2222#if H0736_AVC_STYLE_QP_RANGE
2223Char TComDataCU::getLastCodedQP( UInt uiAbsPartIdx )
2224#else
2225UChar TComDataCU::getLastCodedQP( UInt uiAbsPartIdx )
2226#endif
2227{
2228  UInt uiQUPartIdxMask = ~((1<<(8-(getSlice()->getPPS()->getMaxCuDQPDepth()<<1)))-1);
2229  Int iLastValidPartIdx = getLastValidPartIdx( uiAbsPartIdx&uiQUPartIdxMask );
2230  if ( uiAbsPartIdx < m_uiNumPartition
2231    && (getSCUAddr()+iLastValidPartIdx < getSliceStartCU(m_uiAbsIdxInLCU+uiAbsPartIdx) || getSCUAddr()+iLastValidPartIdx < getEntropySliceStartCU(m_uiAbsIdxInLCU+uiAbsPartIdx) ))
2232  {
2233    return getSlice()->getSliceQp();
2234  }
2235  else
2236  if ( iLastValidPartIdx >= 0 )
2237  {
2238    return getQP( iLastValidPartIdx );
2239  }
2240  else
2241  {
2242    if ( getZorderIdxInCU() > 0 )
2243    {
2244      return getPic()->getCU( getAddr() )->getLastCodedQP( getZorderIdxInCU() );
2245    }
2246    else if ( getAddr() > 0 )
2247    {
2248      return getPic()->getCU( getAddr()-1 )->getLastCodedQP( getPic()->getNumPartInCU() );
2249    }
2250    else
2251    {
2252      return getSlice()->getSliceQp();
2253    }
2254  }
2255}
2256#if LOSSLESS_CODING
2257/** Check whether the CU is coded in lossless coding mode
2258 * \param   uiAbsPartIdx
2259 * \returns true if the CU is coded in lossless coding mode; false if otherwise
2260 */
2261Bool TComDataCU::isLosslessCoded(UInt absPartIdx)
2262{
2263#if H0736_AVC_STYLE_QP_RANGE
2264  return ( getSlice()->getSPS()->getUseLossless() && ((getQP(absPartIdx) + getSlice()->getSPS()->getQpBDOffsetY()) == 0) );
2265#else
2266  return ( getSlice()->getSPS()->getUseLossless() && (getQP(absPartPIdx)  == 0) );
2267#endif
2268}
2269#endif
2270
2271/** Get allowed chroma intra modes
2272*\param   uiAbsPartIdx
2273*\param   uiModeList  pointer to chroma intra modes array
2274*\returns
2275*- fill uiModeList with chroma intra modes
2276*/
2277Void TComDataCU::getAllowedChromaDir( UInt uiAbsPartIdx, UInt* uiModeList )
2278{
2279  uiModeList[0] = PLANAR_IDX;
2280#if LOGI_INTRA_NAME_3MPM
2281  uiModeList[1] = VER_IDX;
2282  uiModeList[2] = HOR_IDX;
2283#else
2284  uiModeList[1] = 1;
2285  uiModeList[2] = 2;
2286#endif
2287  uiModeList[3] = DC_IDX;
2288  uiModeList[4] = LM_CHROMA_IDX;
2289  uiModeList[5] = DM_CHROMA_IDX;
2290
2291  UInt uiLumaMode = getLumaIntraDir( uiAbsPartIdx );
2292#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
2293  mapDMMtoIntraMode( uiLumaMode );
2294#endif
2295
2296  for( Int i = 0; i < NUM_CHROMA_MODE - 2; i++ )
2297  {
2298    if( uiLumaMode == uiModeList[i] )
2299    {
2300#if LOGI_INTRA_NAME_3MPM
2301      uiModeList[i] = 34; // VER+8 mode
2302#else
2303      uiModeList[i] = 7; // VER+8 mode
2304#endif
2305      break;
2306    }
2307  }
2308}
2309
2310/** Get most probable intra modes
2311*\param   uiAbsPartIdx
2312*\param   uiIntraDirPred  pointer to the array for MPM storage
2313*\param   piMode          it is set with MPM mode in case both MPM are equal. It is used to restrict RD search at encode side.
2314*\returns Number of MPM
2315*/
2316Int TComDataCU::getIntraDirLumaPredictor( UInt uiAbsPartIdx, Int* uiIntraDirPred, Int* piMode  )
2317{
2318  TComDataCU* pcTempCU;
2319  UInt        uiTempPartIdx;
2320  Int         iLeftIntraDir, iAboveIntraDir;
2321  Int         uiPredNum = 0;
2322 
2323  // Get intra direction of left PU
2324  pcTempCU = getPULeft( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
2325 
2326#if DEFAULT_DC
2327  iLeftIntraDir  = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : DC_IDX ) : DC_IDX;
2328#else
2329  iLeftIntraDir  = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : PLANAR_IDX ) : PLANAR_IDX;
2330#endif
2331#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
2332  mapDMMtoIntraMode( iLeftIntraDir );
2333#endif
2334 
2335  // Get intra direction of above PU
2336  pcTempCU = getPUAbove( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx, true, true, false, true );
2337 
2338#if DEFAULT_DC
2339  iAboveIntraDir = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : DC_IDX ) : DC_IDX;
2340#else
2341  iAboveIntraDir = pcTempCU ? ( pcTempCU->isIntra( uiTempPartIdx ) ? pcTempCU->getLumaIntraDir( uiTempPartIdx ) : PLANAR_IDX ) : PLANAR_IDX;
2342#endif
2343#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
2344  mapDMMtoIntraMode( iAboveIntraDir );
2345#endif
2346 
2347#if LOGI_INTRA_NAME_3MPM
2348  uiPredNum = 3;
2349  if(iLeftIntraDir == iAboveIntraDir)
2350  {
2351    if( piMode )
2352    {
2353      *piMode = 1;
2354    }
2355   
2356    if (iLeftIntraDir > 1) // angular modes
2357    {
2358      uiIntraDirPred[0] = iLeftIntraDir;
2359      uiIntraDirPred[1] = ((iLeftIntraDir + 29) % 32) + 2;
2360      uiIntraDirPred[2] = ((iLeftIntraDir - 1 ) % 32) + 2;
2361    }
2362    else //non-angular
2363    {
2364      uiIntraDirPred[0] = PLANAR_IDX;
2365      uiIntraDirPred[1] = DC_IDX;
2366      uiIntraDirPred[2] = VER_IDX; 
2367    }
2368  }
2369  else
2370  {
2371    if( piMode )
2372    {
2373      *piMode = 2;
2374    }
2375    uiIntraDirPred[0] = iLeftIntraDir;
2376    uiIntraDirPred[1] = iAboveIntraDir;
2377   
2378    if (iLeftIntraDir && iAboveIntraDir ) //both modes are non-planar
2379    {
2380      uiIntraDirPred[2] = PLANAR_IDX;
2381    }
2382    else
2383    {
2384      uiIntraDirPred[2] =  (iLeftIntraDir+iAboveIntraDir)<2? VER_IDX : DC_IDX;
2385    }
2386  }
2387#else
2388  Int iIdx  = getIntraSizeIdx(uiAbsPartIdx);
2389 
2390 
2391  if ( iLeftIntraDir >= g_aucIntraModeNumAng[iIdx] ) 
2392  {
2393    iLeftIntraDir = PLANAR_IDX;
2394  }
2395 
2396 
2397  if ( iAboveIntraDir >= g_aucIntraModeNumAng[iIdx] ) 
2398  {
2399    iAboveIntraDir = PLANAR_IDX;
2400  }
2401 
2402  if(iLeftIntraDir == iAboveIntraDir)
2403  {
2404    uiPredNum = 2;
2405   
2406    if( piMode )
2407    {
2408      *piMode = iLeftIntraDir;
2409    }
2410   
2411    iAboveIntraDir = iLeftIntraDir == PLANAR_IDX ? DC_IDX : PLANAR_IDX; // DC or Planar
2412   
2413    assert( iLeftIntraDir != iAboveIntraDir );
2414   
2415    uiIntraDirPred[0] = min(iLeftIntraDir, iAboveIntraDir);
2416    uiIntraDirPred[1] = max(iLeftIntraDir, iAboveIntraDir);
2417  }
2418  else
2419  {
2420    uiPredNum = 2;
2421    uiIntraDirPred[0] = min(iLeftIntraDir, iAboveIntraDir);
2422    uiIntraDirPred[1] = max(iLeftIntraDir, iAboveIntraDir);
2423  }
2424#endif
2425 
2426  return uiPredNum;
2427}
2428
2429UInt TComDataCU::getCtxSplitFlag( UInt uiAbsPartIdx, UInt uiDepth )
2430{
2431  TComDataCU* pcTempCU;
2432  UInt        uiTempPartIdx;
2433  UInt        uiCtx;
2434  // Get left split flag
2435  pcTempCU = getPULeft( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
2436  uiCtx  = ( pcTempCU ) ? ( ( pcTempCU->getDepth( uiTempPartIdx ) > uiDepth ) ? 1 : 0 ) : 0;
2437 
2438  // Get above split flag
2439  pcTempCU = getPUAbove( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
2440  uiCtx += ( pcTempCU ) ? ( ( pcTempCU->getDepth( uiTempPartIdx ) > uiDepth ) ? 1 : 0 ) : 0;
2441 
2442  return uiCtx;
2443}
2444
2445UInt TComDataCU::getCtxQtCbf( UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
2446{
2447  if( eType )
2448  {
2449    return uiTrDepth;
2450  }
2451  else
2452  {
2453    const UInt uiDepth = getDepth( uiAbsPartIdx );
2454    const UInt uiLog2TrafoSize = g_aucConvertToBit[ getSlice()->getSPS()->getMaxCUWidth() ] + 2 - uiDepth - uiTrDepth;
2455    const UInt uiCtx = uiTrDepth == 0 || uiLog2TrafoSize == getSlice()->getSPS()->getQuadtreeTULog2MaxSize() ? 1 : 0;
2456    return uiCtx;
2457  }
2458}
2459
2460UInt TComDataCU::getQuadtreeTULog2MinSizeInCU( UInt absPartIdx )
2461{
2462  UInt log2CbSize = g_aucConvertToBit[getWidth( absPartIdx )] + 2;
2463  PartSize  partSize  = getPartitionSize( absPartIdx );
2464  UInt quadtreeTUMaxDepth = getPredictionMode( absPartIdx ) == MODE_INTRA ? m_pcSlice->getSPS()->getQuadtreeTUMaxDepthIntra() : m_pcSlice->getSPS()->getQuadtreeTUMaxDepthInter(); 
2465  Int intraSplitFlag = ( getPredictionMode( absPartIdx ) == MODE_INTRA && partSize == SIZE_NxN ) ? 1 : 0;
2466#if G519_TU_AMP_NSQT_HARMONIZATION
2467  Int interSplitFlag = ((quadtreeTUMaxDepth == 1) && (getPredictionMode( absPartIdx ) == MODE_INTER) && (partSize != SIZE_2Nx2N) );
2468#else
2469  Int interSplitFlag = ((quadtreeTUMaxDepth == 1) && (getPredictionMode( absPartIdx ) == MODE_INTER) && (partSize == SIZE_Nx2N || partSize == SIZE_2NxN) );
2470#endif
2471 
2472  UInt log2MinTUSizeInCU = 0;
2473  if (log2CbSize < (m_pcSlice->getSPS()->getQuadtreeTULog2MinSize() + quadtreeTUMaxDepth - 1 + interSplitFlag + intraSplitFlag) ) 
2474  {
2475    // when fully making use of signaled TUMaxDepth + inter/intraSplitFlag, resulting luma TB size is < QuadtreeTULog2MinSize
2476    log2MinTUSizeInCU = m_pcSlice->getSPS()->getQuadtreeTULog2MinSize();
2477  }
2478  else
2479  {
2480    // when fully making use of signaled TUMaxDepth + inter/intraSplitFlag, resulting luma TB size is still >= QuadtreeTULog2MinSize
2481    log2MinTUSizeInCU = log2CbSize - ( quadtreeTUMaxDepth - 1 + interSplitFlag + intraSplitFlag); // stop when trafoDepth == hierarchy_depth = splitFlag
2482    if ( log2MinTUSizeInCU > m_pcSlice->getSPS()->getQuadtreeTULog2MaxSize())
2483    {
2484      // when fully making use of signaled TUMaxDepth + inter/intraSplitFlag, resulting luma TB size is still > QuadtreeTULog2MaxSize
2485      log2MinTUSizeInCU = m_pcSlice->getSPS()->getQuadtreeTULog2MaxSize();
2486    } 
2487  }
2488  return log2MinTUSizeInCU;
2489}
2490
2491
2492#if HHI_INTER_VIEW_RESIDUAL_PRED
2493UInt
2494TComDataCU::getCtxResPredFlag( UInt uiAbsPartIdx )
2495{
2496#if 1 // simple context
2497  UInt        uiCtx = 0;
2498#else
2499  TComDataCU* pcTempCU;
2500  UInt        uiTempPartIdx;
2501  UInt        uiCtx = 0;
2502 
2503  // Get BCBP of left PU
2504  pcTempCU = getPULeft( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
2505  uiCtx    = ( pcTempCU ) ? pcTempCU->getResPredFlag( uiTempPartIdx ) : 0;
2506 
2507  // Get BCBP of above PU
2508  pcTempCU = getPUAbove( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
2509  uiCtx   += ( pcTempCU ) ? pcTempCU->getResPredFlag( uiTempPartIdx ) : 0;
2510#endif 
2511  return uiCtx;
2512}
2513#endif
2514
2515
2516UInt TComDataCU::getCtxSkipFlag( UInt uiAbsPartIdx )
2517{
2518  TComDataCU* pcTempCU;
2519  UInt        uiTempPartIdx;
2520  UInt        uiCtx = 0;
2521 
2522  // Get BCBP of left PU
2523  pcTempCU = getPULeft( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
2524  uiCtx    = ( pcTempCU ) ? pcTempCU->isSkipped( uiTempPartIdx ) : 0;
2525 
2526  // Get BCBP of above PU
2527  pcTempCU = getPUAbove( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
2528  uiCtx   += ( pcTempCU ) ? pcTempCU->isSkipped( uiTempPartIdx ) : 0;
2529 
2530  return uiCtx;
2531}
2532
2533UInt TComDataCU::getCtxInterDir( UInt uiAbsPartIdx )
2534{
2535  return getDepth( uiAbsPartIdx );
2536}
2537
2538Void TComDataCU::setCbfSubParts( UInt uiCbfY, UInt uiCbfU, UInt uiCbfV, UInt uiAbsPartIdx, UInt uiDepth )
2539{
2540  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2541  memset( m_puhCbf[0] + uiAbsPartIdx, uiCbfY, sizeof( UChar ) * uiCurrPartNumb );
2542  memset( m_puhCbf[1] + uiAbsPartIdx, uiCbfU, sizeof( UChar ) * uiCurrPartNumb );
2543  memset( m_puhCbf[2] + uiAbsPartIdx, uiCbfV, sizeof( UChar ) * uiCurrPartNumb );
2544}
2545
2546Void TComDataCU::setCbfSubParts( UInt uiCbf, TextType eTType, UInt uiAbsPartIdx, UInt uiDepth )
2547{
2548  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2549  memset( m_puhCbf[g_aucConvertTxtTypeToIdx[eTType]] + uiAbsPartIdx, uiCbf, sizeof( UChar ) * uiCurrPartNumb );
2550}
2551
2552/** Sets a coded block flag for all sub-partitions of a partition
2553 * \param uiCbf The value of the coded block flag to be set
2554 * \param eTType
2555 * \param uiAbsPartIdx
2556 * \param uiPartIdx
2557 * \param uiDepth
2558 * \returns Void
2559 */
2560Void TComDataCU::setCbfSubParts ( UInt uiCbf, TextType eTType, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2561{
2562  setSubPart<UChar>( uiCbf, m_puhCbf[g_aucConvertTxtTypeToIdx[eTType]], uiAbsPartIdx, uiDepth, uiPartIdx );
2563}
2564
2565Void TComDataCU::setDepthSubParts( UInt uiDepth, UInt uiAbsPartIdx )
2566{
2567  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2568  memset( m_puhDepth + uiAbsPartIdx, uiDepth, sizeof(UChar)*uiCurrPartNumb );
2569}
2570
2571Bool TComDataCU::isFirstAbsZorderIdxInDepth (UInt uiAbsPartIdx, UInt uiDepth)
2572{
2573  UInt uiPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2574  return (((m_uiAbsIdxInLCU + uiAbsPartIdx)% uiPartNumb) == 0);
2575}
2576
2577Void TComDataCU::setAlfCtrlFlagSubParts( Bool uiFlag, UInt uiAbsPartIdx, UInt uiDepth )
2578{
2579  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> ( 2 * uiDepth );
2580  memset( m_puiAlfCtrlFlag + uiAbsPartIdx, uiFlag, sizeof( *m_puiAlfCtrlFlag ) * uiCurrPartNumb );
2581}
2582
2583Void TComDataCU::createTmpAlfCtrlFlag()
2584{
2585  m_puiTmpAlfCtrlFlag = new Bool[ m_uiNumPartition ];
2586}
2587
2588Void TComDataCU::destroyTmpAlfCtrlFlag()
2589{
2590  if(m_puiTmpAlfCtrlFlag)
2591  {
2592    delete[] m_puiTmpAlfCtrlFlag;
2593    m_puiTmpAlfCtrlFlag = NULL;
2594  }
2595}
2596
2597Void TComDataCU::copyAlfCtrlFlagToTmp()
2598{
2599  memcpy( m_puiTmpAlfCtrlFlag, m_puiAlfCtrlFlag, sizeof( *m_puiAlfCtrlFlag )*m_uiNumPartition );
2600}
2601
2602Void TComDataCU::copyAlfCtrlFlagFromTmp()
2603{
2604  memcpy( m_puiAlfCtrlFlag, m_puiTmpAlfCtrlFlag, sizeof( *m_puiAlfCtrlFlag )*m_uiNumPartition );
2605}
2606
2607Void TComDataCU::setPartSizeSubParts( PartSize eMode, UInt uiAbsPartIdx, UInt uiDepth )
2608{
2609  assert( sizeof( *m_pePartSize) == 1 );
2610  memset( m_pePartSize + uiAbsPartIdx, eMode, m_pcPic->getNumPartInCU() >> ( 2 * uiDepth ) );
2611}
2612#if HHI_INTERVIEW_SKIP
2613Void TComDataCU::setRenderableSubParts ( Bool bRenderable, UInt uiAbsPartIdx, UInt uiDepth )
2614{
2615  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2616
2617  for (UInt ui = 0; ui < uiCurrPartNumb; ui++ )
2618  {
2619    m_pbRenderable[uiAbsPartIdx + ui] = bRenderable;
2620  }
2621}
2622#endif
2623
2624Void TComDataCU::setPredModeSubParts( PredMode eMode, UInt uiAbsPartIdx, UInt uiDepth )
2625{
2626  assert( sizeof( *m_pePartSize) == 1 );
2627  memset( m_pePredMode + uiAbsPartIdx, eMode, m_pcPic->getNumPartInCU() >> ( 2 * uiDepth ) );
2628}
2629
2630#if H0736_AVC_STYLE_QP_RANGE
2631Void TComDataCU::setQPSubParts( Int qp, UInt uiAbsPartIdx, UInt uiDepth )
2632#else
2633Void TComDataCU::setQPSubParts( UInt uiQP, UInt uiAbsPartIdx, UInt uiDepth )
2634#endif
2635{
2636  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2637  TComSlice * pcSlice = getPic()->getSlice(getPic()->getCurrSliceIdx());
2638
2639  for(UInt uiSCUIdx = uiAbsPartIdx; uiSCUIdx < uiAbsPartIdx+uiCurrPartNumb; uiSCUIdx++)
2640  {
2641    if( m_pcPic->getCU( getAddr() )->getEntropySliceStartCU(uiSCUIdx+getZorderIdxInCU()) == pcSlice->getEntropySliceCurStartCUAddr() )
2642    {
2643#if H0736_AVC_STYLE_QP_RANGE
2644      m_phQP[uiSCUIdx] = qp;
2645#else
2646      m_phQP[uiSCUIdx] = uiQP;
2647#endif
2648    }
2649  }
2650}
2651
2652Void TComDataCU::setLumaIntraDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiDepth )
2653{
2654  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2655 
2656  memset( m_puhLumaIntraDir + uiAbsPartIdx, uiDir, sizeof(UChar)*uiCurrPartNumb );
2657}
2658
2659template<typename T>
2660Void TComDataCU::setSubPart( T uiParameter, T* puhBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx )
2661{
2662  assert( sizeof(T) == 1 ); // Using memset() works only for types of size 1
2663 
2664  UInt uiCurrPartNumQ = (m_pcPic->getNumPartInCU() >> (2 * uiCUDepth)) >> 2;
2665  switch ( m_pePartSize[ uiCUAddr ] )
2666  {
2667    case SIZE_2Nx2N:
2668      memset( puhBaseLCU + uiCUAddr, uiParameter, 4 * uiCurrPartNumQ );
2669      break;
2670    case SIZE_2NxN:
2671      memset( puhBaseLCU + uiCUAddr, uiParameter, 2 * uiCurrPartNumQ );
2672      break;
2673    case SIZE_Nx2N:
2674      memset( puhBaseLCU + uiCUAddr, uiParameter, uiCurrPartNumQ );
2675      memset( puhBaseLCU + uiCUAddr + 2 * uiCurrPartNumQ, uiParameter, uiCurrPartNumQ );
2676      break;
2677    case SIZE_NxN:
2678      memset( puhBaseLCU + uiCUAddr, uiParameter, uiCurrPartNumQ ); 
2679      break;
2680    case SIZE_2NxnU:
2681      if ( uiPUIdx == 0 )
2682      {
2683        memset( puhBaseLCU + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 1) );                     
2684        memset( puhBaseLCU + uiCUAddr + uiCurrPartNumQ, uiParameter, (uiCurrPartNumQ >> 1) );                     
2685      }
2686      else if ( uiPUIdx == 1 )
2687      {
2688        memset( puhBaseLCU + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 1) );                     
2689        memset( puhBaseLCU + uiCUAddr + uiCurrPartNumQ, uiParameter, ((uiCurrPartNumQ >> 1) + (uiCurrPartNumQ << 1)) );                     
2690      }
2691      else
2692      {
2693        assert(0);
2694      }
2695      break;
2696    case SIZE_2NxnD:
2697      if ( uiPUIdx == 0 )
2698      {
2699        memset( puhBaseLCU + uiCUAddr, uiParameter, ((uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1)) );                     
2700        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1) + uiCurrPartNumQ, uiParameter, (uiCurrPartNumQ >> 1) );                     
2701      }
2702      else if ( uiPUIdx == 1 )
2703      {
2704        memset( puhBaseLCU + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 1) );                     
2705        memset( puhBaseLCU + uiCUAddr + uiCurrPartNumQ, uiParameter, (uiCurrPartNumQ >> 1) );                     
2706      }
2707      else
2708      {
2709        assert(0);
2710      }
2711      break;
2712    case SIZE_nLx2N:
2713      if ( uiPUIdx == 0 )
2714      {
2715        memset( puhBaseLCU + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 2) );
2716        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) ); 
2717        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1), uiParameter, (uiCurrPartNumQ >> 2) ); 
2718        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) ); 
2719      }
2720      else if ( uiPUIdx == 1 )
2721      {
2722        memset( puhBaseLCU + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 2) );
2723        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)) ); 
2724        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1), uiParameter, (uiCurrPartNumQ >> 2) ); 
2725        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)) ); 
2726      }
2727      else
2728      {
2729        assert(0);
2730      }
2731      break;
2732    case SIZE_nRx2N:
2733      if ( uiPUIdx == 0 )
2734      {     
2735        memset( puhBaseLCU + uiCUAddr, uiParameter, (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)) );                           
2736        memset( puhBaseLCU + uiCUAddr + uiCurrPartNumQ + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );                           
2737        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1), uiParameter, (uiCurrPartNumQ + (uiCurrPartNumQ >> 2)) );                           
2738        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1) + uiCurrPartNumQ + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );                           
2739      }
2740      else if ( uiPUIdx == 1 )
2741      {
2742        memset( puhBaseLCU + uiCUAddr, uiParameter, (uiCurrPartNumQ >> 2) );                           
2743        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );                           
2744        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1), uiParameter, (uiCurrPartNumQ >> 2) );                           
2745        memset( puhBaseLCU + uiCUAddr + (uiCurrPartNumQ << 1) + (uiCurrPartNumQ >> 1), uiParameter, (uiCurrPartNumQ >> 2) );                         
2746      }
2747      else
2748      {
2749        assert(0);
2750      }
2751      break;
2752    default:
2753      assert( 0 );
2754  }
2755}
2756
2757Void TComDataCU::setMergeFlagSubParts ( Bool bMergeFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2758{
2759  setSubPart( bMergeFlag, m_pbMergeFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
2760}
2761
2762Void TComDataCU::setMergeIndexSubParts ( UInt uiMergeIndex, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2763{
2764  setSubPart<UChar>( uiMergeIndex, m_puhMergeIndex, uiAbsPartIdx, uiDepth, uiPartIdx );
2765}
2766
2767#if HHI_INTER_VIEW_RESIDUAL_PRED
2768Void TComDataCU::setResPredAvailSubParts( Bool bResPredAvailable, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2769{
2770  setSubPart( bResPredAvailable, m_pbResPredAvailable, uiAbsPartIdx, uiDepth, uiPartIdx );
2771}
2772
2773Void TComDataCU::setResPredFlagSubParts( Bool bResPredFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2774{
2775  setSubPart( bResPredFlag, m_pbResPredFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
2776}
2777#endif
2778
2779Void TComDataCU::setChromIntraDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiDepth )
2780{
2781  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2782 
2783  memset( m_puhChromaIntraDir + uiAbsPartIdx, uiDir, sizeof(UChar)*uiCurrPartNumb );
2784}
2785
2786Void TComDataCU::setInterDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2787{
2788  setSubPart<UChar>( uiDir, m_puhInterDir, uiAbsPartIdx, uiDepth, uiPartIdx );
2789}
2790
2791Void TComDataCU::setMVPIdxSubParts( Int iMVPIdx, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2792{
2793  setSubPart<Char>( iMVPIdx, m_apiMVPIdx[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
2794}
2795
2796Void TComDataCU::setMVPNumSubParts( Int iMVPNum, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
2797{
2798  setSubPart<Char>( iMVPNum, m_apiMVPNum[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
2799}
2800
2801
2802Void TComDataCU::setTrIdxSubParts( UInt uiTrIdx, UInt uiAbsPartIdx, UInt uiDepth )
2803{
2804  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2805 
2806  memset( m_puhTrIdx + uiAbsPartIdx, uiTrIdx, sizeof(UChar)*uiCurrPartNumb );
2807}
2808
2809Void TComDataCU::setNSQTIdxSubParts( UInt absPartIdx, UInt depth )
2810{
2811  UInt currPartNumb = m_pcPic->getNumPartInCU() >> (depth << 1);
2812 
2813  memset( m_nsqtPartIdx + absPartIdx, absPartIdx, sizeof(UChar)*currPartNumb );
2814}
2815
2816Void  TComDataCU::setNSQTIdxSubParts( UInt log2TrafoSize, UInt absPartIdx, UInt absTUPartIdx, UInt trMode )
2817{
2818  UInt trWidth, trHeight;
2819  UInt nsTUWidthInBaseUnits, nsTUHeightInBaseUnits;
2820  UInt lcuWidthInBaseUnits = getPic()->getNumPartInWidth();
2821  UInt minTuSize = ( 1 << getSlice()->getSPS()->getQuadtreeTULog2MinSize() );
2822
2823  trWidth = trHeight = ( 1 << log2TrafoSize );
2824
2825  if ( useNonSquareTrans( trMode, absPartIdx ) && ( trWidth > minTuSize ) )
2826  {
2827    trWidth  = ( m_pePartSize[absPartIdx] == SIZE_Nx2N || m_pePartSize[absPartIdx] == SIZE_nLx2N || m_pePartSize[absPartIdx] == SIZE_nRx2N )? trWidth >> 1  : trWidth << 1;
2828    trHeight = ( m_pePartSize[absPartIdx] == SIZE_Nx2N || m_pePartSize[absPartIdx] == SIZE_nLx2N || m_pePartSize[absPartIdx] == SIZE_nRx2N )? trHeight << 1 : trHeight >> 1;
2829  }
2830
2831  nsTUWidthInBaseUnits  = trWidth / getPic()->getMinCUWidth();
2832  nsTUHeightInBaseUnits = trHeight / getPic()->getMinCUHeight();
2833 
2834  if ( nsTUWidthInBaseUnits > nsTUHeightInBaseUnits )
2835  {
2836    UInt currPartNumb = nsTUHeightInBaseUnits*nsTUHeightInBaseUnits;
2837    memset( m_nsqtPartIdx + absTUPartIdx                                                                , absPartIdx, sizeof(UChar)*(currPartNumb) );
2838    memset( m_nsqtPartIdx + g_auiRasterToZscan[g_auiZscanToRaster[absTUPartIdx]+  nsTUHeightInBaseUnits], absPartIdx, sizeof(UChar)*(currPartNumb) );
2839    memset( m_nsqtPartIdx + g_auiRasterToZscan[g_auiZscanToRaster[absTUPartIdx]+2*nsTUHeightInBaseUnits], absPartIdx, sizeof(UChar)*(currPartNumb) );
2840    memset( m_nsqtPartIdx + g_auiRasterToZscan[g_auiZscanToRaster[absTUPartIdx]+3*nsTUHeightInBaseUnits], absPartIdx, sizeof(UChar)*(currPartNumb) );
2841  }
2842  else if ( nsTUWidthInBaseUnits < nsTUHeightInBaseUnits )
2843  {
2844    UInt currPartNumb = nsTUWidthInBaseUnits*nsTUWidthInBaseUnits;
2845    memset( m_nsqtPartIdx + absTUPartIdx                                                                                   , absPartIdx, sizeof(UChar)*(currPartNumb) );
2846    memset( m_nsqtPartIdx + g_auiRasterToZscan[g_auiZscanToRaster[absTUPartIdx]+  nsTUWidthInBaseUnits*lcuWidthInBaseUnits], absPartIdx, sizeof(UChar)*(currPartNumb) );
2847    memset( m_nsqtPartIdx + g_auiRasterToZscan[g_auiZscanToRaster[absTUPartIdx]+2*nsTUWidthInBaseUnits*lcuWidthInBaseUnits], absPartIdx, sizeof(UChar)*(currPartNumb) );
2848    memset( m_nsqtPartIdx + g_auiRasterToZscan[g_auiZscanToRaster[absTUPartIdx]+3*nsTUWidthInBaseUnits*lcuWidthInBaseUnits], absPartIdx, sizeof(UChar)*(currPartNumb) );
2849  }
2850  else
2851  {
2852    UInt currPartNumb = nsTUWidthInBaseUnits*nsTUHeightInBaseUnits;
2853    memset( m_nsqtPartIdx + absTUPartIdx, absPartIdx, sizeof(UChar)*(currPartNumb) );
2854  }
2855}
2856
2857Void TComDataCU::setSizeSubParts( UInt uiWidth, UInt uiHeight, UInt uiAbsPartIdx, UInt uiDepth )
2858{
2859  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
2860 
2861  memset( m_puhWidth  + uiAbsPartIdx, uiWidth,  sizeof(UChar)*uiCurrPartNumb );
2862  memset( m_puhHeight + uiAbsPartIdx, uiHeight, sizeof(UChar)*uiCurrPartNumb );
2863}
2864
2865UChar TComDataCU::getNumPartInter()
2866{
2867  UChar iNumPart = 0;
2868 
2869  switch ( m_pePartSize[0] )
2870  {
2871    case SIZE_2Nx2N:    iNumPart = 1; break;
2872    case SIZE_2NxN:     iNumPart = 2; break;
2873    case SIZE_Nx2N:     iNumPart = 2; break;
2874    case SIZE_NxN:      iNumPart = 4; break;
2875    case SIZE_2NxnU:    iNumPart = 2; break;
2876    case SIZE_2NxnD:    iNumPart = 2; break;
2877    case SIZE_nLx2N:    iNumPart = 2; break;
2878    case SIZE_nRx2N:    iNumPart = 2; break;
2879    default:            assert (0);   break;
2880  }
2881 
2882  return  iNumPart;
2883}
2884
2885#if LG_RESTRICTEDRESPRED_M24766
2886Void TComDataCU::getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight, UInt uiAbsPartIdx, Bool bLCU)
2887{
2888        UInt uiNumPartition  = bLCU ? (getWidth(uiAbsPartIdx)*getHeight(uiAbsPartIdx) >> 4) : m_uiNumPartition;
2889        UInt uiTmpAbsPartIdx = bLCU ? uiAbsPartIdx : 0;
2890
2891        switch ( m_pePartSize[uiTmpAbsPartIdx] )
2892        {
2893        case SIZE_2NxN:
2894                riWidth = getWidth(uiTmpAbsPartIdx);      riHeight = getHeight(uiTmpAbsPartIdx) >> 1; ruiPartAddr = ( uiPartIdx == 0 )? 0 : uiNumPartition >> 1;
2895                break;
2896        case SIZE_Nx2N:
2897                riWidth = getWidth(uiTmpAbsPartIdx) >> 1; riHeight = getHeight(uiTmpAbsPartIdx);      ruiPartAddr = ( uiPartIdx == 0 )? 0 : uiNumPartition >> 2;
2898                break;
2899        case SIZE_NxN:
2900                riWidth = getWidth(uiTmpAbsPartIdx) >> 1; riHeight = getHeight(uiTmpAbsPartIdx) >> 1; ruiPartAddr = ( uiNumPartition >> 2 ) * uiPartIdx;
2901                break;
2902        case SIZE_2NxnU:
2903                riWidth     = getWidth(uiTmpAbsPartIdx);
2904                riHeight    = ( uiPartIdx == 0 ) ?  getHeight(uiTmpAbsPartIdx) >> 2 : ( getHeight(uiTmpAbsPartIdx) >> 2 ) + ( getHeight(uiTmpAbsPartIdx) >> 1 );
2905                ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : uiNumPartition >> 3;
2906                break;
2907        case SIZE_2NxnD:
2908                riWidth     = getWidth(uiTmpAbsPartIdx);
2909                riHeight    = ( uiPartIdx == 0 ) ?  ( getHeight(uiTmpAbsPartIdx) >> 2 ) + ( getHeight(uiTmpAbsPartIdx) >> 1 ) : getHeight(uiTmpAbsPartIdx) >> 2;
2910                ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : (uiNumPartition >> 1) + (uiNumPartition >> 3);
2911                break;
2912        case SIZE_nLx2N:
2913                riWidth     = ( uiPartIdx == 0 ) ? getWidth(uiTmpAbsPartIdx) >> 2 : ( getWidth(uiTmpAbsPartIdx) >> 2 ) + ( getWidth(uiTmpAbsPartIdx) >> 1 );
2914                riHeight    = getHeight(uiTmpAbsPartIdx);
2915                ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : uiNumPartition >> 4;
2916                break;
2917        case SIZE_nRx2N:
2918                riWidth     = ( uiPartIdx == 0 ) ? ( getWidth(uiTmpAbsPartIdx) >> 2 ) + ( getWidth(uiTmpAbsPartIdx) >> 1 ) : getWidth(uiTmpAbsPartIdx) >> 2;
2919                riHeight    = getHeight(uiTmpAbsPartIdx);
2920                ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : (uiNumPartition >> 2) + (uiNumPartition >> 4);
2921                break;
2922        default:
2923                assert ( m_pePartSize[0] == SIZE_2Nx2N );
2924                riWidth = getWidth(uiTmpAbsPartIdx);      riHeight = getHeight(uiTmpAbsPartIdx);      ruiPartAddr = 0;
2925                break;
2926        }
2927}
2928#else
2929Void TComDataCU::getPartIndexAndSize( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight )
2930{
2931  switch ( m_pePartSize[0] )
2932  {
2933    case SIZE_2NxN:
2934      riWidth = getWidth(0);      riHeight = getHeight(0) >> 1; ruiPartAddr = ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1;
2935      break;
2936    case SIZE_Nx2N:
2937      riWidth = getWidth(0) >> 1; riHeight = getHeight(0);      ruiPartAddr = ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 2;
2938      break;
2939    case SIZE_NxN:
2940      riWidth = getWidth(0) >> 1; riHeight = getHeight(0) >> 1; ruiPartAddr = ( m_uiNumPartition >> 2 ) * uiPartIdx;
2941      break;
2942    case SIZE_2NxnU:
2943      riWidth     = getWidth(0);
2944      riHeight    = ( uiPartIdx == 0 ) ?  getHeight(0) >> 2 : ( getHeight(0) >> 2 ) + ( getHeight(0) >> 1 );
2945      ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : m_uiNumPartition >> 3;
2946      break;
2947    case SIZE_2NxnD:
2948      riWidth     = getWidth(0);
2949      riHeight    = ( uiPartIdx == 0 ) ?  ( getHeight(0) >> 2 ) + ( getHeight(0) >> 1 ) : getHeight(0) >> 2;
2950      ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : (m_uiNumPartition >> 1) + (m_uiNumPartition >> 3);
2951      break;
2952    case SIZE_nLx2N:
2953      riWidth     = ( uiPartIdx == 0 ) ? getWidth(0) >> 2 : ( getWidth(0) >> 2 ) + ( getWidth(0) >> 1 );
2954      riHeight    = getHeight(0);
2955      ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : m_uiNumPartition >> 4;
2956      break;
2957    case SIZE_nRx2N:
2958      riWidth     = ( uiPartIdx == 0 ) ? ( getWidth(0) >> 2 ) + ( getWidth(0) >> 1 ) : getWidth(0) >> 2;
2959      riHeight    = getHeight(0);
2960      ruiPartAddr = ( uiPartIdx == 0 ) ? 0 : (m_uiNumPartition >> 2) + (m_uiNumPartition >> 4);
2961      break;
2962    default:
2963      assert ( m_pePartSize[0] == SIZE_2Nx2N );
2964      riWidth = getWidth(0);      riHeight = getHeight(0);      ruiPartAddr = 0;
2965      break;
2966  }
2967}
2968#endif
2969
2970#if LG_RESTRICTEDRESPRED_M24766
2971Int TComDataCU::getResiPredMode(UInt uiPartAddr)
2972{
2973        Int iAddResiShift = -1;
2974
2975        for(UInt uiRefIdx = 0; uiRefIdx < 2; uiRefIdx++)
2976        {
2977                RefPicList eRefList = uiRefIdx ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
2978                Int iBestRefIdx = getCUMvField(eRefList)->getRefIdx(uiPartAddr);
2979                if(iBestRefIdx >= 0 && getSlice()->getViewId() == getSlice()->getRefViewId(eRefList, iBestRefIdx))
2980                        iAddResiShift++;
2981        }
2982
2983        return iAddResiShift;
2984}
2985
2986Void TComDataCU::getPUResiPredShift(Int *iPUResiPredShift, UInt uiAbsPartIndex)
2987{
2988        UInt uiPartSize = getPartitionSize(uiAbsPartIndex);
2989        UInt uiPartAddr;
2990        Int iWidth, iHeight;
2991        Int iAddResiShift;
2992
2993        if(uiPartSize == SIZE_2Nx2N)
2994        {
2995                iAddResiShift = getResiPredMode(uiAbsPartIndex);
2996                for(UInt i = 0; i < 4; i++)
2997                        iPUResiPredShift[i] = (getSlice()->getPPS()->getUseWP() || getInterDir(uiAbsPartIndex) != 3) ? (iAddResiShift >= 0 ? 0 : -1) : (iAddResiShift >= 0 ? 1-iAddResiShift : -1);
2998                return;
2999        }
3000
3001        if(uiPartSize == SIZE_2NxN || uiPartSize == SIZE_2NxnU || uiPartSize == SIZE_2NxnD)
3002        {
3003                for(UInt i = 0; i < 2; i++)
3004                {
3005                        getPartIndexAndSize(i, uiPartAddr, iWidth, iHeight, uiAbsPartIndex, true);
3006                        uiPartAddr += uiAbsPartIndex;
3007                        iAddResiShift = getResiPredMode(uiPartAddr);
3008                        iPUResiPredShift[2*i] = iPUResiPredShift[2*i+1] = (getSlice()->getPPS()->getUseWP() || getInterDir(uiPartAddr) != 3) ? (iAddResiShift >= 0 ? 0 : -1) : (iAddResiShift >= 0 ? 1-iAddResiShift : -1);
3009                }
3010                return;
3011        }
3012
3013        if(uiPartSize == SIZE_Nx2N || uiPartSize == SIZE_nLx2N || uiPartSize == SIZE_nRx2N)
3014        {
3015                for(UInt i = 0; i < 2; i++)
3016                {
3017                        getPartIndexAndSize(i, uiPartAddr, iWidth, iHeight, uiAbsPartIndex, true);
3018                        uiPartAddr += uiAbsPartIndex;
3019                        iAddResiShift = getResiPredMode(uiPartAddr);
3020                        iPUResiPredShift[i] = iPUResiPredShift[2+i] = (getSlice()->getPPS()->getUseWP() || getInterDir(uiPartAddr) != 3) ? (iAddResiShift >= 0 ? 0 : -1) : (iAddResiShift >= 0 ? 1-iAddResiShift : -1);
3021                }
3022                return;
3023        }
3024
3025        if(uiPartSize == SIZE_NxN)
3026        {
3027                for(UInt i = 0; i < 4; i++)
3028                {
3029                        getPartIndexAndSize(i, uiPartAddr, iWidth, iHeight, uiAbsPartIndex, true);
3030                        uiPartAddr += uiAbsPartIndex;
3031                        iAddResiShift = getResiPredMode(uiPartAddr);
3032                        iPUResiPredShift[i] = (getSlice()->getPPS()->getUseWP() || getInterDir(uiPartAddr) != 3) ? (iAddResiShift >= 0 ? 0 : -1) : (iAddResiShift >= 0 ? 1-iAddResiShift : -1);
3033                }
3034        }
3035
3036}
3037#endif
3038
3039Void TComDataCU::getMvField ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList, TComMvField& rcMvField )
3040{
3041  if ( pcCU == NULL )  // OUT OF BOUNDARY
3042  {
3043    TComMv  cZeroMv;
3044    rcMvField.setMvField( cZeroMv, NOT_VALID );
3045    return;
3046  }
3047 
3048  TComCUMvField*  pcCUMvField = pcCU->getCUMvField( eRefPicList );
3049  rcMvField.setMvField( pcCUMvField->getMv( uiAbsPartIdx ), pcCUMvField->getRefIdx( uiAbsPartIdx ) );
3050}
3051
3052Void TComDataCU::deriveLeftRightTopIdxGeneral ( PartSize eCUMode, UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT )
3053{
3054  ruiPartIdxLT = m_uiAbsIdxInLCU + uiAbsPartIdx;
3055  UInt uiPUWidth = 0;
3056 
3057  switch ( m_pePartSize[uiAbsPartIdx] )
3058  {
3059    case SIZE_2Nx2N: uiPUWidth = m_puhWidth[uiAbsPartIdx];  break;
3060    case SIZE_2NxN:  uiPUWidth = m_puhWidth[uiAbsPartIdx];   break;
3061    case SIZE_Nx2N:  uiPUWidth = m_puhWidth[uiAbsPartIdx]  >> 1;  break;
3062    case SIZE_NxN:   uiPUWidth = m_puhWidth[uiAbsPartIdx]  >> 1; break;
3063    case SIZE_2NxnU:   uiPUWidth = m_puhWidth[uiAbsPartIdx]; break;
3064    case SIZE_2NxnD:   uiPUWidth = m_puhWidth[uiAbsPartIdx]; break;
3065    case SIZE_nLx2N:   
3066      if ( uiPartIdx == 0 )
3067      {
3068        uiPUWidth = m_puhWidth[uiAbsPartIdx]  >> 2; 
3069      }
3070      else if ( uiPartIdx == 1 )
3071      {
3072        uiPUWidth = (m_puhWidth[uiAbsPartIdx]  >> 1) + (m_puhWidth[uiAbsPartIdx]  >> 2); 
3073      }
3074      else
3075      {
3076        assert(0);
3077      }
3078      break;
3079    case SIZE_nRx2N:   
3080      if ( uiPartIdx == 0 )
3081      {
3082        uiPUWidth = (m_puhWidth[uiAbsPartIdx]  >> 1) + (m_puhWidth[uiAbsPartIdx]  >> 2); 
3083      }
3084      else if ( uiPartIdx == 1 )
3085      {
3086        uiPUWidth = m_puhWidth[uiAbsPartIdx]  >> 2; 
3087      }
3088      else
3089      {
3090        assert(0);
3091      }
3092      break;
3093    default:
3094      assert (0);
3095      break;
3096  }
3097 
3098  ruiPartIdxRT = g_auiRasterToZscan [g_auiZscanToRaster[ ruiPartIdxLT ] + uiPUWidth / m_pcPic->getMinCUWidth() - 1 ];
3099}
3100
3101Void TComDataCU::deriveLeftBottomIdxGeneral( PartSize eCUMode, UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB )
3102{
3103  UInt uiPUHeight = 0;
3104  switch ( m_pePartSize[uiAbsPartIdx] )
3105  {
3106    case SIZE_2Nx2N: uiPUHeight = m_puhHeight[uiAbsPartIdx];    break;
3107    case SIZE_2NxN:  uiPUHeight = m_puhHeight[uiAbsPartIdx] >> 1;    break;
3108    case SIZE_Nx2N:  uiPUHeight = m_puhHeight[uiAbsPartIdx];  break;
3109    case SIZE_NxN:   uiPUHeight = m_puhHeight[uiAbsPartIdx] >> 1;    break;
3110    case SIZE_2NxnU: 
3111      if ( uiPartIdx == 0 )
3112      {
3113        uiPUHeight = m_puhHeight[uiAbsPartIdx] >> 2;   
3114      }
3115      else if ( uiPartIdx == 1 )
3116      {
3117        uiPUHeight = (m_puhHeight[uiAbsPartIdx] >> 1) + (m_puhHeight[uiAbsPartIdx] >> 2);   
3118      }
3119      else
3120      {
3121        assert(0);
3122      }
3123      break;
3124    case SIZE_2NxnD: 
3125      if ( uiPartIdx == 0 )
3126      {
3127        uiPUHeight = (m_puhHeight[uiAbsPartIdx] >> 1) + (m_puhHeight[uiAbsPartIdx] >> 2);   
3128      }
3129      else if ( uiPartIdx == 1 )
3130      {
3131        uiPUHeight = m_puhHeight[uiAbsPartIdx] >> 2;   
3132      }
3133      else
3134      {
3135        assert(0);
3136      }
3137      break;
3138    case SIZE_nLx2N: uiPUHeight = m_puhHeight[uiAbsPartIdx];  break;
3139    case SIZE_nRx2N: uiPUHeight = m_puhHeight[uiAbsPartIdx];  break;
3140    default:
3141      assert (0);
3142      break;
3143  }
3144 
3145  ruiPartIdxLB      = g_auiRasterToZscan [g_auiZscanToRaster[ m_uiAbsIdxInLCU + uiAbsPartIdx ] + ((uiPUHeight / m_pcPic->getMinCUHeight()) - 1)*m_pcPic->getNumPartInWidth()];
3146}
3147
3148Void TComDataCU::deriveLeftRightTopIdx ( PartSize eCUMode, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT )
3149{
3150  ruiPartIdxLT = m_uiAbsIdxInLCU;
3151  ruiPartIdxRT = g_auiRasterToZscan [g_auiZscanToRaster[ ruiPartIdxLT ] + m_puhWidth[0] / m_pcPic->getMinCUWidth() - 1 ];
3152 
3153  switch ( m_pePartSize[0] )
3154  {
3155    case SIZE_2Nx2N:                                                                                                                                break;
3156    case SIZE_2NxN:
3157      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1; ruiPartIdxRT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1;
3158      break;
3159    case SIZE_Nx2N:
3160      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 2; ruiPartIdxRT -= ( uiPartIdx == 1 )? 0 : m_uiNumPartition >> 2;
3161      break;
3162    case SIZE_NxN:
3163      ruiPartIdxLT += ( m_uiNumPartition >> 2 ) * uiPartIdx;         ruiPartIdxRT +=  ( m_uiNumPartition >> 2 ) * ( uiPartIdx - 1 );
3164      break;
3165    case SIZE_2NxnU:
3166      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 3;
3167      ruiPartIdxRT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 3;
3168      break;
3169    case SIZE_2NxnD:
3170      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : ( m_uiNumPartition >> 1 ) + ( m_uiNumPartition >> 3 );
3171      ruiPartIdxRT += ( uiPartIdx == 0 )? 0 : ( m_uiNumPartition >> 1 ) + ( m_uiNumPartition >> 3 );
3172      break;
3173    case SIZE_nLx2N:
3174      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 4;
3175      ruiPartIdxRT -= ( uiPartIdx == 1 )? 0 : ( m_uiNumPartition >> 2 ) + ( m_uiNumPartition >> 4 );
3176      break;
3177    case SIZE_nRx2N:
3178      ruiPartIdxLT += ( uiPartIdx == 0 )? 0 : ( m_uiNumPartition >> 2 ) + ( m_uiNumPartition >> 4 );
3179      ruiPartIdxRT -= ( uiPartIdx == 1 )? 0 : m_uiNumPartition >> 4;
3180      break;
3181    default:
3182      assert (0);
3183      break;
3184  }
3185 
3186}
3187
3188Void TComDataCU::deriveLeftBottomIdx( PartSize      eCUMode,   UInt  uiPartIdx,      UInt&      ruiPartIdxLB )
3189{
3190  ruiPartIdxLB      = g_auiRasterToZscan [g_auiZscanToRaster[ m_uiAbsIdxInLCU ] + ( ((m_puhHeight[0] / m_pcPic->getMinCUHeight())>>1) - 1)*m_pcPic->getNumPartInWidth()];
3191 
3192  switch ( m_pePartSize[0] )
3193  {
3194    case SIZE_2Nx2N:
3195      ruiPartIdxLB += m_uiNumPartition >> 1;
3196      break;
3197    case SIZE_2NxN:
3198      ruiPartIdxLB += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1;
3199      break;
3200    case SIZE_Nx2N:
3201      ruiPartIdxLB += ( uiPartIdx == 0 )? m_uiNumPartition >> 1 : (m_uiNumPartition >> 2)*3;
3202      break;
3203    case SIZE_NxN:
3204      ruiPartIdxLB += ( m_uiNumPartition >> 2 ) * uiPartIdx;
3205      break;
3206    case SIZE_2NxnU:
3207      ruiPartIdxLB += ( uiPartIdx == 0 ) ? -((Int)m_uiNumPartition >> 3) : m_uiNumPartition >> 1;
3208      break;
3209    case SIZE_2NxnD:
3210      ruiPartIdxLB += ( uiPartIdx == 0 ) ? (m_uiNumPartition >> 2) + (m_uiNumPartition >> 3): m_uiNumPartition >> 1;
3211      break;
3212    case SIZE_nLx2N:
3213      ruiPartIdxLB += ( uiPartIdx == 0 ) ? m_uiNumPartition >> 1 : (m_uiNumPartition >> 1) + (m_uiNumPartition >> 4);
3214      break;
3215    case SIZE_nRx2N:
3216      ruiPartIdxLB += ( uiPartIdx == 0 ) ? m_uiNumPartition >> 1 : (m_uiNumPartition >> 1) + (m_uiNumPartition >> 2) + (m_uiNumPartition >> 4);
3217      break;
3218    default:
3219      assert (0);
3220      break;
3221  }
3222}
3223
3224/** Derives the partition index of neighbouring bottom right block
3225 * \param [in]  eCUMode
3226 * \param [in]  uiPartIdx
3227 * \param [out] ruiPartIdxRB
3228 */
3229Void TComDataCU::deriveRightBottomIdx( PartSize      eCUMode,   UInt  uiPartIdx,      UInt&      ruiPartIdxRB )
3230{
3231  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];
3232
3233  switch ( m_pePartSize[0] )
3234  {
3235    case SIZE_2Nx2N: 
3236      ruiPartIdxRB += m_uiNumPartition >> 1;   
3237      break;
3238    case SIZE_2NxN: 
3239      ruiPartIdxRB += ( uiPartIdx == 0 )? 0 : m_uiNumPartition >> 1;   
3240      break;
3241    case SIZE_Nx2N: 
3242      ruiPartIdxRB += ( uiPartIdx == 0 )? m_uiNumPartition >> 2 : (m_uiNumPartition >> 1);   
3243      break;
3244    case SIZE_NxN:   
3245      ruiPartIdxRB += ( m_uiNumPartition >> 2 ) * ( uiPartIdx - 1 );   
3246      break;
3247    case SIZE_2NxnU:
3248      ruiPartIdxRB += ( uiPartIdx == 0 ) ? -((Int)m_uiNumPartition >> 3) : m_uiNumPartition >> 1;
3249      break;
3250    case SIZE_2NxnD:
3251      ruiPartIdxRB += ( uiPartIdx == 0 ) ? (m_uiNumPartition >> 2) + (m_uiNumPartition >> 3): m_uiNumPartition >> 1;
3252      break;
3253    case SIZE_nLx2N:
3254      ruiPartIdxRB += ( uiPartIdx == 0 ) ? (m_uiNumPartition >> 3) + (m_uiNumPartition >> 4): m_uiNumPartition >> 1;
3255      break;
3256    case SIZE_nRx2N:
3257      ruiPartIdxRB += ( uiPartIdx == 0 ) ? (m_uiNumPartition >> 2) + (m_uiNumPartition >> 3) + (m_uiNumPartition >> 4) : m_uiNumPartition >> 1;
3258      break;
3259    default:
3260      assert (0);
3261      break;
3262  }
3263}
3264
3265Void TComDataCU::deriveLeftRightTopIdxAdi ( UInt& ruiPartIdxLT, UInt& ruiPartIdxRT, UInt uiPartOffset, UInt uiPartDepth )
3266{
3267  UInt uiNumPartInWidth = (m_puhWidth[0]/m_pcPic->getMinCUWidth())>>uiPartDepth;
3268  ruiPartIdxLT = m_uiAbsIdxInLCU + uiPartOffset;
3269  ruiPartIdxRT = g_auiRasterToZscan[ g_auiZscanToRaster[ ruiPartIdxLT ] + uiNumPartInWidth - 1 ];
3270}
3271
3272Void TComDataCU::deriveLeftBottomIdxAdi( UInt& ruiPartIdxLB, UInt uiPartOffset, UInt uiPartDepth )
3273{
3274  UInt uiAbsIdx;
3275  UInt uiMinCuWidth, uiWidthInMinCus;
3276 
3277  uiMinCuWidth    = getPic()->getMinCUWidth();
3278  uiWidthInMinCus = (getWidth(0)/uiMinCuWidth)>>uiPartDepth;
3279  uiAbsIdx        = getZorderIdxInCU()+uiPartOffset+(m_uiNumPartition>>(uiPartDepth<<1))-1;
3280  uiAbsIdx        = g_auiZscanToRaster[uiAbsIdx]-(uiWidthInMinCus-1);
3281  ruiPartIdxLB    = g_auiRasterToZscan[uiAbsIdx];
3282}
3283
3284Bool TComDataCU::hasEqualMotion( UInt uiAbsPartIdx, TComDataCU* pcCandCU, UInt uiCandAbsPartIdx )
3285{
3286
3287  if ( getInterDir( uiAbsPartIdx ) != pcCandCU->getInterDir( uiCandAbsPartIdx ) )
3288  {
3289    return false;
3290  }
3291
3292  for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
3293  {
3294    if ( getInterDir( uiAbsPartIdx ) & ( 1 << uiRefListIdx ) )
3295    {
3296      if ( getCUMvField( RefPicList( uiRefListIdx ) )->getMv( uiAbsPartIdx )     != pcCandCU->getCUMvField( RefPicList( uiRefListIdx ) )->getMv( uiCandAbsPartIdx ) || 
3297        getCUMvField( RefPicList( uiRefListIdx ) )->getRefIdx( uiAbsPartIdx ) != pcCandCU->getCUMvField( RefPicList( uiRefListIdx ) )->getRefIdx( uiCandAbsPartIdx ) )
3298      {
3299        return false;
3300      }
3301    }
3302  }
3303
3304  return true;
3305}
3306
3307/** Constructs a list of merging candidates
3308 * \param uiAbsPartIdx
3309 * \param uiPUIdx
3310 * \param uiDepth
3311 * \param pcMvFieldNeighbours
3312 * \param puhInterDirNeighbours
3313 * \param numValidMergeCand
3314 */
3315#if SIMP_MRG_PRUN
3316Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx )
3317#else
3318Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand )
3319#endif
3320{
3321#if HHI_INTER_VIEW_MOTION_PRED
3322  const Int extraMergeCand = ( getSlice()->getSPS()->getMultiviewMvPredMode() ? 1 : 0 );
3323#endif
3324
3325  UInt uiAbsPartAddr = m_uiAbsIdxInLCU + uiAbsPartIdx;
3326  UInt uiIdx = 1;
3327#if HHI_INTER_VIEW_MOTION_PRED
3328  bool abCandIsInter[ MRG_MAX_NUM_CANDS_MEM ];
3329  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS_MEM; ++ui )
3330#else
3331  bool abCandIsInter[ MRG_MAX_NUM_CANDS ];
3332  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ++ui )
3333#endif
3334  {
3335    abCandIsInter[ui] = false;
3336  }
3337  // compute the location of the current PU
3338#if PARALLEL_MERGE
3339  Int xP, yP, nPSW, nPSH;
3340  this->getPartPosition(uiPUIdx, xP, yP, nPSW, nPSH);
3341#endif
3342
3343  Int iCount = 0;
3344
3345  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
3346  PartSize cCurPS = getPartitionSize( uiAbsPartIdx );
3347  deriveLeftRightTopIdxGeneral( cCurPS, uiAbsPartIdx, uiPUIdx, uiPartIdxLT, uiPartIdxRT );
3348  deriveLeftBottomIdxGeneral( cCurPS, uiAbsPartIdx, uiPUIdx, uiPartIdxLB );
3349
3350#if HHI_INTER_VIEW_MOTION_PRED
3351  Bool bNoPdmMerge   = ( m_pcSlice->getSPS()->getViewId() == 0 || ( m_pcSlice->getSPS()->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) != PDM_USE_FOR_MERGE );
3352
3353  //===== add merge with predicted depth maps =====
3354  TComMv  acPdmMv       [2];
3355  Int     aiPdmRefIdx   [2] = {-1, -1};
3356  Int     iPdmInterDir      = getPdmMergeCandidate( uiPUIdx, aiPdmRefIdx, acPdmMv );
3357
3358  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 0 )
3359  {
3360    abCandIsInter        [ iCount ] = true;
3361    puhInterDirNeighbours[ iCount ] = iPdmInterDir;
3362    if( ( iPdmInterDir & 1 ) == 1 )
3363    {
3364      pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 0 ], aiPdmRefIdx[ 0 ] );
3365    }
3366    if( ( iPdmInterDir & 2 ) == 2 )
3367    {
3368      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 1 ], aiPdmRefIdx[ 1 ] );
3369    }
3370#if SIMP_MRG_PRUN
3371    if ( mrgCandIdx == iCount )
3372    {
3373      return;
3374    }
3375#endif
3376    iCount ++;
3377  }
3378#endif
3379
3380  //left
3381  UInt uiLeftPartIdx = 0;
3382  TComDataCU* pcCULeft = 0;
3383#if MVP_AT_ENTROPYSLICE_BOUNDARY
3384  pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB, true, false );
3385#else
3386  pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB );
3387#endif
3388#if PARALLEL_MERGE
3389  if (pcCULeft) 
3390  {
3391    if (!pcCULeft->isDiffMER(xP -1, yP+nPSH-1, xP, yP))
3392    {
3393      pcCULeft = NULL;
3394    }
3395  }
3396#endif
3397  PartSize partSize = getPartitionSize( uiAbsPartIdx );
3398  if (!(uiPUIdx == 1 && (partSize == SIZE_Nx2N || partSize == SIZE_nLx2N || partSize == SIZE_nRx2N)))
3399  {
3400  if ( pcCULeft && !pcCULeft->isIntra( uiLeftPartIdx ) )
3401  {
3402    abCandIsInter[iCount] = true;
3403    // get Inter Dir
3404    puhInterDirNeighbours[iCount] = pcCULeft->getInterDir( uiLeftPartIdx );
3405    // get Mv from Left
3406    pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3407    if ( getSlice()->isInterB() )
3408    {
3409      pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3410    }
3411#if SIMP_MRG_PRUN
3412    if ( mrgCandIdx == iCount )
3413    {
3414      return;
3415    }
3416#endif
3417    iCount ++;
3418  }
3419  }
3420
3421#if HHI_INTER_VIEW_MOTION_PRED
3422  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 1 )
3423  {
3424    abCandIsInter        [ iCount ] = true;
3425    puhInterDirNeighbours[ iCount ] = iPdmInterDir;
3426    if( ( iPdmInterDir & 1 ) == 1 )
3427    {
3428      pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 0 ], aiPdmRefIdx[ 0 ] );
3429    }
3430    if( ( iPdmInterDir & 2 ) == 2 )
3431    {
3432      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 1 ], aiPdmRefIdx[ 1 ] );
3433    }
3434#if SIMP_MRG_PRUN
3435    if ( mrgCandIdx == iCount )
3436    {
3437      return;
3438    }
3439#endif
3440    iCount ++;
3441  }
3442#endif
3443
3444  // above
3445#if !SIMP_MRG_PRUN
3446  partSize = getPartitionSize( uiAbsPartIdx );
3447  if (!(uiPUIdx == 1 && (partSize == SIZE_2NxN || partSize == SIZE_2NxnU || partSize == SIZE_2NxnD)))
3448  {
3449#endif
3450  UInt uiAbovePartIdx = 0;
3451  TComDataCU* pcCUAbove = 0;
3452#if MVP_AT_ENTROPYSLICE_BOUNDARY
3453  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT, true, false, true );
3454#else
3455  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT, true, true, true );
3456#endif
3457#if PARALLEL_MERGE
3458    if (pcCUAbove) 
3459    {
3460      if (!pcCUAbove->isDiffMER(xP+nPSW-1, yP-1, xP, yP))
3461      {
3462        pcCUAbove = NULL;
3463      }
3464    }
3465#endif
3466#if SIMP_MRG_PRUN
3467  if ( pcCUAbove && !pcCUAbove->isIntra( uiAbovePartIdx ) 
3468    && !(uiPUIdx == 1 && (cCurPS == SIZE_2NxN || cCurPS == SIZE_2NxnU || cCurPS == SIZE_2NxnD))
3469    && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAbove, uiAbovePartIdx ) ) )
3470#else
3471  if ( pcCUAbove && !pcCUAbove->isIntra( uiAbovePartIdx ) )
3472#endif
3473  {
3474    abCandIsInter[iCount] = true;
3475    // get Inter Dir
3476    puhInterDirNeighbours[iCount] = pcCUAbove->getInterDir( uiAbovePartIdx );
3477    // get Mv from Left
3478    pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3479    if ( getSlice()->isInterB() )
3480    {
3481      pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3482    }
3483#if SIMP_MRG_PRUN
3484    if ( mrgCandIdx == iCount )
3485    {
3486      return;
3487    }
3488#endif
3489    iCount ++;
3490  }
3491#if !SIMP_MRG_PRUN
3492  }
3493#endif
3494
3495#if HHI_INTER_VIEW_MOTION_PRED
3496  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 2 )
3497  {
3498    abCandIsInter        [ iCount ] = true;
3499    puhInterDirNeighbours[ iCount ] = iPdmInterDir;
3500    if( ( iPdmInterDir & 1 ) == 1 )
3501    {
3502      pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 0 ], aiPdmRefIdx[ 0 ] );
3503    }
3504    if( ( iPdmInterDir & 2 ) == 2 )
3505    {
3506      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 1 ], aiPdmRefIdx[ 1 ] );
3507    }
3508#if SIMP_MRG_PRUN
3509    if ( mrgCandIdx == iCount )
3510    {
3511      return;
3512    }
3513#endif
3514    iCount ++;
3515  }
3516#endif
3517
3518  // above right
3519  UInt uiAboveRightPartIdx = 0;
3520  TComDataCU* pcCUAboveRight = 0;
3521#if MVP_AT_ENTROPYSLICE_BOUNDARY
3522  pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT, true, false, true );
3523#else
3524  pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT, true, true, true);
3525#endif
3526#if PARALLEL_MERGE
3527  if (pcCUAboveRight) 
3528  {
3529    if (!pcCUAboveRight->isDiffMER(xP+nPSW, yP-1, xP, yP))
3530    {
3531      pcCUAboveRight = NULL;
3532    }
3533  }
3534#endif
3535#if SIMP_MRG_PRUN
3536  if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx ) && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
3537#else
3538  if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx ) )
3539#endif
3540  {
3541    abCandIsInter[iCount] = true;
3542    // get Inter Dir
3543    puhInterDirNeighbours[iCount] = pcCUAboveRight->getInterDir( uiAboveRightPartIdx );
3544    // get Mv from Left
3545    pcCUAboveRight->getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3546    if ( getSlice()->isInterB() )
3547    {
3548      pcCUAboveRight->getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3549    }
3550#if SIMP_MRG_PRUN
3551    if ( mrgCandIdx == iCount )
3552    {
3553      return;
3554    }
3555#endif
3556    iCount ++;
3557  }
3558
3559#if HHI_INTER_VIEW_MOTION_PRED
3560  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 3 )
3561  {
3562    abCandIsInter        [ iCount ] = true;
3563    puhInterDirNeighbours[ iCount ] = iPdmInterDir;
3564    if( ( iPdmInterDir & 1 ) == 1 )
3565    {
3566      pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 0 ], aiPdmRefIdx[ 0 ] );
3567    }
3568    if( ( iPdmInterDir & 2 ) == 2 )
3569    {
3570      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 1 ], aiPdmRefIdx[ 1 ] );
3571    }
3572#if SIMP_MRG_PRUN
3573    if ( mrgCandIdx == iCount )
3574    {
3575      return;
3576    }
3577#endif
3578    iCount ++;
3579  }
3580#endif
3581
3582  //left bottom
3583  UInt uiLeftBottomPartIdx = 0;
3584  TComDataCU* pcCULeftBottom = 0;
3585#if MVP_AT_ENTROPYSLICE_BOUNDARY
3586  pcCULeftBottom = this->getPUBelowLeft( uiLeftBottomPartIdx, uiPartIdxLB, true, false );
3587#else
3588  pcCULeftBottom = this->getPUBelowLeft( uiLeftBottomPartIdx, uiPartIdxLB );
3589#endif
3590#if PARALLEL_MERGE
3591  if (pcCULeftBottom)
3592  {
3593    if (!pcCULeftBottom->isDiffMER(xP-1, yP+nPSH, xP, yP))
3594    {
3595      pcCULeftBottom = NULL;
3596    }
3597  }
3598#endif
3599#if SIMP_MRG_PRUN
3600  if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
3601#else
3602  if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) )
3603#endif
3604  {
3605    abCandIsInter[iCount] = true;
3606    // get Inter Dir
3607    puhInterDirNeighbours[iCount] = pcCULeftBottom->getInterDir( uiLeftBottomPartIdx );
3608    // get Mv from Left
3609    pcCULeftBottom->getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3610    if ( getSlice()->isInterB() )
3611    {
3612      pcCULeftBottom->getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3613    }
3614#if SIMP_MRG_PRUN
3615    if ( mrgCandIdx == iCount )
3616    {
3617      return;
3618    }
3619#endif
3620    iCount ++;
3621  }
3622
3623#if HHI_INTER_VIEW_MOTION_PRED
3624  if( iPdmInterDir && !bNoPdmMerge && PDM_MERGE_POS == 4 )
3625  {
3626    abCandIsInter        [ iCount ] = true;
3627    puhInterDirNeighbours[ iCount ] = iPdmInterDir;
3628    if( ( iPdmInterDir & 1 ) == 1 )
3629    {
3630      pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 0 ], aiPdmRefIdx[ 0 ] );
3631    }
3632    if( ( iPdmInterDir & 2 ) == 2 )
3633    {
3634      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 1 ], aiPdmRefIdx[ 1 ] );
3635    }
3636#if SIMP_MRG_PRUN
3637    if ( mrgCandIdx == iCount )
3638    {
3639      return;
3640    }
3641#endif
3642    iCount ++;
3643  }
3644#endif
3645
3646  // above left
3647#if HHI_INTER_VIEW_MOTION_PRED
3648  if( iCount < 4 + extraMergeCand )
3649#else
3650  if( iCount < 4 )
3651#endif
3652  {
3653    UInt uiAboveLeftPartIdx = 0;
3654    TComDataCU* pcCUAboveLeft = 0;
3655#if MVP_AT_ENTROPYSLICE_BOUNDARY
3656    pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr, true, false, true );
3657#else
3658    pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr, true, true, true );
3659#endif
3660#if PARALLEL_MERGE
3661    if (pcCUAboveLeft) 
3662    {
3663      if (!pcCUAboveLeft->isDiffMER(xP-1, yP-1, xP, yP))
3664      {
3665        pcCUAboveLeft = NULL;
3666      }
3667    }
3668#endif
3669#if SIMP_MRG_PRUN
3670    if( pcCUAboveLeft && !pcCUAboveLeft->isIntra( uiAboveLeftPartIdx )
3671     && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
3672     && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
3673     )
3674#else
3675    if( pcCUAboveLeft && !pcCUAboveLeft->isIntra( uiAboveLeftPartIdx ) )
3676#endif
3677    {
3678      abCandIsInter[iCount] = true;
3679      // get Inter Dir
3680      puhInterDirNeighbours[iCount] = pcCUAboveLeft->getInterDir( uiAboveLeftPartIdx );
3681      // get Mv from Left
3682      pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
3683      if ( getSlice()->isInterB() )
3684      {
3685        pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
3686      }
3687#if SIMP_MRG_PRUN
3688      if ( mrgCandIdx == iCount )
3689      {
3690        return;
3691      }
3692#endif
3693      iCount ++;
3694    }
3695  }
3696
3697  if ( getSlice()->getPPS()->getEnableTMVPFlag() )
3698  {
3699    // col [2]
3700    Int iRefIdxSkip[2] = {-1, -1};
3701    for (Int i=0; i<2; i++)
3702    {
3703      RefPicList  eRefPicList = ( i==1 ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
3704#if SET_MERGE_TMVP_REFIDX
3705      Int iRefIdxTmp;
3706      if ( uiPUIdx != 0 )
3707      {
3708        iRefIdxTmp = 0;
3709      }
3710      else
3711      {   
3712        iRefIdxTmp = (pcCULeft != NULL) ? pcCULeft->getCUMvField(eRefPicList)->getRefIdx(uiLeftPartIdx) : -1;
3713      }
3714#else     
3715      Int iRefIdxTmp = (pcCULeft != NULL) ? pcCULeft->getCUMvField(eRefPicList)->getRefIdx(uiLeftPartIdx) : -1;
3716#endif
3717      iRefIdxSkip[i] = (iRefIdxTmp != -1) ? iRefIdxTmp : 0;
3718    }
3719    //>> MTK colocated-RightBottom
3720    UInt uiPartIdxRB;
3721    Int uiLCUIdx = getAddr();
3722    PartSize eCUMode = getPartitionSize( 0 );
3723
3724    deriveRightBottomIdx( eCUMode, uiPUIdx, uiPartIdxRB ); 
3725
3726    UInt uiAbsPartIdxTmp = g_auiZscanToRaster[uiPartIdxRB];
3727    UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
3728
3729    TComMv cColMv;
3730    Int iRefIdx;
3731
3732    if      ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth() ) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )  // image boundary check
3733    {
3734      uiLCUIdx = -1;
3735    }
3736    else if ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() ) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
3737    {
3738      uiLCUIdx = -1;
3739    }
3740    else
3741    {
3742      if ( ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 ) &&           // is not at the last column of LCU
3743        ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) ) // is not at the last row    of LCU
3744      {
3745        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + uiNumPartInCUWidth + 1 ];
3746        uiLCUIdx = getAddr();
3747      }
3748      else if ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 )           // is not at the last column of LCU But is last row of LCU
3749      {
3750        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdxTmp + uiNumPartInCUWidth + 1) % m_pcPic->getNumPartInCU() ];
3751        uiLCUIdx = -1 ; 
3752      }
3753      else if ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) // is not at the last row of LCU But is last column of LCU
3754      {
3755        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + 1 ];
3756        uiLCUIdx = getAddr() + 1;
3757      }
3758      else //is the right bottom corner of LCU                       
3759      {
3760        uiAbsPartAddr = 0;
3761        uiLCUIdx = -1 ; 
3762      }
3763    }
3764    iRefIdx = iRefIdxSkip[0];
3765
3766    Bool bExistMV = false;
3767    UInt uiPartIdxCenter;
3768    UInt uiCurLCUIdx = getAddr();
3769    xDeriveCenterIdx( eCUMode, uiPUIdx, uiPartIdxCenter );
3770    bExistMV = uiLCUIdx >= 0 && xGetColMVP( REF_PIC_LIST_0, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx );
3771    if( bExistMV == false )
3772    {
3773      bExistMV = xGetColMVP( REF_PIC_LIST_0, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx );
3774    }
3775    if( bExistMV )
3776    {
3777      UInt uiArrayAddr = iCount;
3778      abCandIsInter[uiArrayAddr] = true;
3779      pcMvFieldNeighbours[uiArrayAddr << 1].setMvField( cColMv, iRefIdx );
3780
3781      if ( getSlice()->isInterB() )
3782      {       
3783        iRefIdx = iRefIdxSkip[1];
3784        bExistMV = uiLCUIdx >= 0 && xGetColMVP( REF_PIC_LIST_1, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx);
3785        if( bExistMV == false )
3786        {
3787          bExistMV = xGetColMVP( REF_PIC_LIST_1, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx );
3788        }
3789        if( bExistMV )
3790        {
3791          pcMvFieldNeighbours[ ( uiArrayAddr << 1 ) + 1 ].setMvField( cColMv, iRefIdx );
3792          puhInterDirNeighbours[uiArrayAddr] = 3;
3793        }
3794        else
3795        {
3796          puhInterDirNeighbours[uiArrayAddr] = 1;
3797        }
3798      }
3799      else
3800      {
3801        puhInterDirNeighbours[uiArrayAddr] = 1;
3802      }
3803#if SIMP_MRG_PRUN
3804      if ( mrgCandIdx == iCount )
3805      {
3806        return;
3807      }
3808      iCount++;
3809#endif
3810    }
3811    uiIdx++;
3812
3813  }
3814
3815#if SIMP_MRG_PRUN
3816  UInt uiArrayAddr = iCount;
3817#else
3818#if HHI_INTER_VIEW_MOTION_PRED
3819  for( UInt uiOuter = 0; uiOuter < MRG_MAX_NUM_CANDS_MEM; uiOuter++ )
3820#else
3821  for( UInt uiOuter = 0; uiOuter < MRG_MAX_NUM_CANDS; uiOuter++ )
3822#endif
3823  {
3824    if( abCandIsInter[ uiOuter ] )
3825    {
3826#if HHI_INTER_VIEW_MOTION_PRED
3827      for( UInt uiIter = uiOuter + 1; uiIter < MRG_MAX_NUM_CANDS_MEM; uiIter++ )
3828#else
3829      for( UInt uiIter = uiOuter + 1; uiIter < MRG_MAX_NUM_CANDS; uiIter++ )
3830#endif
3831      {
3832        UInt uiMvFieldNeighIdxCurr = uiOuter << 1;
3833        UInt uiMvFieldNeighIdxComp = uiIter << 1;
3834        if( getSlice()->isInterB() )
3835        {
3836          if( puhInterDirNeighbours[ uiOuter ] == 3 )
3837          {
3838            if( pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getRefIdx() && pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getRefIdx() &&
3839              pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getMv() && pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getMv() &&
3840              puhInterDirNeighbours[ uiOuter ] == puhInterDirNeighbours[ uiIter ] )
3841            {
3842              abCandIsInter[ uiIter ] = false;
3843            }
3844          }
3845          else if( puhInterDirNeighbours[ uiOuter ] == 2 )
3846          {
3847            if( pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getRefIdx() &&
3848              pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getMv() &&
3849              puhInterDirNeighbours[ uiOuter ] == puhInterDirNeighbours[ uiIter ] )
3850            {
3851              abCandIsInter[ uiIter ] = false;
3852            }
3853          }
3854          else
3855          {
3856            if( pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getRefIdx() &&
3857              pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getMv() &&
3858              puhInterDirNeighbours[ uiOuter ] == puhInterDirNeighbours[ uiIter ] )
3859            {
3860              abCandIsInter[ uiIter ] = false;
3861            }
3862          }
3863        }
3864        else
3865        {
3866          if( pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getRefIdx() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getRefIdx() && 
3867              pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getMv() == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getMv() )
3868          {
3869            assert( puhInterDirNeighbours[ uiOuter ] == puhInterDirNeighbours[ uiIter ] );
3870            abCandIsInter[ uiIter ] = false;
3871          }
3872        }
3873      }
3874    }
3875  }
3876
3877#if HHI_INTER_VIEW_MOTION_PRED
3878  bool abCandIsInterFlag[MRG_MAX_NUM_CANDS_MEM];
3879  for (int i=0; i<MRG_MAX_NUM_CANDS_MEM; i++)
3880#else
3881  bool abCandIsInterFlag[MRG_MAX_NUM_CANDS];
3882  for (int i=0; i<MRG_MAX_NUM_CANDS; i++)
3883#endif
3884  {
3885    abCandIsInterFlag[i] = abCandIsInter[ i ];
3886    abCandIsInter[ i ] = false;
3887  }
3888
3889  UInt uiArrayAddr = 0;
3890   
3891#if HHI_INTER_VIEW_MOTION_PRED
3892  for (int i=0; i<MRG_MAX_NUM_CANDS_MEM; i++)
3893#else
3894  for (int i=0; i<MRG_MAX_NUM_CANDS; i++)
3895#endif
3896  {
3897    if (abCandIsInterFlag[i])
3898    {
3899      abCandIsInter[uiArrayAddr] = true;
3900      puhInterDirNeighbours[uiArrayAddr] = puhInterDirNeighbours[i];
3901      pcMvFieldNeighbours[uiArrayAddr<<1].setMvField(pcMvFieldNeighbours[i<<1].getMv(), pcMvFieldNeighbours[i<<1].getRefIdx());
3902      pcMvFieldNeighbours[(uiArrayAddr<<1)+1].setMvField(pcMvFieldNeighbours[(i<<1)+1].getMv(), pcMvFieldNeighbours[(i<<1)+1].getRefIdx());
3903      ++uiArrayAddr;
3904    }
3905  }
3906
3907#if HHI_INTER_VIEW_MOTION_PRED
3908  for (int i=uiArrayAddr; i<MRG_MAX_NUM_CANDS_MEM; i++)
3909#else
3910  for (int i=uiArrayAddr; i<MRG_MAX_NUM_CANDS; i++)
3911#endif
3912  {
3913    puhInterDirNeighbours[i] = (getSlice()->isInterB()) ? 3 : 1;
3914    abCandIsInter[i] = false;
3915    TComMv tmpMv;
3916    tmpMv.set(0,0);
3917    pcMvFieldNeighbours[i<<1].setMvField(tmpMv, 0);
3918    if ( getSlice()->isInterB() )
3919    {
3920      pcMvFieldNeighbours[(i<<1)+1].setMvField(tmpMv, 0);
3921    }
3922  }
3923#endif
3924  UInt uiCutoff = uiArrayAddr;
3925   
3926  if ( getSlice()->isInterB() )
3927  {
3928#if HHI_INTER_VIEW_MOTION_PRED
3929    Int iCombinedCount = 0;
3930    Int iMaxCombCount  = ( extraMergeCand ?  6 :  5 );
3931    Int iMaxIdx        = ( extraMergeCand ? 20 : 12 );
3932    UInt uiPriorityList0[20] = {0 , 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3,    0, 4, 1, 4, 2, 4, 3, 4 };
3933    UInt uiPriorityList1[20] = {1 , 0, 2, 0, 2, 1, 3, 0, 3, 1, 3, 2,    4, 0, 4, 1, 4, 2, 4, 3 };
3934
3935    for (Int idx=0; idx<uiCutoff*(uiCutoff-1) && uiArrayAddr!=MRG_MAX_NUM_CANDS_MEM && iCombinedCount<iMaxCombCount && idx < iMaxIdx; idx++)
3936#else
3937    Int iCombinedCount = 0;
3938    UInt uiPriorityList0[12] = {0 , 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3};
3939    UInt uiPriorityList1[12] = {1 , 0, 2, 0, 2, 1, 3, 0, 3, 1, 3, 2};
3940
3941    for (Int idx=0; idx<uiCutoff*(uiCutoff-1) && uiArrayAddr!=MRG_MAX_NUM_CANDS && iCombinedCount<5 && idx < 12; idx++)
3942#endif
3943    {
3944      Int i = uiPriorityList0[idx]; Int j = uiPriorityList1[idx];
3945      if (abCandIsInter[i] && abCandIsInter[j]&& (puhInterDirNeighbours[i]&0x1)&&(puhInterDirNeighbours[j]&0x2))
3946      {
3947        abCandIsInter[uiArrayAddr] = true;
3948        puhInterDirNeighbours[uiArrayAddr] = 3;
3949
3950        // get Mv from cand[i] and cand[j]
3951        pcMvFieldNeighbours[uiArrayAddr << 1].setMvField(pcMvFieldNeighbours[i<<1].getMv(), pcMvFieldNeighbours[i<<1].getRefIdx());
3952        pcMvFieldNeighbours[( uiArrayAddr << 1 ) + 1].setMvField(pcMvFieldNeighbours[(j<<1)+1].getMv(), pcMvFieldNeighbours[(j<<1)+1].getRefIdx());
3953
3954        Int iRefPOCL0    = m_pcSlice->getRefPOC   ( REF_PIC_LIST_0, pcMvFieldNeighbours[(uiArrayAddr<<1)].getRefIdx() );
3955        Int iRefViewIdL0 = m_pcSlice->getRefViewId( REF_PIC_LIST_0, pcMvFieldNeighbours[(uiArrayAddr<<1)].getRefIdx() );
3956        Int iRefPOCL1    = m_pcSlice->getRefPOC   ( REF_PIC_LIST_1, pcMvFieldNeighbours[(uiArrayAddr<<1)+1].getRefIdx() );
3957        Int iRefViewIdL1 = m_pcSlice->getRefViewId( REF_PIC_LIST_1, pcMvFieldNeighbours[(uiArrayAddr<<1)+1].getRefIdx() );
3958        if(iRefPOCL0 == iRefPOCL1 && iRefViewIdL0 == iRefViewIdL1 && pcMvFieldNeighbours[(uiArrayAddr<<1)].getMv() == pcMvFieldNeighbours[(uiArrayAddr<<1)+1].getMv())
3959        {
3960          abCandIsInter[uiArrayAddr] = false;
3961        }
3962        else
3963        {
3964          uiArrayAddr++;
3965          iCombinedCount++;
3966        }
3967      }
3968    }
3969#if !REMOVE_NON_SCALED 
3970    Int iScaledCount = 0;
3971#if HHI_INTER_VIEW_MOTION_PRED
3972    for (int i=0; i<uiCutoff && uiArrayAddr!=MRG_MAX_NUM_CANDS_MEM && iScaledCount<1; i++)
3973#else
3974    for (int i=0; i<uiCutoff && uiArrayAddr!=MRG_MAX_NUM_CANDS && iScaledCount<1; i++)
3975#endif
3976    {
3977#if HHI_INTER_VIEW_MOTION_PRED
3978      for (int j=0; j<2 && uiArrayAddr!=MRG_MAX_NUM_CANDS_MEM && iScaledCount<1; j++)
3979#else
3980      for (int j=0; j<2 && uiArrayAddr!=MRG_MAX_NUM_CANDS && iScaledCount<1; j++)
3981#endif
3982      {
3983        if (abCandIsInter[i] && pcMvFieldNeighbours[(i<<1)+j].getRefIdx()>=0 && pcMvFieldNeighbours[(i<<1)+j].getRefIdx() < m_pcSlice->getNumRefIdx((j==0)?REF_PIC_LIST_1:REF_PIC_LIST_0))
3984        {
3985          Int iCurrPOC = m_pcSlice->getPOC();
3986          Int iCurrRefPOC1 = m_pcSlice->getRefPOC( (j==0)?REF_PIC_LIST_1:REF_PIC_LIST_0, pcMvFieldNeighbours[(i<<1)+j].getRefIdx() );
3987          Int iCurrRefPOC2 = m_pcSlice->getRefPOC( (j==0)?REF_PIC_LIST_0:REF_PIC_LIST_1, pcMvFieldNeighbours[(i<<1)+j].getRefIdx() );
3988
3989          if (iCurrRefPOC1 != iCurrRefPOC2 && abs(iCurrPOC-iCurrRefPOC1) == abs(iCurrPOC-iCurrRefPOC2))
3990          {
3991            abCandIsInter[uiArrayAddr] = true;
3992            puhInterDirNeighbours[uiArrayAddr] = 3;
3993           
3994            TComMv cMvPred = pcMvFieldNeighbours[(i<<1)+j].getMv();
3995            TComMv rcMv;
3996
3997            rcMv.set(-1*cMvPred.getHor(), -1*cMvPred.getVer());
3998
3999            if (j==0)
4000            {
4001              pcMvFieldNeighbours[uiArrayAddr << 1].setMvField(pcMvFieldNeighbours[(i<<1)].getMv(), pcMvFieldNeighbours[(i<<1)].getRefIdx());
4002              pcMvFieldNeighbours[( uiArrayAddr << 1 ) + 1].setMvField(rcMv, pcMvFieldNeighbours[(i<<1)].getRefIdx());
4003            }
4004            else
4005            {
4006              pcMvFieldNeighbours[uiArrayAddr << 1].setMvField(rcMv, pcMvFieldNeighbours[(i<<1)+1].getRefIdx());
4007              pcMvFieldNeighbours[( uiArrayAddr << 1 ) + 1].setMvField(pcMvFieldNeighbours[(i<<1)+1].getMv(), pcMvFieldNeighbours[(i<<1)+1].getRefIdx());
4008            }
4009
4010            uiArrayAddr++;
4011            iScaledCount++;
4012          }
4013        }
4014      }
4015    }
4016#endif
4017  }
4018
4019  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);
4020#if HHI_INTER_VIEW_MOTION_PRED
4021  for (int r=0; r<iNumRefIdx && uiArrayAddr!=MRG_MAX_NUM_CANDS_MEM; r++)
4022#else
4023  for (int r=0; r<iNumRefIdx && uiArrayAddr!=MRG_MAX_NUM_CANDS; r++)
4024#endif
4025  {
4026    abCandIsInter[uiArrayAddr] = true;
4027    puhInterDirNeighbours[uiArrayAddr] = 1;
4028    pcMvFieldNeighbours[uiArrayAddr << 1].setMvField( TComMv(0, 0), r);
4029
4030    if ( getSlice()->isInterB() )
4031    {
4032      puhInterDirNeighbours[uiArrayAddr] = 3;
4033      pcMvFieldNeighbours[(uiArrayAddr << 1) + 1].setMvField(TComMv(0, 0), r);
4034    }
4035    uiArrayAddr++;
4036  }
4037#if HHI_INTER_VIEW_MOTION_PRED
4038  if (uiArrayAddr > MRG_MAX_NUM_CANDS_SIGNALED + extraMergeCand )
4039  {
4040    uiArrayAddr = MRG_MAX_NUM_CANDS_SIGNALED + extraMergeCand;
4041  }
4042#else
4043  if (uiArrayAddr > MRG_MAX_NUM_CANDS_SIGNALED)
4044  {
4045    uiArrayAddr = MRG_MAX_NUM_CANDS_SIGNALED;
4046  }
4047#endif
4048  numValidMergeCand = uiArrayAddr;
4049}
4050
4051/** Check the duplicated candidate in the list
4052 * \param pcMvFieldNeighbours
4053 * \param puhInterDirNeighbours
4054 * \param pbCandIsInter
4055 * \param ruiArrayAddr
4056 * \returns Void
4057 */
4058Void TComDataCU::xCheckDuplicateCand(TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, bool* pbCandIsInter, UInt& ruiArrayAddr)
4059{
4060  if (getSlice()->isInterB())
4061  {
4062    UInt uiMvFieldNeighIdxCurr = ruiArrayAddr << 1;
4063    Int iRefIdxL0 = pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getRefIdx();
4064    Int iRefIdxL1 = pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getRefIdx();
4065    TComMv MvL0 = pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getMv();
4066    TComMv MvL1 = pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr + 1 ].getMv();
4067
4068    for (int k=0; k<ruiArrayAddr; k++)
4069    {
4070      UInt uiMvFieldNeighIdxComp = k << 1;
4071      if (iRefIdxL0 == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getRefIdx() && 
4072          iRefIdxL1 == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getRefIdx() &&
4073          MvL0 == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getMv() && 
4074          MvL1 == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp + 1 ].getMv() &&
4075          puhInterDirNeighbours[ ruiArrayAddr ] == puhInterDirNeighbours[ k ] )
4076      {
4077        pbCandIsInter[ruiArrayAddr] = false;
4078        break;
4079      }
4080    }
4081  }
4082  else
4083  {
4084    UInt uiMvFieldNeighIdxCurr = ruiArrayAddr << 1;
4085    Int iRefIdxL0 = pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getRefIdx();
4086    TComMv MvL0 = pcMvFieldNeighbours[ uiMvFieldNeighIdxCurr ].getMv();
4087
4088    for (int k=0; k<ruiArrayAddr; k++)
4089    {
4090      UInt uiMvFieldNeighIdxComp = k << 1;
4091      if (iRefIdxL0 == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getRefIdx() && 
4092          MvL0 == pcMvFieldNeighbours[ uiMvFieldNeighIdxComp ].getMv() && 
4093          puhInterDirNeighbours[ ruiArrayAddr ] == puhInterDirNeighbours[ k ] )
4094      {
4095        pbCandIsInter[ruiArrayAddr] = false;
4096        break;
4097      }
4098    }
4099  }
4100
4101  if (pbCandIsInter[ruiArrayAddr])
4102  {
4103    ++ruiArrayAddr;
4104  }
4105}
4106
4107Void TComDataCU::xCheckCornerCand( TComDataCU* pcCorner, UInt uiCornerPUIdx, UInt uiIter, Bool& rbValidCand )
4108{
4109  if( uiIter == 0 )
4110  {
4111    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx ) )
4112    {
4113      rbValidCand = true;
4114      if( getSlice()->isInterB() )
4115      {
4116        if ( pcCorner->getInterDir( uiCornerPUIdx ) == 1 )
4117        {
4118          if( pcCorner->getCUMvField(REF_PIC_LIST_0)->getRefIdx( uiCornerPUIdx ) != 0 )
4119          {
4120            rbValidCand = false;
4121          }
4122        }
4123        else if ( pcCorner->getInterDir( uiCornerPUIdx ) == 2 )
4124        {
4125          if( pcCorner->getCUMvField(REF_PIC_LIST_1)->getRefIdx( uiCornerPUIdx ) != 0 )
4126          {
4127            rbValidCand = false;
4128          }
4129        }
4130        else
4131        {
4132          if( pcCorner->getCUMvField(REF_PIC_LIST_0)->getRefIdx( uiCornerPUIdx ) != 0 || pcCorner->getCUMvField(REF_PIC_LIST_1)->getRefIdx( uiCornerPUIdx ) != 0 )
4133          {
4134            rbValidCand = false;
4135          }
4136        }
4137      }
4138      else if( pcCorner->getCUMvField(REF_PIC_LIST_0)->getRefIdx( uiCornerPUIdx ) != 0 )
4139      {
4140        rbValidCand = false;
4141      }
4142    }
4143  }
4144  else
4145  {
4146    if( pcCorner && !pcCorner->isIntra( uiCornerPUIdx ) )
4147    {
4148      rbValidCand = true;
4149      if( getSlice()->isInterB() )
4150      {
4151        if ( pcCorner->getInterDir( uiCornerPUIdx ) == 1 )
4152        {
4153          if( pcCorner->getCUMvField(REF_PIC_LIST_0)->getRefIdx( uiCornerPUIdx ) < 0 )
4154          {
4155            rbValidCand = false;
4156          }
4157        }
4158        else if ( pcCorner->getInterDir( uiCornerPUIdx ) == 2 )
4159        {
4160          if( pcCorner->getCUMvField(REF_PIC_LIST_1)->getRefIdx( uiCornerPUIdx ) < 0 )
4161          {
4162            rbValidCand = false;
4163          }
4164        }
4165        else
4166        {
4167          if( pcCorner->getCUMvField(REF_PIC_LIST_0)->getRefIdx( uiCornerPUIdx ) < 0 || pcCorner->getCUMvField(REF_PIC_LIST_1)->getRefIdx( uiCornerPUIdx ) < 0 )
4168          {
4169            rbValidCand = false;
4170          }
4171        }
4172      }
4173      else if( pcCorner->getCUMvField(REF_PIC_LIST_0)->getRefIdx( uiCornerPUIdx ) < 0 )
4174      {
4175        rbValidCand = false;
4176      }
4177    }
4178  }
4179}
4180#if PARALLEL_MERGE
4181/** Check whether the current PU and a spatial neighboring PU are in a same ME region.
4182 * \param xN, xN   location of the upper-left corner pixel of a neighboring PU
4183 * \param xP, yP   location of the upper-left corner pixel of the current PU
4184 * \returns Bool
4185 */
4186Bool TComDataCU::isDiffMER(Int xN, Int yN, Int xP, Int yP)
4187{
4188
4189  UInt plevel = this->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() + 2;
4190  if ((xN>>plevel)!= (xP>>plevel))
4191  {
4192    return true;
4193  }
4194  if ((yN>>plevel)!= (yP>>plevel))
4195  {
4196    return true;
4197  }
4198  return false;
4199}
4200/** calculate the location of upper-left corner pixel and size of the current PU.
4201 * \param partIdx  PU index within a CU
4202 * \param xP, yP   location of the upper-left corner pixel of the current PU
4203 * \param PSW, nPSH    size of the curren PU
4204 * \returns Void
4205 */
4206Void TComDataCU::getPartPosition( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH)
4207{
4208  UInt col = m_uiCUPelX;
4209  UInt row = m_uiCUPelY;
4210
4211  switch ( m_pePartSize[0] )
4212  {
4213  case SIZE_2NxN:
4214    nPSW = getWidth(0);     
4215    nPSH = getHeight(0) >> 1; 
4216    xP   = col;
4217    yP   = (partIdx ==0)? row: row + nPSH;
4218    break;
4219  case SIZE_Nx2N:
4220    nPSW = getWidth(0) >> 1; 
4221    nPSH = getHeight(0);     
4222    xP   = (partIdx ==0)? col: col + nPSW;
4223    yP   = row;
4224    break;
4225  case SIZE_NxN:
4226    nPSW = getWidth(0) >> 1; 
4227    nPSH = getHeight(0) >> 1; 
4228    xP   = col + (partIdx&0x1)*nPSW;
4229    yP   = row + (partIdx>>1)*nPSH;
4230    break;
4231  case SIZE_2NxnU:
4232    nPSW = getWidth(0);
4233    nPSH = ( partIdx == 0 ) ?  getHeight(0) >> 2 : ( getHeight(0) >> 2 ) + ( getHeight(0) >> 1 );
4234    xP   = col;
4235    yP   = (partIdx ==0)? row: row + getHeight(0) - nPSH;
4236
4237    break;
4238  case SIZE_2NxnD:
4239    nPSW = getWidth(0);
4240    nPSH = ( partIdx == 0 ) ?  ( getHeight(0) >> 2 ) + ( getHeight(0) >> 1 ) : getHeight(0) >> 2;
4241    xP   = col;
4242    yP   = (partIdx ==0)? row: row + getHeight(0) - nPSH;
4243    break;
4244  case SIZE_nLx2N:
4245    nPSW = ( partIdx == 0 ) ? getWidth(0) >> 2 : ( getWidth(0) >> 2 ) + ( getWidth(0) >> 1 );
4246    nPSH = getHeight(0);
4247    xP   = (partIdx ==0)? col: col + getWidth(0) - nPSW;
4248    yP   = row;
4249    break;
4250  case SIZE_nRx2N:
4251    nPSW = ( partIdx == 0 ) ? ( getWidth(0) >> 2 ) + ( getWidth(0) >> 1 ) : getWidth(0) >> 2;
4252    nPSH = getHeight(0);
4253    xP   = (partIdx ==0)? col: col + getWidth(0) - nPSW;
4254    yP   = row;
4255    break;
4256  default:
4257    assert ( m_pePartSize[0] == SIZE_2Nx2N );
4258    nPSW = getWidth(0);     
4259    nPSH = getHeight(0);     
4260    xP   = col ;
4261    yP   = row ;
4262
4263    break;
4264  }
4265}
4266
4267#endif
4268AMVP_MODE TComDataCU::getAMVPMode(UInt uiIdx)
4269{
4270  return m_pcSlice->getSPS()->getAMVPMode(m_puhDepth[uiIdx]);
4271}
4272
4273/** Constructs a list of candidates for AMVP
4274 * \param uiPartIdx
4275 * \param uiPartAddr
4276 * \param eRefPicList
4277 * \param iRefIdx
4278 * \param pInfo
4279 */
4280Void TComDataCU::fillMvpCand ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo )
4281{
4282  PartSize eCUMode = getPartitionSize( 0 );
4283 
4284  TComMv cMvPred;
4285  Bool bAddedSmvp = false;
4286
4287  pInfo->iN = 0; 
4288  if (iRefIdx < 0)
4289  {
4290    return;
4291  }
4292 
4293#if HHI_INTER_VIEW_MOTION_PRED
4294#if ( PDM_AMVP_POS == 0 )
4295  // get inter-view mv predictor (at position 0)
4296  TComMv  cPdmMvPred;
4297  if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
4298  {
4299    clipMv( cPdmMvPred );
4300    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
4301  }
4302#endif
4303#endif
4304
4305  //-- Get Spatial MV
4306  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
4307  UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth();
4308  Bool bAdded = false;
4309 
4310  deriveLeftRightTopIdx( eCUMode, uiPartIdx, uiPartIdxLT, uiPartIdxRT );
4311  deriveLeftBottomIdx( eCUMode, uiPartIdx, uiPartIdxLB );
4312 
4313  TComDataCU* tmpCU = NULL;
4314  UInt idx;
4315#if MVP_AT_ENTROPYSLICE_BOUNDARY
4316  tmpCU = getPUBelowLeft(idx, uiPartIdxLB, true, false);
4317#else
4318  tmpCU = getPUBelowLeft(idx, uiPartIdxLB);
4319#endif
4320  bAddedSmvp = (tmpCU != NULL) && (tmpCU->getPredictionMode(idx) != MODE_INTRA);
4321
4322  if (!bAddedSmvp)
4323  {
4324#if MVP_AT_ENTROPYSLICE_BOUNDARY
4325    tmpCU = getPULeft(idx, uiPartIdxLB, true, false);
4326#else
4327    tmpCU = getPULeft(idx, uiPartIdxLB);
4328#endif
4329    bAddedSmvp = (tmpCU != NULL) && (tmpCU->getPredictionMode(idx) != MODE_INTRA);
4330  }
4331
4332  // Left predictor search
4333  bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_BELOW_LEFT);
4334  if (!bAdded) 
4335  {
4336    bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_LEFT );
4337  }
4338 
4339  if(!bAdded)
4340  {
4341    bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_BELOW_LEFT);
4342    if (!bAdded) 
4343    {
4344      bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_LEFT );
4345    }
4346  }
4347
4348#if HHI_INTER_VIEW_MOTION_PRED
4349#if ( PDM_AMVP_POS == 1 )
4350  // get inter-view mv predictor (at position 1)
4351  TComMv  cPdmMvPred;
4352  if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
4353  {
4354    clipMv( cPdmMvPred );
4355    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
4356  }
4357#endif
4358#endif
4359
4360  // Above predictor search
4361  bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE_RIGHT);
4362
4363  if (!bAdded) 
4364  {
4365    bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE);
4366  }
4367
4368  if(!bAdded)
4369  {
4370    bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
4371  }
4372  bAdded = bAddedSmvp;
4373  if (pInfo->iN==2) bAdded = true;
4374
4375  if(!bAdded)
4376  {
4377    bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE_RIGHT);
4378    if (!bAdded) 
4379    {
4380      bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE);
4381    }
4382
4383    if(!bAdded)
4384    {
4385      bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
4386    }
4387  }
4388 
4389  if (getAMVPMode(uiPartAddr) == AM_NONE)  //Should be optimized later for special cases
4390  {
4391    assert(pInfo->iN > 0);
4392    pInfo->iN = 1;
4393    return;
4394  }
4395
4396#if HHI_INTER_VIEW_MOTION_PRED
4397#if ( PDM_AMVP_POS == 2 )
4398  // get inter-view mv predictor (at position 2)
4399  TComMv  cPdmMvPred;
4400  if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
4401  {
4402    clipMv( cPdmMvPred );
4403    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
4404  } 
4405#endif
4406#endif
4407
4408#if AMVP_PRUNING_SIMPLIFICATION
4409  if ( pInfo->iN == 2 )
4410  {
4411    if ( pInfo->m_acMvCand[ 0 ] == pInfo->m_acMvCand[ 1 ] )
4412    {
4413      pInfo->iN = 1;
4414    }
4415  }
4416#endif
4417
4418  if ( getSlice()->getPPS()->getEnableTMVPFlag() )
4419  {
4420    // Get Temporal Motion Predictor
4421    int iRefIdx_Col = iRefIdx;
4422    TComMv cColMv;
4423    UInt uiPartIdxRB;
4424    UInt uiAbsPartIdx; 
4425    UInt uiAbsPartAddr;
4426    int uiLCUIdx = getAddr();
4427
4428    deriveRightBottomIdx( eCUMode, uiPartIdx, uiPartIdxRB );
4429    uiAbsPartAddr = m_uiAbsIdxInLCU + uiPartAddr;
4430
4431    //----  co-located RightBottom Temporal Predictor (H) ---//
4432    uiAbsPartIdx = g_auiZscanToRaster[uiPartIdxRB];
4433    if ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdx] + m_pcPic->getMinCUWidth() ) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )  // image boundary check
4434    {
4435      uiLCUIdx = -1;
4436    }
4437    else if ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdx] + m_pcPic->getMinCUHeight() ) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
4438    {
4439      uiLCUIdx = -1;
4440    }
4441    else
4442    {
4443      if ( ( uiAbsPartIdx % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 ) &&           // is not at the last column of LCU
4444        ( uiAbsPartIdx / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) ) // is not at the last row    of LCU
4445      {
4446        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdx + uiNumPartInCUWidth + 1 ];
4447        uiLCUIdx = getAddr();
4448      }
4449      else if ( uiAbsPartIdx % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 )           // is not at the last column of LCU But is last row of LCU
4450      {
4451        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdx + uiNumPartInCUWidth + 1) % m_pcPic->getNumPartInCU() ];
4452        uiLCUIdx      = -1 ; 
4453      }
4454      else if ( uiAbsPartIdx / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) // is not at the last row of LCU But is last column of LCU
4455      {
4456        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdx + 1 ];
4457        uiLCUIdx = getAddr() + 1;
4458      }
4459      else //is the right bottom corner of LCU                       
4460      {
4461        uiAbsPartAddr = 0;
4462        uiLCUIdx      = -1 ; 
4463      }
4464    }
4465    if ( uiLCUIdx >= 0 && xGetColMVP( eRefPicList, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx_Col ) )
4466    {
4467      pInfo->m_acMvCand[pInfo->iN++] = cColMv;
4468    }
4469    else 
4470    {
4471      UInt uiPartIdxCenter;
4472      UInt uiCurLCUIdx = getAddr();
4473      xDeriveCenterIdx( eCUMode, uiPartIdx, uiPartIdxCenter );
4474      if (xGetColMVP( eRefPicList, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx_Col ))
4475      {
4476        pInfo->m_acMvCand[pInfo->iN++] = cColMv;
4477      }
4478    }
4479    //----  co-located RightBottom Temporal Predictor  ---//
4480  }
4481
4482#if HHI_INTER_VIEW_MOTION_PRED
4483#if ( PDM_AMVP_POS == 3 )
4484  // get inter-view mv predictor (at position 3)
4485  TComMv  cPdmMvPred;
4486  if( getPdmMvPred( uiPartIdx, eRefPicList, iRefIdx, cPdmMvPred ) )
4487  {
4488    clipMv( cPdmMvPred );
4489    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
4490  }
4491#endif
4492#endif
4493
4494#if !AMVP_PRUNING_SIMPLIFICATION
4495  // Check No MV Candidate
4496  xUniqueMVPCand( pInfo );
4497#endif
4498
4499#if HHI_INTER_VIEW_MOTION_PRED
4500  const Int iNumAMVPCands = AMVP_MAX_NUM_CANDS + ( getSlice()->getSPS()->getMultiviewMvPredMode() ? 1 : 0 );
4501  if (pInfo->iN > iNumAMVPCands)
4502  {
4503    pInfo->iN = iNumAMVPCands;
4504  }
4505  else if (pInfo->iN < iNumAMVPCands)
4506#else
4507  if (pInfo->iN > AMVP_MAX_NUM_CANDS)
4508  {
4509    pInfo->iN = AMVP_MAX_NUM_CANDS;
4510  }
4511  else if (pInfo->iN < AMVP_MAX_NUM_CANDS)
4512#endif
4513  {
4514#if !AMVP_ZERO_CHECKING_REMOVAL
4515    int j;
4516    for (j=0; j<pInfo->iN; j++)
4517    {
4518      if (pInfo->m_acMvCand[j].getHor() == 0 && pInfo->m_acMvCand[j].getVer() == 0)
4519      {
4520        break;
4521      }
4522    }
4523    if (j == pInfo->iN)
4524    {
4525#endif
4526      pInfo->m_acMvCand[pInfo->iN].set(0,0);
4527      pInfo->iN++;
4528#if !AMVP_ZERO_CHECKING_REMOVAL
4529    }
4530#endif
4531  }
4532  return ;
4533}
4534
4535Void TComDataCU::clipMv    (TComMv&  rcMv)
4536{
4537  Int  iMvShift = 2;
4538#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
4539  if( getSlice()->getIsDepth() )
4540    iMvShift = 0;
4541#endif
4542  Int iOffset = 8;
4543  Int iHorMax = ( m_pcSlice->getSPS()->getPicWidthInLumaSamples() + iOffset - m_uiCUPelX - 1 ) << iMvShift;
4544  Int iHorMin = (       -(Int)g_uiMaxCUWidth - iOffset - (Int)m_uiCUPelX + 1 ) << iMvShift;
4545 
4546  Int iVerMax = ( m_pcSlice->getSPS()->getPicHeightInLumaSamples() + iOffset - m_uiCUPelY - 1 ) << iMvShift;
4547  Int iVerMin = (       -(Int)g_uiMaxCUHeight - iOffset - (Int)m_uiCUPelY + 1 ) << iMvShift;
4548 
4549  rcMv.setHor( min (iHorMax, max (iHorMin, rcMv.getHor())) );
4550  rcMv.setVer( min (iVerMax, max (iVerMin, rcMv.getVer())) );
4551}
4552
4553
4554Void TComDataCU::convertTransIdx( UInt uiAbsPartIdx, UInt uiTrIdx, UInt& ruiLumaTrMode, UInt& ruiChromaTrMode )
4555{
4556  ruiLumaTrMode   = uiTrIdx;
4557  ruiChromaTrMode = uiTrIdx;
4558  return;
4559}
4560
4561UInt TComDataCU::getIntraSizeIdx(UInt uiAbsPartIdx)
4562{
4563  UInt uiShift = ( (m_puhTrIdx[uiAbsPartIdx]==0) && (m_pePartSize[uiAbsPartIdx]==SIZE_NxN) ) ? m_puhTrIdx[uiAbsPartIdx]+1 : m_puhTrIdx[uiAbsPartIdx];
4564  uiShift = ( m_pePartSize[uiAbsPartIdx]==SIZE_NxN ? 1 : 0 );
4565 
4566  UChar uiWidth = m_puhWidth[uiAbsPartIdx]>>uiShift;
4567  UInt  uiCnt = 0;
4568  while( uiWidth )
4569  {
4570    uiCnt++;
4571    uiWidth>>=1;
4572  }
4573  uiCnt-=2;
4574  return uiCnt > 6 ? 6 : uiCnt;
4575}
4576
4577Void TComDataCU::clearCbf( UInt uiIdx, TextType eType, UInt uiNumParts )
4578{
4579  ::memset( &m_puhCbf[g_aucConvertTxtTypeToIdx[eType]][uiIdx], 0, sizeof(UChar)*uiNumParts);
4580}
4581
4582/** Set a I_PCM flag for all sub-partitions of a partition.
4583 * \param bIpcmFlag I_PCM flag
4584 * \param uiAbsPartIdx patition index
4585 * \param uiDepth CU depth
4586 * \returns Void
4587 */
4588Void TComDataCU::setIPCMFlagSubParts  (Bool bIpcmFlag, UInt uiAbsPartIdx, UInt uiDepth)
4589{
4590  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
4591
4592  memset(m_pbIPCMFlag + uiAbsPartIdx, bIpcmFlag, sizeof(Bool)*uiCurrPartNumb );
4593}
4594
4595/** Test whether the current block is skipped
4596 * \param uiPartIdx Block index
4597 * \returns Flag indicating whether the block is skipped
4598 */
4599Bool TComDataCU::isSkipped( UInt uiPartIdx )
4600{
4601  if ( m_pcSlice->isIntra () )
4602  {
4603    return false;
4604  }
4605  return ( m_pePredMode[ uiPartIdx ] == MODE_SKIP && getMergeFlag( uiPartIdx ) && !getQtRootCbf( uiPartIdx ) );
4606}
4607
4608// ====================================================================================================================
4609// Protected member functions
4610// ====================================================================================================================
4611
4612Bool TComDataCU::xAddMVPCand( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir )
4613{
4614  TComDataCU* pcTmpCU = NULL;
4615  UInt uiIdx;
4616  switch( eDir )
4617  {
4618    case MD_LEFT:
4619    {
4620#if MVP_AT_ENTROPYSLICE_BOUNDARY
4621      pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx, true, false);
4622#else
4623      pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx);
4624#endif
4625      break;
4626    }
4627    case MD_ABOVE:
4628    {
4629#if MVP_AT_ENTROPYSLICE_BOUNDARY
4630      pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx, true, false, true);
4631#else
4632      pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx, true, true, true);
4633#endif
4634      break;
4635    }
4636    case MD_ABOVE_RIGHT:
4637    {
4638#if MVP_AT_ENTROPYSLICE_BOUNDARY
4639      pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx, true, false, true);
4640#else
4641      pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx, true, true, true);
4642#endif
4643      break;
4644    }
4645    case MD_BELOW_LEFT:
4646    {
4647#if MVP_AT_ENTROPYSLICE_BOUNDARY
4648      pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx, true, false);
4649#else
4650      pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx);
4651#endif
4652      break;
4653    }
4654    case MD_ABOVE_LEFT:
4655    {
4656#if MVP_AT_ENTROPYSLICE_BOUNDARY
4657      pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx, true, false, true);
4658#else
4659      pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx, true, true, true);
4660#endif
4661      break;
4662    }
4663    default:
4664    {
4665      break;
4666    }
4667  }
4668 
4669  if ( pcTmpCU != NULL && m_pcSlice->isEqualRef(eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx), iRefIdx) )
4670  {
4671    TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
4672   
4673    pInfo->m_acMvCand[ pInfo->iN++] = cMvPred;
4674    return true;
4675  }
4676
4677  if ( pcTmpCU == NULL ) 
4678  {
4679    return false;
4680  }
4681 
4682  RefPicList eRefPicList2nd = REF_PIC_LIST_0;
4683  if(       eRefPicList == REF_PIC_LIST_0 )
4684  {
4685    eRefPicList2nd = REF_PIC_LIST_1;
4686  }
4687  else if ( eRefPicList == REF_PIC_LIST_1)
4688  {
4689    eRefPicList2nd = REF_PIC_LIST_0;
4690  }
4691
4692
4693  Int iCurrRefPOC = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC();
4694  Int iNeibRefPOC;
4695
4696
4697  if( pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) >= 0 )
4698  {
4699    if( pcTmpCU->getSlice()->getRefViewId( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) ) != m_pcSlice->getRefViewId( eRefPicList, iRefIdx ) )
4700    {
4701      return false;
4702    }
4703    iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) );
4704    if( iNeibRefPOC == iCurrRefPOC ) // Same Reference Frame But Diff List//
4705    {
4706      TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
4707      pInfo->m_acMvCand[ pInfo->iN++] = cMvPred;
4708      return true;
4709    }
4710  }
4711  return false;
4712}
4713
4714#if !AMVP_PRUNING_SIMPLIFICATION
4715/**
4716 * Reduce list of motion vector predictors to a set of unique predictors
4717 * \param pInfo list of motion vector predictors
4718 */
4719Void TComDataCU::xUniqueMVPCand(AMVPInfo* pInfo)
4720{
4721  Int n = 1;
4722  if ( pInfo->iN == 0 )
4723  {
4724#if AMVP_ZERO_CHECKING_REMOVAL
4725    return;
4726#else
4727    // Add a zero candidate is none is available
4728    pInfo->m_acMvCand[ 0 ].setZero();
4729#endif
4730  }
4731  else
4732  {
4733    for (Int i = 1; i < pInfo->iN; i++)
4734    {
4735      Int j;
4736      for (j = n - 1; j >= 0; j--)
4737      {
4738        if ( pInfo->m_acMvCand[ i ] == pInfo->m_acMvCand[ j ] )
4739        {
4740          break;
4741        }
4742      }
4743      if ( j < 0 )
4744      {
4745        pInfo->m_acMvCand[ n++ ] = pInfo->m_acMvCand[ i ];
4746      }
4747    }
4748  }
4749  pInfo->iN = n;
4750}
4751#endif
4752
4753/**
4754 * \param pInfo
4755 * \param eRefPicList
4756 * \param iRefIdx
4757 * \param uiPartUnitIdx
4758 * \param eDir
4759 * \returns Bool
4760 */
4761Bool TComDataCU::xAddMVPCandOrder( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir )
4762{
4763  TComDataCU* pcTmpCU = NULL;
4764  UInt uiIdx;
4765  switch( eDir )
4766  {
4767  case MD_LEFT:
4768    {
4769#if MVP_AT_ENTROPYSLICE_BOUNDARY
4770      pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx, true, false);
4771#else
4772      pcTmpCU = getPULeft(uiIdx, uiPartUnitIdx);
4773#endif
4774      break;
4775    }
4776  case MD_ABOVE:
4777    {
4778#if MVP_AT_ENTROPYSLICE_BOUNDARY
4779      pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx, true, false, true);
4780#else
4781      pcTmpCU = getPUAbove(uiIdx, uiPartUnitIdx, true, true, true);
4782#endif
4783      break;
4784    }
4785  case MD_ABOVE_RIGHT:
4786    {
4787#if MVP_AT_ENTROPYSLICE_BOUNDARY
4788      pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx, true, false, true);
4789#else
4790      pcTmpCU = getPUAboveRight(uiIdx, uiPartUnitIdx, true, true, true);
4791#endif
4792      break;
4793    }
4794  case MD_BELOW_LEFT:
4795    {
4796#if MVP_AT_ENTROPYSLICE_BOUNDARY
4797      pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx, true, false);
4798#else
4799      pcTmpCU = getPUBelowLeft(uiIdx, uiPartUnitIdx);
4800#endif
4801      break;
4802    }
4803  case MD_ABOVE_LEFT:
4804    {
4805#if MVP_AT_ENTROPYSLICE_BOUNDARY
4806      pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx, true, false, true);
4807#else
4808      pcTmpCU = getPUAboveLeft(uiIdx, uiPartUnitIdx, true, true, true);
4809#endif
4810      break;
4811    }
4812  default:
4813    {
4814      break;
4815    }
4816  }
4817
4818  if ( pcTmpCU == NULL ) 
4819  {
4820    return false;
4821  }
4822 
4823  RefPicList eRefPicList2nd = REF_PIC_LIST_0;
4824  if(       eRefPicList == REF_PIC_LIST_0 )
4825  {
4826    eRefPicList2nd = REF_PIC_LIST_1;
4827  }
4828  else if ( eRefPicList == REF_PIC_LIST_1)
4829  {
4830    eRefPicList2nd = REF_PIC_LIST_0;
4831  }
4832
4833  Int iCurrPOC = m_pcSlice->getPOC();
4834  Int iCurrRefPOC = m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC();
4835  Int iNeibPOC = iCurrPOC;
4836  Int iNeibRefPOC;
4837
4838  //---------------  V1 (END) ------------------//
4839  if( pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0)
4840  {
4841    iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) );
4842    TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
4843    TComMv rcMv;
4844
4845    if( pcTmpCU->getSlice()->getRefViewId( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ) != m_pcSlice->getRefViewId( eRefPicList, iRefIdx ) )
4846    {
4847      return false;
4848    }
4849
4850    Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
4851    if ( iScale == 4096 )
4852    {
4853      rcMv = cMvPred;
4854    }
4855    else
4856    {
4857      rcMv = cMvPred.scaleMv( iScale );
4858    }
4859    pInfo->m_acMvCand[ pInfo->iN++] = rcMv;
4860    return true;
4861  }
4862  //---------------------- V2(END) --------------------//
4863  if( pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) >= 0)
4864  {
4865    iNeibRefPOC = pcTmpCU->getSlice()->getRefPOC( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) );
4866    TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList2nd)->getMv(uiIdx);
4867    TComMv rcMv;
4868
4869    if( pcTmpCU->getSlice()->getRefViewId( eRefPicList2nd, pcTmpCU->getCUMvField(eRefPicList2nd)->getRefIdx(uiIdx) ) != m_pcSlice->getRefViewId( eRefPicList, iRefIdx ) )
4870    {
4871      return false;
4872    }
4873
4874    Int iScale = xGetDistScaleFactor( iCurrPOC, iCurrRefPOC, iNeibPOC, iNeibRefPOC );
4875    if ( iScale == 4096 )
4876    {
4877      rcMv = cMvPred;
4878    }
4879    else
4880    {
4881      rcMv = cMvPred.scaleMv( iScale );
4882    }
4883    pInfo->m_acMvCand[ pInfo->iN++] = rcMv;
4884    return true;
4885  }
4886  //---------------------- V3(END) --------------------//
4887  return false;
4888}
4889
4890/**
4891 * \param eRefPicList
4892 * \param uiCUAddr
4893 * \param uiPartUnitIdx
4894 * \param riRefIdx
4895 * \returns Bool
4896 */
4897Bool TComDataCU::xGetColMVP( RefPicList eRefPicList, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx )
4898{
4899  UInt uiAbsPartAddr = uiPartUnitIdx;
4900
4901  RefPicList  eColRefPicList;
4902  Int iColPOC, iColRefPOC, iCurrPOC, iCurrRefPOC, iScale;
4903#if SONY_COLPIC_AVAILABILITY
4904  Int iColViewOrderIdx, iColRefViewOrderIdx, iCurrViewOrderIdx, iCurrRefViewOrderIdx;
4905#endif
4906  TComMv cColMv;
4907
4908#if SONY_COLPIC_AVAILABILITY
4909  iCurrViewOrderIdx    = m_pcSlice->getViewOrderIdx();
4910  iCurrRefViewOrderIdx = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewOrderIdx();
4911#endif
4912  // use coldir.
4913#if COLLOCATED_REF_IDX
4914  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? getSlice()->getColDir() : 0), getSlice()->getColRefIdx());
4915#else
4916  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? getSlice()->getColDir() : 0), 0);
4917#endif
4918  TComDataCU *pColCU = pColPic->getCU( uiCUAddr );
4919  if(pColCU->getPic()==0||pColCU->getPartitionSize(uiPartUnitIdx)==SIZE_NONE)
4920  {
4921    return false;
4922  }
4923  iCurrPOC = m_pcSlice->getPOC();   
4924  iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
4925  iColPOC = pColCU->getSlice()->getPOC(); 
4926#if SONY_COLPIC_AVAILABILITY
4927  iColViewOrderIdx = pColCU->getSlice()->getViewOrderIdx();
4928#endif
4929
4930  if (pColCU->isIntra(uiAbsPartAddr))
4931  {
4932    return false;
4933  }
4934
4935#if !SONY_COLPIC_AVAILABILITY
4936  if( m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewId() != m_pcSlice->getViewId() )
4937    return false;
4938#endif
4939
4940  if ( !pColPic->getUsedForTMVP() )
4941  {
4942    return false;
4943  }
4944
4945  eColRefPicList = getSlice()->getCheckLDC() ? eRefPicList : RefPicList(1-getSlice()->getColDir());
4946
4947  Int iColRefIdx = pColCU->getCUMvField(RefPicList(eColRefPicList))->getRefIdx(uiAbsPartAddr);
4948
4949  if (iColRefIdx < 0 )
4950  {
4951    eColRefPicList = RefPicList(1 - eColRefPicList);
4952    iColRefIdx = pColCU->getCUMvField(RefPicList(eColRefPicList))->getRefIdx(uiAbsPartAddr);
4953
4954    if (iColRefIdx < 0 )
4955    {
4956      return false;
4957    }
4958  }
4959
4960  // Scale the vector.
4961  iColRefPOC = pColCU->getSlice()->getRefPOC(eColRefPicList, iColRefIdx);
4962
4963#if SONY_COLPIC_AVAILABILITY
4964  iColRefViewOrderIdx = pColCU->getSlice()->getRefPic( eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiAbsPartAddr))->getViewOrderIdx();
4965#else
4966  if( pColCU->getSlice()->getRefViewId( eColRefPicList, iColRefIdx ) != m_pcSlice->getRefPic( eRefPicList, riRefIdx )->getViewId() )
4967  {
4968    return false;
4969  }
4970#endif
4971
4972  cColMv = pColCU->getCUMvField(eColRefPicList)->getMv(uiAbsPartAddr);
4973
4974  iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
4975#if SONY_COLPIC_AVAILABILITY
4976  iScale = 0;
4977  iCurrRefViewOrderIdx = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getViewOrderIdx();
4978  if((iColPOC != iColRefPOC)&&(iCurrPOC != iCurrRefPOC))
4979    iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
4980  else if((iColPOC == iColRefPOC)&&(iCurrPOC == iCurrRefPOC))
4981    iScale = xGetDistScaleFactor(iCurrViewOrderIdx, iCurrRefViewOrderIdx, iColViewOrderIdx, iColRefViewOrderIdx);
4982#else
4983  iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
4984#endif
4985  if ( iScale == 4096 )
4986  {
4987    rcMv = cColMv;
4988  }
4989  else
4990  {
4991    rcMv = cColMv.scaleMv( iScale );
4992  }
4993
4994  return true;
4995}
4996
4997UInt TComDataCU::xGetMvdBits(TComMv cMvd)
4998{
4999  return ( xGetComponentBits(cMvd.getHor()) + xGetComponentBits(cMvd.getVer()) );
5000}
5001
5002UInt TComDataCU::xGetComponentBits(Int iVal)
5003{
5004  UInt uiLength = 1;
5005  UInt uiTemp   = ( iVal <= 0) ? (-iVal<<1)+1: (iVal<<1);
5006 
5007  assert ( uiTemp );
5008 
5009  while ( 1 != uiTemp )
5010  {
5011    uiTemp >>= 1;
5012    uiLength += 2;
5013  }
5014 
5015  return uiLength;
5016}
5017
5018
5019Int TComDataCU::xGetDistScaleFactor(Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC)
5020{
5021  Int iDiffPocD = iColPOC - iColRefPOC;
5022  Int iDiffPocB = iCurrPOC - iCurrRefPOC;
5023 
5024  if( iDiffPocD == iDiffPocB )
5025  {
5026    return 4096;
5027  }
5028  else
5029  {
5030    Int iTDB      = Clip3( -128, 127, iDiffPocB );
5031    Int iTDD      = Clip3( -128, 127, iDiffPocD );
5032    Int iX        = (0x4000 + abs(iTDD/2)) / iTDD;
5033    Int iScale    = Clip3( -4096, 4095, (iTDB * iX + 32) >> 6 );
5034    return iScale;
5035  }
5036}
5037
5038/**
5039 * \param eCUMode
5040 * \param uiPartIdx
5041 * \param ruiPartIdxCenter
5042 * \returns Void
5043 */
5044Void TComDataCU::xDeriveCenterIdx( PartSize eCUMode, UInt uiPartIdx, UInt& ruiPartIdxCenter )
5045{
5046  UInt uiPartAddr;
5047  Int  iPartWidth;
5048  Int  iPartHeight;
5049  getPartIndexAndSize( uiPartIdx, uiPartAddr, iPartWidth, iPartHeight);
5050 
5051  ruiPartIdxCenter = m_uiAbsIdxInLCU+uiPartAddr; // partition origin.
5052  ruiPartIdxCenter = g_auiRasterToZscan[ g_auiZscanToRaster[ ruiPartIdxCenter ]
5053                                        + ( iPartHeight/m_pcPic->getMinCUHeight()  )/2*m_pcPic->getNumPartInWidth()
5054                                        + ( iPartWidth/m_pcPic->getMinCUWidth()  )/2];
5055}
5056
5057/**
5058 * \param uiPartIdx
5059 * \param eRefPicList
5060 * \param iRefIdx
5061 * \param pcMv
5062 * \returns Bool
5063 */
5064Bool TComDataCU::xGetCenterCol( UInt uiPartIdx, RefPicList eRefPicList, int iRefIdx, TComMv *pcMv )
5065{
5066  PartSize eCUMode = getPartitionSize( 0 );
5067 
5068  Int iCurrPOC = m_pcSlice->getPOC();
5069 
5070  // use coldir.
5071#if COLLOCATED_REF_IDX
5072  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? getSlice()->getColDir() : 0), getSlice()->getColRefIdx());
5073#else
5074  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? getSlice()->getColDir() : 0), 0);
5075#endif
5076  TComDataCU *pColCU = pColPic->getCU( m_uiCUAddr );
5077 
5078  Int iColPOC = pColCU->getSlice()->getPOC();
5079  UInt uiPartIdxCenter;
5080  xDeriveCenterIdx( eCUMode, uiPartIdx, uiPartIdxCenter );
5081 
5082  if (pColCU->isIntra(uiPartIdxCenter))
5083  {
5084    return false;
5085  }
5086 
5087  if( m_pcSlice->getRefPic( eRefPicList, iRefIdx )->getViewId() != m_pcSlice->getViewId() )
5088  {
5089    return false;
5090  }
5091
5092  // Prefer a vector crossing us.  Prefer shortest.
5093  RefPicList eColRefPicList = REF_PIC_LIST_0;
5094  bool bFirstCrosses = false;
5095  Int  iFirstColDist = -1;
5096  for (Int l = 0; l < 2; l++)
5097  {
5098    bool bSaveIt = false;
5099    int iColRefIdx = pColCU->getCUMvField(RefPicList(l))->getRefIdx(uiPartIdxCenter);
5100    if (iColRefIdx < 0)
5101    {
5102      continue;
5103    }
5104    int iColRefPOC = pColCU->getSlice()->getRefPOC(RefPicList(l), iColRefIdx);
5105    if( pColCU->getSlice()->getRefViewId( RefPicList(l), iColRefIdx ) != pColCU->getSlice()->getViewId() )
5106    {
5107      continue;
5108    }
5109    int iColDist = abs(iColRefPOC - iColPOC);
5110    bool bCrosses = iColPOC < iCurrPOC ? iColRefPOC > iCurrPOC : iColRefPOC < iCurrPOC;
5111    if (iFirstColDist < 0)
5112    {
5113      bSaveIt = true;
5114    }
5115    else if (bCrosses && !bFirstCrosses)
5116    {
5117      bSaveIt = true;
5118    }
5119    else if (bCrosses == bFirstCrosses && l == eRefPicList)
5120    {
5121      bSaveIt = true;
5122    }
5123   
5124    if (bSaveIt)
5125    {
5126      bFirstCrosses = bCrosses;
5127      iFirstColDist = iColDist;
5128      eColRefPicList = RefPicList(l);
5129    }
5130  }
5131 
5132  // Scale the vector.
5133  Int iColRefPOC = pColCU->getSlice()->getRefPOC(eColRefPicList, pColCU->getCUMvField(eColRefPicList)->getRefIdx(uiPartIdxCenter));
5134  TComMv cColMv = pColCU->getCUMvField(eColRefPicList)->getMv(uiPartIdxCenter);
5135 
5136  Int iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, iRefIdx)->getPOC();
5137  Int iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
5138  if ( iScale == 4096 )
5139  {
5140    pcMv[0] = cColMv;
5141  }
5142  else
5143  {
5144    pcMv[0] = cColMv.scaleMv( iScale );
5145  }
5146 
5147  return true;
5148}
5149
5150Void TComDataCU::compressMV()
5151{
5152  Int scaleFactor = 4 * AMVP_DECIMATION_FACTOR / m_unitSize;
5153  if (scaleFactor > 0)
5154  {
5155#if HHI_MPI
5156    m_acCUMvField[0].compress(m_pePredMode, m_puhInterDir, scaleFactor);
5157    m_acCUMvField[1].compress(m_pePredMode, m_puhInterDir, scaleFactor);
5158#else
5159    m_acCUMvField[0].compress(m_pePredMode, scaleFactor);
5160    m_acCUMvField[1].compress(m_pePredMode, scaleFactor);   
5161#endif
5162  }
5163}
5164
5165UInt TComDataCU::getCoefScanIdx(UInt uiAbsPartIdx, UInt uiWidth, Bool bIsLuma, Bool bIsIntra)
5166{
5167#if !LOGI_INTRA_NAME_3MPM 
5168  static const UChar aucIntraDirToScanIdx[MAX_CU_DEPTH][NUM_INTRA_MODE] =
5169  {
5170    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
5171    },
5172    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
5173    },
5174    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
5175    },
5176    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
5177    },
5178    {0, 1, 2, 0, 0, 1, 1, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0
5179    },
5180    {0, 1, 2, 0, 0, 1, 1, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0
5181    },
5182    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
5183    },
5184  };
5185#endif
5186 
5187  UInt uiCTXIdx;
5188  UInt uiScanIdx;
5189  UInt uiDirMode;
5190
5191  if ( !bIsIntra ) 
5192  {
5193    uiScanIdx = SCAN_ZIGZAG;
5194    return uiScanIdx;
5195  }
5196
5197  switch(uiWidth)
5198  {
5199    case  2: uiCTXIdx = 6; break;
5200    case  4: uiCTXIdx = 5; break;
5201    case  8: uiCTXIdx = 4; break;
5202    case 16: uiCTXIdx = 3; break;
5203    case 32: uiCTXIdx = 2; break;
5204    case 64: uiCTXIdx = 1; break;
5205    default: uiCTXIdx = 0; break;
5206  }
5207
5208  if ( bIsLuma )
5209  {
5210    uiDirMode = getLumaIntraDir(uiAbsPartIdx);
5211#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
5212    mapDMMtoIntraMode( uiDirMode );
5213#endif
5214
5215#if LOGI_INTRA_NAME_3MPM
5216    uiScanIdx = SCAN_ZIGZAG;
5217    if (uiCTXIdx >3 && uiCTXIdx < 6) //if multiple scans supported for PU size
5218    {
5219      uiScanIdx = abs((Int) uiDirMode - VER_IDX) < 5 ? 1 : (abs((Int)uiDirMode - HOR_IDX) < 5 ? 2 : 0);
5220    }
5221#else
5222    uiScanIdx = aucIntraDirToScanIdx[uiCTXIdx][uiDirMode];
5223#endif
5224  }
5225  else
5226  {
5227    uiDirMode = getChromaIntraDir(uiAbsPartIdx);
5228    if( uiDirMode == DM_CHROMA_IDX )
5229    {
5230      // get number of partitions in current CU
5231      UInt depth = getDepth(uiAbsPartIdx);
5232      UInt numParts = getPic()->getNumPartInCU() >> (2 * depth);
5233     
5234      // get luma mode from upper-left corner of current CU
5235      uiDirMode = getLumaIntraDir((uiAbsPartIdx/numParts)*numParts);
5236#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
5237    mapDMMtoIntraMode( uiDirMode );
5238#endif
5239    }
5240#if LOGI_INTRA_NAME_3MPM
5241    uiScanIdx = SCAN_ZIGZAG;
5242    if (uiCTXIdx >4 && uiCTXIdx < 7) //if multiple scans supported for PU size
5243    {
5244      uiScanIdx = abs((Int) uiDirMode - VER_IDX) < 5 ? 1 : (abs((Int)uiDirMode - HOR_IDX) < 5 ? 2 : 0);
5245    }
5246#else
5247    uiScanIdx = aucIntraDirToScanIdx[max<Int>(uiCTXIdx-1,0)][uiDirMode];
5248#endif
5249  }
5250
5251  return uiScanIdx;
5252}
5253
5254Bool TComDataCU::useNonSquareTrans(UInt uiTrMode, Int absPartIdx)
5255{
5256  UInt minTuSize = ( 1 << ( getSlice()->getSPS()->getQuadtreeTULog2MinSize() + 1 ) );
5257  const UInt uiLog2TrSize = g_aucConvertToBit[ getSlice()->getSPS()->getMaxCUWidth() >> ( m_puhDepth[ absPartIdx ] + uiTrMode ) ] + 2;
5258  if ( uiTrMode && uiLog2TrSize < getSlice()->getSPS()->getQuadtreeTULog2MaxSize() && ( getWidth( absPartIdx ) > minTuSize ) &&
5259      ( m_pePartSize[absPartIdx] == SIZE_Nx2N || m_pePartSize[absPartIdx] == SIZE_2NxN || ( m_pePartSize[absPartIdx] >= SIZE_2NxnU && m_pePartSize[absPartIdx] <= SIZE_nRx2N ) ) )
5260  {
5261    return getSlice()->getSPS()->getUseNSQT();
5262  }
5263  else
5264  {
5265    return false;
5266  }
5267}
5268
5269Void TComDataCU::getNSQTSize(Int trMode, Int absPartIdx, Int &trWidth, Int &trHeight)
5270{
5271  UInt minTuSize = ( 1 << getSlice()->getSPS()->getQuadtreeTULog2MinSize() );
5272  if ( useNonSquareTrans( trMode, absPartIdx ) && ( trWidth > minTuSize ) )
5273  {
5274    trWidth  = ( m_pePartSize[absPartIdx] == SIZE_Nx2N || m_pePartSize[absPartIdx] == SIZE_nLx2N || m_pePartSize[absPartIdx] == SIZE_nRx2N )? trWidth >> 1 : trWidth << 1;
5275    trHeight = ( m_pePartSize[absPartIdx] == SIZE_Nx2N || m_pePartSize[absPartIdx] == SIZE_nLx2N || m_pePartSize[absPartIdx] == SIZE_nRx2N )? trHeight << 1 : trHeight >> 1;
5276  }
5277}
5278Bool TComDataCU::useNonSquarePU(UInt absPartIdx)
5279{
5280  if ( ( m_pePartSize[absPartIdx] == SIZE_Nx2N ) || ( m_pePartSize[absPartIdx] == SIZE_2NxN ) || ( m_pePartSize[absPartIdx] >= SIZE_2NxnU && m_pePartSize[absPartIdx] <= SIZE_nRx2N ) )
5281  {
5282    return true;
5283  }
5284  else
5285  {
5286    return false;
5287  }
5288}
5289
5290UInt TComDataCU::getInterTUSplitDirection( Int trWidth, Int trHeight, Int trLastWidth, Int trLastHeight )
5291{
5292  UInt interTUSplitDirection = 2;
5293  if ( ( trWidth == trLastWidth ) && ( trHeight < trLastHeight ) )
5294  {
5295    interTUSplitDirection = 0;
5296  }
5297  else if ( ( trWidth < trLastWidth ) && ( trHeight == trLastHeight ) )
5298  {
5299    interTUSplitDirection = 1;
5300  }   
5301
5302  return interTUSplitDirection;
5303}
5304
5305UInt TComDataCU::getNSAbsPartIdx ( UInt log2TrafoSize, UInt absPartIdx, UInt absTUPartIdx, UInt innerQuadIdx, UInt trMode )
5306{
5307  Int trWidth, trHeight, trLastWidth, trLastHeight;
5308  UInt lcuWidthInBaseUnits = getPic()->getNumPartInWidth();
5309  UInt nsTUWidthInBaseUnits, nsTUHeightInBaseUnits;
5310  UInt interTUSplitDirection;
5311 
5312  if( isIntra(absPartIdx) )
5313  {
5314    return absPartIdx;
5315  }
5316
5317  trWidth = trHeight = ( 1 << log2TrafoSize );
5318  trLastWidth = trWidth << 1, trLastHeight = trHeight << 1; 
5319
5320  getNSQTSize( trMode,     absPartIdx, trWidth,     trHeight );
5321  getNSQTSize( trMode - 1, absPartIdx, trLastWidth, trLastHeight );
5322  interTUSplitDirection = getInterTUSplitDirection ( trWidth, trHeight, trLastWidth, trLastHeight );
5323
5324  nsTUWidthInBaseUnits  = trWidth / getPic()->getMinCUWidth();
5325  nsTUHeightInBaseUnits = trHeight / getPic()->getMinCUHeight();   
5326
5327  if ( interTUSplitDirection != 2 ) 
5328  {
5329    UInt uiNSTUBaseUnits = nsTUWidthInBaseUnits < nsTUHeightInBaseUnits ? nsTUWidthInBaseUnits : nsTUHeightInBaseUnits;
5330    absTUPartIdx = g_auiRasterToZscan[ g_auiZscanToRaster[absTUPartIdx] + innerQuadIdx * uiNSTUBaseUnits * lcuWidthInBaseUnits * ( 1 - interTUSplitDirection ) + innerQuadIdx * uiNSTUBaseUnits * interTUSplitDirection ];
5331  }
5332  else 
5333  {
5334    absTUPartIdx = g_auiRasterToZscan[ g_auiZscanToRaster[absTUPartIdx] + (innerQuadIdx & 0x01) * nsTUWidthInBaseUnits + ( ( innerQuadIdx >> 1 ) & 0x01 ) * nsTUHeightInBaseUnits * lcuWidthInBaseUnits ]; 
5335  }
5336
5337  return absTUPartIdx; 
5338}
5339
5340UInt TComDataCU::getNSAddrChroma( UInt uiLog2TrSizeC, UInt uiTrModeC, UInt uiQuadrant, UInt absTUPartIdx )
5341{ 
5342  if( uiLog2TrSizeC != getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
5343  {
5344    return absTUPartIdx;
5345  }
5346
5347  UInt lcuWidthInBaseUnits = getPic()->getNumPartInWidth();
5348  Int trWidth  = ( 1 << ( uiLog2TrSizeC + 1 ) );
5349  Int trHeight = ( 1 << ( uiLog2TrSizeC + 1 ) );
5350  Int trLastWidth = trWidth << 1, trLastHeight = trHeight << 1;
5351
5352  getNSQTSize ( uiTrModeC - 1, absTUPartIdx, trLastWidth, trLastHeight );
5353  getNSQTSize ( uiTrModeC,     absTUPartIdx, trWidth,     trHeight );
5354
5355  UInt interTUSplitDirection = getInterTUSplitDirection ( trWidth, trHeight, trLastWidth, trLastHeight );
5356  UInt nsTUWidthInBaseUnits  = trWidth / getPic()->getMinCUWidth();
5357  UInt nsTUHeightInBaseUnits = trHeight / getPic()->getMinCUHeight();
5358  UInt firstTURasterIdx = 0, absTUPartIdxC = 0; 
5359
5360  if(interTUSplitDirection != 2)
5361  {
5362    UInt uiNSTUBaseUnits = nsTUWidthInBaseUnits < nsTUHeightInBaseUnits ? 1 : lcuWidthInBaseUnits;
5363    firstTURasterIdx   = g_auiZscanToRaster[absTUPartIdx] - uiQuadrant * uiNSTUBaseUnits;
5364    absTUPartIdxC      = g_auiRasterToZscan[firstTURasterIdx] + uiQuadrant * nsTUWidthInBaseUnits * nsTUHeightInBaseUnits;
5365  }
5366  else
5367  {
5368    UInt uiNSTUBaseUnits = nsTUWidthInBaseUnits < nsTUHeightInBaseUnits ? 2 * lcuWidthInBaseUnits : 2;
5369    firstTURasterIdx   = g_auiZscanToRaster[absTUPartIdx] - ( ( uiQuadrant >> 1 ) & 0x01 ) * nsTUHeightInBaseUnits * lcuWidthInBaseUnits - ( uiQuadrant & 0x01 ) * nsTUWidthInBaseUnits;
5370    absTUPartIdxC      = g_auiRasterToZscan[firstTURasterIdx + uiQuadrant * uiNSTUBaseUnits];
5371  }
5372
5373  return absTUPartIdxC;
5374}
5375
5376
5377UInt TComDataCU::getSCUAddr()
5378{ 
5379  return getPic()->getPicSym()->getInverseCUOrderMap(m_uiCUAddr)*(1<<(m_pcSlice->getSPS()->getMaxCUDepth()<<1))+m_uiAbsIdxInLCU; 
5380}
5381
5382/** Set neighboring blocks availabilities for non-deblocked filtering
5383 * \param numLCUInPicWidth number of LCUs in picture width
5384 * \param numLCUInPicHeight number of LCUs in picture height
5385 * \param numSUInLCUWidth number of SUs in LCU width
5386 * \param numSUInLCUHeight number of SUs in LCU height
5387 * \param picWidth picture width
5388 * \param picHeight picture height
5389 * \param bIndependentSliceBoundaryEnabled true for independent slice boundary enabled
5390 * \param bTopTileBoundary true means that top boundary coincides tile boundary
5391 * \param bDownTileBoundary true means that bottom boundary coincides tile boundary
5392 * \param bLeftTileBoundary true means that left boundary coincides tile boundary
5393 * \param bRightTileBoundary true means that right boundary coincides tile boundary
5394 * \param bIndependentTileBoundaryEnabled true for independent tile boundary enabled
5395 */
5396Void TComDataCU::setNDBFilterBlockBorderAvailability(UInt numLCUInPicWidth, UInt numLCUInPicHeight, UInt numSUInLCUWidth, UInt numSUInLCUHeight, UInt picWidth, UInt picHeight
5397                                                    ,Bool bIndependentSliceBoundaryEnabled
5398                                                    ,Bool bTopTileBoundary, Bool bDownTileBoundary, Bool bLeftTileBoundary, Bool bRightTileBoundary
5399                                                    ,Bool bIndependentTileBoundaryEnabled)
5400{
5401  UInt numSUInLCU = numSUInLCUWidth*numSUInLCUHeight;
5402  Int* pSliceIDMapLCU = m_piSliceSUMap;
5403
5404  UInt uiLPelX, uiTPelY;
5405  UInt width, height;
5406  Bool bPicRBoundary, bPicBBoundary, bPicTBoundary, bPicLBoundary;
5407  Bool bLCURBoundary= false, bLCUBBoundary= false, bLCUTBoundary= false, bLCULBoundary= false;
5408  Bool* pbAvailBorder;
5409  Bool* pbAvail;
5410  UInt rTLSU, rBRSU, widthSU, heightSU;
5411  UInt zRefSU;
5412  Int* pRefID;
5413  Int* pRefMapLCU;
5414  UInt rTRefSU= 0, rBRefSU= 0, rLRefSU= 0, rRRefSU= 0;
5415  Int* pRRefMapLCU= NULL;
5416  Int* pLRefMapLCU= NULL;
5417  Int* pTRefMapLCU= NULL;
5418  Int* pBRefMapLCU= NULL;
5419  Int  sliceID;
5420  UInt numSGU = (UInt)m_vNDFBlock.size();
5421
5422  for(Int i=0; i< numSGU; i++)
5423  {
5424    NDBFBlockInfo& rSGU = m_vNDFBlock[i];
5425
5426    sliceID = rSGU.sliceID;
5427    uiLPelX = rSGU.posX;
5428    uiTPelY = rSGU.posY;
5429    width   = rSGU.width;
5430    height  = rSGU.height;
5431
5432    rTLSU     = g_auiZscanToRaster[ rSGU.startSU ];
5433    rBRSU     = g_auiZscanToRaster[ rSGU.endSU   ];
5434    widthSU   = rSGU.widthSU;
5435    heightSU  = rSGU.heightSU;
5436
5437    pbAvailBorder = rSGU.isBorderAvailable;
5438
5439    bPicTBoundary= (uiTPelY == 0                       )?(true):(false);
5440    bPicLBoundary= (uiLPelX == 0                       )?(true):(false);
5441    bPicRBoundary= (!(uiLPelX+ width < picWidth )  )?(true):(false);
5442    bPicBBoundary= (!(uiTPelY + height < picHeight))?(true):(false);
5443
5444    bLCULBoundary = (rTLSU % numSUInLCUWidth == 0)?(true):(false);
5445    bLCURBoundary = ( (rTLSU+ widthSU) % numSUInLCUWidth == 0)?(true):(false);
5446    bLCUTBoundary = ( (UInt)(rTLSU / numSUInLCUWidth)== 0)?(true):(false);
5447    bLCUBBoundary = ( (UInt)(rBRSU / numSUInLCUWidth) == (numSUInLCUHeight-1) )?(true):(false);
5448
5449    //       SGU_L
5450    pbAvail = &(pbAvailBorder[SGU_L]);
5451    if(bPicLBoundary)
5452    {
5453      *pbAvail = false;
5454    }
5455    else if (!bIndependentSliceBoundaryEnabled)
5456    {
5457      *pbAvail = true;
5458    }
5459    else
5460    {
5461      //      bLCULBoundary = (rTLSU % uiNumSUInLCUWidth == 0)?(true):(false);
5462      if(bLCULBoundary)
5463      {
5464        rLRefSU     = rTLSU + numSUInLCUWidth -1;
5465        zRefSU      = g_auiRasterToZscan[rLRefSU];
5466        pRefMapLCU = pLRefMapLCU= (pSliceIDMapLCU - numSUInLCU);
5467      }
5468      else
5469      {
5470        zRefSU   = g_auiRasterToZscan[rTLSU - 1];
5471        pRefMapLCU  = pSliceIDMapLCU;
5472      }
5473      pRefID = pRefMapLCU + zRefSU;
5474      *pbAvail = (*pRefID == sliceID)?(true):(false);
5475    }
5476
5477    //       SGU_R
5478    pbAvail = &(pbAvailBorder[SGU_R]);
5479    if(bPicRBoundary)
5480    {
5481      *pbAvail = false;
5482    }
5483    else if (!bIndependentSliceBoundaryEnabled)
5484    {
5485      *pbAvail = true;
5486    }
5487    else
5488    {
5489      //       bLCURBoundary = ( (rTLSU+ uiWidthSU) % uiNumSUInLCUWidth == 0)?(true):(false);
5490      if(bLCURBoundary)
5491      {
5492        rRRefSU      = rTLSU + widthSU - numSUInLCUWidth;
5493        zRefSU       = g_auiRasterToZscan[rRRefSU];
5494        pRefMapLCU  = pRRefMapLCU= (pSliceIDMapLCU + numSUInLCU);
5495      }
5496      else
5497      {
5498        zRefSU       = g_auiRasterToZscan[rTLSU + widthSU];
5499        pRefMapLCU  = pSliceIDMapLCU;
5500      }
5501      pRefID = pRefMapLCU + zRefSU;
5502      *pbAvail = (*pRefID == sliceID)?(true):(false);
5503    }
5504
5505    //       SGU_T
5506    pbAvail = &(pbAvailBorder[SGU_T]);
5507    if(bPicTBoundary)
5508    {
5509      *pbAvail = false;
5510    }
5511    else if (!bIndependentSliceBoundaryEnabled)
5512    {
5513      *pbAvail = true;
5514    }
5515    else
5516    {
5517      //      bLCUTBoundary = ( (UInt)(rTLSU / uiNumSUInLCUWidth)== 0)?(true):(false);
5518      if(bLCUTBoundary)
5519      {
5520        rTRefSU      = numSUInLCU - (numSUInLCUWidth - rTLSU);
5521        zRefSU       = g_auiRasterToZscan[rTRefSU];
5522        pRefMapLCU  = pTRefMapLCU= (pSliceIDMapLCU - (numLCUInPicWidth*numSUInLCU));
5523      }
5524      else
5525      {
5526        zRefSU       = g_auiRasterToZscan[rTLSU - numSUInLCUWidth];
5527        pRefMapLCU  = pSliceIDMapLCU;
5528      }
5529      pRefID = pRefMapLCU + zRefSU;
5530      *pbAvail = (*pRefID == sliceID)?(true):(false);
5531    }
5532
5533    //       SGU_B
5534    pbAvail = &(pbAvailBorder[SGU_B]);
5535    if(bPicBBoundary)
5536    {
5537      *pbAvail = false;
5538    }
5539    else if (!bIndependentSliceBoundaryEnabled)
5540    {
5541      *pbAvail = true;
5542    }
5543    else
5544    {
5545      //      bLCUBBoundary = ( (UInt)(rBRSU / uiNumSUInLCUWidth) == (uiNumSUInLCUHeight-1) )?(true):(false);
5546      if(bLCUBBoundary)
5547      {
5548        rBRefSU      = rTLSU % numSUInLCUWidth;
5549        zRefSU       = g_auiRasterToZscan[rBRefSU];
5550        pRefMapLCU  = pBRefMapLCU= (pSliceIDMapLCU + (numLCUInPicWidth*numSUInLCU));
5551      }
5552      else
5553      {
5554        zRefSU       = g_auiRasterToZscan[rTLSU + (heightSU*numSUInLCUWidth)];
5555        pRefMapLCU  = pSliceIDMapLCU;
5556      }
5557      pRefID = pRefMapLCU + zRefSU;
5558      *pbAvail = (*pRefID == sliceID)?(true):(false);
5559    }
5560
5561    //       SGU_TL
5562    pbAvail = &(pbAvailBorder[SGU_TL]);
5563    if(bPicTBoundary || bPicLBoundary)
5564    {
5565      *pbAvail = false;
5566    }
5567    else if (!bIndependentSliceBoundaryEnabled)
5568    {
5569      *pbAvail = true;
5570    }
5571    else
5572    {
5573      if(bLCUTBoundary && bLCULBoundary)
5574      {
5575        zRefSU       = numSUInLCU -1;
5576        pRefMapLCU  = pSliceIDMapLCU - ( (numLCUInPicWidth+1)*numSUInLCU);
5577      }
5578      else if(bLCUTBoundary)
5579      {
5580        zRefSU       = g_auiRasterToZscan[ rTRefSU- 1];
5581        pRefMapLCU  = pTRefMapLCU;
5582      }
5583      else if(bLCULBoundary)
5584      {
5585        zRefSU       = g_auiRasterToZscan[ rLRefSU- numSUInLCUWidth ];
5586        pRefMapLCU  = pLRefMapLCU;
5587      }
5588      else //inside LCU
5589      {
5590        zRefSU       = g_auiRasterToZscan[ rTLSU - numSUInLCUWidth -1];
5591        pRefMapLCU  = pSliceIDMapLCU;
5592      }
5593      pRefID = pRefMapLCU + zRefSU;
5594      *pbAvail = (*pRefID == sliceID)?(true):(false);
5595    }
5596
5597    //       SGU_TR
5598    pbAvail = &(pbAvailBorder[SGU_TR]);
5599    if(bPicTBoundary || bPicRBoundary)
5600    {
5601      *pbAvail = false;
5602    }
5603    else if (!bIndependentSliceBoundaryEnabled)
5604    {
5605      *pbAvail = true;
5606    }
5607    else
5608    {
5609      if(bLCUTBoundary && bLCURBoundary)
5610      {
5611        zRefSU      = g_auiRasterToZscan[numSUInLCU - numSUInLCUWidth];
5612        pRefMapLCU  = pSliceIDMapLCU - ( (numLCUInPicWidth-1)*numSUInLCU);       
5613      }
5614      else if(bLCUTBoundary)
5615      {
5616        zRefSU       = g_auiRasterToZscan[ rTRefSU+ widthSU];
5617        pRefMapLCU  = pTRefMapLCU;
5618      }
5619      else if(bLCURBoundary)
5620      {
5621        zRefSU       = g_auiRasterToZscan[ rRRefSU- numSUInLCUWidth ];
5622        pRefMapLCU  = pRRefMapLCU;
5623      }
5624      else //inside LCU
5625      {
5626        zRefSU       = g_auiRasterToZscan[ rTLSU - numSUInLCUWidth +widthSU];
5627        pRefMapLCU  = pSliceIDMapLCU;
5628      }
5629      pRefID = pRefMapLCU + zRefSU;
5630      *pbAvail = (*pRefID == sliceID)?(true):(false);
5631    }
5632
5633    //       SGU_BL
5634    pbAvail = &(pbAvailBorder[SGU_BL]);
5635    if(bPicBBoundary || bPicLBoundary)
5636    {
5637      *pbAvail = false;
5638    }
5639    else if (!bIndependentSliceBoundaryEnabled)
5640    {
5641      *pbAvail = true;
5642    }
5643    else
5644    {
5645      if(bLCUBBoundary && bLCULBoundary)
5646      {
5647        zRefSU      = g_auiRasterToZscan[numSUInLCUWidth - 1];
5648        pRefMapLCU  = pSliceIDMapLCU + ( (numLCUInPicWidth-1)*numSUInLCU);       
5649      }
5650      else if(bLCUBBoundary)
5651      {
5652        zRefSU       = g_auiRasterToZscan[ rBRefSU - 1];
5653        pRefMapLCU  = pBRefMapLCU;
5654      }
5655      else if(bLCULBoundary)
5656      {
5657        zRefSU       = g_auiRasterToZscan[ rLRefSU+ heightSU*numSUInLCUWidth ];
5658        pRefMapLCU  = pLRefMapLCU;
5659      }
5660      else //inside LCU
5661      {
5662        zRefSU       = g_auiRasterToZscan[ rTLSU + heightSU*numSUInLCUWidth -1];
5663        pRefMapLCU  = pSliceIDMapLCU;
5664      }
5665      pRefID = pRefMapLCU + zRefSU;
5666      *pbAvail = (*pRefID == sliceID)?(true):(false);
5667    }
5668
5669    //       SGU_BR
5670    pbAvail = &(pbAvailBorder[SGU_BR]);
5671    if(bPicBBoundary || bPicRBoundary)
5672    {
5673      *pbAvail = false;
5674    }
5675    else if (!bIndependentSliceBoundaryEnabled)
5676    {
5677      *pbAvail = true;
5678    }
5679    else
5680    {
5681      if(bLCUBBoundary && bLCURBoundary)
5682      {
5683        zRefSU = 0;
5684        pRefMapLCU = pSliceIDMapLCU+ ( (numLCUInPicWidth+1)*numSUInLCU);
5685      }
5686      else if(bLCUBBoundary)
5687      {
5688        zRefSU      = g_auiRasterToZscan[ rBRefSU + widthSU];
5689        pRefMapLCU = pBRefMapLCU;
5690      }
5691      else if(bLCURBoundary)
5692      {
5693        zRefSU      = g_auiRasterToZscan[ rRRefSU + (heightSU*numSUInLCUWidth)];
5694        pRefMapLCU = pRRefMapLCU;
5695      }
5696      else //inside LCU
5697      {
5698        zRefSU      = g_auiRasterToZscan[ rTLSU + (heightSU*numSUInLCUWidth)+ widthSU];
5699        pRefMapLCU = pSliceIDMapLCU;
5700      }
5701      pRefID = pRefMapLCU + zRefSU;
5702      *pbAvail = (*pRefID == sliceID)?(true):(false);
5703    }
5704
5705    if(bIndependentTileBoundaryEnabled)
5706    {
5707      //left LCU boundary
5708      if(!bPicLBoundary && bLCULBoundary)
5709      {
5710        if(bLeftTileBoundary)
5711        {
5712          pbAvailBorder[SGU_L] = pbAvailBorder[SGU_TL] = pbAvailBorder[SGU_BL] = false;
5713        }
5714      }
5715      //right LCU boundary
5716      if(!bPicRBoundary && bLCURBoundary)
5717      {
5718        if(bRightTileBoundary)
5719        {
5720          pbAvailBorder[SGU_R] = pbAvailBorder[SGU_TR] = pbAvailBorder[SGU_BR] = false;
5721        }
5722      }
5723      //top LCU boundary
5724      if(!bPicTBoundary && bLCUTBoundary)
5725      {
5726        if(bTopTileBoundary)
5727        {
5728          pbAvailBorder[SGU_T] = pbAvailBorder[SGU_TL] = pbAvailBorder[SGU_TR] = false;
5729        }
5730      }
5731      //down LCU boundary
5732      if(!bPicBBoundary && bLCUBBoundary)
5733      {
5734        if(bDownTileBoundary)
5735        {
5736          pbAvailBorder[SGU_B] = pbAvailBorder[SGU_BL] = pbAvailBorder[SGU_BR] = false;
5737        }
5738      }
5739    }
5740#if LCU_SYNTAX_ALF
5741    rSGU.allBordersAvailable = true;
5742    for(Int b=0; b< NUM_SGU_BORDER; b++)
5743    {
5744      if(pbAvailBorder[b] == false)
5745      {
5746        rSGU.allBordersAvailable = false;
5747        break;
5748      }
5749    }
5750#endif
5751
5752  }
5753}
5754
5755Void TComDataCU::getPosInPic( UInt uiAbsPartIndex, Int& riPosX, Int& riPosY )
5756{
5757  riPosX = g_auiRasterToPelX[g_auiZscanToRaster[uiAbsPartIndex]] + getCUPelX();
5758  riPosY = g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIndex]] + getCUPelY(); 
5759}
5760
5761// -------------------------------------------------------------------------------------------------------------------
5762// public functions for depth model modes
5763// -------------------------------------------------------------------------------------------------------------------
5764#if HHI_DMM_WEDGE_INTRA
5765Void TComDataCU::setWedgeFullTabIdxSubParts( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth )
5766{
5767  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5768
5769  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5770  {
5771    m_puiWedgeFullTabIdx[uiAbsPartIdx+ui] = uiTIdx;
5772  }
5773}
5774
5775Void TComDataCU::setWedgeFullDeltaDC1SubParts( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth )
5776{
5777  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5778
5779  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5780  {
5781    m_piWedgeFullDeltaDC1[uiAbsPartIdx+ui] = iDC1;
5782  }
5783}
5784
5785Void TComDataCU::setWedgeFullDeltaDC2SubParts( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth )
5786{
5787  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5788
5789  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5790  {
5791    m_piWedgeFullDeltaDC2[uiAbsPartIdx+ui] = iDC2;
5792  }
5793}
5794
5795Void TComDataCU::setWedgePredDirTabIdxSubParts( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth )
5796{
5797  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5798
5799  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5800  {
5801    m_puiWedgePredDirTabIdx[uiAbsPartIdx+ui] = uiTIdx;
5802  }
5803}
5804
5805Void TComDataCU::setWedgePredDirDeltaDC1SubParts( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth )
5806{
5807  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5808
5809  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5810  {
5811    m_piWedgePredDirDeltaDC1[uiAbsPartIdx+ui] = iDC1;
5812  }
5813}
5814
5815Void TComDataCU::setWedgePredDirDeltaDC2SubParts( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth )
5816{
5817  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5818
5819  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5820  {
5821    m_piWedgePredDirDeltaDC2[uiAbsPartIdx+ui] = iDC2;
5822  }
5823}
5824
5825Void TComDataCU::setWedgePredDirDeltaEndSubParts( Int iDelta, UInt uiAbsPartIdx, UInt uiDepth )
5826{
5827  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5828
5829  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5830  {
5831    m_piWedgePredDirDeltaEnd[uiAbsPartIdx+ui] = iDelta;
5832  }
5833}
5834#endif
5835#if HHI_DMM_PRED_TEX
5836Void TComDataCU::setWedgePredTexTabIdxSubParts( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth )
5837{
5838  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5839
5840  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5841  {
5842    m_puiWedgePredTexTabIdx[uiAbsPartIdx+ui] = uiTIdx;
5843  }
5844}
5845
5846Void TComDataCU::setWedgePredTexDeltaDC1SubParts( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth )
5847{
5848  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5849
5850  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5851  {
5852    m_piWedgePredTexDeltaDC1[uiAbsPartIdx+ui] = iDC1;
5853  }
5854}
5855
5856Void TComDataCU::setWedgePredTexDeltaDC2SubParts( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth )
5857{
5858  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5859
5860  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5861  {
5862    m_piWedgePredTexDeltaDC2[uiAbsPartIdx+ui] = iDC2;
5863  }
5864}
5865
5866Void TComDataCU::setContourPredTexDeltaDC1SubParts( Int iDC1, UInt uiAbsPartIdx, UInt uiDepth )
5867{
5868  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5869
5870  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5871  {
5872    m_piContourPredTexDeltaDC1[uiAbsPartIdx+ui] = iDC1;
5873  }
5874}
5875
5876Void TComDataCU::setContourPredTexDeltaDC2SubParts( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth )
5877{
5878  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5879
5880  for ( UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5881  {
5882    m_piContourPredTexDeltaDC2[uiAbsPartIdx+ui] = iDC2;
5883  }
5884}
5885#endif
5886
5887#if HHI_MPI
5888Void TComDataCU::setTextureModeDepthSubParts( Int iTextureModeDepth, UInt uiAbsPartIdx, UInt uiDepth )
5889{
5890  UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5891
5892  for (UInt ui = 0; ui < uiCurrPartNumb; ui++ )
5893  {
5894    m_piTextureModeDepth[uiAbsPartIdx + ui] = iTextureModeDepth;
5895  }
5896}
5897
5898Void TComDataCU::copyTextureMotionDataFrom( TComDataCU* pcCU, UInt uiDepth, UInt uiAbsPartIdxSrc, UInt uiAbsPartIdxDst )
5899{
5900  assert( getSlice()->getIsDepth() && ! pcCU->getSlice()->getIsDepth() );
5901  UInt uiNumPartition = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
5902
5903  memcpy( m_pePredMode + uiAbsPartIdxDst,  pcCU->getPredictionMode() + uiAbsPartIdxSrc, sizeof( m_pePredMode[0] ) * uiNumPartition );
5904  memcpy( m_puhInterDir + uiAbsPartIdxDst, pcCU->getInterDir() + uiAbsPartIdxSrc,       sizeof( m_puhInterDir[0] ) * uiNumPartition );
5905
5906  memcpy( m_apiMVPIdx[0] + uiAbsPartIdxDst, pcCU->getMVPIdx(REF_PIC_LIST_0) + uiAbsPartIdxSrc, sizeof(*m_apiMVPIdx[0]) * uiNumPartition );
5907  memcpy( m_apiMVPIdx[1] + uiAbsPartIdxDst, pcCU->getMVPIdx(REF_PIC_LIST_1) + uiAbsPartIdxSrc, sizeof(*m_apiMVPIdx[0]) * uiNumPartition );
5908  memcpy( m_apiMVPNum[0] + uiAbsPartIdxDst, pcCU->getMVPNum(REF_PIC_LIST_0) + uiAbsPartIdxSrc, sizeof(*m_apiMVPNum[0]) * uiNumPartition );
5909  memcpy( m_apiMVPNum[1] + uiAbsPartIdxDst, pcCU->getMVPNum(REF_PIC_LIST_1) + uiAbsPartIdxSrc, sizeof(*m_apiMVPNum[0]) * uiNumPartition );
5910
5911  pcCU->getCUMvField( REF_PIC_LIST_0 )->copyTo( &m_acCUMvField[0], -Int(uiAbsPartIdxSrc) + uiAbsPartIdxDst, uiAbsPartIdxSrc, uiNumPartition );
5912  pcCU->getCUMvField( REF_PIC_LIST_1 )->copyTo( &m_acCUMvField[1], -Int(uiAbsPartIdxSrc) + uiAbsPartIdxDst, uiAbsPartIdxSrc, uiNumPartition );
5913
5914#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
5915  m_acCUMvField[0].decreaseMvAccuracy( uiAbsPartIdxDst, uiNumPartition, 2 );
5916  m_acCUMvField[1].decreaseMvAccuracy( uiAbsPartIdxDst, uiNumPartition, 2 );
5917#endif
5918}
5919#endif
5920
5921// -------------------------------------------------------------------------------------------------------------------
5922// public functions for Multi-view tools
5923// -------------------------------------------------------------------------------------------------------------------
5924#if HHI_INTER_VIEW_MOTION_PRED
5925Int
5926TComDataCU::getPdmMergeCandidate( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
5927{
5928  TComDepthMapGenerator* pcDepthMapGenerator = m_pcSlice->getSPS()->getDepthMapGenerator();
5929  ROFRS( pcDepthMapGenerator, 0 );
5930  return pcDepthMapGenerator->getPdmMergeCandidate( this, uiPartIdx, paiPdmRefIdx, pacPdmMv );
5931}
5932
5933
5934Bool
5935TComDataCU::getPdmMvPred( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge )
5936{
5937  TComDepthMapGenerator* pcDepthMapGenerator = m_pcSlice->getSPS()->getDepthMapGenerator();
5938  ROFRS( pcDepthMapGenerator, false );
5939  return pcDepthMapGenerator->getPdmMvPred( this, uiPartIdx, eRefPicList, iRefIdx, rcMv, bMerge );
5940}
5941
5942
5943Bool     
5944TComDataCU::getIViewOrgDepthMvPred( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv )
5945{
5946  TComDepthMapGenerator* pcDepthMapGenerator = m_pcSlice->getSPS()->getDepthMapGenerator();
5947  ROFRS( pcDepthMapGenerator, false );
5948  return pcDepthMapGenerator->getIViewOrgDepthMvPred( this, uiPartIdx, eRefPicList, iRefIdx, rcMv );
5949}
5950#endif
5951
5952#if HHI_INTER_VIEW_RESIDUAL_PRED
5953Bool
5954TComDataCU::getResidualSamples( UInt uiPartIdx, TComYuv* pcYuv )
5955{
5956  TComResidualGenerator*  pcResidualGenerator = m_pcSlice->getSPS()->getResidualGenerator();
5957  ROFRS( pcResidualGenerator, false );
5958  return pcResidualGenerator->getResidualSamples( this, uiPartIdx, pcYuv );
5959}
5960#endif
5961
5962//! \}
Note: See TracBrowser for help on using the repository browser.