Context navigation

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

Visit:

Last change on this file since 60 was 56, checked in by hschwarz, 13 years ago
updated trunk (move to HM6.1)
Property svn:eol-style set to `native`
File size: 78.8 KB

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

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

Download in other formats: