Context navigation

TRenTop.cpp @ 213

Visit:

Last change on this file since 213 was 166, checked in by mitsubishi-htm, 12 years ago

Initial integration of VSP into HTM 4.0.1. The version used for JCT3V-B0102 at Shanghai meeting.

VC9 project/solution files updated. Other Visual C++ project/solution files are not updated.
Linux make file updated.

TODO

A second release is expected to include some bug fix and improvements on the interface, e.g. to move switches from macro definition to the configuration file.
A third release is expected after being integrated within HTM 5.x, which is to be used for CE1.h anchor.

Property svn:eol-style set to native

File size: 87.0 KB

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibRenderer/TRenTop.cpp @ 213

Download in other formats: