Ignore:
Timestamp:
10 Nov 2014, 14:19:08 (10 years ago)
Author:
tech
Message:

Removed 3D-HEVC related code.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/HTM-13.0-MV-draft-2/source/Lib/TLibRenderer/TRenSingleModel.cpp

    r608 r1128  
    3636#include "TRenSingleModel.h"
    3737
    38 #if H_3D_VSO
    3938
    40 ////////////// TRENSINGLE MODEL ///////////////
    41 template <BlenMod iBM, Bool bBitInc>
    42 TRenSingleModelC<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 
    92 template <BlenMod iBM, Bool bBitInc>
    93 TRenSingleModelC<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 
    116 template <BlenMod iBM, Bool bBitInc> Void
    117 #if H_3D_VSO_EARLY_SKIP
    118 TRenSingleModelC<iBM,bBitInc>::create( Int iMode, Int iWidth, Int iHeight, Int iShiftPrec, Int*** aaaiSubPelShiftTable, Int iHoleMargin, Bool bUseOrgRef, Int iBlendMode, Bool bEarlySkip )
    119 #else
    120 TRenSingleModelC<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 
    176 template <BlenMod iBM, Bool bBitInc> Void
    177 TRenSingleModelC<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 }
    237 template <BlenMod iBM, Bool bBitInc> Void
    238 TRenSingleModelC<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 
    246 template <BlenMod iBM, Bool bBitInc> Void
    247 TRenSingleModelC<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 
    308 template <BlenMod iBM, Bool bBitInc> Void
    309 #if H_3D_VSO_COLOR_PLANES
    310 TRenSingleModelC<iBM,bBitInc>::xGetSampleStrTextPtrs( Int iViewNum, Pel RenModelOutPels::*& rpiSrcY, Pel RenModelOutPels::*& rpiSrcU, Pel RenModelOutPels::*& rpiSrcV )
    311 #else
    312 TRenSingleModelC<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 
    342 template <BlenMod iBM, Bool bBitInc> Void
    343 TRenSingleModelC<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 
    350 template <BlenMod iBM, Bool bBitInc> Void
    351 TRenSingleModelC<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 
    382 template <BlenMod iBM, Bool bBitInc> Void
    383 TRenSingleModelC<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 
    397 template <BlenMod iBM, Bool bBitInc> Void
    398 TRenSingleModelC<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 
    428 template <BlenMod iBM, Bool bBitInc> Void
    429 TRenSingleModelC<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
    476 template <BlenMod iBM, Bool bBitInc> RMDist
    477 TRenSingleModelC<iBM,bBitInc>::getDistDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData , Pel * piOrgData, Int iOrgStride )
    478 #else
    479 template <BlenMod iBM, Bool bBitInc> RMDist
    480 TRenSingleModelC<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
    518 template <BlenMod iBM, Bool bBitInc> Void
    519 TRenSingleModelC<iBM,bBitInc>::setDepth( Int iViewPos, Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Pel* piOrgData, Int iOrgStride )
    520 #else
    521 template <BlenMod iBM, Bool bBitInc> Void
    522 TRenSingleModelC<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 
    557 template <BlenMod iBM, Bool bBitInc> Void
    558 TRenSingleModelC<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 
    588 template <BlenMod iBM, Bool bBitInc> Void
    589 TRenSingleModelC<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 
    602 template <BlenMod iBM, Bool bBitInc> Void
    603 TRenSingleModelC<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 
    634 template <BlenMod iBM, Bool bBitInc> RMDist
    635 TRenSingleModelC<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 
    641 template <BlenMod iBM, Bool bBitInc> Void
    642 TRenSingleModelC<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 
    649 template <BlenMod iBM, Bool bBitInc> __inline Void
    650 TRenSingleModelC<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 
    658 template <BlenMod iBM, Bool bBitInc> __inline Void
    659 TRenSingleModelC<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
    666 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
    667 TRenSingleModelC<iBM,bBitInc>::xRenderL( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData, Bool bFast)
    668 #else
    669 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
    670 TRenSingleModelC<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
    790 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
    791 TRenSingleModelC<iBM,bBitInc>::xRenderR( Int iStartPosX, Int iStartPosY, Int iWidth, Int iHeight, Int iStride, Pel* piNewData , Bool bFast)
    792 #else
    793 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline RMDist
    794 TRenSingleModelC<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 
    914 template <BlenMod iBM, Bool bBitInc> __inline Void
    915 TRenSingleModelC<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 
    951 template <BlenMod iBM, Bool bBitInc> __inline Void
    952 TRenSingleModelC<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 
    986 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    987 TRenSingleModelC<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 
    1018 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1019 TRenSingleModelC<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 
    1050 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1051 TRenSingleModelC<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 
    1108 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1109 TRenSingleModelC<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 
    1166 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1167 TRenSingleModelC<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 
    1198 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1199 TRenSingleModelC<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 
    1230 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1231 TRenSingleModelC<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 
    1250 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1251 TRenSingleModelC<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 
    1270 template <BlenMod iBM, Bool bBitInc> __inline Int
    1271 TRenSingleModelC<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 
    1279 template <BlenMod iBM, Bool bBitInc> __inline Int
    1280 TRenSingleModelC<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 
    1289 template <BlenMod iBM, Bool bBitInc> __inline Int
    1290 TRenSingleModelC<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 
    1302 template <BlenMod iBM, Bool bBitInc> __inline Int
    1303 TRenSingleModelC<iBM,bBitInc>::xRangeLeftL( Int iPos )
    1304 {
    1305   return  ( iPos +  (1 << m_iShiftPrec) - 1) >> m_iShiftPrec;
    1306 }
    1307 
    1308 
    1309 template <BlenMod iBM, Bool bBitInc> __inline Int
    1310 TRenSingleModelC<iBM,bBitInc>::xRangeLeftR( Int iPos )
    1311 {
    1312 
    1313   return  xRangeRightR( iPos ) + 1;
    1314 }
    1315 
    1316 
    1317 template <BlenMod iBM, Bool bBitInc> __inline Int
    1318 TRenSingleModelC<iBM,bBitInc>::xRangeRightL( Int iPos )
    1319 {
    1320   return xRangeLeftL(iPos) - 1;
    1321 }
    1322 
    1323 template <BlenMod iBM, Bool bBitInc> __inline Int
    1324 TRenSingleModelC<iBM,bBitInc>::xRangeRightR( Int iPos )
    1325 {
    1326   return iPos >> m_iShiftPrec;
    1327 }
    1328 
    1329 
    1330 template <BlenMod iBM, Bool bBitInc> __inline Int
    1331 TRenSingleModelC<iBM,bBitInc>::xRoundL( Int iPos )
    1332 {
    1333   return  (iPos + (( 1 << m_iShiftPrec ) >> 1 )) >> m_iShiftPrec;
    1334 }
    1335 
    1336 template <BlenMod iBM, Bool bBitInc> __inline Int
    1337 TRenSingleModelC<iBM,bBitInc>::xRoundR( Int iPos )
    1338 {
    1339   return  (m_iShiftPrec == 0) ? iPos : xRoundL(iPos - 1);
    1340 }
    1341 
    1342 
    1343 template <BlenMod iBM, Bool bBitInc> Void
    1344 TRenSingleModelC<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 
    1356 template <BlenMod iBM, Bool bBitInc> Void
    1357 TRenSingleModelC<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 
    1370 template <BlenMod iBM, Bool bBitInc> Void
    1371 TRenSingleModelC<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 
    1383 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1384 TRenSingleModelC<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 
    1406 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1407 TRenSingleModelC<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 
    1444 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1445 TRenSingleModelC<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 
    1513 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1514 TRenSingleModelC<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 
    1536 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1537 TRenSingleModelC<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 
    1575 template <BlenMod iBM, Bool bBitInc> template<Bool bSet> __inline Void
    1576 TRenSingleModelC<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 
    1641 template <BlenMod iBM, Bool bBitInc> __inline Int
    1642 TRenSingleModelC<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 
    1668 template <BlenMod iBM, Bool bBitInc> __inline Int
    1669 TRenSingleModelC<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
    1684 template <BlenMod iBM, Bool bBitInc>  __inline Void
    1685 TRenSingleModelC<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
    1687 template <BlenMod iBM, Bool bBitInc>  __inline Void
    1688 TRenSingleModelC<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 
    1804 template <BlenMod iBM, Bool bBitInc> __inline Void
    1805 #if H_3D_VSO_COLOR_PLANES
    1806 TRenSingleModelC<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
    1808 TRenSingleModelC<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 
    1837 template <BlenMod iBM, Bool bBitInc> __inline Void
    1838 #if H_3D_VSO_COLOR_PLANES
    1839 TRenSingleModelC<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
    1841 TRenSingleModelC<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 
    1870 template <BlenMod iBM, Bool bBitInc> __inline Pel
    1871 TRenSingleModelC<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 
    1876 template <BlenMod iBM, Bool bBitInc> Void
    1877 TRenSingleModelC<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 
    1884 template class TRenSingleModelC<BLEND_NONE ,true>;
    1885 template class TRenSingleModelC<BLEND_AVRG ,true>;
    1886 template class TRenSingleModelC<BLEND_LEFT ,true>;
    1887 template class TRenSingleModelC<BLEND_RIGHT,true>;
    1888 
    1889 template class TRenSingleModelC<BLEND_NONE ,false>;
    1890 template class TRenSingleModelC<BLEND_AVRG ,false>;
    1891 template class TRenSingleModelC<BLEND_LEFT ,false>;
    1892 template class TRenSingleModelC<BLEND_RIGHT,false>;
    1893 
    1894 #if H_3D_VSO_EARLY_SKIP
    1895 template <BlenMod iBM, Bool bBitInc>
    1896 __inline Bool
    1897 TRenSingleModelC<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 
    1927 template <BlenMod iBM, Bool bBitInc>
    1928 __inline Bool
    1929 TRenSingleModelC<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 TracChangeset for help on using the changeset viewer.