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

Last change on this file since 61 was 56, checked in by hschwarz, 12 years ago

updated trunk (move to HM6.1)

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