Context navigation

TComDataCU.cpp @ 557

Visit:

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-DEV-2.0-dev3-LG/source/Lib/TLibCommon/TComDataCU.cpp @ 557