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

Last change on this file since 1413 was 1413, checked in by tech, 6 years ago

Merged HTM-16.2-dev@1412

  • Property svn:eol-style set to native
File size: 50.7 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-2016, 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 NH_3D_VSO
39
40////////////// TRENSINGLE MODEL ///////////////
41template <BlenMod iBM, Bool bBitInc>
42TRenSingleModelC<iBM,bBitInc>::TRenSingleModelC()
43:  m_iDistShift ( ( ENC_INTERNAL_BIT_DEPTH  - REN_BIT_DEPTH) << 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 bLimOutput, Bool bEarlySkip )
119#else
120TRenSingleModelC<iBM,bBitInc>::create( Int iMode, Int iWidth, Int iHeight, Int iShiftPrec, Int*** aaaiSubPelShiftTable, Int iHoleMargin, Bool bUseOrgRef, Int iBlendMode, Bool bLimOutput )
121#endif
122
123{
124  m_bLimOutput = bLimOutput; 
125#if H_3D_VSO_EARLY_SKIP
126  m_pbHorSkip     = new Bool [MAX_CU_SIZE];
127  m_bEarlySkip    = bEarlySkip; 
128#endif
129
130  AOF( ( iBlendMode == iBM ) || ( iBM == BLEND_NONE ) ); 
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  m_pcLimOutputSamples    = m_bLimOutput ? new RenModelLimOutPels[m_iOutputSamplesStride*m_iHeight] : NULL;
175}
176
177template <BlenMod iBM, Bool bBitInc> Void
178TRenSingleModelC<iBM,bBitInc>::setLRView( Int iViewPos, Pel** apiCurVideoPel, Int* aiCurVideoStride, Pel* piCurDepthPel, Int iCurDepthStride )
179{
180  AOF(( iViewPos == 0) || (iViewPos == 1) );
181
182  RenModelInPels* pcCurInputSampleRow = m_pcInputSamples[iViewPos];
183 
184  Pel* piDRow = piCurDepthPel;
185  Pel* piYRow = apiCurVideoPel[0];
186#if H_3D_VSO_COLOR_PLANES
187  Pel* piURow = apiCurVideoPel[1];
188  Pel* piVRow = apiCurVideoPel[2];
189#endif 
190
191
192  Int iOffsetX = ( iViewPos == VIEWPOS_RIGHT ) ? 1 : 0;
193
194  for ( Int iPosY = 0; iPosY < m_iUsedHeight; iPosY++ )
195  {
196    if ( iViewPos == VIEWPOS_RIGHT )
197    {
198      Int iSubPosX = (1 << m_iShiftPrec); 
199      pcCurInputSampleRow[0].aiY[iSubPosX] = piYRow[0];
200#if H_3D_VSO_COLOR_PLANES
201      pcCurInputSampleRow[0].aiU[iSubPosX] = piURow[0];
202      pcCurInputSampleRow[0].aiV[iSubPosX] = piVRow[0];
203#endif
204    }
205
206    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
207    {
208      pcCurInputSampleRow[iPosX].iD = piDRow[iPosX];
209
210      for (Int iSubPosX = 0; iSubPosX < (1 << m_iShiftPrec)+1; iSubPosX++ )
211      { 
212        Int iShift = (iPosX << m_iShiftPrec) + iSubPosX;
213        pcCurInputSampleRow[iPosX+iOffsetX].aiY[iSubPosX] = piYRow[iShift];
214#if H_3D_VSO_COLOR_PLANES
215        pcCurInputSampleRow[iPosX+iOffsetX].aiU[iSubPosX] = piURow[iShift];
216        pcCurInputSampleRow[iPosX+iOffsetX].aiV[iSubPosX] = piVRow[iShift];
217#endif
218      }
219    } 
220
221    pcCurInputSampleRow += m_iInputSamplesStride; 
222
223    piDRow += iCurDepthStride;
224    piYRow += aiCurVideoStride[0];
225#if H_3D_VSO_COLOR_PLANES
226    piURow += aiCurVideoStride[1];
227    piVRow += aiCurVideoStride[2];
228#endif
229  }
230
231 
232  m_aapiBaseVideoPel      [iViewPos] = apiCurVideoPel;
233  m_aaiBaseVideoStrides   [iViewPos] = aiCurVideoStride;
234  m_apiBaseDepthPel       [iViewPos] = piCurDepthPel;
235  m_aiBaseDepthStrides    [iViewPos] = iCurDepthStride;
236
237}
238template <BlenMod iBM, Bool bBitInc> Void
239TRenSingleModelC<iBM,bBitInc>::setupPart ( UInt uiHorOffset,       Int iUsedHeight )
240{
241  AOT( iUsedHeight > m_iHeight );   
242
243  m_iUsedHeight =       iUsedHeight; 
244  m_iHorOffset  = (Int) uiHorOffset;
245}
246
247
248template <BlenMod iBM, Bool bBitInc> Void
249  TRenSingleModelC<iBM,bBitInc>::setupRefView      ( TComPicYuv* pcOrgVideo )
250{
251  m_pcPicYuvRef = pcOrgVideo;
252  // Use provided ref view reference
253 
254  TRenFilter<REN_BIT_DEPTH>::copy(             pcOrgVideo->getAddr( COMPONENT_Y  ) +  m_iHorOffset       * pcOrgVideo->getStride( COMPONENT_Y  ), pcOrgVideo->getStride( COMPONENT_Y  ), m_iWidth,      m_iUsedHeight,      m_aapiRefVideoPel[0], m_aiRefVideoStrides[0]);
255  switch ( pcOrgVideo->getChromaFormat() )
256  {
257  case CHROMA_420:
258    TRenFilter<REN_BIT_DEPTH>::sampleCUpHorUp(0, pcOrgVideo->getAddr( COMPONENT_Cb ) + (m_iHorOffset >> 1) * pcOrgVideo->getStride( COMPONENT_Cb ), pcOrgVideo->getStride( COMPONENT_Cb ), m_iWidth >> 1, m_iUsedHeight >> 1, m_aapiRefVideoPel[1], m_aiRefVideoStrides[1]);
259    TRenFilter<REN_BIT_DEPTH>::sampleCUpHorUp(0, pcOrgVideo->getAddr( COMPONENT_Cr ) + (m_iHorOffset >> 1) * pcOrgVideo->getStride( COMPONENT_Cr ), pcOrgVideo->getStride( COMPONENT_Cr ), m_iWidth >> 1, m_iUsedHeight >> 1, m_aapiRefVideoPel[2], m_aiRefVideoStrides[2]);
260    break;
261  case CHROMA_444:
262    TRenFilter<REN_BIT_DEPTH>::copy(             pcOrgVideo->getAddr( COMPONENT_Cb  ) +  m_iHorOffset       * pcOrgVideo->getStride( COMPONENT_Cb  ), pcOrgVideo->getStride( COMPONENT_Cb  ), m_iWidth,      m_iUsedHeight,      m_aapiRefVideoPel[1], m_aiRefVideoStrides[1]);
263    TRenFilter<REN_BIT_DEPTH>::copy(             pcOrgVideo->getAddr( COMPONENT_Cr  ) +  m_iHorOffset       * pcOrgVideo->getStride( COMPONENT_Cr  ), pcOrgVideo->getStride( COMPONENT_Cr  ), m_iWidth,      m_iUsedHeight,      m_aapiRefVideoPel[2], m_aiRefVideoStrides[2]);
264    break;
265  default:
266    break; 
267  }
268  xSetStructRefView();
269}
270
271
272template <BlenMod iBM, Bool bBitInc> Void
273  TRenSingleModelC<iBM,bBitInc>::setupLut( Int** ppiShiftLutLeft, Int** ppiBaseShiftLutLeft, Int** ppiShiftLutRight,  Int** ppiBaseShiftLutRight,  Int iDistToLeft )
274{
275  AOT( (ppiShiftLutLeft  == NULL) && (m_iMode == 0 || m_iMode == 2) );
276  AOT( (ppiShiftLutRight == NULL) && (m_iMode == 1 || m_iMode == 2) );
277
278  m_appiShiftLut[0] = ppiShiftLutLeft;
279  m_appiShiftLut[1] = ppiShiftLutRight;
280
281
282  if ( m_iMode == 2 )
283  {
284    TRenFilter<REN_BIT_DEPTH>::setupZLUT( true, 30, iDistToLeft, ppiBaseShiftLutLeft, ppiBaseShiftLutRight, m_iBlendZThres, m_iBlendDistWeight, m_piInvZLUTLeft, m_piInvZLUTRight );
285  }
286}
287
288template <BlenMod iBM, Bool bBitInc> Void
289TRenSingleModelC<iBM,bBitInc>::renderAll( )
290{
291  // Initial Rendering
292  resetStructError();
293  xInitSampleStructs();
294  switch ( m_iMode )
295  { 
296  case 0:   
297#if H_3D_VSO_EARLY_SKIP
298    xRender<true, SET_FULL>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0],false );
299#else
300    xRender<true, SET_FULL>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0] );
301#endif   
302    break;
303  case 1:   
304#if H_3D_VSO_EARLY_SKIP
305    xRender<false, SET_FULL>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1],false);
306#else
307    xRender<false, SET_FULL>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1] );
308#endif
309    break;
310  case 2:
311#if H_3D_VSO_EARLY_SKIP
312    xRender<true , SET_FULL>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0],false);
313    xRender<false, SET_FULL>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1],false);
314#else     
315    xRender<true,  SET_FULL>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[0], m_apiBaseDepthPel[0] );
316    xRender<false, SET_FULL>( 0, 0, m_iWidth, m_iUsedHeight, m_aiBaseDepthStrides[1], m_apiBaseDepthPel[1] );
317#endif
318    break;
319  default:
320    AOT(true);
321  }
322}
323
324template <BlenMod iBM, Bool bBitInc> Void
325#if H_3D_VSO_COLOR_PLANES
326TRenSingleModelC<iBM,bBitInc>::xGetSampleStrTextPtrs( Int iViewNum, Pel RenModelOutPels::*& rpiSrcY, Pel RenModelOutPels::*& rpiSrcU, Pel RenModelOutPels::*& rpiSrcV )
327#else
328TRenSingleModelC<iBM,bBitInc>::xGetSampleStrTextPtrs( Int iViewNum, Pel RenModelOutPels::*& rpiSrcY )
329#endif
330{
331  switch ( iViewNum )
332  {
333
334  case -1: 
335    rpiSrcY = &RenModelOutPels::iYRef;
336#if H_3D_VSO_COLOR_PLANES 
337    rpiSrcU = &RenModelOutPels::iURef;
338    rpiSrcV = &RenModelOutPels::iVRef;
339#endif
340    break;
341  case 0:
342    rpiSrcY = &RenModelOutPels::iYLeft;
343#if H_3D_VSO_COLOR_PLANES 
344    rpiSrcU = &RenModelOutPels::iULeft;
345    rpiSrcV = &RenModelOutPels::iVLeft;
346#endif
347    break;
348  case 1:
349    rpiSrcY = &RenModelOutPels::iYRight;
350#if H_3D_VSO_COLOR_PLANES 
351    rpiSrcU = &RenModelOutPels::iURight;
352    rpiSrcV = &RenModelOutPels::iVRight;
353#endif
354    break;
355  case 2:
356    rpiSrcY = &RenModelOutPels::iYBlended;
357#if H_3D_VSO_COLOR_PLANES 
358    rpiSrcU = &RenModelOutPels::iUBlended;
359    rpiSrcV = &RenModelOutPels::iVBlended;
360#endif
361    break;
362  }
363}
364
365
366template <BlenMod iBM, Bool bBitInc> Void
367TRenSingleModelC<iBM,bBitInc>::xGetSampleStrDepthPtrs( Int iViewNum, Pel RenModelOutPels::*& rpiSrcD )
368{
369  AOT(iViewNum != 0 && iViewNum != 1); 
370  rpiSrcD = (iViewNum == 1) ? &RenModelOutPels::iDRight : &RenModelOutPels::iDLeft; 
371}
372
373template <BlenMod iBM, Bool bBitInc> Void
374  TRenSingleModelC<iBM,bBitInc>::xGetSampleStrFilledPtrs( Int iViewNum, Int RenModelOutPels::*& rpiSrcFilled )
375{
376  AOT(iViewNum != 0 && iViewNum != 1); 
377  rpiSrcFilled = (iViewNum == 1) ? &RenModelOutPels::iFilledRight : &RenModelOutPels::iFilledLeft; 
378}
379
380
381template <BlenMod iBM, Bool bBitInc> Void
382TRenSingleModelC<iBM,bBitInc>::xSetStructRefView( )
383{
384  RenModelOutPels* pcCurOutSampleRow = m_pcOutputSamples;
385 
386  Pel* piYRow = m_aapiRefVideoPel[0];
387#if H_3D_VSO_COLOR_PLANES
388  Pel* piURow = m_aapiRefVideoPel[1];
389  Pel* piVRow = m_aapiRefVideoPel[2];
390#endif 
391
392  for ( Int iPosY = 0; iPosY < m_iUsedHeight; iPosY++ )
393  {
394    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
395    {     
396      pcCurOutSampleRow[iPosX].iYRef = piYRow[iPosX];
397#if H_3D_VSO_COLOR_PLANES
398      pcCurOutSampleRow[iPosX].iURef = piURow[iPosX];
399      pcCurOutSampleRow[iPosX].iVRef = piVRow[iPosX];
400#endif
401    } 
402
403    pcCurOutSampleRow += m_iOutputSamplesStride; 
404   
405    piYRow += m_aiRefVideoStrides[0];
406#if H_3D_VSO_COLOR_PLANES
407    piURow += m_aiRefVideoStrides[1];
408    piVRow += m_aiRefVideoStrides[2];
409#endif
410  }
411}
412
413template <BlenMod iBM, Bool bBitInc> Void
414TRenSingleModelC<iBM,bBitInc>::resetStructError( )
415{
416  RenModelOutPels* pcCurOutSampleRow = m_pcOutputSamples;
417
418  for ( Int iPosY = 0; iPosY < m_iHeight; iPosY++ )
419  {
420    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
421    {     
422      pcCurOutSampleRow[iPosX].iError = 0;
423    } 
424    pcCurOutSampleRow += m_iOutputSamplesStride; 
425  }
426}
427
428template <BlenMod iBM, Bool bBitInc> Void
429  TRenSingleModelC<iBM,bBitInc>::setLimOutStruct(Int iSourceViewPos )
430{ 
431  RM_AOF( m_bLimOutput ); 
432  RM_AOT( iSourceViewPos < 0 || iSourceViewPos > 1);
433
434  RenModelOutPels*    pcCurOutSampleRow    = m_pcOutputSamples;
435  RenModelLimOutPels* pcCurLimOutSampleRow = m_pcLimOutputSamples;
436
437  Int RenModelOutPels::* piFilled = NULL;
438  xGetSampleStrFilledPtrs( iSourceViewPos, piFilled );
439 
440  Pel RenModelOutPels::* piDepth  = NULL;
441  xGetSampleStrDepthPtrs ( iSourceViewPos, piDepth  );
442
443  Pel RenModelOutPels::* piSrcY = NULL;
444 
445#if H_3D_VSO_COLOR_PLANES 
446  Pel RenModelOutPels::* piSrcU = NULL; 
447  Pel RenModelOutPels::* piSrcV = NULL;
448  xGetSampleStrTextPtrs  ( iSourceViewPos, piSrcY, piSrcU, piSrcV );
449#else
450  xGetSampleStrTextPtrs  ( iSourceViewPos, piSrcY );
451#endif
452 
453  for ( Int iPosY = 0; iPosY < m_iUsedHeight; iPosY++ )
454  {
455    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
456    {     
457      pcCurLimOutSampleRow[iPosX].iYOther      = pcCurOutSampleRow[iPosX].*piSrcY;
458      pcCurLimOutSampleRow[iPosX].iYRef        = pcCurOutSampleRow[iPosX].iYRef;
459
460#if H_3D_VSO_COLOR_PLANES     
461      pcCurLimOutSampleRow[iPosX].iUOther      = pcCurOutSampleRow[iPosX].*piSrcU;
462      pcCurLimOutSampleRow[iPosX].iURef        = pcCurOutSampleRow[iPosX].iURef;
463
464      pcCurLimOutSampleRow[iPosX].iVOther      = pcCurOutSampleRow[iPosX].*piSrcV;     
465      pcCurLimOutSampleRow[iPosX].iVRef        = pcCurOutSampleRow[iPosX].iVRef;
466#endif
467      pcCurLimOutSampleRow[iPosX].iDOther      = pcCurOutSampleRow[iPosX].*piDepth;     
468      pcCurLimOutSampleRow[iPosX].iFilledOther = pcCurOutSampleRow[iPosX].*piFilled;     
469      pcCurLimOutSampleRow[iPosX].iError       = pcCurOutSampleRow[iPosX].iError;     
470
471    } 
472    pcCurOutSampleRow    += m_iOutputSamplesStride; 
473    pcCurLimOutSampleRow += m_iOutputSamplesStride; 
474  }
475}
476
477template <BlenMod iBM, Bool bBitInc> Void
478TRenSingleModelC<iBM,bBitInc>::setStructSynthViewAsRefView( )
479{
480  AOT( m_iMode < 0 || m_iMode > 2);
481
482  RenModelOutPels* pcCurOutSampleRow = m_pcOutputSamples;
483
484  Pel RenModelOutPels::* piSrcY = NULL;
485
486#if H_3D_VSO_COLOR_PLANES 
487  Pel RenModelOutPels::* piSrcU = NULL;
488  Pel RenModelOutPels::* piSrcV = NULL;
489  xGetSampleStrTextPtrs( m_iMode, piSrcY, piSrcU, piSrcV );
490#else
491  xGetSampleStrTextPtrs( m_iMode, piSrcY );
492#endif
493
494  for ( Int iPosY = 0; iPosY < m_iUsedHeight; iPosY++ )
495  {
496    for ( Int iPosX = 0; iPosX < m_iWidth; iPosX++ )
497    {     
498      pcCurOutSampleRow[iPosX].iYRef = pcCurOutSampleRow[iPosX].*piSrcY;
499#if H_3D_VSO_COLOR_PLANES
500      pcCurOutSampleRow[iPosX].iURef = pcCurOutSampleRow[iPosX].*piSrcU;
501      pcCurOutSampleRow[iPosX].iVRef = pcCurOutSampleRow[iPosX].*piSrcV;
502#endif
503    } 
504    pcCurOutSampleRow += m_iOutputSamplesStride; 
505  }
506}
507
508template <BlenMod iBM, Bool bBitInc> Void
509TRenSingleModelC<iBM,bBitInc>::xInitSampleStructs()
510{
511  RenModelOutPels* pcOutSampleRow      = m_pcOutputSamples;
512  RenModelInPels * pcLeftInSampleRow   = m_pcInputSamples[0];
513  RenModelInPels * pcRightInSampleRow  = m_pcInputSamples[1];
514
515
516  for (Int iPosY = 0; iPosY < m_iHeight; iPosY++)
517  {
518    for (Int iPosX = 0; iPosX < m_iWidth; iPosX++)
519    {
520      //// Output Samples
521      pcOutSampleRow[iPosX].iFilledLeft   = REN_IS_HOLE;
522      pcOutSampleRow[iPosX].iFilledRight  = REN_IS_HOLE;
523
524      pcOutSampleRow[iPosX].iDLeft        = 0;
525      pcOutSampleRow[iPosX].iDRight       = 0;
526      pcOutSampleRow[iPosX].iDBlended     = 0;     
527      pcOutSampleRow[iPosX].iError        = 0; 
528                                     
529      // Y Planes                   
530      pcOutSampleRow[iPosX].iYLeft        = 0;
531      pcOutSampleRow[iPosX].iYRight       = 0;
532      pcOutSampleRow[iPosX].iYBlended     = 0;
533#if H_3D_VSO_COLOR_PLANES             
534      // U Planes                   
535      pcOutSampleRow[iPosX].iULeft        = 1 << (REN_BIT_DEPTH  - 1);
536      pcOutSampleRow[iPosX].iURight       = 1 << (REN_BIT_DEPTH  - 1);
537      pcOutSampleRow[iPosX].iUBlended     = 1 << (REN_BIT_DEPTH  - 1);
538                                                 
539      // V Planes                                 
540      pcOutSampleRow[iPosX].iVLeft        = 1 << (REN_BIT_DEPTH  - 1);
541      pcOutSampleRow[iPosX].iVRight       = 1 << (REN_BIT_DEPTH  - 1);
542      pcOutSampleRow[iPosX].iVBlended     = 1 << (REN_BIT_DEPTH  - 1);
543#endif
544  //// Input Samples
545      pcLeftInSampleRow [iPosX].aiOccludedPos = MAX_INT;
546      pcRightInSampleRow[iPosX].aiOccludedPos = MIN_INT;
547    }
548
549    pcOutSampleRow     += m_iOutputSamplesStride;
550    pcLeftInSampleRow  += m_iInputSamplesStride;
551    pcRightInSampleRow += m_iInputSamplesStride;
552  } 
553}
554
555
556#if H_3D_VSO_EARLY_SKIP
557template <BlenMod iBM, Bool bBitInc> RMDist
558TRenSingleModelC<iBM,bBitInc>::getDistDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData , const Pel * piOrgData, Int iOrgStride )
559#else
560template <BlenMod iBM, Bool bBitInc> RMDist
561TRenSingleModelC<iBM,bBitInc>::getDistDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData )
562#endif
563{
564  RMDist iSSE = 0;
565#if H_3D_VSO_EARLY_SKIP
566  Bool   bEarlySkip;
567#endif
568  switch ( iViewPos )
569  {
570  case 0:
571#if H_3D_VSO_EARLY_SKIP
572    bEarlySkip = m_bEarlySkip ? xDetectEarlySkip<true>(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData, iOrgStride) : false;
573    if( !bEarlySkip )
574    {
575      iSSE = xRender<true, GET_SIMP>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData,true );
576    }   
577#else
578    iSSE = xRender<true, GET_SIMP>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData );
579#endif
580    break;
581  case 1:
582#if H_3D_VSO_EARLY_SKIP
583    bEarlySkip = m_bEarlySkip ? xDetectEarlySkip<false>(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData, iOrgStride) : false;
584    if( !bEarlySkip )
585    {
586      iSSE = xRender<false, GET_SIMP>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData,true );
587    }   
588#else
589    iSSE = xRender<false, GET_SIMP>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData );
590#endif
591    break;
592  default:
593    assert(0);
594  }
595
596  return iSSE;
597}
598#if H_3D_VSO_EARLY_SKIP
599template <BlenMod iBM, Bool bBitInc> Void
600TRenSingleModelC<iBM,bBitInc>::setDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData, const Pel* piOrgData, Int iOrgStride )
601#else
602template <BlenMod iBM, Bool bBitInc> Void
603TRenSingleModelC<iBM,bBitInc>::setDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData )
604#endif
605{
606#if  H_3D_VSO_EARLY_SKIP
607  Bool bEarlySkip;
608#endif
609  switch ( iViewPos )
610  {
611  case 0:
612#if H_3D_VSO_EARLY_SKIP
613    bEarlySkip = m_bEarlySkip ? xDetectEarlySkip<true>(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData,iOrgStride) : false;
614    if( !bEarlySkip )
615    {
616      xRender<true, SET_SIMP>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData,true );
617    }   
618#else
619    xRender<true, SET_SIMP>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData );
620#endif     
621    break;
622  case 1:
623#if H_3D_VSO_EARLY_SKIP
624    bEarlySkip = m_bEarlySkip ? xDetectEarlySkip<false>(iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData, piOrgData,iOrgStride) : false;
625    if( !bEarlySkip )
626    {
627      xRender<false, SET_SIMP>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData,true ); 
628    }   
629#else
630    xRender<false, SET_SIMP>( iStartPosX,   iStartPosY,   iWidth,   iHeight,   iStride, piNewData );
631#endif     
632    break;
633  default:
634    assert(0);
635  }
636}
637
638template <BlenMod iBM, Bool bBitInc> Void
639TRenSingleModelC<iBM,bBitInc>::getSynthVideo( Int iViewPos, TComPicYuv* pcPicYuv )
640{ 
641  AOT( pcPicYuv->getWidth( COMPONENT_Y  )  != m_iWidth );
642  AOT( pcPicYuv->getChromaFormat()         != CHROMA_420 ); 
643
644  AOT( pcPicYuv->getHeight( COMPONENT_Y ) < m_iUsedHeight + m_iHorOffset );
645
646#if H_3D_VSO_COLOR_PLANES
647  Pel RenModelOutPels::* piText[3] = { NULL, NULL, NULL };
648  xGetSampleStrTextPtrs(iViewPos, piText[0], piText[1], piText[2]); 
649
650  // Temp image for chroma down sampling
651  PelImage cTempImage( m_iWidth, m_iUsedHeight, 3, 0);
652
653  Int  aiStrides[3]; 
654  Pel* apiData  [3]; 
655
656  cTempImage.getDataAndStrides( apiData, aiStrides ); 
657
658  for (UInt uiCurPlane = 0; uiCurPlane < 3; uiCurPlane++ )
659  {
660    xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piText[uiCurPlane], apiData[uiCurPlane], aiStrides[uiCurPlane] , m_iWidth, m_iUsedHeight);
661  } 
662  xCopy2PicYuv( apiData, aiStrides, pcPicYuv );
663#else
664  Pel RenModelOutPels::* piY;
665  xGetSampleStrTextPtrs(iViewPos, piY); 
666  xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piY, pcPicYuv->getAddr(COMPONENT_Y) + m_iHorOffset * pcPicYuv->getStride(COMPONENT_Y), pcPicYuv->getStride(COMPONENT_Y), m_iWidth, m_iUsedHeight );
667  pcPicYuv->setChromaTo( 1 << (REN_BIT_DEPTH - 1) );   
668#endif 
669}
670
671template <BlenMod iBM, Bool bBitInc> Void
672TRenSingleModelC<iBM,bBitInc>::getSynthDepth( Int iViewPos, TComPicYuv* pcPicYuv )
673{ 
674  AOT( iViewPos != 0 && iViewPos != 1); 
675  AOT( pcPicYuv->getWidth( COMPONENT_Y)  != m_iWidth  );
676  AOT( pcPicYuv->getChromaFormat( )  != CHROMA_420 );
677  AOT( pcPicYuv->getHeight( COMPONENT_Y ) < m_iUsedHeight + m_iHorOffset );
678
679  Pel RenModelOutPels::* piD = 0;
680  xGetSampleStrDepthPtrs(iViewPos, piD); 
681  xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piD, pcPicYuv->getAddr( COMPONENT_Y ) + pcPicYuv->getStride( COMPONENT_Y ) * m_iHorOffset, pcPicYuv->getStride( COMPONENT_Y ), m_iWidth, m_iUsedHeight );
682  pcPicYuv->setChromaTo( 1 << (REN_BIT_DEPTH - 1) );   
683}
684
685
686template <BlenMod iBM, Bool bBitInc> Void
687TRenSingleModelC<iBM,bBitInc>::getRefVideo ( Int iViewPos, TComPicYuv* pcPicYuv )
688{ 
689  AOT( pcPicYuv->getChromaFormat( ) != CHROMA_420 );
690  AOT( pcPicYuv->getWidth( COMPONENT_Y )  != m_iWidth  );
691  AOT( pcPicYuv->getHeight( COMPONENT_Y ) <  m_iUsedHeight + m_iHorOffset);
692
693#if H_3D_VSO_COLOR_PLANES
694  Pel RenModelOutPels::* piText[3];
695  piText[0] = &RenModelOutPels::iYRef;
696  piText[1] = &RenModelOutPels::iURef;
697  piText[2] = &RenModelOutPels::iVRef;
698
699  // Temp image for chroma down sampling
700
701  PelImage cTempImage( m_iWidth, m_iUsedHeight, 3, 0);
702  Int  aiStrides[3]; 
703  Pel* apiData  [3]; 
704
705  cTempImage.getDataAndStrides( apiData, aiStrides ); 
706
707  for (UInt uiCurPlane = 0; uiCurPlane < 3; uiCurPlane++ )
708  {
709    xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, piText[uiCurPlane], apiData[uiCurPlane], aiStrides[uiCurPlane] , m_iWidth, m_iUsedHeight);
710  } 
711
712  xCopy2PicYuv( apiData, aiStrides, pcPicYuv );
713#else
714  xCopyFromSampleStruct( m_pcOutputSamples, m_iOutputSamplesStride, &RenModelOutPels::iYRef, pcPicYuv->getAddr(COMPONENT_Y), pcPicYuv->getStride(COMPONENT_Y), m_iWidth, m_iUsedHeight );
715  pcPicYuv->setChromaTo( 1 << ( REN_BIT_DEPTH - 1 ) );   
716#endif 
717}
718
719template <BlenMod iBM, Bool bBitInc> RMDist
720TRenSingleModelC<iBM,bBitInc>::getDistVideo( Int iViewPos, Int iPlane, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData )
721{
722  AOF(false);
723  return 0;
724}
725
726template <BlenMod iBM, Bool bBitInc> Void
727TRenSingleModelC<iBM,bBitInc>::setVideo( Int iViewPos, Int iPlane, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData )
728{
729  AOF(false);
730}
731
732
733
734template <BlenMod iBM, Bool bBitInc> template<SetMod bSM> __inline Void
735TRenSingleModelC<iBM,bBitInc>::xSetViewRow( Int iPosY )
736{
737  m_pcInputSamplesRow[0] = m_pcInputSamples[0] + m_iInputSamplesStride  * iPosY;
738  m_pcInputSamplesRow[1] = m_pcInputSamples[1] + m_iInputSamplesStride  * iPosY;
739  if (bSM == SET_FULL || bSM == GET_FULL )
740  { 
741    m_pcOutputSamplesRow   = m_pcOutputSamples   + m_iOutputSamplesStride * iPosY; 
742  }
743  else
744  {
745    m_pcLimOutputSamplesRow   = m_pcLimOutputSamples  + m_iOutputSamplesStride * iPosY; 
746  }
747}
748
749template <BlenMod iBM, Bool bBitInc> template<SetMod bSM> __inline Void
750TRenSingleModelC<iBM,bBitInc>::xIncViewRow( )
751{
752  m_pcInputSamplesRow[0] += m_iInputSamplesStride ;
753  m_pcInputSamplesRow[1] += m_iInputSamplesStride ;
754 
755  if (bSM == SET_FULL || bSM == GET_FULL )
756  { 
757    m_pcOutputSamplesRow   += m_iOutputSamplesStride;
758  }
759  else
760  {
761    m_pcLimOutputSamplesRow   += m_iOutputSamplesStride;
762  }
763}
764#if H_3D_VSO_EARLY_SKIP
765template <BlenMod iBM, Bool bBitInc> template<SetMod bSM> __inline RMDist
766TRenSingleModelC<iBM,bBitInc>::xGetSSE( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData, Bool bFast)
767#else
768template <BlenMod iBM, Bool bBitInc> template<SetMod bSM> __inline RMDist
769TRenSingleModelC<iBM,bBitInc>::xGetSSE( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData)
770#endif
771{
772  const Int iCurViewPos   = 0;
773  const Int iOtherViewPos = 1;
774
775  m_piNewDepthData   = piNewData; 
776  m_iNewDataWidth    = iWidth;     
777  m_iStartChangePosX = iStartPosX; 
778
779  if ((iWidth == 0) || (iHeight == 0))
780    return 0;
781
782  xSetViewRow<bSM>      ( iStartPosY);
783
784  // Init Start
785  RMDist iError = 0;     
786  Int iStartChangePos = m_iStartChangePosX; 
787  Int iEndChangePos   = m_iStartChangePosX + iWidth - 1;
788
789  for (Int iPosY = iStartPosY; iPosY < iStartPosY + iHeight; iPosY++ )
790  {   
791    Int iPosXinNewData        = iWidth - 1;                       
792    for ( Int iCurPosX = iEndChangePos; iCurPosX >= iStartChangePos; iCurPosX-- )
793    {
794      Int iCurDepth   = m_piNewDepthData[iPosXinNewData];
795      Int iOldDepth   = m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD; 
796      Int iDiff = (iCurDepth - iOldDepth);
797      iError += iDiff * iDiff;
798      iPosXinNewData--; 
799    }
800    xIncViewRow<bSM>();
801    m_piNewDepthData += iStride;
802  }
803  return iError;
804}
805
806#if H_3D_VSO_EARLY_SKIP
807template <BlenMod iBM, Bool bBitInc> template<Bool bL, SetMod bSM> __inline RMDist
808TRenSingleModelC<iBM,bBitInc>::xRender( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData, Bool bFast)
809#else
810template <BlenMod iBM, Bool bBitInc> template<Bool bL, SetMod bSM> __inline RMDist
811TRenSingleModelC<iBM,bBitInc>::xRender( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData)
812#endif
813{
814  const Int iCurViewPos   = bL ? 0 : 1;
815
816  m_piNewDepthData   = piNewData;
817  m_iNewDataWidth    = iWidth;
818  m_iStartChangePosX = iStartPosX;
819
820  if ((iWidth == 0) || (iHeight == 0))
821  {
822    return 0;
823  }
824
825  // Get Data
826  m_ppiCurLUT      = m_appiShiftLut   [iCurViewPos];
827  xSetViewRow<bSM>( iStartPosY);
828
829  // Init Start
830  RMDist iError = 0;
831  Int   iStartChangePos;
832
833  iStartChangePos = m_iStartChangePosX + ( bL ? 0  : (iWidth - 1));
834
835  for (Int iPosY = iStartPosY; iPosY < iStartPosY + iHeight; iPosY++ )
836  {
837#if H_3D_VSO_EARLY_SKIP
838    if( m_bEarlySkip && bFast )
839    {
840      if ( m_pbHorSkip[iPosY-iStartPosY] )
841      {
842        xIncViewRow<bSM>();
843        m_piNewDepthData += iStride;
844        continue;
845      }
846    }
847#endif
848    m_bInOcclusion = false;
849
850    Int iLastSPos;
851    Int iEndChangePos         = m_iStartChangePosX + ( bL ? (iWidth - 1) : 0 ) ;
852
853    Int iEndChangePosInSubPel = iEndChangePos << m_iShiftPrec;
854    Int iPosXinNewData        = bL ? iWidth - 1 : 0; 
855    Int iMinChangedSPos       = bL ? m_iSampledWidth : -1;
856    if ( iEndChangePos == xWidthMinus1<bL>() )
857    {
858      m_iCurDepth           = m_piNewDepthData[iPosXinNewData];
859      Int iCurSPos          = xShiftDept(iEndChangePosInSubPel, m_iCurDepth );
860
861      m_curRangeStart       = xRangeLeft<bL>( iCurSPos );
862      xExtrapolateMargin<bL, bSM>  ( iCurSPos, iEndChangePos, iError );
863
864      Int iOldDepth          = m_pcInputSamplesRow[iCurViewPos][iEndChangePos].iD;
865      iMinChangedSPos        = xMin<Int, bL>( ( iOldDepth <= m_iCurDepth ) ? iCurSPos : xShiftDept(iEndChangePosInSubPel, iOldDepth ), iMinChangedSPos);
866      iLastSPos           = iCurSPos;
867      m_lastRangeStart    = m_curRangeStart;
868      m_iLastDepth        = m_iCurDepth;
869      m_iLastOccludedSPos = iLastSPos;
870
871      if ( bSM == SET_FULL || bSM == SET_SIMP )
872      {
873        m_pcInputSamplesRow[iCurViewPos][iEndChangePos].iD = m_piNewDepthData[iPosXinNewData];
874      }
875
876      xDec<Int, bL>(iPosXinNewData);
877      xDec<Int, bL>(iEndChangePos);
878    }
879    else
880    {
881      m_iLastDepth = m_pcInputSamplesRow [iCurViewPos][xPlus<Int,bL>(iEndChangePos,1)].iD;
882      iLastSPos    = xShiftDept(xPlus<Int,bL>(iEndChangePosInSubPel, ( 1 << m_iShiftPrec ) ), m_iLastDepth );
883      xInitRenderPart<bL>( iEndChangePos, iLastSPos );
884    }
885
886    //// RENDER NEW DATA
887    Int iCurPosX;
888    for ( iCurPosX = iEndChangePos; xGeQ<Int,bL>(iCurPosX,iStartChangePos); xDec<Int,bL>(iCurPosX))
889    {
890      Int iCurPosXInSubPel = iCurPosX << m_iShiftPrec;
891      m_iCurDepth     = m_piNewDepthData[iPosXinNewData]        ;
892      Int iCurSPos    = xShiftDept(iCurPosXInSubPel,m_iCurDepth); 
893
894      Int iOldDepth   = m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD;
895      iMinChangedSPos = xMin<Int,bL>( ( iOldDepth <= m_iCurDepth ) ? iCurSPos : xShiftDept(iCurPosXInSubPel, iOldDepth ), iMinChangedSPos);
896
897      xRenderRange<bL,bSM>(iCurSPos, iLastSPos, iCurPosX, iError );
898      iLastSPos       = iCurSPos;
899      m_iLastDepth    = m_iCurDepth;
900
901      if ( bSM == SET_FULL || bSM == SET_SIMP )
902      {
903        m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD = m_piNewDepthData[iPosXinNewData];
904      }
905      xDec<Int,bL>(iPosXinNewData);
906    }
907
908    //// RE-RENDER DATA LEFT TO NEW DATA
909
910    while ( xGeQ<Int,bL>(iCurPosX, xZero<bL>() ) )
911    {
912      Int iCurPosXInSubPel = iCurPosX << m_iShiftPrec;
913      m_iCurDepth  = m_pcInputSamplesRow[iCurViewPos][iCurPosX].iD;
914      Int iCurSPos = xShiftDept(iCurPosXInSubPel,m_iCurDepth);     
915      xRenderRange<bL,bSM>( iCurSPos, iLastSPos, iCurPosX, iError );
916      if ( xLess<Int,bL>(iCurSPos,iMinChangedSPos) )
917      {
918        break;
919      }
920
921      xDec<Int,bL>(iCurPosX);
922      iLastSPos    = iCurSPos;
923      m_iLastDepth = m_iCurDepth;
924    }
925
926
927
928
929    xIncViewRow<bSM>();
930    m_piNewDepthData += iStride;
931  }
932  return iError;
933}
934
935template <BlenMod iBM, Bool bBitInc> template<Bool bL> __inline Void
936TRenSingleModelC<iBM,bBitInc>::xInitRenderPart(  Int iEndChangePos, Int iLastSPos )
937{
938  const Int iCurViewPos = bL ? 0 : 1;   
939  m_iLastOccludedSPos = m_pcInputSamplesRow[iCurViewPos][ xPlus<Int,bL>(iEndChangePos,1) ].aiOccludedPos; 
940  m_bInOcclusion      = xGeQ<Int,bL>( iLastSPos, m_iLastOccludedSPos ); 
941
942  if( m_bInOcclusion )
943  {
944    m_lastRangeStart = xRound<bL>( m_iLastOccludedSPos ); 
945  }
946  else
947  {
948    m_iLastOccludedSPos = iLastSPos; 
949    m_lastRangeStart = xRangeLeft<bL>( iLastSPos ); 
950  }
951};
952
953template <BlenMod iBM, Bool bBitInc> template<Bool bL, SetMod bSM> __inline Void
954TRenSingleModelC<iBM,bBitInc>::xRenderShiftedRange(Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
955{
956  RM_AOF( (xGeQ<Int,bL>(iLastSPos,iCurSPos)) );
957  Int iDeltaSPos = bL ? iLastSPos - iCurSPos : iCurSPos - iLastSPos;
958
959  m_curRangeStart = xRangeLeft<bL>( iCurSPos ); 
960  if ( iDeltaSPos > m_iGapTolerance )
961  {
962    xFillHole<bL,bSM>( iCurSPos, iLastSPos, iCurPos, riError );
963  }
964  else
965  {
966    if (!xGeQ<Int,bL>(iLastSPos, bL ? 0 : ( m_iSampledWidth - 1) ))
967    {
968      return;
969    }
970
971    RM_AOT( iDeltaSPos    > m_iGapTolerance );
972
973    m_iThisDepth = m_iCurDepth;
974
975    for (Int iFillSPos = xMax<Int,bL>(xZero<bL>(), m_curRangeStart ); xLess<Int,bL>(iFillSPos,m_lastRangeStart); xInc<Int,bL>(iFillSPos))
976    {
977      Int iDeltaCurSPos  = (iFillSPos << m_iShiftPrec) - (bL ? iCurSPos : iLastSPos); 
978
979      RM_AOT( iDeltaCurSPos > iDeltaSPos );
980      RM_AOT( iDeltaCurSPos < 0 );
981      RM_AOT( m_aaiSubPelShiftL[iDeltaSPos][iDeltaCurSPos] == 0xdeaddead);
982
983      xSetShiftedPel<bL, bSM>( iCurPos, m_aaiSubPelShiftL[iDeltaSPos][iDeltaCurSPos], iFillSPos, REN_IS_FILLED, riError );
984    }
985  };
986  m_lastRangeStart = m_curRangeStart; 
987}
988
989template <BlenMod iBM, Bool bBitInc> template<Bool bL, SetMod bSM> __inline Void
990TRenSingleModelC<iBM,bBitInc>::xRenderRange(Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
991{
992  const Int iCurViewPos = bL ? 0 : 1; 
993
994  if ( bSM == SET_FULL || bSM == SET_SIMP )
995  {
996    m_pcInputSamplesRow[iCurViewPos][ iCurPos ].aiOccludedPos = m_iLastOccludedSPos;
997  }
998
999  if ( xLess<Int,bL>(iCurSPos,m_iLastOccludedSPos ))
1000  {
1001    m_bInOcclusion      = false;
1002    m_iLastOccludedSPos = iCurSPos; 
1003    xRenderShiftedRange<bL,bSM>(iCurSPos, iLastSPos, iCurPos, riError );
1004  }
1005  else
1006  {
1007    if ( !m_bInOcclusion )
1008    {     
1009      RM_AOF( (xGeQ<Int,bL>(iLastSPos, m_iLastOccludedSPos)) ); 
1010      Int iRightSPosFP = xRound<bL>( iLastSPos );     
1011      if ( ( iRightSPosFP == xPlus<Int,bL>(m_lastRangeStart, -1) ) && xGeQ<Int,bL>(iRightSPosFP, xZero<bL>()) )
1012      {
1013        m_iThisDepth = m_iLastDepth;
1014        xSetShiftedPel<bL, bSM>( xPlus<Int,bL>(iCurPos,1), bL ? 0 : (1 << m_iShiftPrec), iRightSPosFP, REN_IS_FILLED, riError );
1015      }
1016      m_lastRangeStart = iRightSPosFP;
1017      m_bInOcclusion   = true; 
1018    }
1019  }
1020}
1021
1022template <BlenMod iBM, Bool bBitInc> template<Bool bL, SetMod bSM> __inline Void
1023TRenSingleModelC<iBM,bBitInc>::xFillHole( Int iCurSPos, Int iLastSPos, Int iCurPos, RMDist& riError )
1024{
1025  if (iLastSPos < 0)
1026  {
1027    return;
1028  }
1029
1030  Int iStartFillSPos = iCurSPos;
1031  Int iStartFillPos  = iCurPos;
1032  Int iLastPos       = xPlus<Int,bL>( iCurPos,1);
1033
1034  Int iStartFillSPosFP = m_curRangeStart; 
1035  if (iStartFillSPosFP == xRound<bL>(iStartFillSPos))
1036  {
1037    if ( xGeQ<Int,bL>(iStartFillSPosFP, xZero<bL>())  && xLess<Int,bL>(iStartFillSPosFP, m_lastRangeStart) )
1038    {
1039      m_iThisDepth = m_iCurDepth;
1040      xSetShiftedPel<bL, bSM>    ( iStartFillPos, bL ? 0 : ( 1 << m_iShiftPrec), iStartFillSPosFP, REN_IS_FILLED, riError );
1041    }
1042  }
1043  else
1044  {
1045    xDec<Int,bL>( iStartFillSPosFP );
1046  }
1047
1048  m_iThisDepth = m_iLastDepth;
1049  for (Int iFillSPos = xMax<Int,bL>(xPlus<Int,bL>(iStartFillSPosFP,1),xZero<bL>()); xLess<Int,bL>(iFillSPos, m_lastRangeStart); xInc<Int,bL>(iFillSPos))
1050  {
1051    xSetShiftedPel<bL, bSM>( iLastPos, bL ? 0 : (1 << m_iShiftPrec),  iFillSPos, REN_IS_HOLE, riError );
1052  }
1053}
1054
1055template <BlenMod iBM, Bool bBitInc> template<Bool bL, SetMod bSM> __inline Void
1056TRenSingleModelC<iBM,bBitInc>::xExtrapolateMargin(Int iCurSPos, Int iCurPos, RMDist& riError )
1057{
1058  Int iSPosFullPel = xMax<Int,bL>(xZero<bL>(),m_curRangeStart);
1059
1060  m_iThisDepth = m_iCurDepth;
1061  if ( xGeQ<Int,bL>(xWidthMinus1<bL>(), iSPosFullPel) )
1062  {
1063    xSetShiftedPel<bL, bSM>( iCurPos, bL ? 0 : (1 << m_iShiftPrec) , iSPosFullPel, REN_IS_FILLED, riError );
1064  }
1065  for (Int iFillSPos = xPlus<Int,bL>(iSPosFullPel ,1); xGeQ<Int,bL>( xWidthMinus1<bL>(), iFillSPos ); xInc<Int,bL>(iFillSPos))
1066  {
1067    xSetShiftedPel<bL, bSM>( iCurPos, bL ? 0 : ( 1 << m_iShiftPrec ), iFillSPos, REN_IS_HOLE, riError );
1068  }
1069}
1070
1071template <BlenMod iBM, Bool bBitInc> template <Bool bL> __inline Int
1072TRenSingleModelC<iBM,bBitInc>::xShiftNewData( Int iPosX, Int iPosInNewData )
1073{
1074  RM_AOT( iPosInNewData <               0 );
1075  RM_AOF( iPosInNewData < m_iNewDataWidth );
1076  return (iPosX << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( m_piNewDepthData[iPosInNewData] )];
1077}
1078
1079
1080template <BlenMod iBM, Bool bBitInc> __inline Int
1081TRenSingleModelC<iBM,bBitInc>::xShiftDept( Int iPosXinSubPel, Int iDepth )
1082{
1083  return (iPosXinSubPel) - m_ppiCurLUT[0][ RenModRemoveBitInc( iDepth )];
1084}
1085
1086
1087template <BlenMod iBM, Bool bBitInc> template <Bool bL> __inline Int
1088TRenSingleModelC<iBM,bBitInc>::xShift( Int iPosX )
1089{
1090 RM_AOT( iPosX <        0);
1091 RM_AOF( iPosX < m_iWidth);
1092 return (iPosX  << m_iShiftPrec) - m_ppiCurLUT[0][ RenModRemoveBitInc( m_pcInputSamplesRow[(bL ? 0 : 1)][iPosX].iD )];
1093}
1094
1095
1096template <BlenMod iBM, Bool bBitInc> template <Bool bL> __inline Int
1097TRenSingleModelC<iBM,bBitInc>::xShift( Int iPos, Int iPosInNewData )
1098{
1099  if ( (iPosInNewData >= 0) && (iPosInNewData < m_iNewDataWidth) )
1100  {
1101    return xShiftNewData(iPos ,iPosInNewData );
1102  }
1103  else
1104  {
1105    return xShift<bL>(iPos);
1106  }
1107}
1108
1109template <BlenMod iBM, Bool bBitInc> template<Bool bL> __inline Int
1110TRenSingleModelC<iBM,bBitInc>::xRangeLeft( Int iPos )
1111{
1112  if ( bL )
1113  {
1114    return  ( iPos +  (1 << m_iShiftPrec) - 1) >> m_iShiftPrec;
1115  }
1116  else
1117  {
1118    return iPos >> m_iShiftPrec;
1119  }
1120}
1121
1122
1123
1124template <BlenMod iBM, Bool bBitInc> template<Bool bL> __inline Int
1125TRenSingleModelC<iBM,bBitInc>::xRangeRight( Int iPos )
1126{
1127  if ( bL )
1128  {
1129    return xRangeLeft<true>(iPos)    - 1;
1130  }
1131  else
1132  {
1133    return xRangeLeft<false>( iPos ) + 1;   
1134  } 
1135}
1136
1137template <BlenMod iBM, Bool bBitInc> template<Bool bL> __inline Int
1138TRenSingleModelC<iBM,bBitInc>::xRound( Int iPos )
1139{
1140  if( bL )
1141  { 
1142    return  (iPos + (( 1 << m_iShiftPrec ) >> 1 )) >> m_iShiftPrec;
1143  }
1144  else
1145  {
1146    return  (m_iShiftPrec == 0) ? iPos : xRound<true>(iPos - 1);
1147  }
1148}
1149
1150
1151template <BlenMod iBM, Bool bBitInc> Void
1152TRenSingleModelC<iBM,bBitInc>::xSetPels( Pel* piPelSource , Int iSourceStride, Int iWidth, Int iHeight, Pel iVal )
1153{
1154  for (Int iYPos = 0; iYPos < iHeight; iYPos++)
1155  {
1156    for (Int iXPos = 0; iXPos < iWidth; iXPos++)
1157    {
1158      piPelSource[iXPos] = iVal;
1159    }
1160    piPelSource += iSourceStride;
1161  }
1162}
1163
1164template <BlenMod iBM, Bool bBitInc> Void
1165TRenSingleModelC<iBM,bBitInc>::xSetInts( Int* piPelSource , Int iSourceStride, Int iWidth, Int iHeight, Int iVal )
1166{
1167  for (Int iYPos = 0; iYPos < iHeight; iYPos++)
1168  {
1169    for (Int iXPos = 0; iXPos < iWidth; iXPos++)
1170    {
1171      piPelSource[iXPos] = iVal;
1172    }
1173    piPelSource += iSourceStride;
1174  }
1175}
1176
1177
1178template <BlenMod iBM, Bool bBitInc> Void
1179TRenSingleModelC<iBM,bBitInc>::xSetBools( Bool* pbPelSource , Int iSourceStride, Int iWidth, Int iHeight, Bool bVal )
1180{
1181  for (Int iYPos = 0; iYPos < iHeight; iYPos++)
1182  {
1183    for (Int iXPos = 0; iXPos < iWidth; iXPos++)
1184    {
1185      pbPelSource[iXPos] = bVal;
1186    }
1187    pbPelSource += iSourceStride;
1188  }
1189}
1190
1191template <BlenMod iBM, Bool bBitInc> template<Bool bL, SetMod bSM> __inline Void
1192TRenSingleModelC<iBM,bBitInc>::xSetShiftedPel(Int iSourcePos, Int iSubSourcePos, Int iTargetSPos, Pel iFilled, RMDist& riError )
1193{
1194  RM_AOT( iSourcePos    <  0                   );
1195  RM_AOT( iSourcePos    >= m_iWidth            );
1196  RM_AOT( iSubSourcePos < 0                    );
1197  RM_AOT( iSubSourcePos >  (1 << m_iShiftPrec) );
1198  RM_AOT( iTargetSPos   < 0                    );
1199  RM_AOT( iTargetSPos   >= m_iWidth            );
1200
1201  RenModelInPels * pcInSample  = m_pcInputSamplesRow[ bL ? VIEWPOS_LEFT : VIEWPOS_RIGHT ] + iSourcePos ;
1202
1203  Pel iY;
1204  Pel iYCurNew = pcInSample->aiY[iSubSourcePos];   
1205#if H_3D_VSO_COLOR_PLANES
1206  Pel iU;
1207  Pel iUCurNew = pcInSample->aiU[iSubSourcePos];
1208  Pel iV;
1209  Pel iVCurNew = pcInSample->aiV[iSubSourcePos];;
1210#endif   
1211
1212  const Bool bFullMode = ( bSM == GET_FULL || bSM == SET_FULL ); 
1213
1214  RenModelOutPels*    pcOutSample    = bFullMode ? ( m_pcOutputSamplesRow    + iTargetSPos ) : NULL; 
1215  RenModelLimOutPels* pcLimOutSample = bFullMode ? NULL  : ( m_pcLimOutputSamplesRow + iTargetSPos ); 
1216
1217  if ( iBM == BLEND_NONE )
1218  {
1219    iY = iYCurNew; 
1220#if H_3D_VSO_COLOR_PLANES
1221    iU = iUCurNew; 
1222    iV = iVCurNew; 
1223#endif
1224  }
1225  else
1226  { 
1227    Pel iYOther      = bFullMode ? ( bL ? pcOutSample->iYRight : pcOutSample->iYLeft) : pcLimOutSample->iYOther; 
1228#if H_3D_VSO_COLOR_PLANES
1229    Pel iUOther      = bFullMode ? ( bL ? pcOutSample->iURight : pcOutSample->iULeft ) : pcLimOutSample->iUOther; 
1230    Pel iVOther      = bFullMode ? ( bL ? pcOutSample->iVRight : pcOutSample->iVLeft ) : pcLimOutSample->iVOther; 
1231#endif
1232    Int iFilledOther = bFullMode ? ( bL ? pcOutSample->iFilledRight : pcOutSample->iFilledLeft ) : pcLimOutSample->iFilledOther; 
1233    Pel iDOther      = bFullMode ? ( bL ? pcOutSample->iDRight      : pcOutSample->iDLeft      ) : pcLimOutSample->iDOther; 
1234
1235    xGetBlendedValue<bL, bSM>(
1236      iY,
1237      bL ? iYCurNew : iYOther,
1238      bL ? iYOther  : iYCurNew,
1239#if H_3D_VSO_COLOR_PLANES
1240      iU,
1241      bL ? iUCurNew  : iUOther,
1242      bL ? iUOther   : iUCurNew,
1243      iV,
1244      bL ? iVCurNew  : iVOther,
1245      bL ? iVOther   : iVCurNew,         
1246#endif
1247      bL ? iFilled      : iFilledOther,
1248      bL ? iFilledOther : iFilled,
1249      m_piInvZLUTLeft [RenModRemoveBitInc( bL ? m_iThisDepth : iDOther)],
1250      m_piInvZLUTRight[RenModRemoveBitInc( bL ? iDOther      : m_iThisDepth)]
1251      ); 
1252  }
1253
1254
1255  Int iDist = xGetDist( 
1256    iY - ( bFullMode ? pcOutSample->iYRef : pcLimOutSample->iYRef ) 
1257#if H_3D_VSO_COLOR_PLANES
1258  , iU - ( bFullMode ? pcOutSample->iURef : pcLimOutSample->iURef )
1259  , iV - ( bFullMode ? pcOutSample->iVRef : pcLimOutSample->iVRef )
1260#endif
1261  );
1262
1263  if ( bSM == GET_FULL || bSM == GET_SIMP )
1264  {   
1265    riError += ( iDist - ( bFullMode ? pcOutSample->iError : pcLimOutSample->iError ) );
1266  }
1267  else // bSM == SET_FULL
1268  {
1269    Int& riErrorStr = bFullMode ? pcOutSample->iError : pcLimOutSample->iError; 
1270    riErrorStr      = iDist; 
1271
1272    if ( bFullMode )
1273    {     
1274      if ( iBM != BLEND_NONE )
1275      {       
1276        pcOutSample->iYBlended   = iY; 
1277#if H_3D_VSO_COLOR_PLANES
1278        pcOutSample->iUBlended   = iU; 
1279        pcOutSample->iVBlended   = iV; 
1280#endif
1281      }
1282
1283      if ( bL )
1284      {
1285        pcOutSample->iDLeft      = m_iThisDepth; 
1286        pcOutSample->iFilledLeft = iFilled; 
1287        pcOutSample->iYLeft      = iYCurNew;
1288#if  H_3D_VSO_COLOR_PLANES
1289        pcOutSample->iULeft      = iUCurNew;
1290        pcOutSample->iVLeft      = iVCurNew;
1291#endif
1292      }
1293      else
1294      {
1295        pcOutSample->iDRight      = m_iThisDepth; 
1296        pcOutSample->iFilledRight = iFilled; 
1297        pcOutSample->iYRight      = iYCurNew;
1298#if  H_3D_VSO_COLOR_PLANES
1299        pcOutSample->iURight      = iUCurNew;
1300        pcOutSample->iVRight      = iVCurNew;
1301#endif
1302      }
1303    }
1304  }   
1305}
1306
1307template <BlenMod iBM, Bool bBitInc> __inline Int
1308TRenSingleModelC<iBM,bBitInc>::xGetDist( Int iDiffY, Int iDiffU, Int iDiffV )
1309{
1310
1311  if ( !bBitInc )
1312  {
1313    return (          (iDiffY * iDiffY )
1314               +  ((( (iDiffU * iDiffU )
1315                     +(iDiffV * iDiffV )
1316                    )
1317                   ) >> 2
1318                  )
1319           );
1320  }
1321  else
1322  {
1323    return (          ((iDiffY * iDiffY) >> m_iDistShift)
1324               +  ((( ((iDiffU * iDiffU) >> m_iDistShift)
1325                     +((iDiffV * iDiffV) >> m_iDistShift)
1326                    )
1327                   ) >> 2
1328                  )
1329           );
1330 
1331  }
1332}
1333
1334template <BlenMod iBM, Bool bBitInc> __inline Int
1335TRenSingleModelC<iBM,bBitInc>::xGetDist( Int iDiffY )
1336{
1337  if ( !bBitInc )
1338  {
1339    return (iDiffY * iDiffY);
1340  }
1341  else
1342  {
1343    return ((iDiffY * iDiffY) >> m_iDistShift);
1344  }
1345
1346}
1347
1348
1349
1350template <BlenMod iBM, Bool bBitInc>  template< Bool bL, SetMod bSM > __inline Void
1351  TRenSingleModelC<iBM,bBitInc>::xGetBlendedValue( Pel& riY, Pel iYL,  Pel iYR, 
1352#if H_3D_VSO_COLOR_PLANES
1353                                                   Pel& riU, Pel iUL,  Pel iUR,  Pel& riV, Pel iVL,  Pel iVR, 
1354#endif
1355                                                   Int iFilledL,  Int iFilledR, Pel iDepthL,  Pel iDepthR  )
1356{ 
1357  RM_AOT( iBM != BLEND_AVRG && iBM != BLEND_LEFT && iBM != BLEND_RIGHT );
1358
1359  if (iBM != BLEND_AVRG )
1360  {
1361    if (iBM == BLEND_LEFT )
1362    {
1363      xGetBlendedValueBM1<bL, bSM>( riY, iYL,  iYR, 
1364#if H_3D_VSO_COLOR_PLANES
1365        riU, iUL,  iUR,  riV, iVL,  iVR, 
1366#endif
1367        iFilledL,  iFilledR, iDepthL,  iDepthR  );
1368    }
1369    else
1370    {
1371      xGetBlendedValueBM2<bL, bSM>(  riY, iYL,  iYR, 
1372#if H_3D_VSO_COLOR_PLANES
1373        riU, iUL,  iUR,  riV, iVL,  iVR, 
1374#endif
1375        iFilledL,  iFilledR, iDepthL,  iDepthR );
1376    }
1377    return;
1378  }
1379
1380  if (  (iFilledL != REN_IS_HOLE ) && ( iFilledR != REN_IS_HOLE) )
1381  {
1382    Int iDepthDifference = iDepthR - iDepthL;
1383
1384    if ( abs ( iDepthDifference ) <= m_iBlendZThres )
1385    {
1386      {
1387        riY = xBlend( iYL, iYR, m_iBlendDistWeight );
1388#if H_3D_VSO_COLOR_PLANES   
1389        riU = xBlend( iUL, iUR, m_iBlendDistWeight );
1390        riV = xBlend( iVL, iVR, m_iBlendDistWeight );
1391#endif
1392      }
1393    }
1394    else if ( iDepthDifference < 0 )
1395    {
1396      riY = iYL;
1397#if H_3D_VSO_COLOR_PLANES
1398      riU = iUL;
1399      riV = iVL;
1400#endif
1401    }
1402    else
1403    {     
1404      riY = iYR;
1405#if H_3D_VSO_COLOR_PLANES
1406      riU = iUR;
1407      riV = iVR;
1408#endif
1409    }
1410  }
1411  else if ( (iFilledL == REN_IS_HOLE) && (iFilledR == REN_IS_HOLE))
1412  {
1413    if ( iDepthR < iDepthL )
1414    {
1415        riY =  iYR;
1416#if H_3D_VSO_COLOR_PLANES
1417        riU =  iUR;
1418        riV =  iVR;
1419#endif
1420    }
1421    else
1422    {
1423        riY =  iYL;
1424#if H_3D_VSO_COLOR_PLANES
1425        riU =  iUL;
1426        riV =  iVL;
1427#endif
1428    }
1429  }
1430  else
1431  {
1432    if (iFilledR == REN_IS_HOLE)
1433    {
1434        riY = iYL;
1435#if H_3D_VSO_COLOR_PLANES
1436        riU = iUL;
1437        riV = iVL;
1438#endif
1439    }
1440    else
1441    {
1442      riY = iYR;
1443#if H_3D_VSO_COLOR_PLANES
1444      riU = iUR;
1445      riV = iVR;
1446#endif
1447    }
1448  }
1449}
1450
1451template <BlenMod iBM, Bool bBitInc> template< Bool bL, SetMod SM > __inline Void
1452TRenSingleModelC<iBM,bBitInc>::xGetBlendedValueBM1( Pel& riY, Pel iYL,  Pel iYR, 
1453#if H_3D_VSO_COLOR_PLANES
1454                                                    Pel& riU, Pel iUL,  Pel iUR,  Pel& riV, Pel iVL,  Pel iVR, 
1455#endif
1456                                                    Int iFilledL,  Int iFilledR, Pel iDepthL,  Pel iDepthR  )
1457{
1458  if ( iFilledL == REN_IS_FILLED ||  iFilledR == REN_IS_HOLE )
1459  {
1460    riY = iYL;
1461#if H_3D_VSO_COLOR_PLANES
1462    riU = iUL;
1463    riV = iVL;
1464#endif
1465  }
1466  else if ( iFilledL == REN_IS_HOLE  )
1467  {
1468    riY = iYR;
1469#if H_3D_VSO_COLOR_PLANES
1470    riU = iUR;
1471    riV = iVR;
1472#endif
1473  }
1474  else
1475  {
1476    riY = xBlend( iYR, iYL, iFilledL );
1477#if H_3D_VSO_COLOR_PLANES
1478    riU = xBlend( iUR, iUL, iFilledL );
1479    riV = xBlend( iVR, iUL, iFilledL );
1480#endif
1481  }
1482}
1483
1484template <BlenMod iBM, Bool bBitInc> template< Bool bL, SetMod SM > __inline Void
1485  TRenSingleModelC<iBM,bBitInc>::xGetBlendedValueBM2( Pel& riY, Pel iYL,  Pel iYR, 
1486#if H_3D_VSO_COLOR_PLANES
1487                                                      Pel& riU, Pel iUL,  Pel iUR,  Pel& riV, Pel iVL,  Pel iVR, 
1488#endif
1489                                                      Int iFilledL,  Int iFilledR, Pel iDepthL,  Pel iDepthR  )
1490{
1491  if      ( iFilledR == REN_IS_FILLED ||  iFilledL == REN_IS_HOLE )
1492  {
1493    riY = iYR;
1494#if H_3D_VSO_COLOR_PLANES
1495    riU = iUR;
1496    riV = iVR;
1497#endif
1498  }
1499  else if ( iFilledR == REN_IS_HOLE  )
1500  {
1501    riY = iYL;
1502#if H_3D_VSO_COLOR_PLANES
1503    riU = iUL;
1504    riV = iVL;
1505#endif
1506  }
1507  else
1508  {
1509    riY = xBlend( iYL, iYR, iFilledR );
1510#if H_3D_VSO_COLOR_PLANES
1511    riU = xBlend( iUL, iUR, iFilledR );
1512    riV = xBlend( iVL, iUR, iFilledR );
1513#endif
1514  }
1515}
1516
1517template <BlenMod iBM, Bool bBitInc> __inline Pel
1518TRenSingleModelC<iBM,bBitInc>::xBlend( Pel pVal1, Pel pVal2, Int iWeightVal2 )
1519{
1520  return pVal1  +  (Pel) (  ( (Int) ( pVal2 - pVal1) * iWeightVal2 + (1 << (REN_VDWEIGHT_PREC - 1)) ) >> REN_VDWEIGHT_PREC );
1521}
1522
1523template <BlenMod iBM, Bool bBitInc> Void
1524TRenSingleModelC<iBM,bBitInc>::xCopy2PicYuv( Pel** ppiSrcVideoPel, Int* piStrides, TComPicYuv* rpcPicYuvTarget )
1525{
1526  TRenFilter<REN_BIT_DEPTH>::copy            ( ppiSrcVideoPel[0], piStrides[0], m_iWidth, m_iUsedHeight, rpcPicYuvTarget->getAddr( COMPONENT_Y  ) +  m_iHorOffset       * rpcPicYuvTarget->getStride( COMPONENT_Y  ), rpcPicYuvTarget->getStride( COMPONENT_Y ) );
1527  TRenFilter<REN_BIT_DEPTH>::sampleDown2Tap13( ppiSrcVideoPel[1], piStrides[1], m_iWidth, m_iUsedHeight, rpcPicYuvTarget->getAddr( COMPONENT_Cb ) + (m_iHorOffset >> 1) * rpcPicYuvTarget->getStride( COMPONENT_Cb ), rpcPicYuvTarget->getStride( COMPONENT_Cb) );
1528  TRenFilter<REN_BIT_DEPTH>::sampleDown2Tap13( ppiSrcVideoPel[2], piStrides[2], m_iWidth, m_iUsedHeight, rpcPicYuvTarget->getAddr( COMPONENT_Cr ) + (m_iHorOffset >> 1) * rpcPicYuvTarget->getStride( COMPONENT_Cr ), rpcPicYuvTarget->getStride( COMPONENT_Cr) );
1529}
1530
1531template class TRenSingleModelC<BLEND_NONE ,true>;
1532template class TRenSingleModelC<BLEND_AVRG ,true>;
1533template class TRenSingleModelC<BLEND_LEFT ,true>;
1534template class TRenSingleModelC<BLEND_RIGHT,true>;
1535
1536template class TRenSingleModelC<BLEND_NONE ,false>;
1537template class TRenSingleModelC<BLEND_AVRG ,false>;
1538template class TRenSingleModelC<BLEND_LEFT ,false>;
1539template class TRenSingleModelC<BLEND_RIGHT,false>;
1540
1541#if H_3D_VSO_EARLY_SKIP
1542template <BlenMod iBM, Bool bBitInc> template <Bool bL > __inline Bool
1543TRenSingleModelC<iBM,bBitInc>::xDetectEarlySkip( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, const Pel* piNewData, const Pel* piOrgData, Int iOrgStride)
1544{
1545  RM_AOF( m_bEarlySkip ); 
1546  const Int iCurViewPos = bL ? 0 : 1;
1547  Int** ppiCurLUT       = m_appiShiftLut   [ iCurViewPos ];
1548 
1549  Bool bNoDiff          = true;   
1550 
1551  for (Int iPosY=0; iPosY < iHeight; iPosY++)
1552  {
1553    m_pbHorSkip[iPosY] = true;
1554
1555    for (Int iPosX = 0; iPosX < iWidth; iPosX++)
1556    {
1557      Int iDisparityRec = abs(ppiCurLUT[0][ RenModRemoveBitInc(piNewData[iPosX])]);
1558      Int iDispartyOrg  = abs(ppiCurLUT[0][ RenModRemoveBitInc(piOrgData[iPosX])]);
1559
1560      if( iDispartyOrg != iDisparityRec)
1561      {
1562        m_pbHorSkip[iPosY] = false;
1563        bNoDiff            = false;
1564        break;
1565      }
1566    }
1567    piNewData += iStride;
1568    piOrgData += iOrgStride;
1569  }
1570  return bNoDiff;
1571}
1572#endif
1573#endif // NH_3D
1574
Note: See TracBrowser for help on using the repository browser.