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

Last change on this file since 166 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
42Void 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
74Void 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
92Void 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
130Void 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
167Void 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
203Void 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
242Void 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
270Void 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
298Void 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
334Void 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
353Void 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
380Void 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
398Void 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
423Void 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
458Void 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
484Void 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
571Void 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
609Void 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
744Void 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
925Void 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
951Void 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
1054Void 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
1120Void 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
1284Void 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
1326Void 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
1368Void 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
1387Void 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
1404Void 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
1421Void 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
1503Void 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
1525Void 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
1594Void 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
1695Void 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
1732Void 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
1756Void 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
1777Void 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
1798Void 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
1910delete[] aiHistLeft ;
1911delete[] aiHistRight;
1912delete[] aiConvLUT  ;
1913}
1914
1915
1916Void 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
1951Void 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
2020Void 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)
2094Void 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
2183TRenTop::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
2288Void 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
2391TRenTop::~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.