Context navigation

source: 3DVCSoftware/branches/HTM-14.1-update-dev1/source/Lib/TLibCommon/TComDataCU.cpp @ 1279

Visit:

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