Ignore:
Timestamp:
13 Nov 2015, 17:00:20 (9 years ago)
Author:
tech
Message:

Removed 3D.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/HTM-16.0-MV-draft-5/source/Lib/TLibCommon/TComSlice.cpp

    r1386 r1390  
    118118, m_viewId                        (0)
    119119, m_viewIndex                     (0)
    120 #if NH_3D_VSO
    121 , m_isDepth                       (false)
    122 #endif
    123120#if NH_MV
    124121, m_pocResetFlag                  (false)
    … …  
    139136, m_pocMsbValRequiredFlag         (false)
    140137#endif
    141 #if NH_3D_IC
    142 , m_bApplyIC                      (false)
    143 , m_icSkipParseFlag               (false)
    144 #endif
    145 #if NH_3D
    146 , m_inCmpPredFlag                 (false)
    147 , m_numViews                      (0)
    148 , m_depthToDisparityB             (NULL)
    149 , m_depthToDisparityF             (NULL)
    150 #endif
    151 #if NH_3D_DIS
    152 , m_bApplyDIS                     (false)
    153 #endif
    154138#endif
    155139{
    … …  
    210194  }
    211195#endif
    212 #if NH_3D
    213   m_iDefaultRefViewIdx = -1;
    214   m_bDefaultRefViewIdxAvailableFlag = false;
    215   m_ivMvPredFlag           = false;
    216   m_ivMvScalingFlag        = false;
    217   m_ivResPredFlag          = false; 
    218   m_depthRefinementFlag    = false;
    219   m_viewSynthesisPredFlag  = false;
    220   m_depthBasedBlkPartFlag  = false;
    221   m_mpiFlag                = false;
    222   m_intraContourFlag       = false;
    223   m_intraSdcWedgeFlag      = false;
    224   m_qtPredFlag             = false;
    225   m_interSdcFlag           = false;
    226   m_depthIntraSkipFlag     = false;
    227   m_subPbSize              =  1 << 6;
    228   m_mpiSubPbSize           =  1 << 6;
    229 
    230   m_aaiCodedOffset.resize(2);
    231   m_aaiCodedScale .resize(2);
    232   for (Int i = 0; i < 2; i++)
    233   {
    234     m_aaiCodedOffset[i].resize(MAX_NUM_LAYERS);
    235     m_aaiCodedScale [i].resize(MAX_NUM_LAYERS);
    236   }
    237  
    238 #endif
    239196
    240197}
    … …  
    242199TComSlice::~TComSlice()
    243200{
    244 #if NH_3D
    245   for( UInt i = 0; i < m_numViews; i++ )
    246   {
    247     if ( m_depthToDisparityB && m_depthToDisparityB[ i ] )
    248     {
    249       delete[] m_depthToDisparityB [ i ];
    250     }
    251 
    252     if ( m_depthToDisparityF && m_depthToDisparityF[ i ] )
    253     {
    254       delete[] m_depthToDisparityF [ i ];
    255     }
    256   }
    257 
    258   if ( m_depthToDisparityF )
    259   {
    260     delete[] m_depthToDisparityF;
    261   }
    262 
    263   m_depthToDisparityF = NULL;
    264 
    265   if ( m_depthToDisparityB )
    266     delete[] m_depthToDisparityB;
    267 
    268   m_depthToDisparityB = NULL;
    269 #endif
    270201
    271202}
    … …  
    289220    m_iSliceChromaQpDelta[component] = 0;
    290221  }
    291 #if NH_3D_IV_MERGE
    292   m_maxNumMergeCand = MRG_MAX_NUM_CANDS_MEM;
    293 #else
    294222  m_maxNumMergeCand = MRG_MAX_NUM_CANDS;
    295 #endif
    296223
    297224  m_bFinalized=false;
    … …  
    300227  m_cabacInitFlag        = false;
    301228  m_enableTMVPFlag = true;
    302 #if NH_3D_TMVP
    303   m_aiAlterRefIdx[0]                  = -1;
    304   m_aiAlterRefIdx[1]                  = -1;
    305 #endif
    306229}
    307230
    … …  
    619542  UInt NumPocLtCurr = 0;
    620543  Int i;
    621 #if NH_3D
    622   m_pocsInCurrRPSs.clear();
    623 #endif
    624544  for(i=0; i < m_pRPS->getNumberOfNegativePictures(); i++)
    625545  {
    … …  
    632552      NumPocStCurr0++;
    633553      pcRefPic->setCheckLTMSBPresent(false); 
    634 #if NH_3D
    635       m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() );
    636 #endif
    637554    }
    638555  }
    … …  
    648565      NumPocStCurr1++;
    649566      pcRefPic->setCheckLTMSBPresent(false); 
    650 #if NH_3D
    651       m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() );
    652 #endif
    653567    }
    654568  }
    … …  
    663577      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
    664578      NumPocLtCurr++;
    665 #if NH_3D
    666       m_pocsInCurrRPSs.push_back( pcRefPic->getPOC() );
    667 #endif
    668579    }
    669580    if(pcRefPic==NULL)
    … …  
    675586
    676587  Int numPocInterCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
    677 #if NH_3D
    678   assert( numPocInterCurr == (Int) m_pocsInCurrRPSs.size() );
    679 #endif
    680588  numPocTotalCurr = numPocInterCurr + getNumActiveRefLayerPics( );
    681589  assert( numPocTotalCurr == getNumRpsCurrTempList() );
    … …  
    827735  }
    828736}
    829 #if NH_3D
    830 #if NH_3D_TMVP
    831 Void TComSlice::generateAlterRefforTMVP()
    832 {
    833   for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
    834   {       
    835     if ( this->getNumRefIdx( RefPicList( uiRefListIdx ) ) == 0)
    836     {
    837         continue;
    838     }
    839     Bool bZeroIdxLtFlag = this->getRefPic(RefPicList(uiRefListIdx), 0)->getIsLongTerm();
    840     for(Int i = 1; i < this->getNumRefIdx(RefPicList(uiRefListIdx)); i++ )
    841     {
    842       if ( ( bZeroIdxLtFlag && !this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) ||
    843            (!bZeroIdxLtFlag &&  this->getRefPic(RefPicList(uiRefListIdx), i)->getIsLongTerm() ) )
    844       {
    845         this->setAlterRefIdx(RefPicList(uiRefListIdx),i);
    846         break;
    847       }
    848     }
    849   }
    850 }
    851 #endif
    852 #endif
    853 
    854 #if NH_3D
    855 Void TComSlice::setCamparaSlice( Int** aaiScale, Int** aaiOffset )
    856 { 
    857   Int voiInVps      = m_pcVPS->getVoiInVps(getViewIndex() );
    858   if( m_pcVPS->getNumCp( voiInVps ) > 0 )
    859   {   
    860     if( m_pcVPS->getCpInSliceSegmentHeaderFlag( voiInVps ) )
    861     {
    862       for( Int m = 0; m < m_pcVPS->getNumCp( voiInVps ); m++ )
    863       {     
    864         Int j      = m_pcVPS->getCpRefVoi( voiInVps, m );
    865         Int jInVps = m_pcVPS->getVoiInVps( j );
    866 
    867         setCpScale   ( jInVps , aaiScale [ jInVps   ][ voiInVps ]);
    868         setCpInvScale( jInVps , aaiScale [ voiInVps ][ jInVps   ]);
    869         setCpOff     ( jInVps , aaiOffset[ jInVps   ][ voiInVps ]);
    870         setCpInvOff  ( jInVps , aaiOffset[ voiInVps ][ jInVps   ]);
    871       }
    872     }
    873   }
    874 }
    875 #endif
     737
    876738
    877739Void TComSlice::checkColRefIdx(UInt curSliceIdx, TComPic* pic)
    … …  
    11691031  }
    11701032#endif
    1171 #if NH_3D_DIS
    1172   m_bApplyDIS = pSrc->m_bApplyDIS;
    1173 #endif
    1174 #if NH_3D_IC
    1175   m_bApplyIC = pSrc->m_bApplyIC;
    1176   m_icSkipParseFlag = pSrc->m_icSkipParseFlag;
    1177 #endif
    11781033
    11791034}
    … …  
    19231778  for ( Int i = 0; i < MAX_VPS_OUTPUTLAYER_SETS; i++)
    19241779  {
    1925 #if !NH_3D_FIX_TICKET_107
    19261780    m_layerSetIdxForOlsMinus1[i]  = -1;
    1927 #endif
    19281781    for ( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++)
    19291782    {
    … …  
    19721825    m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1;
    19731826    m_numDirectRefLayers[i] = 0;
    1974 #if NH_3D
    1975     m_numRefListLayers[i] = 0;
    1976 #endif
    19771827    m_vpsRepFormatIdx    [i] = 0;
    19781828    m_pocLsbNotPresentFlag[i] = 0;   
    19791829    m_viewIdVal          [i] = 0;
    19801830
    1981 #if NH_3D
    1982     m_viewIndex         [i] = -1;
    1983 #endif
    19841831
    19851832    for( Int j = 0; j < MAX_NUM_LAYERS; j++ )
    … …  
    19891836      m_dependencyFlag  [i][j]    = false;
    19901837      m_idDirectRefLayer[i][j]    = -1;
    1991 #if NH_3D
    1992       m_idRefListLayer[i][j]    = -1;
    1993 #endif
    19941838      m_idPredictedLayer[i][j]    = -1;
    19951839      m_idRefLayer      [i][j]    = -1;
    … …  
    20011845      m_dimensionId[i][j] = 0;
    20021846    }
    2003 #if NH_3D_ARP
    2004 #endif
    20051847  } 
    20061848#endif
    … …  
    20781920    Int iNuhLId = getLayerIdInNuh( i );
    20791921    Int d = 0;
    2080 #if NH_3D
    2081     Int l = 0;
    2082 #endif
    20831922    Int r = 0;
    20841923    Int p = 0;
    … …  
    20911930        m_idDirectRefLayer[iNuhLId][d++] = jNuhLid;
    20921931      }
    2093 #if NH_3D
    2094       if( getDirectDependencyFlag( i , j ) && ( getDepthId( iNuhLId ) == getDepthId( jNuhLid ) ))
    2095       {
    2096         m_idRefListLayer [iNuhLId][l++] = jNuhLid;
    2097       }
    2098 #endif
    20991932
    21001933      if( getDependencyFlag( i , j ) )
    … …  
    21081941    }
    21091942    m_numDirectRefLayers[ iNuhLId ] = d;
    2110 #if NH_3D
    2111     m_numRefListLayers[ iNuhLId ] = l;
    2112 #endif
    21131943
    21141944    m_numRefLayers      [ iNuhLId ] = r;
    … …  
    21491979{
    21501980  m_numViews = 1;
    2151 #if NH_3D
    2152   AOF( m_viewOIdxList.size() == 0 );   
    2153   m_viewOIdxList.push_back( 0 );       
    2154 #endif
    21551981
    21561982  for( Int i = 0; i <=  getMaxLayersMinus1(); i++ )
    … …  
    21701996      {
    21711997        m_numViews++;
    2172 #if NH_3D
    2173         m_viewOIdxList.push_back( getViewOrderIdx( lId ) );       
    2174 #endif
    21751998      }
    21761999    }
    … …  
    21842007}
    21852008
    2186 #if NH_3D_VSO
    2187 Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag, Int auxId ) const
    2188 {
    2189   Int foundLayerIdinNuh = -1;
    2190 
    2191   for (Int layerIdInVps = 0 ; layerIdInVps <= getMaxLayersMinus1(); layerIdInVps++ )
    2192   {
    2193     Int layerIdInNuh = getLayerIdInNuh( layerIdInVps );
    2194 #if !NH_3D
    2195     if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getAuxId( layerIdInNuh ) == ( depthFlag ? 2 : 0 ) )  )
    2196 #else
    2197     if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getDepthId( layerIdInNuh ) == ( depthFlag ? 1 : 0 ) )  )
    2198 #endif
    2199     {
    2200       foundLayerIdinNuh = layerIdInNuh;
    2201       break;
    2202     }
    2203   }
    2204   return foundLayerIdinNuh;
    2205 }
    2206 #endif
    2207 #if NH_3D
    2208 Void TComVPS::createCamPars(Int iNumViews)
    2209 {
    2210   m_numCp                     .resize( iNumViews );
    2211   m_cpRefVoi                  .resize( iNumViews );
    2212   m_cpInSliceSegmentHeaderFlag.resize( iNumViews );
    2213   m_cpPresentFlag             .resize( iNumViews );
    2214   m_aaaiCodedScale            .resize( iNumViews );
    2215   m_aaaiCodedOffset           .resize( iNumViews );
    2216 
    2217   for ( Int i = 0; i < iNumViews ; i++ )
    2218   {
    2219     m_numCp                     [i] = 0;
    2220     m_cpRefVoi                  [i].resize( iNumViews );
    2221     m_cpInSliceSegmentHeaderFlag[i] = false;         
    2222     m_aaaiCodedScale            [i].resize( 2 );
    2223     m_aaaiCodedOffset           [i].resize( 2 );       
    2224     m_cpPresentFlag             [i].resize( iNumViews );
    2225 
    2226     for ( Int j = 0; j < iNumViews; j++)
    2227     {
    2228       m_cpRefVoi             [i][j] = 0;
    2229       m_cpPresentFlag        [i][j] = false;
    2230     }
    2231 
    2232     for ( Int j = 0; j < 2; j++ )
    2233     {
    2234       m_aaaiCodedScale       [i][j].resize( MAX_NUM_LAYERS );
    2235       m_aaaiCodedOffset      [i][j].resize( MAX_NUM_LAYERS );
    2236 
    2237       for ( Int k = 0; k < MAX_NUM_LAYERS; k++ )
    2238       {
    2239         m_aaaiCodedScale [i][j][k] = 0;
    2240         m_aaaiCodedOffset[i][j][k] = 0;
    2241       }
    2242     }
    2243   }
    2244 }
    2245 #endif // NH_3D
    22462009
    22472010
    … …  
    24962259  vector<Int> range;
    24972260
    2498 #if NH_3D
    2499   vector<Int> depthId;
    2500 #endif
    25012261
    25022262  vector<Int> viewOrderIndex;
    … …  
    25122272    auxId         .push_back( getAuxId       ( i ) );     
    25132273    viewId        .push_back( getViewId      ( getLayerIdInNuh( i ) ) );
    2514 #if NH_3D 
    2515     depthId.push_back( getDepthId( i ) );
    2516 #endif
    25172274  }
    25182275  std::cout << std::right << std::setw(60) << std::setfill('-') << " " << std::setfill(' ') << std::endl << "Layer Dependencies" << std::endl;
    … …  
    25232280  xPrintArray( "IdRefLayer"      , getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numRefLayers, m_idRefLayer, true );
    25242281  xPrintArray( "IdDirectRefLayer", getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numDirectRefLayers, m_idDirectRefLayer, true );
    2525 #if NH_3D
    2526   xPrintArray( "IdRefListLayer", getMaxLayersMinus1() + 1, m_layerIdInNuh, m_numRefListLayers, m_idRefListLayer, true );
    2527 #endif
    25282282
    25292283  std::cout << std::endl;
    … …  
    26192373}
    26202374
    2621 #if NH_3D
    2622 Void TComVPS::initViewCompLayer()
    2623 {
    2624   assert( m_viewCompLayerId.size() == 0 && m_viewCompLayerPresentFlag.size() == 0  );
    2625   for( Int i = 0; i < getNumViews(); i++ )
    2626   {
    2627     m_viewCompLayerId         .push_back( std::vector<Int>(0)  );
    2628     m_viewCompLayerPresentFlag.push_back( std::vector<Bool>(0) );     
    2629 
    2630     for( Int depFlag = 0; depFlag  <=  1; depFlag++ )
    2631     {
    2632       Int iViewOIdx = getViewOIdxList( i );
    2633       Int layerId = -1;
    2634       for( Int j = 0; j  <=  getMaxLayersMinus1(); j++ )
    2635       {
    2636         Int jNuhLId = getLayerIdInNuh( j );
    2637         if( getVpsDepthFlag( jNuhLId ) == ( (Bool) depFlag )  &&  getViewOrderIdx( jNuhLId )  ==  iViewOIdx 
    2638           &&  getDependencyId( jNuhLId )  ==  0  &&  getAuxId( jNuhLId )  ==  0 )
    2639         {
    2640           layerId = jNuhLId;
    2641         }
    2642       }
    2643       m_viewCompLayerPresentFlag[ i ].push_back( layerId  !=  -1 );
    2644       m_viewCompLayerId         [ i ].push_back( layerId );       
    2645     }
    2646   }
    2647 }
    2648 
    2649 Int TComVPS::getVoiInVps(Int viewOIdx) const
    2650 {
    2651   for ( Int i = 0; i < m_viewOIdxList.size(); i++ )
    2652   {
    2653     if  ( m_viewOIdxList[ i ] == viewOIdx )
    2654     {
    2655       return i;
    2656     }
    2657   }
    2658   assert( 0 );   
    2659   return -1;
    2660 }
    2661 
    2662 Void TComVPS::deriveCpPresentFlag()
    2663 {
    2664   for( Int nInVps = 0; nInVps < getNumViews(); nInVps++  )
    2665   {
    2666     for( Int mInVps = 0; mInVps < getNumViews(); mInVps++ )
    2667     {
    2668       m_cpPresentFlag[nInVps][mInVps] = 0;
    2669     }
    2670   }
    2671 
    2672   for( Int n = 1; n < getNumViews(); n++ )
    2673   {
    2674     Int iInVps = getVoiInVps(  getViewOIdxList( n ) );     
    2675     for( Int m = 0; m < getNumCp( iInVps ); m++ )
    2676     {
    2677       m_cpPresentFlag[ iInVps ][ getVoiInVps( getCpRefVoi( iInVps, m ) ) ] = 1;
    2678     }
    2679   }
    2680 }
    2681 
    2682 #endif
    26832375#endif // NH_MV
    26842376
    … …  
    28452537, m_pocResetInfoPresentFlag          (false)
    28462538#endif
    2847 #if NH_3D_DLT
    2848 , m_cDLT                             ()
    2849 #endif
    28502539{
    28512540#if NH_MV
    … …  
    28622551}
    28632552
    2864 #if NH_3D_DLT
    2865 TComDLT::TComDLT()
    2866 : m_bDltPresentFlag(false)
    2867 , m_iNumDepthViews(0)
    2868 , m_uiDepthViewBitDepth(8)
    2869 {
    2870   for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
    2871   {
    2872     m_bUseDLTFlag                 [i] = false;
    2873     m_bInterViewDltPredEnableFlag [i] = false;
    2874     m_bDltBitMapRepFlag           [i] = false;
    2875 
    2876     // allocate some memory and initialize with default mapping
    2877     m_iNumDepthmapValues[i] = ((1 << m_uiDepthViewBitDepth)-1)+1;
    2878     m_iDepthValue2Idx[i]    = std::vector<Int>(m_iNumDepthmapValues[i]);
    2879     m_iIdx2DepthValue[i]    = std::vector<Int>(m_iNumDepthmapValues[i]);
    2880    
    2881     m_iDepthIdxToLayerId[i] = i;
    2882 
    2883     //default mapping
    2884     for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
    2885     {
    2886       m_iDepthValue2Idx[i][d] = d;
    2887       m_iIdx2DepthValue[i][d] = d;
    2888     }
    2889   }
    2890 }
    2891 
    2892 TComDLT::~TComDLT()
    2893 {
    2894  
    2895 }
    2896 
    2897 Void TComDLT::setDepthLUTs(Int layerIdInVps, std::vector<Int> idxToDepthValueTable, Int iNumDepthValues)
    2898 {
    2899   if( iNumDepthValues == 0 ) // default mapping only
    2900     return;
    2901 
    2902   // copy idx2DepthValue to internal array
    2903   m_iIdx2DepthValue[layerIdInVps] = idxToDepthValueTable;
    2904 
    2905   UInt uiMaxDepthValue = ((1 << m_uiDepthViewBitDepth)-1);
    2906   for(Int p=0; p<=uiMaxDepthValue; p++)
    2907   {
    2908     Int iIdxDown    = 0;
    2909     Int iIdxUp      = iNumDepthValues-1;
    2910     Bool bFound     = false;
    2911 
    2912     // iterate over indices to find lower closest depth
    2913     Int i = 1;
    2914     while(!bFound && i<iNumDepthValues)
    2915     {
    2916       if( m_iIdx2DepthValue[layerIdInVps][i] > p )
    2917       {
    2918         iIdxDown  = i-1;
    2919         bFound    = true;
    2920       }
    2921 
    2922       i++;
    2923     }
    2924     iIdxUp = bFound ?  iIdxDown + 1 : iNumDepthValues-1;
    2925 
    2926     // assign closer depth value/idx
    2927     if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
    2928     {
    2929       m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
    2930     }
    2931     else
    2932     {
    2933       m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
    2934     }
    2935 
    2936   }
    2937 
    2938   // update DLT variables
    2939   m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
    2940 }
    2941 
    2942 Void TComDLT::getDeltaDLT( Int layerIdInVps, std::vector<Int> piDLTInRef, UInt uiDLTInRefNum, std::vector<Int>& riDeltaDLTOut, UInt&ruiDeltaDLTOutNum ) const
    2943 {
    2944   Bool abBM0[ 256 ];
    2945   Bool abBM1[ 256 ];
    2946  
    2947   memset( abBM0, 0, sizeof( abBM0 ));
    2948   memset( abBM1, 0, sizeof( abBM1 ));
    2949  
    2950   // convert reference DLT to bit string
    2951   for( Int i = 0; i < uiDLTInRefNum; i++ )
    2952   {
    2953     abBM0[ piDLTInRef[ i ] ] = true;
    2954   }
    2955   // convert internal DLT to bit string
    2956   for( Int i = 0; i < m_iNumDepthmapValues[ layerIdInVps ]; i++ )
    2957   {
    2958     abBM1[ m_iIdx2DepthValue[ layerIdInVps ][ i ] ] = true;
    2959   }
    2960  
    2961   ruiDeltaDLTOutNum = 0;
    2962   for( Int i = 0; i < 256; i++ )
    2963   {
    2964     if( abBM0[ i ] ^ abBM1[ i ] )
    2965     {
    2966       riDeltaDLTOut[ ruiDeltaDLTOutNum++ ] = i;
    2967     }
    2968   }
    2969 }
    2970 
    2971 Void TComDLT::setDeltaDLT( Int layerIdInVps, std::vector<Int> piDLTInRef, UInt uiDLTInRefNum, std::vector<Int> piDeltaDLTIn, UInt uiDeltaDLTInNum )
    2972 {
    2973   Bool abBM0[ 256 ];
    2974   Bool abBM1[ 256 ];
    2975  
    2976   memset( abBM0, 0, sizeof( abBM0 ));
    2977   memset( abBM1, 0, sizeof( abBM1 ));
    2978  
    2979   // convert reference DLT to bit string
    2980   for( Int i = 0; i < uiDLTInRefNum; i++ )
    2981   {
    2982     abBM0[ piDLTInRef[ i ] ] = true;
    2983   }
    2984   // convert delta DLT to bit string
    2985   for( Int i = 0; i < uiDeltaDLTInNum; i++ )
    2986   {
    2987     abBM1[ piDeltaDLTIn[ i ] ] = true;
    2988   }
    2989  
    2990   std::vector<Int> aiIdx2DepthValue(256, 0);
    2991   UInt uiNumDepthValues = 0;
    2992   std::fill(aiIdx2DepthValue.begin(), aiIdx2DepthValue.end(), 0);
    2993  
    2994   for( Int i = 0; i < 256; i++ )
    2995   {
    2996     if( abBM0[ i ] ^ abBM1[ i ] )
    2997     {
    2998       aiIdx2DepthValue[ uiNumDepthValues++ ] = i;
    2999     }
    3000   }
    3001  
    3002   // update internal tables
    3003   setDepthLUTs(layerIdInVps, aiIdx2DepthValue, uiNumDepthValues);
    3004 }
    3005 
    3006 #endif
    30072553
    30082554#if NH_MV
    … …  
    35123058{
    35133059  const TComVPS* vps = getVPS();
    3514 #if NH_3D
    3515   Int refLayerIdx = vps->getLayerIdInVps( vps->getIdRefListLayer( getLayerId(), i ) );
    3516 #else
    35173060  Int refLayerIdx = vps->getLayerIdInVps( vps->getIdDirectRefLayer( getLayerId(), i ) );
    3518 #endif
    35193061
    35203062  Bool refLayerPicFlag = ( vps->getSubLayersVpsMaxMinus1( refLayerIdx ) >=  getTLayer()  && ( getTLayer() == 0   ||
    … …  
    35273069  Int refLayerPicIdc = -1;
    35283070  Int curj = 0;
    3529 #if NH_3D
    3530   for( Int i = 0;  i < getVPS()->getNumRefListLayers( getLayerId()) ; i++ )
    3531 #else
    35323071  for( Int i = 0;  i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
    3533 #endif
    35343072  {
    35353073    if( getRefLayerPicFlag( i ) )
    … …  
    35523090{ 
    35533091  Int numRefLayerPics = 0;
    3554 #if NH_3D
    3555   for( Int i = 0;  i < getVPS()->getNumRefListLayers( getLayerId()) ; i++ )
    3556 #else
    35573092  for( Int i = 0;  i < getVPS()->getNumDirectRefLayers( getLayerId()) ; i++ )
    3558 #endif
    35593093  {
    35603094    numRefLayerPics += getRefLayerPicFlag( i );
    … …  
    35813115    numActiveRefLayerPics = 0;
    35823116  }
    3583 #if NH_3D
    3584   else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumRefListLayers( getLayerId() ) == 1 )
    3585 #else
    35863117  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
    3587 #endif
    35883118  {
    35893119    numActiveRefLayerPics = 1;
    … …  
    35983128Int TComSlice::getRefPicLayerId( Int i ) const
    35993129{
    3600 #if NH_3D
    3601   return getVPS()->getIdRefListLayer( getLayerId(), getInterLayerPredLayerIdc( i ) );
    3602 #else
    36033130  return getVPS()->getIdDirectRefLayer( getLayerId(), getInterLayerPredLayerIdc( i ) );
    3604 #endif
    3605 }
    3606 #endif
    3607 #if NH_3D_NBDV
    3608 Void TComSlice::setDefaultRefView()
    3609 {
    3610   setDefaultRefViewIdx(-1);
    3611   setDefaultRefViewIdxAvailableFlag(false);
    3612 
    3613   Int valid = 0;
    3614   Int DefaultRefViewIdx = -1;
    3615 
    3616   for(UInt curViewIdx = 0; curViewIdx < getViewIndex() && valid == 0; curViewIdx++)
    3617   {
    3618     for(Int iRefListId = 0; (iRefListId < (isInterB() ? 2 : 1)) && !isIntra() && valid == 0; iRefListId++)
    3619     {
    3620       RefPicList eRefPicList = RefPicList(iRefListId);
    3621       Int        iNumRefPics = getNumRefIdx(eRefPicList);
    3622 
    3623       for(Int i = 0; i < iNumRefPics; i++)
    3624       {
    3625         if(getPOC() == getRefPic(eRefPicList, i)->getPOC() && curViewIdx == getRefPic(eRefPicList, i)->getViewIndex())
    3626         {
    3627           valid = 1;
    3628           DefaultRefViewIdx = curViewIdx;
    3629           break;
    3630         }
    3631       }
    3632     }
    3633   }
    3634 
    3635   if(valid)
    3636   {
    3637     setDefaultRefViewIdx(DefaultRefViewIdx);
    3638     setDefaultRefViewIdxAvailableFlag(true);
    3639   }
    3640 }
    3641 #endif
    3642 
    3643 #if NH_3D_ARP
    3644 Void TComSlice::setARPStepNum( TComPicLists*ivPicLists )
    3645 {
    3646   Bool tempRefPicInListsFlag = false;
    3647   if( !getIvResPredFlag() || this->isIRAP())
    3648   {
    3649     m_nARPStepNum = 0;
    3650   }
    3651   else
    3652   {
    3653     setFirstTRefIdx (REF_PIC_LIST_0, -1);
    3654     setFirstTRefIdx (REF_PIC_LIST_1, -1);
    3655     for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
    3656     {
    3657       Int diffPOC=MAX_INT;
    3658       Int idx=-1;
    3659       for(Int i = 0; i < getNumRefIdx(RefPicList(refListIdx)); i++ )
    3660       {
    3661         if ( getRefPic(RefPicList(refListIdx), i)->getPOC() != getPOC() )
    3662         {
    3663           if( abs(getRefPic(RefPicList(refListIdx), i)->getPOC() - getPOC()) < diffPOC)
    3664           {
    3665             diffPOC=abs(getRefPic(RefPicList(refListIdx), i)->getPOC() - getPOC());
    3666             idx=i;
    3667           }
    3668         }
    3669         if(idx>=0)
    3670         {
    3671           setFirstTRefIdx (RefPicList(refListIdx), idx);
    3672         }
    3673       }
    3674     }
    3675     tempRefPicInListsFlag = (getFirstTRefIdx(REF_PIC_LIST_0) >= 0 || getFirstTRefIdx(REF_PIC_LIST_1) >= 0) && getDefaultRefViewIdxAvailableFlag();
    3676     m_nARPStepNum = tempRefPicInListsFlag ? 3 : 0;
    3677   }
    3678 
    3679   if (tempRefPicInListsFlag)
    3680   {
    3681     for ( Int refListIdx = 0; refListIdx < ((m_eSliceType==B_SLICE) ? 2 : 1); refListIdx++ )
    3682     {
    3683       RefPicList eRefPicList = RefPicList( refListIdx );
    3684       Int prevPOC = getRefPic(eRefPicList, getFirstTRefIdx(eRefPicList) )->getPOC();
    3685       for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
    3686       {
    3687         Int layerIdInNuh = getRefPicLayerId( i );
    3688 
    3689         TComPic* picV = getIvPic( getIsDepth(), getVPS()->getViewIndex( layerIdInNuh ) );
    3690         assert( picV != NULL );
    3691         IntAry1d pocsInCurrRPSsPicV = picV->getSlice(0)->getPocsInCurrRPSs();
    3692         Bool refRpRefAvailFlag = false;
    3693         for (Int idx = 0; idx < pocsInCurrRPSsPicV.size(); idx++)
    3694         {
    3695           if ( pocsInCurrRPSsPicV[idx] == prevPOC )
    3696           {
    3697             refRpRefAvailFlag = true;
    3698             break;
    3699           }
    3700         }
    3701 
    3702         if (getFirstTRefIdx(eRefPicList) >= 0 && refRpRefAvailFlag )
    3703         {
    3704           m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = true;
    3705         }
    3706         else
    3707         {
    3708           m_arpRefPicAvailable[eRefPicList][layerIdInNuh] = false;
    3709         }
    3710       }
    3711     }
    3712   }
    3713   if( m_nARPStepNum > 1)
    3714   {
    3715     for(Int i = 0; i < getNumActiveRefLayerPics(); i ++ )
    3716     {
    3717       Int  iLayerId = getRefPicLayerId( i );
    3718       Int  iViewIdx =   getVPS()->getViewIndex(iLayerId);
    3719       Bool bIsDepth = ( getVPS()->getDepthId  ( iLayerId ) == 1 );
    3720       if( iViewIdx<getViewIndex() && !bIsDepth )
    3721       {
    3722         setBaseViewRefPicList( ivPicLists->getSubDpb( iLayerId, false ), iViewIdx );
    3723       }
    3724     }
    3725   }
    3726 }
    3727 #endif
    3728 
    3729 #if NH_3D_IC
    3730 // This is an encoder only function and should be moved to TEncSlice or TEncSearch!!
    3731 Void TComSlice::xSetApplyIC(Bool bUseLowLatencyICEnc)
    3732 {
    3733   if(bUseLowLatencyICEnc)
    3734   {
    3735     Bool existInterViewRef=false;
    3736     TComPic* pcCurrPic = getPic();
    3737     TComPic* pcRefPic = NULL;
    3738     for ( Int i = 0; (i < getNumRefIdx( REF_PIC_LIST_0 )) && !existInterViewRef; i++ )
    3739     {
    3740       pcRefPic = getRefPic( REF_PIC_LIST_0, i );
    3741       if ( pcRefPic != NULL )
    3742       {
    3743         if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
    3744         {
    3745           existInterViewRef = true;
    3746         }
    3747       }
    3748     }
    3749 
    3750     for ( Int i = 0; (i < getNumRefIdx( REF_PIC_LIST_1 )) && !existInterViewRef; i++ )
    3751     {
    3752       pcRefPic = getRefPic( REF_PIC_LIST_1, i );
    3753       if ( pcRefPic != NULL )
    3754       {
    3755         if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
    3756         {
    3757           existInterViewRef = true;       
    3758         }
    3759       }
    3760     }
    3761 
    3762     if(!existInterViewRef)
    3763     {
    3764       m_bApplyIC = false;
    3765     }
    3766     else
    3767     {
    3768       Int curLayer=getDepth();
    3769       if( curLayer>9) curLayer=9; // Max layer is 10
    3770 
    3771       m_bApplyIC = true;
    3772       Int refLayer = curLayer-1;
    3773 
    3774       Int ICEnableCandidate = getICEnableCandidate(refLayer);
    3775       Int ICEnableNum = getICEnableNum(refLayer);
    3776       if( (refLayer>=0) && (ICEnableCandidate>0) )
    3777       {   
    3778         Double ratio=Double(ICEnableNum/Double(ICEnableCandidate));
    3779 
    3780         if( ratio > IC_LOW_LATENCY_ENCODING_THRESHOLD)
    3781         {
    3782           m_bApplyIC=true;
    3783         }
    3784         else
    3785         {
    3786           m_bApplyIC=false;
    3787         }
    3788       }
    3789       setICEnableCandidate(curLayer, 0);
    3790       setICEnableNum(curLayer, 0);
    3791     }
    3792   }
    3793   else
    3794   {       
    3795     TComPic*    pcCurrPic = getPic();
    3796     TComPicYuv* pcCurrPicYuv = pcCurrPic->getPicYuvOrg();
    3797    
    3798     // Get InterView Reference picture
    3799     // !!!!! Assume only one Interview Reference Picture in L0
    3800     // GT: Is this assumption correct?
    3801 
    3802     TComPicYuv* pcRefPicYuvOrg = NULL;
    3803     for ( Int i = 0; i < getNumRefIdx( REF_PIC_LIST_0 ); i++ )
    3804     {
    3805       TComPic* pcRefPic = getRefPic( REF_PIC_LIST_0, i );
    3806       if ( pcRefPic != NULL )
    3807       {
    3808         if ( pcCurrPic->getViewIndex() != pcRefPic->getViewIndex() )
    3809         {
    3810           pcRefPicYuvOrg = pcRefPic->getPicYuvOrg();
    3811         }
    3812       }
    3813     }
    3814 
    3815     if ( pcRefPicYuvOrg != NULL )
    3816     {
    3817       // Histogram building - luminance
    3818       Int iMaxPelValue = ( 1 << getSPS()->getBitDepth(CHANNEL_TYPE_LUMA) );
    3819       Int *aiRefOrgHist = (Int *) xMalloc( Int,iMaxPelValue );
    3820       Int *aiCurrHist   = (Int *) xMalloc( Int,iMaxPelValue );
    3821       memset( aiRefOrgHist, 0, iMaxPelValue*sizeof(Int) );
    3822       memset( aiCurrHist, 0, iMaxPelValue*sizeof(Int) );
    3823 
    3824       Int iWidth   = pcCurrPicYuv->getWidth(COMPONENT_Y);
    3825       Int iHeight  = pcCurrPicYuv->getHeight(COMPONENT_Y);
    3826       Pel* pCurrY   = pcCurrPicYuv->getAddr(COMPONENT_Y);
    3827       Pel* pRefOrgY = pcRefPicYuvOrg->getAddr(COMPONENT_Y);
    3828       Int iCurrStride = pcCurrPicYuv->getStride(COMPONENT_Y);
    3829       Int iRefStride = pcRefPicYuvOrg->getStride(COMPONENT_Y);
    3830       for ( Int y = 0; y < iHeight; y++ )
    3831       {
    3832         for ( Int x = 0; x < iWidth; x++ )
    3833         {
    3834           aiCurrHist[pCurrY[x]]++;
    3835           aiRefOrgHist[pRefOrgY[x]]++;
    3836         }
    3837         pCurrY += iCurrStride;
    3838         pRefOrgY += iRefStride;
    3839       }
    3840 
    3841       // Histogram SAD
    3842       Int iSumOrgSAD = 0;
    3843       for ( Int i = 0; i < iMaxPelValue; i++ )
    3844       {
    3845         iSumOrgSAD += abs( aiCurrHist[i] - aiRefOrgHist[i] );
    3846       }
    3847 
    3848       // Setting
    3849       Double dThresholdOrgSAD = getIsDepth() ? 0.1 : 0.05;
    3850 
    3851       if ( iSumOrgSAD > Int( dThresholdOrgSAD * iWidth * iHeight ) )
    3852       {
    3853         m_bApplyIC = true;
    3854       }
    3855       else
    3856       {
    3857         m_bApplyIC = false;
    3858       }
    3859 
    3860       xFree( aiCurrHist   );
    3861       xFree( aiRefOrgHist );
    3862     }
    3863   }//if(bUseLowLatencyICEnc)
    3864 }
    3865 #endif
    3866 #if NH_3D_QTL
    3867 Void TComSlice::setIvPicLists( TComPicLists* m_ivPicLists )
    3868 { 
    3869   for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
    3870   {
    3871     for ( Int depthId = 0; depthId < 2; depthId++ )
    3872     {
    3873       m_ivPicsCurrPoc[ depthId ][ i ] = ( i <= m_viewIndex ) ? m_ivPicLists->getPic( i, ( depthId == 1) , 0, getPOC() ) : NULL;
    3874     }       
    3875   } 
    3876 }
    3877 #endif
    3878 #if NH_3D
    3879 Void TComSlice::setDepthToDisparityLUTs()
    3880 {
    3881   Bool setupLUT = false;
    3882  
    3883   setupLUT = setupLUT || getViewSynthesisPredFlag( );
    3884 
    3885 #if NH_3D_NBDV_REF
    3886   setupLUT = setupLUT || getDepthRefinementFlag( );
    3887 #endif 
    3888 
    3889 #if NH_3D_IV_MERGE
    3890   setupLUT = setupLUT || ( getIvMvPredFlag() && getIsDepth() );
    3891 #endif
    3892 
    3893   Int bitDepthY = getSPS()->getBitDepth(CHANNEL_TYPE_LUMA);
    3894 
    3895   if( !setupLUT )
    3896   {
    3897     return;
    3898   }
    3899 
    3900   m_numViews = getVPS()->getNumViews();
    3901   /// GT: Allocation should be moved to a better place later;
    3902   if ( m_depthToDisparityB == NULL )
    3903   {
    3904     m_depthToDisparityB = new Int*[ m_numViews ];
    3905     for ( Int i = 0; i < getVPS()->getNumViews(); i++ )
    3906     {
    3907       m_depthToDisparityB[ i ] = new Int[ Int(1 << bitDepthY) ];
    3908     }
    3909   }
    3910 
    3911  
    3912   if ( m_depthToDisparityF == NULL )
    3913   {
    3914     m_depthToDisparityF = new Int*[ m_numViews ];
    3915     for ( Int i = 0; i < m_numViews; i++ )
    3916     {
    3917       m_depthToDisparityF[ i ] = new Int[ Int(1 << bitDepthY) ];
    3918     }
    3919   }
    3920 
    3921   assert( m_depthToDisparityB != NULL );
    3922   assert( m_depthToDisparityF != NULL );
    3923 
    3924   const TComVPS* vps = getVPS();
    3925 
    3926   Int log2Div = bitDepthY - 1 + vps->getCpPrecision();
    3927   Int voiInVps = vps->getVoiInVps( getViewIndex() );
    3928   Bool camParaSH = vps->getCpInSliceSegmentHeaderFlag( voiInVps ); 
    3929 
    3930   const IntAry1d codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : vps->getCodedScale    ( voiInVps );
    3931   const IntAry1d codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : vps->getCodedOffset   ( voiInVps );
    3932   const IntAry1d invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : vps->getInvCodedScale ( voiInVps );
    3933   const IntAry1d invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : vps->getInvCodedOffset( voiInVps );
    3934 
    3935 
    3936   for (Int i = 0; i < voiInVps; i++)
    3937   {
    3938     Int iInVoi = vps->getVoiInVps( i );
    3939 #if ENC_DEC_TRACE && NH_MV_ENC_DEC_TRAC
    3940     if ( g_traceCameraParameters )
    3941     {
    3942       std::cout << "Cp: " << codScale   [ iInVoi ] << " " <<    codOffset[ iInVoi ] << " "
    3943                 << invCodScale[ iInVoi ] << " " << invCodOffset[ iInVoi ] << " " << log2Div << std::endl ;
    3944     }
    3945 #endif
    3946     for ( Int d = 0; d <= ( ( 1 << bitDepthY ) - 1 ); d++ )
    3947     {     
    3948       Int offset =    ( codOffset  [ iInVoi ] << bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
    3949       m_depthToDisparityB[ iInVoi ][ d ] = ( codScale [ iInVoi ] * d + offset ) >> log2Div;
    3950 
    3951       Int invOffset = ( invCodOffset[ iInVoi ] << bitDepthY ) + ( ( 1 << log2Div ) >> 1 );         
    3952       m_depthToDisparityF[ iInVoi ][ d ] = ( invCodScale[ iInVoi ] * d + invOffset ) >> log2Div;
    3953     }
    3954   }
    3955 }
    3956 #endif
     3131}
     3132#endif
     3133
     3134
    39573135
    39583136
    … …  
    43113489
    43123490
    4313 #if NH_3D
    4314 Void TComSlice::init3dToolParameters()
    4315 {
    4316   Bool depthFlag = getIsDepth();
    4317 
    4318   Bool nRLLG0 =  ( getVPS()->getNumRefListLayers( getLayerId() ) > 0 );     
    4319 
    4320   const TComSps3dExtension* sps3dExt = getSPS()->getSps3dExtension();
    4321 
    4322   m_ivMvPredFlag           = sps3dExt->getIvDiMcEnabledFlag          ( depthFlag ) && nRLLG0                       ;                             
    4323   m_ivMvScalingFlag        = sps3dExt->getIvMvScalEnabledFlag        ( depthFlag )                                 ;                             
    4324   m_ivResPredFlag          = sps3dExt->getIvResPredEnabledFlag       ( depthFlag ) && nRLLG0                       ;                               
    4325   m_depthRefinementFlag    = sps3dExt->getDepthRefEnabledFlag        ( depthFlag )           && getInCompPredFlag() && m_cpAvailableFlag;
    4326   m_viewSynthesisPredFlag  = sps3dExt->getVspMcEnabledFlag           ( depthFlag ) && nRLLG0 && getInCompPredFlag() && m_cpAvailableFlag;
    4327   m_depthBasedBlkPartFlag  = sps3dExt->getDbbpEnabledFlag            ( depthFlag )           && getInCompPredFlag();                         
    4328   m_mpiFlag                = sps3dExt->getTexMcEnabledFlag           ( depthFlag )           && getInCompPredFlag();
    4329   m_intraContourFlag       = sps3dExt->getIntraContourEnabledFlag    ( depthFlag )           && getInCompPredFlag();
    4330   m_intraSdcWedgeFlag      = sps3dExt->getIntraDcOnlyWedgeEnabledFlag( depthFlag )                                 ;                         
    4331   m_qtPredFlag             = sps3dExt->getCqtCuPartPredEnabledFlag   ( depthFlag )           && getInCompPredFlag();
    4332   m_interSdcFlag           = sps3dExt->getInterDcOnlyEnabledFlag     ( depthFlag )                                 ; 
    4333   m_depthIntraSkipFlag     = sps3dExt->getSkipIntraEnabledFlag       ( depthFlag )                                 ;                         
    4334 
    4335   m_subPbSize              =  1 << ( sps3dExt->getLog2IvmcSubPbSizeMinus3 ( depthFlag ) + 3 ); 
    4336   m_mpiSubPbSize           =  1 << ( sps3dExt->getLog2TexmcSubPbSizeMinus3( depthFlag ) + 3 );
    4337 
    4338 
    4339 #if NH_3D_OUTPUT_ACTIVE_TOOLS
    4340   std::cout << "Layer:                  :" << getLayerId()             << std::endl;
    4341   std::cout << "DepthFlag:              :" << getIsDepth()             << std::endl;
    4342   std::cout << "ViewOrderIdx:           :" << getViewIndex()           << std::endl;
    4343   std::cout << "InterCmpPredAvailableFlag:" << getInCmpPredAvailFlag() << std::endl;
    4344   std::cout << "InterCompPredFlag       :"  << getInCompPredFlag()     << std::endl;
    4345  
    4346   std::cout << "ivMvPredFlag            :" << m_ivMvPredFlag           << std::endl;
    4347   std::cout << "ivMvScalingFlag         :" << m_ivMvScalingFlag        << std::endl;
    4348   std::cout << "ivResPredFlag           :" << m_ivResPredFlag          << std::endl;
    4349   std::cout << "depthRefinementFlag     :" << m_depthRefinementFlag    << std::endl;
    4350   std::cout << "viewSynthesisPredFlag   :" << m_viewSynthesisPredFlag  << std::endl;
    4351   std::cout << "depthBasedBlkPartFlag   :" << m_depthBasedBlkPartFlag  << std::endl;
    4352   std::cout << "mpiFlag                 :" << m_mpiFlag                << std::endl;
    4353   std::cout << "intraContourFlag        :" << m_intraContourFlag       << std::endl;
    4354   std::cout << "intraSdcWedgeFlag       :" << m_intraSdcWedgeFlag      << std::endl;
    4355   std::cout << "qtPredFlag              :" << m_qtPredFlag             << std::endl;
    4356   std::cout << "interSdcFlag            :" << m_interSdcFlag           << std::endl;
    4357   std::cout << "depthIntraSkipFlag      :" << m_depthIntraSkipFlag     << std::endl;   
    4358   std::cout << "subPbSize               :" << m_subPbSize              << std::endl;
    4359   std::cout << "mpiSubPbSize            :" << m_mpiSubPbSize           << std::endl;
    4360 #endif
    4361 }
    4362 
    4363 Void TComSlice::deriveInCmpPredAndCpAvailFlag( )
    4364 {
    4365   Int numCurCmpLIds = getIsDepth() ? 1 : getNumActiveRefLayerPics();
    4366   std::vector<Int> curCmpLIds;
    4367   if ( getIsDepth() )
    4368   {
    4369     curCmpLIds.push_back( getLayerId() );
    4370   }
    4371   else
    4372   {
    4373     for (Int i = 0; i < numCurCmpLIds; i++)
    4374     {
    4375       curCmpLIds.push_back( getRefPicLayerId( i ) );
    4376     }
    4377   }
    4378 
    4379   m_cpAvailableFlag = true;
    4380   m_inCmpRefViewIdcs.clear();
    4381   Bool allRefCmpLayersAvailFlag = true;
    4382 
    4383   for( Int i = 0; i <= numCurCmpLIds - 1; i++ )
    4384   {     
    4385     m_inCmpRefViewIdcs.push_back( getVPS()->getViewOrderIdx( curCmpLIds[ i ] ));
    4386     if( !getVPS()->getCpPresentFlag( getVPS()->getVoiInVps( getViewIndex() ),  getVPS()->getVoiInVps( m_inCmpRefViewIdcs[ i ] ) ) )
    4387     {
    4388       m_cpAvailableFlag = false;
    4389     }
    4390     Bool refCmpCurLIdAvailFlag = false;
    4391     if( getVPS()->getViewCompLayerPresentFlag( m_inCmpRefViewIdcs[ i ], !getIsDepth() ) )
    4392     {
    4393       Int j = getVPS()->getLayerIdInVps( getVPS()->getViewCompLayerId( m_inCmpRefViewIdcs[ i ],  !getIsDepth() ) );
    4394       if  ( getVPS()->getDirectDependencyFlag( getVPS()->getLayerIdInVps( getLayerId() ) ,  j ) &&
    4395         getVPS()->getSubLayersVpsMaxMinus1( j ) >= getTemporalId()   &&
    4396         ( getTemporalId() == 0 || getVPS()->getMaxTidIlRefPicsPlus1( j , getVPS()->getLayerIdInVps( getLayerId() ) ) > getTemporalId() )       
    4397         )
    4398       {
    4399         refCmpCurLIdAvailFlag = true;
    4400       }
    4401     }
    4402     if( !refCmpCurLIdAvailFlag )
    4403     {
    4404       allRefCmpLayersAvailFlag = false;
    4405     }
    4406   }
    4407 
    4408   if( !allRefCmpLayersAvailFlag )
    4409   {
    4410     m_inCmpPredAvailFlag = false;
    4411   } 
    4412   else
    4413   {
    4414     const TComSps3dExtension* sps3dExt = getSPS()->getSps3dExtension();
    4415     if( !getIsDepth() )
    4416     {
    4417       m_inCmpPredAvailFlag = sps3dExt->getVspMcEnabledFlag( getIsDepth() ) ||
    4418         sps3dExt->getDbbpEnabledFlag( getIsDepth() ) ||
    4419         sps3dExt->getDepthRefEnabledFlag  ( getIsDepth() );                           
    4420     }
    4421     else
    4422     {
    4423       m_inCmpPredAvailFlag = sps3dExt->getIntraContourEnabledFlag( getIsDepth() ) ||
    4424         sps3dExt->getCqtCuPartPredEnabledFlag( getIsDepth() ) ||
    4425         sps3dExt->getTexMcEnabledFlag( getIsDepth() );                                 
    4426     }
    4427   }
    4428 }
    4429 
    4430 Void TComSlice::checkInCompPredRefLayers()
    4431 { 
    4432   if ( getInCompPredFlag() )
    4433   {
    4434     for (Int i = 0; i < getNumCurCmpLIds(); i++ )
    4435     {     
    4436       assert( getIvPic(!getIsDepth(), getInCmpRefViewIdcs( i ) ) != NULL );       
    4437       //  It is a requirement of bitstream conformance that there
    4438       //  is a picture in the DPB with PicOrderCntVal equal to the PicOrderCntVal of the current picture,
    4439       //  and a nuh_layer_id value equal to ViewCompLayerId[ inCmpRefViewIdcs[ i ] ][ !DepthFlag ].
    4440     }
    4441   }
    4442 }
    4443 
    4444 Void TComSlice::setPocsInCurrRPSs()
    4445 {
    4446   // Currently only needed at decoder side;
    4447   m_pocsInCurrRPSs.clear();   
    4448   std::vector<TComPic*>** rpsCurr = getPic()->getDecodedRps()->m_refPicSetsCurr;
    4449   for (Int i = 0 ; i < 3; i++ )
    4450   {
    4451     for( Int j = 0; j < rpsCurr[i]->size(); j++ )
    4452     {
    4453       m_pocsInCurrRPSs.push_back( (*rpsCurr[i])[j]->getPOC() );
    4454     }
    4455   }
    4456 }
    4457 
    4458 #endif
    44593491
    44603492/** get scaling matrix from RefMatrixID
Note: See TracChangeset for help on using the changeset viewer.