source: 3DVCSoftware/branches/0.3-poznan-univ/source/Lib/TLibRenderer/TRenTop.cpp @ 28

Last change on this file since 28 was 28, checked in by poznan-univ, 12 years ago

Poznan Tools

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