Context navigation

source: 3DVCSoftware/branches/0.2-poznan-univ/source/Lib/TLibCommon/TComDataCU.cpp @ 11

Visit:

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: