Context navigation

source: 3DVCSoftware/tags/HTM-8.0/source/Lib/TLibCommon/TComDataCU.cpp @ 610

Visit:

Last change on this file since 610 was 608, checked in by tech, 11 years ago
Merged DEV-2.0-dev0@604.
Property svn:eol-style set to `native`
File size: 245.7 KB

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