source: 3DVCSoftware/branches/0.2-poznan-univ/source/Lib/TLibRenderer/TRenTop.cpp @ 483

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

Poznan Tools

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