Context navigation

TComPrediction.cpp @ 912

Visit:

Last change on this file since 912 was 578, checked in by ntt, 11 years ago
Integration of JCT3V-E0141
Property svn:eol-style set to `native`
File size: 99.2 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2013, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TComPrediction.cpp
35	\brief prediction class
36	*/
37
38	#include <memory.h>
39	#include "TComPrediction.h"
40
41	//! \ingroup TLibCommon
42	//! \{
43
44	// ====================================================================================================================
45	// Constructor / destructor / initialize
46	// ====================================================================================================================
47
48	TComPrediction::TComPrediction()
49	: m_pLumaRecBuffer(0)
50	, m_iLumaRecStride(0)
51	{
52	m_piYuvExt = NULL;
53	#if H_3D_VSP
54	m_pDepthBlock = (Int) malloc(MAX_NUM_SPU_WMAX_NUM_SPU_W*sizeof(Int));
55	if (m_pDepthBlock == NULL)
56	printf("ERROR: UKTGHU, No memory allocated.\n");
57	#endif
58	}
59
60	TComPrediction::~TComPrediction()
61	{
62	#if H_3D_VSP
63	if (m_pDepthBlock != NULL)
64	free(m_pDepthBlock);
65	#if NTT_VSP_COMMON_E0207_E0208
66	m_cYuvDepthOnVsp.destroy();
67	#endif
68	#endif
69
70	delete[] m_piYuvExt;
71
72	m_acYuvPred[0].destroy();
73	m_acYuvPred[1].destroy();
74
75	m_cYuvPredTemp.destroy();
76
77	#if H_3D_ARP
78	m_acYuvPredBase[0].destroy();
79	m_acYuvPredBase[1].destroy();
80	#endif
81	if( m_pLumaRecBuffer )
82	{
83	delete [] m_pLumaRecBuffer;
84	}
85
86	Int i, j;
87	for (i = 0; i < 4; i++)
88	{
89	for (j = 0; j < 4; j++)
90	{
91	m_filteredBlock[i][j].destroy();
92	}
93	m_filteredBlockTmp[i].destroy();
94	}
95	}
96
97	Void TComPrediction::initTempBuff()
98	{
99	if( m_piYuvExt == NULL )
100	{
101	Int extWidth = MAX_CU_SIZE + 16;
102	Int extHeight = MAX_CU_SIZE + 1;
103	Int i, j;
104	for (i = 0; i < 4; i++)
105	{
106	m_filteredBlockTmp[i].create(extWidth, extHeight + 7);
107	for (j = 0; j < 4; j++)
108	{
109	m_filteredBlock[i][j].create(extWidth, extHeight);
110	}
111	}
112	m_iYuvExtHeight = ((MAX_CU_SIZE + 2) << 4);
113	m_iYuvExtStride = ((MAX_CU_SIZE + 8) << 4);
114	m_piYuvExt = new Int[ m_iYuvExtStride * m_iYuvExtHeight ];
115
116	// new structure
117	m_acYuvPred[0] .create( MAX_CU_SIZE, MAX_CU_SIZE );
118	m_acYuvPred[1] .create( MAX_CU_SIZE, MAX_CU_SIZE );
119
120	m_cYuvPredTemp.create( MAX_CU_SIZE, MAX_CU_SIZE );
121	#if H_3D_ARP
122	m_acYuvPredBase[0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
123	m_acYuvPredBase[1] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
124	#endif
125	#if NTT_VSP_COMMON_E0207_E0208
126	m_cYuvDepthOnVsp.create( g_uiMaxCUWidth, g_uiMaxCUHeight );
127	#endif
128	}
129
130	if (m_iLumaRecStride != (MAX_CU_SIZE>>1) + 1)
131	{
132	m_iLumaRecStride = (MAX_CU_SIZE>>1) + 1;
133	if (!m_pLumaRecBuffer)
134	{
135	m_pLumaRecBuffer = new Pel[ m_iLumaRecStride * m_iLumaRecStride ];
136	}
137	}
138	#if H_3D_IC
139	for( Int i = 1; i < 64; i++ )
140	{
141	m_uiaShift[i-1] = ( (1 << 15) + i/2 ) / i;
142	}
143	#endif
144	}
145
146	// ====================================================================================================================
147	// Public member functions
148	// ====================================================================================================================
149
150	// Function for calculating DC value of the reference samples used in Intra prediction
151	Pel TComPrediction::predIntraGetPredValDC( Int* pSrc, Int iSrcStride, UInt iWidth, UInt iHeight, Bool bAbove, Bool bLeft )
152	{
153	assert(iWidth > 0 && iHeight > 0);
154	Int iInd, iSum = 0;
155	Pel pDcVal;
156
157	if (bAbove)
158	{
159	for (iInd = 0;iInd < iWidth;iInd++)
160	{
161	iSum += pSrc[iInd-iSrcStride];
162	}
163	}
164	if (bLeft)
165	{
166	for (iInd = 0;iInd < iHeight;iInd++)
167	{
168	iSum += pSrc[iInd*iSrcStride-1];
169	}
170	}
171
172	if (bAbove && bLeft)
173	{
174	pDcVal = (iSum + iWidth) / (iWidth + iHeight);
175	}
176	else if (bAbove)
177	{
178	pDcVal = (iSum + iWidth/2) / iWidth;
179	}
180	else if (bLeft)
181	{
182	pDcVal = (iSum + iHeight/2) / iHeight;
183	}
184	else
185	{
186	pDcVal = pSrc[-1]; // Default DC value already calculated and placed in the prediction array if no neighbors are available
187	}
188
189	return pDcVal;
190	}
191
192	// Function for deriving the angular Intra predictions
193
194	/** Function for deriving the simplified angular intra predictions.
195	* \param pSrc pointer to reconstructed sample array
196	* \param srcStride the stride of the reconstructed sample array
197	* \param rpDst reference to pointer for the prediction sample array
198	* \param dstStride the stride of the prediction sample array
199	* \param width the width of the block
200	* \param height the height of the block
201	* \param dirMode the intra prediction mode index
202	* \param blkAboveAvailable boolean indication if the block above is available
203	* \param blkLeftAvailable boolean indication if the block to the left is available
204	*
205	* This function derives the prediction samples for the angular mode based on the prediction direction indicated by
206	* the prediction mode index. The prediction direction is given by the displacement of the bottom row of the block and
207	* the reference row above the block in the case of vertical prediction or displacement of the rightmost column
208	* of the block and reference column left from the block in the case of the horizontal prediction. The displacement
209	* is signalled at 1/32 pixel accuracy. When projection of the predicted pixel falls inbetween reference samples,
210	* the predicted value for the pixel is linearly interpolated from the reference samples. All reference samples are taken
211	* from the extended main reference.
212	*/
213	Void TComPrediction::xPredIntraAng(Int bitDepth, Int* pSrc, Int srcStride, Pel*& rpDst, Int dstStride, UInt width, UInt height, UInt dirMode, Bool blkAboveAvailable, Bool blkLeftAvailable, Bool bFilter )
214	{
215	Int k,l;
216	Int blkSize = width;
217	Pel* pDst = rpDst;
218
219	// Map the mode index to main prediction direction and angle
220	assert( dirMode > 0 ); //no planar
221	Bool modeDC = dirMode < 2;
222	Bool modeHor = !modeDC && (dirMode < 18);
223	Bool modeVer = !modeDC && !modeHor;
224	Int intraPredAngle = modeVer ? (Int)dirMode - VER_IDX : modeHor ? -((Int)dirMode - HOR_IDX) : 0;
225	Int absAng = abs(intraPredAngle);
226	Int signAng = intraPredAngle < 0 ? -1 : 1;
227
228	// Set bitshifts and scale the angle parameter to block size
229	Int angTable[9] = {0, 2, 5, 9, 13, 17, 21, 26, 32};
230	Int invAngTable[9] = {0, 4096, 1638, 910, 630, 482, 390, 315, 256}; // (256 * 32) / Angle
231	Int invAngle = invAngTable[absAng];
232	absAng = angTable[absAng];
233	intraPredAngle = signAng * absAng;
234
235	// Do the DC prediction
236	if (modeDC)
237	{
238	Pel dcval = predIntraGetPredValDC(pSrc, srcStride, width, height, blkAboveAvailable, blkLeftAvailable);
239
240	for (k=0;k<blkSize;k++)
241	{
242	for (l=0;l<blkSize;l++)
243	{
244	pDst[k*dstStride+l] = dcval;
245	}
246	}
247	}
248
249	// Do angular predictions
250	else
251	{
252	Pel* refMain;
253	Pel* refSide;
254	Pel refAbove[2*MAX_CU_SIZE+1];
255	Pel refLeft[2*MAX_CU_SIZE+1];
256
257	// Initialise the Main and Left reference array.
258	if (intraPredAngle < 0)
259	{
260	for (k=0;k<blkSize+1;k++)
261	{
262	refAbove[k+blkSize-1] = pSrc[k-srcStride-1];
263	}
264	for (k=0;k<blkSize+1;k++)
265	{
266	refLeft[k+blkSize-1] = pSrc[(k-1)*srcStride-1];
267	}
268	refMain = (modeVer ? refAbove : refLeft) + (blkSize-1);
269	refSide = (modeVer ? refLeft : refAbove) + (blkSize-1);
270
271	// Extend the Main reference to the left.
272	Int invAngleSum = 128; // rounding for (shift by 8)
273	for (k=-1; k>blkSize*intraPredAngle>>5; k--)
274	{
275	invAngleSum += invAngle;
276	refMain[k] = refSide[invAngleSum>>8];
277	}
278	}
279	else
280	{
281	for (k=0;k<2*blkSize+1;k++)
282	{
283	refAbove[k] = pSrc[k-srcStride-1];
284	}
285	for (k=0;k<2*blkSize+1;k++)
286	{
287	refLeft[k] = pSrc[(k-1)*srcStride-1];
288	}
289	refMain = modeVer ? refAbove : refLeft;
290	refSide = modeVer ? refLeft : refAbove;
291	}
292
293	if (intraPredAngle == 0)
294	{
295	for (k=0;k<blkSize;k++)
296	{
297	for (l=0;l<blkSize;l++)
298	{
299	pDst[k*dstStride+l] = refMain[l+1];
300	}
301	}
302
303	if ( bFilter )
304	{
305	for (k=0;k<blkSize;k++)
306	{
307	pDst[kdstStride] = Clip3(0, (1<<bitDepth)-1, pDst[kdstStride] + (( refSide[k+1] - refSide[0] ) >> 1) );
308	}
309	}
310	}
311	else
312	{
313	Int deltaPos=0;
314	Int deltaInt;
315	Int deltaFract;
316	Int refMainIndex;
317
318	for (k=0;k<blkSize;k++)
319	{
320	deltaPos += intraPredAngle;
321	deltaInt = deltaPos >> 5;
322	deltaFract = deltaPos & (32 - 1);
323
324	if (deltaFract)
325	{
326	// Do linear filtering
327	for (l=0;l<blkSize;l++)
328	{
329	refMainIndex = l+deltaInt+1;
330	pDst[kdstStride+l] = (Pel) ( ((32-deltaFract)refMain[refMainIndex]+deltaFract*refMain[refMainIndex+1]+16) >> 5 );
331	}
332	}
333	else
334	{
335	// Just copy the integer samples
336	for (l=0;l<blkSize;l++)
337	{
338	pDst[k*dstStride+l] = refMain[l+deltaInt+1];
339	}
340	}
341	}
342	}
343
344	// Flip the block if this is the horizontal mode
345	if (modeHor)
346	{
347	Pel tmp;
348	for (k=0;k<blkSize-1;k++)
349	{
350	for (l=k+1;l<blkSize;l++)
351	{
352	tmp = pDst[k*dstStride+l];
353	pDst[kdstStride+l] = pDst[ldstStride+k];
354	pDst[l*dstStride+k] = tmp;
355	}
356	}
357	}
358	}
359	}
360
361	Void TComPrediction::predIntraLumaAng(TComPattern* pcTComPattern, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft )
362	{
363	Pel *pDst = piPred;
364	Int *ptrSrc;
365
366	assert( g_aucConvertToBit[ iWidth ] >= 0 ); // 4x 4
367	assert( g_aucConvertToBit[ iWidth ] <= 5 ); // 128x128
368	assert( iWidth == iHeight );
369
370	ptrSrc = pcTComPattern->getPredictorPtr( uiDirMode, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
371
372	// get starting pixel in block
373	Int sw = 2 * iWidth + 1;
374
375	// Create the prediction
376	if ( uiDirMode == PLANAR_IDX )
377	{
378	xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
379	}
380	else
381	{
382	if ( (iWidth > 16) \|\| (iHeight > 16) )
383	{
384	xPredIntraAng(g_bitDepthY, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, false );
385	}
386	else
387	{
388	xPredIntraAng(g_bitDepthY, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, true );
389
390	if( (uiDirMode == DC_IDX ) && bAbove && bLeft )
391	{
392	xDCPredFiltering( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight);
393	}
394	}
395	}
396	}
397
398	// Angular chroma
399	Void TComPrediction::predIntraChromaAng( Int* piSrc, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft )
400	{
401	Pel *pDst = piPred;
402	Int *ptrSrc = piSrc;
403
404	// get starting pixel in block
405	Int sw = 2 * iWidth + 1;
406
407	if ( uiDirMode == PLANAR_IDX )
408	{
409	xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
410	}
411	else
412	{
413	// Create the prediction
414	xPredIntraAng(g_bitDepthC, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, false );
415	}
416	}
417
418	#if H_3D_DIM
419	Void TComPrediction::predIntraLumaDepth( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiIntraMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bFastEnc )
420	{
421	assert( iWidth == iHeight );
422	assert( iWidth >= DIM_MIN_SIZE && iWidth <= DIM_MAX_SIZE );
423	assert( isDimMode( uiIntraMode ) );
424
425	UInt dimType = getDimType ( uiIntraMode );
426	Bool dimDeltaDC = isDimDeltaDC( uiIntraMode );
427	Bool isDmmMode = (dimType < DMM_NUM_TYPE);
428	Bool isRbcMode = (dimType == RBC_IDX);
429
430	Bool* biSegPattern = NULL;
431	UInt patternStride = 0;
432
433	// get partiton
434	#if H_3D_DIM_DMM
435	TComWedgelet* dmmSegmentation = NULL;
436	if( isDmmMode )
437	{
438	switch( dimType )
439	{
440	case( DMM1_IDX ):
441	{
442	dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ) ]);
443	} break;
444	case( DMM2_IDX ):
445	{
446	UInt uiTabIdx = 0;
447	if( bFastEnc ) { uiTabIdx = pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ); }
448	else
449	{
450	uiTabIdx = xPredWedgeFromIntra( pcCU, uiAbsPartIdx, iWidth, iHeight, pcCU->getDmm2DeltaEnd( uiAbsPartIdx ) );
451	pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dimType, uiAbsPartIdx, (pcCU->getDepth(0) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1)) );
452	}
453	dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ uiTabIdx ]);
454	} break;
455	case( DMM3_IDX ):
456	{
457	UInt uiTabIdx = 0;
458	if( bFastEnc ) { uiTabIdx = pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ); }
459	else
460	{
461	uiTabIdx = xPredWedgeFromTex( pcCU, uiAbsPartIdx, iWidth, iHeight, pcCU->getDmm3IntraTabIdx( uiAbsPartIdx ) );
462	pcCU->setDmmWedgeTabIdxSubParts( uiTabIdx, dimType, uiAbsPartIdx, (pcCU->getDepth(0) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1)) );
463	}
464	dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ uiTabIdx ]);
465	} break;
466	case( DMM4_IDX ):
467	{
468	dmmSegmentation = new TComWedgelet( iWidth, iHeight );
469	xPredContourFromTex( pcCU, uiAbsPartIdx, iWidth, iHeight, dmmSegmentation );
470	} break;
471	default: assert(0);
472	}
473	assert( dmmSegmentation );
474	biSegPattern = dmmSegmentation->getPattern();
475	patternStride = dmmSegmentation->getStride ();
476	}
477	#endif
478	#if H_3D_DIM_RBC
479	if( isRbcMode )
480	{
481	biSegPattern = pcCU->getEdgePartition( uiAbsPartIdx );
482	patternStride = iWidth;
483	}
484	#endif
485
486	// get predicted partition values
487	assert( biSegPattern );
488	Int* piMask = NULL;
489	if( isDmmMode ) piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt ); // no filtering for DMM
490	else piMask = pcCU->getPattern()->getPredictorPtr( 0, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
491	assert( piMask );
492	Int maskStride = 2*iWidth + 1;
493	Int* ptrSrc = piMask+maskStride+1;
494	Pel predDC1 = 0; Pel predDC2 = 0;
495	xPredBiSegDCs( ptrSrc, maskStride, biSegPattern, patternStride, predDC1, predDC2 );
496
497	// set segment values with deltaDC offsets
498	Pel segDC1 = 0;
499	Pel segDC2 = 0;
500	if( dimDeltaDC )
501	{
502	Pel deltaDC1 = pcCU->getDimDeltaDC( dimType, 0, uiAbsPartIdx );
503	Pel deltaDC2 = pcCU->getDimDeltaDC( dimType, 1, uiAbsPartIdx );
504	#if H_3D_DIM_DMM
505	if( isDmmMode )
506	{
507	#if H_3D_DIM_DLT
508	segDC1 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 ) + deltaDC1 );
509	segDC2 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 ) + deltaDC2 );
510	#else
511	segDC1 = ClipY( predDC1 + deltaDC1 );
512	segDC2 = ClipY( predDC2 + deltaDC2 );
513	#endif
514	}
515	#endif
516	#if H_3D_DIM_RBC
517	if( isRbcMode )
518	{
519	xDeltaDCQuantScaleUp( pcCU, deltaDC1 );
520	xDeltaDCQuantScaleUp( pcCU, deltaDC2 );
521	segDC1 = ClipY( predDC1 + deltaDC1 );
522	segDC2 = ClipY( predDC2 + deltaDC2 );
523	}
524	#endif
525	}
526	else
527	{
528	segDC1 = predDC1;
529	segDC2 = predDC2;
530	}
531
532	// set prediction signal
533	Pel* pDst = piPred;
534	xAssignBiSegDCs( pDst, uiStride, biSegPattern, patternStride, segDC1, segDC2 );
535
536	#if H_3D_DIM_DMM
537	if( dimType == DMM4_IDX ) { dmmSegmentation->destroy(); delete dmmSegmentation; }
538	#endif
539	}
540	#endif
541
542	/** Function for checking identical motion.
543	* \param TComDataCU* pcCU
544	* \param UInt PartAddr
545	*/
546	Bool TComPrediction::xCheckIdenticalMotion ( TComDataCU* pcCU, UInt PartAddr )
547	{
548	if( pcCU->getSlice()->isInterB() && !pcCU->getSlice()->getPPS()->getWPBiPred() )
549	{
550	if( pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr) >= 0 && pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr) >= 0)
551	{
552	Int RefPOCL0 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_0, pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr))->getPOC();
553	Int RefPOCL1 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_1, pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr))->getPOC();
554	if(RefPOCL0 == RefPOCL1 && pcCU->getCUMvField(REF_PIC_LIST_0)->getMv(PartAddr) == pcCU->getCUMvField(REF_PIC_LIST_1)->getMv(PartAddr))
555	{
556	return true;
557	}
558	}
559	}
560	return false;
561	}
562
563
564	Void TComPrediction::motionCompensation ( TComDataCU* pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList, Int iPartIdx )
565	{
566	Int iWidth;
567	Int iHeight;
568	UInt uiPartAddr;
569
570	if ( iPartIdx >= 0 )
571	{
572	pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
573	#if H_3D_VSP
574	if ( 0 == pcCU->getVSPFlag(uiPartAddr) )
575	{
576	#endif
577	if ( eRefPicList != REF_PIC_LIST_X )
578	{
579	if( pcCU->getSlice()->getPPS()->getUseWP())
580	{
581	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, true );
582	}
583	else
584	{
585	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
586	}
587	if ( pcCU->getSlice()->getPPS()->getUseWP() )
588	{
589	xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
590	}
591	}
592	else
593	{
594	if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
595	{
596	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
597	}
598	else
599	{
600	xPredInterBi (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
601	}
602	}
603	#if H_3D_VSP
604	}
605	else
606	{
607	if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
608	xPredInterUniVSP( pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
609	else
610	xPredInterBiVSP ( pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
611	}
612	#endif
613	return;
614	}
615
616	for ( iPartIdx = 0; iPartIdx < pcCU->getNumPartInter(); iPartIdx++ )
617	{
618	pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
619
620	#if H_3D_VSP
621	if ( 0 == pcCU->getVSPFlag(uiPartAddr) )
622	{
623	#endif
624	if ( eRefPicList != REF_PIC_LIST_X )
625	{
626	if( pcCU->getSlice()->getPPS()->getUseWP())
627	{
628	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, true );
629	}
630	else
631	{
632	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
633	}
634	if ( pcCU->getSlice()->getPPS()->getUseWP() )
635	{
636	xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred );
637	}
638	}
639	else
640	{
641	if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
642	{
643	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
644	}
645	else
646	{
647	xPredInterBi (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
648	}
649	}
650	#if H_3D_VSP
651	}
652	else
653	{
654	if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
655	xPredInterUniVSP( pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
656	else
657	xPredInterBiVSP ( pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
658	}
659	#endif
660	}
661	return;
662	}
663
664	Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi )
665	{
666	Int iRefIdx = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr ); assert (iRefIdx >= 0);
667	TComMv cMv = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
668	pcCU->clipMv(cMv);
669	#if H_3D_ARP
670	if( pcCU->getARPW( uiPartAddr ) > 0
671	&& pcCU->getPartitionSize(uiPartAddr)==SIZE_2Nx2N
672	&& pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPOC()!= pcCU->getSlice()->getPOC()
673	)
674	{
675	xPredInterUniARP( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, rpcYuvPred, bi );
676	}
677	else
678	{
679	#endif
680	#if H_3D_IC
681	Bool bICFlag = pcCU->getICFlag( uiPartAddr ) && ( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getViewIndex() != pcCU->getSlice()->getViewIndex() );
682	xPredInterLumaBlk ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi
683	#if H_3D_ARP
684	, false
685	#endif
686	, bICFlag );
687	xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi
688	#if H_3D_ARP
689	, false
690	#endif
691	, bICFlag );
692	#else
693	xPredInterLumaBlk ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
694	xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
695	#endif
696	#if H_3D_ARP
697	}
698	#endif
699	}
700
701	#if H_3D_VSP
702	Void TComPrediction::xPredInterUniVSP( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Bool bi )
703	{
704	// Get depth reference
705	#if MTK_VSP_FIX_E0172
706	Int vspDir = pcCU->getVSPDir( uiPartAddr );
707	RefPicList privateRefPicList = (vspDir == 0) ? REF_PIC_LIST_0 : REF_PIC_LIST_1;
708	Int privateRefIdx = pcCU->getCUMvField( privateRefPicList )->getRefIdx( uiPartAddr );
709	Int depthRefViewIdx = pcCU->getSlice()->getRefPic(privateRefPicList, privateRefIdx)->getViewIndex();
710	#else
711	Int depthRefViewIdx = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
712	#endif
713	TComPic* pRefPicBaseDepth = pcCU->getSlice()->getIvPic (true, depthRefViewIdx );
714	assert(pRefPicBaseDepth != NULL);
715	TComPicYuv* pcBaseViewDepthPicYuv = pRefPicBaseDepth->getPicYuvRec();
716	assert(pcBaseViewDepthPicYuv != NULL);
717
718	// Get texture reference
719	Int iRefIdx = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
720	assert(iRefIdx >= 0);
721	TComPic* pRefPicBaseTxt = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx );
722	TComPicYuv* pcBaseViewTxtPicYuv = pRefPicBaseTxt->getPicYuvRec();
723	assert(pcBaseViewTxtPicYuv != NULL);
724
725	// Initialize LUT according to the reference viewIdx
726	Int txtRefViewIdx = pRefPicBaseTxt->getViewIndex();
727	Int* pShiftLUT = pcCU->getSlice()->getDepthToDisparityB( txtRefViewIdx );
728	assert( txtRefViewIdx < pcCU->getSlice()->getViewIndex() );
729
730	// Do compensation
731	#if MTK_VSP_FIX_E0172
732	TComMv cDv = pcCU->getCUMvField( privateRefPicList )->getMv( uiPartAddr );
733	#else
734	TComMv cDv = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr ); // cDv is the disparity vector derived from the neighbors
735	#endif
736	pcCU->clipMv(cDv);
737
738	#if NTT_VSP_COMMON_E0207_E0208
739	// fetch virtual depth map
740	#if NTT_VSP_VECTOR_CLIP_E0208
741	pcBaseViewDepthPicYuv->extendPicBorder();
742	#endif
743	xGetVirtualDepth( pcCU, pcBaseViewDepthPicYuv, &cDv, uiPartAddr, iWidth, iHeight, &m_cYuvDepthOnVsp );
744	// sub-PU based compensation
745	xPredInterLumaBlkFromDM ( pcCU, pcBaseViewTxtPicYuv, &m_cYuvDepthOnVsp, pShiftLUT, &cDv, uiPartAddr, iWidth, iHeight, pcCU->getSlice()->getIsDepth(), rpcYuvPred, bi );
746	xPredInterChromaBlkFromDM ( pcCU, pcBaseViewTxtPicYuv, &m_cYuvDepthOnVsp, pShiftLUT, &cDv, uiPartAddr, iWidth, iHeight, pcCU->getSlice()->getIsDepth(), rpcYuvPred, bi );
747	#else
748	UInt uiAbsPartIdx = pcCU->getZorderIdxInCU();
749	Int iBlkX = ( pcCU->getAddr() % pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUWidth + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
750	Int iBlkY = ( pcCU->getAddr() / pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
751	xPredInterLumaBlkFromDM ( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, &cDv, uiPartAddr, iBlkX, iBlkY, iWidth, iHeight, pcCU->getSlice()->getIsDepth(), rpcYuvPred, bi );
752	xPredInterChromaBlkFromDM( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, &cDv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1, pcCU->getSlice()->getIsDepth(), rpcYuvPred, bi );
753	#endif
754
755	}
756	#endif
757
758	#if H_3D_ARP
759	Void TComPrediction::xPredInterUniARP( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv& rpcYuvPred, Bool bi, TComMvField pNewMvFiled )
760	{
761	Int iRefIdx = pNewMvFiled ? pNewMvFiled->getRefIdx() : pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
762	TComMv cMv = pNewMvFiled ? pNewMvFiled->getMv() : pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
763	Bool bTobeScaled = false;
764	TComPic* pcPicYuvBaseCol = NULL;
765	TComPic* pcPicYuvBaseRef = NULL;
766
767	#if H_3D_NBDV
768	DisInfo cDistparity;
769	cDistparity.bDV = pcCU->getDvInfo(uiPartAddr).bDV;
770	if( cDistparity.bDV )
771	{
772	cDistparity.m_acNBDV = pcCU->getDvInfo(0).m_acNBDV;
773	assert(pcCU->getDvInfo(uiPartAddr).bDV == pcCU->getDvInfo(0).bDV);
774	cDistparity.m_aVIdxCan = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
775	}
776	#else
777	assert(0); // ARP can be applied only when a DV is available
778	#endif
779
780	UChar dW = cDistparity.bDV ? pcCU->getARPW ( uiPartAddr ) : 0;
781
782	if( cDistparity.bDV )
783	{
784	if( dW > 0 && pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC()!= pcCU->getSlice()->getPOC() )
785	{
786	bTobeScaled = true;
787	}
788
789	pcPicYuvBaseCol = pcCU->getSlice()->getBaseViewRefPic( pcCU->getSlice()->getPOC(), cDistparity.m_aVIdxCan );
790	pcPicYuvBaseRef = pcCU->getSlice()->getBaseViewRefPic( pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC(), cDistparity.m_aVIdxCan );
791
792	if( ( !pcPicYuvBaseCol \|\| pcPicYuvBaseCol->getPOC() != pcCU->getSlice()->getPOC() ) \|\| ( !pcPicYuvBaseRef \|\| pcPicYuvBaseRef->getPOC() != pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC() ) )
793	{
794	dW = 0;
795	bTobeScaled = false;
796	}
797	else
798	{
799	assert( pcPicYuvBaseCol->getPOC() == pcCU->getSlice()->getPOC() && pcPicYuvBaseRef->getPOC() == pcCU->getSlice()->getRefPic( eRefPicList, 0 )->getPOC() );
800	}
801
802	if(bTobeScaled)
803	{
804	Int iCurrPOC = pcCU->getSlice()->getPOC();
805	Int iColRefPOC = pcCU->getSlice()->getRefPOC( eRefPicList, iRefIdx );
806	Int iCurrRefPOC = pcCU->getSlice()->getRefPOC( eRefPicList, 0);
807	Int iScale = pcCU-> xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iCurrPOC, iColRefPOC);
808	if ( iScale != 4096 )
809	{
810	cMv = cMv.scaleMv( iScale );
811	}
812	iRefIdx = 0;
813	}
814	}
815
816	pcCU->clipMv(cMv);
817	TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec();
818	xPredInterLumaBlk ( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, true );
819	xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, true );
820
821	if( dW > 0 )
822	{
823	TComYuv * pYuvB0 = &m_acYuvPredBase[0];
824	TComYuv * pYuvB1 = &m_acYuvPredBase[1];
825
826	TComMv cMVwithDisparity = cMv + cDistparity.m_acNBDV;
827	pcCU->clipMv(cMVwithDisparity);
828
829	assert ( cDistparity.bDV );
830
831	pcPicYuvRef = pcPicYuvBaseCol->getPicYuvRec();
832	xPredInterLumaBlk ( pcCU, pcPicYuvRef, uiPartAddr, &cDistparity.m_acNBDV, iWidth, iHeight, pYuvB0, bi, true );
833	xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cDistparity.m_acNBDV, iWidth, iHeight, pYuvB0, bi, true );
834
835	pcPicYuvRef = pcPicYuvBaseRef->getPicYuvRec();
836	xPredInterLumaBlk ( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvB1, bi, true );
837	xPredInterChromaBlk( pcCU, pcPicYuvRef, uiPartAddr, &cMVwithDisparity, iWidth, iHeight, pYuvB1, bi, true );
838
839	pYuvB0->subtractARP( pYuvB0 , pYuvB1 , uiPartAddr , iWidth , iHeight );
840
841	if( 2 == dW )
842	{
843	pYuvB0->multiplyARP( uiPartAddr , iWidth , iHeight , dW );
844	}
845	rpcYuvPred->addARP( rpcYuvPred , pYuvB0 , uiPartAddr , iWidth , iHeight , !bi );
846	}
847	}
848	#endif
849
850	Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvPred )
851	{
852	TComYuv* pcMbYuv;
853	Int iRefIdx[2] = {-1, -1};
854
855	for ( Int iRefList = 0; iRefList < 2; iRefList++ )
856	{
857	RefPicList eRefPicList = (iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0);
858	iRefIdx[iRefList] = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
859
860	if ( iRefIdx[iRefList] < 0 )
861	{
862	continue;
863	}
864
865	assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) );
866
867	pcMbYuv = &m_acYuvPred[iRefList];
868	if( pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr ) >= 0 && pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr ) >= 0 )
869	{
870	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, true );
871	}
872	else
873	{
874	if ( ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType() == P_SLICE ) \|\|
875	( pcCU->getSlice()->getPPS()->getWPBiPred() && pcCU->getSlice()->getSliceType() == B_SLICE ) )
876	{
877	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, true );
878	}
879	else
880	{
881	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv );
882	}
883	}
884	}
885
886	if ( pcCU->getSlice()->getPPS()->getWPBiPred() && pcCU->getSlice()->getSliceType() == B_SLICE )
887	{
888	xWeightedPredictionBi( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
889	}
890	else if ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType() == P_SLICE )
891	{
892	xWeightedPredictionUni( pcCU, &m_acYuvPred[0], uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, rpcYuvPred );
893	}
894	else
895	{
896	xWeightedAverage( &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
897	}
898	}
899
900	#if H_3D_VSP
901
902	Void TComPrediction::xPredInterBiVSP( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvPred )
903	{
904	TComYuv* pcMbYuv;
905	Int iRefIdx[2] = {-1, -1};
906	Bool bi = (pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr ) >= 0 && pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr ) >= 0);
907
908	for ( Int iRefList = 0; iRefList < 2; iRefList++ )
909	{
910	RefPicList eRefPicList = RefPicList(iRefList);
911	iRefIdx[iRefList] = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
912
913	if ( iRefIdx[iRefList] < 0 )
914	continue;
915	assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) );
916
917	pcMbYuv = &m_acYuvPred[iRefList];
918	xPredInterUniVSP ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, bi );
919	}
920
921	xWeightedAverage( &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
922	}
923
924	#endif
925
926	/**
927	* \brief Generate motion-compensated luma block
928	*
929	* \param cu Pointer to current CU
930	* \param refPic Pointer to reference picture
931	* \param partAddr Address of block within CU
932	* \param mv Motion vector
933	* \param width Width of block
934	* \param height Height of block
935	* \param dstPic Pointer to destination picture
936	* \param bi Flag indicating whether bipred is used
937	*/
938	Void TComPrediction::xPredInterLumaBlk( TComDataCU cu, TComPicYuv refPic, UInt partAddr, TComMv mv, Int width, Int height, TComYuv &dstPic, Bool bi
939	#if H_3D_ARP
940	, Bool filterType
941	#endif
942	#if H_3D_IC
943	, Bool bICFlag
944	#endif
945	)
946	{
947	Int refStride = refPic->getStride();
948	Int refOffset = ( mv->getHor() >> 2 ) + ( mv->getVer() >> 2 ) * refStride;
949	Pel *ref = refPic->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
950
951	Int dstStride = dstPic->getStride();
952	Pel *dst = dstPic->getLumaAddr( partAddr );
953
954	Int xFrac = mv->getHor() & 0x3;
955	Int yFrac = mv->getVer() & 0x3;
956
957	#if H_3D_IC
958	if( cu->getSlice()->getIsDepth() )
959	{
960	refOffset = mv->getHor() + mv->getVer() * refStride;
961	ref = refPic->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
962	xFrac = 0;
963	yFrac = 0;
964	}
965	#endif
966	if ( yFrac == 0 )
967	{
968	m_if.filterHorLuma( ref, refStride, dst, dstStride, width, height, xFrac, !bi
969	#if H_3D_ARP
970	, filterType
971	#endif
972	);
973	}
974	else if ( xFrac == 0 )
975	{
976	m_if.filterVerLuma( ref, refStride, dst, dstStride, width, height, yFrac, true, !bi
977	#if H_3D_ARP
978	, filterType
979	#endif
980	);
981	}
982	else
983	{
984	Int tmpStride = m_filteredBlockTmp[0].getStride();
985	Short *tmp = m_filteredBlockTmp[0].getLumaAddr();
986
987	Int filterSize = NTAPS_LUMA;
988	Int halfFilterSize = ( filterSize >> 1 );
989
990	m_if.filterHorLuma(ref - (halfFilterSize-1)*refStride, refStride, tmp, tmpStride, width, height+filterSize-1, xFrac, false
991	#if H_3D_ARP
992	, filterType
993	#endif
994	);
995	m_if.filterVerLuma(tmp + (halfFilterSize-1)*tmpStride, tmpStride, dst, dstStride, width, height, yFrac, false, !bi
996	#if H_3D_ARP
997	, filterType
998	#endif
999	);
1000	}
1001
1002	#if H_3D_IC
1003	if( bICFlag )
1004	{
1005	Int a, b, iShift, i, j;
1006
1007	xGetLLSICPrediction( cu, mv, refPic, a, b, iShift, TEXT_LUMA );
1008
1009	for ( i = 0; i < height; i++ )
1010	{
1011	for ( j = 0; j < width; j++ )
1012	{
1013	if( bi )
1014	{
1015	Int iIFshift = IF_INTERNAL_PREC - g_bitDepthY;
1016	dst[j] = ( ( adst[j] + aIF_INTERNAL_OFFS ) >> iShift ) + b*( 1 << iIFshift ) - IF_INTERNAL_OFFS;
1017	}
1018	else
1019	dst[j] = Clip3( 0, ( 1 << g_bitDepthY ) - 1, ( ( a*dst[j] ) >> iShift ) + b );
1020	}
1021	dst += dstStride;
1022	}
1023	}
1024	#endif
1025	}
1026
1027	/**
1028	* \brief Generate motion-compensated chroma block
1029	*
1030	* \param cu Pointer to current CU
1031	* \param refPic Pointer to reference picture
1032	* \param partAddr Address of block within CU
1033	* \param mv Motion vector
1034	* \param width Width of block
1035	* \param height Height of block
1036	* \param dstPic Pointer to destination picture
1037	* \param bi Flag indicating whether bipred is used
1038	*/
1039	Void TComPrediction::xPredInterChromaBlk( TComDataCU cu, TComPicYuv refPic, UInt partAddr, TComMv mv, Int width, Int height, TComYuv &dstPic, Bool bi
1040	#if H_3D_ARP
1041	, Bool filterType
1042	#endif
1043	#if H_3D_IC
1044	, Bool bICFlag
1045	#endif
1046	)
1047	{
1048	Int refStride = refPic->getCStride();
1049	Int dstStride = dstPic->getCStride();
1050
1051	Int refOffset = (mv->getHor() >> 3) + (mv->getVer() >> 3) * refStride;
1052
1053	Pel* refCb = refPic->getCbAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1054	Pel* refCr = refPic->getCrAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1055
1056	Pel* dstCb = dstPic->getCbAddr( partAddr );
1057	Pel* dstCr = dstPic->getCrAddr( partAddr );
1058
1059	Int xFrac = mv->getHor() & 0x7;
1060	Int yFrac = mv->getVer() & 0x7;
1061	UInt cxWidth = width >> 1;
1062	UInt cxHeight = height >> 1;
1063
1064	Int extStride = m_filteredBlockTmp[0].getStride();
1065	Short* extY = m_filteredBlockTmp[0].getLumaAddr();
1066
1067	Int filterSize = NTAPS_CHROMA;
1068
1069	Int halfFilterSize = (filterSize>>1);
1070
1071	if ( yFrac == 0 )
1072	{
1073	m_if.filterHorChroma(refCb, refStride, dstCb, dstStride, cxWidth, cxHeight, xFrac, !bi
1074	#if H_3D_ARP
1075	, filterType
1076	#endif
1077	);
1078	m_if.filterHorChroma(refCr, refStride, dstCr, dstStride, cxWidth, cxHeight, xFrac, !bi
1079	#if H_3D_ARP
1080	, filterType
1081	#endif
1082	);
1083	}
1084	else if ( xFrac == 0 )
1085	{
1086	m_if.filterVerChroma(refCb, refStride, dstCb, dstStride, cxWidth, cxHeight, yFrac, true, !bi
1087	#if H_3D_ARP
1088	, filterType
1089	#endif
1090	);
1091	m_if.filterVerChroma(refCr, refStride, dstCr, dstStride, cxWidth, cxHeight, yFrac, true, !bi
1092	#if H_3D_ARP
1093	, filterType
1094	#endif
1095	);
1096	}
1097	else
1098	{
1099	m_if.filterHorChroma(refCb - (halfFilterSize-1)*refStride, refStride, extY, extStride, cxWidth, cxHeight+filterSize-1, xFrac, false
1100	#if H_3D_ARP
1101	, filterType
1102	#endif
1103	);
1104	m_if.filterVerChroma(extY + (halfFilterSize-1)*extStride, extStride, dstCb, dstStride, cxWidth, cxHeight , yFrac, false, !bi
1105	#if H_3D_ARP
1106	, filterType
1107	#endif
1108	);
1109
1110	m_if.filterHorChroma(refCr - (halfFilterSize-1)*refStride, refStride, extY, extStride, cxWidth, cxHeight+filterSize-1, xFrac, false
1111	#if H_3D_ARP
1112	, filterType
1113	#endif
1114	);
1115	m_if.filterVerChroma(extY + (halfFilterSize-1)*extStride, extStride, dstCr, dstStride, cxWidth, cxHeight , yFrac, false, !bi
1116	#if H_3D_ARP
1117	, filterType
1118	#endif
1119	);
1120	}
1121
1122	#if H_3D_IC
1123	if( bICFlag )
1124	{
1125	Int a, b, iShift, i, j;
1126	xGetLLSICPrediction( cu, mv, refPic, a, b, iShift, TEXT_CHROMA_U ); // Cb
1127	for ( i = 0; i < cxHeight; i++ )
1128	{
1129	for ( j = 0; j < cxWidth; j++ )
1130	{
1131	if( bi )
1132	{
1133	Int iIFshift = IF_INTERNAL_PREC - g_bitDepthC;
1134	dstCb[j] = ( ( adstCb[j] + aIF_INTERNAL_OFFS ) >> iShift ) + b*( 1<<iIFshift ) - IF_INTERNAL_OFFS;
1135	}
1136	else
1137	dstCb[j] = Clip3( 0, ( 1 << g_bitDepthC ) - 1, ( ( a*dstCb[j] ) >> iShift ) + b );
1138	}
1139	dstCb += dstStride;
1140	}
1141	xGetLLSICPrediction( cu, mv, refPic, a, b, iShift, TEXT_CHROMA_V ); // Cr
1142	for ( i = 0; i < cxHeight; i++ )
1143	{
1144	for ( j = 0; j < cxWidth; j++ )
1145	{
1146	if( bi )
1147	{
1148	Int iIFshift = IF_INTERNAL_PREC - g_bitDepthC;
1149	dstCr[j] = ( ( adstCr[j] + aIF_INTERNAL_OFFS ) >> iShift ) + b*( 1<<iIFshift ) - IF_INTERNAL_OFFS;
1150	}
1151	else
1152	dstCr[j] = Clip3( 0, ( 1 << g_bitDepthC ) - 1, ( ( a*dstCr[j] ) >> iShift ) + b );
1153	}
1154	dstCr += dstStride;
1155	}
1156	}
1157	#endif
1158	}
1159
1160	Void TComPrediction::xWeightedAverage( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst )
1161	{
1162	if( iRefIdx0 >= 0 && iRefIdx1 >= 0 )
1163	{
1164	rpcYuvDst->addAvg( pcYuvSrc0, pcYuvSrc1, uiPartIdx, iWidth, iHeight );
1165	}
1166	else if ( iRefIdx0 >= 0 && iRefIdx1 < 0 )
1167	{
1168	pcYuvSrc0->copyPartToPartYuv( rpcYuvDst, uiPartIdx, iWidth, iHeight );
1169	}
1170	else if ( iRefIdx0 < 0 && iRefIdx1 >= 0 )
1171	{
1172	pcYuvSrc1->copyPartToPartYuv( rpcYuvDst, uiPartIdx, iWidth, iHeight );
1173	}
1174	}
1175
1176	// AMVP
1177	Void TComPrediction::getMvPredAMVP( TComDataCU* pcCU, UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, TComMv& rcMvPred )
1178	{
1179	AMVPInfo* pcAMVPInfo = pcCU->getCUMvField(eRefPicList)->getAMVPInfo();
1180	if( pcAMVPInfo->iN <= 1 )
1181	{
1182	rcMvPred = pcAMVPInfo->m_acMvCand[0];
1183
1184	pcCU->setMVPIdxSubParts( 0, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
1185	pcCU->setMVPNumSubParts( pcAMVPInfo->iN, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
1186	return;
1187	}
1188
1189	assert(pcCU->getMVPIdx(eRefPicList,uiPartAddr) >= 0);
1190	rcMvPred = pcAMVPInfo->m_acMvCand[pcCU->getMVPIdx(eRefPicList,uiPartAddr)];
1191	return;
1192	}
1193
1194	/** Function for deriving planar intra prediction.
1195	* \param pSrc pointer to reconstructed sample array
1196	* \param srcStride the stride of the reconstructed sample array
1197	* \param rpDst reference to pointer for the prediction sample array
1198	* \param dstStride the stride of the prediction sample array
1199	* \param width the width of the block
1200	* \param height the height of the block
1201	*
1202	* This function derives the prediction samples for planar mode (intra coding).
1203	*/
1204	Void TComPrediction::xPredIntraPlanar( Int* pSrc, Int srcStride, Pel* rpDst, Int dstStride, UInt width, UInt height )
1205	{
1206	assert(width == height);
1207
1208	Int k, l, bottomLeft, topRight;
1209	Int horPred;
1210	Int leftColumn[MAX_CU_SIZE], topRow[MAX_CU_SIZE], bottomRow[MAX_CU_SIZE], rightColumn[MAX_CU_SIZE];
1211	UInt blkSize = width;
1212	UInt offset2D = width;
1213	UInt shift1D = g_aucConvertToBit[ width ] + 2;
1214	UInt shift2D = shift1D + 1;
1215
1216	// Get left and above reference column and row
1217	for(k=0;k<blkSize+1;k++)
1218	{
1219	topRow[k] = pSrc[k-srcStride];
1220	leftColumn[k] = pSrc[k*srcStride-1];
1221	}
1222
1223	// Prepare intermediate variables used in interpolation
1224	bottomLeft = leftColumn[blkSize];
1225	topRight = topRow[blkSize];
1226	for (k=0;k<blkSize;k++)
1227	{
1228	bottomRow[k] = bottomLeft - topRow[k];
1229	rightColumn[k] = topRight - leftColumn[k];
1230	topRow[k] <<= shift1D;
1231	leftColumn[k] <<= shift1D;
1232	}
1233
1234	// Generate prediction signal
1235	for (k=0;k<blkSize;k++)
1236	{
1237	horPred = leftColumn[k] + offset2D;
1238	for (l=0;l<blkSize;l++)
1239	{
1240	horPred += rightColumn[k];
1241	topRow[l] += bottomRow[l];
1242	rpDst[k*dstStride+l] = ( (horPred + topRow[l]) >> shift2D );
1243	}
1244	}
1245	}
1246
1247	/** Function for filtering intra DC predictor.
1248	* \param pSrc pointer to reconstructed sample array
1249	* \param iSrcStride the stride of the reconstructed sample array
1250	* \param rpDst reference to pointer for the prediction sample array
1251	* \param iDstStride the stride of the prediction sample array
1252	* \param iWidth the width of the block
1253	* \param iHeight the height of the block
1254	*
1255	* This function performs filtering left and top edges of the prediction samples for DC mode (intra coding).
1256	*/
1257	Void TComPrediction::xDCPredFiltering( Int* pSrc, Int iSrcStride, Pel*& rpDst, Int iDstStride, Int iWidth, Int iHeight )
1258	{
1259	Pel* pDst = rpDst;
1260	Int x, y, iDstStride2, iSrcStride2;
1261
1262	// boundary pixels processing
1263	pDst[0] = (Pel)((pSrc[-iSrcStride] + pSrc[-1] + 2 * pDst[0] + 2) >> 2);
1264
1265	for ( x = 1; x < iWidth; x++ )
1266	{
1267	pDst[x] = (Pel)((pSrc[x - iSrcStride] + 3 * pDst[x] + 2) >> 2);
1268	}
1269
1270	for ( y = 1, iDstStride2 = iDstStride, iSrcStride2 = iSrcStride-1; y < iHeight; y++, iDstStride2+=iDstStride, iSrcStride2+=iSrcStride )
1271	{
1272	pDst[iDstStride2] = (Pel)((pSrc[iSrcStride2] + 3 * pDst[iDstStride2] + 2) >> 2);
1273	}
1274
1275	return;
1276	}
1277	#if H_3D_IC
1278	/** Function for deriving the position of first non-zero binary bit of a value
1279	* \param x input value
1280	*
1281	* This function derives the position of first non-zero binary bit of a value
1282	*/
1283	Int GetMSB( UInt x )
1284	{
1285	Int iMSB = 0, bits = ( sizeof( Int ) << 3 ), y = 1;
1286
1287	while( x > 1 )
1288	{
1289	bits >>= 1;
1290	y = x >> bits;
1291
1292	if( y )
1293	{
1294	x = y;
1295	iMSB += bits;
1296	}
1297	}
1298
1299	iMSB+=y;
1300
1301	return iMSB;
1302	}
1303
1304	/** Function for counting leading number of zeros/ones
1305	* \param x input value
1306	\ This function counts leading number of zeros for positive numbers and
1307	\ leading number of ones for negative numbers. This can be implemented in
1308	\ single instructure cycle on many processors.
1309	*/
1310
1311	Short CountLeadingZerosOnes (Short x)
1312	{
1313	Short clz;
1314	Short i;
1315
1316	if(x == 0)
1317	{
1318	clz = 0;
1319	}
1320	else
1321	{
1322	if (x == -1)
1323	{
1324	clz = 15;
1325	}
1326	else
1327	{
1328	if(x < 0)
1329	{
1330	x = ~x;
1331	}
1332	clz = 15;
1333	for(i = 0;i < 15;++i)
1334	{
1335	if(x)
1336	{
1337	clz --;
1338	}
1339	x = x >> 1;
1340	}
1341	}
1342	}
1343	return clz;
1344	}
1345
1346	/** Function for deriving LM illumination compensation.
1347	*/
1348	Void TComPrediction::xGetLLSICPrediction( TComDataCU* pcCU, TComMv pMv, TComPicYuv pRefPic, Int &a, Int &b, Int &iShift, TextType eType )
1349	{
1350	TComPicYuv *pRecPic = pcCU->getPic()->getPicYuvRec();
1351	Pel pRec = NULL, pRef = NULL;
1352	UInt uiWidth, uiHeight, uiTmpPartIdx;
1353	Int iRecStride = ( eType == TEXT_LUMA ) ? pRecPic->getStride() : pRecPic->getCStride();
1354	Int iRefStride = ( eType == TEXT_LUMA ) ? pRefPic->getStride() : pRefPic->getCStride();
1355	Int iCUPelX, iCUPelY, iRefX, iRefY, iRefOffset, iHor, iVer;
1356
1357	iCUPelX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
1358	iCUPelY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
1359	iHor = pcCU->getSlice()->getIsDepth() ? pMv->getHor() : ( ( pMv->getHor() + 2 ) >> 2 );
1360	iVer = pcCU->getSlice()->getIsDepth() ? pMv->getVer() : ( ( pMv->getVer() + 2 ) >> 2 );
1361	iRefX = iCUPelX + iHor;
1362	iRefY = iCUPelY + iVer;
1363	if( eType != TEXT_LUMA )
1364	{
1365	iHor = pcCU->getSlice()->getIsDepth() ? ( ( pMv->getHor() + 1 ) >> 1 ) : ( ( pMv->getHor() + 4 ) >> 3 );
1366	iVer = pcCU->getSlice()->getIsDepth() ? ( ( pMv->getVer() + 1 ) >> 1 ) : ( ( pMv->getVer() + 4 ) >> 3 );
1367	}
1368	uiWidth = ( eType == TEXT_LUMA ) ? pcCU->getWidth( 0 ) : ( pcCU->getWidth( 0 ) >> 1 );
1369	uiHeight = ( eType == TEXT_LUMA ) ? pcCU->getHeight( 0 ) : ( pcCU->getHeight( 0 ) >> 1 );
1370
1371	Int i, j, iCountShift = 0;
1372
1373	// LLS parameters estimation -->
1374
1375	Int x = 0, y = 0, xx = 0, xy = 0;
1376
1377	if( pcCU->getPUAbove( uiTmpPartIdx, pcCU->getZorderIdxInCU() ) && iCUPelY > 0 && iRefY > 0 )
1378	{
1379	iRefOffset = iHor + iVer * iRefStride - iRefStride;
1380	if( eType == TEXT_LUMA )
1381	{
1382	pRef = pRefPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1383	pRec = pRecPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
1384	}
1385	else if( eType == TEXT_CHROMA_U )
1386	{
1387	pRef = pRefPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1388	pRec = pRecPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
1389	}
1390	else
1391	{
1392	assert( eType == TEXT_CHROMA_V );
1393	pRef = pRefPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1394	pRec = pRecPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
1395	}
1396
1397	for( j = 0; j < uiWidth; j++ )
1398	{
1399	x += pRef[j];
1400	y += pRec[j];
1401	xx += pRef[j] * pRef[j];
1402	xy += pRef[j] * pRec[j];
1403	}
1404	iCountShift += g_aucConvertToBit[ uiWidth ] + 2;
1405	}
1406
1407
1408	if( pcCU->getPULeft( uiTmpPartIdx, pcCU->getZorderIdxInCU() ) && iCUPelX > 0 && iRefX > 0 )
1409	{
1410	iRefOffset = iHor + iVer * iRefStride - 1;
1411	if( eType == TEXT_LUMA )
1412	{
1413	pRef = pRefPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1414	pRec = pRecPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
1415	}
1416	else if( eType == TEXT_CHROMA_U )
1417	{
1418	pRef = pRefPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1419	pRec = pRecPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
1420	}
1421	else
1422	{
1423	assert( eType == TEXT_CHROMA_V );
1424	pRef = pRefPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
1425	pRec = pRecPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
1426	}
1427
1428	for( i = 0; i < uiHeight; i++ )
1429	{
1430	x += pRef[0];
1431	y += pRec[0];
1432	xx += pRef[0] * pRef[0];
1433	xy += pRef[0] * pRec[0];
1434
1435	pRef += iRefStride;
1436	pRec += iRecStride;
1437	}
1438	iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 2 );
1439	}
1440
1441	Int iTempShift = ( ( eType == TEXT_LUMA ) ? g_bitDepthY : g_bitDepthC ) + g_aucConvertToBit[ uiWidth ] + 3 - 15;
1442
1443	if( iTempShift > 0 )
1444	{
1445	x = ( x + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
1446	y = ( y + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
1447	xx = ( xx + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
1448	xy = ( xy + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
1449	iCountShift -= iTempShift;
1450	}
1451
1452	iShift = 13;
1453
1454	if( iCountShift == 0 )
1455	{
1456	a = 1;
1457	b = 0;
1458	iShift = 0;
1459	}
1460	else
1461	{
1462	Int a1 = ( xy << iCountShift ) - y * x;
1463	Int a2 = ( xx << iCountShift ) - x * x;
1464
1465	{
1466	const Int iShiftA2 = 6;
1467	const Int iShiftA1 = 15;
1468	const Int iAccuracyShift = 15;
1469
1470	Int iScaleShiftA2 = 0;
1471	Int iScaleShiftA1 = 0;
1472	Int a1s = a1;
1473	Int a2s = a2;
1474
1475	iScaleShiftA1 = GetMSB( abs( a1 ) ) - iShiftA1;
1476	iScaleShiftA2 = GetMSB( abs( a2 ) ) - iShiftA2;
1477
1478	if( iScaleShiftA1 < 0 )
1479	{
1480	iScaleShiftA1 = 0;
1481	}
1482
1483	if( iScaleShiftA2 < 0 )
1484	{
1485	iScaleShiftA2 = 0;
1486	}
1487
1488	Int iScaleShiftA = iScaleShiftA2 + iAccuracyShift - iShift - iScaleShiftA1;
1489
1490	a2s = a2 >> iScaleShiftA2;
1491
1492	a1s = a1 >> iScaleShiftA1;
1493
1494	if (a2s >= 1)
1495	{
1496	a = a1s * m_uiaShift[ a2s - 1];
1497	}
1498	else
1499	{
1500	a = 0;
1501	}
1502
1503	if( iScaleShiftA < 0 )
1504	{
1505	a = a << -iScaleShiftA;
1506	}
1507	else
1508	{
1509	a = a >> iScaleShiftA;
1510	}
1511
1512	a = Clip3( -( 1 << 15 ), ( 1 << 15 ) - 1, a );
1513
1514	Int minA = -(1 << (6));
1515	Int maxA = (1 << 6) - 1;
1516	if( a <= maxA && a >= minA )
1517	{
1518	// do nothing
1519	}
1520	else
1521	{
1522	Short n = CountLeadingZerosOnes( a );
1523	a = a >> (9-n);
1524	iShift -= (9-n);
1525	}
1526
1527	b = ( y - ( ( a * x ) >> iShift ) + ( 1 << ( iCountShift - 1 ) ) ) >> iCountShift;
1528	}
1529	}
1530	}
1531	#endif
1532
1533	#if H_3D_VSP
1534
1535	#if NTT_VSP_COMMON_E0207_E0208
1536	// not fully support iRatioTxtPerDepth* != 1
1537	Void TComPrediction::xGetVirtualDepth( TComDataCU cu, TComPicYuv picRefDepth, TComMv mv, UInt partAddr, Int width, Int height, TComYuv yuvDepth, Int ratioTxtPerDepthX, Int ratioTxtPerDepthY )
1538	{
1539	Int nTxtPerDepthX = H_3D_VSP_BLOCKSIZE;
1540	Int nTxtPerDepthY = H_3D_VSP_BLOCKSIZE;
1541
1542	Int refDepStride = picRefDepth->getStride();
1543
1544	#if NTT_VSP_VECTOR_CLIP_E0208
1545
1546	Int refDepOffset = ( (mv->getHor()+2) >> 2 ) + ( (mv->getVer()+2) >> 2 ) * refDepStride;
1547	Pel *refDepth = picRefDepth->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr );
1548
1549	if( ratioTxtPerDepthX!=1 \|\| ratioTxtPerDepthY!=1 )
1550	{
1551	Int posX, posY;
1552	refDepth = picRefDepth->getLumaAddr( );
1553	cu->getPic()->getPicYuvRec()->getTopLeftSamplePos( cu->getAddr(), cu->getZorderIdxInCU() + partAddr, posX, posY ); // top-left position in texture
1554	posX /= ratioTxtPerDepthX; // texture position -> depth postion
1555	posY /= ratioTxtPerDepthY;
1556	refDepOffset += posX + posY * refDepStride;
1557
1558	width /= ratioTxtPerDepthX; // texture size -> depth size
1559	height /= ratioTxtPerDepthY;
1560	}
1561
1562	refDepth += refDepOffset;
1563
1564	#else // NTT_VSP_VECTOR_CLIP_E0208
1565
1566	Int widthDepth = picRefDepth->getWidth();
1567	Int heightDepth = picRefDepth->getHeight();
1568	Int posX, posY;
1569	cu->getPic()->getPicYuvRec()->getTopLeftSamplePos( cu->getAddr(), cu->getZorderIdxInCU() + partAddr, posX, posY ); // top-left position in texture
1570	posX /= ratioTxtPerDepthX; // texture position -> depth postion
1571	posY /= ratioTxtPerDepthY;
1572
1573	posX = Clip3(0, widthDepth-width, posX + ((mv->getHor()+2)>>2));
1574	posY = Clip3(0, heightDepth-height, posY + ((mv->getVer()+2)>>2));
1575
1576	Pel refDepth = picRefDepth->getLumaAddr() + posX + posY refDepStride;
1577
1578	#endif // NTT_VSP_VECTOR_CLIP_E0208
1579
1580	Int depStride = yuvDepth->getStride();
1581	Pel *depth = yuvDepth->getLumaAddr();
1582
1583	#if NTT_VSP_ADAPTIVE_SPLIT_E0207
1584
1585	if( width<8 \|\| height<8 )
1586	{ // no split
1587	Int rightOffset = width - 1;
1588	Int depStrideBlock = depStride * nTxtPerDepthY;
1589	Pel *refDepthTop = refDepth;
1590	Pel refDepthBot = refDepthTop + (height-1)refDepStride;
1591
1592	Pel maxDepth = refDepthTop[0] > refDepthBot[0] ? refDepthTop[0] : refDepthBot[0];
1593	if( maxDepth < refDepthTop[rightOffset] ) { maxDepth = refDepthTop[rightOffset]; }
1594	if( maxDepth < refDepthBot[rightOffset] ) { maxDepth = refDepthBot[rightOffset]; }
1595
1596	for( Int sY=0; sY<height; sY+=nTxtPerDepthY )
1597	{
1598	for( Int sX=0; sX<width; sX+=nTxtPerDepthX )
1599	{
1600	depth[sX] = maxDepth;
1601	}
1602	depth += depStrideBlock;
1603	}
1604	}
1605	else
1606	{ // split to 4x8, or 8x4
1607	Int blocksize = 8;
1608	Int subblocksize = 4;
1609	Int depStrideBlock = depStride * blocksize;
1610	Pel *depthTmp = NULL;
1611	Int depStrideTmp = depStride * nTxtPerDepthY;
1612	Int offset[4] = { 0, subblocksize-1, subblocksize, blocksize-1 };
1613	Pel *refDepthTmp[4] = { NULL, NULL, NULL, NULL };
1614	Pel repDepth4x8[2] = {0, 0};
1615	Pel repDepth8x4[2] = {0, 0};
1616
1617	Int refDepStrideBlock = refDepStride * blocksize;
1618	Int refDepStrideSubBlock = refDepStride * subblocksize;
1619
1620	refDepthTmp[0] = refDepth;
1621	refDepthTmp[2] = refDepthTmp[0] + refDepStrideSubBlock;
1622	refDepthTmp[1] = refDepthTmp[2] - refDepStride;
1623	refDepthTmp[3] = refDepthTmp[1] + refDepStrideSubBlock;
1624
1625	for( Int y=0; y<height; y+=blocksize )
1626	{
1627	for( Int x=0; x<width; x+=blocksize )
1628	{
1629	Bool ULvsBR = false, URvsBL = false;
1630
1631	ULvsBR = refDepthTmp[0][x+offset[0]] < refDepthTmp[3][x+offset[3]];
1632	URvsBL = refDepthTmp[0][x+offset[3]] < refDepthTmp[3][x+offset[0]];
1633
1634	if( ULvsBR ^ URvsBL )
1635	{ // 4x8
1636	repDepth4x8[0] = refDepthTmp[0][x+offset[0]] > refDepthTmp[0][x+offset[1]] ? refDepthTmp[0][x+offset[0]] : refDepthTmp[0][x+offset[1]];
1637	if( repDepth4x8[0] < refDepthTmp[3][x+offset[0]] )
1638	{
1639	repDepth4x8[0] = refDepthTmp[3][x+offset[0]];
1640	}
1641	if( repDepth4x8[0] < refDepthTmp[3][x+offset[1]] )
1642	{
1643	repDepth4x8[0] = refDepthTmp[3][x+offset[1]];
1644	}
1645	repDepth4x8[1] = refDepthTmp[0][x+offset[2]] > refDepthTmp[0][x+offset[3]] ? refDepthTmp[0][x+offset[2]] : refDepthTmp[0][x+offset[3]];
1646	if( repDepth4x8[1] < refDepthTmp[3][x+offset[2]] )
1647	{
1648	repDepth4x8[1] = refDepthTmp[3][x+offset[2]];
1649	}
1650	if( repDepth4x8[1] < refDepthTmp[3][x+offset[3]] )
1651	{
1652	repDepth4x8[1] = refDepthTmp[3][x+offset[3]];
1653	}
1654
1655	depthTmp = &depth[x];
1656	for( Int sY=0; sY<blocksize; sY+=nTxtPerDepthY )
1657	{
1658	for( Int sX=0; sX<subblocksize; sX+=nTxtPerDepthX )
1659	{
1660	depthTmp[sX] = repDepth4x8[0];
1661	}
1662	depthTmp += depStrideTmp;
1663	}
1664	depthTmp = &depth[x+subblocksize];
1665	for( Int sY=0; sY<blocksize; sY+=nTxtPerDepthY )
1666	{
1667	for( Int sX=0; sX<subblocksize; sX+=nTxtPerDepthX )
1668	{
1669	depthTmp[sX] = repDepth4x8[1];
1670	}
1671	depthTmp += depStrideTmp;
1672	}
1673	}
1674	else
1675	{ // 8x4
1676	repDepth8x4[0] = refDepthTmp[0][x+offset[0]] > refDepthTmp[0][x+offset[3]] ? refDepthTmp[0][x+offset[0]] : refDepthTmp[0][x+offset[3]];
1677	if( repDepth8x4[0] < refDepthTmp[1][x+offset[0]] )
1678	{
1679	repDepth8x4[0] = refDepthTmp[1][x+offset[0]];
1680	}
1681	if( repDepth8x4[0] < refDepthTmp[1][x+offset[3]] )
1682	{
1683	repDepth8x4[0] = refDepthTmp[1][x+offset[3]];
1684	}
1685	repDepth8x4[1] = refDepthTmp[2][x+offset[0]] > refDepthTmp[2][x+offset[3]] ? refDepthTmp[2][x+offset[0]] : refDepthTmp[2][x+offset[3]];
1686	if( repDepth8x4[1] < refDepthTmp[3][x+offset[0]] )
1687	{
1688	repDepth8x4[1] = refDepthTmp[3][x+offset[0]];
1689	}
1690	if( repDepth8x4[1] < refDepthTmp[3][x+offset[3]] )
1691	{
1692	repDepth8x4[1] = refDepthTmp[3][x+offset[3]];
1693	}
1694
1695	depthTmp = &depth[x];
1696	for( Int sY=0; sY<subblocksize; sY+=nTxtPerDepthY )
1697	{
1698	for( Int sX=0; sX<blocksize; sX+=nTxtPerDepthX )
1699	{
1700	depthTmp[sX] = repDepth8x4[0];
1701	}
1702	depthTmp += depStrideTmp;
1703	}
1704	for( Int sY=0; sY<subblocksize; sY+=nTxtPerDepthY )
1705	{
1706	for( Int sX=0; sX<blocksize; sX+=nTxtPerDepthX )
1707	{
1708	depthTmp[sX] = repDepth8x4[1];
1709	}
1710	depthTmp += depStrideTmp;
1711	}
1712	}
1713	}
1714	refDepthTmp[0] += refDepStrideBlock;
1715	refDepthTmp[1] += refDepStrideBlock;
1716	refDepthTmp[2] += refDepStrideBlock;
1717	refDepthTmp[3] += refDepStrideBlock;
1718	depth += depStrideBlock;
1719	}
1720	}
1721
1722	#else // NTT_VSP_ADAPTIVE_SPLIT_E0207
1723
1724	Int rightOffset = nTxtPerDepthX - 1;
1725	Int depStrideBlock = depStride * nTxtPerDepthY;
1726	Int refDepStrideBlock = refDepStride * nTxtPerDepthY;
1727	Pel *refDepthTop = refDepth;
1728	Pel refDepthBot = refDepthTop + (nTxtPerDepthY-1)refDepStride;
1729
1730	for( Int y=0; y<height; y+= nTxtPerDepthY )
1731	{
1732	for( Int x=0; x<width; x+=nTxtPerDepthX )
1733	{
1734	Pel maxDepth = refDepthTop[x] > refDepthBot[x] ? refDepthTop[x] : refDepthBot[x];
1735
1736	if( maxDepth < refDepthTop[x+rightOffset] )
1737	{
1738	maxDepth = refDepthTop[x+rightOffset];
1739	}
1740	if( maxDepth < refDepthBot[x+rightOffset] )
1741	{
1742	maxDepth = refDepthBot[x+rightOffset];
1743	}
1744
1745	depth[x] = maxDepth;
1746
1747	}
1748	refDepthTop += refDepStrideBlock;
1749	refDepthBot += refDepStrideBlock;
1750	depth += depStrideBlock;
1751	}
1752
1753	#endif // NTT_VSP_ADAPTIVE_SPLIT_E0207
1754	}
1755
1756	Void TComPrediction::xPredInterLumaBlkFromDM( TComDataCU cu, TComPicYuv picRef, TComYuv yuvDepth, Int shiftLUT, TComMv mv, UInt partAddr, Int width, Int height, Bool isDepth, TComYuv &yuvDst, Bool isBi )
1757	{
1758	Int nTxtPerDepthX = H_3D_VSP_BLOCKSIZE;
1759	Int nTxtPerDepthY = H_3D_VSP_BLOCKSIZE;
1760
1761	Int refStride = picRef->getStride();
1762	Int dstStride = yuvDst->getStride();
1763	Int depStride = yuvDepth->getStride();
1764	Int refStrideBlock = refStride * nTxtPerDepthY;
1765	Int dstStrideBlock = dstStride * nTxtPerDepthY;
1766	Int depStrideBlock = depStride * nTxtPerDepthY;
1767
1768	Pel *ref = picRef->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr );
1769	Pel *dst = yuvDst->getLumaAddr(partAddr);
1770	Pel *depth = yuvDepth->getLumaAddr();
1771
1772	#if !(NTT_VSP_DC_BUGFIX_E0208)
1773	Int widthLuma = picRef->getWidth();
1774	Int posX, posY;
1775	cu->getPic()->getPicYuvRec()->getTopLeftSamplePos( cu->getAddr(), cu->getZorderIdxInCU() + partAddr, posX, posY ); // top-left position in texture
1776	#endif
1777
1778	#if H_3D_VSP_BLOCKSIZE == 1
1779	#if H_3D_VSP_CONSTRAINED
1780	//get LUT based horizontal reference range
1781	Int range = xGetConstrainedSize(width, height);
1782
1783	// The minimum depth value
1784	Int minRelativePos = MAX_INT;
1785	Int maxRelativePos = MIN_INT;
1786
1787	Pel* depthTemp, *depthInitial=depth;
1788	for (Int yTxt = 0; yTxt < height; yTxt++)
1789	{
1790	for (Int xTxt = 0; xTxt < width; xTxt++)
1791	{
1792	if (depthPosX+xTxt < widthDepth)
1793	{
1794	depthTemp = depthInitial + xTxt;
1795	}
1796	else
1797	{
1798	depthTemp = depthInitial + (widthDepth - depthPosX - 1);
1799	}
1800
1801	Int disparity = shiftLUT[ *depthTemp ]; // << iShiftPrec;
1802	Int disparityInt = disparity >> 2;
1803
1804	if( disparity <= 0)
1805	{
1806	if (minRelativePos > disparityInt+xTxt)
1807	{
1808	minRelativePos = disparityInt+xTxt;
1809	}
1810	}
1811	else
1812	{
1813	if (maxRelativePos < disparityInt+xTxt)
1814	{
1815	maxRelativePos = disparityInt+xTxt;
1816	}
1817	}
1818	}
1819	if (depthPosY+yTxt < heightDepth)
1820	{
1821	depthInitial = depthInitial + depStride;
1822	}
1823	}
1824
1825	Int disparity_tmp = shiftLUT[ *depth ]; // << iShiftPrec;
1826	if (disparity_tmp <= 0)
1827	{
1828	maxRelativePos = minRelativePos + range -1 ;
1829	}
1830	else
1831	{
1832	minRelativePos = maxRelativePos - range +1 ;
1833	}
1834	#endif
1835	#endif // H_3D_VSP_BLOCKSIZE == 1
1836
1837	TComMv dv(0, 0);
1838
1839	for ( Int yTxt = 0; yTxt < height; yTxt += nTxtPerDepthY )
1840	{
1841	for ( Int xTxt = 0; xTxt < width; xTxt += nTxtPerDepthX )
1842	{
1843	Pel repDepth = depth[ xTxt ];
1844	assert( repDepth >= 0 && repDepth <= 255 );
1845
1846	Int disparity = shiftLUT[ repDepth ]; // remove << iShiftPrec ??
1847	Int xFrac = disparity & 0x3;
1848
1849	#if NTT_VSP_DC_BUGFIX_E0208
1850
1851	dv.setHor( disparity );
1852	cu->clipMv( dv );
1853
1854	Int refOffset = xTxt + (dv.getHor() >> 2);
1855
1856	#if H_3D_VSP_CONSTRAINED
1857	if(refOffset<minRelativePos \|\| refOffset>maxRelativePos)
1858	{
1859	xFrac = 0;
1860	}
1861	refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
1862	#endif
1863
1864	assert( ref[refOffset] >= 0 && ref[refOffset]<= 255 );
1865	m_if.filterHorLuma( &ref[refOffset], refStride, &dst[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !isBi );
1866
1867	#else // NTT_VSP_DC_BUGFIX_E0208
1868
1869	for( Int j=0; j < nTxtPerDepthX; j++ )
1870	{
1871	Int refOffset = xTxt+j + (disparity >> 2);
1872	#if H_3D_VSP_CONSTRAINED
1873	if(refOffset<minRelativePos \|\| refOffset>maxRelativePos)
1874	{
1875	xFrac = 0;
1876	}
1877	refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
1878	#endif
1879	Int absX = posX + refOffset;
1880
1881	if (xFrac == 0)
1882	{
1883	absX = Clip3(0, widthLuma-1, absX);
1884	}
1885	else
1886	{
1887	absX = Clip3(4, widthLuma-5, absX);
1888	}
1889
1890	refOffset = absX - posX;
1891	assert( ref[refOffset] >= 0 && ref[refOffset] <= 255 );
1892
1893	m_if.filterHorLuma( &ref[refOffset], refStride, &dst[xTxt+j], dstStride, 1, nTxtPerDepthY, xFrac, !isBi );
1894	}
1895
1896	#endif // NTT_VSP_DC_BUGFIX_E0208
1897
1898	}
1899	ref += refStrideBlock;
1900	dst += dstStrideBlock;
1901	depth += depStrideBlock;
1902	}
1903
1904	}
1905
1906	Void TComPrediction::xPredInterChromaBlkFromDM ( TComDataCU cu, TComPicYuv picRef, TComYuv yuvDepth, Int shiftLUT, TComMv mv, UInt partAddr, Int width, Int height, Bool isDepth, TComYuv &yuvDst, Bool isBi )
1907	{
1908	#if (H_3D_VSP_BLOCKSIZE==1)
1909	Int nTxtPerDepthX = 1;
1910	Int nTxtPerDepthY = 1;
1911	#else
1912	Int nTxtPerDepthX = H_3D_VSP_BLOCKSIZE >> 1;
1913	Int nTxtPerDepthY = H_3D_VSP_BLOCKSIZE >> 1;
1914	#endif
1915
1916	Int refStride = picRef->getCStride();
1917	Int dstStride = yuvDst->getCStride();
1918	Int depStride = yuvDepth->getStride();
1919	Int refStrideBlock = refStride * nTxtPerDepthY;
1920	Int dstStrideBlock = dstStride * nTxtPerDepthY;
1921	Int depStrideBlock = depStride * (nTxtPerDepthY<<1);
1922
1923	Pel *refCb = picRef->getCbAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr );
1924	Pel *refCr = picRef->getCrAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr );
1925	Pel *dstCb = yuvDst->getCbAddr(partAddr);
1926	Pel *dstCr = yuvDst->getCrAddr(partAddr);
1927	Pel *depth = yuvDepth->getLumaAddr();
1928
1929	#if !(NTT_VSP_DC_BUGFIX_E0208)
1930	Int widthChroma = picRef->getWidth() >> 1;
1931	Int posX, posY;
1932	cu->getPic()->getPicYuvRec()->getTopLeftSamplePos( cu->getAddr(), cu->getZorderIdxInCU() + partAddr, posX, posY ); // top-left position in texture
1933	posX >>= 1;
1934	posY >>= 1;
1935	#endif
1936
1937	#if H_3D_VSP_BLOCKSIZE == 1
1938	#if H_3D_VSP_CONSTRAINED
1939	//get LUT based horizontal reference range
1940	Int range = xGetConstrainedSize(width, height, false);
1941
1942	// The minimum depth value
1943	Int minRelativePos = MAX_INT;
1944	Int maxRelativePos = MIN_INT;
1945
1946	Int depthTmp;
1947	for (Int yTxt=0; yTxt<height; yTxt++)
1948	{
1949	for (Int xTxt=0; xTxt<width; xTxt++)
1950	{
1951	depthTmp = m_pDepthBlock[xTxt+yTxt*width];
1952	Int disparity = shiftLUT[ depthTmp ]; // << iShiftPrec;
1953	Int disparityInt = disparity >> 3;//in chroma resolution
1954
1955	if (disparityInt < 0)
1956	{
1957	if (minRelativePos > disparityInt+xTxt)
1958	{
1959	minRelativePos = disparityInt+xTxt;
1960	}
1961	}
1962	else
1963	{
1964	if (maxRelativePos < disparityInt+xTxt)
1965	{
1966	maxRelativePos = disparityInt+xTxt;
1967	}
1968	}
1969	}
1970	}
1971
1972	depthTmp = m_pDepthBlock[0];
1973	Int disparity_tmp = shiftLUT[ depthTmp ]; // << iShiftPrec;
1974	if ( disparity_tmp < 0 )
1975	{
1976	maxRelativePos = minRelativePos + range - 1;
1977	}
1978	else
1979	{
1980	minRelativePos = maxRelativePos - range + 1;
1981	}
1982
1983	#endif // H_3D_VSP_CONSTRAINED
1984	#endif // H_3D_VSP_BLOCKSIZE == 1
1985
1986	TComMv dv(0, 0);
1987	// luma size -> chroma size
1988	height >>= 1;
1989	width >>= 1;
1990
1991	for ( Int yTxt = 0; yTxt < height; yTxt += nTxtPerDepthY )
1992	{
1993	for ( Int xTxt = 0; xTxt < width; xTxt += nTxtPerDepthX )
1994	{
1995	Pel repDepth = depth[ xTxt<<1 ];
1996	assert( repDepth >= 0 && repDepth <= 255 );
1997
1998	Int disparity = shiftLUT[ repDepth ]; // remove << iShiftPrec;
1999	Int xFrac = disparity & 0x7;
2000
2001	#if NTT_VSP_DC_BUGFIX_E0208
2002
2003	dv.setHor( disparity );
2004	cu->clipMv( dv );
2005
2006	Int refOffset = xTxt + (dv.getHor() >> 3);
2007
2008	#if H_3D_VSP_CONSTRAINED
2009	if(refOffset<minRelativePos \|\| refOffset>maxRelativePos)
2010	{
2011	xFrac = 0;
2012	}
2013	refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
2014	#endif
2015
2016	assert( refCb[refOffset] >= 0 && refCb[refOffset]<= 255 );
2017	assert( refCr[refOffset] >= 0 && refCr[refOffset]<= 255 );
2018
2019	m_if.filterHorChroma( &refCb[refOffset], refStride, &dstCb[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !isBi );
2020	m_if.filterHorChroma( &refCr[refOffset], refStride, &dstCr[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !isBi );
2021
2022	#else // NTT_VSP_DC_BUGFIX_E0208
2023
2024	for( Int j=0; j < nTxtPerDepthX; j++ )
2025	{
2026	Int refOffset = xTxt+j + (disparity >> 3);
2027	#if H_3D_VSP_CONSTRAINED
2028	if(refOffset<minRelativePos \|\| refOffset>maxRelativePos)
2029	{
2030	xFrac = 0;
2031	}
2032	refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
2033	#endif
2034	Int absX = posX + refOffset;
2035
2036	if (xFrac == 0)
2037	{
2038	absX = Clip3(0, widthChroma-1, absX);
2039	}
2040	else
2041	{
2042	absX = Clip3(4, widthChroma-5, absX);
2043	}
2044
2045	refOffset = absX - posX;
2046	assert( refCb[refOffset] >= 0 && refCb[refOffset] <= 255 );
2047	assert( refCr[refOffset] >= 0 && refCr[refOffset] <= 255 );
2048
2049	m_if.filterHorChroma( &refCb[refOffset], refStride, &dstCb[xTxt+j], dstStride, 1, nTxtPerDepthY, xFrac, !isBi );
2050	m_if.filterHorChroma( &refCr[refOffset], refStride, &dstCr[xTxt+j], dstStride, 1, nTxtPerDepthY, xFrac, !isBi );
2051	}
2052
2053	#endif // NTT_VSP_DC_BUGFIX_E0208
2054	}
2055	refCb += refStrideBlock;
2056	refCr += refStrideBlock;
2057	dstCb += dstStrideBlock;
2058	dstCr += dstStrideBlock;
2059	depth += depStrideBlock;
2060	}
2061
2062	}
2063	#else // NTT_VSP_COMMON_E0207_E0208
2064
2065	// Input:
2066	// refPic: Ref picture. Full picture, with padding
2067	// posX, posY: PU position, texture
2068	// sizeX, sizeY: PU size
2069	// partAddr: z-order index
2070	// dv: disparity vector. derived from neighboring blocks
2071	//
2072	// Output: dstPic, PU predictor 64x64
2073	Void TComPrediction::xPredInterLumaBlkFromDM( TComPicYuv refPic, TComPicYuv pPicBaseDepth, Int* pShiftLUT, TComMv* dv, UInt partAddr,Int posX, Int posY
2074	, Int sizeX, Int sizeY, Bool isDepth, TComYuv *&dstPic, Bool bi )
2075	{
2076	Int widthLuma;
2077	Int heightLuma;
2078
2079	if (isDepth)
2080	{
2081	widthLuma = pPicBaseDepth->getWidth();
2082	heightLuma = pPicBaseDepth->getHeight();
2083	}
2084	else
2085	{
2086	widthLuma = refPic->getWidth();
2087	heightLuma = refPic->getHeight();
2088	}
2089
2090	#if H_3D_VSP_BLOCKSIZE != 1
2091	Int widthDepth = pPicBaseDepth->getWidth();
2092	Int heightDepth = pPicBaseDepth->getHeight();
2093	#endif
2094
2095	#if H_3D_VSP_CONSTRAINED
2096	Int widthDepth = pPicBaseDepth->getWidth();
2097	Int heightDepth = pPicBaseDepth->getHeight();
2098	#endif
2099
2100	Int nTxtPerDepthX = widthLuma / ( pPicBaseDepth->getWidth() ); // texture pixel # per depth pixel
2101	Int nTxtPerDepthY = heightLuma / ( pPicBaseDepth->getHeight() );
2102
2103	Int refStride = refPic->getStride();
2104	Int dstStride = dstPic->getStride();
2105	Int depStride = pPicBaseDepth->getStride();
2106	Int depthPosX = Clip3(0, widthLuma - sizeX, (posX/nTxtPerDepthX) + ((dv->getHor()+2)>>2));
2107	Int depthPosY = Clip3(0, heightLuma- sizeY, (posY/nTxtPerDepthY) + ((dv->getVer()+2)>>2));
2108	Pel ref = refPic->getLumaAddr() + posX + posY refStride;
2109	Pel *dst = dstPic->getLumaAddr(partAddr);
2110	Pel depth = pPicBaseDepth->getLumaAddr() + depthPosX + depthPosY depStride;
2111
2112	#if H_3D_VSP_BLOCKSIZE != 1
2113	#if H_3D_VSP_BLOCKSIZE == 2
2114	Int dW = sizeX>>1;
2115	Int dH = sizeY>>1;
2116	#endif
2117	#if H_3D_VSP_BLOCKSIZE == 4
2118	Int dW = sizeX>>2;
2119	Int dH = sizeY>>2;
2120	#endif
2121	{
2122	Pel* depthi = depth;
2123	for (Int j = 0; j < dH; j++)
2124	{
2125	for (Int i = 0; i < dW; i++)
2126	{
2127	Pel* depthTmp;
2128	#if H_3D_VSP_BLOCKSIZE == 2
2129	if (depthPosX + (i<<1) < widthDepth)
2130	depthTmp = depthi + (i << 1);
2131	else
2132	depthTmp = depthi + (widthDepth - depthPosX - 1);
2133	#endif
2134	#if H_3D_VSP_BLOCKSIZE == 4
2135	if (depthPosX + (i<<2) < widthDepth)
2136	depthTmp = depthi + (i << 2);
2137	else
2138	depthTmp = depthi + (widthDepth - depthPosX - 1);
2139	#endif
2140	Int maxV = 0;
2141	for (Int blockj = 0; blockj < H_3D_VSP_BLOCKSIZE; blockj+=(H_3D_VSP_BLOCKSIZE-1))
2142	{
2143	Int iX = 0;
2144	for (Int blocki = 0; blocki < H_3D_VSP_BLOCKSIZE; blocki+=(H_3D_VSP_BLOCKSIZE-1))
2145	{
2146	if (maxV < depthTmp[iX])
2147	maxV = depthTmp[iX];
2148	#if H_3D_VSP_BLOCKSIZE == 2
2149	if (depthPosX + (i<<1) + blocki < widthDepth - 1)
2150	#else // H_3D_VSP_BLOCKSIZE == 4
2151	if (depthPosX + (i<<2) + blocki < widthDepth - 1)
2152	#endif
2153	iX = (H_3D_VSP_BLOCKSIZE-1);
2154	}
2155	#if H_3D_VSP_BLOCKSIZE == 2
2156	if (depthPosY + (j<<1) + blockj < heightDepth - 1)
2157	#else // H_3D_VSP_BLOCKSIZE == 4
2158	if (depthPosY + (j<<2) + blockj < heightDepth - 1)
2159	#endif
2160	depthTmp += depStride * (H_3D_VSP_BLOCKSIZE-1);
2161	}
2162	m_pDepthBlock[i+j*dW] = maxV;
2163	} // end of i < dW
2164	#if H_3D_VSP_BLOCKSIZE == 2
2165	if (depthPosY + ((j+1)<<1) < heightDepth)
2166	depthi += (depStride << 1);
2167	else
2168	depthi = depth + (heightDepth-depthPosY-1)*depStride;
2169	#endif
2170	#if H_3D_VSP_BLOCKSIZE == 4
2171	if (depthPosY + ((j+1)<<2) < heightDepth) // heightDepth-1
2172	depthi += (depStride << 2);
2173	else
2174	depthi = depth + (heightDepth-depthPosY-1)*depStride; // the last line
2175	#endif
2176	}
2177	}
2178	#endif // H_3D_VSP_BLOCKSIZE != 1
2179
2180	#if H_3D_VSP_BLOCKSIZE == 1
2181	#if H_3D_VSP_CONSTRAINED
2182	//get LUT based horizontal reference range
2183	Int range = xGetConstrainedSize(sizeX, sizeY);
2184
2185	// The minimum depth value
2186	Int minRelativePos = MAX_INT;
2187	Int maxRelativePos = MIN_INT;
2188
2189	Pel* depthTemp, *depthInitial=depth;
2190	for (Int yTxt = 0; yTxt < sizeY; yTxt++)
2191	{
2192	for (Int xTxt = 0; xTxt < sizeX; xTxt++)
2193	{
2194	if (depthPosX+xTxt < widthDepth)
2195	depthTemp = depthInitial + xTxt;
2196	else
2197	depthTemp = depthInitial + (widthDepth - depthPosX - 1);
2198
2199	Int disparity = pShiftLUT[ *depthTemp ]; // << iShiftPrec;
2200	Int disparityInt = disparity >> 2;
2201
2202	if( disparity <= 0)
2203	{
2204	if (minRelativePos > disparityInt+xTxt)
2205	minRelativePos = disparityInt+xTxt;
2206	}
2207	else
2208	{
2209	if (maxRelativePos < disparityInt+xTxt)
2210	maxRelativePos = disparityInt+xTxt;
2211	}
2212	}
2213	if (depthPosY+yTxt < heightDepth)
2214	depthInitial = depthInitial + depStride;
2215	}
2216
2217	Int disparity_tmp = pShiftLUT[ *depth ]; // << iShiftPrec;
2218	if (disparity_tmp <= 0)
2219	maxRelativePos = minRelativePos + range -1 ;
2220	else
2221	minRelativePos = maxRelativePos - range +1 ;
2222	#endif
2223	#endif // H_3D_VSP_BLOCKSIZE == 1
2224
2225	#if H_3D_VSP_BLOCKSIZE != 1
2226	Int yDepth = 0;
2227	#endif
2228	for ( Int yTxt = 0; yTxt < sizeY; yTxt += nTxtPerDepthY )
2229	{
2230	for ( Int xTxt = 0, xDepth = 0; xTxt < sizeX; xTxt += nTxtPerDepthX, xDepth++ )
2231	{
2232	Pel repDepth = 0; // to store the depth value used for warping
2233	#if H_3D_VSP_BLOCKSIZE == 1
2234	repDepth = depth[xDepth];
2235	#endif
2236	#if H_3D_VSP_BLOCKSIZE == 2
2237	repDepth = m_pDepthBlock[(xTxt>>1) + (yTxt>>1)*dW];
2238	#endif
2239	#if H_3D_VSP_BLOCKSIZE == 4
2240	repDepth = m_pDepthBlock[(xTxt>>2) + (yTxt>>2)*dW];
2241	#endif
2242
2243	assert( repDepth >= 0 && repDepth <= 255 );
2244	Int disparity = pShiftLUT[ repDepth ]; // remove << iShiftPrec ??
2245	Int refOffset = xTxt + (disparity >> 2);
2246	Int xFrac = disparity & 0x3;
2247	#if H_3D_VSP_CONSTRAINED
2248	if(refOffset<minRelativePos \|\| refOffset>maxRelativePos)
2249	xFrac = 0;
2250	refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
2251	#endif
2252	Int absX = posX + refOffset;
2253
2254	if (xFrac == 0)
2255	absX = Clip3(0, widthLuma-1, absX);
2256	else
2257	absX = Clip3(4, widthLuma-5, absX);
2258
2259	refOffset = absX - posX;
2260
2261	assert( ref[refOffset] >= 0 && ref[refOffset]<= 255 );
2262	m_if.filterHorLuma( &ref[refOffset], refStride, &dst[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !bi );
2263	}
2264	ref += refStride*nTxtPerDepthY;
2265	dst += dstStride*nTxtPerDepthY;
2266	depth += depStride;
2267	#if H_3D_VSP_BLOCKSIZE != 1
2268	yDepth++;
2269	#endif
2270
2271	}
2272	}
2273
2274	Void TComPrediction::xPredInterChromaBlkFromDM ( TComPicYuv refPic, TComPicYuv pPicBaseDepth, Int* pShiftLUT, TComMv*dv, UInt partAddr, Int posX, Int posY
2275	, Int sizeX, Int sizeY, Bool isDepth, TComYuv *&dstPic, Bool bi)
2276	{
2277	Int refStride = refPic->getCStride();
2278	Int dstStride = dstPic->getCStride();
2279	Int depStride = pPicBaseDepth->getStride();
2280
2281	Int widthChroma, heightChroma;
2282	if( isDepth)
2283	{
2284	widthChroma = pPicBaseDepth->getWidth()>>1;
2285	heightChroma = pPicBaseDepth->getHeight()>>1;
2286	}
2287	else
2288	{
2289	widthChroma = refPic->getWidth()>>1;
2290	heightChroma = refPic->getHeight()>>1;
2291	}
2292
2293	// Below is only for Texture chroma component
2294
2295	Int widthDepth = pPicBaseDepth->getWidth();
2296	Int heightDepth = pPicBaseDepth->getHeight();
2297
2298	Int nTxtPerDepthX, nTxtPerDepthY; // Number of texture samples per one depth sample
2299	Int nDepthPerTxtX, nDepthPerTxtY; // Number of depth samples per one texture sample
2300
2301	Int depthPosX; // Starting position in depth image
2302	Int depthPosY;
2303
2304	if ( widthChroma > widthDepth )
2305	{
2306	nTxtPerDepthX = widthChroma / widthDepth;
2307	nDepthPerTxtX = 1;
2308	depthPosX = posX / nTxtPerDepthX + ((dv->getHor()+2)>>2);
2309	}
2310	else
2311	{
2312	nTxtPerDepthX = 1;
2313	nDepthPerTxtX = widthDepth / widthChroma;
2314	depthPosX = posX * nDepthPerTxtX + ((dv->getHor()+2)>>2);
2315	}
2316	depthPosX = Clip3(0, widthDepth - (sizeX<<1), depthPosX);
2317	if ( heightChroma > heightDepth )
2318	{
2319	nTxtPerDepthY = heightChroma / heightDepth;
2320	nDepthPerTxtY = 1;
2321	depthPosY = posY / nTxtPerDepthY + ((dv->getVer()+2)>>2);
2322	}
2323	else
2324	{
2325	nTxtPerDepthY = 1;
2326	nDepthPerTxtY = heightDepth / heightChroma;
2327	depthPosY = posY * nDepthPerTxtY + ((dv->getVer()+2)>>2);
2328	}
2329	depthPosY = Clip3(0, heightDepth - (sizeY<<1), depthPosY);
2330
2331	Pel refCb = refPic->getCbAddr() + posX + posY refStride;
2332	Pel refCr = refPic->getCrAddr() + posX + posY refStride;
2333	Pel *dstCb = dstPic->getCbAddr(partAddr);
2334	Pel *dstCr = dstPic->getCrAddr(partAddr);
2335	Pel depth = pPicBaseDepth->getLumaAddr() + depthPosX + depthPosY depStride; // move the pointer to the current depth pixel position
2336
2337	Int refStrideBlock = refStride * nTxtPerDepthY;
2338	Int dstStrideBlock = dstStride * nTxtPerDepthY;
2339	Int depStrideBlock = depStride * nDepthPerTxtY;
2340
2341	if ( widthChroma > widthDepth ) // We assume
2342	{
2343	assert( heightChroma > heightDepth );
2344	printf("This branch should never been reached.\n");
2345	exit(0);
2346	}
2347	else
2348	{
2349	#if H_3D_VSP_BLOCKSIZE == 1
2350	Int dW = sizeX;
2351	Int dH = sizeY;
2352	Int sW = 2; // search window size
2353	Int sH = 2;
2354	#endif
2355	#if H_3D_VSP_BLOCKSIZE == 2
2356	Int dW = sizeX;
2357	Int dH = sizeY;
2358	Int sW = 2; // search window size
2359	Int sH = 2;
2360	#endif
2361	#if H_3D_VSP_BLOCKSIZE == 4
2362	Int dW = sizeX>>1;
2363	Int dH = sizeY>>1;
2364	Int sW = 4; // search window size
2365	Int sH = 4;
2366	#endif
2367
2368	{
2369	Pel* depthi = depth;
2370	for (Int j = 0; j < dH; j++)
2371	{
2372	for (Int i = 0; i < dW; i++)
2373	{
2374	Pel* depthTmp;
2375	#if H_3D_VSP_BLOCKSIZE == 1
2376	depthTmp = depthi + (i << 1);
2377	#endif
2378	#if H_3D_VSP_BLOCKSIZE == 2
2379	if (depthPosX + (i<<1) < widthDepth)
2380	depthTmp = depthi + (i << 1);
2381	else
2382	depthTmp = depthi + (widthDepth - depthPosX - 1);
2383	#endif
2384	#if H_3D_VSP_BLOCKSIZE == 4
2385	if (depthPosX + (i<<2) < widthDepth)
2386	depthTmp = depthi + (i << 2);
2387	else
2388	depthTmp = depthi + (widthDepth - depthPosX - 1);
2389	#endif
2390	Int maxV = 0;
2391	for (Int blockj = 0; blockj < sH; blockj+=(sH-1))
2392	{
2393	Int iX = 0;
2394	for (Int blocki = 0; blocki < sW; blocki+=(sW-1))
2395	{
2396	if (maxV < depthTmp[iX])
2397	maxV = depthTmp[iX];
2398	if (depthPosX + i*sW + blocki < widthDepth - 1)
2399	iX = (sW-1);
2400	}
2401	if (depthPosY + j*sH + blockj < heightDepth - 1)
2402	depthTmp += depStride * (sH-1);
2403	}
2404	m_pDepthBlock[i+j*dW] = maxV;
2405	} // end of i < dW
2406	#if H_3D_VSP_BLOCKSIZE == 1
2407	if (depthPosY + ((j+1)<<1) < heightDepth)
2408	depthi += (depStride << 1);
2409	else
2410	depthi = depth + (heightDepth-1)*depStride;
2411	#endif
2412	#if H_3D_VSP_BLOCKSIZE == 2
2413	if (depthPosY + ((j+1)<<1) < heightDepth)
2414	depthi += (depStride << 1);
2415	else
2416	depthi = depth + (heightDepth-depthPosY-1)*depStride;
2417	#endif
2418	#if H_3D_VSP_BLOCKSIZE == 4
2419	if (depthPosY + ((j+1)<<2) < heightDepth) // heightDepth-1
2420	depthi += (depStride << 2);
2421	else
2422	depthi = depth + (heightDepth-depthPosY-1)*depStride; // the last line
2423	#endif
2424	}
2425	}
2426
2427
2428	#if H_3D_VSP_BLOCKSIZE == 1
2429	#if H_3D_VSP_CONSTRAINED
2430	//get LUT based horizontal reference range
2431	Int range = xGetConstrainedSize(sizeX, sizeY, false);
2432
2433	// The minimum depth value
2434	Int minRelativePos = MAX_INT;
2435	Int maxRelativePos = MIN_INT;
2436
2437	Int depthTmp;
2438	for (Int yTxt=0; yTxt<sizeY; yTxt++)
2439	{
2440	for (Int xTxt=0; xTxt<sizeX; xTxt++)
2441	{
2442	depthTmp = m_pDepthBlock[xTxt+yTxt*dW];
2443	Int disparity = pShiftLUT[ depthTmp ]; // << iShiftPrec;
2444	Int disparityInt = disparity >> 3;//in chroma resolution
2445
2446	if (disparityInt < 0)
2447	{
2448	if (minRelativePos > disparityInt+xTxt)
2449	minRelativePos = disparityInt+xTxt;
2450	}
2451	else
2452	{
2453	if (maxRelativePos < disparityInt+xTxt)
2454	maxRelativePos = disparityInt+xTxt;
2455	}
2456	}
2457	}
2458
2459	depthTmp = m_pDepthBlock[0];
2460	Int disparity_tmp = pShiftLUT[ depthTmp ]; // << iShiftPrec;
2461	if ( disparity_tmp < 0 )
2462	maxRelativePos = minRelativePos + range - 1;
2463	else
2464	minRelativePos = maxRelativePos - range + 1;
2465
2466	#endif // H_3D_VSP_CONSTRAINED
2467	#endif // H_3D_VSP_BLOCKSIZE == 1
2468
2469	// (sizeX, sizeY) is Chroma block size
2470	for ( Int yTxt = 0, yDepth = 0; yTxt < sizeY; yTxt += nTxtPerDepthY, yDepth += nDepthPerTxtY )
2471	{
2472	for ( Int xTxt = 0, xDepth = 0; xTxt < sizeX; xTxt += nTxtPerDepthX, xDepth += nDepthPerTxtX )
2473	{
2474	Pel repDepth = 0; // to store the depth value used for warping
2475	#if H_3D_VSP_BLOCKSIZE == 1
2476	repDepth = m_pDepthBlock[(xTxt) + (yTxt)*dW];
2477	#endif
2478	#if H_3D_VSP_BLOCKSIZE == 2
2479	repDepth = m_pDepthBlock[(xTxt) + (yTxt)*dW];
2480	#endif
2481	#if H_3D_VSP_BLOCKSIZE == 4
2482	repDepth = m_pDepthBlock[(xTxt>>1) + (yTxt>>1)*dW];
2483	#endif
2484
2485	// calculate the offset in the reference picture
2486	Int disparity = pShiftLUT[ repDepth ]; // Remove << iShiftPrec;
2487	Int refOffset = xTxt + (disparity >> 3); // in integer pixel in chroma image
2488	Int xFrac = disparity & 0x7;
2489	#if H_3D_VSP_CONSTRAINED
2490	if(refOffset < minRelativePos \|\| refOffset > maxRelativePos)
2491	xFrac = 0;
2492	refOffset = Clip3(minRelativePos, maxRelativePos, refOffset);
2493	#endif
2494	Int absX = posX + refOffset;
2495
2496	if (xFrac == 0)
2497	absX = Clip3(0, widthChroma-1, absX);
2498	else
2499	absX = Clip3(4, widthChroma-5, absX);
2500
2501	refOffset = absX - posX;
2502
2503	assert( refCb[refOffset] >= 0 && refCb[refOffset]<= 255 );
2504	assert( refCr[refOffset] >= 0 && refCr[refOffset]<= 255 );
2505	m_if.filterHorChroma(&refCb[refOffset], refStride, &dstCb[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !bi);
2506	m_if.filterHorChroma(&refCr[refOffset], refStride, &dstCr[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, !bi);
2507	}
2508	refCb += refStrideBlock;
2509	refCr += refStrideBlock;
2510	dstCb += dstStrideBlock;
2511	dstCr += dstStrideBlock;
2512	depth += depStrideBlock;
2513	}
2514	}
2515
2516	}
2517
2518	#endif // NTT_VSP_COMMON_E0207_E0208
2519
2520	#if H_3D_VSP_CONSTRAINED
2521	Int TComPrediction::xGetConstrainedSize(Int nPbW, Int nPbH, Bool bLuma)
2522	{
2523	Int iSize = 0;
2524	if (bLuma)
2525	{
2526	Int iArea = (nPbW+7) * (nPbH+7);
2527	Int iAlpha = iArea / nPbH - nPbW - 7;
2528	iSize = iAlpha + nPbW;
2529	}
2530	else // chroma
2531	{
2532	Int iArea = (nPbW+2) * (nPbH+2);
2533	Int iAlpha = iArea / nPbH - nPbW - 4;
2534	iSize = iAlpha + nPbW;
2535	}
2536	return iSize;
2537	}
2538	#endif // H_3D_VSP_CONSTRAINED
2539
2540	#endif // H_3D_VSP
2541
2542	#if H_3D_DIM
2543	Void TComPrediction::xPredBiSegDCs( Int* ptrSrc, UInt srcStride, Bool* biSegPattern, Int patternStride, Pel& predDC1, Pel& predDC2 )
2544	{
2545	Int refDC1, refDC2;
2546	const Int iTR = ( patternStride - 1 ) - srcStride;
2547	const Int iTM = ( ( patternStride - 1 ) >> 1 ) - srcStride;
2548	const Int iLB = ( patternStride - 1 ) * srcStride - 1;
2549	const Int iLM = ( ( patternStride - 1 ) >> 1 ) * srcStride - 1;
2550
2551	Bool bL = ( biSegPattern[0] != biSegPattern[(patternStride-1)*patternStride] );
2552	Bool bT = ( biSegPattern[0] != biSegPattern[(patternStride-1)] );
2553
2554	if( bL == bT )
2555	{
2556	refDC1 = bL ? ( ptrSrc[iTR] + ptrSrc[iLB] )>>1 : 1<<( g_bitDepthY - 1 );
2557	refDC2 = ( ptrSrc[ -1] + ptrSrc[-(Int)srcStride] )>>1;
2558	}
2559	else
2560	{
2561	refDC1 = bL ? ptrSrc[iLB] : ptrSrc[iTR];
2562	refDC2 = bL ? ptrSrc[iTM] : ptrSrc[iLM];
2563	}
2564
2565	predDC1 = biSegPattern[0] ? refDC1 : refDC2;
2566	predDC2 = biSegPattern[0] ? refDC2 : refDC1;
2567	}
2568
2569	Void TComPrediction::xAssignBiSegDCs( Pel* ptrDst, UInt dstStride, Bool* biSegPattern, Int patternStride, Pel valDC1, Pel valDC2 )
2570	{
2571	if( dstStride == patternStride )
2572	{
2573	for( UInt k = 0; k < (patternStride * patternStride); k++ )
2574	{
2575	if( true == biSegPattern[k] ) { ptrDst[k] = valDC2; }
2576	else { ptrDst[k] = valDC1; }
2577	}
2578	}
2579	else
2580	{
2581	Pel* piTemp = ptrDst;
2582	for( UInt uiY = 0; uiY < patternStride; uiY++ )
2583	{
2584	for( UInt uiX = 0; uiX < patternStride; uiX++ )
2585	{
2586	if( true == biSegPattern[uiX] ) { piTemp[uiX] = valDC2; }
2587	else { piTemp[uiX] = valDC1; }
2588	}
2589	piTemp += dstStride;
2590	biSegPattern += patternStride;
2591	}
2592	}
2593	}
2594
2595	#if H_3D_DIM_DMM
2596	UInt TComPrediction::xPredWedgeFromIntra( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd )
2597	{
2598	UInt uiThisBlockSize = uiWidth;
2599
2600	TComDataCU* pcTempCU;
2601	UInt uiTempPartIdx;
2602	// 1st: try continue above wedgelet
2603	pcTempCU = pcCU->getPUAbove( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
2604	if( pcTempCU && isDimMode( pcTempCU->getLumaIntraDir( uiTempPartIdx ) ) )
2605	{
2606	UInt dimType = getDimType( pcTempCU->getLumaIntraDir( uiTempPartIdx ) );
2607	if( DMM1_IDX == dimType \|\| DMM2_IDX == dimType \|\| DMM3_IDX == dimType )
2608	{
2609	// get offset between current and reference block
2610	UInt uiOffsetX = 0, uiOffsetY = 0;
2611	xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
2612
2613	// get reference wedgelet
2614	WedgeList* pacWedgeList = &g_dmmWedgeLists[(g_aucConvertToBit[(pcTempCU->getWidth( uiTempPartIdx )>>((pcTempCU->getPartitionSize( uiTempPartIdx ) == SIZE_NxN) ? 1 : 0))])];
2615	TComWedgelet* pcRefWedgelet = &(pacWedgeList->at( pcTempCU->getDmmWedgeTabIdx( dimType, uiTempPartIdx ) ) );
2616
2617	// find wedgelet, if direction is suitable for continue wedge
2618	if( pcRefWedgelet->checkPredDirAbovePossible( uiThisBlockSize, uiOffsetX ) )
2619	{
2620	UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
2621	pcRefWedgelet->getPredDirStartEndAbove( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetX, iDeltaEnd );
2622	return xGetWedgePatternIdx( uiThisBlockSize, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
2623	}
2624	}
2625	}
2626
2627	// 2nd: try continue left wedglelet
2628	pcTempCU = pcCU->getPULeft( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
2629	if( pcTempCU && isDimMode( pcTempCU->getLumaIntraDir( uiTempPartIdx ) ) )
2630	{
2631	UInt dimType = getDimType( pcTempCU->getLumaIntraDir( uiTempPartIdx ) );
2632	if( DMM1_IDX == dimType \|\| DMM2_IDX == dimType \|\| DMM3_IDX == dimType )
2633	{
2634	// get offset between current and reference block
2635	UInt uiOffsetX = 0, uiOffsetY = 0;
2636	xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
2637
2638	// get reference wedgelet
2639	WedgeList* pacWedgeList = &g_dmmWedgeLists[(g_aucConvertToBit[(pcTempCU->getWidth( uiTempPartIdx )>>((pcTempCU->getPartitionSize( uiTempPartIdx ) == SIZE_NxN) ? 1 : 0))])];
2640	TComWedgelet* pcRefWedgelet = &(pacWedgeList->at( pcTempCU->getDmmWedgeTabIdx( dimType, uiTempPartIdx ) ) );
2641
2642	// find wedgelet, if direction is suitable for continue wedge
2643	if( pcRefWedgelet->checkPredDirLeftPossible( uiThisBlockSize, uiOffsetY ) )
2644	{
2645	UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
2646	pcRefWedgelet->getPredDirStartEndLeft( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetY, iDeltaEnd );
2647	return xGetWedgePatternIdx( uiThisBlockSize, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
2648	}
2649	}
2650	}
2651
2652	// 3rd: (default) make wedglet from intra dir and max slope point
2653	Int iSlopeX = 0, iSlopeY = 0;
2654	UInt uiStartPosX = 0, uiStartPosY = 0;
2655	if( xGetWedgeIntraDirPredData( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY ) )
2656	{
2657	UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
2658	xGetWedgeIntraDirStartEnd( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, iDeltaEnd );
2659	return xGetWedgePatternIdx( uiThisBlockSize, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
2660	}
2661
2662	return 0;
2663	}
2664
2665	UInt TComPrediction::xPredWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt intraTabIdx )
2666	{
2667	TComPic* pcPicTex = pcCU->getSlice()->getTexturePic();
2668	assert( pcPicTex != NULL );
2669	TComDataCU* pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
2670	UInt uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
2671	Int uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
2672
2673	if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 ) { return g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]][uiColTexIntraDir-2].at(intraTabIdx); }
2674	else { return g_dmmWedgeNodeLists[(g_aucConvertToBit[uiWidth])].at(intraTabIdx).getPatternIdx(); }
2675	}
2676
2677	Void TComPrediction::xPredContourFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge )
2678	{
2679	pcContourWedge->clear();
2680
2681	// get copy of co-located texture luma block
2682	TComYuv cTempYuv;
2683	cTempYuv.create( uiWidth, uiHeight );
2684	cTempYuv.clear();
2685	Pel* piRefBlkY = cTempYuv.getLumaAddr();
2686	xCopyTextureLumaBlock( pcCU, uiAbsPartIdx, piRefBlkY, uiWidth, uiHeight );
2687	piRefBlkY = cTempYuv.getLumaAddr();
2688
2689	// find contour for texture luma block
2690	UInt iDC = 0;
2691	for( UInt k = 0; k < (uiWidth*uiHeight); k++ )
2692	{
2693	iDC += piRefBlkY[k];
2694	}
2695	iDC /= (uiWidth*uiHeight);
2696	piRefBlkY = cTempYuv.getLumaAddr();
2697
2698	Bool* pabContourPattern = pcContourWedge->getPattern();
2699	for( UInt k = 0; k < (uiWidth*uiHeight); k++ )
2700	{
2701	pabContourPattern[k] = (piRefBlkY[k] > iDC) ? true : false;
2702	}
2703
2704	cTempYuv.destroy();
2705	}
2706
2707
2708	Void TComPrediction::xCopyTextureLumaBlock( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight )
2709	{
2710	TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getTexturePic()->getPicYuvRec();
2711	assert( pcPicYuvRef != NULL );
2712	Int iRefStride = pcPicYuvRef->getStride();
2713	Pel* piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx );
2714
2715	for ( Int y = 0; y < uiHeight; y++ )
2716	{
2717	::memcpy(piDestBlockY, piRefY, sizeof(Pel)*uiWidth);
2718	piDestBlockY += uiWidth;
2719	piRefY += iRefStride;
2720	}
2721	}
2722
2723	Void TComPrediction::xGetBlockOffset( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY )
2724	{
2725	ruiOffsetX = 0;
2726	ruiOffsetY = 0;
2727
2728	// get offset between current and above/left block
2729	UInt uiThisOriginX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
2730	UInt uiThisOriginY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
2731
2732	UInt uiNumPartInRefCU = pcRefCU->getTotalNumPart();
2733	UInt uiMaxDepthRefCU = 0;
2734	while( uiNumPartInRefCU > 1 )
2735	{
2736	uiNumPartInRefCU >>= 2;
2737	uiMaxDepthRefCU++;
2738	}
2739
2740	UInt uiDepthRefPU = (pcRefCU->getDepth(uiRefAbsPartIdx)) + (pcRefCU->getPartitionSize(uiRefAbsPartIdx) == SIZE_2Nx2N ? 0 : 1);
2741	UInt uiShifts = (uiMaxDepthRefCU - uiDepthRefPU)*2;
2742	UInt uiRefBlockOriginPartIdx = (uiRefAbsPartIdx>>uiShifts)<<uiShifts;
2743
2744	UInt uiRefOriginX = pcRefCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
2745	UInt uiRefOriginY = pcRefCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
2746
2747	if( (uiThisOriginX - uiRefOriginX) > 0 ) { ruiOffsetX = (UInt)(uiThisOriginX - uiRefOriginX); }
2748	if( (uiThisOriginY - uiRefOriginY) > 0 ) { ruiOffsetY = (UInt)(uiThisOriginY - uiRefOriginY); }
2749	}
2750
2751	Bool TComPrediction::xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY )
2752	{
2753	riSlopeX = 0, riSlopeY = 0, ruiStartPosX = 0, ruiStartPosY = 0;
2754
2755	// 1st step: get wedge start point (max. slope)
2756	Int* piSource = pcCU->getPattern()->getAdiOrgBuf( uiBlockSize, uiBlockSize, m_piYuvExt );
2757	Int iSourceStride = ( uiBlockSize<<1 ) + 1;
2758
2759	UInt uiSlopeMaxAbove = 0, uiPosSlopeMaxAbove = 0;
2760	for( UInt uiPosHor = 0; uiPosHor < (uiBlockSize-1); uiPosHor++ )
2761	{
2762	if( abs( piSource[uiPosHor+1] - piSource[uiPosHor] ) > uiSlopeMaxAbove )
2763	{
2764	uiSlopeMaxAbove = abs( piSource[uiPosHor+1] - piSource[uiPosHor] );
2765	uiPosSlopeMaxAbove = uiPosHor;
2766	}
2767	}
2768
2769	UInt uiSlopeMaxLeft = 0, uiPosSlopeMaxLeft = 0;
2770	for( UInt uiPosVer = 0; uiPosVer < (uiBlockSize-1); uiPosVer++ )
2771	{
2772	if( abs( piSource[(uiPosVer+1)iSourceStride] - piSource[uiPosVeriSourceStride] ) > uiSlopeMaxLeft )
2773	{
2774	uiSlopeMaxLeft = abs( piSource[(uiPosVer+1)iSourceStride] - piSource[uiPosVeriSourceStride] );
2775	uiPosSlopeMaxLeft = uiPosVer;
2776	}
2777	}
2778
2779	if( uiSlopeMaxAbove == 0 && uiSlopeMaxLeft == 0 )
2780	{
2781	return false;
2782	}
2783
2784	ruiStartPosX = ( uiSlopeMaxAbove > uiSlopeMaxLeft ) ? uiPosSlopeMaxAbove : 0;
2785	ruiStartPosY = ( uiSlopeMaxLeft >= uiSlopeMaxAbove ) ? uiPosSlopeMaxLeft : 0;
2786
2787	// 2nd step: derive wedge direction
2788	Int uiPreds[3] = {-1, -1, -1};
2789	Int iMode = -1;
2790	Int iPredNum = pcCU->getIntraDirLumaPredictor( uiAbsPartIdx, uiPreds, &iMode );
2791
2792	UInt uiDirMode = 0;
2793	if( iMode >= 0 ) { iPredNum = iMode; }
2794	if( iPredNum == 1 ) { uiDirMode = uiPreds[0]; }
2795	if( iPredNum == 2 ) { uiDirMode = uiPreds[1]; }
2796
2797	if( uiDirMode < 2 ) { return false; } // no planar & DC
2798
2799	Bool modeHor = (uiDirMode < 18);
2800	Bool modeVer = !modeHor;
2801	Int intraPredAngle = modeVer ? (Int)uiDirMode - VER_IDX : modeHor ? -((Int)uiDirMode - HOR_IDX) : 0;
2802	Int absAng = abs(intraPredAngle);
2803	Int signAng = intraPredAngle < 0 ? -1 : 1;
2804	Int angTable[9] = {0,2,5,9,13,17,21,26,32};
2805	absAng = angTable[absAng];
2806	intraPredAngle = signAng * absAng;
2807
2808	// 3rd step: set slope for direction
2809	if( modeHor )
2810	{
2811	riSlopeX = ( intraPredAngle > 0 ) ? -32 : 32;
2812	riSlopeY = ( intraPredAngle > 0 ) ? intraPredAngle : -intraPredAngle;
2813	}
2814	else if( modeVer )
2815	{
2816	riSlopeX = ( intraPredAngle > 0 ) ? intraPredAngle : -intraPredAngle;
2817	riSlopeY = ( intraPredAngle > 0 ) ? -32 : 32;
2818	}
2819
2820	return true;
2821	}
2822
2823	Void TComPrediction::xGetWedgeIntraDirStartEnd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int iDeltaX, Int iDeltaY, UInt uiPMSPosX, UInt uiPMSPosY, UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, Int iDeltaEnd )
2824	{
2825	ruhXs = 0;
2826	ruhYs = 0;
2827	ruhXe = 0;
2828	ruhYe = 0;
2829
2830	// scaling of start pos and block size to wedge resolution
2831	UInt uiScaledStartPosX = 0;
2832	UInt uiScaledStartPosY = 0;
2833	UInt uiScaledBlockSize = 0;
2834	WedgeResolution eWedgeRes = g_dmmWedgeResolution[(UInt)g_aucConvertToBit[uiBlockSize]];
2835	switch( eWedgeRes )
2836	{
2837	case( DOUBLE_PEL ): { uiScaledStartPosX = (uiPMSPosX>>1); uiScaledStartPosY = (uiPMSPosY>>1); uiScaledBlockSize = (uiBlockSize>>1); break; }
2838	case( FULL_PEL ): { uiScaledStartPosX = uiPMSPosX; uiScaledStartPosY = uiPMSPosY; uiScaledBlockSize = uiBlockSize; break; }
2839	case( HALF_PEL ): { uiScaledStartPosX = (uiPMSPosX<<1); uiScaledStartPosY = (uiPMSPosY<<1); uiScaledBlockSize = (uiBlockSize<<1); break; }
2840	}
2841	Int iMaxPos = (Int)uiScaledBlockSize - 1;
2842
2843	// case above
2844	if( uiScaledStartPosX > 0 && uiScaledStartPosY == 0 )
2845	{
2846	ruhXs = (UChar)uiScaledStartPosX;
2847	ruhYs = 0;
2848
2849	if( iDeltaY == 0 )
2850	{
2851	if( iDeltaX < 0 )
2852	{
2853	ruhXe = 0;
2854	ruhYe = (UChar)std::min( std::max( iDeltaEnd, 0 ), iMaxPos );
2855	return;
2856	}
2857	else
2858	{
2859	ruhXe = (UChar)iMaxPos;
2860	ruhYe = (UChar)std::min( std::max( -iDeltaEnd, 0 ), iMaxPos );
2861	std::swap( ruhXs, ruhXe );
2862	std::swap( ruhYs, ruhYe );
2863	return;
2864	}
2865	}
2866
2867	// regular case
2868	Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)iMaxPos * ((Double)iDeltaX / (Double)iDeltaY) );
2869
2870	if( iVirtualEndX < 0 )
2871	{
2872	Int iYe = roftoi( (Double)(0 - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) + iDeltaEnd;
2873	if( iYe < (Int)uiScaledBlockSize )
2874	{
2875	ruhXe = 0;
2876	ruhYe = (UChar)std::max( iYe, 0 );
2877	return;
2878	}
2879	else
2880	{
2881	ruhXe = (UChar)std::min( (iYe - iMaxPos), iMaxPos );
2882	ruhYe = (UChar)iMaxPos;
2883	return;
2884	}
2885	}
2886	else if( iVirtualEndX > iMaxPos )
2887	{
2888	Int iYe = roftoi( (Double)(iMaxPos - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
2889	if( iYe < (Int)uiScaledBlockSize )
2890	{
2891	ruhXe = (UChar)iMaxPos;
2892	ruhYe = (UChar)std::max( iYe, 0 );
2893	std::swap( ruhXs, ruhXe );
2894	std::swap( ruhYs, ruhYe );
2895	return;
2896	}
2897	else
2898	{
2899	ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
2900	ruhYe = (UChar)iMaxPos;
2901	return;
2902	}
2903	}
2904	else
2905	{
2906	Int iXe = iVirtualEndX + iDeltaEnd;
2907	if( iXe < 0 )
2908	{
2909	ruhXe = 0;
2910	ruhYe = (UChar)std::max( (iMaxPos + iXe), 0 );
2911	return;
2912	}
2913	else if( iXe > iMaxPos )
2914	{
2915	ruhXe = (UChar)iMaxPos;
2916	ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
2917	std::swap( ruhXs, ruhXe );
2918	std::swap( ruhYs, ruhYe );
2919	return;
2920	}
2921	else
2922	{
2923	ruhXe = (UChar)iXe;
2924	ruhYe = (UChar)iMaxPos;
2925	return;
2926	}
2927	}
2928	}
2929
2930	// case left
2931	if( uiScaledStartPosY > 0 && uiScaledStartPosX == 0 )
2932	{
2933	ruhXs = 0;
2934	ruhYs = (UChar)uiScaledStartPosY;
2935
2936	if( iDeltaX == 0 )
2937	{
2938	if( iDeltaY < 0 )
2939	{
2940	ruhXe = (UChar)std::min( std::max( -iDeltaEnd, 0 ), iMaxPos );
2941	ruhYe = 0;
2942	std::swap( ruhXs, ruhXe );
2943	std::swap( ruhYs, ruhYe );
2944	return;
2945	}
2946	else
2947	{
2948	ruhXe = (UChar)std::min( std::max( iDeltaEnd, 0 ), iMaxPos );
2949	ruhYe = (UChar)iMaxPos;
2950	return;
2951	}
2952	}
2953
2954	// regular case
2955	Int iVirtualEndY = (Int)ruhYs + roftoi( (Double)iMaxPos * ((Double)iDeltaY / (Double)iDeltaX) );
2956
2957	if( iVirtualEndY < 0 )
2958	{
2959	Int iXe = roftoi( (Double)(0 - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) - iDeltaEnd;
2960	if( iXe < (Int)uiScaledBlockSize )
2961	{
2962	ruhXe = (UChar)std::max( iXe, 0 );
2963	ruhYe = 0;
2964	std::swap( ruhXs, ruhXe );
2965	std::swap( ruhYs, ruhYe );
2966	return;
2967	}
2968	else
2969	{
2970	ruhXe = (UChar)iMaxPos;
2971	ruhYe = (UChar)std::min( (iXe - iMaxPos), iMaxPos );
2972	std::swap( ruhXs, ruhXe );
2973	std::swap( ruhYs, ruhYe );
2974	return;
2975	}
2976	}
2977	else if( iVirtualEndY > (uiScaledBlockSize-1) )
2978	{
2979	Int iXe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) + iDeltaEnd;
2980	if( iXe < (Int)uiScaledBlockSize )
2981	{
2982	ruhXe = (UChar)std::max( iXe, 0 );
2983	ruhYe = (UChar)(uiScaledBlockSize-1);
2984	return;
2985	}
2986	else
2987	{
2988	ruhXe = (UChar)iMaxPos;
2989	ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
2990	std::swap( ruhXs, ruhXe );
2991	std::swap( ruhYs, ruhYe );
2992	return;
2993	}
2994	}
2995	else
2996	{
2997	Int iYe = iVirtualEndY - iDeltaEnd;
2998	if( iYe < 0 )
2999	{
3000	ruhXe = (UChar)std::max( (iMaxPos + iYe), 0 );
3001	ruhYe = 0;
3002	std::swap( ruhXs, ruhXe );
3003	std::swap( ruhYs, ruhYe );
3004	return;
3005	}
3006	else if( iYe > iMaxPos )
3007	{
3008	ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
3009	ruhYe = (UChar)iMaxPos;
3010	return;
3011	}
3012	else
3013	{
3014	ruhXe = (UChar)iMaxPos;
3015	ruhYe = (UChar)iYe;
3016	std::swap( ruhXs, ruhXe );
3017	std::swap( ruhYs, ruhYe );
3018	return;
3019	}
3020	}
3021	}
3022
3023	// case origin
3024	if( uiScaledStartPosX == 0 && uiScaledStartPosY == 0 )
3025	{
3026	if( iDeltaX*iDeltaY < 0 )
3027	{
3028	return;
3029	}
3030
3031	ruhXs = 0;
3032	ruhYs = 0;
3033
3034	if( iDeltaY == 0 )
3035	{
3036	ruhXe = (UChar)iMaxPos;
3037	ruhYe = 0;
3038	std::swap( ruhXs, ruhXe );
3039	std::swap( ruhYs, ruhYe );
3040	return;
3041	}
3042
3043	if( iDeltaX == 0 )
3044	{
3045	ruhXe = 0;
3046	ruhYe = (UChar)iMaxPos;
3047	return;
3048	}
3049
3050	Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)iMaxPos * ((Double)iDeltaX / (Double)iDeltaY) );
3051
3052	if( iVirtualEndX > iMaxPos )
3053	{
3054	Int iYe = roftoi( (Double)((Int)iMaxPos - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
3055	if( iYe < (Int)uiScaledBlockSize )
3056	{
3057	ruhXe = (UChar)(uiScaledBlockSize-1);
3058	ruhYe = (UChar)std::max( iYe, 0 );
3059	std::swap( ruhXs, ruhXe );
3060	std::swap( ruhYs, ruhYe );
3061	return;
3062	}
3063	else
3064	{
3065	ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
3066	ruhYe = (UChar)(uiScaledBlockSize-1);
3067	return;
3068	}
3069	}
3070	else
3071	{
3072	Int iXe = iVirtualEndX + iDeltaEnd;
3073	if( iXe < 0 )
3074	{
3075	ruhXe = 0;
3076	ruhYe = (UChar)std::max( (iMaxPos + iXe), 0 );
3077	return;
3078	}
3079	else if( iXe > iMaxPos )
3080	{
3081	ruhXe = (UChar)(uiScaledBlockSize-1);
3082	ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
3083	std::swap( ruhXs, ruhXe );
3084	std::swap( ruhYs, ruhYe );
3085	return;
3086	}
3087	else
3088	{
3089	ruhXe = (UChar)iXe;
3090	ruhYe = (UChar)(uiScaledBlockSize-1);
3091	return;
3092	}
3093	}
3094	}
3095	}
3096
3097	UInt TComPrediction::xGetWedgePatternIdx( UInt uiBlockSize, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe )
3098	{
3099	WedgeRefList* pcWedgeRefList = &g_dmmWedgeRefLists[(g_aucConvertToBit[uiBlockSize])];
3100	for( UInt uiIdx = 0; uiIdx < pcWedgeRefList->size(); uiIdx++ )
3101	{
3102	TComWedgeRef* pcTestWedgeRef = &(pcWedgeRefList->at(uiIdx));
3103	if( pcTestWedgeRef->getStartX() == uhXs && pcTestWedgeRef->getStartY() == uhYs && pcTestWedgeRef->getEndX() == uhXe && pcTestWedgeRef->getEndY() == uhYe )
3104	{
3105	return pcTestWedgeRef->getRefIdx();
3106	}
3107	}
3108	return 0;
3109	}
3110	#endif
3111	#if H_3D_DIM_RBC
3112	Void TComPrediction::xDeltaDCQuantScaleUp( TComDataCU* pcCU, Pel& rDeltaDC )
3113	{
3114	Int iSign = rDeltaDC < 0 ? -1 : 1;
3115	UInt uiAbs = abs( rDeltaDC );
3116
3117	Int iQp = pcCU->getQP(0);
3118	Double dMax = (Double)( 1<<( g_bitDepthY - 1 ) );
3119	Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 - 2.0 ) );
3120
3121	rDeltaDC = iSign * roftoi( uiAbs * dStepSize );
3122	return;
3123	}
3124
3125	Void TComPrediction::xDeltaDCQuantScaleDown( TComDataCU* pcCU, Pel& rDeltaDC )
3126	{
3127	Int iSign = rDeltaDC < 0 ? -1 : 1;
3128	UInt uiAbs = abs( rDeltaDC );
3129
3130	Int iQp = pcCU->getQP(0);
3131	Double dMax = (Double)( 1<<( g_bitDepthY - 1 ) );
3132	Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 - 2.0 ) );
3133
3134	rDeltaDC = iSign * roftoi( uiAbs / dStepSize );
3135	return;
3136	}
3137	#endif
3138	#if H_3D_DIM_SDC
3139	Void TComPrediction::analyzeSegmentsSDC( Pel* pOrig, UInt uiStride, UInt uiSize, Pel* rpSegMeans, UInt uiNumSegments, Bool* pMask, UInt uiMaskStride )
3140	{
3141	Int iSumDepth[2];
3142	memset(iSumDepth, 0, sizeof(Int)*2);
3143	Int iSumPix[2];
3144	memset(iSumPix, 0, sizeof(Int)*2);
3145
3146	Int subSamplePix;
3147	if ( uiSize == 64 \|\| uiSize == 32 )
3148	{
3149	subSamplePix = 2;
3150	}
3151	else
3152	{
3153	subSamplePix = 1;
3154	}
3155	for (Int y=0; y<uiSize; y+=subSamplePix)
3156	{
3157	for (Int x=0; x<uiSize; x+=subSamplePix)
3158	{
3159	UChar ucSegment = pMask?(UChar)pMask[x]:0;
3160	assert( ucSegment < uiNumSegments );
3161
3162	iSumDepth[ucSegment] += pOrig[x];
3163	iSumPix[ucSegment] += 1;
3164	}
3165
3166	pOrig += uiStride*subSamplePix;
3167	pMask += uiMaskStride*subSamplePix;
3168	}
3169
3170	// compute mean for each segment
3171	for( UChar ucSeg = 0; ucSeg < uiNumSegments; ucSeg++ )
3172	{
3173	if( iSumPix[ucSeg] > 0 )
3174	rpSegMeans[ucSeg] = iSumDepth[ucSeg] / iSumPix[ucSeg];
3175	else
3176	rpSegMeans[ucSeg] = 0; // this happens for zero-segments
3177	}
3178	}
3179	#endif // H_3D_DIM_SDC
3180	#endif
3181	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-DEV-2.0-dev1-Samsung/source/Lib/TLibCommon/TComPrediction.cpp @ 912

Download in other formats: