source: 3DVCSoftware/trunk/source/Lib/TLibRenderer/TRenSingleModel.cpp @ 1197

Last change on this file since 1197 was 1179, checked in by tech, 10 years ago

Merged branch 13.1-dev0@1178.
  • Property svn:eol-style set to native
File size: 59.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-2015, ITU/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 "TRenFilter.h"
36#include "TRenSingleModel.h"
37
38#if H_3D_VSO
39
40////////////// TRENSINGLE MODEL ///////////////
41template <BlenMod iBM, Bool bBitInc>
42TRenSingleModelC<iBM,bBitInc>::TRenSingleModelC()
43:  m_iDistShift ( ( g_bitDepthY - 8) << 1 )
44{
45  m_iWidth  = -1;
46  m_iHeight = -1;
47  m_iStride = -1;
48  m_iUsedHeight = -1; 
49  m_iHorOffset  = -1; 
50  m_iMode   = -1;
51  m_iPad    = PICYUV_PAD;
52  m_iGapTolerance = -1;
53  m_bUseOrgRef = false;
54
55  m_pcPicYuvRef          = NULL;
56
57  m_pcOutputSamples      = NULL; 
58  m_pcOutputSamplesRow   = NULL;   
59  m_iOutputSamplesStride = -1; 
60
61  m_ppiCurLUT            = NULL;
62  m_piInvZLUTLeft        = NULL;
63  m_piInvZLUTRight       = NULL;
64
65  m_aapiRefVideoPel[0]   = NULL;
66  m_aapiRefVideoPel[1]   = NULL;
67  m_aapiRefVideoPel[2]   = NULL;
68
69  m_aiRefVideoStrides[0] = -1;
70  m_aiRefVideoStrides[1] = -1;
71  m_aiRefVideoStrides[2] = -1;
72
73
74  for (UInt uiViewNum = 0 ; uiViewNum < 2; uiViewNum++)
75  {
76    // LUT
77    m_appiShiftLut[uiViewNum] = NULL;
78
79    m_pcInputSamples[uiViewNum] = NULL; 
80    m_iInputSamplesStride       = -1; 
81
82    m_ppiCurLUT               = NULL;
83    m_piInvZLUTLeft           = NULL;
84    m_piInvZLUTRight          = NULL;
85  }
86
87#if H_3D_VSO_EARLY_SKIP
88  m_pbHorSkip = NULL;
89#endif
90}
91
92template <BlenMod iBM, Bool bBitInc>
93TRenSingleModelC<iBM,bBitInc>::~TRenSingleModelC()
94{
95#if H_3D_VSO_EARLY_SKIP
96  if ( m_pbHorSkip ) 
97  {
98    delete[] m_pbHorSkip;
99    m_pbHorSkip = NULL;
100  }
101#endif
102
103  if ( m_pcInputSamples [0] ) delete[] m_pcInputSamples [0];
104  if ( m_pcInputSamples [1] ) delete[] m_pcInputSamples [1];
105
106  if ( m_pcOutputSamples    ) delete[] m_pcOutputSamples   ;
107
108  if ( m_piInvZLUTLeft  ) delete[] m_piInvZLUTLeft ;
109  if ( m_piInvZLUTRight ) delete[] m_piInvZLUTRight;
110
111  if ( m_aapiRefVideoPel[0] ) delete[] ( m_aapiRefVideoPel[0] - ( m_aiRefVideoStrides[0] * m_iPad + m_iPad ) );
112  if ( m_aapiRefVideoPel[1] ) delete[] ( m_aapiRefVideoPel[1] - ( m_aiRefVideoStrides[1] * m_iPad + m_iPad ) );
113  if ( m_aapiRefVideoPel[2] ) delete[] ( m_aapiRefVideoPel[2] - ( m_aiRefVideoStrides[2] * m_iPad + m_iPad ) );
114}
115
116template <BlenMod iBM, Bool bBitInc> Void
117#if H_3D_VSO_EARLY_SKIP
118TRenSingleModelC<iBM,bBitInc>::create( Int iMode, Int iWidth, Int iHeight, Int iShiftPrec, Int*** aaaiSubPelShiftTable, Int iHoleMargin, Bool bUseOrgRef, Int iBlendMode, Bool bEarlySkip )
119#else
120TRenSingleModelC<iBM,bBitInc>::create( Int iMode, Int iWidth, Int iHeight, Int iShiftPrec, Int*** aaaiSubPelShiftTable, Int iHoleMargin, Bool bUseOrgRef, Int iBlendMode )
121#endif
122
123{
124#if H_3D_VSO_EARLY_SKIP
125  m_pbHorSkip     = new Bool [MAX_CU_SIZE];
126  m_bEarlySkip    = bEarlySkip; 
127#endif
128
129  AOF( iBlendMode == iBM ); 
130
131  m_iMode = iMode;
132
133  m_iWidth  = iWidth;
134  m_iHeight = iHeight;
135  m_iStride = iWidth;
136
137  m_iSampledWidth  = m_iWidth  << iShiftPrec;
138  m_iSampledStride = m_iStride << iShiftPrec;
139
140  m_iShiftPrec     = iShiftPrec;
141  m_aaiSubPelShiftL = aaaiSubPelShiftTable[0];
142  m_aaiSubPelShiftR = aaaiSubPelShiftTable[1];
143
144  if (m_iMode == 2)
145  {
146    m_piInvZLUTLeft  = new Int[257];
147    m_piInvZLUTRight = new Int[257];
148  }
149
150  m_iGapTolerance  = ( 2 << iShiftPrec );
151  m_iHoleMargin    =  iHoleMargin;
152
153  m_bUseOrgRef = bUseOrgRef;
154
155  m_aiRefVideoStrides[0] = m_iStride + (m_iPad << 1);
156  m_aiRefVideoStrides[1] = m_iStride + (m_iPad << 1);
157  m_aiRefVideoStrides[2] = m_iStride + (m_iPad << 1);
158
159  m_aapiRefVideoPel  [0] = new Pel[ m_aiRefVideoStrides[0] * (m_iHeight + (m_iPad << 1))];
160  m_aapiRefVideoPel  [1] = new Pel[ m_aiRefVideoStrides[1] * (m_iHeight + (m_iPad << 1))];
161  m_aapiRefVideoPel  [2] = new Pel[ m_aiRefVideoStrides[2] * (m_iHeight + (m_iPad << 1))];
162
163  m_aapiRefVideoPel  [0] += m_aiRefVideoStrides[0] * m_iPad + m_iPad;
164  m_aapiRefVideoPel  [1] += m_aiRefVideoStrides[1] * m_iPad + m_iPad;
165  m_aapiRefVideoPel  [2] += m_aiRefVideoStrides[2] * m_iPad + m_iPad;
166
167  m_iInputSamplesStride  = m_iWidth+1;
168  m_iOutputSamplesStride = m_iWidth;
169
170  m_pcInputSamples[0]     = new RenModelInPels[m_iInputSamplesStride*m_iHeight];
171  m_pcInputSamples[1]     = new RenModelInPels[m_iInputSamplesStride*m_iHeight];
172
173  m_pcOutputSamples       = new RenModelOutPels[m_iOutputSamplesStride*m_iHeight]; 
174}
175
176template <BlenMod iBM, Bool bBitInc> Void
177TRenSingleModelC<iBM,bBitInc>::setLRView( Int iViewPos, Pel** apiCurVideoPel, Int* aiCurVideoStride, Pel* piCurDepthPel, Int iCurDepthStride )
178{
179  AOF(( iViewPos == 0) || (iViewPos == 1) );
180
181  RenModelInPels* pcCurInputSampleRow = m_pcInputSamples[iViewPos];
182 
183  Pel* piDRow = piCurDepthPel;
184  Pel* piYRow = apiCurVideoPel[0];
185#if H_3D_VSO_COLOR_PLANES
186  Pel* piURow = apiCurVideoPel[1];
187  Pel* piVRow = apiCurVideoPel[2];
188#endif 
189
190
191  Int iOffsetX = ( iViewPos == VIEWPOS_RIGHT ) ? 1 : 0;
192
193  for ( Int iPosY = 0; iPosY < m_iUsedHeight; iPosY++ )
194  {
195    if ( iViewPos == VIEWPOS_RIGHT )
196    {
197      Int iSubPosX = (1 << m_iShiftPrec); 
198      pcCurInputSampleRow[0].aiY[iSubPosX] = piYRow[0];
199#if H_3D_VSO_COLOR_PLANES
200      pcCurInputSampleRow[0].aiU[iSubPosX] = piURow[0];
201      pcCurInputSampleRow[0].aiV[iSubPosX] = piVRow[0];
202#endif
203    }
204
205    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
206    {
207      pcCurInputSampleRow[iPosX].iD = piDRow[iPosX];
208
209      for (Int iSubPosX = 0; iSubPosX < (1 << m_iShiftPrec)+1; iSubPosX++ )
210      { 
211        Int iShift = (iPosX << m_iShiftPrec) + iSubPosX;
212        pcCurInputSampleRow[iPosX+iOffsetX].aiY[iSubPosX] = piYRow[iShift];
213#if H_3D_VSO_COLOR_PLANES
214        pcCurInputSampleRow[iPosX+iOffsetX].aiU[iSubPosX] = piURow[iShift];
215        pcCurInputSampleRow[iPosX+iOffsetX].aiV[iSubPosX] = piVRow[iShift];
216#endif
217      }
218    } 
219
220    pcCurInputSampleRow += m_iInputSamplesStride; 
221
222    piDRow += iCurDepthStride;
223    piYRow += aiCurVideoStride[0];
224#if H_3D_VSO_COLOR_PLANES
225    piURow += aiCurVideoStride[1];
226    piVRow += aiCurVideoStride[2];
227#endif
228  }
229
230 
231  m_aapiBaseVideoPel      [iViewPos] = apiCurVideoPel;
232  m_aaiBaseVideoStrides   [iViewPos] = aiCurVideoStride;
233  m_apiBaseDepthPel       [iViewPos] = piCurDepthPel;
234  m_aiBaseDepthStrides    [iViewPos] = iCurDepthStride;
235
236}
237template <BlenMod iBM, Bool bBitInc> Void
238TRenSingleModelC<iBM,bBitInc>::setupPart ( UInt uiHorOffset,       Int iUsedHeight )
239{
240  AOT( iUsedHeight > m_iHeight );   
241
242  m_iUsedHeight =       iUsedHeight; 
243  m_iHorOffset  = (Int) uiHorOffset;
244}
245
246template <BlenMod iBM, Bool bBitInc> Void
247TRenSingleModelC<iBM,bBitInc>::setup( TComPicYuv* pcOrgVideo, Int** ppiShiftLutLeft, Int** ppiBaseShiftLutLeft, Int** ppiShiftLutRight,  Int** ppiBaseShiftLutRight,  Int iDistToLeft, Bool bKeepReference )
248{
249  AOT( !m_bUseOrgRef && pcOrgVideo );
250  AOT( (ppiShiftLutLeft  == NULL) && (m_iMode == 0 || m_iMode == 2) );
251  AOT( (ppiShiftLutRight == NULL) && (m_iMode == 1 || m_iMode == 2) );
252
253  m_appiShiftLut[0] = ppiShiftLutLeft;
254  m_appiShiftLut[1] = ppiShiftLutRight;
255
256  // Copy Reference
257  m_pcPicYuvRef = pcOrgVideo;
258
259  if ( pcOrgVideo && !bKeepReference )
260  {
261    TRenFilter::copy(             pcOrgVideo->getLumaAddr() +  m_iHorOffset       * pcOrgVideo->getStride() , pcOrgVideo->getStride() , m_iWidth,      m_iUsedHeight,      m_aapiRefVideoPel[0], m_aiRefVideoStrides[0]);
262    TRenFilter::sampleCUpHorUp(0, pcOrgVideo->getCbAddr()   + (m_iHorOffset >> 1) * pcOrgVideo->getCStride(), pcOrgVideo->getCStride(), m_iWidth >> 1, m_iUsedHeight >> 1, m_aapiRefVideoPel[1], m_aiRefVideoStrides[1]);
263    TRenFilter::sampleCUpHorUp(0, pcOrgVideo->getCrAddr()   + (m_iHorOffset >> 1) * pcOrgVideo->getCStride(), pcOrgVideo->getCStride(), m_iWidth >> 1, m_iUsedHeight >> 1, m_aapiRefVideoPel[2], m_aiRefVideoStrides[2]);   
264    xSetStructRefView();
265  }
266
267  // Initial Rendering
268  xResetStructError();
269  xInitSampleStructs();
270  switch ( m_iMode )
271  { 
272  case 0:   
273#if H_3D_VSO_EARLY_SKIP
274    xRenderL<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0],false );
275#else
276    xRenderL<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0] );
277#endif   
278    break;
279  case 1:   
280#if H_3D_VSO_EARLY_SKIP
281    xRenderR<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1],false);
282#else
283    xRenderR<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1] );
284#endif
285    break;
286  case 2:
287    TRenFilter::setupZLUT( true, 30, iDistToLeft, ppiBaseShiftLutLeft, ppiBaseShiftLutRight, m_iBlendZThres, m_iBlendDistWeight, m_piInvZLUTLeft, m_piInvZLUTRight );
288#if H_3D_VSO_EARLY_SKIP
289    xRenderL<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0],false);
290    xRenderR<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1],false);
291#else     
292    xRenderL<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0] );
293    xRenderR<true>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1] );
294#endif
295    break;
296  default:
297    AOT(true);
298  }
299
300  // Get Rendered View as Reference
301  if ( !pcOrgVideo && !bKeepReference )
302  {
303    xResetStructError();
304    xSetStructSynthViewAsRefView();
305  }
306}
307
308template <BlenMod iBM, Bool bBitInc> Void
309#if H_3D_VSO_COLOR_PLANES
310TRenSingleModelC<iBM,bBitInc>::xGetSampleStrTextPtrs( Int iViewNum, Pel RenModelOutPels::*& rpiSrcY, Pel RenModelOutPels::*& rpiSrcU, Pel RenModelOutPels::*& rpiSrcV )
311#else
312TRenSingleModelC<iBM,bBitInc>::xGetSampleStrTextPtrs( Int iViewNum, Pel RenModelOutPels::*& rpiSrcY )
313#endif
314{
315  switch ( iViewNum )
316  {
317  case 0:
318    rpiSrcY = &RenModelOutPels::iYLeft;
319#if H_3D_VSO_COLOR_PLANES 
320    rpiSrcU = &RenModelOutPels::iULeft;
321    rpiSrcV = &RenModelOutPels::iVLeft;
322#endif
323    break;
324  case 1:
325    rpiSrcY = &RenModelOutPels::iYRight;
326#if H_3D_VSO_COLOR_PLANES 
327    rpiSrcU = &RenModelOutPels::iURight;
328    rpiSrcV = &RenModelOutPels::iVRight;
329#endif
330    break;
331  case 2:
332    rpiSrcY = &RenModelOutPels::iYBlended;
333#if H_3D_VSO_COLOR_PLANES 
334    rpiSrcU = &RenModelOutPels::iUBlended;
335    rpiSrcV = &RenModelOutPels::iVBlended;
336#endif
337    break;
338  }
339}
340
341
342template <BlenMod iBM, Bool bBitInc> Void
343TRenSingleModelC<iBM,bBitInc>::xGetSampleStrDepthPtrs( Int iViewNum, Pel RenModelOutPels::*& rpiSrcD )
344{
345  AOT(iViewNum != 0 && iViewNum != 1); 
346  rpiSrcD = (iViewNum == 1) ? &RenModelOutPels::iDRight : &RenModelOutPels::iDLeft; 
347}
348
349
350template <BlenMod iBM, Bool bBitInc> Void
351TRenSingleModelC<iBM,bBitInc>::xSetStructRefView( )
352{
353  RenModelOutPels* pcCurOutSampleRow = m_pcOutputSamples;
354 
355  Pel* piYRow = m_aapiRefVideoPel[0];
356#if H_3D_VSO_COLOR_PLANES
357  Pel* piURow = m_aapiRefVideoPel[1];
358  Pel* piVRow = m_aapiRefVideoPel[2];
359#endif 
360
361  for ( Int iPosY = 0; iPosY < m_iUsedHeight; iPosY++ )
362  {
363    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
364    {     
365      pcCurOutSampleRow[iPosX].iYRef = piYRow[iPosX];
366#if H_3D_VSO_COLOR_PLANES
367      pcCurOutSampleRow[iPosX].iURef = piURow[iPosX];
368      pcCurOutSampleRow[iPosX].iVRef = piVRow[iPosX];
369#endif
370    } 
371
372    pcCurOutSampleRow += m_iOutputSamplesStride; 
373   
374    piYRow += m_aiRefVideoStrides[0];
375#if H_3D_VSO_COLOR_PLANES
376    piURow += m_aiRefVideoStrides[1];
377    piVRow += m_aiRefVideoStrides[2];
378#endif
379  }
380}
381
382template <BlenMod iBM, Bool bBitInc> Void
383TRenSingleModelC<iBM,bBitInc>::xResetStructError( )
384{
385  RenModelOutPels* pcCurOutSampleRow = m_pcOutputSamples;
386
387  for ( Int iPosY = 0; iPosY < m_iHeight; iPosY++ )
388  {
389    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
390    {     
391      pcCurOutSampleRow[iPosX].iError = 0;
392    } 
393    pcCurOutSampleRow += m_iOutputSamplesStride; 
394  }
395}
396
397template <BlenMod iBM, Bool bBitInc> Void
398TRenSingleModelC<iBM,bBitInc>::xSetStructSynthViewAsRefView( )
399{
400  AOT( m_iMode < 0 || m_iMode > 2);
401
402  RenModelOutPels* pcCurOutSampleRow = m_pcOutputSamples;
403
404  Pel RenModelOutPels::* piSrcY = NULL;
405
406#if H_3D_VSO_COLOR_PLANES 
407  Pel RenModelOutPels::* piSrcU = NULL;
408  Pel RenModelOutPels::* piSrcV = NULL;
409  xGetSampleStrTextPtrs( m_iMode, piSrcY, piSrcU, piSrcV );
410#else
411  xGetSampleStrTextPtrs( m_iMode, piSrcY );
412#endif
413
414  for ( Int iPosY = 0; iPosY < m_iUsedHeight; iPosY++ )
415  {
416    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
417    {     
418      pcCurOutSampleRow[iPosX].iYRef = pcCurOutSampleRow[iPosX].*piSrcY;
419#if H_3D_VSO_COLOR_PLANES
420      pcCurOutSampleRow[iPosX].iURef = pcCurOutSampleRow[iPosX].*piSrcU;
421      pcCurOutSampleRow[iPosX].iVRef = pcCurOutSampleRow[iPosX].*piSrcV;
422#endif
423    } 
424    pcCurOutSampleRow += m_iOutputSamplesStride; 
425  }
426}
427
428template <BlenMod iBM, Bool bBitInc> Void
429TRenSingleModelC<iBM,bBitInc>::xInitSampleStructs()
430{
431  RenModelOutPels* pcOutSampleRow      = m_pcOutputSamples;
432  RenModelInPels * pcLeftInSampleRow   = m_pcInputSamples[0];
433  RenModelInPels * pcRightInSampleRow  = m_pcInputSamples[1];
434
435
436  for (Int iPosY = 0; iPosY < m_iHeight; iPosY++)
437  {
438    for (Int iPosX = 0; iPosX < m_iWidth; iPosX++)
439    {
440      //// Output Samples
441      pcOutSampleRow[iPosX].iFilledLeft   = REN_IS_HOLE;
442      pcOutSampleRow[iPosX].iFilledRight  = REN_IS_HOLE;
443
444      pcOutSampleRow[iPosX].iDLeft        = 0;
445      pcOutSampleRow[iPosX].iDRight       = 0;
446      pcOutSampleRow[iPosX].iDBlended     = 0;     
447                                     
448      // Y Planes                   
449      pcOutSampleRow[iPosX].iYLeft        = 0;
450      pcOutSampleRow[iPosX].iYRight       = 0;
451      pcOutSampleRow[iPosX].iYBlended     = 0;
452#if H_3D_VSO_COLOR_PLANES             
453      // U Planes                   
454      pcOutSampleRow[iPosX].iULeft        = 1 << (g_bitDepthC - 1);
455      pcOutSampleRow[iPosX].iURight       = 1 << (g_bitDepthC - 1);
456      pcOutSampleRow[iPosX].iUBlended     = 1 << (g_bitDepthC - 1);
457                                     
458      // V Planes                   
459      pcOutSampleRow[iPosX].iVLeft        = 1 << (g_bitDepthC - 1);
460      pcOutSampleRow[iPosX].iVRight       = 1 << (g_bitDepthC - 1);
461      pcOutSampleRow[iPosX].iVBlended     = 1 << (g_bitDepthC - 1);
462#endif
463      //// Input Samples
464      pcLeftInSampleRow [iPosX].bOccluded = false;
465      pcRightInSampleRow[iPosX].bOccluded = false;
466    }
467
468    pcOutSampleRow     += m_iOutputSamplesStride;
469    pcLeftInSampleRow  += m_iInputSamplesStride;
470    pcRightInSampleRow += m_iInputSamplesStride;
471  } 
472}
473
474
475#if H_3D_VSO_EARLY_SKIP
476template <BlenMod iBM, Bool bBitInc> RMDist
477TRenSingleModelC<iBM,bBitInc>::getDistDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData , Pel * piOrgData, Int iOrgStride )
478#else
479template <BlenMod iBM, Bool bBitInc> RMDist
480TRenSingleModelC<iBM,bBitInc>::getDistDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData )
481#endif
482{
483  RMDist iSSE = 0;
484#if H_3D_VSO_EARLY_SKIP
485  Bool   bEarlySkip;
486#endif
487  switch ( iViewPos )
488  {
489  case 0:
490#if H_3D_VSO_EARLY_SKIP
491    bEarlySkip = m_bEarlySkip ? xDetectEarlySkipL(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData, iOrgStride) : false;
492    if( !bEarlySkip )
493    {
494      iSSE = xRenderL<false>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData,true );
495    }   
496#else
497    iSSE = xRenderL<false>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData );
498#endif
499    break;
500  case 1:
501#if H_3D_VSO_EARLY_SKIP
502    bEarlySkip = m_bEarlySkip ? xDetectEarlySkipR(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData, iOrgStride) : false;
503    if( !bEarlySkip )
504    {
505      iSSE = xRenderR<false>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData,true );
506    }   
507#else
508    iSSE = xRenderR<false>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData );
509#endif
510    break;
511  default:
512    assert(0);
513  }
514
515  return iSSE;
516}
517#if H_3D_VSO_EARLY_SKIP
518template <BlenMod iBM, Bool bBitInc> Void
519TRenSingleModelC<iBM,bBitInc>::setDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel* piOrgData, Int iOrgStride )
520#else
521template <BlenMod iBM, Bool bBitInc> Void
522TRenSingleModelC<iBM,bBitInc>::setDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData )
523#endif
524{
525#ifdef  H_3D_VSO_EARLY_SKIP
526  Bool bEarlySkip;
527#endif
528  switch ( iViewPos )
529  {
530  case 0:
531#if H_3D_VSO_EARLY_SKIP
532    bEarlySkip = m_bEarlySkip ? xDetectEarlySkipL(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData,iOrgStride) : false;
533    if( !bEarlySkip )
534    {
535      xRenderL<true>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData,true );
536    }   
537#else
538    xRenderL<true>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData );
539#endif     
540    break;
541  case 1:
542#if H_3D_VSO_EARLY_SKIP
543    bEarlySkip = m_bEarlySkip ? xDetectEarlySkipR(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData,iOrgStride) : false;
544    if( !bEarlySkip )
545    {
546      xRenderR<true>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData,true ); 
547    }   
548#else
549    xRenderR<true>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData );
550#endif     
551    break;
552  default:
553    assert(0);
554  }
555}
556
557template <BlenMod iBM, Bool bBitInc> Void
558TRenSingleModelC<iBM,bBitInc>::getSynthVideo( Int iViewPos, TComPicYuv* pcPicYuv )
559{ 
560  AOT( pcPicYuv->getWidth() != m_iWidth );
561  AOT( pcPicYuv->getHeight() < m_iUsedHeight + m_iHorOffset );
562
563#if H_3D_VSO_COLOR_PLANES
564  Pel RenModelOutPels::* piText[3] = { NULL, NULL, NULL };
565  xGetSampleStrTextPtrs(iViewPos, piText[0], piText[1], piText[2]); 
566
567  // Temp image for chroma down sampling
568  PelImage cTempImage( m_iWidth, m_iUsedHeight, 3, 0);
569
570  Int  aiStrides[3]; 
571  Pel* apiData  [3]; 
572
573  cTempImage.getDataAndStrides( apiData, aiStrides ); 
574
575  for (UInt uiCurPlane = 0; uiCurPlane < 3; uiCurPlane++ )
576  {
577    xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piText[uiCurPlane], apiData[uiCurPlane], aiStrides[uiCurPlane] , m_iWidth, m_iUsedHeight);
578  } 
579  xCopy2PicYuv( apiData, aiStrides, pcPicYuv );
580#else
581  Pel RenModelOutPels::* piY;
582  xGetSampleStrTextPtrs(iViewPos, piY); 
583  xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piY, pcPicYuv->getLumaAddr() + m_iHorOffset * pcPicYuv->getStride(), pcPicYuv->getStride(), m_iWidth, m_iUsedHeight );
584  pcPicYuv->setChromaTo( 1 << (g_bitDepthC - 1) );   
585#endif 
586}
587
588template <BlenMod iBM, Bool bBitInc> Void
589TRenSingleModelC<iBM,bBitInc>::getSynthDepth( Int iViewPos, TComPicYuv* pcPicYuv )
590{ 
591  AOT( iViewPos != 0 && iViewPos != 1); 
592  AOT( pcPicYuv->getWidth()  != m_iWidth  );
593  AOT( pcPicYuv->getHeight() < m_iUsedHeight + m_iHorOffset );
594
595  Pel RenModelOutPels::* piD = 0;
596  xGetSampleStrDepthPtrs(iViewPos, piD); 
597  xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piD, pcPicYuv->getLumaAddr() + pcPicYuv->getStride() * m_iHorOffset, pcPicYuv->getStride(), m_iWidth, m_iUsedHeight );
598  pcPicYuv->setChromaTo( 1 << (g_bitDepthC - 1) );   
599}
600
601
602template <BlenMod iBM, Bool bBitInc> Void
603TRenSingleModelC<iBM,bBitInc>::getRefVideo ( Int iViewPos, TComPicYuv* pcPicYuv )
604{ 
605  AOT( pcPicYuv->getWidth()  != m_iWidth  );
606  AOT( pcPicYuv->getHeight() <  m_iUsedHeight + m_iHorOffset);
607
608#if H_3D_VSO_COLOR_PLANES
609  Pel RenModelOutPels::* piText[3];
610  piText[0] = &RenModelOutPels::iYRef;
611  piText[1] = &RenModelOutPels::iURef;
612  piText[2] = &RenModelOutPels::iVRef;
613
614  // Temp image for chroma down sampling
615
616  PelImage cTempImage( m_iWidth, m_iUsedHeight, 3, 0);
617  Int  aiStrides[3]; 
618  Pel* apiData  [3]; 
619
620  cTempImage.getDataAndStrides( apiData, aiStrides ); 
621
622  for (UInt uiCurPlane = 0; uiCurPlane < 3; uiCurPlane++ )
623  {
624    xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piText[uiCurPlane], apiData[uiCurPlane], aiStrides[uiCurPlane] , m_iWidth, m_iUsedHeight);
625  } 
626
627  xCopy2PicYuv( apiData, aiStrides, pcPicYuv );
628#else
629  xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, &RenModelOutPels::iYRef, pcPicYuv->getLumaAddr() *  pcPicYuv->getStride() + m_iHorOffset, pcPicYuv->getStride(), m_iWidth, m_iUsedHeight );
630  pcPicYuv->setChromaTo( 1 << ( g_bitDepthC - 1 ) );   
631#endif 
632}
633
634template <BlenMod iBM, Bool bBitInc> RMDist
635TRenSingleModelC<iBM,bBitInc>::getDistVideo( Int iViewPos, Int iPlane, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData )
636{
637  AOF(false);
638  return 0;
639}
640
641template <BlenMod iBM, Bool bBitInc> Void
642TRenSingleModelC<iBM,bBitInc>::setVideo( Int iViewPos, Int iPlane, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData )
643{
644  AOF(false);
645}
646
647
648
649template <BlenMod iBM, Bool bBitInc> __inline Void
650TRenSingleModelC<iBM,bBitInc>::xSetViewRow( Int iPosY )
651{
652  m_pcInputSamplesRow[0] = m_pcInputSamples[0] + m_iInputSamplesStride  * iPosY;
653  m_pcInputSamplesRow[1] = m_pcInputSamples[1] + m_iInputSamplesStride  * iPosY;
654  m_pcOutputSamplesRow   = m_pcOutputSamples   + m_iOutputSamplesStride * iPosY; 
655
656}
657
658template <BlenMod iBM, Bool bBitInc> __inline Void
659TRenSingleModelC<iBM,bBitInc>::xIncViewRow( )
660{
661  m_pcInputSamplesRow[0] += m_iInputSamplesStride ;
662  m_pcInputSamplesRow[1] += m_iInputSamplesStride ;
663  m_pcOutputSamplesRow   += m_iOutputSamplesStride; 
664}
665#if H_3D_VSO_EARLY_SKIP
666template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
667TRenSingleModelC<iBM,bBitInc>::xRenderL( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Bool bFast)
668#else
669template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
670TRenSingleModelC<iBM,bBitInc>::xRenderL( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData)
671#endif
672{
673  const Int iCurViewPos   = 0;
674  const Int iOtherViewPos = 1;
675
676  m_iCurViewPos   = iCurViewPos  ; 
677  m_iOtherViewPos = iOtherViewPos;
678
679  m_piNewDepthData   = piNewData;
680  m_iNewDataWidth    = iWidth;
681  m_iStartChangePosX = iStartPosX;
682
683  if ((iWidth == 0) || (iHeight == 0))
684    return 0;
685
686  // Get Data
687  m_ppiCurLUT      = m_appiShiftLut   [iCurViewPos];
688  xSetViewRow      ( iStartPosY);
689
690  // Init Start
691  RMDist iError = 0;
692  Int   iStartChangePos;
693
694  iStartChangePos = m_iStartChangePosX;
695
696  for (Int iPosY = iStartPosY; iPosY < iStartPosY + iHeight; iPosY++ )
697  {
698#if H_3D_VSO_EARLY_SKIP
699    if( m_bEarlySkip && bFast )
700    {
701      if ( m_pbHorSkip[iPosY-iStartPosY] )
702      {
703        xIncViewRow();
704        m_piNewDepthData += iStride;
705        continue;
706      }
707    }
708#endif
709    m_bInOcclusion = false;
710
711    Int iLastSPos;
712    Int iEndChangePos         = m_iStartChangePosX + iWidth - 1;
713    Int iPosXinNewData        = iWidth - 1;
714    Int iMinChangedSPos       = m_iSampledWidth;
715
716    if ( iEndChangePos == ( m_iWidth -1 )) // Special processing for rightmost depth sample
717    {
718      m_iCurDepth           = m_piNewDepthData[iPosXinNewData];
719      Int iCurSPos          = xShiftNewData(iEndChangePos, iPosXinNewData);
720      m_iLastOccludedSPos   = iCurSPos + 1;
721      m_iLastOccludedSPosFP = xRangeLeftL( m_iLastOccludedSPos );
722      xExtrapolateMarginL<bSet>  ( iCurSPos, iEndChangePos, iError );
723
724      iMinChangedSPos       = std::min( iMinChangedSPos, (iEndChangePos << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( std::max(m_pcInputSamplesRow[iCurViewPos][iEndChangePos].iD, m_piNewDepthData[iPosXinNewData] )) ]);
725      iLastSPos             = iCurSPos;
726      m_iLastDepth          = m_iCurDepth;
727
728      if ( bSet )
729      {
730        m_pcInputSamplesRow[iCurViewPos][iEndChangePos].iD = m_piNewDepthData[iPosXinNewData];
731      }
732
733      iPosXinNewData--;
734      iEndChangePos--;
735    }
736    else
737    {
738      iLastSPos    = xShift(iEndChangePos+1);
739      m_iLastDepth = m_pcInputSamplesRow [iCurViewPos][iEndChangePos+1].iD;
740      xInitRenderPartL( iEndChangePos, iLastSPos );
741    }
742
743    //// RENDER NEW DATA
744    Int iCurPosX;
745    for ( iCurPosX = iEndChangePos; iCurPosX >= iStartChangePos; iCurPosX-- )
746    {
747      // Get minimal changed sample position
748
749      iMinChangedSPos = std::min( iMinChangedSPos, (iCurPosX << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( std::max(m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD, m_piNewDepthData[iPosXinNewData] )) ]);
750      Int iCurSPos    = xShiftNewData(iCurPosX,iPosXinNewData);
751      m_iCurDepth     = m_piNewDepthData[iPosXinNewData];
752      xRenderRangeL<bSet>(iCurSPos, iLastSPos, iCurPosX, iError );
753      iLastSPos       = iCurSPos;
754      m_iLastDepth    = m_iCurDepth;
755
756      if ( bSet )
757      {
758        m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD = m_piNewDepthData[iPosXinNewData];
759      }
760
761      iPosXinNewData--;
762    }
763
764    //// RE-RENDER DATA LEFT TO NEW DATA
765    while ( iCurPosX >= 0 )
766    {
767      Int iCurSPos = xShift(iCurPosX);
768
769      m_iCurDepth  = m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD;
770      xRenderRangeL<bSet>( iCurSPos, iLastSPos, iCurPosX, iError );
771
772      if ( iCurSPos < iMinChangedSPos )
773      {
774          break;
775      }
776
777      iCurPosX--;
778      iLastSPos    = iCurSPos;
779      m_iLastDepth = m_iCurDepth;
780    }
781
782
783    xIncViewRow();
784    m_piNewDepthData += iStride;
785  }
786  return iError;
787}
788
789#ifdef  H_3D_VSO_EARLY_SKIP
790template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
791TRenSingleModelC<iBM,bBitInc>::xRenderR( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData , Bool bFast)
792#else
793template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
794TRenSingleModelC<iBM,bBitInc>::xRenderR( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData )
795#endif
796{
797
798  const Int iCurViewPos   = 1;
799  const Int iOtherViewPos = 0;
800
801  m_iCurViewPos      = iCurViewPos;
802  m_iOtherViewPos    = iOtherViewPos;
803
804  m_piNewDepthData   = piNewData;
805  m_iNewDataWidth    = iWidth;
806  m_iStartChangePosX = iStartPosX;
807
808  if ((iWidth == 0) || (iHeight == 0))
809    return 0;
810
811  // Get Data
812  m_ppiCurLUT      = m_appiShiftLut   [iCurViewPos];
813  xSetViewRow      ( iStartPosY);
814
815  // Init Start
816  RMDist iError = 0;
817  Int   iEndChangePos;
818
819  iEndChangePos = m_iStartChangePosX + iWidth - 1;
820
821  for (Int iPosY = iStartPosY; iPosY < iStartPosY + iHeight; iPosY++ )
822  {
823#if H_3D_VSO_EARLY_SKIP
824    if( m_bEarlySkip && bFast )
825    {
826      if ( m_pbHorSkip[iPosY-iStartPosY] )
827      {
828        xIncViewRow();
829        m_piNewDepthData += iStride;
830        continue;
831      }
832    }
833#endif
834    m_bInOcclusion = false;
835
836    Int iLastSPos;
837    Int iStartChangePos       = m_iStartChangePosX;
838    Int iPosXinNewData        = 0;
839    Int iMaxChangedSPos = -1;
840
841    if ( iStartChangePos == 0 ) // Special processing for leftmost depth sample
842    {
843      m_iCurDepth           = m_piNewDepthData[iPosXinNewData];
844      Int iCurSPos          = xShiftNewData(iStartChangePos, iPosXinNewData);
845      m_iLastOccludedSPos   = iCurSPos - 1;
846      m_iLastOccludedSPosFP = xRangeRightR( m_iLastOccludedSPos );
847      xExtrapolateMarginR<bSet>     ( iCurSPos, iStartChangePos, iError );
848
849      iMaxChangedSPos       = std::max( iMaxChangedSPos, (iStartChangePos << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( std::max(m_pcInputSamplesRow[iCurViewPos][iStartChangePos].iD, m_piNewDepthData[iPosXinNewData] )) ]);
850      iLastSPos             = iCurSPos;
851      m_iLastDepth          = m_iCurDepth;
852      if ( bSet )
853      {
854        m_pcInputSamplesRow[iCurViewPos][iStartChangePos].iD = m_piNewDepthData[iPosXinNewData];
855      }
856
857
858      iPosXinNewData++;
859      iStartChangePos++;
860    }
861    else
862    {
863      iLastSPos   = xShift(iStartChangePos-1);
864
865      m_iLastDepth = m_pcInputSamplesRow[iCurViewPos][iStartChangePos-1].iD;
866      xInitRenderPartR( iStartChangePos, iLastSPos );
867    }
868
869    //// RENDER NEW DATA
870    Int iCurPosX;
871    for ( iCurPosX = iStartChangePos; iCurPosX <= iEndChangePos; iCurPosX++ )
872    {
873      // Get minimal changed sample position
874
875      iMaxChangedSPos = std::max( iMaxChangedSPos, (iCurPosX << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( std::max(m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD, m_piNewDepthData[iPosXinNewData] )) ]);
876      Int iCurSPos    = xShiftNewData(iCurPosX,iPosXinNewData);
877      m_iCurDepth     = m_piNewDepthData[iPosXinNewData];
878      xRenderRangeR<bSet>(iCurSPos, iLastSPos, iCurPosX, iError );
879      iLastSPos      = iCurSPos;
880      m_iLastDepth    = m_iCurDepth;
881
882      if ( bSet )
883      {
884        m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD = m_piNewDepthData[iPosXinNewData];
885      }
886
887      iPosXinNewData++;
888    }
889
890    //// RE-RENDER DATA LEFT TO NEW DATA
891    while ( iCurPosX < m_iWidth )
892    {
893      Int iCurSPos = xShift(iCurPosX);
894
895      m_iCurDepth  = m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD;
896      xRenderRangeR<bSet>( iCurSPos, iLastSPos, iCurPosX, iError );
897
898      if ( iCurSPos > iMaxChangedSPos )
899      {
900          break;
901        }
902      iCurPosX++;
903      iLastSPos    = iCurSPos;
904      m_iLastDepth = m_iCurDepth;
905    }
906
907    xIncViewRow();
908    m_piNewDepthData += iStride;
909  }
910  return iError;
911}
912
913
914template <BlenMod iBM, Bool bBitInc> __inline Void
915TRenSingleModelC<iBM,bBitInc>::xInitRenderPartL(  Int iEndChangePos, Int iLastSPos )
916{
917  const Int iCurViewPos = 0; 
918  // GET MINIMAL OCCLUDED SAMPLE POSITION
919  Int iCurPosX           = iEndChangePos;
920
921
922  if ( ( iCurPosX + 1 < m_iWidth ) && (m_pcInputSamplesRow[iCurViewPos][ iCurPosX + 1].bOccluded ) )
923  {
924    iCurPosX++;
925
926    while ( (iCurPosX + 1 < m_iWidth) &&  (m_pcInputSamplesRow[iCurViewPos][ iCurPosX + 1].bOccluded  )  )
927
928      iCurPosX++;
929
930    if ( iCurPosX + 1 < m_iWidth )
931    {
932      iCurPosX++;
933      m_iLastOccludedSPos = xShift(iCurPosX);
934    }
935    else
936    {
937      m_iLastOccludedSPos = xShift(iCurPosX) + 1;
938    }
939
940    m_iLastOccludedSPosFP = xRoundL( m_iLastOccludedSPos );
941  }
942  else
943  {
944    m_iLastOccludedSPos   = iLastSPos+1;
945    m_iLastOccludedSPosFP = xRangeLeftL( m_iLastOccludedSPos );
946  }
947
948  m_bInOcclusion = iLastSPos >= m_iLastOccludedSPos;
949};
950
951template <BlenMod iBM, Bool bBitInc> __inline Void
952TRenSingleModelC<iBM,bBitInc>::xInitRenderPartR(  Int iStartChangePos, Int iLastSPos )
953{
954    const Int iCurViewPos = 1; 
955  // GET MINIMAL OCCLUDED SAMPLE POSITION
956  Int iCurPosX           = iStartChangePos;
957
958  if ( ( iCurPosX - 1 > -1 ) && (m_pcInputSamplesRow[iCurViewPos][ iCurPosX - 1].bOccluded  ) )
959  {
960    iCurPosX--;
961
962    while ( (iCurPosX - 1 > -1 ) &&  (m_pcInputSamplesRow[iCurViewPos][ iCurPosX - 1].bOccluded  )  )
963      iCurPosX--;
964
965    if ( iCurPosX - 1 > -1 )
966    {
967      iCurPosX--;
968      m_iLastOccludedSPos = xShift(iCurPosX);
969    }
970    else
971    {
972      m_iLastOccludedSPos = xShift(iCurPosX) - 1;
973    }
974    m_iLastOccludedSPosFP = xRoundR( m_iLastOccludedSPos );
975  }
976  else
977  {
978    m_iLastOccludedSPos   = iLastSPos-1;
979    m_iLastOccludedSPosFP = xRangeRightR( m_iLastOccludedSPos );
980  }
981
982  m_bInOcclusion = iLastSPos <= m_iLastOccludedSPos;
983};
984
985
986template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
987TRenSingleModelC<iBM,bBitInc>::xRenderShiftedRangeL(Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
988{
989  assert( iCurSPos <= iLastSPos );
990  //assert( iRightSPos < m_iWidth );
991
992  Int iDeltaSPos = iLastSPos - iCurSPos;
993  if ( iDeltaSPos > m_iGapTolerance )
994  {
995    xFillHoleL<bSet>( iCurSPos, iLastSPos, iCurPos, riError );
996  }
997  else
998  {
999    if (iLastSPos < 0 )
1000      return;
1001
1002    RM_AOT( iDeltaSPos    > m_iGapTolerance );
1003
1004    m_iThisDepth = m_iCurDepth;
1005    for (Int iFillSPos = std::max(0, xRangeLeftL(iCurSPos) ); iFillSPos <= min(xRangeRightL( iLastSPos ) ,m_iLastOccludedSPosFP-1); iFillSPos++ )
1006    {
1007      Int iDeltaCurSPos  = (iFillSPos << m_iShiftPrec) - iCurSPos;
1008
1009      RM_AOT( iDeltaCurSPos > iDeltaSPos );
1010      RM_AOT( iDeltaCurSPos < 0 );
1011      RM_AOT( m_aaiSubPelShiftL[iDeltaSPos][iDeltaCurSPos] == 0xdeaddead);
1012
1013      xSetShiftedPelL<bSet>( iCurPos, m_aaiSubPelShiftL[iDeltaSPos][iDeltaCurSPos], iFillSPos, REN_IS_FILLED, riError );
1014    }
1015  };
1016}
1017
1018template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1019TRenSingleModelC<iBM,bBitInc>::xRenderShiftedRangeR(Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
1020{
1021  assert( iCurSPos >= iLastSPos );
1022
1023  Int iDeltaSPos = iCurSPos - iLastSPos;
1024  if ( iDeltaSPos > m_iGapTolerance )
1025  {
1026    xFillHoleR<bSet>( iCurSPos, iLastSPos, iCurPos, riError );
1027  }
1028  else
1029  {
1030    if (iLastSPos > m_iSampledWidth - 1 )
1031      return;
1032
1033    m_iThisDepth = m_iCurDepth;
1034    RM_AOT( iDeltaSPos    > m_iGapTolerance );
1035    for (Int iFillSPos = max(m_iLastOccludedSPosFP+1, xRangeLeftR(iLastSPos) ); iFillSPos <= min(xRangeRightR( iCurSPos ) ,m_iWidth -1); iFillSPos++ )
1036    {
1037      Int iDeltaCurSPos  = (iFillSPos << m_iShiftPrec) - iLastSPos;
1038
1039      RM_AOT( iDeltaCurSPos > iDeltaSPos );
1040      RM_AOT( iDeltaCurSPos < 0 );
1041      RM_AOT( m_aaiSubPelShiftR[iDeltaSPos][iDeltaCurSPos] == 0xdeaddead);
1042
1043      xSetShiftedPelR<bSet>( iCurPos, m_aaiSubPelShiftR[iDeltaSPos][iDeltaCurSPos], iFillSPos, REN_IS_FILLED, riError );
1044    }
1045  };
1046}
1047
1048
1049
1050template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1051TRenSingleModelC<iBM,bBitInc>::xRenderRangeL(Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
1052{
1053  const Int iCurViewPos = 0; 
1054  if (  !m_bInOcclusion )
1055  {
1056    if ( iCurSPos >= iLastSPos )
1057    {
1058      m_iLastOccludedSPos = iLastSPos;
1059
1060      Int iRightSPosFP = xRoundL( iLastSPos );
1061      if ( ( iRightSPosFP == xRangeRightL(iLastSPos)) && (iRightSPosFP >= 0) )
1062      {
1063        m_iThisDepth = m_iLastDepth;
1064
1065        xSetShiftedPelL<bSet>( iCurPos+1, 0, iRightSPosFP, REN_IS_FILLED, riError );
1066      }
1067      m_iLastOccludedSPosFP = iRightSPosFP;
1068
1069      m_bInOcclusion = true;
1070
1071      if ( bSet )
1072      {
1073        m_pcInputSamplesRow[iCurViewPos][ iCurPos ].bOccluded  = true;
1074      }
1075    }
1076    else
1077    {
1078      if ( bSet )
1079      {
1080        m_pcInputSamplesRow[iCurViewPos][ iCurPos ].bOccluded  = false;
1081      }
1082
1083      xRenderShiftedRangeL<bSet>(iCurSPos, iLastSPos, iCurPos, riError );
1084    }
1085  }
1086  else
1087  {
1088    if ( iCurSPos < m_iLastOccludedSPos )
1089    {
1090      m_bInOcclusion = false;
1091      if ( bSet )
1092      {
1093        m_pcInputSamplesRow[iCurViewPos][ iCurPos ].bOccluded  = false;
1094      }
1095
1096      xRenderShiftedRangeL<bSet>(iCurSPos, iLastSPos, iCurPos, riError );
1097    }
1098    else
1099    {
1100      if ( bSet )
1101      {
1102        m_pcInputSamplesRow[iCurViewPos][ iCurPos ].bOccluded  = true;
1103      }
1104    }
1105  }
1106}
1107
1108template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1109TRenSingleModelC<iBM,bBitInc>::xRenderRangeR(Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
1110{
1111  const Int iCurViewPos = 1; 
1112  // Find out if current sample is occluded
1113  if (  !m_bInOcclusion )
1114  {
1115    if ( iCurSPos <= iLastSPos )
1116    {
1117      m_iLastOccludedSPos = iLastSPos;
1118
1119      Int iLeftSPosFP = xRoundR( iLastSPos );
1120      if ( ( iLeftSPosFP == xRangeLeftR(iLastSPos)) && (iLeftSPosFP <= m_iWidth - 1) )
1121      {
1122        m_iThisDepth = m_iLastDepth;
1123        xSetShiftedPelR<bSet>( iCurPos-1,1 << m_iShiftPrec , iLeftSPosFP, REN_IS_FILLED, riError );
1124      }
1125      m_iLastOccludedSPosFP = iLeftSPosFP;
1126
1127      m_bInOcclusion = true;
1128
1129      if ( bSet )
1130      {
1131        m_pcInputSamplesRow[iCurViewPos][ iCurPos ].bOccluded  = true;
1132      }
1133    }
1134    else
1135    {
1136      if ( bSet )
1137      {
1138        m_pcInputSamplesRow[iCurViewPos][ iCurPos ].bOccluded  = false;
1139      }
1140
1141      xRenderShiftedRangeR<bSet>(iCurSPos, iLastSPos, iCurPos, riError );
1142    }
1143  }
1144  else
1145  {
1146    if ( iCurSPos > m_iLastOccludedSPos )
1147    {
1148      m_bInOcclusion = false;
1149      if ( bSet )
1150      {
1151        m_pcInputSamplesRow[iCurViewPos][ iCurPos ].bOccluded  = false;
1152      }
1153
1154      xRenderShiftedRangeR<bSet>(iCurSPos, iLastSPos, iCurPos, riError );
1155    }
1156    else
1157    {
1158      if ( bSet )
1159      {
1160        m_pcInputSamplesRow[iCurViewPos][ iCurPos ].bOccluded  = true;
1161      }
1162    }
1163  }
1164}
1165
1166template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1167TRenSingleModelC<iBM,bBitInc>::xFillHoleL( Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
1168{
1169  if (iLastSPos < 0)
1170    return;
1171
1172  Int iStartFillSPos = iCurSPos;
1173  Int iStartFillPos  = iCurPos;
1174  Int iLastPos      = iCurPos + 1;
1175
1176  Int iStartFillSPosFP = xRangeLeftL(iStartFillSPos);
1177
1178  if (iStartFillSPosFP == xRoundL(iStartFillSPos))
1179  {
1180    if ((iStartFillSPosFP >= 0) && (iStartFillSPosFP < m_iLastOccludedSPosFP) )
1181    {
1182      m_iThisDepth = m_iCurDepth;
1183      xSetShiftedPelL<bSet>    ( iStartFillPos, 0, iStartFillSPosFP, REN_IS_FILLED, riError );
1184    }
1185  }
1186  else
1187  {
1188    iStartFillSPosFP--;
1189  }
1190
1191  m_iThisDepth = m_iLastDepth;
1192  for (Int iFillSPos = std::max(iStartFillSPosFP+1,0); iFillSPos <= min(xRangeRightL( iLastSPos ), m_iLastOccludedSPosFP-1 ); iFillSPos++ )
1193  {
1194    xSetShiftedPelL<bSet>( iLastPos, 0,  iFillSPos, REN_IS_HOLE, riError );
1195  }
1196}
1197
1198template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1199TRenSingleModelC<iBM,bBitInc>::xFillHoleR( Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
1200{
1201  if (iLastSPos < 0)
1202    return;
1203
1204  Int iStartFillSPos = iCurSPos;
1205  Int iEndFillPos    = iCurPos;
1206  Int iLastPos       = iCurPos - 1;
1207
1208  Int iStartFillSPosFP = xRangeRightR(iStartFillSPos);
1209
1210  if (iStartFillSPosFP == xRoundR(iStartFillSPos))
1211  {
1212    if ((iStartFillSPosFP < m_iWidth) && (iStartFillSPosFP > m_iLastOccludedSPosFP) )
1213    {
1214      m_iThisDepth = m_iCurDepth;
1215      xSetShiftedPelR<bSet>( iEndFillPos, 1 << m_iShiftPrec , iStartFillSPosFP, REN_IS_FILLED, riError );
1216    }
1217  }
1218  else
1219  {
1220    iStartFillSPosFP++;
1221  }
1222
1223  m_iThisDepth = m_iLastDepth;
1224  for (Int iFillSPos = max(xRangeLeftR( iLastSPos ), m_iLastOccludedSPosFP+1); iFillSPos <= min(iStartFillSPosFP,m_iWidth)-1 ; iFillSPos++ )
1225  {
1226    xSetShiftedPelR<bSet>( iLastPos, 1 << m_iShiftPrec, iFillSPos, REN_IS_HOLE, riError );
1227  }
1228}
1229
1230template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1231TRenSingleModelC<iBM,bBitInc>::xExtrapolateMarginL(Int iCurSPos, Int iCurPos, RMDist& riError )
1232{
1233//  if (iLeftSPos < 0 )
1234//    return;
1235
1236  Int iSPosFullPel = std::max(0,xRangeLeftL(iCurSPos));
1237
1238  m_iThisDepth = m_iCurDepth;
1239  if (iSPosFullPel < m_iWidth)
1240  {
1241    xSetShiftedPelL<bSet>( iCurPos, 0, iSPosFullPel, REN_IS_FILLED, riError );
1242  }
1243
1244  for (Int iFillSPos = iSPosFullPel +1; iFillSPos < m_iWidth; iFillSPos++ )
1245  {
1246    xSetShiftedPelL<bSet>( iCurPos, 0, iFillSPos, REN_IS_HOLE, riError );
1247  }
1248}
1249
1250template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1251TRenSingleModelC<iBM,bBitInc>::xExtrapolateMarginR(Int iCurSPos, Int iCurPos, RMDist& riError )
1252{
1253  //  if (iLeftSPos < 0 )
1254  //    return;
1255
1256  Int iSPosFullPel = std::min(m_iWidth-1,xRangeRightR(iCurSPos));
1257
1258  m_iThisDepth = m_iCurDepth;
1259  if (iSPosFullPel > -1)
1260  {
1261    xSetShiftedPelR<bSet>( iCurPos, 1 << m_iShiftPrec, iSPosFullPel, REN_IS_FILLED, riError );
1262  }
1263
1264  for (Int iFillSPos = iSPosFullPel -1; iFillSPos > -1; iFillSPos-- )
1265  {
1266    xSetShiftedPelR<bSet>( iCurPos , 1 << m_iShiftPrec, iFillSPos, REN_IS_HOLE, riError );
1267  }
1268}
1269
1270template <BlenMod iBM, Bool bBitInc> __inline Int
1271TRenSingleModelC<iBM,bBitInc>::xShiftNewData( Int iPosX, Int iPosInNewData )
1272{
1273  RM_AOT( iPosInNewData <               0 );
1274  RM_AOF( iPosInNewData < m_iNewDataWidth );
1275
1276  return (iPosX << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( m_piNewDepthData[iPosInNewData] )];
1277}
1278
1279template <BlenMod iBM, Bool bBitInc> __inline Int
1280TRenSingleModelC<iBM,bBitInc>::xShift( Int iPosX )
1281{
1282 RM_AOT( iPosX <        0);
1283 RM_AOF( iPosX < m_iWidth);
1284
1285 return (iPosX  << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( m_pcInputSamplesRow[m_iCurViewPos][iPosX].iD )];
1286}
1287
1288
1289template <BlenMod iBM, Bool bBitInc> __inline Int
1290TRenSingleModelC<iBM,bBitInc>::xShift( Int iPos, Int iPosInNewData )
1291{
1292  if ( (iPosInNewData >= 0) && (iPosInNewData < m_iNewDataWidth) )
1293  {
1294    return xShiftNewData(iPos ,iPosInNewData );
1295  }
1296  else
1297  {
1298    return xShift(iPos);
1299  }
1300}
1301
1302template <BlenMod iBM, Bool bBitInc> __inline Int
1303TRenSingleModelC<iBM,bBitInc>::xRangeLeftL( Int iPos )
1304{
1305  return  ( iPos +  (1 << m_iShiftPrec) - 1) >> m_iShiftPrec;
1306}
1307
1308
1309template <BlenMod iBM, Bool bBitInc> __inline Int
1310TRenSingleModelC<iBM,bBitInc>::xRangeLeftR( Int iPos )
1311{
1312
1313  return  xRangeRightR( iPos ) + 1;
1314}
1315
1316
1317template <BlenMod iBM, Bool bBitInc> __inline Int
1318TRenSingleModelC<iBM,bBitInc>::xRangeRightL( Int iPos )
1319{
1320  return xRangeLeftL(iPos) - 1;
1321}
1322
1323template <BlenMod iBM, Bool bBitInc> __inline Int
1324TRenSingleModelC<iBM,bBitInc>::xRangeRightR( Int iPos )
1325{
1326  return iPos >> m_iShiftPrec;
1327}
1328
1329
1330template <BlenMod iBM, Bool bBitInc> __inline Int
1331TRenSingleModelC<iBM,bBitInc>::xRoundL( Int iPos )
1332{
1333  return  (iPos + (( 1 << m_iShiftPrec ) >> 1 )) >> m_iShiftPrec;
1334}
1335
1336template <BlenMod iBM, Bool bBitInc> __inline Int
1337TRenSingleModelC<iBM,bBitInc>::xRoundR( Int iPos )
1338{
1339  return  (m_iShiftPrec == 0) ? iPos : xRoundL(iPos - 1);
1340}
1341
1342
1343template <BlenMod iBM, Bool bBitInc> Void
1344TRenSingleModelC<iBM,bBitInc>::xSetPels( Pel* piPelSource , Int iSourceStride, Int iWidth, Int iHeight, Pel iVal )
1345{
1346  for (Int iYPos = 0; iYPos < iHeight; iYPos++)
1347  {
1348    for (Int iXPos = 0; iXPos < iWidth; iXPos++)
1349    {
1350      piPelSource[iXPos] = iVal;
1351    }
1352    piPelSource += iSourceStride;
1353  }
1354}
1355
1356template <BlenMod iBM, Bool bBitInc> Void
1357TRenSingleModelC<iBM,bBitInc>::xSetInts( Int* piPelSource , Int iSourceStride, Int iWidth, Int iHeight, Int iVal )
1358{
1359  for (Int iYPos = 0; iYPos < iHeight; iYPos++)
1360  {
1361    for (Int iXPos = 0; iXPos < iWidth; iXPos++)
1362    {
1363      piPelSource[iXPos] = iVal;
1364    }
1365    piPelSource += iSourceStride;
1366  }
1367}
1368
1369
1370template <BlenMod iBM, Bool bBitInc> Void
1371TRenSingleModelC<iBM,bBitInc>::xSetBools( Bool* pbPelSource , Int iSourceStride, Int iWidth, Int iHeight, Bool bVal )
1372{
1373  for (Int iYPos = 0; iYPos < iHeight; iYPos++)
1374  {
1375    for (Int iXPos = 0; iXPos < iWidth; iXPos++)
1376    {
1377      pbPelSource[iXPos] = bVal;
1378    }
1379    pbPelSource += iSourceStride;
1380  }
1381}
1382
1383template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1384TRenSingleModelC<iBM,bBitInc>::xSetShiftedPelL(Int iSourcePos, Int iSubSourcePos, Int iTargetSPos, Pel iFilled, RMDist& riError )
1385{
1386  RM_AOT( iSourcePos    <  0                   );
1387  RM_AOT( iSourcePos    >= m_iWidth            );
1388  RM_AOT( iSubSourcePos < 0                    );
1389  RM_AOT( iSubSourcePos >  (1 << m_iShiftPrec) );
1390  RM_AOT( iTargetSPos   < 0                    );
1391  RM_AOT( iTargetSPos   >= m_iWidth            ); 
1392
1393  RenModelOutPels* pcOutSample = m_pcOutputSamplesRow              + iTargetSPos;
1394  RenModelInPels * pcInSample  = m_pcInputSamplesRow[VIEWPOS_LEFT] + iSourcePos ;
1395
1396  if ( iBM != BLEND_NONE )
1397  {
1398    xSetShiftedPelBlendL<bSet>  (pcInSample, iSubSourcePos, pcOutSample, iFilled, riError);
1399  }
1400  else
1401  {
1402    xSetShiftedPelNoBlendL<bSet>(pcInSample, iSubSourcePos, pcOutSample, iFilled, riError);
1403  }
1404}
1405
1406template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1407TRenSingleModelC<iBM,bBitInc>::xSetShiftedPelNoBlendL(RenModelInPels* pcInSample, Int iSubSourcePos, RenModelOutPels* pcOutSample, Pel iFilled, RMDist& riError )
1408{
1409  if ( bSet )
1410  { 
1411    // Filled
1412    pcOutSample->iFilledLeft = iFilled;
1413
1414    // Yuv
1415    pcOutSample->iYLeft  = pcInSample->aiY[iSubSourcePos];
1416#if H_3D_VSO_COLOR_PLANES
1417    pcOutSample->iULeft  = pcInSample->aiU[iSubSourcePos];
1418    pcOutSample->iVLeft  = pcInSample->aiV[iSubSourcePos];
1419
1420    pcOutSample->iError = xGetDist( pcOutSample->iYLeft - pcOutSample->iYRef,
1421                                    pcOutSample->iULeft - pcOutSample->iURef,   
1422                                    pcOutSample->iVLeft - pcOutSample->iVRef
1423                                  );   
1424#else
1425    pcOutSample->iError = xGetDist( pcOutSample->iYLeft - pcOutSample->iYRef );   
1426#endif   
1427   
1428  }
1429  else
1430  { 
1431#if H_3D_VSO_COLOR_PLANES
1432    riError += xGetDist( pcInSample->aiY[iSubSourcePos] - pcOutSample->iYRef,
1433                         pcInSample->aiU[iSubSourcePos] - pcOutSample->iURef,
1434                         pcInSample->aiV[iSubSourcePos] - pcOutSample->iVRef
1435                       );
1436#else               
1437    riError += xGetDist( pcInSample->aiY[iSubSourcePos] - pcOutSample->iYRef );
1438#endif
1439
1440    riError -= pcOutSample->iError;
1441  }
1442}
1443
1444template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1445TRenSingleModelC<iBM,bBitInc>::xSetShiftedPelBlendL(RenModelInPels* pcInSample, Int iSubSourcePos, RenModelOutPels* pcOutSample, Pel iFilled, RMDist& riError )
1446{
1447  Pel piBlendedValueY;
1448#if H_3D_VSO_COLOR_PLANES
1449  Pel piBlendedValueU;
1450  Pel piBlendedValueV;
1451#endif
1452
1453  xGetBlendedValue (
1454    pcInSample ->aiY[iSubSourcePos],
1455    pcOutSample->iYRight,   
1456#if H_3D_VSO_COLOR_PLANES
1457    pcInSample ->aiU[iSubSourcePos],
1458    pcOutSample->iURight,   
1459    pcInSample ->aiV[iSubSourcePos],
1460    pcOutSample->iVRight,   
1461#endif
1462    m_piInvZLUTLeft [RenModRemoveBitInc(m_iThisDepth)        ],
1463    m_piInvZLUTRight[RenModRemoveBitInc(pcOutSample->iDRight)],
1464    iFilled,
1465    pcOutSample->iFilledRight  ,
1466    piBlendedValueY
1467#if H_3D_VSO_COLOR_PLANES
1468    , piBlendedValueU,
1469    piBlendedValueV
1470#endif
1471    );
1472
1473  if ( bSet )
1474  {   
1475    // Set values
1476    pcOutSample->iDLeft      = m_iThisDepth;
1477    pcOutSample->iYLeft      = pcInSample ->aiY[iSubSourcePos];
1478    pcOutSample->iYBlended   = piBlendedValueY;   
1479#if H_3D_VSO_COLOR_PLANES 
1480    pcOutSample->iULeft      = pcInSample ->aiU[iSubSourcePos];
1481    pcOutSample->iUBlended   = piBlendedValueU;   
1482    pcOutSample->iVLeft      = pcInSample ->aiV[iSubSourcePos];
1483    pcOutSample->iVBlended   = piBlendedValueV;   
1484#endif
1485    pcOutSample->iFilledLeft = iFilled;
1486
1487    // Get Error
1488    Int iDiffY = pcOutSample->iYRef - piBlendedValueY;
1489#if H_3D_VSO_COLOR_PLANES
1490    Int iDiffU = pcOutSample->iURef - piBlendedValueU;
1491    Int iDiffV = pcOutSample->iVRef - piBlendedValueV;
1492    pcOutSample->iError  = xGetDist(iDiffY, iDiffU, iDiffV );
1493#else
1494    pcOutSample->iError  = xGetDist(iDiffY );
1495#endif
1496  }
1497  else
1498  {
1499    Int iDiffY = pcOutSample->iYRef - piBlendedValueY;
1500#if H_3D_VSO_COLOR_PLANES
1501    Int iDiffU = pcOutSample->iURef - piBlendedValueU;
1502    Int iDiffV = pcOutSample->iVRef - piBlendedValueV;
1503    riError   += ( xGetDist( iDiffY, iDiffU, iDiffV ) - pcOutSample->iError );
1504
1505#else
1506    riError   += ( xGetDist( iDiffY ) - pcOutSample->iError  );
1507#endif
1508
1509  }
1510}
1511
1512
1513template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1514TRenSingleModelC<iBM,bBitInc>::xSetShiftedPelR(Int iSourcePos, Int iSubSourcePos, Int iTargetSPos, Pel iFilled, RMDist& riError )
1515{
1516  RM_AOT( iSourcePos    <  0                     );
1517  RM_AOT( iSourcePos    >= m_iWidth              );
1518  RM_AOT( iSubSourcePos <  0                     );
1519  RM_AOT( iSubSourcePos >= (1 << m_iShiftPrec)+1 );
1520  RM_AOT( iTargetSPos   < 0                      );
1521  RM_AOT( iTargetSPos   >= m_iWidth              ); 
1522
1523  RenModelOutPels* pcOutSample = m_pcOutputSamplesRow               + iTargetSPos;
1524  RenModelInPels * pcInSample  = m_pcInputSamplesRow[VIEWPOS_RIGHT] + iSourcePos ;
1525
1526  if ( iBM != BLEND_NONE )
1527  {
1528    xSetShiftedPelBlendR<bSet>   (pcInSample, iSubSourcePos, pcOutSample, iFilled, riError);
1529  }
1530  else
1531  {
1532    xSetShiftedPelNoBlendR<bSet> (pcInSample, iSubSourcePos, pcOutSample, iFilled, riError);
1533  }
1534}
1535
1536template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1537TRenSingleModelC<iBM,bBitInc>::xSetShiftedPelNoBlendR(RenModelInPels* pcInSample, Int iSubSourcePos, RenModelOutPels* pcOutSample, Pel iFilled, RMDist& riError )
1538{
1539  if ( bSet )
1540  { 
1541    // Filled
1542    pcOutSample->iFilledRight = iFilled;
1543
1544    // Yuv
1545    pcOutSample->iYRight  = pcInSample->aiY[iSubSourcePos];
1546#if H_3D_VSO_COLOR_PLANES
1547    pcOutSample->iURight  = pcInSample->aiU[iSubSourcePos];
1548    pcOutSample->iVRight  = pcInSample->aiV[iSubSourcePos];
1549
1550    pcOutSample->iError = xGetDist( 
1551      pcOutSample->iYRight - pcOutSample->iYRef,
1552      pcOutSample->iURight - pcOutSample->iURef,   
1553      pcOutSample->iVRight - pcOutSample->iVRef
1554      );   
1555#else
1556    pcOutSample->iError = xGetDist( pcOutSample->iYRight - pcOutSample->iYRef );   
1557#endif   
1558
1559  }
1560  else
1561  { 
1562#if H_3D_VSO_COLOR_PLANES
1563    riError += xGetDist( pcInSample->aiY[iSubSourcePos] - pcOutSample->iYRef,
1564      pcInSample->aiU[iSubSourcePos] - pcOutSample->iURef,
1565      pcInSample->aiV[iSubSourcePos] - pcOutSample->iVRef
1566      );
1567#else               
1568    riError += xGetDist( pcInSample->aiY[iSubSourcePos] - pcOutSample->iYRef );
1569#endif
1570
1571    riError -= pcOutSample->iError;
1572  }
1573}
1574
1575template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
1576TRenSingleModelC<iBM,bBitInc>::xSetShiftedPelBlendR(RenModelInPels* pcInSample, Int iSubSourcePos, RenModelOutPels* pcOutSample, Pel iFilled, RMDist& riError )
1577{
1578  Pel piBlendedValueY;
1579#if H_3D_VSO_COLOR_PLANES
1580  Pel piBlendedValueU;
1581  Pel piBlendedValueV;
1582#endif
1583
1584  xGetBlendedValue (
1585    pcOutSample->iYLeft, 
1586    pcInSample ->aiY[iSubSourcePos],       
1587#if H_3D_VSO_COLOR_PLANES
1588    pcOutSample->iULeft,   
1589    pcInSample ->aiU[iSubSourcePos],
1590    pcOutSample->iVLeft,   
1591    pcInSample ->aiV[iSubSourcePos],
1592#endif
1593    m_piInvZLUTLeft  [RenModRemoveBitInc(pcOutSample->iDLeft)],
1594    m_piInvZLUTRight [RenModRemoveBitInc(m_iThisDepth)       ],
1595    pcOutSample->iFilledLeft,
1596    iFilled,
1597    piBlendedValueY
1598#if H_3D_VSO_COLOR_PLANES
1599    , piBlendedValueU,
1600    piBlendedValueV
1601#endif
1602    );
1603
1604  if ( bSet )
1605  {   
1606    // Set values
1607    pcOutSample->iDRight     = m_iThisDepth;
1608    pcOutSample->iYRight     = pcInSample ->aiY[iSubSourcePos];
1609    pcOutSample->iYBlended   = piBlendedValueY;   
1610#if H_3D_VSO_COLOR_PLANES 
1611    pcOutSample->iURight     = pcInSample ->aiU[iSubSourcePos];
1612    pcOutSample->iUBlended   = piBlendedValueU;   
1613    pcOutSample->iVRight     = pcInSample ->aiV[iSubSourcePos];
1614    pcOutSample->iVBlended   = piBlendedValueV;   
1615#endif
1616    pcOutSample->iFilledRight = iFilled;
1617
1618    // Get Error
1619    Int iDiffY = pcOutSample->iYRef - piBlendedValueY;
1620#if H_3D_VSO_COLOR_PLANES
1621    Int iDiffU = pcOutSample->iURef - piBlendedValueU;
1622    Int iDiffV = pcOutSample->iVRef - piBlendedValueV;
1623    pcOutSample->iError  = xGetDist(iDiffY, iDiffU, iDiffV );
1624#else
1625    pcOutSample->iError  = xGetDist(iDiffY );
1626#endif
1627  }
1628  else
1629  {
1630    Int iDiffY = pcOutSample->iYRef - piBlendedValueY;
1631#if H_3D_VSO_COLOR_PLANES
1632    Int iDiffU = pcOutSample->iURef - piBlendedValueU;
1633    Int iDiffV = pcOutSample->iVRef - piBlendedValueV;
1634    riError   += ( xGetDist( iDiffY, iDiffU, iDiffV ) - pcOutSample->iError );
1635#else
1636    riError   += ( xGetDist( iDiffY ) -  pcOutSample->iError  );
1637#endif
1638  }
1639}
1640
1641template <BlenMod iBM, Bool bBitInc> __inline Int
1642TRenSingleModelC<iBM,bBitInc>::xGetDist( Int iDiffY, Int iDiffU, Int iDiffV )
1643{
1644
1645  if ( !bBitInc )
1646  {
1647    return (          (iDiffY * iDiffY )
1648               +  ((( (iDiffU * iDiffU )
1649                     +(iDiffV * iDiffV )
1650                    )
1651                   ) >> 2
1652                  )
1653           );
1654  }
1655  else
1656  {
1657    return (          ((iDiffY * iDiffY) >> m_iDistShift)
1658               +  ((( ((iDiffU * iDiffU) >> m_iDistShift)
1659                     +((iDiffV * iDiffV) >> m_iDistShift)
1660                    )
1661                   ) >> 2
1662                  )
1663           );
1664 
1665  }
1666}
1667
1668template <BlenMod iBM, Bool bBitInc> __inline Int
1669TRenSingleModelC<iBM,bBitInc>::xGetDist( Int iDiffY )
1670{
1671  if ( !bBitInc )
1672  {
1673    return (iDiffY * iDiffY);
1674  }
1675  else
1676  {
1677    return ((iDiffY * iDiffY) >> m_iDistShift);
1678  }
1679
1680}
1681
1682
1683#if H_3D_VSO_COLOR_PLANES
1684template <BlenMod iBM, Bool bBitInc>  __inline Void
1685TRenSingleModelC<iBM,bBitInc>::xGetBlendedValue( Pel iYL, Pel iYR, Pel iUL, Pel iUR, Pel iVL, Pel iVR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY, Pel& riU, Pel&riV )
1686#else
1687template <BlenMod iBM, Bool bBitInc>  __inline Void
1688TRenSingleModelC<iBM,bBitInc>::xGetBlendedValue( Pel iYL, Pel iYR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY )
1689#endif
1690{
1691
1692  RM_AOT( iBM != BLEND_AVRG && iBM != BLEND_LEFT && iBM != BLEND_RIGHT );
1693
1694  if (iBM != BLEND_AVRG )
1695  {
1696    if (iBM == BLEND_LEFT )
1697    {
1698#if H_3D_VSO_COLOR_PLANES
1699      xGetBlendedValueBM1(  iYL,  iYR,  iUL,  iUR,  iVL,  iVR,  iDepthL,  iDepthR,  iFilledL,  iFilledR,  riY,  riU, riV );
1700#else
1701      xGetBlendedValueBM1(  iYL,  iYR,  iDepthL,  iDepthR,  iFilledL,  iFilledR,  riY );
1702#endif
1703    }
1704    else
1705    {
1706#if H_3D_VSO_COLOR_PLANES
1707      xGetBlendedValueBM2(  iYL,  iYR,  iUL,  iUR,  iVL,  iVR,  iDepthL,  iDepthR,  iFilledL,  iFilledR,  riY,  riU, riV );
1708#else
1709      xGetBlendedValueBM2(  iYL,  iYR, iDepthL,  iDepthR,  iFilledL,  iFilledR,  riY );
1710#endif
1711    }
1712    return;
1713  }
1714
1715  if (  (iFilledL != REN_IS_HOLE ) && ( iFilledR != REN_IS_HOLE) )
1716  {
1717    Int iDepthDifference = iDepthR - iDepthL;
1718
1719    if ( abs ( iDepthDifference ) <= m_iBlendZThres )
1720    {
1721      if      ((iFilledL == REN_IS_FILLED) && ( iFilledR != REN_IS_FILLED))
1722      {
1723        riY = xBlend( iYL, iYR, iFilledR >> 1 );
1724#if H_3D_VSO_COLOR_PLANES
1725        riU = xBlend( iUL, iUR, iFilledR >> 1 );
1726        riV = xBlend( iVL, iVR, iFilledR >> 1 );
1727#endif
1728
1729      }
1730      else if ((iFilledL != REN_IS_FILLED) && ( iFilledR == REN_IS_FILLED))
1731      {
1732        riY = xBlend( iYR, iYL, (iFilledL >> 1) );
1733#if H_3D_VSO_COLOR_PLANES
1734        riU = xBlend( iUR, iUL, (iFilledL >> 1) );
1735        riV = xBlend( iVR, iVL, (iFilledL >> 1) );
1736#endif
1737      }
1738      else
1739      {
1740        riY = xBlend( iYL, iYR, m_iBlendDistWeight );
1741#if H_3D_VSO_COLOR_PLANES   
1742        riU = xBlend( iUL, iUR, m_iBlendDistWeight );
1743        riV = xBlend( iVL, iVR, m_iBlendDistWeight );
1744#endif
1745      }
1746    }
1747    else if ( iDepthDifference < 0 )
1748    {
1749      riY = iYL;
1750#if H_3D_VSO_COLOR_PLANES
1751      riU = iUL;
1752      riV = iVL;
1753#endif
1754    }
1755    else
1756    {
1757      riY = iYR;
1758#if H_3D_VSO_COLOR_PLANES
1759      riU = iUR;
1760      riV = iVR;
1761#endif
1762    }
1763  }
1764  else if ( (iFilledL == REN_IS_HOLE) && (iFilledR == REN_IS_HOLE))
1765  {
1766    if ( iDepthR < iDepthL )
1767    {
1768        riY =  iYR;
1769#if H_3D_VSO_COLOR_PLANES
1770        riU =  iUR;
1771        riV =  iVR;
1772#endif
1773    }
1774    else
1775    {
1776        riY =  iYL;
1777#if H_3D_VSO_COLOR_PLANES
1778        riU =  iUL;
1779        riV =  iVL;
1780#endif
1781    }
1782  }
1783  else
1784  {
1785    if (iFilledR == REN_IS_HOLE)
1786    {
1787        riY = iYL;
1788#if H_3D_VSO_COLOR_PLANES
1789        riU = iUL;
1790        riV = iVL;
1791#endif
1792    }
1793    else
1794    {
1795      riY = iYR;
1796#if H_3D_VSO_COLOR_PLANES
1797      riU = iUR;
1798      riV = iVR;
1799#endif
1800    }
1801  }
1802}
1803
1804template <BlenMod iBM, Bool bBitInc> __inline Void
1805#if H_3D_VSO_COLOR_PLANES
1806TRenSingleModelC<iBM,bBitInc>::xGetBlendedValueBM1( Pel iYL, Pel iYR, Pel iUL, Pel iUR, Pel iVL, Pel iVR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY, Pel& riU, Pel&riV )
1807#else
1808TRenSingleModelC<iBM,bBitInc>::xGetBlendedValueBM1( Pel iYL, Pel iYR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY )
1809#endif
1810{
1811  if ( iFilledL == REN_IS_FILLED ||  iFilledR == REN_IS_HOLE )
1812  {
1813    riY = iYL;
1814#if H_3D_VSO_COLOR_PLANES
1815    riU = iUL;
1816    riV = iVL;
1817#endif
1818  }
1819  else if ( iFilledL == REN_IS_HOLE  )
1820  {
1821    riY = iYR;
1822#if H_3D_VSO_COLOR_PLANES
1823    riU = iUR;
1824    riV = iVR;
1825#endif
1826  }
1827  else
1828  {
1829    riY = xBlend( iYR, iYL, iFilledL );
1830#if H_3D_VSO_COLOR_PLANES
1831    riU = xBlend( iUR, iUL, iFilledL );
1832    riV = xBlend( iVR, iUL, iFilledL );
1833#endif
1834  }
1835}
1836
1837template <BlenMod iBM, Bool bBitInc> __inline Void
1838#if H_3D_VSO_COLOR_PLANES
1839TRenSingleModelC<iBM,bBitInc>::xGetBlendedValueBM2( Pel iYL, Pel iYR, Pel iUL, Pel iUR, Pel iVL, Pel iVR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY, Pel& riU, Pel&riV )
1840#else
1841TRenSingleModelC<iBM,bBitInc>::xGetBlendedValueBM2( Pel iYL, Pel iYR, Pel iDepthL, Pel iDepthR, Int iFilledL, Int iFilledR, Pel& riY )
1842#endif
1843{
1844  if      ( iFilledR == REN_IS_FILLED ||  iFilledL == REN_IS_HOLE )
1845  {
1846    riY = iYR;
1847#if H_3D_VSO_COLOR_PLANES
1848    riU = iUR;
1849    riV = iVR;
1850#endif
1851  }
1852  else if ( iFilledR == REN_IS_HOLE  )
1853  {
1854    riY = iYL;
1855#if H_3D_VSO_COLOR_PLANES
1856    riU = iUL;
1857    riV = iVL;
1858#endif
1859  }
1860  else
1861  {
1862    riY = xBlend( iYL, iYR, iFilledR );
1863#if H_3D_VSO_COLOR_PLANES
1864    riU = xBlend( iUL, iUR, iFilledR );
1865    riV = xBlend( iVL, iUR, iFilledR );
1866#endif
1867  }
1868}
1869
1870template <BlenMod iBM, Bool bBitInc> __inline Pel
1871TRenSingleModelC<iBM,bBitInc>::xBlend( Pel pVal1, Pel pVal2, Int iWeightVal2 )
1872{
1873  return pVal1  +  (Pel) (  ( (Int) ( pVal2 - pVal1) * iWeightVal2 + (1 << (REN_VDWEIGHT_PREC - 1)) ) >> REN_VDWEIGHT_PREC );
1874}
1875
1876template <BlenMod iBM, Bool bBitInc> Void
1877TRenSingleModelC<iBM,bBitInc>::xCopy2PicYuv( Pel** ppiSrcVideoPel, Int* piStrides, TComPicYuv* rpcPicYuvTarget )
1878{
1879  TRenFilter::copy            ( ppiSrcVideoPel[0], piStrides[0], m_iWidth, m_iUsedHeight, rpcPicYuvTarget->getLumaAddr() +  m_iHorOffset       * rpcPicYuvTarget->getStride() , rpcPicYuvTarget->getStride () );
1880  TRenFilter::sampleDown2Tap13( ppiSrcVideoPel[1], piStrides[1], m_iWidth, m_iUsedHeight, rpcPicYuvTarget->getCbAddr  () + (m_iHorOffset >> 1) * rpcPicYuvTarget->getCStride(), rpcPicYuvTarget->getCStride() );
1881  TRenFilter::sampleDown2Tap13( ppiSrcVideoPel[2], piStrides[2], m_iWidth, m_iUsedHeight, rpcPicYuvTarget->getCrAddr  () + (m_iHorOffset >> 1) * rpcPicYuvTarget->getCStride(), rpcPicYuvTarget->getCStride() );
1882}
1883
1884template class TRenSingleModelC<BLEND_NONE ,true>;
1885template class TRenSingleModelC<BLEND_AVRG ,true>;
1886template class TRenSingleModelC<BLEND_LEFT ,true>;
1887template class TRenSingleModelC<BLEND_RIGHT,true>;
1888
1889template class TRenSingleModelC<BLEND_NONE ,false>;
1890template class TRenSingleModelC<BLEND_AVRG ,false>;
1891template class TRenSingleModelC<BLEND_LEFT ,false>;
1892template class TRenSingleModelC<BLEND_RIGHT,false>;
1893
1894#if H_3D_VSO_EARLY_SKIP
1895template <BlenMod iBM, Bool bBitInc> 
1896__inline Bool
1897TRenSingleModelC<iBM,bBitInc>::xDetectEarlySkipL( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData,Pel* piOrgData, Int iOrgStride)
1898{
1899  RM_AOF( m_bEarlySkip ); 
1900  const Int iCurViewPos = 0;
1901  Int** ppiCurLUT       = m_appiShiftLut   [ iCurViewPos ];
1902 
1903  Bool bNoDiff          = true;   
1904 
1905  for (Int iPosY=0; iPosY < iHeight; iPosY++)
1906  {
1907    m_pbHorSkip[iPosY] = true;
1908
1909    for (Int iPosX = 0; iPosX < iWidth; iPosX++)
1910    {
1911      Int iDisparityRec = abs(ppiCurLUT[0][ RenModRemoveBitInc(piNewData[iPosX])]);
1912      Int iDispartyOrg  = abs(ppiCurLUT[0][ RenModRemoveBitInc(piOrgData[iPosX])]);
1913
1914      if( iDispartyOrg != iDisparityRec)
1915      {
1916        m_pbHorSkip[iPosY] = false;
1917        bNoDiff            = false;
1918        break;
1919      }
1920    }
1921    piNewData += iStride;
1922    piOrgData += iOrgStride;
1923  }
1924  return bNoDiff;
1925}
1926
1927template <BlenMod iBM, Bool bBitInc> 
1928__inline Bool
1929TRenSingleModelC<iBM,bBitInc>::xDetectEarlySkipR( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData,Pel* piOrgData, Int iOrgStride)
1930{
1931  RM_AOF( m_bEarlySkip ); 
1932  Bool bNoDiff  = true;
1933
1934  const Int iCurViewPos = 1;
1935  Int** ppiCurLUT       = m_appiShiftLut   [ iCurViewPos ];
1936
1937  for ( Int iPosY = 0; iPosY < iHeight; iPosY++ )
1938  {
1939    m_pbHorSkip[iPosY] = true;
1940
1941    for (Int iPosX = 0; iPosX < iWidth; iPosX++)
1942    {
1943      Int iDisparityRec = abs( ppiCurLUT[0][ RenModRemoveBitInc(piNewData[iPosX])] );
1944      Int iDisparityOrg = abs( ppiCurLUT[0][ RenModRemoveBitInc(piOrgData[iPosX])] );
1945
1946      if( iDisparityRec != iDisparityOrg )
1947      {
1948        m_pbHorSkip[iPosY] = false;
1949        bNoDiff            = false;
1950        break;
1951      }
1952    }
1953
1954    piNewData += iStride;
1955    piOrgData += iOrgStride;
1956  }
1957  return bNoDiff;
1958}
1959#endif
1960#endif // H_3D
1961
Note: See TracBrowser for help on using the repository browser.