source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComDataCU.cpp @ 504

Last change on this file since 504 was 504, checked in by zhang, 11 years ago

Merge Dev2.a to Dev2 and simulation results updated

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