Context navigation

source: 3DVCSoftware/trunk/source/Lib/TLibRenderer/TRenTop.cpp @ 2

Visit:

Last change on this file since 2 was 2, checked in by hhi, 13 years ago
inital import
Property svn:eol-style set to `native`
File size: 80.8 KB

Line
1
2	#include "TRenImage.h"
3	#include "TRenTop.h"
4
5	#include "TRenFilter.h"
6	#include <iostream>
7	#include <math.h>
8	#include "../TLibCommon/CommonDef.h"
9
10	Void TRenTop::xGetDataPointers( PelImage& rpcInputImage, PelImage& rpcOutputImage, PelImage& rpcInputDepth, PelImage& rpcOutputDepth, PelImage*& rpcFilled, Bool bRenderDepth )
11	{
12	UInt uiWidth = m_auiInputResolution[0] << m_iLog2SamplingFactor;
13
14	UInt uiSubPelWidth = uiWidth;
15
16	if ( m_iInterpolationMode == eRenInt8Tap )
17	{
18	uiSubPelWidth <<= m_iRelShiftLUTPrec;
19	}
20
21	UInt uiHeight = m_auiInputResolution[1];
22
23	if ( m_bUVUp )
24	{
25	rpcInputDepth = new PelImage(uiSubPelWidth, uiHeight,1,0);
26	rpcInputImage = new PelImage(uiSubPelWidth, uiHeight,3,0);
27	rpcOutputImage = new PelImage(uiWidth, uiHeight,3,0);
28	rpcOutputDepth = bRenderDepth ? new PelImage(uiWidth, uiHeight,1,0) : 0;
29	rpcFilled = new PelImage(uiWidth, uiHeight,1,0);
30	}
31	else
32	{
33	rpcInputDepth = new PelImage(uiSubPelWidth, uiHeight,1,1);
34	rpcInputImage = new PelImage(uiSubPelWidth, uiHeight,1,2);
35	rpcOutputImage = new PelImage(uiWidth, uiHeight,1,2);
36	rpcOutputDepth = bRenderDepth ? new PelImage(uiWidth, uiHeight,1,1) : 0;
37	rpcFilled = new PelImage(uiWidth, uiHeight,1,1);
38	}
39
40	}
41
42	Void TRenTop::xGetDataPointerOutputImage( PelImage& rpcOutputImage, PelImage& rpcOutputDepth )
43	{
44
45	UInt uiWidth = m_auiInputResolution[0] << m_iLog2SamplingFactor;
46	UInt uiHeight = m_auiInputResolution[1];
47
48	if ( m_bUVUp )
49	{
50	rpcOutputImage = new PelImage(uiWidth, uiHeight,3,0);
51	rpcOutputDepth = (m_iBlendMode == eRenBlendDepthFirst ) ? new PelImage(uiWidth, uiHeight,1,0) : NULL;
52	}
53	else
54	{
55	rpcOutputImage = new PelImage(uiWidth, uiHeight,1,2);
56	rpcOutputDepth = (m_iBlendMode == eRenBlendDepthFirst ) ? new PelImage(uiWidth, uiHeight,1,1) : NULL;
57	}
58	}
59
60	Void TRenTop::xConvertInputVideo( PelImage* pcOrgInputImage, PelImage* pcConvInputImage)
61	{
62	TRenImagePlane<Pel>* pcOrgPlane ;
63	TRenImagePlane<Pel>* pcConvPlane;
64
65	Int iLog2SamplingFactor = m_iLog2SamplingFactor;
66
67	if ( m_iInterpolationMode == eRenInt8Tap)
68	{
69	iLog2SamplingFactor += m_iRelShiftLUTPrec;
70	}
71
72	AOT( iLog2SamplingFactor > 2);
73
74	for (UInt uiPlane = 0; uiPlane < 3; uiPlane++)
75	{
76	pcOrgPlane = pcOrgInputImage ->getPlane(uiPlane);
77	pcConvPlane = pcConvInputImage->getPlane(uiPlane);
78
79	if (uiPlane == 0)
80	{
81	TRenFilter::sampleHorUp ( iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
82	}
83	else
84	{
85	if ( m_bUVUp )
86	{
87	TRenFilter::sampleCUpHorUp( iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
88	}
89	else
90	{
91	TRenFilter::sampleCHorUp ( iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
92	}
93	}
94	}
95	}
96
97	Void TRenTop::xConvertInputDepth( PelImage* pcOrgInputImage, PelImage* pcConvInputImage)
98	{
99	PelImagePlane* pcOrgPlane ;
100	PelImagePlane* pcConvPlane;
101
102	// Full Plane
103	pcOrgPlane = pcOrgInputImage ->getPlane(0);
104	pcConvPlane = pcConvInputImage->getPlane(0);
105
106	Int iLog2SamplingFactor = m_iLog2SamplingFactor;
107
108	if ( m_iInterpolationMode == eRenInt8Tap)
109	{
110	iLog2SamplingFactor += m_iRelShiftLUTPrec;
111	}
112	AOT( iLog2SamplingFactor > 2);
113
114	TRenFilter::sampleHorUp(iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
115
116	if ( !m_bUVUp ) //GT: depth down
117	{
118	// Quarter Plane
119	PelImagePlane* pcTempPlane = new PelImagePlane(pcOrgInputImage->getPlane(0)->getWidth(), ( pcOrgInputImage->getPlane(0)->getHeight() >> 1), REN_LUMA_MARGIN );
120
121	TRenFilter::sampleVerDown2Tap13(pcOrgInputImage->getPlane(0), pcTempPlane, 12);
122	pcConvPlane = pcConvInputImage->getPlane(1);
123
124	if ( iLog2SamplingFactor == 0 )
125	{
126	TRenFilter::sampleHorDown2Tap13(pcTempPlane, pcConvPlane, 0 );
127	}
128	else
129	{
130	TRenFilter::sampleHorUp ( iLog2SamplingFactor - 1, pcTempPlane->getPlaneData(), pcTempPlane->getStride(), pcTempPlane->getWidth(), pcTempPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
131	}
132	delete pcTempPlane;
133	}
134	}
135
136	Void TRenTop::xConvertInputData( PelImage* pcOrgInputImage, PelImage* pcOrgInputDepth, PelImage* pcConvInputImage, PelImage* pcConvInputDepth, Bool bMirror )
137	{
138	//ToDo: remove unnecessary copying
139	if ( bMirror )
140	{
141	m_pcTempImage->assign( pcOrgInputImage );
142	TRenFilter::mirrorHor( m_pcTempImage );
143	m_pcTempImage->extendMargin();
144	xConvertInputVideo( m_pcTempImage, pcConvInputImage );
145
146	m_pcTempImage->getPlane(0)->assign( pcOrgInputDepth->getPlane(0) );
147	TRenFilter::mirrorHor( m_pcTempImage->getPlane(0) );
148	m_pcTempImage->getPlane(0)->extendMargin();
149	xConvertInputDepth( m_pcTempImage, pcConvInputDepth );
150	}
151	else
152	{
153	m_pcTempImage->assign( pcOrgInputImage );
154	m_pcTempImage->extendMargin();
155	xConvertInputVideo( m_pcTempImage, pcConvInputImage );
156
157	m_pcTempImage->getPlane(0)->assign( pcOrgInputDepth->getPlane(0) );
158	m_pcTempImage->getPlane(0)->extendMargin();
159	xConvertInputDepth( m_pcTempImage, pcConvInputDepth );
160	}
161	}
162
163
164	Void TRenTop::xConvertOutputData( PelImage* pcOrgOutputImage, PelImage* pcConvOutputImage, Bool bMirror )
165	{
166	Int iLog2SamplingFactor = m_iLog2SamplingFactor;
167
168	for ( UInt uiPlane = 0; uiPlane < 3; uiPlane++)
169	{
170	PelImagePlane* pcOrgPlane = pcOrgOutputImage ->getPlane(uiPlane);
171	PelImagePlane* pcConvPlane = pcConvOutputImage->getPlane(uiPlane);
172
173	pcOrgPlane->extendMargin();
174
175	if ( uiPlane == 0 )
176	{
177	TRenFilter::sampleHorDown( iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
178	}
179	else
180	{
181	if ( m_bUVUp )
182	{
183	TRenFilter::sampleCDownHorDown( iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
184	}
185	else
186	{
187	TRenFilter::sampleCHorDown ( iLog2SamplingFactor, pcOrgPlane->getPlaneData(), pcOrgPlane->getStride(), pcOrgPlane->getWidth(), pcOrgPlane->getHeight(), pcConvPlane->getPlaneData(), pcConvPlane->getStride());
188	}
189	}
190	}
191
192	if ( bMirror )
193	{
194	TRenFilter::mirrorHor( pcConvOutputImage );
195	}
196
197	}
198
199	Void TRenTop::setShiftLUTs( Double ppdShiftLUTLeft, Int ppiShiftLUTLeft, Int ppiBaseShiftLUTLeft, Double ppdShiftLUTRight, Int ppiShiftLUTRight, Int ppiBaseShiftLUTRight, Int iRelDistToLeft )
200	{
201	m_ppdShiftLUTLeft = ppdShiftLUTLeft;
202	m_ppdShiftLUTRight = ppdShiftLUTRight;
203
204	m_ppiShiftLUTLeft = ppiShiftLUTLeft;
205	m_ppiShiftLUTRight = ppiShiftLUTRight;
206
207	if ( m_ppdShiftLUTRight != NULL && m_ppiShiftLUTRight != NULL )
208	{
209	for( UInt uiPlane = 0; uiPlane < 2; uiPlane++)
210	{
211	for (UInt uiDepthValue = 0; uiDepthValue <= 256; uiDepthValue++)
212	{
213	m_ppdShiftLUTRightMirror[uiPlane][uiDepthValue] = - m_ppdShiftLUTRight[uiPlane][uiDepthValue];
214	m_ppiShiftLUTRightMirror[uiPlane][uiDepthValue] = - m_ppiShiftLUTRight[uiPlane][uiDepthValue];
215	}
216	}
217	}
218
219	if ( !m_bExtrapolate )
220	{
221	TRenFilter::setupZLUT( m_bBlendUseDistWeight, m_iBlendZThresPerc, iRelDistToLeft, ppiBaseShiftLUTLeft, ppiBaseShiftLUTRight, m_iBlendZThres, m_iBlendDistWeight, m_piInvZLUTLeft, m_piInvZLUTRight);
222	}
223	}
224
225	Void TRenTop::extrapolateView( TComPicYuv* pcPicYuvVideo, TComPicYuv* pcPicYuvDepth, TComPicYuv* pcPicYuvSynthOut, Bool bRenderFromLeft )
226	{
227	AOF( m_bExtrapolate );
228	AOF( bRenderFromLeft ? m_ppiShiftLUTLeft \|\| m_ppdShiftLUTLeft : m_ppiShiftLUTRight \|\| m_ppdShiftLUTRight );
229	AOF( m_auiInputResolution[0] == pcPicYuvVideo->getWidth ());
230	AOF( m_auiInputResolution[1] == pcPicYuvVideo->getHeight());
231
232	PelImage cInputImage ( pcPicYuvVideo );
233	PelImage cInputDepth ( pcPicYuvDepth , true);
234	PelImage cOutputImage( pcPicYuvSynthOut );
235
236	m_pcOutputImage->init();
237	m_pcFilled ->assign(REN_IS_HOLE);
238
239	xPreProcessDepth ( &cInputDepth, &cInputDepth);
240	xConvertInputData( &cInputImage, &cInputDepth, m_pcInputImage, m_pcInputDepth, !bRenderFromLeft );
241	xShiftPixels(m_pcInputImage, m_pcInputDepth, m_pcOutputImage, m_pcFilled, bRenderFromLeft);
242	xRemBoundaryNoise ( m_pcOutputImage, m_pcFilled, m_pcOutputImage, bRenderFromLeft); // Erode
243	xFillHoles ( m_pcOutputImage, m_pcFilled, m_pcOutputImage, bRenderFromLeft);
244	xConvertOutputData( m_pcOutputImage, &cOutputImage, !bRenderFromLeft );
245	xPostProcessImage (&cOutputImage, &cOutputImage);
246	xCutMargin ( &cOutputImage );
247	};
248
249	Void TRenTop::getUsedSamplesMap( TComPicYuv* pcPicYuvDepth, TComPicYuv* pcUsedSampleMap, Bool bRenderFromLeft )
250	{
251	AOF( bRenderFromLeft ? m_ppiShiftLUTLeft && m_ppdShiftLUTLeft : m_ppiShiftLUTRight && m_ppdShiftLUTRight );
252	AOF(m_auiInputResolution[0] == pcPicYuvDepth->getWidth ());
253	AOF(m_auiInputResolution[1] == pcPicYuvDepth->getHeight());
254
255	PelImage cInputDepth ( pcPicYuvDepth , true);
256	PelImage cOutputImage( pcUsedSampleMap );
257	PelImage cInputImage ( m_auiInputResolution[0], m_auiInputResolution[1], 1, 2 );
258	cInputImage.assign(0);
259
260	m_pcFilled ->assign(REN_IS_HOLE);
261	xConvertInputData( &cInputImage, &cInputDepth, m_pcInputImage, m_pcInputDepth, !bRenderFromLeft );
262	xShiftPixels (m_pcInputImage, m_pcInputDepth, m_pcOutputImage, m_pcFilled, bRenderFromLeft);
263
264	xCreateAlphaMap ( m_pcFilled, m_pcFilled, bRenderFromLeft );
265
266	if ( !bRenderFromLeft )
267	{
268	TRenFilter::mirrorHor( m_pcFilled );
269	}
270
271	TRenFilter::filledToUsedPelMap( m_pcFilled, &cOutputImage, m_iUsedPelMapMarExt );
272	};
273
274
275	Void TRenTop::interpolateView( TComPicYuv* pcPicYuvVideoLeft, TComPicYuv* pcPicYuvDepthLeft, TComPicYuv* pcPicYuvVideoRight, TComPicYuv* pcPicYuvDepthRight, TComPicYuv* pcPicYuvSynthOut, Int iBlendMode, Int iSimEnhBaseView )
276	{
277	assert( !m_bExtrapolate );
278	assert( m_auiInputResolution[0] == pcPicYuvVideoLeft ->getWidth () );
279	assert( m_auiInputResolution[1] == pcPicYuvVideoRight->getHeight() );
280
281	AOT( iBlendMode == 3);
282	m_iBlendMode = iBlendMode;
283	m_iSimEnhBaseView = iSimEnhBaseView;
284
285	PelImage cLeftInputImage ( pcPicYuvVideoLeft );
286	PelImage cLeftInputDepth ( pcPicYuvDepthLeft, true );
287	PelImage cRightInputImage ( pcPicYuvVideoRight );
288	PelImage cRightInputDepth ( pcPicYuvDepthRight , true );
289	PelImage cOutputImage ( pcPicYuvSynthOut );
290
291	m_pcLeftOutputImage ->init();
292	m_pcRightOutputImage->init();
293	m_pcOutputImage ->init();
294
295	if ( m_iBlendMode == eRenBlendDepthFirst )
296	{
297	m_pcOutputDepth->init();
298	}
299
300	m_pcLeftFilled ->assign(REN_IS_HOLE);
301	m_pcRightFilled->assign(REN_IS_HOLE);
302
303	xPreProcessDepth(&cLeftInputDepth , &cLeftInputDepth );
304	xPreProcessDepth(&cRightInputDepth, &cRightInputDepth);
305
306	xConvertInputData( &cLeftInputImage, &cLeftInputDepth, m_pcLeftInputImage, m_pcLeftInputDepth ,false );
307	xConvertInputData( &cRightInputImage, &cRightInputDepth, m_pcRightInputImage, m_pcRightInputDepth ,true );
308
309	// Render from Left View to Right view
310	if ( m_iBlendMode != eRenBlendDepthFirst )
311	{
312	xShiftPixels(m_pcLeftInputImage, m_pcLeftInputDepth, m_pcLeftOutputImage, m_pcLeftFilled, true );
313	xFillHoles (m_pcLeftOutputImage, m_pcLeftFilled, m_pcLeftOutputImage, true );
314	}
315
316	xShiftPixels(m_pcLeftInputDepth, m_pcLeftInputDepth, m_pcLeftOutputDepth, m_pcLeftFilled, true );
317	xFillHoles ( m_pcLeftOutputDepth, m_pcLeftFilled, m_pcLeftOutputDepth, true);
318	xCreateAlphaMap( m_pcLeftFilled, m_pcLeftFilled, true );
319
320	// Render from Right View to Left view
321	if ( m_iBlendMode != eRenBlendDepthFirst )
322	{
323	xShiftPixels(m_pcRightInputImage , m_pcRightInputDepth, m_pcRightOutputImage, m_pcRightFilled, false );
324	xFillHoles (m_pcRightOutputImage, m_pcRightFilled, m_pcRightOutputImage, false);
325	}
326
327	xShiftPixels(m_pcRightInputDepth, m_pcRightInputDepth, m_pcRightOutputDepth, m_pcRightFilled, false);
328	xFillHoles ( m_pcRightOutputDepth, m_pcRightFilled, m_pcRightOutputDepth, false);
329	xCreateAlphaMap( m_pcRightFilled, m_pcRightFilled, false );
330
331	TRenFilter::mirrorHor( m_pcRightOutputImage );
332	TRenFilter::mirrorHor( m_pcRightOutputDepth );
333	TRenFilter::mirrorHor( m_pcRightFilled );
334
335	xEnhSimilarity( m_pcLeftOutputImage, m_pcRightOutputImage, m_pcLeftFilled, m_pcRightFilled );
336
337	if ( m_iBlendMode == eRenBlendDepthFirst )
338	{
339	xBlend ( m_pcLeftOutputDepth, m_pcRightOutputDepth, m_pcLeftFilled, m_pcRightFilled, m_pcLeftOutputDepth, m_pcRightOutputDepth, m_pcOutputDepth);
340
341	xBackShiftPixels ( m_pcLeftInputImage, m_pcOutputDepth, m_pcLeftOutputImage, m_pcLeftFilled , false);
342	xFillHoles ( m_pcLeftOutputImage, m_pcLeftFilled, m_pcLeftOutputImage, false);
343	xCreateAlphaMap ( m_pcLeftFilled, m_pcLeftFilled, true );
344
345	TRenFilter::mirrorHor( m_pcRightInputImage );
346	xBackShiftPixels ( m_pcRightInputImage, m_pcOutputDepth, m_pcRightOutputImage, m_pcRightFilled , true );
347	xFillHoles ( m_pcRightOutputImage, m_pcRightFilled, m_pcRightOutputImage, true);
348
349	TRenFilter::mirrorHor( m_pcRightFilled );
350	xCreateAlphaMap ( m_pcRightFilled, m_pcRightFilled, true );
351	TRenFilter::mirrorHor( m_pcRightFilled );
352	}
353
354	xBlend(m_pcLeftOutputImage, m_pcRightOutputImage, m_pcLeftFilled, m_pcRightFilled, m_pcLeftOutputDepth, m_pcRightOutputDepth, m_pcOutputImage);
355
356	xConvertOutputData( m_pcOutputImage, &cOutputImage , false );
357	xPostProcessImage ( &cOutputImage, &cOutputImage);
358	xCutMargin( &cOutputImage );
359	};
360
361
362	Void TRenTop::xPreProcessDepth( PelImage* pcInImage, PelImage* pcOutImage )
363	{
364	if ( m_iPreProcMode == eRenPreProNone )
365	return;
366
367	PelImage* pcTemp;
368
369	if (pcInImage == pcOutImage)
370	{
371	pcTemp = pcOutImage->create();
372	}
373	else
374	{
375	pcTemp = pcOutImage;
376	}
377
378	pcTemp->assign(pcInImage);
379
380	switch ( m_iPreProcMode )
381	{
382	case eRenPreProBinom:
383	TRenFilter::binominal(pcOutImage, pcTemp, m_iPreFilterSize);
384	break;
385	case eRenPreProNone:
386	break;
387	default:
388	assert(0);
389	break;
390	}
391
392	if (pcInImage == pcOutImage)
393	{
394	pcOutImage->setData(pcTemp, true);
395	delete pcTemp;
396	};
397
398	}
399
400	Void TRenTop::xShiftPlanePixelsLinInt( PelImagePlane** apcInputPlanes, PelImagePlane* pcDepthPlane, PelImagePlane** apcOutputPlanes, PelImagePlane* pcFilledPlane, UInt uiNumberOfPlanes )
401	{
402	Int iWidth = apcInputPlanes[0]->getWidth();
403	Int iHeight = apcInputPlanes[0]->getHeight();
404
405	Int iInputStride = apcInputPlanes [0]->getStride();
406	Int iOutputStride = apcOutputPlanes[0]->getStride();
407
408	Int iFilledStride = pcFilledPlane->getStride();
409	Int iDepthStride = pcDepthPlane ->getStride();
410
411	pcFilledPlane->assign(REN_IS_HOLE);
412
413	Pel** apcInputData = new Pel*[ uiNumberOfPlanes ];
414	Pel** apcOutputData = new Pel*[ uiNumberOfPlanes ];
415
416	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
417	{
418	apcInputData [uiCurPlane] = apcInputPlanes [uiCurPlane]->getPlaneData();
419	apcOutputData [uiCurPlane] = apcOutputPlanes[uiCurPlane]->getPlaneData();
420	assert( iWidth == apcInputPlanes [uiCurPlane]->getWidth() && iWidth == apcOutputPlanes[uiCurPlane]->getWidth() );
421	assert( iHeight == apcInputPlanes [uiCurPlane]->getHeight() && iHeight == apcOutputPlanes[uiCurPlane]->getHeight());
422	assert( iInputStride == apcInputPlanes [uiCurPlane]->getStride() && iOutputStride == apcOutputPlanes[uiCurPlane]->getStride());
423	}
424
425	Pel* pcDepthData = pcDepthPlane ->getPlaneData();
426	Pel* pcFilledData = pcFilledPlane->getPlaneData();
427
428	for(Int iPosY = 0; iPosY < iHeight; iPosY++)
429	{
430	Int iPrevShiftedPos = -1;
431	Int iShiftedPos = -1;
432
433	for(Int iPosX = 0; iPosX < iWidth; iPosX ++ )
434	{
435	Bool bExtrapolate = false;
436
437	// compute disparity and shift
438	iShiftedPos = ( iPosX << m_iRelShiftLUTPrec ) - m_aiShiftLUTCur[RemoveBitIncrement( pcDepthData[iPosX])];
439
440	if (iPosX == 0)
441	{
442	// in first iteration only get dLeftPos
443	iPrevShiftedPos = iShiftedPos;
444	continue;
445	};
446
447	Int iDeltaPos = iShiftedPos - iPrevShiftedPos;
448
449	if ( iDeltaPos <= 0 \|\| (iDeltaPos > (2 << m_iRelShiftLUTPrec)))
450	{
451	// skip Interpolation if pixel is shifted forwards (gap) or if pixel is shifted backwards (foreground object)
452	bExtrapolate = true;
453	};
454
455	Int iInterPolPos;
456	if (!bExtrapolate)
457	{ // Interpolate between j1 and j2
458	for (iInterPolPos = ( iPrevShiftedPos + (1 << m_iRelShiftLUTPrec) - 1 ) >> m_iRelShiftLUTPrec ; iInterPolPos <= (iShiftedPos >> m_iRelShiftLUTPrec); iInterPolPos++)
459	{
460	if ( (iInterPolPos >= iWidth) \|\| (iInterPolPos < (Int) 0))
461	{
462	// skip Interpolation if Interpolation position is outside frame
463	continue;
464	};
465
466	// Interpolate
467	Int iDeltaCurPos = (iInterPolPos << m_iRelShiftLUTPrec) - iPrevShiftedPos;
468	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
469	{
470	Pel cVal = (( apcInputData[uiCurPlane][iPosX - 1] * iDeltaPos + ( apcInputData[uiCurPlane][iPosX] - apcInputData[uiCurPlane][iPosX - 1] ) * iDeltaCurPos ) / iDeltaPos );
471	apcOutputData[uiCurPlane][iInterPolPos] = cVal;
472	}
473
474	pcFilledData[iInterPolPos] = REN_IS_FILLED;
475	}
476	}
477	else
478	{ // Extrapolate right from dLeftPos and left from dRightPos
479	Int iShiftedPosCeiled = (( iPrevShiftedPos + (1 << m_iRelShiftLUTPrec) - 1) >> m_iRelShiftLUTPrec ) << m_iRelShiftLUTPrec;
480	if ( (iPrevShiftedPos + (m_iRelShiftLUTPrec >> 1) ) > iShiftedPosCeiled )
481	{
482	iInterPolPos = iShiftedPosCeiled >> m_iRelShiftLUTPrec;
483
484	if ( (iInterPolPos >= iWidth) \|\| (iInterPolPos < (Int) 0))
485	{
486	// skip Interpolation if Interpolation position is outside frame
487	iPrevShiftedPos = iShiftedPos;
488	continue;
489	};
490
491	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
492	{
493	apcOutputData[uiCurPlane][iInterPolPos] = apcInputData[uiCurPlane][iPosX - 1];
494	}
495
496	pcFilledData[iInterPolPos] = REN_IS_FILLED;
497	}
498
499	Int iPrevShiftedPosFloor = (iShiftedPos >> m_iRelShiftLUTPrec) << m_iRelShiftLUTPrec;
500	if (iShiftedPos - (m_iRelShiftLUTPrec > 1) < iPrevShiftedPosFloor )
501	{
502	iInterPolPos = iPrevShiftedPosFloor >> m_iRelShiftLUTPrec;
503
504	if ( (iInterPolPos >= iWidth) \|\| (iInterPolPos < (Int) 0))
505	{
506	// skip Interpolation if Interpolation position is outside frame
507	iPrevShiftedPos = iShiftedPos;
508	continue;
509	};
510
511	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
512	{
513	apcOutputData[uiCurPlane][iInterPolPos] = apcInputData[uiCurPlane][iPosX ];
514	}
515
516	pcFilledData[iInterPolPos] = REN_IS_FILLED;
517	}
518	}
519	iPrevShiftedPos = iShiftedPos;
520	}
521
522	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
523	{
524	apcOutputData[uiCurPlane] += iOutputStride;
525	apcInputData [uiCurPlane] += iInputStride;
526	}
527	pcFilledData += iFilledStride;
528	pcDepthData += iDepthStride;
529	}
530	delete[] apcInputData;
531	delete[] apcOutputData;
532	};
533
534
535	Void TRenTop::xShiftPlanePixelsLinReal( PelImagePlane** apcInputPlanes, PelImagePlane* pcDepthPlane, PelImagePlane** apcOutputPlanes, PelImagePlane* pcFilledPlane, UInt uiNumberOfPlanes )
536	{
537	Int iWidth = apcInputPlanes[0]->getWidth();
538	Int iHeight = apcInputPlanes[0]->getHeight();
539
540	Int iInputStride = apcInputPlanes [0]->getStride();
541	Int iOutputStride = apcOutputPlanes[0]->getStride();
542
543	Int iFilledStride = pcFilledPlane->getStride();
544	Int iDepthStride = pcDepthPlane ->getStride();
545
546	pcFilledPlane->assign( REN_IS_HOLE );
547
548	Pel** apcInputData = new Pel*[ uiNumberOfPlanes ];
549	Pel** apcOutputData = new Pel*[ uiNumberOfPlanes ];
550
551	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
552	{
553	apcInputData [uiCurPlane] = apcInputPlanes [uiCurPlane]->getPlaneData();
554	apcOutputData [uiCurPlane] = apcOutputPlanes[uiCurPlane]->getPlaneData();
555	assert( iWidth == apcInputPlanes [uiCurPlane]->getWidth() && iWidth == apcOutputPlanes[uiCurPlane]->getWidth() );
556	assert( iHeight == apcInputPlanes [uiCurPlane]->getHeight() && iHeight == apcOutputPlanes[uiCurPlane]->getHeight());
557	assert( iInputStride == apcInputPlanes [uiCurPlane]->getStride() && iOutputStride == apcOutputPlanes[uiCurPlane]->getStride());
558	}
559
560	Pel* pcDepthData = pcDepthPlane ->getPlaneData();
561	Pel* pcFilledData = pcFilledPlane->getPlaneData();
562
563	///// FEM Stuff /////
564	const UInt cuiMaxPlaneNum = 6; AOT( uiNumberOfPlanes > cuiMaxPlaneNum );
565	IntImagePlane* apcDiffPlane[ cuiMaxPlaneNum ];
566	Int* ppiDiffPlanes[ cuiMaxPlaneNum ];
567	Int iDiffStride = 0;
568
569	if ( m_iInterpolationMode == eRenIntFEM )
570	{
571	AOT( uiNumberOfPlanes > cuiMaxPlaneNum );
572	for ( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++ )
573	{
574	apcDiffPlane[uiCurPlane] = new IntImagePlane( iWidth, iHeight, apcInputPlanes[uiCurPlane]->getPad());
575	TRenFilter::diffHorSym(apcInputPlanes[uiCurPlane] , apcDiffPlane[uiCurPlane]);
576	ppiDiffPlanes[uiCurPlane] = apcDiffPlane[uiCurPlane]->getPlaneData();
577	}
578	iDiffStride = apcDiffPlane[0]->getStride();
579	}
580	///// FEM Stuff End /////
581
582	for(Int iPosY = 0; iPosY < iHeight; iPosY++)
583	{
584	Double dShiftedPos = 0;
585	Double dPrevShiftedPos = 0;
586
587	for(Int iPosX = 0; iPosX < iWidth; iPosX ++ )
588	{
589	Bool bExtrapolate = false;
590
591	// compute disparity and shift
592	assert( RemoveBitIncrement(pcDepthData[iPosX]) >= 0 && RemoveBitIncrement(pcDepthData[iPosX]) <= 256 );
593	dPrevShiftedPos = (Double) iPosX - m_adShiftLUTCur[ RemoveBitIncrement(pcDepthData[iPosX])];
594
595	if (iPosX == 0)
596	{
597	// in first iteration only get dLeftPos
598	dShiftedPos = dPrevShiftedPos;
599	continue;
600	};
601
602	Double dDeltaPos = dPrevShiftedPos - dShiftedPos;
603
604	if ((dDeltaPos <= 0) \|\| ( dDeltaPos > 2 ))
605	{
606	// skip Interpolation if pixel is shifted backwards (foreground object) or if pixel is shifted forwards (gap)
607	bExtrapolate = true;
608	};
609
610	Int iInterPolPos;
611	if (!bExtrapolate)
612	{ // Interpolate between j1 and j2
613	for (iInterPolPos = (Int) ceil(dShiftedPos); iInterPolPos <= floor(dPrevShiftedPos); iInterPolPos++)
614	{
615	if ( (iInterPolPos >= (Int) iWidth) \|\| (iInterPolPos < (Int) 0 ))
616	{
617	// skip Interpolation if Interpolation position is outside frame
618	continue;
619	};
620
621	// Interpolate
622	Pel cVal;
623	if ( m_iInterpolationMode == eRenIntFEM ) //FEM Interpolation
624	{
625	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
626	{
627	cVal = TRenFilter::interpCHSpline(iInterPolPos, dShiftedPos, dPrevShiftedPos, apcInputData[uiCurPlane][iPosX - 1], ppiDiffPlanes[uiCurPlane][iPosX - 1], apcInputData[uiCurPlane][iPosX], ppiDiffPlanes[uiCurPlane][iPosX] );
628	apcOutputData[uiCurPlane][iInterPolPos] = cVal;
629	}
630	}
631	else
632	{
633	Double dDeltaJ = (Double) iInterPolPos - dShiftedPos;
634
635	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
636	{
637	cVal = (UChar) ( (Double) apcInputData[uiCurPlane][iPosX - 1] + ( (Double) apcInputData[uiCurPlane][iPosX] - (Double) apcInputData[uiCurPlane][iPosX - 1] ) / dDeltaPos * dDeltaJ + 0.5);
638	apcOutputData[uiCurPlane][iInterPolPos] = cVal;
639	}
640	};
641
642	pcFilledData[iInterPolPos] = REN_IS_FILLED;
643	}
644	}
645	else
646	{ // Extrapolate right from dLeftPos and left from dRightPos
647	if (dShiftedPos + 0.5 > ceil(dShiftedPos))
648	{
649	iInterPolPos = (Int) ceil(dShiftedPos);
650
651	if ( (iInterPolPos >= (Int) iWidth) \|\| (iInterPolPos < (Int) 0))
652	{
653	// skip Interpolation if Interpolation position is outside frame
654	dShiftedPos = dPrevShiftedPos;
655	continue;
656	};
657
658	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
659	{
660	apcOutputData[uiCurPlane][iInterPolPos] = apcInputData[uiCurPlane][iPosX - 1];
661	}
662
663	pcFilledData[iInterPolPos] = REN_IS_FILLED;
664	}
665
666	if (dPrevShiftedPos - 0.5 < floor(dPrevShiftedPos))
667	{
668	iInterPolPos = (Int) floor(dPrevShiftedPos);
669
670	if ( (iInterPolPos >= (Int) iWidth) \|\| (iInterPolPos < (Int) 0))
671	{
672	// skip Interpolation if Interpolation position is outside frame
673	dShiftedPos = dPrevShiftedPos;
674	continue;
675	};
676
677	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
678	{
679	apcOutputData[uiCurPlane][iInterPolPos] = apcInputData[uiCurPlane][iPosX ];
680	}
681
682	pcFilledData[iInterPolPos] = REN_IS_FILLED;
683	}
684	}
685	dShiftedPos = dPrevShiftedPos;
686	}
687
688	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
689	{
690	apcOutputData[uiCurPlane] += iOutputStride;
691	apcInputData [uiCurPlane] += iInputStride;
692
693	if (m_iInterpolationMode == eRenIntFEM)
694	{
695	ppiDiffPlanes[ uiCurPlane ] += iDiffStride;
696	}
697	}
698
699	pcFilledData += iFilledStride;
700	pcDepthData += iDepthStride;
701	}
702
703	if (m_iInterpolationMode == eRenIntFEM)
704	{
705	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
706	{
707	delete apcDiffPlane[uiCurPlane];
708	}
709	}
710
711	delete[] apcInputData;
712	delete[] apcOutputData;
713	}
714
715
716	Void TRenTop::xShiftPlanePixels( PelImagePlane** apcInPlane, PelImagePlane* pcDepthPlane, PelImagePlane** apcOutPlane, PelImagePlane* pcPlaneFilled, UInt uiNumberOfPlanes )
717	{
718	switch ( m_iInterpolationMode)
719	{
720	case eRenIntFullPel:
721	xShiftPlanePixelsFullPel( apcInPlane, pcDepthPlane, apcOutPlane, pcPlaneFilled, uiNumberOfPlanes);
722	break;
723	case eRenIntFEM:
724	case eRenIntLinReal:
725	xShiftPlanePixelsLinReal( apcInPlane, pcDepthPlane, apcOutPlane, pcPlaneFilled, uiNumberOfPlanes);
726	break;
727	case eRenIntLinInt:
728	xShiftPlanePixelsLinInt ( apcInPlane, pcDepthPlane, apcOutPlane, pcPlaneFilled, uiNumberOfPlanes);
729	break;
730	case eRenInt8Tap:
731	xShiftPlanePixels8Tap ( apcInPlane, pcDepthPlane, apcOutPlane, pcPlaneFilled, uiNumberOfPlanes );
732	break;
733	default:
734	AOF( false );
735	}
736	}
737
738
739	Void TRenTop::xShiftPlanePixelsFullPel( PelImagePlane** apcInputPlanes, PelImagePlane* pcDepthPlane, PelImagePlane** apcOutputPlanes, PelImagePlane* pcFilledPlane, UInt uiNumberOfPlanes )
740	{
741	Int iWidth = apcInputPlanes[0]->getWidth();
742	Int iHeight = apcInputPlanes[0]->getHeight();
743
744	Int iInputStride = apcInputPlanes [0]->getStride();
745	Int iOutputStride = apcOutputPlanes[0]->getStride();
746
747	Int iFilledStride = pcFilledPlane->getStride();
748	Int iDepthStride = pcDepthPlane ->getStride();
749
750	pcFilledPlane->assign(REN_IS_HOLE);
751
752	Pel** apcInputData = new Pel*[ uiNumberOfPlanes ];
753	Pel** apcOutputData = new Pel*[ uiNumberOfPlanes ];
754
755	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
756	{
757	apcInputData [uiCurPlane] = apcInputPlanes [uiCurPlane]->getPlaneData();
758	apcOutputData [uiCurPlane] = apcOutputPlanes[uiCurPlane]->getPlaneData();
759	assert( iWidth == apcInputPlanes [uiCurPlane]->getWidth() && iWidth == apcOutputPlanes[uiCurPlane]->getWidth() );
760	assert( iHeight == apcInputPlanes [uiCurPlane]->getHeight() && iHeight == apcOutputPlanes[uiCurPlane]->getHeight());
761	assert( iInputStride == apcInputPlanes [uiCurPlane]->getStride() && iOutputStride == apcOutputPlanes[uiCurPlane]->getStride());
762	}
763
764	Pel* pcDepthData = pcDepthPlane ->getPlaneData();
765	Pel* pcFilledData = pcFilledPlane->getPlaneData();
766
767	for(Int iPosY = 0; iPosY < iHeight; iPosY++)
768	{
769	Int iPrevShiftedPos = -1;
770
771	for(Int iPosX = 0; iPosX < iWidth; iPosX++)
772	{
773	assert( RemoveBitIncrement(pcDepthData[iPosX]) >= 0 && RemoveBitIncrement(pcDepthData[iPosX]) <= 256 );
774	Int iShiftedPos = iPosX - m_aiShiftLUTCur[ RemoveBitIncrement(pcDepthData[iPosX])] ;
775	if (iShiftedPos < iWidth && iShiftedPos >= 0)
776	{
777	Int iDiff = iShiftedPos - iPrevShiftedPos;
778	if (( iDiff <= 2) && (iDiff > 0) )
779	{
780	for (Int iCurPos = iPrevShiftedPos+1; iCurPos <= iShiftedPos; iCurPos++)
781	{
782	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
783	{
784	apcOutputData[uiCurPlane][iCurPos] = apcInputData[uiCurPlane][iPosX]; // Only small gaps, therefor not necessary NN
785	}
786	pcFilledData[iCurPos] = REN_IS_FILLED;
787	}
788	}
789	else
790	{
791	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
792	{
793	apcOutputData[uiCurPlane][iShiftedPos] = apcInputData[uiCurPlane][iPosX];
794	}
795	pcFilledData[iShiftedPos] = REN_IS_FILLED;
796	}
797	iPrevShiftedPos = iShiftedPos;
798	}
799	}
800	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
801	{
802	apcOutputData[uiCurPlane] += iOutputStride;
803	apcInputData [uiCurPlane] += iInputStride;
804	}
805	pcFilledData += iFilledStride;
806	pcDepthData += iDepthStride;
807	}
808
809	delete[] apcInputData;
810	delete[] apcOutputData;
811	}
812
813	Void TRenTop::xBackShiftPlanePixels( PelImagePlane** apcInputPlanes, PelImagePlane* pcDepthPlane, PelImagePlane** apcOutputPlanes, PelImagePlane* pcFilledPlane, UInt uiNumberOfPlanes )
814	{
815	Int iOutputWidth = apcOutputPlanes[0]->getWidth();
816	Int iInputWidth = apcInputPlanes [0]->getWidth();
817	Int iHeight = apcInputPlanes [0]->getHeight();
818
819	Int iInputStride = apcInputPlanes [0]->getStride();
820	Int iOutputStride = apcOutputPlanes[0]->getStride();
821
822	Int iFilledStride = pcFilledPlane->getStride();
823	Int iDepthStride = pcDepthPlane ->getStride();
824
825	Pel** apcInputData = new Pel*[ uiNumberOfPlanes ];
826	Pel** apcOutputData = new Pel*[ uiNumberOfPlanes ];
827
828	Int iStep = (1 << m_iRelShiftLUTPrec);
829
830	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
831	{
832	apcInputData [uiCurPlane] = apcInputPlanes [uiCurPlane]->getPlaneData();
833	apcOutputData [uiCurPlane] = apcOutputPlanes[uiCurPlane]->getPlaneData();
834	AOF( iInputWidth == apcInputPlanes [uiCurPlane]->getWidth() && iOutputWidth == apcOutputPlanes[uiCurPlane]->getWidth() );
835	AOF( iHeight == apcInputPlanes [uiCurPlane]->getHeight() && iHeight == apcOutputPlanes[uiCurPlane]->getHeight());
836	AOF( iInputStride == apcInputPlanes [uiCurPlane]->getStride() && iOutputStride == apcOutputPlanes[uiCurPlane]->getStride());
837	AOF( iInputWidth == iOutputWidth * iStep );
838	}
839
840	Pel* pcDepthData = pcDepthPlane ->getPlaneData();
841	Pel* pcFilledData = pcFilledPlane->getPlaneData();
842
843
844	for(Int iPosY = 0; iPosY < iHeight; iPosY++)
845	{
846	for(Int iPosX = 0; iPosX < iOutputWidth; iPosX ++)
847	{
848	Int iBackShiftedPos = (iPosX << m_iRelShiftLUTPrec) - m_aiShiftLUTCur[ RemoveBitIncrement( pcDepthData[iPosX] )];
849	if( ( pcFilledData[iPosX] == REN_IS_FILLED ) && (iBackShiftedPos >= 0 ) && ( iBackShiftedPos < iInputWidth ) )
850	{
851	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
852	{
853	apcOutputData[uiCurPlane][iPosX] = apcInputData[uiCurPlane][iBackShiftedPos];
854	}
855	}
856	else
857	{
858	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
859	{
860	apcOutputData[uiCurPlane][iPosX] = 0;
861	}
862	pcFilledData[iPosX] = REN_IS_HOLE;
863	}
864	}
865
866	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
867	{
868	apcOutputData[uiCurPlane] += iOutputStride;
869	apcInputData [uiCurPlane] += iInputStride;
870	}
871	pcFilledData += iFilledStride;
872	pcDepthData += iDepthStride;
873	}
874
875	delete[] apcInputData;
876	delete[] apcOutputData;
877	}
878
879	Void TRenTop::xShiftPlanePixels8Tap( PelImagePlane** apcInputPlanes, PelImagePlane* pcDepthPlane, PelImagePlane** apcOutputPlanes, PelImagePlane* pcFilledPlane, UInt uiNumberOfPlanes )
880	{
881
882	Bool bRenderDepth = (apcInputPlanes[0] == pcDepthPlane);
883
884	Int iOutputWidth = apcOutputPlanes[0]->getWidth();
885	Int iInputWidth = apcInputPlanes [0]->getWidth();
886	Int iHeight = apcInputPlanes [0]->getHeight();
887
888	Int iInputStride = apcInputPlanes [0]->getStride();
889	Int iOutputStride = apcOutputPlanes[0]->getStride();
890
891	Int iFilledStride = pcFilledPlane->getStride();
892	Int iDepthStride = pcDepthPlane ->getStride();
893
894	Int iStep = (1 << m_iRelShiftLUTPrec);
895
896	pcFilledPlane->assign(REN_IS_HOLE);
897
898	Pel** apcInputData = new Pel*[ uiNumberOfPlanes ];
899	Pel** apcOutputData = new Pel*[ uiNumberOfPlanes ];
900
901	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
902	{
903	apcInputData [uiCurPlane] = apcInputPlanes [uiCurPlane]->getPlaneData();
904	apcOutputData [uiCurPlane] = apcOutputPlanes[uiCurPlane]->getPlaneData();
905	AOF( iInputWidth == apcInputPlanes [uiCurPlane]->getWidth() && iOutputWidth == apcOutputPlanes[uiCurPlane]->getWidth() );
906	AOF( iHeight == apcInputPlanes [uiCurPlane]->getHeight() && iHeight == apcOutputPlanes[uiCurPlane]->getHeight());
907	AOF( iInputStride == apcInputPlanes [uiCurPlane]->getStride() && iOutputStride == apcOutputPlanes[uiCurPlane]->getStride());
908	AOF( iInputWidth == iOutputWidth * iStep );
909	}
910
911	Pel* pcDepthData = pcDepthPlane ->getPlaneData();
912	Pel* pcFilledData = pcFilledPlane->getPlaneData();
913
914	for(Int iPosY = 0; iPosY < iHeight; iPosY++)
915	{
916	Int iPrevShiftedPos = -1;
917	Int iShiftedPos = -1;
918
919	for(Int iPosX = 0; iPosX < iInputWidth; iPosX += iStep )
920	{
921	// compute disparity and shift
922	iShiftedPos = iPosX - m_aiShiftLUTCur[RemoveBitIncrement(pcDepthData[iPosX])];
923
924	if ( iPosX == 0 )
925	{
926	// in first iteration only get dLeftPos
927	iPrevShiftedPos = iShiftedPos;
928	continue;
929	};
930
931	Int iDeltaPos = iShiftedPos - iPrevShiftedPos;
932
933	Bool bDisocclusion = ( iDeltaPos > (2 << m_iRelShiftLUTPrec) );
934	Bool bOcclusion = ( iDeltaPos <= 0 );
935
936	Int iInterPolPos;
937	if ( !bDisocclusion && !bOcclusion )
938	{ // Interpolate between previous shifted pos and shifted pos
939	for (iInterPolPos = xCeil( iPrevShiftedPos ); iInterPolPos <= xCeil (iShiftedPos ) -1 ; iInterPolPos++)
940	{
941	if ( (iInterPolPos < (Int) 0) \|\| (iInterPolPos >= iOutputWidth))
942	{
943	// skip Interpolation if Interpolation position is outside frame
944	continue;
945	};
946
947	// Interpolate
948	Int iDeltaCurPos = (iInterPolPos << m_iRelShiftLUTPrec) - iPrevShiftedPos;
949
950	AOF( (iDeltaCurPos <= iDeltaPos) && ( iDeltaCurPos >= 0));
951	AOF( iDeltaPos <= (2 << m_iRelShiftLUTPrec) );
952	AOF( m_aaiSubPelShift[iDeltaPos][iDeltaCurPos] != 0xdeaddead);
953
954	Int iSourcePos;
955
956	if ( bRenderDepth )
957	{
958	iSourcePos = iPosX - iStep; // Render depth with Full Pel accuracy to avoid ringing at sharp depth edges;
959	}
960	else
961	{
962	iSourcePos = iPosX + m_aaiSubPelShift[iDeltaPos][iDeltaCurPos]; // GT: = iPosX - iStep + ( iStep * iDeltaCurPos + ( iDeltaPos >> 1) ) / iDeltaPos;
963	}
964
965	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
966	{
967	apcOutputData[uiCurPlane][iInterPolPos] = apcInputData[uiCurPlane][iSourcePos];
968	}
969
970	pcFilledData[ iInterPolPos] = REN_IS_FILLED;
971	}
972	}
973	else
974	{
975	// Fill Disocclusion Edge
976
977	if ( bDisocclusion )
978	{
979	Int iPrevShiftedPosCeiled = xCeil(iPrevShiftedPos) << m_iRelShiftLUTPrec;
980	iInterPolPos = iPrevShiftedPosCeiled >> m_iRelShiftLUTPrec;
981
982	if ((iPrevShiftedPos + (iStep >> 1) ) > iPrevShiftedPosCeiled )
983	{
984	if ( (iInterPolPos < (Int) 0) \|\| (iInterPolPos >= iOutputWidth))
985	{
986	// skip Interpolation if Interpolation position is outside frame
987	iPrevShiftedPos = iShiftedPos;
988	continue;
989	};
990
991	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
992	{
993	apcOutputData[uiCurPlane][iInterPolPos] = apcInputData[uiCurPlane][iPosX - iStep];
994	}
995	pcFilledData[iInterPolPos] = REN_IS_FILLED;
996	iInterPolPos++;
997	}
998
999	// Fill Disocclusion
1000	if ( m_bInstantHoleFilling )
1001	{
1002	for ( ; iInterPolPos <= xCeil (iShiftedPos ) -1 ; iInterPolPos++)
1003	{
1004	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1005	{
1006	if ( ( iInterPolPos >= 0 ) && ( iInterPolPos < iOutputWidth ) )
1007	{
1008	apcOutputData[uiCurPlane][iInterPolPos] = apcInputData[uiCurPlane][iPosX];
1009	}
1010
1011	}
1012	}
1013	}
1014	}
1015
1016	//// Last sample next to occlusion
1017	Int iShiftedPosFloor = ( iShiftedPos >> m_iRelShiftLUTPrec ) << m_iRelShiftLUTPrec;
1018	if ( bOcclusion && (iShiftedPos - (iStep >> 1) < iShiftedPosFloor) )
1019	{
1020	iInterPolPos = iShiftedPosFloor >> m_iRelShiftLUTPrec;
1021	if ( (iInterPolPos < (Int) 0) \|\| (iInterPolPos >= iOutputWidth))
1022	{
1023	// skip Interpolation if Interpolation position is outside frame
1024	iPrevShiftedPos = iShiftedPos;
1025	continue;
1026	};
1027
1028	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1029	{
1030	apcOutputData[uiCurPlane][iInterPolPos] = apcInputData[uiCurPlane][iPosX ];
1031	}
1032
1033	pcFilledData[iInterPolPos] = REN_IS_FILLED;
1034	}
1035	}
1036	iPrevShiftedPos = iShiftedPos;
1037	}
1038
1039	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1040	{
1041	apcOutputData[uiCurPlane] += iOutputStride;
1042	apcInputData [uiCurPlane] += iInputStride;
1043	}
1044	pcFilledData += iFilledStride;
1045	pcDepthData += iDepthStride;
1046	}
1047	delete[] apcInputData;
1048	delete[] apcOutputData;
1049	};
1050
1051	Void TRenTop::xShiftPixels(PelImage* pcInImage, PelImage* pcDepth, PelImage* pcOutImage, PelImage* pcFilledImage, Bool bShiftFromLeft )
1052	{
1053	PelImage* pcTemp = 0;
1054
1055	if (pcInImage == pcOutImage)
1056	{
1057	pcTemp = pcOutImage->create();
1058	}
1059	else
1060	{
1061	pcTemp = pcOutImage;
1062	}
1063
1064	Double ** ppdShiftLUT = bShiftFromLeft ? m_ppdShiftLUTLeft : m_ppdShiftLUTRightMirror;
1065	Int ** ppiShiftLUT = bShiftFromLeft ? m_ppiShiftLUTLeft : m_ppiShiftLUTRightMirror;
1066
1067	UInt uiNumFullPlanes = pcInImage->getNumberOfFullPlanes();
1068	UInt uiNumQuatPlanes = pcInImage->getNumberOfQuaterPlanes();
1069
1070	assert( uiNumFullPlanes == pcOutImage->getNumberOfFullPlanes () );
1071	assert( uiNumQuatPlanes == pcOutImage->getNumberOfQuaterPlanes() );
1072
1073	m_aiShiftLUTCur = ppiShiftLUT[ 0 ];
1074	m_adShiftLUTCur = ppdShiftLUT[ 0 ];
1075
1076	xShiftPlanePixels( pcInImage->getPlanes(), pcDepth->getPlane(0), pcOutImage->getPlanes(), pcFilledImage->getPlane(0), uiNumFullPlanes );
1077
1078	if (uiNumQuatPlanes > 0)
1079	{
1080	assert( pcDepth->getNumberOfPlanes() > 1 && pcFilledImage->getNumberOfPlanes() > 1);
1081	m_aiShiftLUTCur = ppiShiftLUT[ 1 ];
1082	m_adShiftLUTCur = ppdShiftLUT[ 1 ];
1083	xShiftPlanePixels( pcInImage->getPlanes()+uiNumFullPlanes,pcDepth->getPlane(1), pcOutImage->getPlanes() + uiNumFullPlanes, pcFilledImage->getPlane(1), uiNumQuatPlanes );
1084	}
1085
1086	if (pcInImage == pcOutImage)
1087	{
1088	pcOutImage->assign(pcTemp);
1089	delete pcTemp;
1090	};
1091	};
1092
1093	Void TRenTop::xBackShiftPixels(PelImage* pcInImage, PelImage* pcDepth, PelImage* pcOutImage, PelImage* pcFilledImage, Bool bShiftFromLeft )
1094	{
1095	PelImage* pcTemp = 0;
1096
1097	if (pcInImage == pcOutImage)
1098	{
1099	pcTemp = pcOutImage->create();
1100	}
1101	else
1102	{
1103	pcTemp = pcOutImage;
1104	}
1105
1106	Double ** ppdShiftLUT = bShiftFromLeft ? m_ppdShiftLUTLeft : m_ppdShiftLUTRight;
1107	Int ** ppiShiftLUT = bShiftFromLeft ? m_ppiShiftLUTLeft : m_ppiShiftLUTRight;
1108
1109	UInt uiNumFullPlanes = pcInImage->getNumberOfFullPlanes();
1110	UInt uiNumQuatPlanes = pcInImage->getNumberOfQuaterPlanes();
1111
1112	assert( uiNumFullPlanes == pcOutImage->getNumberOfFullPlanes () );
1113	assert( uiNumQuatPlanes == pcOutImage->getNumberOfQuaterPlanes() );
1114
1115	m_aiShiftLUTCur = ppiShiftLUT[ 0 ];
1116	m_adShiftLUTCur = ppdShiftLUT[ 0 ];
1117
1118	xBackShiftPlanePixels( pcInImage->getPlanes(), pcDepth->getPlane(0), pcOutImage->getPlanes(), pcFilledImage->getPlane(0), uiNumFullPlanes );
1119
1120	if (uiNumQuatPlanes > 0)
1121	{
1122	assert( pcDepth->getNumberOfPlanes() > 1 && pcFilledImage->getNumberOfPlanes() > 1);
1123	m_aiShiftLUTCur = ppiShiftLUT[ 1 ];
1124	m_adShiftLUTCur = ppdShiftLUT[ 1 ];
1125	xBackShiftPlanePixels( pcInImage->getPlanes()+uiNumFullPlanes,pcDepth->getPlane(1), pcOutImage->getPlanes() + uiNumFullPlanes, pcFilledImage->getPlane(1), uiNumQuatPlanes );
1126	}
1127
1128	if (pcInImage == pcOutImage)
1129	{
1130	pcOutImage->assign(pcTemp);
1131	delete pcTemp;
1132	};
1133	};
1134
1135	Void TRenTop::xFillHoles(PelImage* pcInImage, PelImage* pcFilled, PelImage* pcOutImage, Bool bRenderFromLeft )
1136	{
1137	if (pcInImage != pcOutImage)
1138	{
1139	pcOutImage->assign(pcInImage);
1140	}
1141
1142	switch (m_iHoleFillingMode)
1143	{
1144	case eRenHFNone:
1145	break;
1146	case eRenHFLWBackExt:
1147	xFillLWBackExt( pcInImage, pcFilled, pcOutImage, bRenderFromLeft);
1148	break;
1149	default:
1150	break;
1151	}
1152	};
1153
1154	Void TRenTop::xFillLWBackExt( PelImage* pcInImage, PelImage* pcFilledImage, PelImage* pcOutImage, Bool bRenderFromLeft )
1155	{
1156	UInt uiNumFullPlanes = pcInImage->getNumberOfFullPlanes();
1157	UInt uiNumQuatPlanes = pcInImage->getNumberOfQuaterPlanes();
1158
1159	assert( uiNumFullPlanes == pcOutImage->getNumberOfFullPlanes () );
1160	assert( uiNumQuatPlanes == pcOutImage->getNumberOfQuaterPlanes() );
1161
1162	xFillPlaneHoles( pcInImage->getPlanes(), pcFilledImage->getPlane(0), pcOutImage->getPlanes(), uiNumFullPlanes, bRenderFromLeft );
1163
1164	if (uiNumQuatPlanes > 0)
1165	{
1166	assert( pcFilledImage->getNumberOfPlanes() > 1);
1167	xFillPlaneHoles( pcInImage->getPlanes()+uiNumFullPlanes, pcFilledImage->getPlane(1), pcOutImage->getPlanes() + uiNumFullPlanes, uiNumQuatPlanes, bRenderFromLeft );
1168	}
1169	};
1170
1171	Void TRenTop::xCreateAlphaMap(PelImage* pcFilledImage, PelImage* pcAlphaMapImage, Bool bRenderFromLeft )
1172	{
1173	UInt uiNumFullPlanes = pcFilledImage ->getNumberOfFullPlanes();
1174	UInt uiNumQuatPlanes = pcFilledImage->getNumberOfQuaterPlanes();
1175
1176	AOF( uiNumFullPlanes == pcAlphaMapImage->getNumberOfFullPlanes () );
1177	AOF( uiNumQuatPlanes == pcAlphaMapImage->getNumberOfQuaterPlanes() );
1178
1179	xCreateAlphaMapPlane( pcFilledImage->getPlanes(), pcAlphaMapImage->getPlanes(), uiNumFullPlanes, bRenderFromLeft );
1180
1181	if (uiNumQuatPlanes > 0)
1182	{
1183	AOF( pcFilledImage->getNumberOfPlanes() > 1);
1184	xCreateAlphaMapPlane( pcFilledImage->getPlanes()+ uiNumFullPlanes, pcAlphaMapImage->getPlanes()+uiNumFullPlanes, uiNumQuatPlanes, bRenderFromLeft );
1185	}
1186	};
1187
1188	Void TRenTop::xCreateAlphaMapPlane(PelImagePlane apcFilledPlanes, PelImagePlane apcAlphaPlanes, UInt uiNumberOfPlanes, Bool bRenderFromLeft)
1189	{
1190	Int iWidth = apcFilledPlanes [0]->getWidth();
1191	Int iHeight = apcFilledPlanes [0]->getHeight();
1192
1193	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1194	{
1195	AOF( iWidth == apcFilledPlanes [uiCurPlane]->getWidth() && iWidth == apcAlphaPlanes[uiCurPlane]->getWidth() );
1196	AOF( iHeight == apcFilledPlanes [uiCurPlane]->getHeight() && iHeight == apcAlphaPlanes[uiCurPlane]->getHeight());
1197	}
1198
1199	Int iBlendWidth = m_iBlendHoleMargin;
1200	Int iMaxBlendLevel;
1201
1202	if (!m_bBlendUseDistWeight )
1203	{
1204	iMaxBlendLevel = ( 1 << REN_VDWEIGHT_PREC ) ;
1205
1206	if ( m_iBlendMode == 0)
1207	{
1208	iMaxBlendLevel >>= 1;
1209	}
1210	}
1211	else
1212	{
1213	if ( m_iBlendMode == 0)
1214	{
1215	iMaxBlendLevel = bRenderFromLeft ? (1 << REN_VDWEIGHT_PREC) - m_iBlendDistWeight : m_iBlendDistWeight;
1216	}
1217	else
1218	{
1219	iMaxBlendLevel = ( 1 << REN_VDWEIGHT_PREC );
1220	}
1221	}
1222
1223	Int iWeightStep = (iBlendWidth > 0) ? ( iMaxBlendLevel + (iBlendWidth >> 1) ) / iBlendWidth : 0;
1224
1225	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1226	{
1227	Int iFilledStride = apcFilledPlanes [uiCurPlane]->getStride();
1228	Int iAlphaStride = apcAlphaPlanes [uiCurPlane]->getStride();
1229
1230	Pel* pcFilledData = apcFilledPlanes [uiCurPlane]->getPlaneData();
1231	Pel* pcAlphaData = apcAlphaPlanes [uiCurPlane]->getPlaneData();
1232
1233	for(Int iYPos = 0; iYPos < iHeight; iYPos++)
1234	{
1235	for(Int iXPos = 0 ; iXPos < iWidth; iXPos++ )
1236	{
1237	if (pcFilledData[iXPos] == REN_IS_HOLE)
1238	{
1239	while( (pcFilledData[iXPos] == REN_IS_HOLE) && (iXPos < iWidth) )
1240	{
1241	pcAlphaData[iXPos] = REN_IS_HOLE;
1242	iXPos++;
1243	}
1244
1245	if ( iXPos >= iWidth )
1246	continue;
1247
1248	Int iWeight = 0;
1249	Int iLastFillPos = iXPos + iBlendWidth;
1250
1251	while( (pcFilledData[iXPos] != REN_IS_HOLE) && (iXPos < iWidth) && (iXPos < iLastFillPos) )
1252	{
1253	AOF( iWeight <= (1 << REN_VDWEIGHT_PREC) );
1254	pcAlphaData[iXPos] = (iWeight == 0) ? 1 : iWeight;
1255	iWeight += iWeightStep;
1256	iXPos++;
1257	}
1258	}
1259	else
1260	{
1261	pcAlphaData[iXPos] = REN_IS_FILLED;
1262	}
1263	}
1264	pcAlphaData += iAlphaStride;
1265	pcFilledData += iFilledStride;
1266	}
1267	}
1268	}
1269
1270	Void TRenTop::xRemBoundaryNoise(PelImage* pcInImage, PelImage* pcFilledImage, PelImage* pcOutImage, Bool bRenderFromLeft )
1271	{
1272	if (pcInImage != pcOutImage)
1273	{
1274	pcOutImage->assign(pcInImage);
1275	}
1276
1277	UInt uiNumFullPlanes = pcInImage->getNumberOfFullPlanes();
1278	UInt uiNumQuatPlanes = pcInImage->getNumberOfQuaterPlanes();
1279
1280	AOF( uiNumFullPlanes == pcOutImage->getNumberOfFullPlanes () );
1281	AOF( uiNumQuatPlanes == pcOutImage->getNumberOfQuaterPlanes() );
1282
1283	xRemBoundaryNoisePlane( pcInImage->getPlanes(), pcFilledImage->getPlane(0), pcOutImage->getPlanes(), uiNumFullPlanes, bRenderFromLeft );
1284
1285	if (uiNumQuatPlanes > 0)
1286	{
1287	AOF( pcFilledImage->getNumberOfPlanes() > 1);
1288	xRemBoundaryNoisePlane( pcInImage->getPlanes()+uiNumFullPlanes, pcFilledImage->getPlane(1), pcOutImage->getPlanes() + uiNumFullPlanes, uiNumQuatPlanes, bRenderFromLeft );
1289	}
1290	};
1291
1292	Void TRenTop::xRemBoundaryNoisePlane(PelImagePlane** apcInputPlanes, PelImagePlane* pcFilledPlane, PelImagePlane** apcOutputPlanes, UInt uiNumberOfPlanes, Bool bRenderFromLeft)
1293	{
1294	Int iWidth = apcOutputPlanes[0]->getWidth();
1295	Int iHeight = apcInputPlanes [0]->getHeight();
1296
1297	Int iInputStride = apcInputPlanes [0]->getStride();
1298	Int iOutputStride = apcOutputPlanes[0]->getStride();
1299
1300	Int iFilledStride = pcFilledPlane->getStride();
1301
1302	Pel** apcInputData = new Pel*[ uiNumberOfPlanes ];
1303	Pel** apcOutputData = new Pel*[ uiNumberOfPlanes ];
1304	Pel* pcFilledData = pcFilledPlane->getPlaneData();
1305
1306	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1307	{
1308	apcInputData [uiCurPlane] = apcInputPlanes [uiCurPlane]->getPlaneData();
1309	apcOutputData [uiCurPlane] = apcOutputPlanes[uiCurPlane]->getPlaneData();
1310	AOF( iWidth == apcInputPlanes [uiCurPlane]->getWidth() && iWidth == apcOutputPlanes[uiCurPlane]->getWidth() );
1311	AOF( iHeight == apcInputPlanes [uiCurPlane]->getHeight() && iHeight == apcOutputPlanes[uiCurPlane]->getHeight());
1312	AOF( iInputStride == apcInputPlanes [uiCurPlane]->getStride() && iOutputStride == apcOutputPlanes[uiCurPlane]->getStride());
1313	}
1314
1315	Int iRemovalWidth = m_iBlendHoleMargin;
1316	AOT(iRemovalWidth > 6); // GT: insufficent padding
1317
1318	for(Int iYPos = 0; iYPos < iHeight; iYPos++)
1319	{
1320	for(Int iXPos = iWidth-1; iXPos >= 0; iXPos-- )
1321	{
1322	if (pcFilledData[iXPos] == REN_IS_HOLE)
1323	{
1324	Int iSourcePos = iXPos + 1;
1325
1326	// Get New Value
1327	while( (pcFilledData[iSourcePos] != REN_IS_HOLE) && ( iSourcePos < iWidth) && ( iSourcePos < iXPos + iRemovalWidth ) ) iSourcePos++;
1328
1329	if (iSourcePos == iWidth \|\| pcFilledData[iSourcePos] != REN_IS_HOLE )
1330	iSourcePos--;
1331
1332	Int iXPosRem = iSourcePos - 1;
1333
1334	// Remove
1335	while( iXPosRem > iXPos)
1336	{
1337	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1338	{
1339	apcOutputData[uiCurPlane][iXPosRem] = apcInputData[uiCurPlane][iSourcePos];
1340	}
1341
1342	iXPosRem--;
1343	}
1344
1345	// Skip Hole
1346	while( (pcFilledData[iXPos] == REN_IS_HOLE) && ( iXPos > 0) ) iXPos--;
1347	}
1348	}
1349
1350	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1351	{
1352	apcOutputData[uiCurPlane] += iOutputStride;
1353	apcInputData [uiCurPlane] += iInputStride;
1354	}
1355	pcFilledData += iFilledStride;
1356	}
1357	delete[] apcInputData;
1358	delete[] apcOutputData;
1359	}
1360
1361	Void TRenTop::xFillPlaneHoles(PelImagePlane** apcInputPlanes, PelImagePlane* pcFilledPlane, PelImagePlane** apcOutputPlanes, UInt uiNumberOfPlanes, Bool bRenderFromLeft)
1362	{
1363	Int iWidth = apcOutputPlanes[0]->getWidth();
1364	Int iHeight = apcInputPlanes [0]->getHeight();
1365
1366	Int iInputStride = apcInputPlanes [0]->getStride();
1367	Int iOutputStride = apcOutputPlanes[0]->getStride();
1368
1369	Int iFilledStride = pcFilledPlane->getStride();
1370
1371	Pel** apcInputData = new Pel*[ uiNumberOfPlanes ];
1372	Pel** apcOutputData = new Pel*[ uiNumberOfPlanes ];
1373	Pel* pcFilledData = pcFilledPlane->getPlaneData();
1374
1375	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1376	{
1377	apcInputData [uiCurPlane] = apcInputPlanes [uiCurPlane]->getPlaneData();
1378	apcOutputData [uiCurPlane] = apcOutputPlanes[uiCurPlane]->getPlaneData();
1379	AOF( iWidth == apcInputPlanes [uiCurPlane]->getWidth() && iWidth == apcOutputPlanes[uiCurPlane]->getWidth() );
1380	AOF( iHeight == apcInputPlanes [uiCurPlane]->getHeight() && iHeight == apcOutputPlanes[uiCurPlane]->getHeight());
1381	AOF( iInputStride == apcInputPlanes [uiCurPlane]->getStride() && iOutputStride == apcOutputPlanes[uiCurPlane]->getStride());
1382	}
1383
1384	for(Int iYPos = 0; iYPos < iHeight; iYPos++)
1385	{
1386	if ( !m_bInstantHoleFilling )
1387	{
1388	for(Int iXPos = 0 ; iXPos < iWidth; iXPos++ )
1389	{
1390	if (pcFilledData[iXPos] == REN_IS_HOLE)
1391	{
1392	Int iSourcePos;
1393	Int iLastFillPos;
1394
1395	Int iXPosSearch = iXPos;
1396	while( (pcFilledData[iXPosSearch] == REN_IS_HOLE) && (iXPosSearch < iWidth) ) iXPosSearch++;
1397
1398	if ( iXPosSearch >= iWidth )
1399	{
1400	continue;
1401	}
1402	else
1403	{
1404	iSourcePos = iXPosSearch;
1405	iLastFillPos = iXPosSearch-1;
1406	}
1407
1408	while( iXPos <= iLastFillPos)
1409	{
1410	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1411	{
1412	apcOutputData[uiCurPlane][iXPos] = apcInputData[uiCurPlane][iSourcePos];
1413	}
1414	iXPos++;
1415	}
1416	}
1417	}
1418	}
1419
1420	// Fill Right Gap
1421	Int iXPosSearch = iWidth -1;
1422	while( (pcFilledData[iXPosSearch] == REN_IS_HOLE) && (iXPosSearch >= 0) ) iXPosSearch--;
1423	if ( iXPosSearch < 0) iXPosSearch++;
1424
1425	Int iSourcePos = iXPosSearch;
1426
1427	for( Int iXPos = iSourcePos + 1; iXPos < iWidth; iXPos++)
1428	{
1429	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1430	{
1431	apcOutputData[uiCurPlane][iXPos] = apcInputData[uiCurPlane][iSourcePos];
1432	}
1433	}
1434
1435	// Fill Left Gap
1436	iXPosSearch = 0;
1437	while( (pcFilledData[iXPosSearch] == REN_IS_HOLE) && (iXPosSearch < iWidth) ) iXPosSearch++;
1438	if ( iXPosSearch >= iWidth) iXPosSearch--;
1439
1440	iSourcePos = iXPosSearch;
1441
1442	for( Int iXPos = iSourcePos - 1; iXPos >= 0; iXPos--)
1443	{
1444	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1445	{
1446	apcOutputData[uiCurPlane][iXPos] = apcInputData[uiCurPlane][iSourcePos];
1447	}
1448	}
1449
1450	// Go to next line
1451	for( UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++)
1452	{
1453	apcOutputData[uiCurPlane] += iOutputStride;
1454	apcInputData [uiCurPlane] += iInputStride;
1455	}
1456	pcFilledData += iFilledStride;
1457	}
1458	delete[] apcInputData;
1459	delete[] apcOutputData;
1460	}
1461
1462	Void TRenTop::xPostProcessImage(PelImage* pcInImage, PelImage* pcOutImage)
1463	{
1464	if ( m_iPostProcMode == eRenPostProNone )
1465	return;
1466
1467	PelImage* pcTemp;
1468
1469	if (pcInImage == pcOutImage)
1470	{
1471	pcTemp = pcOutImage->create();
1472	}
1473	else
1474	{
1475	pcTemp = pcOutImage;
1476	}
1477
1478	pcTemp->assign(pcInImage);
1479
1480	switch ( m_iPostProcMode )
1481	{
1482	case eRenPostProMed:
1483	TRenFilter::lineMedian3(pcTemp);
1484	break;
1485	case eRenPostProNone:
1486	break;
1487	default:
1488	assert(0);
1489	}
1490
1491	if (pcInImage == pcOutImage)
1492	{
1493	pcOutImage->assign(pcTemp);
1494	delete pcTemp;
1495	};
1496	}
1497
1498	Void TRenTop::xChangePixels( PelImage* pcDispImage )
1499	{
1500	if (m_uNumelauiChangePixels < 3 )
1501	{
1502	return;
1503	};
1504
1505	UInt* puiCP = m_auiChangePixels;
1506	UInt uiWidth = pcDispImage->getPlane(0)->getWidth();
1507
1508	for (UInt uiIdx = 0; uiIdx < m_uNumelauiChangePixels; uiIdx+= 3 )
1509	{
1510	pcDispImage->getPlane(0)->getPlaneData()[ puiCP[ uiIdx ] * uiWidth + puiCP[ uiIdx + 1 ] ] = puiCP[uiIdx + 2 ];
1511	};
1512	};
1513
1514
1515	Void TRenTop::xCutPlaneMargin( PelImagePlane* pcImagePlane, Pel cFill, UInt uiScale )
1516	{
1517	UInt uiWidth = pcImagePlane->getWidth();
1518	UInt uiHeight = pcImagePlane->getHeight();
1519
1520	UInt uiStride = pcImagePlane->getStride();
1521	Pel* pcPlaneData = pcImagePlane->getPlaneData();
1522
1523	UInt uiCutLeft = m_auiCut[0] / uiScale;
1524	UInt uiCutRight = uiWidth - m_auiCut[1] / uiScale;
1525
1526	for(UInt uiYPos = 0; uiYPos < uiHeight; uiYPos++)
1527	{
1528	for(UInt uiXPos = 0; uiXPos < (UInt) uiWidth ; uiXPos++)
1529	{
1530	if ( ( uiXPos < uiCutLeft ) \|\| ( uiXPos >= uiCutRight ) )
1531	{
1532	pcPlaneData[uiXPos ] = cFill;
1533	}
1534	}
1535	pcPlaneData += uiStride;
1536	}
1537	};
1538
1539	Void TRenTop::xCutMargin( PelImage* pcInputImage )
1540	{
1541	if ( ( m_auiCut[0] == 0 ) && ( m_auiCut[1] == 0 ) )
1542	{
1543	return;
1544	};
1545
1546	UInt uiCurPlane = 0;
1547	for (; uiCurPlane < pcInputImage->getNumberOfFullPlanes(); uiCurPlane++ )
1548	{
1549	xCutPlaneMargin( pcInputImage->getPlane(uiCurPlane), (Pel) 0 , 1 );
1550	}
1551
1552	for (; uiCurPlane < pcInputImage->getNumberOfPlanes(); uiCurPlane++ )
1553	{
1554	xCutPlaneMargin( pcInputImage->getPlane(uiCurPlane), (Pel) 128 , 2 );
1555	}
1556
1557	};
1558
1559
1560	Void TRenTop::xEnhSimilarity( PelImage* pcLeftImage, PelImage* pcRightImage, PelImage* pcFilledLeft, PelImage* pcFilledRight )
1561	{
1562	if (m_iSimEnhBaseView == 0)
1563	return;
1564
1565	UInt uiNumFullPlanes = pcLeftImage->getNumberOfFullPlanes();
1566	UInt uiNumQuatPlanes = pcLeftImage->getNumberOfQuaterPlanes();
1567
1568	if (uiNumQuatPlanes > 0)
1569	{
1570	assert( pcFilledLeft ->getNumberOfPlanes() > 1);
1571	assert( pcFilledRight->getNumberOfPlanes() > 1);
1572	};
1573
1574	xEnhSimilarityPlane ( pcLeftImage->getPlanes() , pcRightImage->getPlanes() , pcFilledLeft->getPlane(0), pcFilledRight->getPlane(0), uiNumFullPlanes);
1575	if (uiNumQuatPlanes > 0)
1576	{
1577	xEnhSimilarityPlane ( pcLeftImage->getPlanes()+uiNumFullPlanes, pcRightImage->getPlanes()+uiNumFullPlanes, pcFilledLeft->getPlane(1), pcFilledRight->getPlane(1), uiNumQuatPlanes);
1578	}
1579	}
1580
1581	Void TRenTop::xEnhSimilarityPlane ( PelImagePlane apcLeftPlane, PelImagePlane apcRightPlane, PelImagePlane* pcFilledLeftPlane, PelImagePlane* pcFilledRightPlane, UInt uiNumberOfPlanes )
1582	{
1583	AOT( m_iSimEnhBaseView != 1 && m_iSimEnhBaseView != 2 );
1584	Int iWidth = (*apcRightPlane)->getWidth ();
1585	Int iHeight = (*apcRightPlane)->getHeight();
1586
1587	Int* aiHistLeft = new Int[ g_uiIBDI_MAX + 1 ];
1588	Int* aiHistRight = new Int[ g_uiIBDI_MAX + 1 ];
1589	Pel* aiConvLUT = new Pel[ g_uiIBDI_MAX + 1 ];
1590
1591	for (UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++ )
1592	{
1593	for (Int iCurVal = 0 ; iCurVal <= g_uiIBDI_MAX; iCurVal++)
1594	{
1595	aiHistLeft [iCurVal] = 0;
1596	aiHistRight[iCurVal] = 0;
1597	}
1598
1599	Pel* pcFilledRightData = pcFilledRightPlane ->getPlaneData();
1600	Pel* pcRightImageData = (*apcRightPlane ) ->getPlaneData();
1601
1602	Pel* pcFilledLeftData = pcFilledLeftPlane ->getPlaneData();
1603	Pel* pcLeftImageData = (*apcLeftPlane) ->getPlaneData();
1604
1605	//Int iSumLeft = 0;
1606	//Int iSumRight = 0;
1607	//Int iSumLeftSquare = 0;
1608	//Int iSumRightSquare = 0;
1609
1610	for (UInt uiYPos = 0; uiYPos < iHeight; uiYPos++ )
1611	{
1612	//Int iRowSumLeft = 0;
1613	//Int iRowSumRight = 0;
1614	//Int iRowSumLeftSquare = 0;
1615	//Int iRowSumRightSquare = 0;
1616
1617	for (UInt uiXPos = 0; uiXPos < iWidth; uiXPos++ )
1618	{
1619	if ( pcFilledLeftData[uiXPos] == REN_IS_FILLED && pcFilledRightData[uiXPos] == REN_IS_FILLED )
1620	{
1621	aiHistLeft [pcLeftImageData [uiXPos] ]++;
1622	aiHistRight[pcRightImageData [uiXPos] ]++;
1623	//iNumElem++;
1624	//iRowSumLeft += ;
1625	//iRowSumRight += pcRightImageData [uiXPos];
1626	//iRowSumLeftSquare += pcLeftImageData [uiXPos] * pcLeftImageData [uiXPos];
1627	//iRowSumRightSquare += pcRightImageData [uiXPos] * pcRightImageData[uiXPos];
1628	}
1629	}
1630
1631
1632	pcFilledRightData += pcFilledRightPlane ->getStride();
1633	pcRightImageData += (*apcRightPlane) ->getStride();
1634
1635	pcFilledLeftData += pcFilledLeftPlane ->getStride();
1636	pcLeftImageData += (*apcLeftPlane) ->getStride();
1637	}
1638
1639	Int iCumSumChange = 0;
1640	Int iCumSumBase = 0;
1641	Int iCurBaseVal = 0;
1642	Int iCurChangeVal = 0;
1643
1644	Int* aiHistChange = (m_iSimEnhBaseView == 2 ) ? aiHistLeft : aiHistRight;
1645	Int* aiHistBase = (m_iSimEnhBaseView == 2 ) ? aiHistRight : aiHistLeft ;
1646
1647	iCumSumChange += aiHistChange[iCurChangeVal];
1648	iCumSumBase += aiHistBase [iCurBaseVal] ;
1649
1650	Int iCheckSumLeft = 0;
1651	Int iCheckSumRight = 0;
1652
1653	for (Int iCurVal = 0 ; iCurVal <= g_uiIBDI_MAX; iCurVal++)
1654	{
1655	iCheckSumLeft += aiHistLeft [iCurVal];
1656	iCheckSumRight += aiHistRight[iCurVal];
1657	}
1658
1659
1660	while( iCurChangeVal <= g_uiIBDI_MAX )
1661	{
1662	#if 0 //GERHARD_DEBUG
1663	std::cout << iCumSumBase << " " << iCumSumChange << " " << iCurBaseVal << " " << iCurChangeVal << std::endl;
1664	#endif
1665	if ( iCumSumBase == iCumSumChange )
1666	{
1667	aiConvLUT[iCurChangeVal] = Min(iCurBaseVal, g_uiIBDI_MAX);
1668	iCurBaseVal ++;
1669	iCurChangeVal++;
1670	iCumSumChange += aiHistChange[iCurChangeVal];
1671	if (iCurBaseVal <= g_uiIBDI_MAX )
1672	{
1673	iCumSumBase += aiHistBase [iCurBaseVal] ;
1674	}
1675	}
1676	else if ( iCumSumBase < iCumSumChange )
1677	{
1678	iCurBaseVal++;
1679	if (iCurBaseVal <= g_uiIBDI_MAX )
1680	{
1681	iCumSumBase += aiHistBase [iCurBaseVal] ;
1682	}
1683	}
1684	else if ( iCumSumBase > iCumSumChange)
1685	{
1686	aiConvLUT[iCurChangeVal] = Min(iCurBaseVal, g_uiIBDI_MAX);
1687	iCurChangeVal++;
1688	iCumSumChange += aiHistChange [iCurChangeVal] ;
1689	}
1690	}
1691
1692	Pel* pcChangeImageData = ( ( m_iSimEnhBaseView == 2 ) ? (apcLeftPlane) : (apcRightPlane) )->getPlaneData();
1693	Int iChangeImageStride = ( ( m_iSimEnhBaseView == 2 ) ? (apcLeftPlane) : (apcRightPlane) )->getStride ();
1694
1695	for (UInt uiYPos = 0; uiYPos < iHeight; uiYPos++ )
1696	{
1697	for (UInt uiXPos = 0; uiXPos < iWidth; uiXPos++ )
1698	{
1699	pcChangeImageData [uiXPos] = aiConvLUT[ pcChangeImageData[uiXPos]];
1700	}
1701	pcChangeImageData += iChangeImageStride;
1702	}
1703
1704	apcRightPlane ++;
1705	apcLeftPlane ++;
1706
1707	}
1708
1709	delete[] aiHistLeft ;
1710	delete[] aiHistRight;
1711	delete[] aiConvLUT ;
1712
1713
1714	}
1715
1716
1717	Void TRenTop::xBlend( PelImage* pcLeftImage, PelImage* pcRightImage, PelImage* pcFilledLeft, PelImage* pcFilledRight, PelImage* pcLeftDepth, PelImage* pcRightDepth, PelImage* pcOutputImage )
1718	{
1719	UInt uiNumFullPlanes = pcLeftImage->getNumberOfFullPlanes();
1720	UInt uiNumQuatPlanes = pcLeftImage->getNumberOfQuaterPlanes();
1721
1722	assert( uiNumFullPlanes == pcRightImage->getNumberOfFullPlanes () && uiNumFullPlanes == pcOutputImage->getNumberOfFullPlanes ());
1723	assert( uiNumQuatPlanes == pcRightImage->getNumberOfQuaterPlanes() && uiNumQuatPlanes == pcOutputImage->getNumberOfQuaterPlanes ());
1724
1725	if (uiNumQuatPlanes > 0)
1726	{
1727	assert( pcLeftDepth ->getNumberOfPlanes() > 1 \|\| pcFilledLeft ->getNumberOfPlanes() > 1);
1728	assert( pcRightDepth->getNumberOfPlanes() > 1 \|\| pcFilledRight->getNumberOfPlanes() > 1);
1729	};
1730
1731	switch (m_iBlendMode)
1732	{
1733	case eRenBlendAverg:
1734	case eRenBlendDepthFirst:
1735	xBlendPlanesAvg( pcLeftImage->getPlanes() , pcRightImage->getPlanes() , pcFilledLeft->getPlane(0), pcFilledRight->getPlane(0), pcLeftDepth->getPlane(0), pcRightDepth->getPlane(0), pcOutputImage->getPlanes(), uiNumFullPlanes);
1736	if (uiNumQuatPlanes > 0)
1737	{
1738	xBlendPlanesAvg( pcLeftImage->getPlanes()+uiNumFullPlanes, pcRightImage->getPlanes()+uiNumFullPlanes, pcFilledLeft->getPlane(1), pcFilledRight->getPlane(1), pcLeftDepth->getPlane(1), pcRightDepth->getPlane(1), pcOutputImage->getPlanes()+uiNumFullPlanes, uiNumQuatPlanes);
1739	}
1740	break;
1741	case eRenBlendLeft:
1742	case eRenBlendRight:
1743	xBlendPlanesOneView( pcLeftImage->getPlanes() , pcRightImage->getPlanes() , pcFilledLeft->getPlane(0), pcFilledRight->getPlane(0), pcLeftDepth->getPlane(0), pcRightDepth->getPlane(0), pcOutputImage->getPlanes(), uiNumFullPlanes);
1744	if (uiNumQuatPlanes > 0)
1745	{
1746	xBlendPlanesOneView( pcLeftImage->getPlanes()+uiNumFullPlanes, pcRightImage->getPlanes()+uiNumFullPlanes, pcFilledLeft->getPlane(1), pcFilledRight->getPlane(1), pcLeftDepth->getPlane(1), pcRightDepth->getPlane(1), pcOutputImage->getPlanes()+uiNumFullPlanes, uiNumQuatPlanes);
1747	}
1748	break;
1749	}
1750	}
1751
1752	Void TRenTop::xBlendPlanesOneView( PelImagePlane apcLeftPlane, PelImagePlane apcRightPlane, PelImagePlane* pcFilledLeftPlane, PelImagePlane* pcFilledRightPlane, PelImagePlane* pcLeftDepthPlane, PelImagePlane* pcRightDepthPlane, PelImagePlane** apcOutputImagePlane, UInt uiNumberOfPlanes )
1753	{
1754	for (UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++ )
1755	{
1756	Pel* pcFilledRightData = pcFilledRightPlane ->getPlaneData();
1757	Pel* pcRightImageData = (*apcRightPlane ) ->getPlaneData();
1758	Pel* pcRightDepthData = pcRightDepthPlane ->getPlaneData();
1759
1760	Pel* pcFilledLeftData = pcFilledLeftPlane ->getPlaneData();
1761	Pel* pcLeftImageData = (*apcLeftPlane) ->getPlaneData();
1762	Pel* pcLeftDepthData = pcLeftDepthPlane ->getPlaneData();
1763	Pel* pcOutputData = (*apcOutputImagePlane)->getPlaneData();
1764
1765	for (UInt uiYPos = 0; uiYPos < (*apcOutputImagePlane)->getHeight(); uiYPos++ )
1766	{
1767	for (UInt uiXPos = 0; uiXPos < (*apcOutputImagePlane)->getWidth(); uiXPos++ )
1768	{
1769	if (m_iBlendMode == eRenBlendLeft )
1770	{
1771	if ( pcFilledLeftData[uiXPos] == REN_IS_FILLED \|\| pcFilledRightData[uiXPos] == REN_IS_HOLE )
1772	{
1773	pcOutputData[uiXPos] = pcLeftImageData[uiXPos];
1774	}
1775	else if ( pcFilledLeftData[uiXPos] == REN_IS_HOLE )
1776	{
1777	pcOutputData[uiXPos] = pcRightImageData[uiXPos];
1778	}
1779	else
1780	{
1781	pcOutputData[uiXPos] = pcRightImageData[uiXPos] + (Pel) ( ( (Int) ( pcLeftImageData[uiXPos] - pcRightImageData[uiXPos] ) * pcFilledLeftData[uiXPos] + (1 << (REN_VDWEIGHT_PREC - 1)) ) >> REN_VDWEIGHT_PREC );
1782	}
1783	}
1784	else if ( m_iBlendMode == eRenBlendRight )
1785	{
1786	if ( pcFilledRightData[uiXPos] == REN_IS_FILLED \|\| pcFilledLeftData[uiXPos] == REN_IS_HOLE )
1787	{
1788	pcOutputData[uiXPos] = pcRightImageData[uiXPos];
1789	}
1790	else if ( pcFilledRightData[uiXPos] == REN_IS_HOLE )
1791	{
1792	pcOutputData[uiXPos] = pcLeftImageData[uiXPos];
1793	}
1794	else
1795	{
1796	pcOutputData[uiXPos] = pcLeftImageData[uiXPos] + (Pel) ( ( (Int) ( pcRightImageData[uiXPos] - pcLeftImageData[uiXPos] ) * pcFilledRightData[uiXPos] + (1 << (REN_VDWEIGHT_PREC - 1)) ) >> REN_VDWEIGHT_PREC );
1797	}
1798	}
1799	else
1800	{
1801	AOT(true);
1802	}
1803	}
1804
1805	pcFilledRightData += pcFilledRightPlane ->getStride();
1806	pcRightImageData += (*apcRightPlane) ->getStride();
1807	pcRightDepthData += pcRightDepthPlane ->getStride();
1808
1809	pcFilledLeftData += pcFilledLeftPlane ->getStride();
1810	pcLeftImageData += (*apcLeftPlane) ->getStride();
1811	pcLeftDepthData += pcLeftDepthPlane ->getStride();
1812	pcOutputData += (*apcOutputImagePlane)->getStride();
1813	}
1814
1815	apcRightPlane ++;
1816	apcLeftPlane ++;
1817	apcOutputImagePlane++;
1818	}
1819	}
1820
1821	Void TRenTop::xBlendPlanesAvg( PelImagePlane apcLeftPlane, PelImagePlane apcRightPlane, PelImagePlane* pcFilledLeftPlane, PelImagePlane* pcFilledRightPlane, PelImagePlane* pcLeftDepthPlane, PelImagePlane* pcRightDepthPlane, PelImagePlane** apcOutputImagePlane, UInt uiNumberOfPlanes )
1822	{
1823	for (UInt uiCurPlane = 0; uiCurPlane < uiNumberOfPlanes; uiCurPlane++ )
1824	{
1825	Pel* pcFilledRightData = pcFilledRightPlane ->getPlaneData();
1826	Pel* pcRightVideoData = (*apcRightPlane ) ->getPlaneData();
1827	Pel* pcRightDepthData = pcRightDepthPlane ->getPlaneData();
1828
1829	Pel* pcFilledLeftData = pcFilledLeftPlane ->getPlaneData();
1830	Pel* pcLeftVideoData = (*apcLeftPlane) ->getPlaneData();
1831	Pel* pcLeftDepthData = pcLeftDepthPlane ->getPlaneData();
1832
1833	Pel* pcOutputData = (*apcOutputImagePlane)->getPlaneData();
1834
1835	for (UInt uiYPos = 0; uiYPos < (*apcOutputImagePlane)->getHeight(); uiYPos++ )
1836	{
1837	for (UInt uiXPos = 0; uiXPos < (*apcOutputImagePlane)->getWidth(); uiXPos++ )
1838	{
1839	if ( (pcFilledRightData[uiXPos] != REN_IS_HOLE ) && ( pcFilledLeftData[uiXPos] != REN_IS_HOLE) )
1840	{
1841	Int iDepthDifference = m_piInvZLUTLeft[RemoveBitIncrement(pcLeftDepthData[uiXPos])] - m_piInvZLUTRight[RemoveBitIncrement(pcRightDepthData[uiXPos])];
1842
1843	if ( abs ( iDepthDifference ) <= m_iBlendZThres )
1844	{
1845	if ((pcFilledRightData[uiXPos] == REN_IS_FILLED) && ( pcFilledLeftData[uiXPos] != REN_IS_FILLED))
1846	{
1847	pcOutputData[uiXPos] = pcRightVideoData[uiXPos] + (Pel) ( ( (Int) ( pcLeftVideoData[uiXPos] - pcRightVideoData[uiXPos] ) * (pcFilledLeftData[uiXPos]) + (1 << (REN_VDWEIGHT_PREC - 1)) ) >> REN_VDWEIGHT_PREC );
1848	}
1849	else if ((pcFilledRightData[uiXPos] != REN_IS_FILLED) && ( pcFilledLeftData[uiXPos] == REN_IS_FILLED))
1850	{
1851	pcOutputData[uiXPos] = pcLeftVideoData[uiXPos] + (Pel) ( ( (Int) ( pcRightVideoData[uiXPos] - pcLeftVideoData[uiXPos] ) * (pcFilledRightData[uiXPos]) + (1 << (REN_VDWEIGHT_PREC - 1)) ) >> REN_VDWEIGHT_PREC );
1852	}
1853	else
1854	{
1855	pcOutputData[uiXPos] = pcLeftVideoData[uiXPos] + (Pel) ( ( (Int) ( pcRightVideoData[uiXPos] - pcLeftVideoData[uiXPos] ) * m_iBlendDistWeight + (1 << (REN_VDWEIGHT_PREC - 1)) ) >> REN_VDWEIGHT_PREC );
1856	}
1857
1858	}
1859	else if ( iDepthDifference < 0 )
1860	{
1861	pcOutputData[uiXPos] = pcRightVideoData[uiXPos];
1862	}
1863	else
1864	{
1865	pcOutputData[uiXPos] = pcLeftVideoData[uiXPos];
1866	}
1867	}
1868	else if ( (pcFilledRightData[uiXPos] == REN_IS_HOLE) && (pcFilledLeftData[uiXPos] == REN_IS_HOLE))
1869	{
1870	pcOutputData[uiXPos] = m_piInvZLUTLeft[RemoveBitIncrement( pcLeftDepthData[uiXPos])] < m_piInvZLUTRight[RemoveBitIncrement(pcRightDepthData[uiXPos])] ? pcLeftVideoData[uiXPos] : pcRightVideoData[uiXPos];
1871	}
1872	else
1873	{
1874	pcOutputData[uiXPos] = (pcFilledLeftData[uiXPos] == REN_IS_HOLE) ? pcRightVideoData[uiXPos] : pcLeftVideoData[uiXPos];
1875	}
1876	}
1877
1878	pcFilledRightData += pcFilledRightPlane ->getStride();
1879	pcRightVideoData += (*apcRightPlane) ->getStride();
1880	pcRightDepthData += pcRightDepthPlane ->getStride();
1881
1882	pcFilledLeftData += pcFilledLeftPlane ->getStride();
1883	pcLeftVideoData += (*apcLeftPlane) ->getStride();
1884	pcLeftDepthData += pcLeftDepthPlane ->getStride();
1885	pcOutputData += (*apcOutputImagePlane)->getStride();
1886	};
1887
1888	apcRightPlane ++;
1889	apcLeftPlane ++;
1890	apcOutputImagePlane++;
1891	}
1892	}
1893
1894
1895	Void TRenTop::xReEstimateDisp( Pel* pcInputLeftImageRow, Pel* pcInputRightImageRow, Int iLeftImageStride, Int iRightImageStride, Int iPosX, Pel cLeftDepth, Pel cRightDepth, Int iLut, Pel& rcBestDepth, Int& riBestSAD )
1896	{
1897	Int iHalfBlkSizeMin1 = 3;
1898	UInt uiStep = m_iRelShiftLUTPrec;
1899
1900	AOT(iHalfBlkSizeMin1 > 3);
1901
1902	Pel cInc = (cRightDepth < cLeftDepth) ? 1 : -1;
1903
1904	UInt uiBestSAD = -1;
1905
1906	for (Pel cCurDepth = cRightDepth; cCurDepth <= cLeftDepth; cCurDepth += cInc )
1907	{
1908	Int iShiftLeft = m_ppiShiftLUTLeft [iLut][ RemoveBitIncrement( cCurDepth)];
1909	Int iShiftRight = m_ppiShiftLUTLeft [iLut][ RemoveBitIncrement( cCurDepth)];
1910
1911	Int iShiftedPosLeft = iPosX - iShiftLeft;
1912	Int iShiftedPosRight = iPosX - iShiftRight;
1913
1914	if ( !(( iShiftedPosLeft < 0 ) \|\| (iShiftedPosLeft >= m_uiSampledWidth) \|\| ( iShiftedPosRight < 0 ) \|\| (iShiftedPosRight >= m_uiSampledWidth)))
1915	{
1916	Pel* pcCurLeftIm = pcInputLeftImageRow - iLeftImageStride * iHalfBlkSizeMin1 - iHalfBlkSizeMin1*uiStep - iShiftLeft;
1917	Pel* pcCurRightIm = pcInputRightImageRow - iRightImageStride * iHalfBlkSizeMin1 - iHalfBlkSizeMin1*uiStep - iShiftRight;
1918
1919	UInt uiSAD = 0;
1920
1921	for ( Int iCurPosY= 0; iCurPosY < (iHalfBlkSizeMin1 << 1) + 1; iCurPosY++ )
1922	{
1923	for ( Int iCurPosX = 0; iCurPosX < (iHalfBlkSizeMin1 << 1) * uiStep + uiStep; iCurPosX += uiStep )
1924	{
1925	uiSAD += abs( pcCurLeftIm[iCurPosX] - pcCurRightIm[iCurPosX] );
1926	}
1927	pcCurLeftIm += iLeftImageStride;
1928	pcCurRightIm += iRightImageStride;
1929	}
1930
1931	if (uiSAD < uiBestSAD)
1932	{
1933	uiBestSAD = uiSAD;
1934	rcBestDepth = cCurDepth;
1935	}
1936	}
1937	}
1938	}
1939
1940	Int TRenTop::xVSRSHoleCount( Pel* pcFilledData, Int iFilledStride, Int iCenterPosX, Int iCenterPosY )
1941	{
1942	// Counts holes in a 6x6 Block around iPosX and iPosY
1943	//GT: currently not supported for rendering in up sampled domain ( padding to less )
1944	if ( m_iLog2SamplingFactor > 0 )
1945	{
1946	return 0;
1947	}
1948
1949	Int iHalfBlkSizeY = 3;
1950	Int iHalfBlkSizeX = 3; // iHalfBlkSizeY * ( 1 << m_iLog2SamplingFactor );
1951
1952	Int iNumOfHolePels = 0;
1953	pcFilledData -= ( iHalfBlkSizeX + iHalfBlkSizeY * iFilledStride );
1954
1955	for (Int iPosY = 0; iPosY < (iHalfBlkSizeY << 1) + 1; iPosY++)
1956	{
1957	for (Int iPosX = 0; iPosX < (iHalfBlkSizeX << 1) + 1; iPosX++)
1958	{
1959	if (*pcFilledData == REN_IS_HOLE)
1960	{
1961	iNumOfHolePels++;
1962	}
1963	pcFilledData++;
1964	}
1965	pcFilledData += iFilledStride;
1966	}
1967	return iNumOfHolePels;
1968	}
1969
1970	// Temporal Filter from Zhejiang University: (a little different from m16041: Temporal Improvement Method in View Synthesis)
1971	Void TRenTop::temporalFilterVSRS( TComPicYuv* pcPicYuvVideoCur, TComPicYuv* pcPicYuvDepthCur, TComPicYuv* pcPicYuvVideoLast, TComPicYuv* pcPicYuvDepthLast, Bool bFirstFrame )
1972	{
1973	Int iSADThres = 100 ; //threshold of sad in 4*4 block motion detection
1974
1975	Int iWidth = m_auiInputResolution[0];
1976	Int iHeight = m_auiInputResolution[1];
1977
1978	//internal variables
1979	Int* piFlagMoving = m_aiBlkMoving + 2;
1980
1981	Int iVideoCurStride = pcPicYuvVideoCur ->getStride();
1982	Int iVideoLastStride = pcPicYuvVideoLast->getStride();
1983	Int iDepthCurStride = pcPicYuvDepthCur ->getStride();
1984	Int iDepthLastStride = pcPicYuvDepthLast->getStride();
1985
1986	Pel* pcVideoCurData = pcPicYuvVideoCur ->getLumaAddr();
1987	Pel* pcVideoLastData = pcPicYuvVideoLast->getLumaAddr();
1988	Pel* pcDepthCurData = pcPicYuvDepthCur ->getLumaAddr();
1989	Pel* pcDepthLastData = pcPicYuvDepthLast->getLumaAddr();
1990
1991	Pel* pcVideoCurDataFrm = pcVideoCurData ;
1992	Pel* pcVideoLastDataFrm = pcVideoLastData;
1993	Pel* pcDepthCurDataFrm = pcDepthCurData ;
1994	Pel* pcDepthLastDataFrm = pcDepthLastData;
1995
1996
1997	if( !bFirstFrame ) // first frame need not the weighting, but need to prepare the data
1998	{
1999	for ( Int iPosY = 0; iPosY < (iHeight >> 2); iPosY++)
2000	{
2001	//motion detection by SAD
2002	for ( Int iPosX = 0; iPosX < (iWidth >> 2); iPosX++)
2003	{
2004	Int iSAD = 0;
2005
2006	Pel* pcVideoCurDataBlk = pcVideoCurDataFrm + (iPosX << 2);
2007	Pel* pcVideoLastDataBlk = pcVideoLastDataFrm + (iPosX << 2);
2008
2009	//GT: Check difference of block compared to last frame
2010	for( Int iCurPosY = 0; iCurPosY < 4; iCurPosY++)
2011	{
2012	for( Int iCurPosX = 0; iCurPosX < 4; iCurPosX++)
2013	{
2014	iSAD += abs( pcVideoLastDataBlk[iCurPosX] - pcVideoCurDataBlk[iCurPosX] ); //SAD
2015	}
2016	pcVideoLastDataBlk += iVideoLastStride;
2017	pcVideoCurDataBlk += iVideoCurStride;
2018	}
2019
2020	piFlagMoving[iPosX] = ( iSAD < iSADThres ) ? 0 : 1;
2021	}
2022
2023	//temporal weighting according to motion detection result -- do a line
2024	for ( Int iPosX = 0; iPosX < (iWidth >> 2); iPosX++)
2025	{
2026	//5 block
2027	Int iSumMoving = piFlagMoving[iPosX-2] + piFlagMoving[iPosX-1] + piFlagMoving[iPosX] + piFlagMoving[iPosX+1] + piFlagMoving[iPosX+2];
2028
2029	if( iSumMoving == 0 ) // if not moving
2030	{
2031	Pel* pcDepthCurDataBlk = pcDepthCurDataFrm + (iPosX << 2);
2032	Pel* pcDepthLastDataBlk = pcDepthLastDataFrm + (iPosX << 2);
2033
2034	for( Int iCurPosY = 0; iCurPosY < 4; iCurPosY++)
2035	{
2036	for( Int iCurPosX = 0; iCurPosX < 4; iCurPosX++)
2037	{ //Weight: 0.75
2038	Int iFilt = (( (pcDepthLastDataBlk[iCurPosX] << 1 ) + pcDepthLastDataBlk[iCurPosX] + pcDepthCurDataBlk[iCurPosX] + 2 ) >> 2 );
2039	assert( (iFilt >= 0) && (iFilt <= g_uiIBDI_MAX) );
2040	pcDepthCurDataBlk[iCurPosX] = pcDepthLastDataBlk[iCurPosX];
2041	pcDepthCurDataBlk[iCurPosX] = iFilt;
2042	}
2043
2044	pcDepthCurDataBlk += iDepthCurStride;
2045	pcDepthLastDataBlk += iDepthLastStride;
2046	}
2047	}
2048	}
2049
2050	pcDepthCurDataFrm += ( iDepthCurStride << 2);
2051	pcDepthLastDataFrm += ( iDepthLastStride << 2);
2052	pcVideoCurDataFrm += ( iVideoCurStride << 2);
2053	pcVideoLastDataFrm += ( iVideoLastStride << 2);
2054	}
2055	}
2056	pcPicYuvVideoCur->copyToPic( pcPicYuvVideoLast );
2057	pcPicYuvDepthCur->copyToPic( pcPicYuvDepthLast );
2058	}
2059
2060	TRenTop::TRenTop()
2061	{
2062	m_auiInputResolution[0] = 0;
2063	m_auiInputResolution[1] = 0;
2064
2065	// Sub Pel Rendering
2066	m_iLog2SamplingFactor = 0;
2067
2068	// ColorPlaneHandling
2069	m_bUVUp = true;
2070
2071
2072	//PreProcessing
2073	m_iPreProcMode = eRenPreProNone;
2074	m_iPreFilterSize = 2;
2075
2076	// Interpolation
2077	m_iInterpolationMode = eRenIntFullPel;
2078
2079	// Sim Enhancement
2080	m_iSimEnhBaseView = 0;
2081
2082	// Blending
2083	m_iBlendMode = eRenBlendAverg;
2084	m_iBlendZThresPerc = -1;
2085	m_bBlendUseDistWeight = false;
2086	m_iBlendHoleMargin = -1;
2087
2088	m_iBlendZThres = -1;
2089	m_iBlendDistWeight = -1;
2090
2091	// Hole Filling
2092	m_iHoleFillingMode = eRenHFLWBackExt;
2093	m_bInstantHoleFilling = false;
2094
2095	// PostProcessing
2096	m_iPostProcMode = eRenPostProNone;
2097
2098	//ChangePixels
2099	m_auiChangePixels[0] = 0;
2100	m_uNumelauiChangePixels = 0;
2101
2102	// Cut
2103	m_auiCut[0] = 0;
2104	m_auiCut[1] = 0;
2105
2106	// Data
2107	m_uiSampledWidth = -1;
2108
2109	// LUTs
2110	m_ppdShiftLUTLeft = 0;
2111	m_ppdShiftLUTRight = 0;
2112
2113	m_ppdShiftLUTRightMirror = new Double*[2];
2114	m_ppdShiftLUTRightMirror[0] = new Double [257];
2115	m_ppdShiftLUTRightMirror[1] = new Double [257];
2116
2117	m_adShiftLUTCur = 0;
2118
2119	m_ppiShiftLUTLeft = 0;
2120	m_ppiShiftLUTRight = 0;
2121	m_ppiShiftLUTRightMirror = new Int*[2];
2122	m_ppiShiftLUTRightMirror[0] = new Int[257];
2123	m_ppiShiftLUTRightMirror[1] = new Int[257];
2124
2125	m_aiShiftLUTCur = 0;
2126	m_piInvZLUTLeft = new Int[257];
2127	m_piInvZLUTRight = new Int[257];
2128
2129	// Buffers
2130	m_pcLeftInputImage = 0;
2131	m_pcLeftInputDepth = 0;
2132	m_pcLeftOutputImage = 0;
2133	m_pcLeftOutputDepth = 0;
2134	m_pcLeftFilled = 0;
2135
2136	m_pcRightInputImage = 0;
2137	m_pcRightInputDepth = 0;
2138	m_pcRightOutputImage = 0;
2139	m_pcRightOutputDepth = 0;
2140	m_pcRightFilled = 0;
2141
2142	m_pcOutputImage = 0;
2143	m_pcOutputDepth = 0;
2144
2145	//Extrapolation
2146	m_pcInputImage = 0;
2147	m_pcInputDepth = 0;
2148	m_pcFilled = 0;
2149
2150	// SubPel
2151	m_aaiSubPelShift = 0;
2152
2153	// Temp
2154	m_pcTempImage = 0;
2155
2156	//Temporal Filter
2157	m_aiBlkMoving = 0;
2158	}
2159
2160
2161	Void TRenTop::init(UInt uiImageWidth,
2162	UInt uiImageHeight,
2163	Bool bExtrapolate,
2164	UInt uiLog2SamplingFactor,
2165	Int iShiftLUTPrec,
2166	Bool bUVUp,
2167	Int iPreProcMode,
2168	Int iPreFilterKernelSize,
2169	Int iBlendMode,
2170	Int iBlendZThresPerc,
2171	Bool bBlendUseDistWeight,
2172	Int iBlendHoleMargin,
2173	Int iInterpolationMode,
2174	Int iHoleFillingMode,
2175	Int iPostProcMode,
2176	Int iUsedPelMapMarExt
2177	)
2178
2179	{
2180	// Shift LUT Prec
2181	m_iRelShiftLUTPrec = iShiftLUTPrec - (Int) uiLog2SamplingFactor;
2182
2183	// Sub Pel Rendering
2184	m_iLog2SamplingFactor = uiLog2SamplingFactor;
2185
2186	// Extrapolation ?
2187	m_bExtrapolate = bExtrapolate;
2188
2189	// ColorPlaneHandling
2190	m_bUVUp = bUVUp;
2191
2192	//PreProcessing
2193	m_iPreProcMode = iPreProcMode;
2194	m_iPreFilterSize = iPreFilterKernelSize;
2195
2196	// Interpolation
2197	m_iInterpolationMode = iInterpolationMode;
2198
2199	//Blending
2200	m_iBlendMode = iBlendMode;
2201	m_iBlendZThresPerc = iBlendZThresPerc;
2202	m_bBlendUseDistWeight = bBlendUseDistWeight;
2203	m_iBlendHoleMargin = iBlendHoleMargin;
2204
2205	// Hole Filling
2206	m_iHoleFillingMode = iHoleFillingMode;
2207
2208	m_bInstantHoleFilling = (m_iInterpolationMode == eRenInt8Tap ) && (m_iHoleFillingMode != 0 );
2209
2210	// PostProcessing
2211	m_iPostProcMode = iPostProcMode;
2212
2213	//ChangePixels
2214	m_auiChangePixels[0] = 0;
2215	m_uNumelauiChangePixels = 0;
2216
2217	// Used pel map
2218	m_iUsedPelMapMarExt = iUsedPelMapMarExt;
2219
2220	// Cut
2221	m_auiCut[0] = 0;
2222	m_auiCut[1] = 0;
2223
2224	m_auiInputResolution[0] = uiImageWidth;
2225	m_auiInputResolution[1] = uiImageHeight;
2226
2227	if ( m_bExtrapolate )
2228	{
2229	PelImage* pcDump = 0;
2230	xGetDataPointers( m_pcInputImage, m_pcOutputImage, m_pcInputDepth, pcDump, m_pcFilled, false );
2231	}
2232	else
2233	{
2234	xGetDataPointers(m_pcLeftInputImage, m_pcLeftOutputImage, m_pcLeftInputDepth, m_pcLeftOutputDepth, m_pcLeftFilled, true);
2235	xGetDataPointers(m_pcRightInputImage, m_pcRightOutputImage, m_pcRightInputDepth, m_pcRightOutputDepth, m_pcRightFilled, true);
2236	xGetDataPointerOutputImage(m_pcOutputImage, m_pcOutputDepth );
2237	}
2238
2239	m_pcTempImage = new PelImage( m_auiInputResolution[0],m_auiInputResolution[1],1,2);
2240
2241	// SubPelShiftLUT
2242	if (iInterpolationMode == eRenInt8Tap)
2243	{
2244	// SubPel Shift LUT
2245	Int iNumEntries = (1 << ( m_iRelShiftLUTPrec + 1) ) + 1 ;
2246	m_aaiSubPelShift = new Int*[ iNumEntries ];
2247	for (UInt uiEntry = 0; uiEntry < iNumEntries; uiEntry++)
2248	{
2249	m_aaiSubPelShift[uiEntry] = new Int[ iNumEntries ];
2250	}
2251
2252	TRenFilter::setSubPelShiftLUT(m_iRelShiftLUTPrec, m_aaiSubPelShift, -1);
2253	}
2254
2255	// Zheijang temporal filter
2256	m_aiBlkMoving = new Int[ ( m_auiInputResolution[0] >> 2 ) + 4 ];
2257	m_aiBlkMoving[0] = 0;
2258	m_aiBlkMoving[1] = 0;
2259	m_aiBlkMoving[ ( m_auiInputResolution[0] >> 2 ) + 2 ] = 0;
2260	m_aiBlkMoving[ ( m_auiInputResolution[0] >> 2 ) + 3 ] = 0;
2261	}
2262
2263
2264	Void TRenTop::xGetChangePixels( UInt& ruiNumPixels, UInt* & rauiChangePixels )
2265	{
2266	ruiNumPixels = m_uNumelauiChangePixels;
2267	rauiChangePixels = m_auiChangePixels;
2268	}
2269
2270	TRenTop::~TRenTop()
2271	{
2272	if ( m_ppdShiftLUTRightMirror != NULL )
2273	{
2274	delete[] m_ppdShiftLUTRightMirror[0];
2275	delete[] m_ppdShiftLUTRightMirror[1];
2276	delete[] m_ppdShiftLUTRightMirror;
2277	};
2278
2279	if ( m_ppiShiftLUTRightMirror != NULL )
2280	{
2281	delete[] m_ppiShiftLUTRightMirror[0];
2282	delete[] m_ppiShiftLUTRightMirror[1];
2283	delete[] m_ppiShiftLUTRightMirror;
2284	};
2285
2286	if (m_piInvZLUTLeft != NULL ) delete[] m_piInvZLUTLeft ;
2287	if (m_piInvZLUTLeft != NULL ) delete[] m_piInvZLUTRight ;
2288
2289	if (m_pcLeftInputImage != NULL ) delete m_pcLeftInputImage ;
2290	if (m_pcLeftInputDepth != NULL ) delete m_pcLeftInputDepth ;
2291	if (m_pcLeftOutputImage != NULL ) delete m_pcLeftOutputImage ;
2292	if (m_pcLeftOutputDepth != NULL ) delete m_pcLeftOutputDepth ;
2293	if (m_pcLeftFilled != NULL ) delete m_pcLeftFilled ;
2294
2295	if (m_pcRightInputImage != NULL ) delete m_pcRightInputImage ;
2296	if (m_pcRightInputDepth != NULL ) delete m_pcRightInputDepth ;
2297	if (m_pcRightOutputImage != NULL ) delete m_pcRightOutputImage;
2298	if (m_pcRightOutputDepth != NULL ) delete m_pcRightOutputDepth;
2299	if (m_pcRightFilled != NULL ) delete m_pcRightFilled ;
2300
2301	if (m_pcOutputImage != NULL ) delete m_pcOutputImage ;
2302	if (m_pcOutputDepth != NULL ) delete m_pcOutputDepth ;
2303
2304	if (m_pcInputImage != NULL ) delete m_pcInputImage ;
2305	if (m_pcInputDepth != NULL ) delete m_pcInputDepth ;
2306	if (m_pcFilled != NULL ) delete m_pcFilled ;
2307
2308	if (m_pcTempImage != NULL ) delete m_pcTempImage ;
2309
2310	// SubPel LUT
2311	if ( m_aaiSubPelShift != NULL)
2312	{
2313	Int iNumEntries = (1 << ( m_iRelShiftLUTPrec + 1) ) + 1;
2314	for (UInt uiEntry = 0; uiEntry < iNumEntries; uiEntry++)
2315	{
2316	delete[] m_aaiSubPelShift[uiEntry];
2317	}
2318	delete[] m_aaiSubPelShift;
2319	}
2320
2321	// Zheijang temporal filter
2322	if(m_aiBlkMoving != NULL ) delete[] m_aiBlkMoving;
2323	}
2324

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

Download in other formats: