Context navigation

TComPrediction.cpp @ 312

Visit:

Last change on this file since 312 was 312, checked in by tech, 11 years ago
Incorporated MTK_DVPREFINE_BVSP_BUG_FIX.
Property svn:eol-style set to `native`
File size: 121.0 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2012, 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	#if LGE_EDGE_INTRA_A0070
49	#define MAX_DISTANCE_EDGEINTRA 255
50	#endif
51
52	TComPrediction::TComPrediction()
53	: m_pLumaRecBuffer(0)
54	{
55	m_piYuvExt = NULL;
56	#if MERL_VSP_C0152
57	m_pDepth = (Int) malloc(6464*sizeof(Int)); // TODO: Use a smart way to determine the size of the array
58	if (m_pDepth == NULL)
59	{
60	printf("ERROR: UKTGHU, No memory allocated.\n");
61	}
62	#endif
63	}
64
65	TComPrediction::~TComPrediction()
66	{
67
68	#if MERL_VSP_C0152
69	if (m_pDepth != NULL)
70	{
71	free(m_pDepth);
72	}
73	#endif
74	delete[] m_piYuvExt;
75
76	m_acYuvPred[0].destroy();
77	m_acYuvPred[1].destroy();
78
79	m_cYuvPredTemp.destroy();
80
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 = g_uiMaxCUWidth + 16;
102	Int extHeight = g_uiMaxCUHeight + 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 = ((g_uiMaxCUHeight + 2) << 4);
113	m_iYuvExtStride = ((g_uiMaxCUWidth + 8) << 4);
114	m_piYuvExt = new Int[ m_iYuvExtStride * m_iYuvExtHeight ];
115
116	// new structure
117	m_acYuvPred[0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
118	m_acYuvPred[1] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
119
120	m_cYuvPredTemp.create( g_uiMaxCUWidth, g_uiMaxCUHeight );
121	}
122
123	m_iLumaRecStride = (g_uiMaxCUWidth>>1) + 1;
124	m_pLumaRecBuffer = new Pel[ m_iLumaRecStride * m_iLumaRecStride ];
125
126	for( Int i = 1; i < 64; i++ )
127	{
128	m_uiaShift[i-1] = ( (1 << 15) + i/2 ) / i;
129	}
130	}
131
132	// ====================================================================================================================
133	// Public member functions
134	// ====================================================================================================================
135
136	// Function for calculating DC value of the reference samples used in Intra prediction
137	Pel TComPrediction::predIntraGetPredValDC( Int* pSrc, Int iSrcStride, UInt iWidth, UInt iHeight, Bool bAbove, Bool bLeft )
138	{
139	Int iInd, iSum = 0;
140	Pel pDcVal;
141
142	if (bAbove)
143	{
144	for (iInd = 0;iInd < iWidth;iInd++)
145	{
146	iSum += pSrc[iInd-iSrcStride];
147	}
148	}
149	if (bLeft)
150	{
151	for (iInd = 0;iInd < iHeight;iInd++)
152	{
153	iSum += pSrc[iInd*iSrcStride-1];
154	}
155	}
156
157	if (bAbove && bLeft)
158	{
159	pDcVal = (iSum + iWidth) / (iWidth + iHeight);
160	}
161	else if (bAbove)
162	{
163	pDcVal = (iSum + iWidth/2) / iWidth;
164	}
165	else if (bLeft)
166	{
167	pDcVal = (iSum + iHeight/2) / iHeight;
168	}
169	else
170	{
171	pDcVal = pSrc[-1]; // Default DC value already calculated and placed in the prediction array if no neighbors are available
172	}
173
174	return pDcVal;
175	}
176
177	// Function for deriving the angular Intra predictions
178
179	/** Function for deriving the simplified angular intra predictions.
180	* \param pSrc pointer to reconstructed sample array
181	* \param srcStride the stride of the reconstructed sample array
182	* \param rpDst reference to pointer for the prediction sample array
183	* \param dstStride the stride of the prediction sample array
184	* \param width the width of the block
185	* \param height the height of the block
186	* \param dirMode the intra prediction mode index
187	* \param blkAboveAvailable boolean indication if the block above is available
188	* \param blkLeftAvailable boolean indication if the block to the left is available
189	*
190	* This function derives the prediction samples for the angular mode based on the prediction direction indicated by
191	* the prediction mode index. The prediction direction is given by the displacement of the bottom row of the block and
192	* the reference row above the block in the case of vertical prediction or displacement of the rightmost column
193	* of the block and reference column left from the block in the case of the horizontal prediction. The displacement
194	* is signalled at 1/32 pixel accuracy. When projection of the predicted pixel falls inbetween reference samples,
195	* the predicted value for the pixel is linearly interpolated from the reference samples. All reference samples are taken
196	* from the extended main reference.
197	*/
198	Void TComPrediction::xPredIntraAng( Int* pSrc, Int srcStride, Pel*& rpDst, Int dstStride, UInt width, UInt height, UInt dirMode, Bool blkAboveAvailable, Bool blkLeftAvailable, Bool bFilter )
199	{
200	Int k,l;
201	Int blkSize = width;
202	Pel* pDst = rpDst;
203
204	// Map the mode index to main prediction direction and angle
205	assert( dirMode > 0 ); //no planar
206	Bool modeDC = dirMode < 2;
207	Bool modeHor = !modeDC && (dirMode < 18);
208	Bool modeVer = !modeDC && !modeHor;
209	Int intraPredAngle = modeVer ? (Int)dirMode - VER_IDX : modeHor ? -((Int)dirMode - HOR_IDX) : 0;
210	Int absAng = abs(intraPredAngle);
211	Int signAng = intraPredAngle < 0 ? -1 : 1;
212
213	// Set bitshifts and scale the angle parameter to block size
214	Int angTable[9] = {0, 2, 5, 9, 13, 17, 21, 26, 32};
215	Int invAngTable[9] = {0, 4096, 1638, 910, 630, 482, 390, 315, 256}; // (256 * 32) / Angle
216	Int invAngle = invAngTable[absAng];
217	absAng = angTable[absAng];
218	intraPredAngle = signAng * absAng;
219
220	// Do the DC prediction
221	if (modeDC)
222	{
223	Pel dcval = predIntraGetPredValDC(pSrc, srcStride, width, height, blkAboveAvailable, blkLeftAvailable);
224
225	for (k=0;k<blkSize;k++)
226	{
227	for (l=0;l<blkSize;l++)
228	{
229	pDst[k*dstStride+l] = dcval;
230	}
231	}
232	}
233
234	// Do angular predictions
235	else
236	{
237	Pel* refMain;
238	Pel* refSide;
239	Pel refAbove[2*MAX_CU_SIZE+1];
240	Pel refLeft[2*MAX_CU_SIZE+1];
241
242	// Initialise the Main and Left reference array.
243	if (intraPredAngle < 0)
244	{
245	for (k=0;k<blkSize+1;k++)
246	{
247	refAbove[k+blkSize-1] = pSrc[k-srcStride-1];
248	}
249	for (k=0;k<blkSize+1;k++)
250	{
251	refLeft[k+blkSize-1] = pSrc[(k-1)*srcStride-1];
252	}
253	refMain = (modeVer ? refAbove : refLeft) + (blkSize-1);
254	refSide = (modeVer ? refLeft : refAbove) + (blkSize-1);
255
256	// Extend the Main reference to the left.
257	Int invAngleSum = 128; // rounding for (shift by 8)
258	for (k=-1; k>blkSize*intraPredAngle>>5; k--)
259	{
260	invAngleSum += invAngle;
261	refMain[k] = refSide[invAngleSum>>8];
262	}
263	}
264	else
265	{
266	for (k=0;k<2*blkSize+1;k++)
267	{
268	refAbove[k] = pSrc[k-srcStride-1];
269	}
270	for (k=0;k<2*blkSize+1;k++)
271	{
272	refLeft[k] = pSrc[(k-1)*srcStride-1];
273	}
274	refMain = modeVer ? refAbove : refLeft;
275	refSide = modeVer ? refLeft : refAbove;
276	}
277
278	if (intraPredAngle == 0)
279	{
280	for (k=0;k<blkSize;k++)
281	{
282	for (l=0;l<blkSize;l++)
283	{
284	pDst[k*dstStride+l] = refMain[l+1];
285	}
286	}
287
288	if ( bFilter )
289	{
290	for (k=0;k<blkSize;k++)
291	{
292	pDst[kdstStride] = Clip ( pDst[kdstStride] + (( refSide[k+1] - refSide[0] ) >> 1) );
293	}
294	}
295	}
296	else
297	{
298	Int deltaPos=0;
299	Int deltaInt;
300	Int deltaFract;
301	Int refMainIndex;
302
303	for (k=0;k<blkSize;k++)
304	{
305	deltaPos += intraPredAngle;
306	deltaInt = deltaPos >> 5;
307	deltaFract = deltaPos & (32 - 1);
308
309	if (deltaFract)
310	{
311	// Do linear filtering
312	for (l=0;l<blkSize;l++)
313	{
314	refMainIndex = l+deltaInt+1;
315	pDst[kdstStride+l] = (Pel) ( ((32-deltaFract)refMain[refMainIndex]+deltaFract*refMain[refMainIndex+1]+16) >> 5 );
316	}
317	}
318	else
319	{
320	// Just copy the integer samples
321	for (l=0;l<blkSize;l++)
322	{
323	pDst[k*dstStride+l] = refMain[l+deltaInt+1];
324	}
325	}
326	}
327	}
328
329	// Flip the block if this is the horizontal mode
330	if (modeHor)
331	{
332	Pel tmp;
333	for (k=0;k<blkSize-1;k++)
334	{
335	for (l=k+1;l<blkSize;l++)
336	{
337	tmp = pDst[k*dstStride+l];
338	pDst[kdstStride+l] = pDst[ldstStride+k];
339	pDst[l*dstStride+k] = tmp;
340	}
341	}
342	}
343	}
344	}
345
346	Void TComPrediction::predIntraLumaAng(TComPattern* pcTComPattern, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, TComDataCU* pcCU, Bool bAbove, Bool bLeft )
347	{
348	Pel *pDst = piPred;
349	Int *ptrSrc;
350
351	assert( g_aucConvertToBit[ iWidth ] >= 0 ); // 4x 4
352	assert( g_aucConvertToBit[ iWidth ] <= 5 ); // 128x128
353	assert( iWidth == iHeight );
354
355	ptrSrc = pcTComPattern->getPredictorPtr( uiDirMode, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
356
357	// get starting pixel in block
358	Int sw = 2 * iWidth + 1;
359
360	// Create the prediction
361	if ( uiDirMode == PLANAR_IDX )
362	{
363	xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
364	}
365	else
366	{
367	xPredIntraAng( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, true );
368
369	if( (uiDirMode == DC_IDX ) && bAbove && bLeft )
370	{
371	xDCPredFiltering( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight);
372	}
373	}
374	}
375
376	// Angular chroma
377	Void TComPrediction::predIntraChromaAng( TComPattern* pcTComPattern, Int* piSrc, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, TComDataCU* pcCU, Bool bAbove, Bool bLeft )
378	{
379	Pel *pDst = piPred;
380	Int *ptrSrc = piSrc;
381
382	// get starting pixel in block
383	Int sw = 2 * iWidth + 1;
384
385	if ( uiDirMode == PLANAR_IDX )
386	{
387	xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
388	}
389	else
390	{
391	// Create the prediction
392	xPredIntraAng( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, false );
393	}
394	}
395
396	/** Function for checking identical motion.
397	* \param TComDataCU* pcCU
398	* \param UInt PartAddr
399	*/
400	Bool TComPrediction::xCheckIdenticalMotion ( TComDataCU* pcCU, UInt PartAddr )
401	{
402	if( pcCU->getSlice()->isInterB() && pcCU->getSlice()->getPPS()->getWPBiPredIdc() == 0 )
403	{
404	if( pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr) >= 0 && pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr) >= 0)
405	{
406	Int RefPOCL0 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_0, pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr))->getPOC();
407	Int RefViewIdL0 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_0, pcCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx(PartAddr))->getViewId();
408	Int RefPOCL1 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_1, pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr))->getPOC();
409	Int RefViewIdL1 = pcCU->getSlice()->getRefPic(REF_PIC_LIST_1, pcCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx(PartAddr))->getViewId();
410	if(RefPOCL0 == RefPOCL1 && RefViewIdL0 == RefViewIdL1 && pcCU->getCUMvField(REF_PIC_LIST_0)->getMv(PartAddr) == pcCU->getCUMvField(REF_PIC_LIST_1)->getMv(PartAddr))
411	{
412	return true;
413	}
414	}
415	}
416	return false;
417	}
418
419	#if LGE_EDGE_INTRA_A0070
420	Void TComPrediction::predIntraLumaEdge ( TComDataCU* pcCU, TComPattern* pcTComPattern, UInt uiAbsPartIdx, Int iWidth, Int iHeight, Pel* piPred, UInt uiStride, Bool bDelta )
421	{
422	Pel *piDst = piPred;
423	Int *piSrc;
424	Int iSrcStride = ( iWidth<<1 ) + 1;
425	Int iDstStride = uiStride;
426
427	piSrc = pcTComPattern->getPredictorPtr( 0, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );
428
429	xPredIntraEdge ( pcCU, uiAbsPartIdx, iWidth, iHeight, piSrc, iSrcStride, piDst, iDstStride
430	#if LGE_EDGE_INTRA_DELTA_DC
431	, bDelta
432	#endif
433	);
434	}
435
436	Pel TComPrediction::xGetNearestNeighbor( Int x, Int y, Int* pSrc, Int srcStride, Int iWidth, Int iHeight, Bool* bpRegion )
437	{
438	Bool bLeft = (x < y) ? true : false;
439	Bool bFound = false;
440	Int iFoundX = -1, iFoundY = -1;
441	Int cResult = 0;
442
443	UChar* piTopDistance = new UChar[iWidth];
444	UChar* piLeftDistance = new UChar[iHeight];
445
446	for( Int i = 0; i < iWidth; i++ )
447	{
448	int Abs = x > i ? x - i : i - x;
449	piTopDistance[ i ] = y + Abs;
450
451	Abs = y > i ? y - i : i - y;
452	piLeftDistance[ i ] = x + Abs;
453	}
454
455	for( Int dist = 0; dist < MAX_DISTANCE_EDGEINTRA && !bFound; dist++ )
456	{
457	if( !bLeft )
458	{
459	for( Int i = 0; i < iWidth; i++ )
460	{
461	if( piTopDistance[ i ] == dist )
462	{
463	if( bpRegion[ i ] == bpRegion[ x + y * iWidth ] )
464	{
465	iFoundX = i;
466	iFoundY = 0;
467	bFound = true;
468	}
469	}
470	}
471	for( Int i = 0; i < iHeight; i++ )
472	{
473	if( piLeftDistance[ i ] == dist )
474	{
475	if( bpRegion[ i * iWidth ] == bpRegion[ x + y * iWidth ] )
476	{
477	iFoundX = 0;
478	iFoundY = i;
479	bFound = true;
480	}
481	}
482	}
483	}
484	else
485	{
486	for( Int i = 0; i < iHeight; i++ )
487	{
488	if( piLeftDistance[ i ] == dist )
489	{
490	if( bpRegion[ i * iWidth ] == bpRegion[ x + y * iWidth ] )
491	{
492	iFoundX = 0;
493	iFoundY = i;
494	bFound = true;
495	}
496	}
497	}
498	for( Int i = 0; i < iWidth; i++ )
499	{
500	if( piTopDistance[ i ] == dist )
501	{
502	if( bpRegion[ i ] == bpRegion[ x + y * iWidth ] )
503	{
504	iFoundX = i;
505	iFoundY = 0;
506	bFound = true;
507	}
508	}
509	}
510	}
511	}
512
513	if( iFoundY == 0 )
514	{
515	cResult = pSrc[ iFoundX + 1 ];
516	}
517	else // iFoundX == 0
518	{
519	cResult = pSrc[ (iFoundY + 1) * srcStride ];
520	}
521
522	delete[] piTopDistance; piTopDistance = NULL;
523	delete[] piLeftDistance; piLeftDistance = NULL;
524
525	assert( bFound );
526
527	return cResult;
528	}
529
530	Void TComPrediction::xPredIntraEdge( TComDataCU* pcCU, UInt uiAbsPartIdx, Int iWidth, Int iHeight, Int* pSrc, Int srcStride, Pel*& rpDst, Int dstStride, Bool bDelta )
531	{
532	Pel* pDst = rpDst;
533	Bool* pbRegion = pcCU->getEdgePartition( uiAbsPartIdx );
534
535	// Do prediction
536	{
537	//UInt uiSum0 = 0, uiSum1 = 0;
538	Int iSum0 = 0, iSum1 = 0;
539	//UInt uiMean0, uiMean1;
540	Int iMean0, iMean1;
541	//UInt uiCount0 = 0, uiCount1 = 0;
542	Int iCount0 = 0, iCount1 = 0;
543	for( UInt ui = 0; ui < iWidth; ui++ )
544	{
545	if( pbRegion[ ui ] == false )
546	{
547	iSum0 += (pSrc[ ui + 1 ]);
548	iCount0++;
549	}
550	else
551	{
552	iSum1 += (pSrc[ ui + 1 ]);
553	iCount1++;
554	}
555	}
556	for( UInt ui = 0; ui < iHeight; ui++ ) // (0,0) recount (to avoid division)
557	{
558	if( pbRegion[ ui * iWidth ] == false )
559	{
560	iSum0 += (pSrc[ (ui + 1) * srcStride ]);
561	iCount0++;
562	}
563	else
564	{
565	iSum1 += (pSrc[ (ui + 1) * srcStride ]);
566	iCount1++;
567	}
568	}
569	if( iCount0 == 0 )
570	assert(false);
571	if( iCount1 == 0 )
572	assert(false);
573	iMean0 = iSum0 / iCount0; // TODO : integer op.
574	iMean1 = iSum1 / iCount1;
575	#if LGE_EDGE_INTRA_DELTA_DC
576	if( bDelta )
577	{
578	Int iDeltaDC0 = pcCU->getEdgeDeltaDC0( uiAbsPartIdx );
579	Int iDeltaDC1 = pcCU->getEdgeDeltaDC1( uiAbsPartIdx );
580	xDeltaDCQuantScaleUp( pcCU, iDeltaDC0 );
581	xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
582	iMean0 = Clip( iMean0 + iDeltaDC0 );
583	iMean1 = Clip( iMean1 + iDeltaDC1 );
584	}
585	#endif
586	for( UInt ui = 0; ui < iHeight; ui++ )
587	{
588	for( UInt uii = 0; uii < iWidth; uii++ )
589	{
590	if( pbRegion[ uii + ui * iWidth ] == false )
591	pDst[ uii + ui * dstStride ] = iMean0;
592	else
593	pDst[ uii + ui * dstStride ] = iMean1;
594	}
595	}
596	}
597	}
598	#endif
599
600	#if DEPTH_MAP_GENERATION
601	#if MERL_VSP_C0152
602	Void TComPrediction::motionCompensation( TComDataCU* pcCU, TComYuv* pcYuvPred, UInt uiAbsPartIdx, RefPicList eRefPicList, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY )
603	#else
604	Void TComPrediction::motionCompensation( TComDataCU* pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY )
605	#endif
606	#else
607	#if MERL_VSP_C0152
608	Void TComPrediction::motionCompensation ( TComDataCU* pcCU, TComYuv* pcYuvPred, UInt uiAbsPartIdx, RefPicList eRefPicList, Int iPartIdx )
609	#else
610	Void TComPrediction::motionCompensation ( TComDataCU* pcCU, TComYuv* pcYuvPred, RefPicList eRefPicList, Int iPartIdx )
611	#endif
612	#endif
613	{
614	Int iWidth;
615	Int iHeight;
616	UInt uiPartAddr;
617
618	if ( iPartIdx >= 0 )
619	{
620	pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
621
622	#if DEPTH_MAP_GENERATION
623	if( bPrdDepthMap )
624	{
625	iWidth >>= uiSubSampExpX;
626	iHeight >>= uiSubSampExpY;
627	}
628	#endif
629
630	if ( eRefPicList != REF_PIC_LIST_X )
631	{
632	#if LGE_ILLUCOMP_B0045
633	if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr))
634	#else
635	if( pcCU->getSlice()->getPPS()->getUseWP())
636	#endif
637	{
638	#if DEPTH_MAP_GENERATION
639	#if MERL_VSP_C0152
640	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
641	#else
642	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
643	#endif
644	#else
645	#if MERL_VSP_C0152
646	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, true );
647	#else
648	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, true );
649	#endif
650	#endif
651	}
652	else
653	{
654	#if DEPTH_MAP_GENERATION
655	#if MERL_VSP_C0152
656	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
657	#else
658	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
659	#endif
660	#else
661	#if MERL_VSP_C0152
662	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
663	#else
664	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
665	#endif
666	#endif
667	}
668	#if LGE_ILLUCOMP_B0045
669	if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr) )
670	#else
671	if ( pcCU->getSlice()->getPPS()->getUseWP() )
672	#endif
673	{
674	xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx );
675	}
676	}
677	else
678	{
679	#if DEPTH_MAP_GENERATION
680	if( xCheckIdenticalMotion( pcCU, uiPartAddr ) && !bPrdDepthMap )
681	#else
682	if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
683	#endif
684	{
685	#if DEPTH_MAP_GENERATION
686	#if MERL_VSP_C0152
687	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
688	#else
689	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
690	#endif
691	#else
692	#if MERL_VSP_C0152
693	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, false );
694	#else
695	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, false );
696	#endif
697	#endif
698	}
699	else
700	{
701	#if DEPTH_MAP_GENERATION
702	#if MERL_VSP_C0152
703	xPredInterBi (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
704	#else
705	xPredInterBi (pcCU, uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
706	#endif
707	#else
708	#if MERL_VSP_C0152
709	xPredInterBi (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
710	#else
711	xPredInterBi (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
712	#endif
713	#endif
714	}
715	}
716	return;
717	}
718
719	for ( iPartIdx = 0; iPartIdx < pcCU->getNumPartInter(); iPartIdx++ )
720	{
721	pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
722
723	#if DEPTH_MAP_GENERATION
724	if( bPrdDepthMap )
725	{
726	iWidth >>= uiSubSampExpX;
727	iHeight >>= uiSubSampExpY;
728	}
729	#endif
730
731	if ( eRefPicList != REF_PIC_LIST_X )
732	{
733	#if LGE_ILLUCOMP_B0045
734	if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr))
735	#else
736	if( pcCU->getSlice()->getPPS()->getUseWP())
737	#endif
738	{
739	#if DEPTH_MAP_GENERATION
740	#if MERL_VSP_C0152
741	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
742	#else
743	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
744	#endif
745	#else
746	#if MERL_VSP_C0152
747	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, true );
748	#else
749	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, true );
750	#endif
751	#endif
752	}
753	else
754	{
755	#if DEPTH_MAP_GENERATION
756	#if MERL_VSP_C0152
757	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
758	#else
759	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
760	#endif
761	#else
762	#if MERL_VSP_C0152
763	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
764	#else
765	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
766	#endif
767	#endif
768	}
769	#if DEPTH_MAP_GENERATION
770	#if MERL_VSP_C0152
771	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
772	#else
773	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
774	#endif
775	#else
776	#if MERL_VSP_C0152
777	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
778	#else
779	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx, false );
780	#endif
781	#endif
782	#if LGE_ILLUCOMP_B0045
783	if( pcCU->getSlice()->getPPS()->getUseWP() && !pcCU->getICFlag(uiPartAddr))
784	#else
785	if( pcCU->getSlice()->getPPS()->getUseWP())
786	#endif
787	{
788	xWeightedPredictionUni( pcCU, pcYuvPred, uiPartAddr, iWidth, iHeight, eRefPicList, pcYuvPred, iPartIdx );
789	}
790	}
791	else
792	{
793	if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
794	{
795	#if DEPTH_MAP_GENERATION
796	#if MERL_VSP_C0152
797	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
798	#else
799	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
800	#endif
801	#else
802	#if MERL_VSP_C0152
803	xPredInterUni (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, false );
804	#else
805	xPredInterUni (pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred, iPartIdx, false );
806	#endif
807	#endif
808	}
809	else
810	{
811	#if DEPTH_MAP_GENERATION
812	#if MERL_VSP_C0152
813	xPredInterBi (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
814	#else
815	xPredInterBi (pcCU, uiPartAddr, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, pcYuvPred, iPartIdx, bPrdDepthMap );
816	#endif
817	#else
818	#if MERL_VSP_C0152
819	xPredInterBi (pcCU, uiPartAddr, uiAbsPartIdx+uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
820	#else
821	xPredInterBi (pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred, iPartIdx );
822	#endif
823	#endif
824	}
825	}
826	}
827	return;
828	}
829
830	#if MTK_MDIVRP_C0138
831	Void TComPrediction::residualPrediction(TComDataCU* pcCU, TComYuv* pcYuvPred, TComYuv* pcYuvResPred)
832	{
833	Int iWidth;
834	Int iHeight;
835	UInt uiPartAddr;
836
837	pcCU->getPartIndexAndSize( 0, uiPartAddr, iWidth, iHeight );
838
839	Bool bResAvail = false;
840
841	bResAvail = pcCU->getResidualSamples( 0, true, pcYuvResPred );
842
843	assert (bResAvail);
844
845	pcYuvPred->add(pcYuvResPred, iWidth, iHeight);
846	}
847	#endif
848
849	#if DEPTH_MAP_GENERATION
850	#if MERL_VSP_C0152
851	Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY, Bool bi )
852	#else
853	Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, UInt uiSubSampExpX, UInt uiSubSampExpY, Bool bi )
854	#endif
855	#else
856	#if MERL_VSP_C0152
857	Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi )
858	#else
859	Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi )
860	#endif
861	#endif
862	{
863	#if MERL_VSP_C0152
864	Int iRefIdx = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
865	Int vspIdx = pcCU->getVSPIndex(uiPartAddr);
866	if (vspIdx != 0)
867	{
868	if (iRefIdx >= 0)
869	{
870	printf("vspIdx = %d, iRefIdx = %d\n", vspIdx, iRefIdx);
871	}
872	assert (iRefIdx < 0); // assert (iRefIdx == NOT_VALID);
873	}
874	else
875	{
876	assert (iRefIdx >= 0);
877	}
878	#else
879	Int iRefIdx = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr ); assert (iRefIdx >= 0);
880	#endif
881
882	TComMv cMv = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr );
883	pcCU->clipMv(cMv);
884
885	#if DEPTH_MAP_GENERATION
886	if( bPrdDepthMap )
887	{
888	UInt uiRShift = 0;
889	#if PDM_REMOVE_DEPENDENCE
890	if( pcCU->getPic()->getStoredPDMforV2() == 1 )
891	xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPredDepthMapTemp(), uiPartAddr, &cMv, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, rpcYuvPred, uiRShift, 0 );
892	else
893	#endif
894	xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPredDepthMap(), uiPartAddr, &cMv, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY, rpcYuvPred, uiRShift, 0 );
895
896	return;
897	}
898	#endif
899
900	#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
901	if( pcCU->getSlice()->getSPS()->isDepth() )
902	{
903	#if MERL_VSP_C0152
904	if (vspIdx != 0)
905	{ // depth, vsp
906	// get depth estimator here
907	TComPic* pRefPicBaseDepth = pcCU->getSlice()->getRefPicBaseDepth();
908	TComPicYuv* pcBaseViewDepthPicYuv = NULL;
909	if (vspIdx < 4) // spatial
910	{
911	pcBaseViewDepthPicYuv = pRefPicBaseDepth->getPicYuvRec();
912	}
913	Int iBlkX = ( pcCU->getAddr() % pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUWidth + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
914	Int iBlkY = ( pcCU->getAddr() / pRefPicBaseDepth->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
915	Int* pShiftLUT;
916	Int iShiftPrec;
917	pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec);
918	//using disparity to find the depth block of the base view as the depth block estimator of the current block
919	//using depth block estimator and base view texture to get Backward warping
920	xPredInterLumaBlkFromDM ( pcBaseViewDepthPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX, iBlkY, iWidth, iHeight, pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
921	xPredInterChromaBlkFromDM( pcBaseViewDepthPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1, pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
922	}
923	else
924	{
925	#endif
926	UInt uiRShift = ( bi ? 14-g_uiBitDepth-g_uiBitIncrement : 0 );
927	UInt uiOffset = bi ? IF_INTERNAL_OFFS : 0;
928	#if LGE_ILLUCOMP_DEPTH_C0046
929	Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
930	#endif
931	#if DEPTH_MAP_GENERATION
932	xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, 0, 0, rpcYuvPred, uiRShift, uiOffset
933	#if LGE_ILLUCOMP_DEPTH_C0046
934	, bICFlag
935	#endif
936	);
937	#else
938	xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, uiRShift, uiOffset );
939	#endif
940	#if MERL_VSP_C0152
941	}
942	#endif// MERL_VSP_C0152 //else
943	}
944	else
945	{
946	#endif
947	#if MERL_VSP_C0152
948	if ( vspIdx != 0 )
949	{ // texture, vsp
950	TComPic* pRefPicBaseTxt = pcCU->getSlice()->getRefPicBaseTxt();
951	TComPicYuv* pcBaseViewTxtPicYuv = pRefPicBaseTxt->getPicYuvRec();
952	TComPicYuv* pcBaseViewDepthPicYuv = NULL;
953	if (vspIdx < 4) // spatial
954	{
955	TComPic* pRefPicBaseDepth = pcCU->getSlice()->getRefPicBaseDepth();
956	pcBaseViewDepthPicYuv = pRefPicBaseDepth->getPicYuvRec();
957	}
958	Int iBlkX = ( pcCU->getAddr() % pRefPicBaseTxt->getFrameWidthInCU() ) * g_uiMaxCUWidth + g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
959	Int iBlkY = ( pcCU->getAddr() / pRefPicBaseTxt->getFrameWidthInCU() ) * g_uiMaxCUHeight + g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
960	Int* pShiftLUT;
961	Int iShiftPrec;
962	pcCU->getSlice()->getBWVSPLUTParam(pShiftLUT, iShiftPrec);
963
964	//using disparity to find the depth block of the base view as the depth block estimator of the current block
965	//using depth block estimator and base view texture to get Backward warping
966	xPredInterLumaBlkFromDM ( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX, iBlkY, iWidth, iHeight, pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
967	xPredInterChromaBlkFromDM( pcBaseViewTxtPicYuv, pcBaseViewDepthPicYuv, pShiftLUT, iShiftPrec, &cMv, uiPartAddr, iBlkX>>1, iBlkY>>1, iWidth>>1, iHeight>>1, pcCU->getSlice()->getSPS()->isDepth(), vspIdx, rpcYuvPred );
968	}
969	else//texture not VSP
970	{
971	#endif //MERL_VSP_C0152
972	#if LGE_ILLUCOMP_B0045
973	Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
974
975	xPredInterLumaBlk ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, bICFlag);
976	#else
977	xPredInterLumaBlk ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
978	#endif
979	#if MERL_VSP_C0152
980	} //texture not VSP
981	#endif
982	#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
983	}
984	#endif
985
986	#if MERL_VSP_C0152
987	if ( vspIdx == 0 )//Not VSP
988	{
989	#endif
990	#if LGE_ILLUCOMP_B0045
991	Bool bICFlag = pcCU->getICFlag(uiPartAddr) && (pcCU->getSlice()->getRefViewId( eRefPicList, iRefIdx ) != pcCU->getSlice()->getViewId());
992
993	xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi, bICFlag );
994	#else
995	xPredInterChromaBlk( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, bi );
996	#endif
997	#if MERL_VSP_C0152
998	}
999	#endif
1000	}
1001
1002
1003	#if DEPTH_MAP_GENERATION
1004	#if MERL_VSP_C0152
1005	Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap )
1006	#else
1007	Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap )
1008	#endif
1009	#else
1010	#if MERL_VSP_C0152
1011	Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, UInt uiAbsPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvPred, Int iPartIdx )
1012	#else
1013	Void TComPrediction::xPredInterBi ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, TComYuv*& rpcYuvPred, Int iPartIdx )
1014	#endif
1015	#endif
1016	{
1017	TComYuv* pcMbYuv;
1018	Int iRefIdx[2] = {-1, -1};
1019
1020	for ( Int iRefList = 0; iRefList < 2; iRefList++ )
1021	{
1022	RefPicList eRefPicList = (iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0);
1023	iRefIdx[iRefList] = pcCU->getCUMvField( eRefPicList )->getRefIdx( uiPartAddr );
1024
1025	#if MERL_VSP_C0152
1026	if(!pcCU->getVSPIndex(uiPartAddr))
1027	{
1028	if ( iRefIdx[iRefList] < 0 )
1029	{
1030	continue;
1031	}
1032	}
1033	else
1034	{
1035	if ( iRefList== REF_PIC_LIST_1 && iRefIdx[iRefList] < 0 ) // iRefIdx[iRefList] ==NOT_VALID
1036	{
1037	continue;
1038	}
1039	}
1040	#else
1041	if ( iRefIdx[iRefList] < 0 )
1042	{
1043	continue;
1044	}
1045	#endif
1046
1047	assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) );
1048
1049	pcMbYuv = &m_acYuvPred[iRefList];
1050	if( pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr ) >= 0 && pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr ) >= 0 )
1051	{
1052	#if DEPTH_MAP_GENERATION
1053	#if MERL_VSP_C0152
1054	xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
1055	#else
1056	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
1057	#endif
1058	#else
1059	#if MERL_VSP_C0152
1060	xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
1061	#else
1062	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
1063	#endif
1064	#endif
1065	}
1066	else
1067	{
1068	#if FIX_LGE_WP_FOR_3D_C0223
1069	if ( ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType() == P_SLICE ) \|\|
1070	( pcCU->getSlice()->getPPS()->getWPBiPredIdc() && pcCU->getSlice()->getSliceType() == B_SLICE ) )
1071	#else
1072	if ( pcCU->getSlice()->getPPS()->getWPBiPredIdc() )
1073	#endif
1074	{
1075	#if DEPTH_MAP_GENERATION
1076	#if MERL_VSP_C0152
1077	xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
1078	#else
1079	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, true );
1080	#endif
1081	#else
1082	#if MERL_VSP_C0152
1083	xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
1084	#else
1085	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
1086	#endif
1087	#endif
1088	}
1089	else
1090	{
1091	#if DEPTH_MAP_GENERATION
1092	#if MERL_VSP_C0152
1093	xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
1094	#else
1095	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, uiSubSampExpX, uiSubSampExpY, false );
1096	#endif
1097	#else
1098	#if MERL_VSP_C0152
1099	xPredInterUni ( pcCU, uiPartAddr, uiAbsPartIdx, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, false );
1100	#else
1101	xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, false );
1102	#endif
1103	#endif
1104	}
1105	}
1106	}
1107	#if FIX_LGE_WP_FOR_3D_C0223
1108	if ( pcCU->getSlice()->getPPS()->getWPBiPredIdc() && pcCU->getSlice()->getSliceType() == B_SLICE )
1109	#else
1110	if ( pcCU->getSlice()->getPPS()->getWPBiPredIdc() )
1111	#endif
1112	{
1113	#if MERL_VSP_C0152
1114	if(pcCU->getVSPIndex(uiPartAddr))
1115	m_acYuvPred[0].copyPartToPartYuv( rpcYuvPred, uiPartAddr, iWidth, iHeight );
1116	else
1117	#endif
1118	xWeightedPredictionBi( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
1119	}
1120	#if FIX_LGE_WP_FOR_3D_C0223
1121	else if ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType() == P_SLICE )
1122
1123	{
1124	#if MERL_VSP_C0152
1125	if(pcCU->getVSPIndex(uiPartAddr))
1126	m_acYuvPred[0].copyPartToPartYuv( rpcYuvPred, uiPartAddr, iWidth, iHeight );
1127	else
1128	#endif
1129	xWeightedPredictionUni( pcCU, &m_acYuvPred[0], uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, rpcYuvPred, iPartIdx );
1130	}
1131	#endif
1132	else
1133	{
1134	#if DEPTH_MAP_GENERATION
1135	if ( bPrdDepthMap )
1136	{
1137	xWeightedAveragePdm( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred, uiSubSampExpX, uiSubSampExpY );
1138	}
1139	else
1140	{
1141	#if MERL_VSP_C0152
1142	if(pcCU->getVSPIndex(uiPartAddr))
1143	m_acYuvPred[0].copyPartToPartYuv( rpcYuvPred, uiPartAddr, iWidth, iHeight );
1144	else
1145	#endif
1146	xWeightedAverage( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
1147	}
1148	#else
1149	xWeightedAverage( pcCU, &m_acYuvPred[0], &m_acYuvPred[1], iRefIdx[0], iRefIdx[1], uiPartAddr, iWidth, iHeight, rpcYuvPred );
1150	#endif
1151	}
1152	}
1153
1154
1155
1156	Void
1157	#if DEPTH_MAP_GENERATION
1158	TComPrediction::xPredInterPrdDepthMap( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight, UInt uiSubSampExpX, UInt uiSubSampExpY, TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset
1159	#if LGE_ILLUCOMP_DEPTH_C0046
1160	, Bool bICFlag
1161	#endif
1162	)
1163	#else
1164	TComPrediction::xPredInterPrdDepthMap( TComDataCU* pcCU, TComPicYuv* pcPicYuvRef, UInt uiPartAddr, TComMv* pcMv, Int iWidth, Int iHeight, TComYuv*& rpcYuv, UInt uiRShift, UInt uiOffset )
1165	#endif
1166	{
1167	#if DEPTH_MAP_GENERATION
1168	Int iShiftX = 2 + uiSubSampExpX;
1169	Int iShiftY = 2 + uiSubSampExpY;
1170	Int iAddX = ( 1 << iShiftX ) >> 1;
1171	Int iAddY = ( 1 << iShiftY ) >> 1;
1172	Int iHor = ( pcMv->getHor() + iAddX ) >> iShiftX;
1173	Int iVer = ( pcMv->getVer() + iAddY ) >> iShiftY;
1174	#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
1175	if( pcCU->getSlice()->getSPS()->isDepth() )
1176	{
1177	iHor = pcMv->getHor();
1178	iVer = pcMv->getVer();
1179	}
1180	#endif
1181	Int iRefStride = pcPicYuvRef->getStride();
1182	Int iDstStride = rpcYuv->getStride();
1183	Int iRefOffset = iHor + iVer * iRefStride;
1184	#else
1185	Int iFPelMask = ~3;
1186	Int iRefStride = pcPicYuvRef->getStride();
1187	Int iDstStride = rpcYuv->getStride();
1188	Int iHor = ( pcMv->getHor() + 2 ) & iFPelMask;
1189	Int iVer = ( pcMv->getVer() + 2 ) & iFPelMask;
1190	#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
1191	if( pcCU->getSlice()->getSPS()->isDepth() )
1192	{
1193	iHor = pcMv->getHor() * 4;
1194	iVer = pcMv->getVer() * 4;
1195	}
1196	#endif
1197	#if !QC_MVHEVC_B0046
1198	Int ixFrac = iHor & 0x3;
1199	Int iyFrac = iVer & 0x3;
1200	#endif
1201	Int iRefOffset = ( iHor >> 2 ) + ( iVer >> 2 ) * iRefStride;
1202	#endif
1203
1204	Pel* piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr ) + iRefOffset;
1205	Pel* piDstY = rpcYuv->getLumaAddr( uiPartAddr );
1206
1207	for( Int y = 0; y < iHeight; y++, piDstY += iDstStride, piRefY += iRefStride )
1208	{
1209	for( Int x = 0; x < iWidth; x++ )
1210	{
1211	piDstY[ x ] = ( piRefY[ x ] << uiRShift ) - uiOffset;
1212	}
1213	}
1214
1215	#if LGE_ILLUCOMP_DEPTH_C0046
1216	if(bICFlag)
1217	{
1218	Int a, b, iShift;
1219	TComMv tTmpMV(pcMv->getHor()<<2, pcMv->getVer()<<2);
1220
1221	piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr ) + iRefOffset;
1222	piDstY = rpcYuv->getLumaAddr( uiPartAddr );
1223
1224	xGetLLSICPrediction(pcCU, &tTmpMV, pcPicYuvRef, a, b, iShift);
1225
1226	for( Int y = 0; y < iHeight; y++, piDstY += iDstStride, piRefY += iRefStride )
1227	{
1228	for( Int x = 0; x < iWidth; x++ )
1229	{
1230	if(uiOffset)
1231	{
1232	Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
1233	piDstY[ x ] = ( (apiDstY[ x ]+aIF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
1234	}
1235	else
1236	piDstY[ x ] = Clip( ( (a*piDstY[ x ]) >> iShift ) + b );
1237	}
1238	}
1239	}
1240	#endif
1241	}
1242
1243
1244	/**
1245	* \brief Generate motion-compensated luma block
1246	*
1247	* \param cu Pointer to current CU
1248	* \param refPic Pointer to reference picture
1249	* \param partAddr Address of block within CU
1250	* \param mv Motion vector
1251	* \param width Width of block
1252	* \param height Height of block
1253	* \param dstPic Pointer to destination picture
1254	* \param bi Flag indicating whether bipred is used
1255	*/
1256	#if LGE_ILLUCOMP_B0045
1257	Void TComPrediction::xPredInterLumaBlk( TComDataCU cu, TComPicYuv refPic, UInt partAddr, TComMv mv, Int width, Int height, TComYuv &dstPic, Bool bi, Bool bICFlag)
1258	#else
1259	Void TComPrediction::xPredInterLumaBlk( TComDataCU cu, TComPicYuv refPic, UInt partAddr, TComMv mv, Int width, Int height, TComYuv &dstPic, Bool bi )
1260	#endif
1261	{
1262	Int refStride = refPic->getStride();
1263	Int refOffset = ( mv->getHor() >> 2 ) + ( mv->getVer() >> 2 ) * refStride;
1264	Pel *ref = refPic->getLumaAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1265
1266	Int dstStride = dstPic->getStride();
1267	Pel *dst = dstPic->getLumaAddr( partAddr );
1268
1269	Int xFrac = mv->getHor() & 0x3;
1270	Int yFrac = mv->getVer() & 0x3;
1271
1272	#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
1273	assert( ! cu->getSlice()->getIsDepth() \|\| ( xFrac == 0 && yFrac == 0 ) );
1274	#endif
1275
1276	if ( yFrac == 0 )
1277	{
1278	m_if.filterHorLuma( ref, refStride, dst, dstStride, width, height, xFrac, !bi );
1279	}
1280	else if ( xFrac == 0 )
1281	{
1282	m_if.filterVerLuma( ref, refStride, dst, dstStride, width, height, yFrac, true, !bi );
1283	}
1284	else
1285	{
1286	Int tmpStride = m_filteredBlockTmp[0].getStride();
1287	Short *tmp = m_filteredBlockTmp[0].getLumaAddr();
1288
1289	Int filterSize = NTAPS_LUMA;
1290	Int halfFilterSize = ( filterSize >> 1 );
1291
1292	m_if.filterHorLuma(ref - (halfFilterSize-1)*refStride, refStride, tmp, tmpStride, width, height+filterSize-1, xFrac, false );
1293	m_if.filterVerLuma(tmp + (halfFilterSize-1)*tmpStride, tmpStride, dst, dstStride, width, height, yFrac, false, !bi);
1294	}
1295
1296	#if LGE_ILLUCOMP_B0045
1297	if(bICFlag)
1298	{
1299	Int a, b, iShift, i, j;
1300
1301	xGetLLSICPrediction(cu, mv, refPic, a, b, iShift);
1302
1303	for (i = 0; i < height; i++)
1304	{
1305	for (j = 0; j < width; j++)
1306	{
1307	if(bi)
1308	{
1309	Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
1310	dst[j] = ( (adst[j]+aIF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
1311	}
1312	else
1313	dst[j] = Clip( ( (a*dst[j]) >> iShift ) + b );
1314	}
1315	dst += dstStride;
1316	}
1317	}
1318	#endif
1319	}
1320
1321	/**
1322	* \brief Generate motion-compensated chroma block
1323	*
1324	* \param cu Pointer to current CU
1325	* \param refPic Pointer to reference picture
1326	* \param partAddr Address of block within CU
1327	* \param mv Motion vector
1328	* \param width Width of block
1329	* \param height Height of block
1330	* \param dstPic Pointer to destination picture
1331	* \param bi Flag indicating whether bipred is used
1332	*/
1333	#if LGE_ILLUCOMP_B0045
1334	Void TComPrediction::xPredInterChromaBlk( TComDataCU cu, TComPicYuv refPic, UInt partAddr, TComMv mv, Int width, Int height, TComYuv &dstPic, Bool bi, Bool bICFlag )
1335	#else
1336	Void TComPrediction::xPredInterChromaBlk( TComDataCU cu, TComPicYuv refPic, UInt partAddr, TComMv mv, Int width, Int height, TComYuv &dstPic, Bool bi )
1337	#endif
1338	{
1339	Int refStride = refPic->getCStride();
1340	Int dstStride = dstPic->getCStride();
1341
1342	Int refOffset = (mv->getHor() >> 3) + (mv->getVer() >> 3) * refStride;
1343
1344	Pel* refCb = refPic->getCbAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1345	Pel* refCr = refPic->getCrAddr( cu->getAddr(), cu->getZorderIdxInCU() + partAddr ) + refOffset;
1346
1347	Pel* dstCb = dstPic->getCbAddr( partAddr );
1348	Pel* dstCr = dstPic->getCrAddr( partAddr );
1349
1350	Int xFrac = mv->getHor() & 0x7;
1351	Int yFrac = mv->getVer() & 0x7;
1352	UInt cxWidth = width >> 1;
1353	UInt cxHeight = height >> 1;
1354
1355	Int extStride = m_filteredBlockTmp[0].getStride();
1356	Short* extY = m_filteredBlockTmp[0].getLumaAddr();
1357
1358	Int filterSize = NTAPS_CHROMA;
1359
1360	Int halfFilterSize = (filterSize>>1);
1361
1362	if ( yFrac == 0 )
1363	{
1364	m_if.filterHorChroma(refCb, refStride, dstCb, dstStride, cxWidth, cxHeight, xFrac, !bi);
1365	m_if.filterHorChroma(refCr, refStride, dstCr, dstStride, cxWidth, cxHeight, xFrac, !bi);
1366	}
1367	else if ( xFrac == 0 )
1368	{
1369	m_if.filterVerChroma(refCb, refStride, dstCb, dstStride, cxWidth, cxHeight, yFrac, true, !bi);
1370	m_if.filterVerChroma(refCr, refStride, dstCr, dstStride, cxWidth, cxHeight, yFrac, true, !bi);
1371	}
1372	else
1373	{
1374	m_if.filterHorChroma(refCb - (halfFilterSize-1)*refStride, refStride, extY, extStride, cxWidth, cxHeight+filterSize-1, xFrac, false);
1375	m_if.filterVerChroma(extY + (halfFilterSize-1)*extStride, extStride, dstCb, dstStride, cxWidth, cxHeight , yFrac, false, !bi);
1376
1377	m_if.filterHorChroma(refCr - (halfFilterSize-1)*refStride, refStride, extY, extStride, cxWidth, cxHeight+filterSize-1, xFrac, false);
1378	m_if.filterVerChroma(extY + (halfFilterSize-1)*extStride, extStride, dstCr, dstStride, cxWidth, cxHeight , yFrac, false, !bi);
1379	}
1380	#if LGE_ILLUCOMP_B0045
1381	if(bICFlag)
1382	{
1383	Int a, b, iShift, i, j;
1384	xGetLLSICPredictionChroma(cu, mv, refPic, a, b, iShift, 0); // Cb
1385	for (i = 0; i < cxHeight; i++)
1386	{
1387	for (j = 0; j < cxWidth; j++)
1388	{
1389	if(bi)
1390	{
1391	Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
1392	dstCb[j] = ( (adstCb[j]+aIF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
1393	}
1394	else
1395	dstCb[j] = Clip3(0, 255, ((a*dstCb[j])>>iShift)+b);
1396	}
1397	dstCb += dstStride;
1398	}
1399
1400	xGetLLSICPredictionChroma(cu, mv, refPic, a, b, iShift, 1); // Cr
1401	for (i = 0; i < cxHeight; i++)
1402	{
1403	for (j = 0; j < cxWidth; j++)
1404	{
1405	if(bi)
1406	{
1407	Int iIFshift = IF_INTERNAL_PREC - ( g_uiBitDepth + g_uiBitIncrement );
1408	dstCr[j] = ( (adstCr[j]+aIF_INTERNAL_OFFS) >> iShift ) + b*(1<<iIFshift) - IF_INTERNAL_OFFS;
1409	}
1410	else
1411	dstCr[j] = Clip3(0, 255, ((a*dstCr[j])>>iShift)+b);
1412	}
1413	dstCr += dstStride;
1414	}
1415	}
1416	#endif
1417	}
1418
1419	#if MERL_VSP_C0152
1420	// Input:
1421	// refPic: Ref picture. Full picture, with padding
1422	// posX, posY: PU position, texture
1423	// size_x, size_y: PU size
1424	// partAddr: z-order index
1425	// mv: disparity vector. derived from neighboring blocks
1426	//
1427	// Output: dstPic, PU predictor 64x64
1428	Void TComPrediction::xPredInterLumaBlkFromDM( TComPicYuv refPic, TComPicYuv pPicBaseDepth, Int* pShiftLUT, Int iShiftPrec, TComMv* mv, UInt partAddr,Int posX, Int posY, Int size_x, Int size_y, Bool isDepth, Int vspIdx
1429	, TComYuv *&dstPic )
1430	{
1431	Int widthLuma;
1432	Int heightLuma;
1433
1434	if (isDepth)
1435	{
1436	widthLuma = pPicBaseDepth->getWidth();
1437	heightLuma = pPicBaseDepth->getHeight();
1438	}
1439	else
1440	{
1441	widthLuma = refPic->getWidth();
1442	heightLuma = refPic->getHeight();
1443	}
1444
1445	#if MERL_VSP_BLOCKSIZE_C0152 != 1
1446	Int widthDepth = pPicBaseDepth->getWidth();
1447	Int heightDepth = pPicBaseDepth->getHeight();
1448	#endif
1449
1450	Int nTxtPerDepthX = widthLuma / ( pPicBaseDepth->getWidth() ); // texture pixel # per depth pixel
1451	Int nTxtPerDepthY = heightLuma / ( pPicBaseDepth->getHeight() );
1452
1453	Int refStride = refPic->getStride();
1454	Int dstStride = dstPic->getStride();
1455	Int depStride = pPicBaseDepth->getStride();
1456	#if MTK_DVPREFINE_BVSP_BUG_FIX
1457	Int depthPosX = Clip3(0, widthLuma - size_x, (posX/nTxtPerDepthX) + (mv->getHor()>>2));
1458	Int depthPosY = Clip3(0, heightLuma- size_y, (posY/nTxtPerDepthY) + (mv->getVer()>>2));
1459	#else
1460	Int depthPosX = Clip3(0, widthLuma - size_x - 1, (posX/nTxtPerDepthX) + (mv->getHor()>>2));
1461	Int depthPosY = Clip3(0, heightLuma- size_y - 1, (posY/nTxtPerDepthY) + (mv->getVer()>>2));
1462	#endif
1463	Pel ref = refPic->getLumaAddr() + posX + posY refStride;
1464	Pel *dst = dstPic->getLumaAddr(partAddr);
1465	Pel depth = pPicBaseDepth->getLumaAddr() + depthPosX + depthPosY depStride;
1466
1467	#if MERL_VSP_BLOCKSIZE_C0152 != 1
1468	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1469	Int dW = size_x>>1;
1470	Int dH = size_y>>1;
1471	#endif
1472	#if MERL_VSP_BLOCKSIZE_C0152 == 4
1473	Int dW = size_x>>2;
1474	Int dH = size_y>>2;
1475	#endif
1476	{
1477	Pel* depthi = depth;
1478	for (Int j = 0; j < dH; j++)
1479	{
1480	for (Int i = 0; i < dW; i++)
1481	{
1482	Pel* depthTmp;
1483	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1484	if (depthPosX + (i<<1) < widthDepth)
1485	depthTmp = depthi + (i << 1);
1486	else
1487	depthTmp = depthi + (widthDepth - depthPosX - 1);
1488	#endif
1489	#if MERL_VSP_BLOCKSIZE_C0152 == 4
1490	if (depthPosX + (i<<2) < widthDepth)
1491	depthTmp = depthi + (i << 2);
1492	else
1493	depthTmp = depthi + (widthDepth - depthPosX - 1);
1494	#endif
1495	Int maxV = 0;
1496	for (Int blockj = 0; blockj < MERL_VSP_BLOCKSIZE_C0152; blockj++)
1497	{
1498	Int iX = 0;
1499	for (Int blocki = 0; blocki < MERL_VSP_BLOCKSIZE_C0152; blocki++)
1500	{
1501	if (maxV < depthTmp[iX])
1502	maxV = depthTmp[iX];
1503	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1504	if (depthPosX + (i<<1) + blocki < widthDepth - 1)
1505	#else // MERL_VSP_BLOCKSIZE_C0152 == 4
1506	if (depthPosX + (i<<2) + blocki < widthDepth - 1)
1507	#endif
1508	iX++;
1509	}
1510	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1511	if (depthPosY + (j<<1) + blockj < heightDepth - 1)
1512	#else // MERL_VSP_BLOCKSIZE_C0152 == 4
1513	if (depthPosY + (j<<2) + blockj < heightDepth - 1)
1514	#endif
1515	depthTmp += depStride;
1516	}
1517	m_pDepth[i+j*dW] = maxV;
1518	} // end of i < dW
1519	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1520	if (depthPosY + ((j+1)<<1) < heightDepth)
1521	depthi += (depStride << 1);
1522	else
1523	depthi = depth + (heightDepth-depthPosY-1)*depStride;
1524	#endif
1525	#if MERL_VSP_BLOCKSIZE_C0152 == 4
1526	if (depthPosY + ((j+1)<<2) < heightDepth) // heightDepth-1
1527	depthi += (depStride << 2);
1528	else
1529	depthi = depth + (heightDepth-depthPosY-1)*depStride; // the last line
1530	#endif
1531	}
1532	}
1533	#endif
1534
1535	#if MERL_VSP_BLOCKSIZE_C0152 != 1
1536	Int yDepth = 0;
1537	#endif
1538	for ( Int yTxt = 0; yTxt < size_y; yTxt += nTxtPerDepthY )
1539	{
1540	for ( Int xTxt = 0, xDepth = 0; xTxt < size_x; xTxt += nTxtPerDepthX, xDepth++ )
1541	{
1542	Pel rep_depth = 0; // to store the depth value used for warping
1543	#if MERL_VSP_BLOCKSIZE_C0152 == 1
1544	rep_depth = depth[xDepth];
1545	#endif
1546	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1547	rep_depth = m_pDepth[(xTxt>>1) + (yTxt>>1)*dW];
1548	#endif
1549	#if MERL_VSP_BLOCKSIZE_C0152 == 4
1550	rep_depth = m_pDepth[(xTxt>>2) + (yTxt>>2)*dW];
1551	#endif
1552
1553	assert( rep_depth >= 0 && rep_depth <= 255 );
1554	Int disparity = pShiftLUT[ rep_depth ] << iShiftPrec;
1555	Int refOffset = xTxt + (disparity >> 2);
1556	Int xFrac = disparity & 0x3;
1557	Int absX = posX + refOffset;
1558
1559	if (xFrac == 0)
1560	absX = Clip3(0, widthLuma-1, absX);
1561	else
1562	absX = Clip3(4, widthLuma-5, absX);
1563
1564	refOffset = absX - posX;
1565
1566	assert( ref[refOffset] >= 0 && ref[refOffset]<= 255 );
1567	m_if.filterHorLuma( &ref[refOffset], refStride, &dst[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true );
1568	}
1569	ref += refStride*nTxtPerDepthY;
1570	dst += dstStride*nTxtPerDepthY;
1571	depth += depStride;
1572	#if MERL_VSP_BLOCKSIZE_C0152 != 1
1573	yDepth++;
1574	#endif
1575	}
1576	}
1577
1578	Void TComPrediction::xPredInterChromaBlkFromDM ( TComPicYuv refPic, TComPicYuv pPicBaseDepth, Int* pShiftLUT, Int iShiftPrec, TComMv*mv, UInt partAddr, Int posX, Int posY, Int size_x, Int size_y, Bool isDepth, Int vspIdx
1579	, TComYuv *&dstPic )
1580	{
1581	Int refStride = refPic->getCStride();
1582	Int dstStride = dstPic->getCStride();
1583	Int depStride = pPicBaseDepth->getStride();
1584
1585	Int widthChroma, heightChroma;
1586	if( isDepth)
1587	{
1588	widthChroma = pPicBaseDepth->getWidth()>>1;
1589	heightChroma = pPicBaseDepth->getHeight()>>1;
1590	}
1591	else
1592	{
1593	widthChroma = refPic->getWidth()>>1;
1594	heightChroma = refPic->getHeight()>>1;
1595	}
1596
1597	// Below is only for Texture chroma component
1598
1599	Int widthDepth = pPicBaseDepth->getWidth();
1600	Int heightDepth = pPicBaseDepth->getHeight();
1601
1602	Int nTxtPerDepthX, nTxtPerDepthY; // Number of texture samples per one depth sample
1603	Int nDepthPerTxtX, nDepthPerTxtY; // Number of depth samples per one texture sample
1604
1605	Int depthPosX; // Starting position in depth image
1606	Int depthPosY;
1607
1608	if ( widthChroma > widthDepth )
1609	{
1610	nTxtPerDepthX = widthChroma / widthDepth;
1611	nDepthPerTxtX = 1;
1612	depthPosX = posX / nTxtPerDepthX + (mv->getHor()>>2); //mv denotes the disparity for VSP
1613	}
1614	else
1615	{
1616	nTxtPerDepthX = 1;
1617	nDepthPerTxtX = widthDepth / widthChroma;
1618	depthPosX = posX * nDepthPerTxtX + (mv->getHor()>>2); //mv denotes the disparity for VSP
1619	}
1620	#if MTK_DVPREFINE_BVSP_BUG_FIX
1621	depthPosX = Clip3(0, widthDepth - (size_x<<1), depthPosX);
1622	#else
1623	depthPosX = Clip3(0, widthDepth - (size_x<<1) - 1, depthPosX);
1624	#endif
1625	if ( heightChroma > heightDepth )
1626	{
1627	nTxtPerDepthY = heightChroma / heightDepth;
1628	nDepthPerTxtY = 1;
1629	depthPosY = posY / nTxtPerDepthY + (mv->getVer()>>2); //mv denotes the disparity for VSP
1630	}
1631	else
1632	{
1633	nTxtPerDepthY = 1;
1634	nDepthPerTxtY = heightDepth / heightChroma;
1635	depthPosY = posY * nDepthPerTxtY + (mv->getVer()>>2); //mv denotes the disparity for VSP
1636	}
1637	#if MTK_DVPREFINE_BVSP_BUG_FIX
1638	depthPosY = Clip3(0, heightDepth - (size_y<<1), depthPosY);
1639	#else
1640	depthPosY = Clip3(0, heightDepth - (size_y<<1) - 1, depthPosY);
1641	#endif
1642
1643	Pel refCb = refPic->getCbAddr() + posX + posY refStride;
1644	Pel refCr = refPic->getCrAddr() + posX + posY refStride;
1645	Pel *dstCb = dstPic->getCbAddr(partAddr);
1646	Pel *dstCr = dstPic->getCrAddr(partAddr);
1647	Pel depth = pPicBaseDepth->getLumaAddr() + depthPosX + depthPosY depStride; // move the pointer to the current depth pixel position
1648
1649	Int refStrideBlock = refStride * nTxtPerDepthY;
1650	Int dstStrideBlock = dstStride * nTxtPerDepthY;
1651	Int depStrideBlock = depStride * nDepthPerTxtY;
1652
1653	if (isDepth)
1654	{
1655	// DT: Since the call for this function is redundant, ..
1656	for (Int y = 0; y < size_y; y++)
1657	{
1658	for (Int x = 0; x < size_x; x++)
1659	{
1660	dstCb[x] = 128;
1661	dstCr[x] = 128;
1662	}
1663	dstCb += dstStride;
1664	dstCr += dstStride;
1665	}
1666	return;
1667	}
1668
1669	if ( widthChroma > widthDepth ) // We assume
1670	{
1671	assert( heightChroma > heightDepth );
1672	printf("This branch should never been reached.\n");
1673	exit(0);
1674	}
1675	else
1676	{
1677	#if MERL_VSP_BLOCKSIZE_C0152 == 1
1678	Int dW = size_x;
1679	Int dH = size_y;
1680	Int sW = 2; // search window size
1681	Int sH = 2;
1682	#endif
1683	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1684	Int dW = size_x;
1685	Int dH = size_y;
1686	Int sW = 2; // search window size
1687	Int sH = 2;
1688	#endif
1689	#if MERL_VSP_BLOCKSIZE_C0152 == 4
1690	Int dW = size_x>>1;
1691	Int dH = size_y>>1;
1692	Int sW = 4; // search window size
1693	Int sH = 4;
1694	#endif
1695
1696	{
1697	Pel* depthi = depth;
1698	for (Int j = 0; j < dH; j++)
1699	{
1700	for (Int i = 0; i < dW; i++)
1701	{
1702	Pel* depthTmp;
1703	#if MERL_VSP_BLOCKSIZE_C0152 == 1
1704	depthTmp = depthi + (i << 1);
1705	#endif
1706	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1707	if (depthPosX + (i<<1) < widthDepth)
1708	depthTmp = depthi + (i << 1);
1709	else
1710	depthTmp = depthi + (widthDepth - depthPosX - 1);
1711	#endif
1712	#if MERL_VSP_BLOCKSIZE_C0152 == 4
1713	if (depthPosX + (i<<2) < widthDepth)
1714	depthTmp = depthi + (i << 2);
1715	else
1716	depthTmp = depthi + (widthDepth - depthPosX - 1);
1717	#endif
1718	Int maxV = 0;
1719	for (Int blockj = 0; blockj < sH; blockj++)
1720	{
1721	Int iX = 0;
1722	for (Int blocki = 0; blocki < sW; blocki++)
1723	{
1724	if (maxV < depthTmp[iX])
1725	maxV = depthTmp[iX];
1726	if (depthPosX + i*sW + blocki < widthDepth - 1)
1727	iX++;
1728	}
1729	if (depthPosY + j*sH + blockj < heightDepth - 1)
1730	depthTmp += depStride;
1731	}
1732	m_pDepth[i+j*dW] = maxV;
1733	} // end of i < dW
1734	#if MERL_VSP_BLOCKSIZE_C0152 == 1
1735	if (depthPosY + ((j+1)<<1) < heightDepth)
1736	depthi += (depStride << 1);
1737	else
1738	depthi = depth + (heightDepth-1)*depStride;
1739	#endif
1740	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1741	if (depthPosY + ((j+1)<<1) < heightDepth)
1742	depthi += (depStride << 1);
1743	else
1744	depthi = depth + (heightDepth-depthPosY-1)*depStride;
1745	#endif
1746	#if MERL_VSP_BLOCKSIZE_C0152 == 4
1747	if (depthPosY + ((j+1)<<2) < heightDepth) // heightDepth-1
1748	depthi += (depStride << 2);
1749	else
1750	depthi = depth + (heightDepth-depthPosY-1)*depStride; // the last line
1751	#endif
1752	}
1753	}
1754
1755
1756	// (size_x, size_y) is Chroma block size
1757	for ( Int yTxt = 0, yDepth = 0; yTxt < size_y; yTxt += nTxtPerDepthY, yDepth += nDepthPerTxtY )
1758	{
1759	for ( Int xTxt = 0, xDepth = 0; xTxt < size_x; xTxt += nTxtPerDepthX, xDepth += nDepthPerTxtX )
1760	{
1761	Pel rep_depth = 0; // to store the depth value used for warping
1762	#if MERL_VSP_BLOCKSIZE_C0152 == 1
1763	rep_depth = m_pDepth[(xTxt) + (yTxt)*dW];
1764	#endif
1765	#if MERL_VSP_BLOCKSIZE_C0152 == 2
1766	rep_depth = m_pDepth[(xTxt) + (yTxt)*dW];
1767	#endif
1768	#if MERL_VSP_BLOCKSIZE_C0152 == 4
1769	rep_depth = m_pDepth[(xTxt>>1) + (yTxt>>1)*dW];
1770	#endif
1771
1772	// calculate the offset in the reference picture
1773	Int disparity = pShiftLUT[ rep_depth ] << iShiftPrec;
1774	Int refOffset = xTxt + (disparity >> 3); // in integer pixel in chroma image
1775	Int xFrac = disparity & 0x7;
1776	Int absX = posX + refOffset;
1777
1778	if (xFrac == 0)
1779	absX = Clip3(0, widthChroma-1, absX);
1780	else
1781	absX = Clip3(4, widthChroma-5, absX);
1782
1783	refOffset = absX - posX;
1784
1785	assert( refCb[refOffset] >= 0 && refCb[refOffset]<= 255 );
1786	assert( refCr[refOffset] >= 0 && refCr[refOffset]<= 255 );
1787	m_if.filterHorChroma(&refCb[refOffset], refStride, &dstCb[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true);
1788	m_if.filterHorChroma(&refCr[refOffset], refStride, &dstCr[xTxt], dstStride, nTxtPerDepthX, nTxtPerDepthY, xFrac, true);
1789	}
1790	refCb += refStrideBlock;
1791	refCr += refStrideBlock;
1792	dstCb += dstStrideBlock;
1793	dstCr += dstStrideBlock;
1794	depth += depStrideBlock;
1795	}
1796	}
1797	}
1798
1799	#endif // MERL_VSP_C0152
1800
1801	#if DEPTH_MAP_GENERATION
1802	Void TComPrediction::xWeightedAveragePdm( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst, UInt uiSubSampExpX, UInt uiSubSampExpY )
1803	{
1804	if( iRefIdx0 >= 0 && iRefIdx1 >= 0 )
1805	{
1806	rpcYuvDst->addAvgPdm( pcYuvSrc0, pcYuvSrc1, uiPartIdx, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY );
1807	}
1808	else if ( iRefIdx0 >= 0 && iRefIdx1 < 0 )
1809	{
1810	pcYuvSrc0->copyPartToPartYuvPdm( rpcYuvDst, uiPartIdx, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY );
1811	}
1812	else if ( iRefIdx0 < 0 && iRefIdx1 >= 0 )
1813	{
1814	pcYuvSrc1->copyPartToPartYuvPdm( rpcYuvDst, uiPartIdx, iWidth, iHeight, uiSubSampExpX, uiSubSampExpY );
1815	}
1816	else
1817	{
1818	assert (0);
1819	}
1820	}
1821	#endif
1822
1823	Void TComPrediction::xWeightedAverage( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv*& rpcYuvDst )
1824	{
1825	if( iRefIdx0 >= 0 && iRefIdx1 >= 0 )
1826	{
1827	rpcYuvDst->addAvg( pcYuvSrc0, pcYuvSrc1, uiPartIdx, iWidth, iHeight );
1828	}
1829	else if ( iRefIdx0 >= 0 && iRefIdx1 < 0 )
1830	{
1831	pcYuvSrc0->copyPartToPartYuv( rpcYuvDst, uiPartIdx, iWidth, iHeight );
1832	}
1833	else if ( iRefIdx0 < 0 && iRefIdx1 >= 0 )
1834	{
1835	pcYuvSrc1->copyPartToPartYuv( rpcYuvDst, uiPartIdx, iWidth, iHeight );
1836	}
1837	}
1838
1839	// AMVP
1840	Void TComPrediction::getMvPredAMVP( TComDataCU* pcCU, UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMvPred )
1841	{
1842	AMVPInfo* pcAMVPInfo = pcCU->getCUMvField(eRefPicList)->getAMVPInfo();
1843
1844	if( pcCU->getAMVPMode(uiPartAddr) == AM_NONE \|\| (pcAMVPInfo->iN <= 1 && pcCU->getAMVPMode(uiPartAddr) == AM_EXPL) )
1845	{
1846	rcMvPred = pcAMVPInfo->m_acMvCand[0];
1847
1848	pcCU->setMVPIdxSubParts( 0, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
1849	pcCU->setMVPNumSubParts( pcAMVPInfo->iN, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
1850	return;
1851	}
1852
1853	assert(pcCU->getMVPIdx(eRefPicList,uiPartAddr) >= 0);
1854	rcMvPred = pcAMVPInfo->m_acMvCand[pcCU->getMVPIdx(eRefPicList,uiPartAddr)];
1855	return;
1856	}
1857
1858	/** Function for deriving planar intra prediction.
1859	* \param pSrc pointer to reconstructed sample array
1860	* \param srcStride the stride of the reconstructed sample array
1861	* \param rpDst reference to pointer for the prediction sample array
1862	* \param dstStride the stride of the prediction sample array
1863	* \param width the width of the block
1864	* \param height the height of the block
1865	*
1866	* This function derives the prediction samples for planar mode (intra coding).
1867	*/
1868	Void TComPrediction::xPredIntraPlanar( Int* pSrc, Int srcStride, Pel* rpDst, Int dstStride, UInt width, UInt height )
1869	{
1870	assert(width == height);
1871
1872	Int k, l, bottomLeft, topRight;
1873	Int horPred;
1874	Int leftColumn[MAX_CU_SIZE], topRow[MAX_CU_SIZE], bottomRow[MAX_CU_SIZE], rightColumn[MAX_CU_SIZE];
1875	UInt blkSize = width;
1876	UInt offset2D = width;
1877	UInt shift1D = g_aucConvertToBit[ width ] + 2;
1878	UInt shift2D = shift1D + 1;
1879
1880	// Get left and above reference column and row
1881	for(k=0;k<blkSize+1;k++)
1882	{
1883	topRow[k] = pSrc[k-srcStride];
1884	leftColumn[k] = pSrc[k*srcStride-1];
1885	}
1886
1887	// Prepare intermediate variables used in interpolation
1888	bottomLeft = leftColumn[blkSize];
1889	topRight = topRow[blkSize];
1890	for (k=0;k<blkSize;k++)
1891	{
1892	bottomRow[k] = bottomLeft - topRow[k];
1893	rightColumn[k] = topRight - leftColumn[k];
1894	topRow[k] <<= shift1D;
1895	leftColumn[k] <<= shift1D;
1896	}
1897
1898	// Generate prediction signal
1899	for (k=0;k<blkSize;k++)
1900	{
1901	horPred = leftColumn[k] + offset2D;
1902	for (l=0;l<blkSize;l++)
1903	{
1904	horPred += rightColumn[k];
1905	topRow[l] += bottomRow[l];
1906	rpDst[k*dstStride+l] = ( (horPred + topRow[l]) >> shift2D );
1907	}
1908	}
1909	}
1910
1911	/** Function for deriving chroma LM intra prediction.
1912	* \param pcPattern pointer to neighbouring pixel access pattern
1913	* \param piSrc pointer to reconstructed chroma sample array
1914	* \param pPred pointer for the prediction sample array
1915	* \param uiPredStride the stride of the prediction sample array
1916	* \param uiCWidth the width of the chroma block
1917	* \param uiCHeight the height of the chroma block
1918	* \param uiChromaId boolean indication of chroma component
1919	*
1920	* This function derives the prediction samples for chroma LM mode (chroma intra coding)
1921	*/
1922	Void TComPrediction::predLMIntraChroma( TComPattern* pcPattern, Int* piSrc, Pel* pPred, UInt uiPredStride, UInt uiCWidth, UInt uiCHeight, UInt uiChromaId )
1923	{
1924	UInt uiWidth = 2 * uiCWidth;
1925
1926	xGetLLSPrediction( pcPattern, piSrc+uiWidth+2, uiWidth+1, pPred, uiPredStride, uiCWidth, uiCHeight, 1 );
1927	}
1928
1929	/** Function for deriving downsampled luma sample of current chroma block and its above, left causal pixel
1930	* \param pcPattern pointer to neighbouring pixel access pattern
1931	* \param uiCWidth the width of the chroma block
1932	* \param uiCHeight the height of the chroma block
1933	*
1934	* This function derives downsampled luma sample of current chroma block and its above, left causal pixel
1935	*/
1936	Void TComPrediction::getLumaRecPixels( TComPattern* pcPattern, UInt uiCWidth, UInt uiCHeight )
1937	{
1938	UInt uiWidth = 2 * uiCWidth;
1939	UInt uiHeight = 2 * uiCHeight;
1940
1941	Pel* pRecSrc = pcPattern->getROIY();
1942	Pel* pDst0 = m_pLumaRecBuffer + m_iLumaRecStride + 1;
1943
1944	Int iRecSrcStride = pcPattern->getPatternLStride();
1945	Int iRecSrcStride2 = iRecSrcStride << 1;
1946	Int iDstStride = m_iLumaRecStride;
1947	Int iSrcStride = ( max( uiWidth, uiHeight ) << 1 ) + 1;
1948
1949	Int* ptrSrc = pcPattern->getAdiOrgBuf( uiWidth, uiHeight, m_piYuvExt );
1950
1951	// initial pointers
1952	Pel* pDst = pDst0 - 1 - iDstStride;
1953	Int* piSrc = ptrSrc;
1954
1955	// top left corner downsampled from ADI buffer
1956	// don't need this point
1957
1958	// top row downsampled from ADI buffer
1959	pDst++;
1960	piSrc ++;
1961	for (Int i = 0; i < uiCWidth; i++)
1962	{
1963	pDst[i] = ((piSrc[2i] 2 ) + piSrc[2i - 1] + piSrc[2i + 1] + 2) >> 2;
1964	}
1965
1966	// left column downsampled from ADI buffer
1967	pDst = pDst0 - 1;
1968	piSrc = ptrSrc + iSrcStride;
1969	for (Int j = 0; j < uiCHeight; j++)
1970	{
1971	pDst[0] = ( piSrc[0] + piSrc[iSrcStride] ) >> 1;
1972	piSrc += iSrcStride << 1;
1973	pDst += iDstStride;
1974	}
1975
1976	// inner part from reconstructed picture buffer
1977	for( Int j = 0; j < uiCHeight; j++ )
1978	{
1979	for (Int i = 0; i < uiCWidth; i++)
1980	{
1981	pDst0[i] = (pRecSrc[2i] + pRecSrc[2i + iRecSrcStride]) >> 1;
1982	}
1983
1984	pDst0 += iDstStride;
1985	pRecSrc += iRecSrcStride2;
1986	}
1987	}
1988
1989	/** Function for deriving the positon of first non-zero binary bit of a value
1990	* \param x input value
1991	*
1992	* This function derives the positon of first non-zero binary bit of a value
1993	*/
1994	Int GetMSB( UInt x )
1995	{
1996	Int iMSB = 0, bits = ( sizeof( Int ) << 3 ), y = 1;
1997
1998	while( x > 1 )
1999	{
2000	bits >>= 1;
2001	y = x >> bits;
2002
2003	if( y )
2004	{
2005	x = y;
2006	iMSB += bits;
2007	}
2008	}
2009
2010	iMSB+=y;
2011
2012	return iMSB;
2013	}
2014
2015	/** Function for counting leading number of zeros/ones
2016	* \param x input value
2017	\ This function counts leading number of zeros for positive numbers and
2018	\ leading number of ones for negative numbers. This can be implemented in
2019	\ single instructure cycle on many processors.
2020	*/
2021
2022	Short CountLeadingZerosOnes (Short x)
2023	{
2024	Short clz;
2025	Short i;
2026
2027	if(x == 0)
2028	{
2029	clz = 0;
2030	}
2031	else
2032	{
2033	if (x == -1)
2034	{
2035	clz = 15;
2036	}
2037	else
2038	{
2039	if(x < 0)
2040	{
2041	x = ~x;
2042	}
2043	clz = 15;
2044	for(i = 0;i < 15;++i)
2045	{
2046	if(x)
2047	{
2048	clz --;
2049	}
2050	x = x >> 1;
2051	}
2052	}
2053	}
2054	return clz;
2055	}
2056
2057	/** Function for deriving LM intra prediction.
2058	* \param pcPattern pointer to neighbouring pixel access pattern
2059	* \param pSrc0 pointer to reconstructed chroma sample array
2060	* \param iSrcStride the stride of reconstructed chroma sample array
2061	* \param pDst0 reference to pointer for the prediction sample array
2062	* \param iDstStride the stride of the prediction sample array
2063	* \param uiWidth the width of the chroma block
2064	* \param uiHeight the height of the chroma block
2065	* \param uiExt0 line number of neiggboirng pixels for calculating LM model parameter, default value is 1
2066	*
2067	* This function derives the prediction samples for chroma LM mode (chroma intra coding)
2068	*/
2069	Void TComPrediction::xGetLLSPrediction( TComPattern* pcPattern, Int* pSrc0, Int iSrcStride, Pel* pDst0, Int iDstStride, UInt uiWidth, UInt uiHeight, UInt uiExt0 )
2070	{
2071
2072	Pel pDst, pLuma;
2073	Int *pSrc;
2074
2075	Int iLumaStride = m_iLumaRecStride;
2076	Pel* pLuma0 = m_pLumaRecBuffer + uiExt0 * iLumaStride + uiExt0;
2077
2078	Int i, j, iCountShift = 0;
2079
2080	UInt uiExt = uiExt0;
2081
2082	// LLS parameters estimation -->
2083
2084	Int x = 0, y = 0, xx = 0, xy = 0;
2085
2086	pSrc = pSrc0 - iSrcStride;
2087	pLuma = pLuma0 - iLumaStride;
2088
2089	for( j = 0; j < uiWidth; j++ )
2090	{
2091	x += pLuma[j];
2092	y += pSrc[j];
2093	xx += pLuma[j] * pLuma[j];
2094	xy += pLuma[j] * pSrc[j];
2095	}
2096	iCountShift += g_aucConvertToBit[ uiWidth ] + 2;
2097
2098	pSrc = pSrc0 - uiExt;
2099	pLuma = pLuma0 - uiExt;
2100
2101	for( i = 0; i < uiHeight; i++ )
2102	{
2103	x += pLuma[0];
2104	y += pSrc[0];
2105	xx += pLuma[0] * pLuma[0];
2106	xy += pLuma[0] * pSrc[0];
2107
2108	pSrc += iSrcStride;
2109	pLuma += iLumaStride;
2110	}
2111	iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 2 );
2112
2113	Int iTempShift = ( g_uiBitDepth + g_uiBitIncrement ) + g_aucConvertToBit[ uiWidth ] + 3 - 15;
2114
2115	if(iTempShift > 0)
2116	{
2117	x = ( x + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2118	y = ( y + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2119	xx = ( xx + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2120	xy = ( xy + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2121	iCountShift -= iTempShift;
2122	}
2123
2124	Int a, b, iShift = 13;
2125
2126	if( iCountShift == 0 )
2127	{
2128	a = 0;
2129	b = 1 << (g_uiBitDepth + g_uiBitIncrement - 1);
2130	iShift = 0;
2131	}
2132	else
2133	{
2134	Int a1 = ( xy << iCountShift ) - y * x;
2135	Int a2 = ( xx << iCountShift ) - x * x;
2136
2137	{
2138	const Int iShiftA2 = 6;
2139	const Int iShiftA1 = 15;
2140	const Int iAccuracyShift = 15;
2141
2142	Int iScaleShiftA2 = 0;
2143	Int iScaleShiftA1 = 0;
2144	Int a1s = a1;
2145	Int a2s = a2;
2146
2147	iScaleShiftA1 = GetMSB( abs( a1 ) ) - iShiftA1;
2148	iScaleShiftA2 = GetMSB( abs( a2 ) ) - iShiftA2;
2149
2150	if( iScaleShiftA1 < 0 )
2151	{
2152	iScaleShiftA1 = 0;
2153	}
2154
2155	if( iScaleShiftA2 < 0 )
2156	{
2157	iScaleShiftA2 = 0;
2158	}
2159
2160	Int iScaleShiftA = iScaleShiftA2 + iAccuracyShift - iShift - iScaleShiftA1;
2161
2162	a2s = a2 >> iScaleShiftA2;
2163
2164	a1s = a1 >> iScaleShiftA1;
2165
2166	if (a2s >= 1)
2167	{
2168	a = a1s * m_uiaShift[ a2s - 1];
2169	}
2170	else
2171	{
2172	a = 0;
2173	}
2174
2175	if( iScaleShiftA < 0 )
2176	{
2177	a = a << -iScaleShiftA;
2178	}
2179	else
2180	{
2181	a = a >> iScaleShiftA;
2182	}
2183
2184	a = Clip3(-( 1 << 15 ), ( 1 << 15 ) - 1, a);
2185
2186	Int minA = -(1 << (6));
2187	Int maxA = (1 << 6) - 1;
2188	if( a <= maxA && a >= minA )
2189	{
2190	// do nothing
2191	}
2192	else
2193	{
2194	Short n = CountLeadingZerosOnes(a);
2195	a = a >> (9-n);
2196	iShift -= (9-n);
2197	}
2198
2199	b = ( y - ( ( a * x ) >> iShift ) + ( 1 << ( iCountShift - 1 ) ) ) >> iCountShift;
2200	}
2201	}
2202
2203	// <-- end of LLS parameters estimation
2204
2205	// get prediction -->
2206	uiExt = uiExt0;
2207	pLuma = pLuma0;
2208	pDst = pDst0;
2209
2210	for( i = 0; i < uiHeight; i++ )
2211	{
2212	for( j = 0; j < uiWidth; j++ )
2213	{
2214	pDst[j] = Clip( ( ( a * pLuma[j] ) >> iShift ) + b );
2215	}
2216
2217	pDst += iDstStride;
2218	pLuma += iLumaStride;
2219	}
2220	// <-- end of get prediction
2221
2222	}
2223
2224
2225	#if LGE_ILLUCOMP_B0045
2226	/** Function for deriving LM illumination compensation.
2227	*/
2228	Void TComPrediction::xGetLLSICPrediction(TComDataCU* pcCU, TComMv pMv, TComPicYuv pRefPic, Int &a, Int &b, Int &iShift)
2229	{
2230	TComPicYuv *pRecPic = pcCU->getPic()->getPicYuvRec();
2231	Pel pRec, pRef;
2232	UInt uiWidth, uiHeight, uiTmpPartIdx;
2233	Int iRecStride = pRecPic->getStride(), iRefStride = pRefPic->getStride();
2234	Int iCUPelX, iCUPelY, iRefX, iRefY, iRefOffset;
2235
2236	iCUPelX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
2237	iCUPelY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
2238	iRefX = iCUPelX + (pMv->getHor() >> 2);
2239	iRefY = iCUPelY + (pMv->getVer() >> 2);
2240	uiWidth = pcCU->getWidth(0);
2241	uiHeight = pcCU->getHeight(0);
2242
2243	Int i, j, iCountShift = 0;
2244
2245	// LLS parameters estimation -->
2246
2247	Int x = 0, y = 0, xx = 0, xy = 0;
2248
2249	if(pcCU->getPUAbove(uiTmpPartIdx, pcCU->getZorderIdxInCU()) && iCUPelY > 0 && iRefY > 0)
2250	{
2251	iRefOffset = ( pMv->getHor() >> 2 ) + ( pMv->getVer() >> 2 ) * iRefStride - iRefStride;
2252	pRef = pRefPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
2253	pRec = pRecPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
2254
2255	for( j = 0; j < uiWidth; j++ )
2256	{
2257	x += pRef[j];
2258	y += pRec[j];
2259	xx += pRef[j] * pRef[j];
2260	xy += pRef[j] * pRec[j];
2261	}
2262	iCountShift += g_aucConvertToBit[ uiWidth ] + 2;
2263	}
2264
2265
2266	if(pcCU->getPULeft(uiTmpPartIdx, pcCU->getZorderIdxInCU()) && iCUPelX > 0 && iRefX > 0)
2267	{
2268	iRefOffset = ( pMv->getHor() >> 2 ) + ( pMv->getVer() >> 2 ) * iRefStride - 1;
2269	pRef = pRefPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
2270	pRec = pRecPic->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
2271
2272	for( i = 0; i < uiHeight; i++ )
2273	{
2274	x += pRef[0];
2275	y += pRec[0];
2276	xx += pRef[0] * pRef[0];
2277	xy += pRef[0] * pRec[0];
2278
2279	pRef += iRefStride;
2280	pRec += iRecStride;
2281	}
2282	iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 2 );
2283	}
2284
2285	Int iTempShift = ( g_uiBitDepth + g_uiBitIncrement ) + g_aucConvertToBit[ uiWidth ] + 3 - 15;
2286
2287	if(iTempShift > 0)
2288	{
2289	x = ( x + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2290	y = ( y + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2291	xx = ( xx + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2292	xy = ( xy + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2293	iCountShift -= iTempShift;
2294	}
2295
2296	iShift = 13;
2297
2298	if( iCountShift == 0 )
2299	{
2300	a = 1;
2301	b = 0;
2302	iShift = 0;
2303	}
2304	else
2305	{
2306	Int a1 = ( xy << iCountShift ) - y * x;
2307	Int a2 = ( xx << iCountShift ) - x * x;
2308
2309	{
2310	const Int iShiftA2 = 6;
2311	const Int iShiftA1 = 15;
2312	const Int iAccuracyShift = 15;
2313
2314	Int iScaleShiftA2 = 0;
2315	Int iScaleShiftA1 = 0;
2316	Int a1s = a1;
2317	Int a2s = a2;
2318
2319	iScaleShiftA1 = GetMSB( abs( a1 ) ) - iShiftA1;
2320	iScaleShiftA2 = GetMSB( abs( a2 ) ) - iShiftA2;
2321
2322	if( iScaleShiftA1 < 0 )
2323	{
2324	iScaleShiftA1 = 0;
2325	}
2326
2327	if( iScaleShiftA2 < 0 )
2328	{
2329	iScaleShiftA2 = 0;
2330	}
2331
2332	Int iScaleShiftA = iScaleShiftA2 + iAccuracyShift - iShift - iScaleShiftA1;
2333
2334	a2s = a2 >> iScaleShiftA2;
2335
2336	a1s = a1 >> iScaleShiftA1;
2337
2338	if (a2s >= 1)
2339	{
2340	a = a1s * m_uiaShift[ a2s - 1];
2341	}
2342	else
2343	{
2344	a = 0;
2345	}
2346
2347	if( iScaleShiftA < 0 )
2348	{
2349	a = a << -iScaleShiftA;
2350	}
2351	else
2352	{
2353	a = a >> iScaleShiftA;
2354	}
2355
2356	a = Clip3(-( 1 << 15 ), ( 1 << 15 ) - 1, a);
2357
2358	Int minA = -(1 << (6));
2359	Int maxA = (1 << 6) - 1;
2360	if( a <= maxA && a >= minA )
2361	{
2362	// do nothing
2363	}
2364	else
2365	{
2366	Short n = CountLeadingZerosOnes(a);
2367	a = a >> (9-n);
2368	iShift -= (9-n);
2369	}
2370
2371	b = ( y - ( ( a * x ) >> iShift ) + ( 1 << ( iCountShift - 1 ) ) ) >> iCountShift;
2372	}
2373	}
2374	}
2375
2376	Void TComPrediction::xGetLLSICPredictionChroma(TComDataCU* pcCU, TComMv pMv, TComPicYuv pRefPic, Int &a, Int &b, Int &iShift, Int iChromaId)
2377	{
2378	TComPicYuv *pRecPic = pcCU->getPic()->getPicYuvRec();
2379	Pel pRec = NULL, pRef = NULL;
2380	UInt uiWidth, uiHeight, uiTmpPartIdx;
2381	Int iRecStride = pRecPic->getCStride(), iRefStride = pRefPic->getCStride();
2382	Int iCUPelX, iCUPelY, iRefX, iRefY, iRefOffset;
2383
2384	iCUPelX = pcCU->getCUPelX() + g_auiRasterToPelX[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
2385	iCUPelY = pcCU->getCUPelY() + g_auiRasterToPelY[g_auiZscanToRaster[pcCU->getZorderIdxInCU()]];
2386	#if FIX_LGE_ILLUCOMP_B0045
2387	iRefX = iCUPelX + (pMv->getHor() >> 2);
2388	iRefY = iCUPelY + (pMv->getVer() >> 2);
2389	#else
2390	iRefX = iCUPelX + (pMv->getHor() >> 3);
2391	iRefY = iCUPelY + (pMv->getVer() >> 3);
2392	#endif
2393	uiWidth = pcCU->getWidth(0) >> 1;
2394	uiHeight = pcCU->getHeight(0) >> 1;
2395
2396	Int i, j, iCountShift = 0;
2397
2398	// LLS parameters estimation -->
2399
2400	Int x = 0, y = 0, xx = 0, xy = 0;
2401
2402	if(pcCU->getPUAbove(uiTmpPartIdx, pcCU->getZorderIdxInCU()) && iCUPelY > 0 && iRefY > 0)
2403	{
2404	iRefOffset = ( pMv->getHor() >> 3 ) + ( pMv->getVer() >> 3 ) * iRefStride - iRefStride;
2405	if (iChromaId == 0) // Cb
2406	{
2407	pRef = pRefPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
2408	pRec = pRecPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
2409	}
2410	else if (iChromaId == 1) // Cr
2411	{
2412	pRef = pRefPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
2413	pRec = pRecPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - iRecStride;
2414	}
2415
2416	for( j = 0; j < uiWidth; j++ )
2417	{
2418	x += pRef[j];
2419	y += pRec[j];
2420	xx += pRef[j] * pRef[j];
2421	xy += pRef[j] * pRec[j];
2422	}
2423	iCountShift += g_aucConvertToBit[ uiWidth ] + 2;
2424	}
2425
2426
2427	if(pcCU->getPULeft(uiTmpPartIdx, pcCU->getZorderIdxInCU()) && iCUPelX > 0 && iRefX > 0)
2428	{
2429	iRefOffset = ( pMv->getHor() >> 3 ) + ( pMv->getVer() >> 3 ) * iRefStride - 1;
2430	if (iChromaId == 0) // Cb
2431	{
2432	pRef = pRefPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
2433	pRec = pRecPic->getCbAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
2434	}
2435	else if (iChromaId == 1) // Cr
2436	{
2437	pRef = pRefPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) + iRefOffset;
2438	pRec = pRecPic->getCrAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() ) - 1;
2439	}
2440
2441	for( i = 0; i < uiHeight; i++ )
2442	{
2443	x += pRef[0];
2444	y += pRec[0];
2445	xx += pRef[0] * pRef[0];
2446	xy += pRef[0] * pRec[0];
2447
2448	pRef += iRefStride;
2449	pRec += iRecStride;
2450	}
2451	iCountShift += iCountShift > 0 ? 1 : ( g_aucConvertToBit[ uiWidth ] + 2 );
2452	}
2453
2454	Int iTempShift = ( g_uiBitDepth + g_uiBitIncrement ) + g_aucConvertToBit[ uiWidth ] + 3 - 15;
2455
2456	if(iTempShift > 0)
2457	{
2458	x = ( x + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2459	y = ( y + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2460	xx = ( xx + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2461	xy = ( xy + ( 1 << ( iTempShift - 1 ) ) ) >> iTempShift;
2462	iCountShift -= iTempShift;
2463	}
2464
2465	iShift = 13;
2466
2467	if( iCountShift == 0 )
2468	{
2469	a = 1;
2470	b = 0;
2471	iShift = 0;
2472	}
2473	else
2474	{
2475	Int a1 = ( xy << iCountShift ) - y * x;
2476	Int a2 = ( xx << iCountShift ) - x * x;
2477
2478	{
2479	const Int iShiftA2 = 6;
2480	const Int iShiftA1 = 15;
2481	const Int iAccuracyShift = 15;
2482
2483	Int iScaleShiftA2 = 0;
2484	Int iScaleShiftA1 = 0;
2485	Int a1s = a1;
2486	Int a2s = a2;
2487
2488	iScaleShiftA1 = GetMSB( abs( a1 ) ) - iShiftA1;
2489	iScaleShiftA2 = GetMSB( abs( a2 ) ) - iShiftA2;
2490
2491	if( iScaleShiftA1 < 0 )
2492	{
2493	iScaleShiftA1 = 0;
2494	}
2495
2496	if( iScaleShiftA2 < 0 )
2497	{
2498	iScaleShiftA2 = 0;
2499	}
2500
2501	Int iScaleShiftA = iScaleShiftA2 + iAccuracyShift - iShift - iScaleShiftA1;
2502
2503	a2s = a2 >> iScaleShiftA2;
2504
2505	a1s = a1 >> iScaleShiftA1;
2506
2507	if (a2s >= 1)
2508	{
2509	a = a1s * m_uiaShift[ a2s - 1];
2510	}
2511	else
2512	{
2513	a = 0;
2514	}
2515
2516	if( iScaleShiftA < 0 )
2517	{
2518	a = a << -iScaleShiftA;
2519	}
2520	else
2521	{
2522	a = a >> iScaleShiftA;
2523	}
2524
2525	a = Clip3(-( 1 << 15 ), ( 1 << 15 ) - 1, a);
2526
2527	Int minA = -(1 << (6));
2528	Int maxA = (1 << 6) - 1;
2529	if( a <= maxA && a >= minA )
2530	{
2531	// do nothing
2532	}
2533	else
2534	{
2535	Short n = CountLeadingZerosOnes(a);
2536	a = a >> (9-n);
2537	iShift -= (9-n);
2538	}
2539
2540	b = ( y - ( ( a * x ) >> iShift ) + ( 1 << ( iCountShift - 1 ) ) ) >> iCountShift;
2541	}
2542	}
2543	}
2544	#endif
2545	/** Function for filtering intra DC predictor.
2546	* \param pSrc pointer to reconstructed sample array
2547	* \param iSrcStride the stride of the reconstructed sample array
2548	* \param rpDst reference to pointer for the prediction sample array
2549	* \param iDstStride the stride of the prediction sample array
2550	* \param iWidth the width of the block
2551	* \param iHeight the height of the block
2552	*
2553	* This function performs filtering left and top edges of the prediction samples for DC mode (intra coding).
2554	*/
2555	Void TComPrediction::xDCPredFiltering( Int* pSrc, Int iSrcStride, Pel*& rpDst, Int iDstStride, Int iWidth, Int iHeight )
2556	{
2557	Pel* pDst = rpDst;
2558	Int x, y, iDstStride2, iSrcStride2;
2559
2560	// boundary pixels processing
2561	pDst[0] = (Pel)((pSrc[-iSrcStride] + pSrc[-1] + 2 * pDst[0] + 2) >> 2);
2562
2563	for ( x = 1; x < iWidth; x++ )
2564	{
2565	pDst[x] = (Pel)((pSrc[x - iSrcStride] + 3 * pDst[x] + 2) >> 2);
2566	}
2567
2568	for ( y = 1, iDstStride2 = iDstStride, iSrcStride2 = iSrcStride-1; y < iHeight; y++, iDstStride2+=iDstStride, iSrcStride2+=iSrcStride )
2569	{
2570	pDst[iDstStride2] = (Pel)((pSrc[iSrcStride2] + 3 * pDst[iDstStride2] + 2) >> 2);
2571	}
2572
2573	return;
2574	}
2575
2576	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
2577	Void TComPrediction::predIntraLumaDMM( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder )
2578	{
2579	#if HHI_DMM_WEDGE_INTRA
2580	if( uiMode == DMM_WEDGE_FULL_IDX ) { xPredIntraWedgeFull ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false, pcCU->getWedgeFullTabIdx ( uiAbsPartIdx ) ); }
2581	if( uiMode == DMM_WEDGE_FULL_D_IDX ) { xPredIntraWedgeFull ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true, pcCU->getWedgeFullTabIdx( uiAbsPartIdx ), pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx ), pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx ) ); }
2582	if( uiMode == DMM_WEDGE_PREDDIR_IDX ) { xPredIntraWedgeDir ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false, pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx ) ); }
2583	if( uiMode == DMM_WEDGE_PREDDIR_D_IDX ) { xPredIntraWedgeDir ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true, pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx ), pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx ), pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx ) ); }
2584	#endif
2585	#if HHI_DMM_PRED_TEX
2586	if( uiMode == DMM_WEDGE_PREDTEX_IDX ) { xPredIntraWedgeTex ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false ); }
2587	if( uiMode == DMM_WEDGE_PREDTEX_D_IDX ) { xPredIntraWedgeTex ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true, pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx ), pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx ) ); }
2588	if( uiMode == DMM_CONTOUR_PREDTEX_IDX ) { xPredIntraContourTex( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false ); }
2589	if( uiMode == DMM_CONTOUR_PREDTEX_D_IDX ) { xPredIntraContourTex( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true, pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx ), pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx ) ); }
2590	#endif
2591	}
2592
2593	Void TComPrediction::getWedgePredDCs( TComWedgelet* pcWedgelet, Int* piMask, Int iMaskStride, Int& riPredDC1, Int& riPredDC2, Bool bAbove, Bool bLeft )
2594	{
2595	riPredDC1 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ); //pred val, if no neighbors are available
2596	riPredDC2 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
2597
2598	if( !bAbove && !bLeft ) { return; }
2599
2600	UInt uiNumSmpDC1 = 0, uiNumSmpDC2 = 0;
2601	Int iPredDC1 = 0, iPredDC2 = 0;
2602
2603	Bool* pabWedgePattern = pcWedgelet->getPattern();
2604	UInt uiWedgeStride = pcWedgelet->getStride();
2605
2606	#if HS_REFERENCE_SUBSAMPLE_C0154
2607	Int subSamplePix;
2608	if ( pcWedgelet->getWidth() == 32 )
2609	{
2610	subSamplePix = 2;
2611	}
2612	else
2613	{
2614	subSamplePix = 1;
2615	}
2616	#endif
2617
2618	if( bAbove )
2619	{
2620	#if HS_REFERENCE_SUBSAMPLE_C0154
2621	for( Int k = 0; k < pcWedgelet->getWidth(); k+=subSamplePix )
2622	#else
2623	for( Int k = 0; k < pcWedgelet->getWidth(); k++ )
2624	#endif
2625	{
2626	if( true == pabWedgePattern[k] )
2627	{
2628	iPredDC2 += piMask[k-iMaskStride];
2629	uiNumSmpDC2++;
2630	}
2631	else
2632	{
2633	iPredDC1 += piMask[k-iMaskStride];
2634	uiNumSmpDC1++;
2635	}
2636	}
2637	}
2638	if( bLeft )
2639	{
2640	#if HS_REFERENCE_SUBSAMPLE_C0154
2641	for( Int k = 0; k < pcWedgelet->getHeight(); k+=subSamplePix )
2642	#else
2643	for( Int k = 0; k < pcWedgelet->getHeight(); k++ )
2644	#endif
2645	{
2646	if( true == pabWedgePattern[k*uiWedgeStride] )
2647	{
2648	iPredDC2 += piMask[k*iMaskStride-1];
2649	uiNumSmpDC2++;
2650	}
2651	else
2652	{
2653	iPredDC1 += piMask[k*iMaskStride-1];
2654	uiNumSmpDC1++;
2655	}
2656	}
2657	}
2658
2659	if( uiNumSmpDC1 > 0 )
2660	{
2661	iPredDC1 /= uiNumSmpDC1;
2662	riPredDC1 = iPredDC1;
2663	}
2664	if( uiNumSmpDC2 > 0 )
2665	{
2666	iPredDC2 /= uiNumSmpDC2;
2667	riPredDC2 = iPredDC2;
2668	}
2669	}
2670
2671	Void TComPrediction::calcWedgeDCs( TComWedgelet* pcWedgelet, Pel* piOrig, UInt uiStride, Int& riDC1, Int& riDC2 )
2672	{
2673	UInt uiDC1 = 0;
2674	UInt uiDC2 = 0;
2675	UInt uiNumPixDC1 = 0, uiNumPixDC2 = 0;
2676	Bool* pabWedgePattern = pcWedgelet->getPattern();
2677	if( uiStride == pcWedgelet->getStride() )
2678	{
2679	for( UInt k = 0; k < (pcWedgelet->getWidth() * pcWedgelet->getHeight()); k++ )
2680	{
2681	if( true == pabWedgePattern[k] )
2682	{
2683	uiDC2 += piOrig[k];
2684	uiNumPixDC2++;
2685	}
2686	else
2687	{
2688	uiDC1 += piOrig[k];
2689	uiNumPixDC1++;
2690	}
2691	}
2692	}
2693	else
2694	{
2695	Pel* piTemp = piOrig;
2696	UInt uiWedgeStride = pcWedgelet->getStride();
2697	for( UInt uiY = 0; uiY < pcWedgelet->getHeight(); uiY++ )
2698	{
2699	for( UInt uiX = 0; uiX < pcWedgelet->getWidth(); uiX++ )
2700	{
2701	if( true == pabWedgePattern[uiX] )
2702	{
2703	uiDC2 += piTemp[uiX];
2704	uiNumPixDC2++;
2705	}
2706	else
2707	{
2708	uiDC1 += piTemp[uiX];
2709	uiNumPixDC1++;
2710	}
2711	}
2712	piTemp += uiStride;
2713	pabWedgePattern += uiWedgeStride;
2714	}
2715	}
2716
2717	if( uiNumPixDC1 > 0 ) { riDC1 = uiDC1 / uiNumPixDC1; }
2718	else { riDC1 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ); }
2719
2720	if( uiNumPixDC2 > 0 ) { riDC2 = uiDC2 / uiNumPixDC2; }
2721	else { riDC2 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ); }
2722	}
2723
2724	Void TComPrediction::assignWedgeDCs2Pred( TComWedgelet* pcWedgelet, Pel* piPred, UInt uiStride, Int iDC1, Int iDC2 )
2725	{
2726	Bool* pabWedgePattern = pcWedgelet->getPattern();
2727
2728	if( uiStride == pcWedgelet->getStride() )
2729	{
2730	for( UInt k = 0; k < (pcWedgelet->getWidth() * pcWedgelet->getHeight()); k++ )
2731	{
2732	if( true == pabWedgePattern[k] )
2733	{
2734	piPred[k] = iDC2;
2735	}
2736	else
2737	{
2738	piPred[k] = iDC1;
2739	}
2740	}
2741	}
2742	else
2743	{
2744	Pel* piTemp = piPred;
2745	UInt uiWedgeStride = pcWedgelet->getStride();
2746	for( UInt uiY = 0; uiY < pcWedgelet->getHeight(); uiY++ )
2747	{
2748	for( UInt uiX = 0; uiX < pcWedgelet->getWidth(); uiX++ )
2749	{
2750	if( true == pabWedgePattern[uiX] )
2751	{
2752	piTemp[uiX] = iDC2;
2753	}
2754	else
2755	{
2756	piTemp[uiX] = iDC1;
2757	}
2758	}
2759	piTemp += uiStride;
2760	pabWedgePattern += uiWedgeStride;
2761	}
2762	}
2763	}
2764
2765	Void TComPrediction::xDeltaDCQuantScaleUp( TComDataCU* pcCU, Int& riDeltaDC )
2766	{
2767	Int iSign = riDeltaDC < 0 ? -1 : 1;
2768	UInt uiAbs = abs( riDeltaDC );
2769
2770	Int iQp = pcCU->getQP(0);
2771	Double dMax = (Double)( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
2772	Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 + g_iDeltaDCsQuantOffset ) );
2773
2774	riDeltaDC = iSign * roftoi( uiAbs * dStepSize );
2775	return;
2776	}
2777
2778	Void TComPrediction::xDeltaDCQuantScaleDown( TComDataCU* pcCU, Int& riDeltaDC )
2779	{
2780	Int iSign = riDeltaDC < 0 ? -1 : 1;
2781	UInt uiAbs = abs( riDeltaDC );
2782
2783	Int iQp = pcCU->getQP(0);
2784	Double dMax = (Double)( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
2785	Double dStepSize = Clip3( 1.0, dMax, pow( 2.0, iQp/10.0 + g_iDeltaDCsQuantOffset ) );
2786
2787	riDeltaDC = iSign * roftoi( uiAbs / dStepSize );
2788	return;
2789	}
2790	#endif
2791
2792	#if HHI_DMM_PRED_TEX
2793	Void TComPrediction::getBestContourFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge )
2794	{
2795	pcContourWedge->clear();
2796
2797	// get copy of co-located texture luma block
2798	TComYuv cTempYuv;
2799	cTempYuv.create( uiWidth, uiHeight );
2800	cTempYuv.clear();
2801	Pel* piRefBlkY = cTempYuv.getLumaAddr();
2802	copyTextureLumaBlock( pcCU, uiAbsPartIdx, piRefBlkY, uiWidth, uiHeight );
2803	piRefBlkY = cTempYuv.getLumaAddr();
2804
2805	// find contour for texture luma block
2806	UInt iDC = 0;
2807	for( UInt k = 0; k < (uiWidth*uiHeight); k++ )
2808	{
2809	iDC += piRefBlkY[k];
2810	}
2811	iDC /= (uiWidth*uiHeight);
2812	piRefBlkY = cTempYuv.getLumaAddr();
2813
2814	Bool* pabContourPattern = pcContourWedge->getPattern();
2815	for( UInt k = 0; k < (uiWidth*uiHeight); k++ )
2816	{
2817	pabContourPattern[k] = (piRefBlkY[k] > iDC) ? true : false;
2818	}
2819
2820	cTempYuv.destroy();
2821	}
2822
2823	#if LGE_DMM3_SIMP_C0044
2824	/**
2825	- fetch best Wedgelet pattern at decoder
2826	*/
2827	UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt IntraTabIdx)
2828	{
2829	assert( uiWidth >= DMM_WEDGEMODEL_MIN_SIZE && uiWidth <= DMM_WEDGEMODEL_MAX_SIZE );
2830
2831	UInt uiBestTabIdx = 0;
2832	TComPic* pcPicTex = pcCU->getSlice()->getTexturePic();
2833	TComDataCU* pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
2834	UInt uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
2835	Int uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
2836
2837	std::vector< std::vector<UInt> > pauiWdgLstSz = g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]];
2838
2839	if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 )
2840	{
2841	std::vector<UInt>* pauiWdgLst = &pauiWdgLstSz[uiColTexIntraDir-2];
2842	uiBestTabIdx = pauiWdgLst->at(IntraTabIdx);
2843	}
2844	else
2845	{
2846	WedgeNodeList* pacWedgeNodeList = &g_aacWedgeNodeLists[(g_aucConvertToBit[uiWidth])];
2847	uiBestTabIdx = pacWedgeNodeList->at(IntraTabIdx).getPatternIdx();
2848	}
2849
2850	return uiBestTabIdx;
2851	}
2852	#endif
2853
2854	#if LGE_DMM3_SIMP_C0044
2855	/**
2856	- calculate best Wedgelet pattern at encoder
2857	*/
2858	UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Pel* piOrigi, UInt uiStride, UInt & ruiIntraTabIdx)
2859	#else
2860	UInt TComPrediction::getBestWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight )
2861	#endif
2862	{
2863	assert( uiWidth >= DMM_WEDGEMODEL_MIN_SIZE && uiWidth <= DMM_WEDGEMODEL_MAX_SIZE );
2864
2865	// get copy of co-located texture luma block
2866	TComYuv cTempYuv;
2867	cTempYuv.create( uiWidth, uiHeight );
2868	cTempYuv.clear();
2869	Pel* piRefBlkY = cTempYuv.getLumaAddr();
2870
2871	copyTextureLumaBlock( pcCU, uiAbsPartIdx, piRefBlkY, uiWidth, uiHeight );
2872	piRefBlkY = cTempYuv.getLumaAddr();
2873
2874	// local pred buffer
2875	TComYuv cPredYuv;
2876	cPredYuv.create( uiWidth, uiHeight );
2877	cPredYuv.clear();
2878	Pel* piPred = cPredYuv.getLumaAddr();
2879
2880	UInt uiPredStride = cPredYuv.getStride();
2881
2882	// wedge search
2883	TComWedgeDist cWedgeDist;
2884	UInt uiBestDist = MAX_UINT;
2885	UInt uiBestTabIdx = 0;
2886	Int iDC1 = 0;
2887	Int iDC2 = 0;
2888	WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiWidth])];
2889	#if LGE_DMM3_SIMP_C0044
2890	ruiIntraTabIdx = 0;
2891	#endif
2892	TComPic* pcPicTex = pcCU->getSlice()->getTexturePic();
2893	TComDataCU* pcColTexCU = pcPicTex->getCU(pcCU->getAddr());
2894	UInt uiTexPartIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
2895	Int uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
2896
2897	std::vector< std::vector<UInt> > pauiWdgLstSz = g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]];
2898	if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 )
2899	{
2900	std::vector<UInt>* pauiWdgLst = &pauiWdgLstSz[uiColTexIntraDir-2];
2901	for( UInt uiIdxW = 0; uiIdxW < pauiWdgLst->size(); uiIdxW++ )
2902	{
2903	UInt uiIdx = pauiWdgLst->at(uiIdxW);
2904	#if LGE_DMM3_SIMP_C0044
2905	calcWedgeDCs ( &(pacWedgeList->at(uiIdx)), piOrigi, uiWidth, iDC1, iDC2 );
2906	#else
2907	calcWedgeDCs ( &(pacWedgeList->at(uiIdx)), piRefBlkY, uiWidth, iDC1, iDC2 );
2908	#endif
2909	assignWedgeDCs2Pred( &(pacWedgeList->at(uiIdx)), piPred, uiPredStride, iDC1, iDC2 );
2910
2911	#if LGE_DMM3_SIMP_C0044
2912	UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piOrigi, uiStride, uiWidth, uiHeight, WedgeDist_SAD );
2913	#else
2914	UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
2915	#endif
2916
2917	if( uiActDist < uiBestDist \|\| uiBestDist == MAX_UINT )
2918	{
2919	uiBestDist = uiActDist;
2920	uiBestTabIdx = uiIdx;
2921	#if LGE_DMM3_SIMP_C0044
2922	ruiIntraTabIdx = uiIdxW;
2923	#endif
2924	}
2925	}
2926	}
2927	else
2928	{
2929	WedgeNodeList* pacWedgeNodeList = &g_aacWedgeNodeLists[(g_aucConvertToBit[uiWidth])];
2930	UInt uiBestNodeDist = MAX_UINT;
2931	UInt uiBestNodeId = 0;
2932	for( UInt uiNodeId = 0; uiNodeId < pacWedgeNodeList->size(); uiNodeId++ )
2933	{
2934	#if LGE_DMM3_SIMP_C0044
2935	calcWedgeDCs ( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piOrigi, uiWidth, iDC1, iDC2 );
2936	#else
2937	calcWedgeDCs ( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piRefBlkY, uiWidth, iDC1, iDC2 );
2938	#endif
2939	assignWedgeDCs2Pred( &(pacWedgeList->at(pacWedgeNodeList->at(uiNodeId).getPatternIdx())), piPred, uiPredStride, iDC1, iDC2 );
2940
2941	#if LGE_DMM3_SIMP_C0044
2942	UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piOrigi, uiStride, uiWidth, uiHeight, WedgeDist_SAD );
2943	#else
2944	UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
2945	#endif
2946
2947	if( uiActDist < uiBestNodeDist \|\| uiBestNodeDist == MAX_UINT )
2948	{
2949	uiBestNodeDist = uiActDist;
2950	uiBestNodeId = uiNodeId;
2951	#if LGE_DMM3_SIMP_C0044
2952	ruiIntraTabIdx = uiNodeId;
2953	#endif
2954	}
2955	}
2956	#if LGE_DMM3_SIMP_C0044
2957	uiBestTabIdx = pacWedgeNodeList->at(uiBestNodeId).getPatternIdx();
2958	#else
2959	// refinement
2960	uiBestDist = uiBestNodeDist;
2961	uiBestTabIdx = pacWedgeNodeList->at(uiBestNodeId).getPatternIdx();
2962	for( UInt uiRefId = 0; uiRefId < NUM_WEDGE_REFINES; uiRefId++ )
2963	{
2964	if( pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId ) != NO_IDX )
2965	{
2966	calcWedgeDCs ( &(pacWedgeList->at(pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId ))), piRefBlkY, uiWidth, iDC1, iDC2 );
2967	assignWedgeDCs2Pred( &(pacWedgeList->at(pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId ))), piPred, uiPredStride, iDC1, iDC2 );
2968
2969	UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piRefBlkY, uiWidth, uiWidth, uiHeight, WedgeDist_SAD );
2970
2971	if( uiActDist < uiBestDist \|\| uiBestDist == MAX_UINT )
2972	{
2973	uiBestDist = uiActDist;
2974	uiBestTabIdx = pacWedgeNodeList->at(uiBestNodeId).getRefineIdx( uiRefId );
2975	}
2976	}
2977	}
2978	#endif
2979	}
2980
2981	cPredYuv.destroy();
2982	cTempYuv.destroy();
2983	return uiBestTabIdx;
2984	}
2985
2986	Void TComPrediction::copyTextureLumaBlock( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight )
2987	{
2988	TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getTexturePic()->getPicYuvRec();
2989	Int iRefStride = pcPicYuvRef->getStride();
2990	Pel* piRefY;
2991
2992	piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx );
2993
2994	for ( Int y = 0; y < uiHeight; y++ )
2995	{
2996	::memcpy(piDestBlockY, piRefY, sizeof(Pel)*uiWidth);
2997	// ::memset(piDestBlockY, 128, sizeof(Pel)*uiWidth);
2998	piDestBlockY += uiWidth;
2999	piRefY += iRefStride;
3000	}
3001	}
3002
3003	Void TComPrediction::xPredIntraWedgeTex( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1, Int iDeltaDC2 )
3004	{
3005	assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
3006	WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
3007
3008	// get wedge pattern
3009	UInt uiTextureWedgeTabIdx = 0;
3010	if( bEncoder )
3011	{
3012	// encoder: load stored wedge pattern from CU
3013	uiTextureWedgeTabIdx = pcCU->getWedgePredTexTabIdx( uiAbsPartIdx );
3014	}
3015	else
3016	{
3017	// decoder: get and store wedge pattern in CU
3018	// decoder: get and store wedge pattern in CU
3019	#if LGE_DMM3_SIMP_C0044
3020	UInt uiIntraTabIdx = pcCU->getWedgePredTexIntraTabIdx ( uiAbsPartIdx );
3021	uiTextureWedgeTabIdx = getBestWedgeFromTex( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight, uiIntraTabIdx );
3022	#else
3023	uiTextureWedgeTabIdx = getBestWedgeFromTex( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight );
3024	#endif
3025
3026	UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
3027	pcCU->setWedgePredTexTabIdxSubParts( uiTextureWedgeTabIdx, uiAbsPartIdx, uiDepth );
3028	}
3029	TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiTextureWedgeTabIdx));
3030
3031	// get wedge pred DCs
3032	Int iPredDC1 = 0;
3033	Int iPredDC2 = 0;
3034	Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3035	Int iMaskStride = ( iWidth<<1 ) + 1;
3036	piMask += iMaskStride+1;
3037	getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
3038
3039	#if HHI_DMM_DELTADC_Q1_C0034
3040	#else
3041	if( bDelta )
3042	{
3043	xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
3044	xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
3045	}
3046	#endif
3047
3048	// assign wedge pred DCs to prediction
3049	if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip ( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
3050	else { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, iPredDC1, iPredDC2 ); }
3051	}
3052
3053	Void TComPrediction::xPredIntraContourTex( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1, Int iDeltaDC2 )
3054	{
3055	// get contour pattern
3056	TComWedgelet* pcContourWedge = new TComWedgelet( iWidth, iHeight );
3057	getBestContourFromTex( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight, pcContourWedge );
3058
3059	// get wedge pred DCs
3060	Int iPredDC1 = 0;
3061	Int iPredDC2 = 0;
3062	Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3063	Int iMaskStride = ( iWidth<<1 ) + 1;
3064	piMask += iMaskStride+1;
3065	getWedgePredDCs( pcContourWedge, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
3066
3067	#if HHI_DMM_DELTADC_Q1_C0034
3068	#else
3069	if( bDelta )
3070	{
3071	xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
3072	xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
3073	}
3074	#endif
3075
3076	// assign wedge pred DCs to prediction
3077	if( bDelta ) { assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride, Clip ( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
3078	else { assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride, iPredDC1, iPredDC2 ); }
3079
3080	pcContourWedge->destroy();
3081	delete pcContourWedge;
3082	}
3083	#endif // HHI_DMM_PRED_TEX
3084
3085	#if HHI_DMM_WEDGE_INTRA
3086	UInt TComPrediction::getBestContinueWedge( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd )
3087	{
3088	UInt uiThisBlockSize = uiWidth;
3089	assert( uiThisBlockSize >= DMM_WEDGEMODEL_MIN_SIZE && uiThisBlockSize <= DMM_WEDGEMODEL_MAX_SIZE );
3090	WedgeRefList* pacContDWedgeRefList = &g_aacWedgeRefLists[(g_aucConvertToBit[uiThisBlockSize])];
3091
3092	UInt uiPredDirWedgeTabIdx = 0;
3093	TComDataCU* pcTempCU;
3094	UInt uiTempPartIdx;
3095	// 1st: try continue above wedgelet
3096	pcTempCU = pcCU->getPUAbove( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
3097	if( pcTempCU )
3098	{
3099	UChar uhLumaIntraDir = pcTempCU->getLumaIntraDir( uiTempPartIdx );
3100	if( DMM_WEDGE_FULL_IDX == uhLumaIntraDir \|\|
3101	DMM_WEDGE_FULL_D_IDX == uhLumaIntraDir \|\|
3102	DMM_WEDGE_PREDDIR_IDX == uhLumaIntraDir \|\|
3103	DMM_WEDGE_PREDDIR_D_IDX == uhLumaIntraDir
3104	#if HHI_DMM_PRED_TEX
3105	\|\|
3106	DMM_WEDGE_PREDTEX_IDX == uhLumaIntraDir \|\|
3107	DMM_WEDGE_PREDTEX_D_IDX == uhLumaIntraDir
3108	#endif
3109	)
3110	{
3111	UInt uiRefWedgeSize = (UInt)g_aucIntraSizeIdxToWedgeSize[pcTempCU->getIntraSizeIdx( uiTempPartIdx )];
3112	WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiRefWedgeSize])];
3113
3114	// get offset between current and reference block
3115	UInt uiOffsetX = 0;
3116	UInt uiOffsetY = 0;
3117	xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
3118
3119	// get reference wedgelet
3120	UInt uiRefWedgeTabIdx = 0;
3121	switch( uhLumaIntraDir )
3122	{
3123	case( DMM_WEDGE_FULL_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx ( uiTempPartIdx ); } break;
3124	case( DMM_WEDGE_FULL_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx ( uiTempPartIdx ); } break;
3125	case( DMM_WEDGE_PREDDIR_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
3126	case( DMM_WEDGE_PREDDIR_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
3127	#if HHI_DMM_PRED_TEX
3128	case( DMM_WEDGE_PREDTEX_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
3129	case( DMM_WEDGE_PREDTEX_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
3130	#endif
3131	default: { assert( 0 ); return uiPredDirWedgeTabIdx; }
3132	}
3133	TComWedgelet* pcRefWedgelet;
3134	pcRefWedgelet = &(pacWedgeList->at( uiRefWedgeTabIdx ));
3135
3136	// find reference wedgelet, if direction is suitable for continue wedge
3137	if( pcRefWedgelet->checkPredDirAbovePossible( uiThisBlockSize, uiOffsetX ) )
3138	{
3139	UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
3140	pcRefWedgelet->getPredDirStartEndAbove( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetX, iDeltaEnd );
3141	getWedgePatternIdx( pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
3142	return uiPredDirWedgeTabIdx;
3143	}
3144	}
3145	}
3146
3147	// 2nd: try continue left wedglelet
3148	pcTempCU = pcCU->getPULeft( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
3149	if( pcTempCU )
3150	{
3151	UChar uhLumaIntraDir = pcTempCU->getLumaIntraDir( uiTempPartIdx );
3152	if( DMM_WEDGE_FULL_IDX == uhLumaIntraDir \|\|
3153	DMM_WEDGE_FULL_D_IDX == uhLumaIntraDir \|\|
3154	DMM_WEDGE_PREDDIR_IDX == uhLumaIntraDir \|\|
3155	DMM_WEDGE_PREDDIR_D_IDX == uhLumaIntraDir
3156	#if HHI_DMM_PRED_TEX
3157	\|\|
3158	DMM_WEDGE_PREDTEX_IDX == uhLumaIntraDir \|\|
3159	DMM_WEDGE_PREDTEX_D_IDX == uhLumaIntraDir
3160	#endif
3161	)
3162	{
3163	UInt uiRefWedgeSize = (UInt)g_aucIntraSizeIdxToWedgeSize[pcTempCU->getIntraSizeIdx( uiTempPartIdx )];
3164	WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiRefWedgeSize])];
3165
3166	// get offset between current and reference block
3167	UInt uiOffsetX = 0;
3168	UInt uiOffsetY = 0;
3169	xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
3170
3171	// get reference wedgelet
3172	UInt uiRefWedgeTabIdx = 0;
3173	switch( uhLumaIntraDir )
3174	{
3175	case( DMM_WEDGE_FULL_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx ( uiTempPartIdx ); } break;
3176	case( DMM_WEDGE_FULL_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx ( uiTempPartIdx ); } break;
3177	case( DMM_WEDGE_PREDDIR_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
3178	case( DMM_WEDGE_PREDDIR_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
3179	#if HHI_DMM_PRED_TEX
3180	case( DMM_WEDGE_PREDTEX_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
3181	case( DMM_WEDGE_PREDTEX_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
3182	#endif
3183	default: { assert( 0 ); return uiPredDirWedgeTabIdx; }
3184	}
3185	TComWedgelet* pcRefWedgelet;
3186	pcRefWedgelet = &(pacWedgeList->at( uiRefWedgeTabIdx ));
3187
3188	// find reference wedgelet, if direction is suitable for continue wedge
3189	if( pcRefWedgelet->checkPredDirLeftPossible( uiThisBlockSize, uiOffsetY ) )
3190	{
3191	UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
3192	pcRefWedgelet->getPredDirStartEndLeft( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetY, iDeltaEnd );
3193	getWedgePatternIdx( pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
3194	return uiPredDirWedgeTabIdx;
3195	}
3196	}
3197	}
3198
3199	// 3rd: (default) make wedglet from intra dir and max slope point
3200	Int iSlopeX = 0;
3201	Int iSlopeY = 0;
3202	UInt uiStartPosX = 0;
3203	UInt uiStartPosY = 0;
3204	if( xGetWedgeIntraDirPredData( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY ) )
3205	{
3206	UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
3207	xGetWedgeIntraDirStartEnd( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, iDeltaEnd );
3208	getWedgePatternIdx( pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
3209	return uiPredDirWedgeTabIdx;
3210	}
3211
3212	return uiPredDirWedgeTabIdx;
3213	}
3214
3215	Bool TComPrediction::getWedgePatternIdx( WedgeRefList* pcWedgeRefList, UInt& ruiTabIdx, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe )
3216	{
3217	ruiTabIdx = 0;
3218
3219	for( UInt uiIdx = 0; uiIdx < pcWedgeRefList->size(); uiIdx++ )
3220	{
3221	TComWedgeRef* pcTestWedgeRef = &(pcWedgeRefList->at(uiIdx));
3222
3223	if( pcTestWedgeRef->getStartX() == uhXs &&
3224	pcTestWedgeRef->getStartY() == uhYs &&
3225	pcTestWedgeRef->getEndX() == uhXe &&
3226	pcTestWedgeRef->getEndY() == uhYe )
3227	{
3228	ruiTabIdx = pcTestWedgeRef->getRefIdx();
3229	return true;
3230	}
3231	}
3232
3233	return false;
3234	}
3235
3236	Void TComPrediction::xPredIntraWedgeFull( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, UInt uiTabIdx, Int iDeltaDC1, Int iDeltaDC2 )
3237	{
3238	assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
3239	WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
3240	TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiTabIdx));
3241
3242	// get wedge pred DCs
3243	Int iPredDC1 = 0;
3244	Int iPredDC2 = 0;
3245
3246	Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3247	Int iMaskStride = ( iWidth<<1 ) + 1;
3248	piMask += iMaskStride+1;
3249	getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
3250
3251	#if HHI_DMM_DELTADC_Q1_C0034
3252	#else
3253	if( bDelta )
3254	{
3255	xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
3256	xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
3257	}
3258	#endif
3259
3260	// assign wedge pred DCs to prediction
3261	if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
3262	else { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, iPredDC1, iPredDC2 ); }
3263	}
3264
3265	Void TComPrediction::xPredIntraWedgeDir( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iWedgeDeltaEnd, Int iDeltaDC1, Int iDeltaDC2 )
3266	{
3267	assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
3268	WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
3269
3270	// get wedge pattern
3271	UInt uiDirWedgeTabIdx = 0;
3272	if( bEncoder )
3273	{
3274	// encoder: load stored wedge pattern from CU
3275	uiDirWedgeTabIdx = pcCU->getWedgePredDirTabIdx( uiAbsPartIdx );
3276	}
3277	else
3278	{
3279	uiDirWedgeTabIdx = getBestContinueWedge( pcCU, uiAbsPartIdx, iWidth, iHeight, iWedgeDeltaEnd );
3280
3281	UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
3282	pcCU->setWedgePredDirTabIdxSubParts( uiDirWedgeTabIdx, uiAbsPartIdx, uiDepth );
3283	}
3284	TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiDirWedgeTabIdx));
3285
3286	// get wedge pred DCs
3287	Int iPredDC1 = 0;
3288	Int iPredDC2 = 0;
3289
3290	Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3291	Int iMaskStride = ( iWidth<<1 ) + 1;
3292	piMask += iMaskStride+1;
3293	getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
3294
3295	#if HHI_DMM_DELTADC_Q1_C0034
3296	#else
3297	if( bDelta )
3298	{
3299	xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
3300	xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
3301	}
3302	#endif
3303
3304	// assign wedge pred DCs to prediction
3305	if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
3306	else { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, iPredDC1, iPredDC2 ); }
3307	}
3308
3309	Void TComPrediction::xGetBlockOffset( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY )
3310	{
3311	ruiOffsetX = 0;
3312	ruiOffsetY = 0;
3313
3314	// get offset between current and above/left block
3315	UInt uiThisOriginX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
3316	UInt uiThisOriginY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
3317
3318	UInt uiNumPartInRefCU = pcRefCU->getTotalNumPart();
3319	UInt uiMaxDepthRefCU = 0;
3320	while( uiNumPartInRefCU > 1 )
3321	{
3322	uiNumPartInRefCU >>= 2;
3323	uiMaxDepthRefCU++;
3324	}
3325
3326	UInt uiDepthRefPU = (pcRefCU->getDepth(uiRefAbsPartIdx)) + (pcRefCU->getPartitionSize(uiRefAbsPartIdx) == SIZE_2Nx2N ? 0 : 1);
3327	UInt uiShifts = (uiMaxDepthRefCU - uiDepthRefPU)*2;
3328	UInt uiRefBlockOriginPartIdx = (uiRefAbsPartIdx>>uiShifts)<<uiShifts;
3329
3330	UInt uiRefOriginX = pcRefCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
3331	UInt uiRefOriginY = pcRefCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
3332
3333	if( (uiThisOriginX - uiRefOriginX) > 0 ) { ruiOffsetX = (UInt)(uiThisOriginX - uiRefOriginX); }
3334	if( (uiThisOriginY - uiRefOriginY) > 0 ) { ruiOffsetY = (UInt)(uiThisOriginY - uiRefOriginY); }
3335	}
3336
3337	Bool TComPrediction::xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY )
3338	{
3339	riSlopeX = 0;
3340	riSlopeY = 0;
3341	ruiStartPosX = 0;
3342	ruiStartPosY = 0;
3343
3344	// 1st step: get wedge start point (max. slope)
3345	Int* piSource = pcCU->getPattern()->getAdiOrgBuf( uiBlockSize, uiBlockSize, m_piYuvExt );
3346	Int iSourceStride = ( uiBlockSize<<1 ) + 1;
3347
3348	UInt uiSlopeMaxAbove = 0;
3349	UInt uiPosSlopeMaxAbove = 0;
3350	for( UInt uiPosHor = 0; uiPosHor < (uiBlockSize-1); uiPosHor++ )
3351	{
3352	if( abs( piSource[uiPosHor+1] - piSource[uiPosHor] ) > uiSlopeMaxAbove )
3353	{
3354	uiSlopeMaxAbove = abs( piSource[uiPosHor+1] - piSource[uiPosHor] );
3355	uiPosSlopeMaxAbove = uiPosHor;
3356	}
3357	}
3358
3359	UInt uiSlopeMaxLeft = 0;
3360	UInt uiPosSlopeMaxLeft = 0;
3361	for( UInt uiPosVer = 0; uiPosVer < (uiBlockSize-1); uiPosVer++ )
3362	{
3363	if( abs( piSource[(uiPosVer+1)iSourceStride] - piSource[uiPosVeriSourceStride] ) > uiSlopeMaxLeft )
3364	{
3365	uiSlopeMaxLeft = abs( piSource[(uiPosVer+1)iSourceStride] - piSource[uiPosVeriSourceStride] );
3366	uiPosSlopeMaxLeft = uiPosVer;
3367	}
3368	}
3369
3370	if( uiSlopeMaxAbove == 0 && uiSlopeMaxLeft == 0 )
3371	{
3372	return false;
3373	}
3374
3375	if( uiSlopeMaxAbove > uiSlopeMaxLeft )
3376	{
3377	ruiStartPosX = uiPosSlopeMaxAbove;
3378	ruiStartPosY = 0;
3379	}
3380	else
3381	{
3382	ruiStartPosX = 0;
3383	ruiStartPosY = uiPosSlopeMaxLeft;
3384	}
3385
3386	// 2nd step: derive wedge direction
3387	Int uiPreds[3] = {-1, -1, -1};
3388	Int iMode = -1;
3389	Int iPredNum = pcCU->getIntraDirLumaPredictor( uiAbsPartIdx, uiPreds, &iMode );
3390
3391	UInt uiDirMode = 0;
3392	if( iMode >= 0 ) { iPredNum = iMode; }
3393	if( iPredNum == 1 ) { uiDirMode = uiPreds[0]; }
3394	if( iPredNum == 2 ) { uiDirMode = uiPreds[1]; }
3395
3396	if( uiDirMode < 2 ) { return false; } // no planar & DC
3397
3398	Bool modeHor = (uiDirMode < 18);
3399	Bool modeVer = !modeHor;
3400	Int intraPredAngle = modeVer ? (Int)uiDirMode - VER_IDX : modeHor ? -((Int)uiDirMode - HOR_IDX) : 0;
3401	Int absAng = abs(intraPredAngle);
3402	Int signAng = intraPredAngle < 0 ? -1 : 1;
3403	Int angTable[9] = {0,2,5,9,13,17,21,26,32};
3404	absAng = angTable[absAng];
3405	intraPredAngle = signAng * absAng;
3406
3407	// 3rd step: set slope for direction
3408	if( modeHor )
3409	{
3410	if( intraPredAngle > 0 )
3411	{
3412	riSlopeX = -32;
3413	riSlopeY = intraPredAngle;
3414	}
3415	else
3416	{
3417	riSlopeX = 32;
3418	riSlopeY = -intraPredAngle;
3419	}
3420	}
3421	else if( modeVer )
3422	{
3423	if( intraPredAngle > 0 )
3424	{
3425	riSlopeX = intraPredAngle;
3426	riSlopeY = -32;
3427	}
3428	else
3429	{
3430	riSlopeX = -intraPredAngle;
3431	riSlopeY = 32;
3432	}
3433	}
3434
3435	return true;
3436	}
3437
3438	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 )
3439	{
3440	ruhXs = 0;
3441	ruhYs = 0;
3442	ruhXe = 0;
3443	ruhYe = 0;
3444
3445	// scaling of start pos and block size to wedge resolution
3446	UInt uiScaledStartPosX = 0;
3447	UInt uiScaledStartPosY = 0;
3448	UInt uiScaledBlockSize = 0;
3449	WedgeResolution eWedgeRes = g_aeWedgeResolutionList[(UInt)g_aucConvertToBit[uiBlockSize]];
3450	switch( eWedgeRes )
3451	{
3452	case( DOUBLE_PEL ): { uiScaledStartPosX = (uiPMSPosX>>1); uiScaledStartPosY = (uiPMSPosY>>1); uiScaledBlockSize = (uiBlockSize>>1); break; }
3453	case( FULL_PEL ): { uiScaledStartPosX = uiPMSPosX; uiScaledStartPosY = uiPMSPosY; uiScaledBlockSize = uiBlockSize; break; }
3454	case( HALF_PEL ): { uiScaledStartPosX = (uiPMSPosX<<1); uiScaledStartPosY = (uiPMSPosY<<1); uiScaledBlockSize = (uiBlockSize<<1); break; }
3455	}
3456	Int iMaxPos = (Int)uiScaledBlockSize - 1;
3457
3458	// case above
3459	if( uiScaledStartPosX > 0 && uiScaledStartPosY == 0 )
3460	{
3461	ruhXs = (UChar)uiScaledStartPosX;
3462	ruhYs = 0;
3463
3464	if( iDeltaY == 0 )
3465	{
3466	if( iDeltaX < 0 )
3467	{
3468	ruhXe = 0;
3469	ruhYe = (UChar)std::min( std::max( iDeltaEnd, 0 ), iMaxPos );
3470	return;
3471	}
3472	else
3473	{
3474	ruhXe = (UChar)iMaxPos;
3475	ruhYe = (UChar)std::min( std::max( -iDeltaEnd, 0 ), iMaxPos );
3476	std::swap( ruhXs, ruhXe );
3477	std::swap( ruhYs, ruhYe );
3478	return;
3479	}
3480	}
3481
3482	// regular case
3483	Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)iMaxPos * ((Double)iDeltaX / (Double)iDeltaY) );
3484
3485	if( iVirtualEndX < 0 )
3486	{
3487	Int iYe = roftoi( (Double)(0 - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) + iDeltaEnd;
3488	if( iYe < (Int)uiScaledBlockSize )
3489	{
3490	ruhXe = 0;
3491	ruhYe = (UChar)std::max( iYe, 0 );
3492	return;
3493	}
3494	else
3495	{
3496	ruhXe = (UChar)std::min( (iYe - iMaxPos), iMaxPos );
3497	ruhYe = (UChar)iMaxPos;
3498	return;
3499	}
3500	}
3501	else if( iVirtualEndX > iMaxPos )
3502	{
3503	Int iYe = roftoi( (Double)(iMaxPos - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
3504	if( iYe < (Int)uiScaledBlockSize )
3505	{
3506	ruhXe = (UChar)iMaxPos;
3507	ruhYe = (UChar)std::max( iYe, 0 );
3508	std::swap( ruhXs, ruhXe );
3509	std::swap( ruhYs, ruhYe );
3510	return;
3511	}
3512	else
3513	{
3514	ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
3515	ruhYe = (UChar)iMaxPos;
3516	return;
3517	}
3518	}
3519	else
3520	{
3521	Int iXe = iVirtualEndX + iDeltaEnd;
3522	if( iXe < 0 )
3523	{
3524	ruhXe = 0;
3525	ruhYe = (UChar)std::max( (iMaxPos + iXe), 0 );
3526	return;
3527	}
3528	else if( iXe > iMaxPos )
3529	{
3530	ruhXe = (UChar)iMaxPos;
3531	ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
3532	std::swap( ruhXs, ruhXe );
3533	std::swap( ruhYs, ruhYe );
3534	return;
3535	}
3536	else
3537	{
3538	ruhXe = (UChar)iXe;
3539	ruhYe = (UChar)iMaxPos;
3540	return;
3541	}
3542	}
3543	}
3544
3545	// case left
3546	if( uiScaledStartPosY > 0 && uiScaledStartPosX == 0 )
3547	{
3548	ruhXs = 0;
3549	ruhYs = (UChar)uiScaledStartPosY;
3550
3551	if( iDeltaX == 0 )
3552	{
3553	if( iDeltaY < 0 )
3554	{
3555	ruhXe = (UChar)std::min( std::max( -iDeltaEnd, 0 ), iMaxPos );
3556	ruhYe = 0;
3557	std::swap( ruhXs, ruhXe );
3558	std::swap( ruhYs, ruhYe );
3559	return;
3560	}
3561	else
3562	{
3563	ruhXe = (UChar)std::min( std::max( iDeltaEnd, 0 ), iMaxPos );
3564	ruhYe = (UChar)iMaxPos;
3565	return;
3566	}
3567	}
3568
3569	// regular case
3570	Int iVirtualEndY = (Int)ruhYs + roftoi( (Double)iMaxPos * ((Double)iDeltaY / (Double)iDeltaX) );
3571
3572	if( iVirtualEndY < 0 )
3573	{
3574	Int iXe = roftoi( (Double)(0 - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) - iDeltaEnd;
3575	if( iXe < (Int)uiScaledBlockSize )
3576	{
3577	ruhXe = (UChar)std::max( iXe, 0 );
3578	ruhYe = 0;
3579	std::swap( ruhXs, ruhXe );
3580	std::swap( ruhYs, ruhYe );
3581	return;
3582	}
3583	else
3584	{
3585	ruhXe = (UChar)iMaxPos;
3586	ruhYe = (UChar)std::min( (iXe - iMaxPos), iMaxPos );
3587	std::swap( ruhXs, ruhXe );
3588	std::swap( ruhYs, ruhYe );
3589	return;
3590	}
3591	}
3592	else if( iVirtualEndY > (uiScaledBlockSize-1) )
3593	{
3594	Int iXe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) + iDeltaEnd;
3595	if( iXe < (Int)uiScaledBlockSize )
3596	{
3597	ruhXe = (UChar)std::max( iXe, 0 );
3598	ruhYe = (UChar)(uiScaledBlockSize-1);
3599	return;
3600	}
3601	else
3602	{
3603	ruhXe = (UChar)iMaxPos;
3604	ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
3605	std::swap( ruhXs, ruhXe );
3606	std::swap( ruhYs, ruhYe );
3607	return;
3608	}
3609	}
3610	else
3611	{
3612	Int iYe = iVirtualEndY - iDeltaEnd;
3613	if( iYe < 0 )
3614	{
3615	ruhXe = (UChar)std::max( (iMaxPos + iYe), 0 );
3616	ruhYe = 0;
3617	std::swap( ruhXs, ruhXe );
3618	std::swap( ruhYs, ruhYe );
3619	return;
3620	}
3621	else if( iYe > iMaxPos )
3622	{
3623	ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
3624	ruhYe = (UChar)iMaxPos;
3625	return;
3626	}
3627	else
3628	{
3629	ruhXe = (UChar)iMaxPos;
3630	ruhYe = (UChar)iYe;
3631	std::swap( ruhXs, ruhXe );
3632	std::swap( ruhYs, ruhYe );
3633	return;
3634	}
3635	}
3636	}
3637
3638	// case origin
3639	if( uiScaledStartPosX == 0 && uiScaledStartPosY == 0 )
3640	{
3641	if( iDeltaX*iDeltaY < 0 )
3642	{
3643	return;
3644	}
3645
3646	ruhXs = 0;
3647	ruhYs = 0;
3648
3649	if( iDeltaY == 0 )
3650	{
3651	ruhXe = (UChar)iMaxPos;
3652	ruhYe = 0;
3653	std::swap( ruhXs, ruhXe );
3654	std::swap( ruhYs, ruhYe );
3655	return;
3656	}
3657
3658	if( iDeltaX == 0 )
3659	{
3660	ruhXe = 0;
3661	ruhYe = (UChar)iMaxPos;
3662	return;
3663	}
3664
3665	Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)iMaxPos * ((Double)iDeltaX / (Double)iDeltaY) );
3666
3667	if( iVirtualEndX > iMaxPos )
3668	{
3669	Int iYe = roftoi( (Double)((Int)iMaxPos - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
3670	if( iYe < (Int)uiScaledBlockSize )
3671	{
3672	ruhXe = (UChar)(uiScaledBlockSize-1);
3673	ruhYe = (UChar)std::max( iYe, 0 );
3674	std::swap( ruhXs, ruhXe );
3675	std::swap( ruhYs, ruhYe );
3676	return;
3677	}
3678	else
3679	{
3680	ruhXe = (UChar)std::max( (iMaxPos - (iYe - iMaxPos)), 0 );
3681	ruhYe = (UChar)(uiScaledBlockSize-1);
3682	return;
3683	}
3684	}
3685	else
3686	{
3687	Int iXe = iVirtualEndX + iDeltaEnd;
3688	if( iXe < 0 )
3689	{
3690	ruhXe = 0;
3691	ruhYe = (UChar)std::max( (iMaxPos + iXe), 0 );
3692	return;
3693	}
3694	else if( iXe > iMaxPos )
3695	{
3696	ruhXe = (UChar)(uiScaledBlockSize-1);
3697	ruhYe = (UChar)std::max( (iMaxPos - (iXe - iMaxPos)), 0 );
3698	std::swap( ruhXs, ruhXe );
3699	std::swap( ruhYs, ruhYe );
3700	return;
3701	}
3702	else
3703	{
3704	ruhXe = (UChar)iXe;
3705	ruhYe = (UChar)(uiScaledBlockSize-1);
3706	return;
3707	}
3708	}
3709	}
3710	}
3711	#endif
3712
3713	Void
3714	TComPrediction::predIntraDepthAng(TComPattern* pcTComPattern, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight )
3715	{
3716	Pel* pDst = piPred;
3717	Int* ptrSrc = pcTComPattern->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
3718	Int sw = ( iWidth<<1 ) + 1;
3719	xPredIntraAngDepth( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode );
3720	}
3721
3722	Int
3723	TComPrediction::xGetDCDepth( Int* pSrc, Int iDelta, Int iBlkSize )
3724	{
3725	Int iDC = PDM_UNDEFINED_DEPTH;
3726	Int iSum = 0;
3727	Int iNum = 0;
3728	for( Int k = 0; k < iBlkSize; k++, pSrc += iDelta )
3729	{
3730	if( *pSrc != PDM_UNDEFINED_DEPTH )
3731	{
3732	iSum += *pSrc;
3733	iNum ++;
3734	}
3735	}
3736	if( iNum )
3737	{
3738	iDC = ( iSum + ( iNum >> 1 ) ) / iNum;
3739	}
3740	return iDC;
3741	}
3742
3743	Int
3744	TComPrediction::xGetDCValDepth( Int iVal1, Int iVal2, Int iVal3, Int iVal4 )
3745	{
3746	if ( iVal1 != PDM_UNDEFINED_DEPTH ) return iVal1;
3747	else if( iVal2 != PDM_UNDEFINED_DEPTH ) return iVal2;
3748	else if( iVal3 != PDM_UNDEFINED_DEPTH ) return iVal3;
3749	return iVal4;
3750	}
3751
3752	Void
3753	TComPrediction::xPredIntraAngDepth( Int* pSrc, Int srcStride, Pel* pDst, Int dstStride, UInt width, UInt height, UInt dirMode )
3754	{
3755	AOF( width == height );
3756	Int blkSize = width;
3757	Int iDCAbove = xGetDCDepth( pSrc - srcStride, 1, blkSize );
3758	Int iDCAboveRight = xGetDCDepth( pSrc - srcStride + blkSize, 1, blkSize );
3759	Int iDCLeft = xGetDCDepth( pSrc - 1, srcStride, blkSize );
3760	Int iDCBelowLeft = xGetDCDepth( pSrc - 1 + blkSize * srcStride, srcStride, blkSize );
3761	Int iWgt, iDC1, iDC2;
3762	if( dirMode < 2 ) // 1..2
3763	{
3764	iDC1 = xGetDCValDepth( iDCAbove, iDCAboveRight, iDCLeft, iDCBelowLeft );
3765	iDC2 = xGetDCValDepth( iDCLeft, iDCBelowLeft, iDCAbove, iDCAboveRight );
3766	iWgt = 8;
3767	}
3768	else if( dirMode < 11 ) // 3..10
3769	{
3770	iDC1 = xGetDCValDepth( iDCLeft, iDCBelowLeft, iDCAbove, iDCAboveRight );
3771	iDC2 = xGetDCValDepth( iDCBelowLeft, iDCLeft, iDCAbove, iDCAboveRight );
3772	iWgt = 6 + dirMode;
3773	}
3774	else if( dirMode < 27 ) // 11..26
3775	{
3776	iDC1 = xGetDCValDepth( iDCAbove, iDCAboveRight, iDCLeft, iDCBelowLeft );
3777	iDC2 = xGetDCValDepth( iDCLeft, iDCBelowLeft, iDCAbove, iDCAboveRight );
3778	iWgt = dirMode - 10;
3779	}
3780	else if( dirMode < 35 ) // 27..34
3781	{
3782	iDC1 = xGetDCValDepth( iDCAbove, iDCAboveRight, iDCLeft, iDCBelowLeft );
3783	iDC2 = xGetDCValDepth( iDCAboveRight, iDCAbove, iDCLeft, iDCBelowLeft );
3784	iWgt = 42 - dirMode;
3785	}
3786	else // (wedgelet -> use simple DC prediction
3787	{
3788	iDC1 = xGetDCValDepth( iDCAbove, iDCAboveRight, iDCLeft, iDCBelowLeft );
3789	iDC2 = xGetDCValDepth( iDCLeft, iDCBelowLeft, iDCAbove, iDCAboveRight );
3790	iWgt = 8;
3791	}
3792	Int iWgt2 = 16 - iWgt;
3793	Int iDCVal = ( iWgt * iDC1 + iWgt2 * iDC2 + 8 ) >> 4;
3794
3795	// set depth
3796	for( Int iY = 0; iY < blkSize; iY++, pDst += dstStride )
3797	{
3798	for( Int iX = 0; iX < blkSize; iX++ )
3799	{
3800	pDst[ iX ] = iDCVal;
3801	}
3802	}
3803	}
3804
3805	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-6.0-dev0/source/Lib/TLibCommon/TComPrediction.cpp @ 312

Download in other formats: