Changeset 758 in 3DVCSoftware for trunk/source/Lib


Ignore:
Timestamp:
3 Jan 2014, 17:43:40 (11 years ago)
Author:
tech
Message:

Merged HTM-9.1-dev0-MediaTek@757. (3D-HEVC HLS)

Location:
trunk/source/Lib
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/Lib/TLibCommon/TComPrediction.cpp

    r724 r758  
    506506    {
    507507#if H_3D_DIM_DLT
     508#if DLT_DIFF_CODING_IN_PPS
     509      segDC1 = pcCU->getSlice()->getPPS()->getDLT()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 ) + deltaDC1 );
     510      segDC2 = pcCU->getSlice()->getPPS()->getDLT()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 ) + deltaDC2 );
     511#else
    508512      segDC1 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 ) + deltaDC1 );
    509513      segDC2 = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 ) + deltaDC2 );
     514#endif
    510515#else
    511516      segDC1 = ClipY( predDC1 + deltaDC1 );

  • trunk/source/Lib/TLibCommon/TComSlice.cpp

    r738 r758  
    782782Void TComSlice::setCamparaSlice( Int** aaiScale, Int** aaiOffset )
    783783{ 
     784#if CAM_HLS_F0136_F0045_F0082
     785  if( m_pcVPS->hasCamParInSliceHeader( m_viewIndex ) )
     786#else
    784787  if( m_pcSPS->hasCamParInSliceHeader() )
     788#endif
    785789  {   
    786790    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < m_viewIndex; uiBaseViewIndex++ )
    … …  
    18161820    m_vpsDepthModesFlag [i] = false;
    18171821#if H_3D_DIM_DLT
     1822#if !DLT_DIFF_CODING_IN_PPS
    18181823    m_bUseDLTFlag         [i] = false;
    18191824   
    … …  
    18321837    }
    18331838#endif
     1839#endif
    18341840#if H_3D
    18351841    m_ivMvScalingFlag = true;
    … …  
    19021908    if (m_repFormat[ i ] != NULL )      delete m_repFormat[ i ];   
    19031909#if H_3D_DIM_DLT
     1910#if !DLT_DIFF_CODING_IN_PPS
    19041911    if ( m_iDepthValue2Idx[i] != 0 )
    19051912    {
    … …  
    19141921    }
    19151922#endif
    1916   }
     1923#endif
     1924  }
     1925#endif
     1926#if CAM_HLS_F0136_F0045_F0082
     1927  deleteCamPars();
    19171928#endif
    19181929}
    19191930
    19201931#if H_3D_DIM_DLT
     1932#if !DLT_DIFF_CODING_IN_PPS
    19211933  Void TComVPS::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
    19221934  {
    … …  
    19801992  }
    19811993#endif
     1994#endif
    19821995
    19831996#if H_MV
    … …  
    20662079  return foundLayerIdinNuh;
    20672080}
     2081#if CAM_HLS_F0136_F0045_F0082
     2082Void TComVPS::createCamPars(Int iNumViews)
     2083{
     2084  Int i = 0, j = 0;
     2085
     2086  m_bCamParPresent = new Bool[ iNumViews ];
     2087  m_bCamParInSliceHeader = new Bool[ iNumViews ];
     2088
     2089  m_aaaiCodedScale = new Int**[ iNumViews ];
     2090  m_aaaiCodedOffset = new Int**[ iNumViews ];
     2091  for ( i = 0; i < iNumViews ; i++ )
     2092  {
     2093    m_aaaiCodedScale[i] = new Int*[ 2 ];
     2094    m_aaaiCodedOffset[i] = new Int*[ 2 ];
     2095    for ( j = 0; j < 2; j++ )
     2096    {
     2097      m_aaaiCodedScale[i][j] = new Int[ MAX_NUM_LAYERS ];
     2098      m_aaaiCodedOffset[i][j] = new Int[ MAX_NUM_LAYERS ];
     2099      for ( Int k = 0; k < MAX_NUM_LAYERS; k++ )
     2100      {
     2101        m_aaaiCodedScale[i][j][k] = 0;
     2102        m_aaaiCodedOffset[i][j][k] = 0;
     2103      }
     2104    }
     2105  }
     2106}
     2107
     2108Void TComVPS::deleteCamPars()
     2109{
     2110  Int iNumViews = getNumViews();
     2111  Int i = 0, j = 0;
     2112
     2113  if ( m_bCamParPresent != NULL )
     2114  {
     2115    delete [] m_bCamParPresent;
     2116  }
     2117  if ( m_bCamParInSliceHeader != NULL )
     2118  {
     2119    delete [] m_bCamParInSliceHeader;
     2120  }
     2121
     2122  if ( m_aaaiCodedScale != NULL )
     2123  {
     2124    for ( i = 0; i < iNumViews ; i++ )
     2125    {
     2126      for ( j = 0; j < 2; j++ )
     2127      {
     2128        delete [] m_aaaiCodedScale[i][j];
     2129      }
     2130      delete [] m_aaaiCodedScale[i];
     2131    }
     2132    delete [] m_aaaiCodedScale;
     2133  }
     2134
     2135  if ( m_aaaiCodedOffset != NULL )
     2136  {
     2137    for ( i = 0; i < iNumViews ; i++ )
     2138    {
     2139      for ( j = 0; j < 2; j++ )
     2140      {
     2141        delete [] m_aaaiCodedOffset[i][j];
     2142      }
     2143      delete [] m_aaaiCodedOffset[i];
     2144    }
     2145    delete [] m_aaaiCodedOffset;
     2146  }
     2147}
     2148
     2149
     2150Void
     2151  TComVPS::initCamParaVPS( UInt uiViewIndex, Bool bCamParPresent, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
     2152{
     2153  AOT( uiViewIndex != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) ); 
     2154
     2155  m_uiCamParPrecision = ( ( uiViewIndex != 0 )? uiCamParPrecision : 0 );
     2156  m_bCamParPresent[ uiViewIndex ] = (( uiViewIndex != 0 )? bCamParPresent  : false );
     2157  m_bCamParInSliceHeader[ uiViewIndex ]  = ( (uiViewIndex != 0)? bCamParSlice  : false );
     2158
     2159  if( !m_bCamParInSliceHeader[ uiViewIndex ] )
     2160  {
     2161    for( UInt uiBaseViewIndex = 0; uiBaseViewIndex < uiViewIndex; uiBaseViewIndex++ )
     2162    {
     2163      m_aaaiCodedScale [ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiScale [ uiBaseViewIndex ][     uiViewIndex ];
     2164      m_aaaiCodedScale [ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiScale [     uiViewIndex ][ uiBaseViewIndex ];
     2165      m_aaaiCodedOffset[ uiViewIndex ][ 0 ][ uiBaseViewIndex ] = aaiOffset[ uiBaseViewIndex ][     uiViewIndex ];
     2166      m_aaaiCodedOffset[ uiViewIndex ][ 1 ][ uiBaseViewIndex ] = aaiOffset[     uiViewIndex ][ uiBaseViewIndex ];
     2167    }
     2168  }
     2169}
     2170#endif // CAM_HLS_F0136_F0045_F0082
     2171
    20682172#endif // H_3D
    20692173
    … …  
    24442548, m_ppsInferScalingListFlag(false)
    24452549, m_ppsScalingListRefLayerId(0)
     2550#if DLT_DIFF_CODING_IN_PPS
     2551, m_pcDLT(NULL)
     2552#endif
    24462553#endif
    24472554{
    … …  
    24632570  delete m_scalingList;
    24642571}
     2572
     2573#if DLT_DIFF_CODING_IN_PPS
     2574TComDLT::TComDLT()
     2575: m_bDltPresentFlag(false)
     2576, m_iNumDepthViews(0)
     2577, m_uiDepthViewBitDepth(8)
     2578{
     2579  m_uiDepthViewBitDepth = g_bitDepthY;
     2580
     2581  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
     2582  {
     2583    m_bUseDLTFlag                 [i] = false;
     2584    m_bInterViewDltPredEnableFlag [i] = false;
     2585
     2586    // allocate some memory and initialize with default mapping
     2587    m_iNumDepthmapValues[i] = ((1 << m_uiDepthViewBitDepth)-1)+1;
     2588    m_iBitsPerDepthValue[i] = numBitsForValue(m_iNumDepthmapValues[i]);
     2589
     2590    m_iDepthValue2Idx[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
     2591    m_iIdx2DepthValue[i]    = (Int*) xMalloc(Int, m_iNumDepthmapValues[i]);
     2592
     2593    //default mapping
     2594    for (Int d=0; d<m_iNumDepthmapValues[i]; d++)
     2595    {
     2596      m_iDepthValue2Idx[i][d] = d;
     2597      m_iIdx2DepthValue[i][d] = d;
     2598    }
     2599  }
     2600}
     2601
     2602TComDLT::~TComDLT()
     2603{
     2604  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
     2605  {
     2606    if ( m_iDepthValue2Idx[i] != NULL )
     2607    {
     2608      xFree( m_iDepthValue2Idx[i] );
     2609      m_iDepthValue2Idx[i] = NULL;
     2610    }
     2611
     2612    if ( m_iIdx2DepthValue[i] != NULL )
     2613    {
     2614      xFree( m_iIdx2DepthValue[i] );
     2615      m_iIdx2DepthValue[i] = NULL;
     2616    }
     2617  }
     2618}
     2619
     2620Void TComDLT::setDepthLUTs(Int layerIdInVps, Int* idxToDepthValueTable, Int iNumDepthValues)
     2621{
     2622  if( idxToDepthValueTable == NULL || iNumDepthValues == 0 ) // default mapping only
     2623    return;
     2624
     2625  // copy idx2DepthValue to internal array
     2626  memcpy(m_iIdx2DepthValue[layerIdInVps], idxToDepthValueTable, iNumDepthValues*sizeof(UInt));
     2627
     2628  UInt uiMaxDepthValue = ((1 << g_bitDepthY)-1);
     2629  for(Int p=0; p<=uiMaxDepthValue; p++)
     2630  {
     2631    Int iIdxDown    = 0;
     2632    Int iIdxUp      = iNumDepthValues-1;
     2633    Bool bFound     = false;
     2634
     2635    // iterate over indices to find lower closest depth
     2636    Int i = 1;
     2637    while(!bFound && i<iNumDepthValues)
     2638    {
     2639      if( m_iIdx2DepthValue[layerIdInVps][i] > p )
     2640      {
     2641        iIdxDown  = i-1;
     2642        bFound    = true;
     2643      }
     2644
     2645      i++;
     2646    }
     2647    // iterate over indices to find upper closest depth
     2648    i = iNumDepthValues-2;
     2649    bFound = false;
     2650    while(!bFound && i>=0)
     2651    {
     2652      if( m_iIdx2DepthValue[layerIdInVps][i] < p )
     2653      {
     2654        iIdxUp  = i+1;
     2655        bFound    = true;
     2656      }
     2657
     2658      i--;
     2659    }
     2660
     2661    // assert monotony
     2662    assert(iIdxDown<=iIdxUp);
     2663
     2664    // assign closer depth value/idx
     2665    if( abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxDown]) < abs(p-m_iIdx2DepthValue[layerIdInVps][iIdxUp]) )
     2666    {
     2667      m_iDepthValue2Idx[layerIdInVps][p] = iIdxDown;
     2668    }
     2669    else
     2670    {
     2671      m_iDepthValue2Idx[layerIdInVps][p] = iIdxUp;
     2672    }
     2673
     2674  }
     2675
     2676  // update DLT variables
     2677  m_iNumDepthmapValues[layerIdInVps] = iNumDepthValues;
     2678  m_iBitsPerDepthValue[layerIdInVps] = numBitsForValue(m_iNumDepthmapValues[layerIdInVps]);
     2679}
     2680
     2681#if H_3D_DELTA_DLT
     2682Void TComDLT::getDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTOut, UInt *puiDeltaDLTOutNum )
     2683{
     2684  Bool abBM0[ 256 ];
     2685  Bool abBM1[ 256 ];
     2686 
     2687  memset( abBM0, 0, sizeof( abBM0 ));
     2688  memset( abBM1, 0, sizeof( abBM1 ));
     2689 
     2690  // convert reference DLT to bit string
     2691  for( Int i = 0; i < uiDLTInRefNum; i++ )
     2692  {
     2693    abBM0[ piDLTInRef[ i ] ] = true;
     2694  }
     2695  // convert internal DLT to bit string
     2696  for( Int i = 0; i < m_iNumDepthmapValues[ layerIdInVps ]; i++ )
     2697  {
     2698    abBM1[ m_iIdx2DepthValue[ layerIdInVps ][ i ] ] = true;
     2699  }
     2700 
     2701  *puiDeltaDLTOutNum = 0;
     2702  for( Int i = 0; i < 256; i++ )
     2703  {
     2704    if( abBM0[ i ] ^ abBM1[ i ] )
     2705    {
     2706      piDeltaDLTOut[ *puiDeltaDLTOutNum ] = i;
     2707      *puiDeltaDLTOutNum = *puiDeltaDLTOutNum + 1;
     2708    }
     2709  }
     2710}
     2711
     2712Void TComDLT::setDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTIn, UInt uiDeltaDLTInNum )
     2713{
     2714  Bool abBM0[ 256 ];
     2715  Bool abBM1[ 256 ];
     2716 
     2717  memset( abBM0, 0, sizeof( abBM0 ));
     2718  memset( abBM1, 0, sizeof( abBM1 ));
     2719 
     2720  // convert reference DLT to bit string
     2721  for( Int i = 0; i < uiDLTInRefNum; i++ )
     2722  {
     2723    abBM0[ piDLTInRef[ i ] ] = true;
     2724  }
     2725  // convert delta DLT to bit string
     2726  for( Int i = 0; i < uiDeltaDLTInNum; i++ )
     2727  {
     2728    abBM1[ piDeltaDLTIn[ i ] ] = true;
     2729  }
     2730 
     2731  Int aiIdx2DepthValue[256];
     2732  UInt uiNumDepthValues = 0;
     2733  memset( aiIdx2DepthValue, 0, sizeof( aiIdx2DepthValue ));
     2734 
     2735  for( Int i = 0; i < 256; i++ )
     2736  {
     2737    if( abBM0[ i ] ^ abBM1[ i ] )
     2738    {
     2739      aiIdx2DepthValue[ uiNumDepthValues++ ] = i;
     2740    }
     2741  }
     2742 
     2743  // update internal tables
     2744  setDepthLUTs(layerIdInVps, aiIdx2DepthValue, uiNumDepthValues);
     2745}
     2746#endif
     2747
     2748#endif
    24652749
    24662750#if H_MV
    … …  
    25252809#endif
    25262810#if H_3D
     2811#if !CAM_HLS_F0136_F0045_F0082
    25272812Void
    25282813TComSPS::initCamParaSPS( UInt uiViewIndex, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
    … …  
    25462831  }
    25472832}
     2833#endif
    25482834#endif
    25492835TComReferencePictureSet::TComReferencePictureSet()
    … …  
    32573543  assert( m_depthToDisparityF != NULL );
    32583544
     3545#if CAM_HLS_F0136_F0045_F0082
     3546  TComVPS* vps = getVPS();
     3547#else
    32593548  TComSPS* sps = getSPS();
    3260 
     3549#endif
     3550
     3551#if CAM_HLS_F0136_F0045_F0082
     3552  Int log2Div = g_bitDepthY - 1 + vps->getCamParPrecision();
     3553  Int viewIndex = getViewIndex();
     3554
     3555  Bool camParaSH = vps->hasCamParInSliceHeader( viewIndex );
     3556
     3557  Int* codScale     = camParaSH ? m_aaiCodedScale [ 0 ] : vps->getCodedScale    ( viewIndex );
     3558  Int* codOffset    = camParaSH ? m_aaiCodedOffset[ 0 ] : vps->getCodedOffset   ( viewIndex );
     3559  Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : vps->getInvCodedScale ( viewIndex );
     3560  Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : vps->getInvCodedOffset( viewIndex );
     3561#else
    32613562  Int log2Div = g_bitDepthY - 1 + sps->getCamParPrecision();
    32623563
    … …  
    32673568  Int* invCodScale  = camParaSH ? m_aaiCodedScale [ 1 ] : sps->getInvCodedScale ();
    32683569  Int* invCodOffset = camParaSH ? m_aaiCodedOffset[ 1 ] : sps->getInvCodedOffset();
     3570#endif
    32693571
    32703572  for (Int i = 0; i <= ( getViewIndex() - 1); i++)
    … …  
    37074009  // It is a requirement of bitstream conformance that bitstream partition with index j shall not include
    37084010  // direct or indirect reference layers of any layers in bitstream partition i for any values of i and j
    3709   // in the range of 0 to num_bitstream_partitions[ h ] – 1, inclusive, such that i is less than j.
     4011  // in the range of 0 to num_bitstream_partitions[ h ] ?1, inclusive, such that i is less than j.
    37104012
    37114013  for ( Int partJ = 0; partJ < getNumBitstreamPartitions( h ); partJ++ )

  • trunk/source/Lib/TLibCommon/TComSlice.h

    r738 r758  
    849849#endif
    850850  Bool        m_vpsDepthModesFlag        [MAX_NUM_LAYERS   ];
     851
    851852#if H_3D_DIM_DLT
     853#if !DLT_DIFF_CODING_IN_PPS
    852854  Bool        m_bUseDLTFlag              [MAX_NUM_LAYERS   ];
    853855 
    … …  
    857859  Int*        m_iIdx2DepthValue          [MAX_NUM_LAYERS   ];
    858860#endif
     861#endif
     862
    859863#if H_3D
     864#if CAM_HLS_F0136_F0045_F0082
     865  UInt        m_uiCamParPrecision;
     866  Bool*       m_bCamParInSliceHeader;
     867  Bool*       m_bCamParPresent;
     868  Int         ***m_aaaiCodedScale ;
     869  Int         ***m_aaaiCodedOffset;
     870#endif
    860871  Bool        m_ivMvScalingFlag;
    861872#endif
    … …  
    10351046#endif
    10361047
    1037   Void    setProfileLevelTierIdx( Int outLayerSetIdx, Int val )            { m_profileLevelTierIdx[ outLayerSetIdx  = val ]; } 
     1048  Void    setProfileLevelTierIdx( Int outLayerSetIdx, Int val )            { m_profileLevelTierIdx[ outLayerSetIdx  = val ]; }
    10381049  Int     getProfileLevelTierIdx( Int outLayerSetIdx )                     { return m_profileLevelTierIdx[ outLayerSetIdx ]; }
    10391050#if H_MV_6_GEN_0153_28
    … …  
    11391150  Void    setARPStepNum( Int layerIdInVps, UInt val )                      { m_uiARPStepNum[layerIdInVps]    = val;     }
    11401151#endif
     1152#if CAM_HLS_F0136_F0045_F0082
     1153  Void createCamPars(Int iNumViews);
     1154  Void deleteCamPars();
     1155  Void initCamParaVPS      (  UInt uiViewIndex, Bool bCamParPresent = false, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
     1156  UInt getCamParPrecision    ()  { return m_uiCamParPrecision; }
     1157  Bool getCamParPresent      ( Int viewIndex )  { return m_bCamParPresent[viewIndex]; }
     1158  Bool hasCamParInSliceHeader( Int viewIndex )  { return m_bCamParInSliceHeader[viewIndex]; }
     1159  Void setHasCamParInSliceHeader( Int viewIndex, Bool b )  { m_bCamParInSliceHeader[viewIndex] = b; }
     1160  Int* getCodedScale         ( Int viewIndex )  { return m_aaaiCodedScale [viewIndex][0]; }
     1161  Int* getCodedOffset        ( Int viewIndex )  { return m_aaaiCodedOffset[viewIndex][0]; }
     1162  Int* getInvCodedScale      ( Int viewIndex )  { return m_aaaiCodedScale [viewIndex][1]; }
     1163  Int* getInvCodedOffset     ( Int viewIndex )  { return m_aaaiCodedOffset[viewIndex][1]; }
     1164#endif
     1165
    11411166#if H_3D_IV_MERGE
    11421167  Void    setIvMvPredFlag     ( Int layerIdInVps, Bool val )  { m_ivMvPredFlag[ layerIdInVps ] = val; }
    … …  
    11571182  Void    setVpsDepthModesFlag( Int layerIdInVps, Bool val )               { m_vpsDepthModesFlag[ layerIdInVps ] = val; }
    11581183  Bool    getVpsDepthModesFlag( Int layerIdInVps )                         { return m_vpsDepthModesFlag[ layerIdInVps ]; }
     1184
    11591185#if H_3D_DIM_DLT
     1186#if !DLT_DIFF_CODING_IN_PPS
    11601187  Bool    getUseDLTFlag      ( Int layerIdInVps )                         { return m_bUseDLTFlag[ layerIdInVps ]; }
    11611188  Void    setUseDLTFlag      ( Int layerIdInVps, Bool b ) { m_bUseDLTFlag[ layerIdInVps ]  = b;          }
    … …  
    11671194  Void    setDepthLUTs( Int layerIdInVps, Int* idx2DepthValue = NULL, Int iNumDepthValues = 0 );
    11681195#endif
     1196#endif
    11691197
    11701198  Bool    getIvMvScalingFlag   (  )                       { return m_ivMvScalingFlag; }
    … …  
    11811209#endif
    11821210};
     1211
     1212#if DLT_DIFF_CODING_IN_PPS
     1213class TComDLT
     1214{
     1215private:
     1216  Bool        m_bDltPresentFlag;
     1217  Bool        m_bUseDLTFlag              [ MAX_NUM_LAYERS ];
     1218  Bool        m_bInterViewDltPredEnableFlag[ MAX_NUM_LAYERS ];
     1219
     1220  Int         m_iBitsPerDepthValue       [ MAX_NUM_LAYERS ];
     1221  Int         m_iNumDepthmapValues       [ MAX_NUM_LAYERS ];
     1222  Int*        m_iDepthValue2Idx          [ MAX_NUM_LAYERS ];
     1223  Int*        m_iIdx2DepthValue          [ MAX_NUM_LAYERS ];
     1224
     1225  Int         m_iNumDepthViews;
     1226  UInt        m_uiDepthViewBitDepth;
     1227
     1228public:
     1229  TComDLT();
     1230  ~TComDLT();
     1231
     1232  Bool    getDltPresentFlag  ()                           { return m_bDltPresentFlag; }
     1233  Void    setDltPresentFlag  ( Bool b )                   { m_bDltPresentFlag = b;    }
     1234
     1235  Bool    getUseDLTFlag      ( Int layerIdInVps )         { return m_bUseDLTFlag[ layerIdInVps ]; }
     1236  Void    setUseDLTFlag      ( Int layerIdInVps, Bool b ) { m_bUseDLTFlag[ layerIdInVps ]  = b;   }
     1237 
     1238  Bool    getInterViewDltPredEnableFlag( Int layerIdInVps )         { return m_bInterViewDltPredEnableFlag[ layerIdInVps ]; }
     1239  Void    setInterViewDltPredEnableFlag( Int layerIdInVps, Bool b ) { m_bInterViewDltPredEnableFlag[ layerIdInVps ] = b;    }
     1240
     1241  Void    setNumDepthViews   ( Int n )                    { m_iNumDepthViews = n; }
     1242  Int     getNumDepthViews   ()                           { return m_iNumDepthViews; }
     1243
     1244  Void    setDepthViewBitDepth( UInt n )                  { m_uiDepthViewBitDepth = n; }
     1245  UInt    getDepthViewBitDepth()                          { return m_uiDepthViewBitDepth; }
     1246
     1247  Int     getBitsPerDepthValue( Int layerIdInVps )        { return getUseDLTFlag(layerIdInVps)?m_iBitsPerDepthValue[layerIdInVps]:g_bitDepthY; }
     1248  Int     getNumDepthValues( Int layerIdInVps )           { return getUseDLTFlag(layerIdInVps)?m_iNumDepthmapValues[layerIdInVps]:((1 << g_bitDepthY)-1); }
     1249  Int     depthValue2idx( Int layerIdInVps, Pel value )   { return getUseDLTFlag(layerIdInVps)?m_iDepthValue2Idx[layerIdInVps][value]:value; }
     1250  Pel     idx2DepthValue( Int layerIdInVps, UInt uiIdx )  { return getUseDLTFlag(layerIdInVps)?m_iIdx2DepthValue[layerIdInVps][uiIdx]:uiIdx; }
     1251  Void    setDepthLUTs( Int layerIdInVps, Int* idx2DepthValue = NULL, Int iNumDepthValues = 0 );
     1252#if H_3D_DELTA_DLT
     1253  Int*    idx2DepthValue( Int layerIdInVps )  { return m_iIdx2DepthValue[layerIdInVps]; }
     1254  Void    getDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTOut, UInt *puiDeltaDLTOutNum );
     1255  Void    setDeltaDLT( Int layerIdInVps, Int* piDLTInRef, UInt uiDLTInRefNum, Int* piDeltaDLTIn, UInt uiDeltaDLTInNum );
     1256#endif
     1257};
     1258#endif
    11831259
    11841260class Window
    … …  
    17251801#endif
    17261802#if H_3D
     1803#if !CAM_HLS_F0136_F0045_F0082
    17271804  Void initCamParaSPS      (  UInt uiViewIndex, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
    17281805  UInt getCamParPrecision    ()  { return m_uiCamParPrecision; }
    … …  
    17351812  Int* getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
    17361813  Int* getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
     1814#endif
    17371815#endif
    17381816#if H_MV
    … …  
    18401918  Int  m_ppsScalingListRefLayerId;
    18411919#endif
     1920
     1921#if DLT_DIFF_CODING_IN_PPS
     1922  TComDLT*  m_pcDLT;
     1923#endif
     1924
    18421925public:
    18431926  TComPPS();
    … …  
    18641947  Void      setMinCuDQPSize     ( UInt u ) { m_uiMinCuDQPSize = u;    }
    18651948  UInt      getMinCuDQPSize     ()         { return m_uiMinCuDQPSize; }
     1949
     1950#if DLT_DIFF_CODING_IN_PPS
     1951  Void      setDLT              ( TComDLT* pcDLT ) { m_pcDLT = pcDLT; }
     1952  TComDLT*  getDLT              ()                 { return m_pcDLT; }
     1953#endif
    18661954
    18671955  Void      setChromaCbQpOffset( Int i ) { m_chromaCbQpOffset = i;    }

  • trunk/source/Lib/TLibCommon/TypeDef.h

    r738 r758  
    175175#endif
    176176
     177#define CAM_HLS_F0136_F0045_F0082         1   // JCT3V-F0136/F0045: view order index based camera parameter signaling
     178                                              // JCT3V-F0082: the cp_in_slice_segment_layer_flag to be view specific and used as a condition of the presence of slice header level camera parameters
     179#define CAM_HLS_F0044                     1   // JCT3V-F0044: move camera parameter from slice header extension to slice header
     180
     181
    177182// Rate Control
    178183#define KWU_FIX_URQ                       1
    … …  
    215220#define H_3D_DIM_SDC                      1   // Simplified Depth Coding method
    216221#define H_3D_DIM_DLT                      1   // Depth Lookup Table
     222
     223#if H_3D_DIM_DLT
     224#define DLT_DIFF_CODING_IN_PPS            1   // moving DLT syntax elements from VPS to PPS and differential coding of DLT values
     225                                              // JCT3V-F0131, JCT3V-F0139
     226#if DLT_DIFF_CODING_IN_PPS
     227#define Log2( n ) ( log((double)n) / log(2.0) )
     228#endif
     229#define H_3D_DELTA_DLT                    1
     230#endif
     231
    217232#define H_3D_DIM_ENC                      1   // Depth Intra encoder optimizations, includes:
    218233                                              // HHI_DEPTH_INTRA_SEARCH_RAU_C0160
    … …  
    262277#define H_MV_FIX_SKIP_PICTURES                  1  // Fix related to skipping pictures.
    263278#define H_MV_6_HRD_O0164_15                     1  // (HRD/O0164/Multilayer HRD) #15 Decision: Adopt, modified as follows: It was suggested to constrain the stalling based on the relative cpb removal times, which must be in decoding order. The "du_based_bpb_sync_flag" is not needed, in view of this. SEI in the highest layer of the layer set or (inclusive "or") VPS VUI is used to carry the parameters (at encoder discretion). SEI in higher layer and SEI in VUI do not need to repeat information available in some lower layer. Shall be after APS SEI and buffering period SEI and before all other SEI of all layers except other HRD related SEI.
    264 #define H_MV_6_HRD_O0217_13                     1  // (HRD/O0217/Sub-DPB based DPB operations) #13 Decision: Adopt – Specify a separate DPB capacity for each layer – no sharing of capacity across layers – each layer has its own parameters (max pictures, max latency, max reordering). This proposal would specify distinct parameters for each "output layer set" and to change the definition of an operation point to be specific to an output layer set instead of a 'layer set". Decision: Adopted this aspect as well.
     279#define H_MV_6_HRD_O0217_13                     1  // (HRD/O0217/Sub-DPB based DPB operations) #13 Decision: Adopt ?Specify a separate DPB capacity for each layer ?no sharing of capacity across layers ?each layer has its own parameters (max pictures, max latency, max reordering). This proposal would specify distinct parameters for each "output layer set" and to change the definition of an operation point to be specific to an output layer set instead of a 'layer set". Decision: Adopted this aspect as well.
    265280#define H_MV_6_SHVC_O0098_36                    1  // (SHVC/O0098/Scaled ref layer offset) #36 Modify signalling of scaled reference layer offsets to allow signalling of any lower layer, rather than just a direct reference layer, in order to enable alignment of auxiliary pictures. In further JCT-VC and JCT-3V discussion, it was also agreed to use the same offset signalling for MV-HEVC as well as SHVC
    266281#define H_MV_6_GEN_0153_28                      1  //(Gen/O0153/output highest layer) #28 Add a flag in the VPS to indicate if startup process should output the highest available layer if the target output layer is not available.
    … …  
    291306#define H_MV_6_PS_O0096_21                      1  // (PS/O0096/direct_dependency_type gating flag) #21 Add a gating flag in VPS extension to condition the presence of direct dependency type, with a default type signalled, from JCTVC-O0096
    292307#define H_MV_6_PS_O0109_22                      1  // (PS/O0109/view_id_len) #22 Modify the VPS extension syntax and semantics to replace view_id_len_minus1 with view_id_len, always signal that syntax element, add a constraint that (1<<view_id_len) >= NumViews, and modify view_id_val semantics to infer value of 0 when not present, from discussion of JCTVC-O0109
    293 #define H_MV_6_PS_O0109_23                      1  // (PS/O0109/profile_ref_minus1 constraint) #23 Modify the semantics of profile_ref_minus1[ i ] to replace “shall be less than i” with “shall be less than or equal to i”, from discussion of JCTVC-O0109
     308#define H_MV_6_PS_O0109_23                      1  // (PS/O0109/profile_ref_minus1 constraint) #23 Modify the semantics of profile_ref_minus1[ i ] to replace “shall be less than i?with “shall be less than or equal to i? from discussion of JCTVC-O0109
    294309#define H_MV_6_PS_O0109_24                      1  // (PS/O0109/vps_vui_present_flag move) #24 Move the vps_vui_present_flag to precede vps_vui_offset, and make vps_vui_offset conditional on that flag, from JCTVC-O0109
    295310/////////////////////////////////////////////////////////////////////////////////////////

  • trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r738 r758  
    215215}
    216216
     217#if DLT_DIFF_CODING_IN_PPS
     218Void TDecCavlc::parsePPS(TComPPS* pcPPS, TComVPS* pcVPS )
     219#else
    217220Void TDecCavlc::parsePPS(TComPPS* pcPPS)
     221#endif
    218222{
    219223#if ENC_DEC_TRACE 
    … …  
    364368  if (uiCode)
    365369  {
    366     while ( xMoreRbspData() )
    367     {
    368       READ_FLAG( uiCode, "pps_extension_data_flag");
    369     }
    370   }
    371 }
     370#if DLT_DIFF_CODING_IN_PPS
     371    parsePPSExtension( pcPPS, pcVPS );
     372    READ_FLAG( uiCode, "pps_extension2_flag");
     373    if ( uiCode )
     374    {
     375#endif
     376      while ( xMoreRbspData() )
     377      {
     378        READ_FLAG( uiCode, "pps_extension_data_flag");
     379      }
     380#if DLT_DIFF_CODING_IN_PPS
     381    }
     382#endif
     383  }
     384}
     385
     386#if DLT_DIFF_CODING_IN_PPS
     387Void TDecCavlc::parsePPSExtension( TComPPS* pcPPS, TComVPS* pcVPS )
     388{
     389  UInt uiCode = 0;
     390  TComDLT* pcDLT = new TComDLT;
     391
     392  READ_FLAG(uiCode, "dlt_present_flag");
     393  pcDLT->setDltPresentFlag( (uiCode == 1) ? true : false );
     394
     395  if ( pcDLT->getDltPresentFlag() )
     396  {
     397    READ_CODE(6, uiCode, "pps_depth_layers_minus1");
     398    pcDLT->setNumDepthViews( uiCode );
     399
     400    READ_CODE(4, uiCode, "pps_bit_depth_for_depth_views_minus8");
     401    pcDLT->setDepthViewBitDepth( (uiCode+8) );
     402
     403    for( Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
     404    {
     405      if ( i != 0 )
     406      {
     407        if( pcVPS->getDepthId( i ) == 1 )
     408        {
     409          READ_FLAG(uiCode, "dlt_flag[i]");
     410          pcDLT->setUseDLTFlag(i, (uiCode == 1) ? true : false);
     411
     412          if ( pcDLT->getUseDLTFlag( i ) )
     413          {
     414            Bool bDltBitMapRepFlag    = false;
     415            UInt uiMaxDiff            = 0xffffffff;
     416            UInt uiMinDiff            = 0;
     417            UInt uiCodeLength         = 0;
     418
     419            READ_FLAG(uiCode, "inter_view_dlt_pred_enable_flag[ i ]");
     420            pcDLT->setInterViewDltPredEnableFlag( i, (uiCode == 1) ? true : false );
     421
     422            if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )
     423            {
     424              READ_FLAG(uiCode, "dlt_bit_map_rep_flag[ layerId ]");
     425              bDltBitMapRepFlag = (uiCode == 1) ? true : false;
     426            }
     427            else
     428            {
     429              bDltBitMapRepFlag = false;
     430            }
     431           
     432            UInt uiNumDepthValues = 0;
     433            Int  aiIdx2DepthValue[256];
     434
     435            // Bit map
     436            if ( bDltBitMapRepFlag )
     437            {
     438              for (UInt d=0; d<256; d++)
     439              {
     440                READ_FLAG(uiCode, "dlt_bit_map_flag[ layerId ][ j ]");
     441                if (uiCode == 1)
     442                {
     443                  aiIdx2DepthValue[uiNumDepthValues] = d;
     444                  uiNumDepthValues++;
     445                }
     446              }
     447            }
     448            // Diff Coding
     449            else
     450            {
     451              READ_CODE(8, uiNumDepthValues, "num_depth_values_in_dlt[i]");   // num_entry
     452
     453#if !H_3D_DELTA_DLT
     454              if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )       // Single-view DLT Diff Coding
     455#endif
     456              {
     457                // The condition if( pcVPS->getNumDepthValues(i) > 0 ) is always true since for Single-view Diff Coding, there is at least one depth value in depth component.
     458
     459                if (uiNumDepthValues > 1)
     460                {
     461                  READ_CODE(8, uiCode, "max_diff[ layerId ]");
     462                  uiMaxDiff = uiCode;
     463                }
     464                else
     465                {
     466                  uiMaxDiff = 0;           // when there is only one value in DLT
     467                }
     468
     469                if (uiNumDepthValues > 2)
     470                {
     471                  uiCodeLength = (UInt) ceil(Log2(uiMaxDiff + 1));
     472                  READ_CODE(uiCodeLength, uiCode, "min_diff_minus1[ layerId ]");
     473                  uiMinDiff = uiCode + 1;
     474                }
     475                else
     476                {
     477                  uiMinDiff = uiMaxDiff;   // when there are only one or two values in DLT
     478                }
     479
     480                READ_CODE(8, uiCode, "dlt_depth_value0[layerId]");   // entry0
     481                aiIdx2DepthValue[0] = uiCode;
     482
     483                if (uiMaxDiff == uiMinDiff)
     484                {
     485                  for (UInt d=1; d<uiNumDepthValues; d++)
     486                  {
     487                    aiIdx2DepthValue[d] = aiIdx2DepthValue[d-1] + uiMinDiff + 0;
     488                  }
     489                }
     490                else
     491                {
     492                  uiCodeLength = (UInt) ceil(Log2(uiMaxDiff - uiMinDiff + 1));
     493                  for (UInt d=1; d<uiNumDepthValues; d++)
     494                  {
     495                    READ_CODE(uiCodeLength, uiCode, "dlt_depth_value_diff_minus_min[ layerId ][ j ]");
     496                    aiIdx2DepthValue[d] = aiIdx2DepthValue[d-1] + uiMinDiff + uiCode;
     497                  }
     498                }
     499
     500              }
     501            }
     502           
     503#if H_3D_DELTA_DLT
     504            if( pcDLT->getInterViewDltPredEnableFlag( i ) )
     505            {
     506              // interpret decoded values as delta DLT
     507              AOF( pcVPS->getDepthId( 1 ) == 1 );
     508              AOF( i > 1 );
     509              // assumes ref layer id to be 1
     510              Int* piRefDLT = pcDLT->idx2DepthValue( 1 );
     511              UInt uiRefNum = pcDLT->getNumDepthValues( 1 );
     512              pcDLT->setDeltaDLT(i, piRefDLT, uiRefNum, aiIdx2DepthValue, uiNumDepthValues);
     513            }
     514            else
     515            {
     516              // store final DLT
     517              pcDLT->setDepthLUTs(i, aiIdx2DepthValue, uiNumDepthValues);
     518            }
     519#else
     520            // store final DLT
     521            pcDLT->setDepthLUTs(i, aiIdx2DepthValue, uiNumDepthValues);
     522#endif
     523          }
     524        }
     525      }
     526    }
     527  }
     528
     529  pcPPS->setDLT( pcDLT );
     530}
     531#endif
    372532
    373533Void  TDecCavlc::parseVUI(TComVUI* pcVUI, TComSPS *pcSPS)
    … …  
    8891049#endif
    8901050
     1051#if !CAM_HLS_F0136_F0045_F0082
    8911052  UInt uiCamParPrecision = 0;
    8921053  Bool bCamParSlice      = false;
    … …  
    9081069  }
    9091070  pcSPS->initCamParaSPS( viewIndex, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
     1071#endif
    9101072}
    9111073#endif
    … …  
    10191181#if H_3D
    10201182      m_pcBitstream->readOutTrailingBits();
     1183#if CAM_HLS_F0136_F0045_F0082
     1184      pcVPS->createCamPars(pcVPS->getNumViews());
     1185#endif
    10211186      parseVPSExtension2( pcVPS );   
    10221187      READ_FLAG( uiCode,  "vps_extension3_flag" );
    … …  
    17381903        //          READ_FLAG( uiCode, "lim_qt_pred_flag[i]");                  pcVPS->setLimQtPreFlag     ( i, uiCode == 1 ? true : false );
    17391904#if H_3D_DIM_DLT
     1905#if !DLT_DIFF_CODING_IN_PPS
    17401906        if( pcVPS->getVpsDepthModesFlag( i ) )
    17411907        {
    … …  
    17631929        }
    17641930#endif
     1931#endif
    17651932#if H_3D_INTER_SDC
    17661933            READ_FLAG( uiCode, "depth_inter_SDC_flag" );              pcVPS->setInterSDCFlag( i, uiCode ? true : false );
    … …  
    17691936    }
    17701937  }
     1938#if CAM_HLS_F0136_F0045_F0082
     1939  UInt uiCamParPrecision = 0;
     1940  Bool bCamParSlice      = false;
     1941  Bool bCamParPresentFlag = false;
     1942
     1943  READ_UVLC( uiCamParPrecision, "cp_precision" );
     1944  for (UInt viewIndex=0; viewIndex<pcVPS->getNumViews(); viewIndex++)
     1945  {
     1946    READ_FLAG( uiCode, "cp_present_flag[i]" );                  bCamParPresentFlag = ( uiCode == 1);
     1947    if ( bCamParPresentFlag )
     1948    {
     1949      READ_FLAG( uiCode, "cp_in_slice_segment_header_flag[i]" );          bCamParSlice = ( uiCode == 1);
     1950      if ( !bCamParSlice )
     1951      {
     1952        for( UInt uiBaseIndex = 0; uiBaseIndex < viewIndex; uiBaseIndex++ )
     1953        {
     1954          Int iCode;
     1955          READ_SVLC( iCode, "vps_cp_scale" );                m_aaiTempScale  [ uiBaseIndex ][ viewIndex ]   = iCode;
     1956          READ_SVLC( iCode, "vps_cp_off" );                  m_aaiTempOffset [ uiBaseIndex ][ viewIndex ]   = iCode;
     1957          READ_SVLC( iCode, "vps_cp_inv_scale_plus_scale" ); m_aaiTempScale  [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ viewIndex ];
     1958          READ_SVLC( iCode, "vps_cp_inv_off_plus_off" );     m_aaiTempOffset [ viewIndex   ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ viewIndex ];
     1959        }
     1960      }
     1961      pcVPS->initCamParaVPS( viewIndex, bCamParPresentFlag, uiCamParPrecision, bCamParSlice, m_aaiTempScale, m_aaiTempOffset );
     1962    }
     1963  }
     1964#endif
    17711965  READ_FLAG( uiCode, "iv_mv_scaling_flag");                       pcVPS->setIvMvScalingFlag( uiCode == 1 ? true : false );
    17721966}
    … …  
    24952689  }
    24962690
     2691#if CAM_HLS_F0044
     2692#if CAM_HLS_F0136_F0045_F0082
     2693  if( rpcSlice->getVPS()->hasCamParInSliceHeader( rpcSlice->getViewIndex() )  && !rpcSlice->getIsDepth() )
     2694#else
     2695  if( rpcSlice->getSPS()->hasCamParInSliceHeader() )
     2696#endif
     2697  {
     2698    UInt uiViewIndex = rpcSlice->getViewIndex();
     2699    for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
     2700    {
     2701      READ_SVLC( iCode, "cp_scale" );                m_aaiTempScale [ uiBaseIndex ][ uiViewIndex ] = iCode;
     2702      READ_SVLC( iCode, "cp_off" );                  m_aaiTempOffset[ uiBaseIndex ][ uiViewIndex ] = iCode;
     2703      READ_SVLC( iCode, "cp_inv_scale_plus_scale" ); m_aaiTempScale [ uiViewIndex ][ uiBaseIndex ] = iCode - m_aaiTempScale [ uiBaseIndex ][ uiViewIndex ];
     2704      READ_SVLC( iCode, "cp_inv_off_plus_off" );     m_aaiTempOffset[ uiViewIndex ][ uiBaseIndex ] = iCode - m_aaiTempOffset[ uiBaseIndex ][ uiViewIndex ];
     2705    }
     2706    rpcSlice->setCamparaSlice( m_aaiTempScale, m_aaiTempOffset );
     2707  }
     2708
     2709#endif
     2710
    24972711  if(pps->getSliceHeaderExtensionPresentFlag())
    24982712  {
    24992713    READ_UVLC(uiCode,"slice_header_extension_length");
    2500 #if H_3D
     2714#if H_3D && !CAM_HLS_F0044
     2715#if CAM_HLS_F0136_F0045_F0082
     2716    if( rpcSlice->getVPS()->hasCamParInSliceHeader( rpcSlice->getViewIndex() )  && !rpcSlice->getIsDepth() )
     2717#else
    25012718    if( rpcSlice->getSPS()->hasCamParInSliceHeader() )
     2719#endif
    25022720    {
    25032721      UInt uiViewIndex = rpcSlice->getViewIndex();

  • trunk/source/Lib/TLibDecoder/TDecCAVLC.h

    r738 r758  
    105105  Void  parseSPS            ( TComSPS* pcSPS );
    106106#endif
     107
     108#if H_3D && DLT_DIFF_CODING_IN_PPS
     109  Void  parsePPS            ( TComPPS* pcPPS, TComVPS* pcVPS );
     110  Void  parsePPSExtension   ( TComPPS* pcPPS, TComVPS* pcVPS );
     111#else
    107112  Void  parsePPS            ( TComPPS* pcPPS);
     113#endif
     114
    108115  Void  parseVUI            ( TComVUI* pcVUI, TComSPS* pcSPS );
    109116  Void  parseSEI            ( SEIMessages& );

  • trunk/source/Lib/TLibDecoder/TDecCu.cpp

    r735 r758  
    781781    {
    782782#if LGE_PRED_RES_CODING_DLT_DOMAIN_F0159
    783         if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getVPS()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     783#if DLT_DIFF_CODING_IN_PPS
     784      if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getPPS()->getDLT()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     785#else
     786      if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getVPS()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     787#endif
    784788        {
    785             pReco    [ uiX ] = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), Clip3( 0, pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() ) - 1, pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] ) + pResi[ uiX ] ) );
     789#if DLT_DIFF_CODING_IN_PPS
     790          pReco    [ uiX ] = pcCU->getSlice()->getPPS()->getDLT()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), Clip3( 0, pcCU->getSlice()->getPPS()->getDLT()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() ) - 1, pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] ) + pResi[ uiX ] ) );
     791#else
     792          pReco    [ uiX ] = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), Clip3( 0, pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() ) - 1, pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] ) + pResi[ uiX ] ) );
     793#endif
    786794        }
    787795        else
    … …  
    10001008  {
    10011009#if H_3D_DIM_DLT
     1010#if DLT_DIFF_CODING_IN_PPS
     1011    Pel   pPredIdx    = pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
     1012    Pel   pResiIdx    = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
     1013    Pel   pRecoValue  = pcCU->getSlice()->getPPS()->getDLT()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pPredIdx + pResiIdx );
     1014#else
    10021015    Pel   pPredIdx    = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
    10031016    Pel   pResiIdx    = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
    10041017    Pel   pRecoValue  = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pPredIdx + pResiIdx );
    1005    
     1018#endif
     1019
    10061020    apDCResiValues[uiSegment]  = pRecoValue - apDCPredValues[uiSegment];
    10071021#else

  • trunk/source/Lib/TLibDecoder/TDecEntropy.h

    r655 r758  
    7171  virtual Void  parseSPS                  ( TComSPS* pcSPS )                                      = 0;
    7272#endif
     73#if DLT_DIFF_CODING_IN_PPS
     74  virtual Void  parsePPS                  ( TComPPS* pcPPS, TComVPS* pcVPS )                      = 0;
     75#else
    7376  virtual Void  parsePPS                  ( TComPPS* pcPPS )                                      = 0;
     77#endif
    7478
    7579  virtual Void parseSliceHeader          ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager)       = 0;
    … …  
    148152  Void    decodeSPS                   ( TComSPS* pcSPS     )    { m_pcEntropyDecoderIf->parseSPS(pcSPS);                    }
    149153#endif
     154#if DLT_DIFF_CODING_IN_PPS
     155  Void    decodePPS                   ( TComPPS* pcPPS, TComVPS* pcVPS )    { m_pcEntropyDecoderIf->parsePPS(pcPPS, pcVPS);                    }
     156#else
    150157  Void    decodePPS                   ( TComPPS* pcPPS )    { m_pcEntropyDecoderIf->parsePPS(pcPPS);                    }
     158#endif
    151159  Void    decodeSliceHeader           ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager)  { m_pcEntropyDecoderIf->parseSliceHeader(rpcSlice, parameterSetManager);         }
    152160

  • trunk/source/Lib/TLibDecoder/TDecSbac.cpp

    r724 r758  
    568568 
    569569#if H_3D_DIM_DLT
     570#if DLT_DIFF_CODING_IN_PPS
     571  UInt uiMaxResidualBits = pcCU->getSlice()->getPPS()->getDLT()->getBitsPerDepthValue( pcCU->getSlice()->getLayerIdInVps() );
     572#else
    570573  UInt uiMaxResidualBits = pcCU->getSlice()->getVPS()->getBitsPerDepthValue( pcCU->getSlice()->getLayerIdInVps() );
     574#endif
    571575#else
    572576  UInt uiMaxResidualBits = g_bitDepthY;
    … …  
    592596    UInt uiCount = 0;
    593597#if H_3D_DIM_DLT
     598#if DLT_DIFF_CODING_IN_PPS
     599    UInt uiNumDepthValues = pcCU->getSlice()->getPPS()->getDLT()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() );
     600#else
    594601    UInt uiNumDepthValues = pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() );
     602#endif
    595603#else
    596604    UInt uiNumDepthValues = ((1 << g_bitDepthY)-1);

  • trunk/source/Lib/TLibDecoder/TDecSbac.h

    r724 r758  
    8181  Void  parseSPS                  ( TComSPS* /*pcSPS*/ ) {}
    8282#endif
     83#if DLT_DIFF_CODING_IN_PPS
     84  Void  parsePPS                  ( TComPPS* /*pcPPS*/, TComVPS* /*pcVPS*/ ) {}
     85#else
    8386  Void  parsePPS                  ( TComPPS* /*pcPPS*/ ) {}
     87#endif
    8488
    8589  Void  parseSliceHeader          ( TComSlice*& /*rpcSlice*/, ParameterSetManagerDecoder* /*parameterSetManager*/) {}

  • trunk/source/Lib/TLibDecoder/TDecTop.cpp

    r738 r758  
    228228    m_uiMaxViewIndex                     = std::max( m_uiMaxViewIndex, uiViewIndex );
    229229    m_aiViewId[ uiViewIndex ]            = pcSlice->getViewId();
     230#if CAM_HLS_F0136_F0045_F0082
     231    if( uiViewIndex == 1 )
     232    {
     233      m_uiCamParsCodedPrecision       = pcSlice->getVPS()->getCamParPrecision     ();
     234      m_bCamParsVaryOverTime          = pcSlice->getVPS()->hasCamParInSliceHeader ( uiViewIndex );
     235    }
     236    else if( uiViewIndex > 1 )
     237    {
     238      AOF( m_uiCamParsCodedPrecision == pcSlice->getVPS()->getCamParPrecision     () );
     239      AOF( m_bCamParsVaryOverTime    == pcSlice->getVPS()->hasCamParInSliceHeader ( uiViewIndex ) );
     240    }
     241#else
    230242    if( uiViewIndex == 1 )
    231243    {
    … …  
    238250      AOF( m_bCamParsVaryOverTime    == pcSlice->getSPS()->hasCamParInSliceHeader () );
    239251    }
     252#endif
    240253    for( UInt uiBaseIndex = 0; uiBaseIndex < uiViewIndex; uiBaseIndex++ )
    241254    {
    … …  
    251264      else
    252265      {
     266#if CAM_HLS_F0136_F0045_F0082
     267        m_aaiCodedScale [ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getVPS()->getCodedScale    (uiViewIndex) [ uiBaseIndex ];
     268        m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getVPS()->getCodedOffset   (uiViewIndex) [ uiBaseIndex ];
     269        m_aaiCodedScale [ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getVPS()->getInvCodedScale (uiViewIndex) [ uiBaseIndex ];
     270        m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getVPS()->getInvCodedOffset(uiViewIndex) [ uiBaseIndex ];
     271#else
    253272        m_aaiCodedScale [ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getSPS()->getCodedScale    () [ uiBaseIndex ];
    254273        m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ]  = pcSlice->getSPS()->getCodedOffset   () [ uiBaseIndex ];
    255274        m_aaiCodedScale [ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getSPS()->getInvCodedScale () [ uiBaseIndex ];
    256275        m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ]  = pcSlice->getSPS()->getInvCodedOffset() [ uiBaseIndex ];
     276#endif
    257277        xInitLUTs( uiBaseIndex, uiViewIndex, m_aaiCodedScale[ uiBaseIndex ][ uiViewIndex ], m_aaiCodedOffset[ uiBaseIndex ][ uiViewIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
    258278        xInitLUTs( uiViewIndex, uiBaseIndex, m_aaiCodedScale[ uiViewIndex ][ uiBaseIndex ], m_aaiCodedOffset[ uiViewIndex ][ uiBaseIndex ], m_adBaseViewShiftLUT, m_aiBaseViewShiftLUT );
    … …  
    286306CamParsCollector::copyCamParamForSlice( TComSlice* pcSlice )
    287307{
     308#if !CAM_HLS_F0136_F0045_F0082
    288309  UInt uiViewIndex = pcSlice->getViewIndex();
    289310
    290311  pcSlice->getSPS()->initCamParaSPS( uiViewIndex, m_uiCamParsCodedPrecision, m_bCamParsVaryOverTime, m_aaiCodedScale, m_aaiCodedOffset );
    291 
     312#endif
    292313  if( m_bCamParsVaryOverTime )
    293314  {
    … …  
    11091130  if( pcSlice->getIsDepth() )
    11101131  {
     1132#if !CAM_HLS_F0136_F0045_F0082
    11111133    pcSlice->getSPS()->setHasCamParInSliceHeader( false );
     1134#endif
    11121135  }
    11131136#endif
    … …  
    11511174  pps->setLayerId( getLayerId() );
    11521175#endif
     1176#if DLT_DIFF_CODING_IN_PPS
     1177  // Assuming that all PPS indirectly refer to the same VPS via different SPS
     1178  // There is no parsing dependency in decoding DLT in PPS.
     1179  // The VPS information passed to decodePPS() is used to arrange the decoded DLT tables to their corresponding layers.
     1180  // This is equivalent to the process of
     1181  //   Step 1) decoding DLT tables based on the number of depth layers, and
     1182  //   Step 2) mapping DLT tables to the depth layers
     1183  // as descripted in the 3D-HEVC WD.
     1184  TComVPS* vps = m_parameterSetManagerDecoder.getPrefetchedVPS( 0 );
     1185  m_cEntropyDecoder.decodePPS( pps, vps );
     1186#else
    11531187  m_cEntropyDecoder.decodePPS( pps );
     1188#endif
    11541189  m_parameterSetManagerDecoder.storePrefetchedPPS( pps );
    11551190}

  • trunk/source/Lib/TLibEncoder/TEncCavlc.cpp

    r738 r758  
    256256  WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
    257257  WRITE_FLAG( pcPPS->getSliceHeaderExtensionPresentFlag() ? 1 : 0, "slice_segment_header_extension_present_flag");
     258
     259#if !DLT_DIFF_CODING_IN_PPS
    258260  WRITE_FLAG( 0, "pps_extension_flag" );
    259 }
     261#else
     262  WRITE_FLAG( 1, "pps_extension_flag" );
     263  codePPSExtension( pcPPS );
     264  WRITE_FLAG( 0, "pps_extension2_flag" );
     265#endif
     266}
     267
     268#if DLT_DIFF_CODING_IN_PPS
     269Void  TEncCavlc::codePPSExtension        ( TComPPS* pcPPS )
     270{
     271  // Assuming that all PPS indirectly refer to the same VPS via different SPS
     272  // There is no parsing dependency in decoding DLT in PPS.
     273  // The VPS information passed to decodePPS() is used to arrange the decoded DLT tables to their corresponding layers.
     274  // This is equivalent to the process of
     275  //   Step 1) decoding DLT tables based on the number of depth layers, and
     276  //   Step 2) mapping DLT tables to the depth layers
     277  // as descripted in the 3D-HEVC WD.
     278  TComVPS* pcVPS = pcPPS->getSPS()->getVPS();
     279
     280  TComDLT* pcDLT = pcPPS->getDLT();
     281
     282  WRITE_FLAG( pcDLT->getDltPresentFlag() ? 1 : 0, "dlt_present_flag" );
     283
     284  if ( pcDLT->getDltPresentFlag() )
     285  {
     286    WRITE_CODE(pcDLT->getNumDepthViews(), 6, "pps_depth_layers_minus1");
     287    WRITE_CODE((pcDLT->getDepthViewBitDepth() - 8), 4, "pps_bit_depth_for_depth_views_minus8");
     288
     289    for( Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
     290    {
     291      if ( i != 0 )
     292      {
     293        if ( pcVPS->getDepthId( i ) == 1 )
     294        {
     295          WRITE_FLAG( pcDLT->getUseDLTFlag( i ) ? 1 : 0, "dlt_flag[i]" );
     296
     297          if ( pcDLT->getUseDLTFlag( i ) )
     298          {
     299            WRITE_FLAG( pcDLT->getInterViewDltPredEnableFlag( i ) ? 1 : 0, "inter_view_dlt_pred_enable_flag[ i ]");
     300
     301            // ----------------------------- determine whether to use bit-map -----------------------------
     302            Bool bDltBitMapRepFlag       = false;
     303            UInt uiNumBitsNonBitMap      = 0;
     304            UInt uiNumBitsBitMap         = 0;
     305
     306            UInt uiMaxDiff               = 0;
     307            UInt uiMinDiff               = 0xffffffff;
     308            UInt uiLengthMinDiff         = 0;
     309            UInt uiLengthDltDiffMinusMin = 0;
     310
     311            UInt* puiDltDiffValues       = NULL;
     312           
     313            Int aiIdx2DepthValue_coded[256];
     314            UInt uiNumDepthValues_coded = 0;
     315           
     316            uiNumDepthValues_coded = pcDLT->getNumDepthValues(i);
     317            for( UInt ui = 0; ui<uiNumDepthValues_coded; ui++ )
     318            {
     319              aiIdx2DepthValue_coded[ui] = pcDLT->idx2DepthValue(i, ui);
     320            }
     321           
     322#if H_3D_DELTA_DLT
     323            if( pcDLT->getInterViewDltPredEnableFlag( i ) )
     324            {
     325              AOF( pcVPS->getDepthId( 1 ) == 1 );
     326              AOF( i > 1 );
     327              // assumes ref layer id to be 1
     328              Int* piRefDLT = pcDLT->idx2DepthValue( 1 );
     329              UInt uiRefNum = pcDLT->getNumDepthValues( 1 );
     330              pcDLT->getDeltaDLT(i, piRefDLT, uiRefNum, aiIdx2DepthValue_coded, &uiNumDepthValues_coded);
     331            }
     332#endif
     333
     334            if ( NULL == (puiDltDiffValues = (UInt *)calloc(uiNumDepthValues_coded, sizeof(UInt))) )
     335            {
     336              exit(-1);
     337            }
     338
     339            for (UInt d = 1; d < uiNumDepthValues_coded; d++)
     340            {
     341              puiDltDiffValues[d] = aiIdx2DepthValue_coded[d] - aiIdx2DepthValue_coded[d-1];
     342
     343              if ( uiMaxDiff < puiDltDiffValues[d] )
     344              {
     345                uiMaxDiff = puiDltDiffValues[d];
     346              }
     347
     348              if ( uiMinDiff > puiDltDiffValues[d] )
     349              {
     350                uiMinDiff = puiDltDiffValues[d];
     351              }
     352            }
     353
     354            // counting bits
     355            // diff coding branch
     356            uiNumBitsNonBitMap += 8;                          // u(v) bits for num_depth_values_in_dlt[layerId] (i.e. num_entry[ layerId ])
     357
     358            if ( uiNumDepthValues_coded > 1 )
     359            {
     360              uiNumBitsNonBitMap += 8;                        // u(v) bits for max_diff[ layerId ]
     361            }
     362
     363            if ( uiNumDepthValues_coded > 2 )
     364            {
     365              uiLengthMinDiff    = (UInt) ceil(Log2(uiMaxDiff + 1));
     366              uiNumBitsNonBitMap += uiLengthMinDiff;          // u(v)  bits for min_diff[ layerId ]
     367            }
     368
     369            uiNumBitsNonBitMap += 8;                          // u(v) bits for dlt_depth_value0[ layerId ]
     370
     371            if (uiMaxDiff > uiMinDiff)
     372            {
     373              uiLengthDltDiffMinusMin = (UInt) ceil(Log2(uiMaxDiff - uiMinDiff + 1));
     374              uiNumBitsNonBitMap += uiLengthDltDiffMinusMin * (uiNumDepthValues_coded - 1);  // u(v) bits for dlt_depth_value_diff_minus_min[ layerId ][ j ]
     375            }
     376
     377            // bit map branch
     378            uiNumBitsBitMap = 256;   // uiNumBitsBitMap = 1 << pcDLT->getDepthViewBitDepth();
     379
     380            // determine bDltBitMapFlag
     381            bDltBitMapRepFlag = (uiNumBitsBitMap > uiNumBitsNonBitMap) ? false : true;
     382
     383            // ----------------------------- Actual coding -----------------------------
     384            if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )
     385            {
     386              WRITE_FLAG( bDltBitMapRepFlag ? 1 : 0, "dlt_bit_map_rep_flag[ layerId ]" );
     387            }
     388            else
     389            {
     390              bDltBitMapRepFlag = false;
     391            }
     392
     393            // bit map coding
     394            if ( bDltBitMapRepFlag )
     395            {
     396              UInt uiDltArrayIndex = 0;
     397              for (UInt d=0; d < 256; d++)
     398              {
     399                if ( d == aiIdx2DepthValue_coded[uiDltArrayIndex] )
     400                {                 
     401                  WRITE_FLAG(1, "dlt_bit_map_flag[ layerId ][ j ]");
     402                  uiDltArrayIndex++;
     403                }
     404                else
     405                {
     406                  WRITE_FLAG(0, "dlt_bit_map_flag[ layerId ][ j ]");
     407                }
     408              }
     409            }
     410            // Diff Coding
     411            else
     412            {
     413              WRITE_CODE(uiNumDepthValues_coded, 8, "num_depth_values_in_dlt[layerId]");    // num_entry
     414
     415#if !H_3D_DELTA_DLT
     416              if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )   // Single-view DLT Diff Coding
     417#endif
     418              {
     419                // The condition if( uiNumDepthValues_coded > 0 ) is always true since for Single-view Diff Coding, there is at least one depth value in depth component.
     420                if ( uiNumDepthValues_coded > 1 )
     421                {
     422                  WRITE_CODE(uiMaxDiff, 8, "max_diff[ layerId ]");        // max_diff
     423                }
     424
     425                if ( uiNumDepthValues_coded > 2 )
     426                {
     427                  WRITE_CODE((uiMinDiff - 1), uiLengthMinDiff, "min_diff_minus1[ layerId ]");     // min_diff_minus1
     428                }
     429
     430                WRITE_CODE(aiIdx2DepthValue_coded[0], 8, "dlt_depth_value0[layerId]");          // entry0
     431
     432                if (uiMaxDiff > uiMinDiff)
     433                {
     434                  for (UInt d=1; d < uiNumDepthValues_coded; d++)
     435                  {
     436                    WRITE_CODE( (puiDltDiffValues[d] - uiMinDiff), uiLengthDltDiffMinusMin, "dlt_depth_value_diff_minus_min[ layerId ][ j ]");    // entry_value_diff_minus_min[ k ]
     437                  }
     438                }
     439              }
     440            }
     441
     442            free(puiDltDiffValues);
     443          }
     444        }
     445      }
     446    }
     447  }
     448}
     449#endif
    260450
    261451Void TEncCavlc::codeVUI( TComVUI *pcVUI, TComSPS* pcSPS )
    … …  
    671861}
    672862#endif
    673   if (!depthFlag )
    674   {
    675     WRITE_UVLC( pcSPS->getCamParPrecision(), "cp_precision" );
    676     WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "cp_in_slice_header_flag" );
    677     if( !pcSPS->hasCamParInSliceHeader() )
    678     {
    679       for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
    680       {
    681         WRITE_SVLC( pcSPS->getCodedScale    ()[ uiIndex ],                                      "cp_scale" );
    682         WRITE_SVLC( pcSPS->getCodedOffset   ()[ uiIndex ],                                      "cp_off" );
    683         WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiIndex ] + pcSPS->getCodedScale ()[ uiIndex ], "cp_inv_scale_plus_scale" );
    684         WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiIndex ] + pcSPS->getCodedOffset()[ uiIndex ], "cp_inv_off_plus_off" );
    685       }
    686     }
    687   }
     863#if !CAM_HLS_F0136_F0045_F0082
     864if (!depthFlag )
     865{
     866  WRITE_UVLC( pcSPS->getCamParPrecision(), "cp_precision" );
     867  WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "cp_in_slice_header_flag" );
     868  if( !pcSPS->hasCamParInSliceHeader() )
     869  {
     870    for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
     871    {
     872      WRITE_SVLC( pcSPS->getCodedScale    ()[ uiIndex ],                                      "cp_scale" );
     873      WRITE_SVLC( pcSPS->getCodedOffset   ()[ uiIndex ],                                      "cp_off" );
     874      WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiIndex ] + pcSPS->getCodedScale ()[ uiIndex ], "cp_inv_scale_plus_scale" );
     875      WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiIndex ] + pcSPS->getCodedOffset()[ uiIndex ], "cp_inv_off_plus_off" );
     876    }
     877  }
     878}
     879#endif
    688880}
    689881#endif
    … …  
    14631655        //WRITE_FLAG( pcVPS->getLimQtPredFlag    ( i ) ? 1 : 0 ,          "lim_qt_pred_flag[i]"     );
    14641656#if H_3D_DIM_DLT
     1657#if !DLT_DIFF_CODING_IN_PPS
    14651658        if( pcVPS->getVpsDepthModesFlag( i ) )
    14661659        {
    … …  
    14751668            WRITE_UVLC( pcVPS->idx2DepthValue(i, d), "dlt_depth_value[i][d]" );
    14761669          }
    1477         }       
     1670        }
     1671#endif
    14781672#endif
    14791673#if H_3D_INTER_SDC
    … …  
    14831677    } 
    14841678  }
     1679#if CAM_HLS_F0136_F0045_F0082
     1680  WRITE_UVLC( pcVPS->getCamParPrecision(), "cp_precision" );
     1681  for (UInt viewIndex=0; viewIndex<pcVPS->getNumViews(); viewIndex++)
     1682  {
     1683    WRITE_FLAG( pcVPS->getCamParPresent(viewIndex) ? 1 : 0, "cp_present_flag[i]" );
     1684    if ( pcVPS->getCamParPresent(viewIndex) )
     1685    {
     1686      WRITE_FLAG( pcVPS->hasCamParInSliceHeader(viewIndex) ? 1 : 0, "cp_in_slice_segment_header_flag[i]" );
     1687      if ( !pcVPS->hasCamParInSliceHeader(viewIndex) )
     1688      {
     1689        for( UInt uiIndex = 0; uiIndex < viewIndex; uiIndex++ )
     1690        {
     1691          WRITE_SVLC( pcVPS->getCodedScale    (viewIndex)[ uiIndex ],                                               "vps_cp_scale" );
     1692          WRITE_SVLC( pcVPS->getCodedOffset   (viewIndex)[ uiIndex ],                                               "vps_cp_off" );
     1693          WRITE_SVLC( pcVPS->getInvCodedScale (viewIndex)[ uiIndex ] + pcVPS->getCodedScale (viewIndex)[ uiIndex ], "vps_cp_inv_scale_plus_scale" );
     1694          WRITE_SVLC( pcVPS->getInvCodedOffset(viewIndex)[ uiIndex ] + pcVPS->getCodedOffset(viewIndex)[ uiIndex ], "vps_cp_inv_off_plus_off" );
     1695        }
     1696      }
     1697    }
     1698  }
     1699#endif
    14851700#if H_3D_TMVP
    14861701  WRITE_FLAG( pcVPS->getIvMvScalingFlag( ) ? 1 : 0 ,          "iv_mv_scaling_flag" );
    … …  
    19472162    }
    19482163  }
     2164#if CAM_HLS_F0044
     2165#if QC_DEPTH_IV_MRG_F0125
     2166#if CAM_HLS_F0136_F0045_F0082
     2167  if( pcSlice->getVPS()->hasCamParInSliceHeader( pcSlice->getViewIndex() ) && !pcSlice->getIsDepth() )
     2168#else
     2169  if( pcSlice->getSPS()->hasCamParInSliceHeader() && !pcSlice->getIsDepth() )
     2170#endif
     2171#else
     2172  if( pcSlice->getSPS()->hasCamParInSliceHeader() )
     2173#endif
     2174  {
     2175    for( UInt uiId = 0; uiId < pcSlice->getViewIndex(); uiId++ )
     2176    {
     2177      WRITE_SVLC( pcSlice->getCodedScale    ()[ uiId ],                                     "cp_scale" );
     2178      WRITE_SVLC( pcSlice->getCodedOffset   ()[ uiId ],                                     "cp_off" );
     2179      WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "cp_inv_scale_plus_scale" );
     2180      WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "cp_inv_off_plus_off" );
     2181    }
     2182  }
     2183#endif
     2184
    19492185  if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag())
    19502186  {
    1951 #if !H_3D
     2187#if !H_3D || CAM_HLS_F0044
    19522188    WRITE_UVLC(0,"slice_header_extension_length");
    19532189#else
    19542190    WRITE_UVLC(0,"slice_header_extension_length"); //<- this element needs to be set to the correct value!!
    1955 
    19562191#if QC_DEPTH_IV_MRG_F0125
     2192#if CAM_HLS_F0136_F0045_F0082
     2193    if( pcSlice->getVPS()->hasCamParInSliceHeader( pcSlice->getViewIndex() ) && !pcSlice->getIsDepth() )
     2194#else
    19572195    if( pcSlice->getSPS()->hasCamParInSliceHeader() && !pcSlice->getIsDepth() )
     2196#endif
    19582197#else
    19592198    if( pcSlice->getSPS()->hasCamParInSliceHeader() )

  • trunk/source/Lib/TLibEncoder/TEncCavlc.h

    r738 r758  
    116116#endif
    117117  Void  codePPS                 ( TComPPS* pcPPS );
     118
     119#if DLT_DIFF_CODING_IN_PPS
     120  Void  codePPSExtension        ( TComPPS* pcPPS );
     121#endif
     122
    118123  Void  codeSliceHeader         ( TComSlice* pcSlice );
    119124  Void  codePTL                 ( TComPTL* pcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1);

  • trunk/source/Lib/TLibEncoder/TEncCfg.h

    r724 r758  
    330330  TComVPS                    m_cVPS;
    331331#endif
     332
     333#if DLT_DIFF_CODING_IN_PPS
     334  TComDLT*  m_cDLT;
     335#endif
     336
    332337  Bool      m_recalculateQPAccordingToLambda;                 ///< recalculate QP value according to the lambda value
    333338  Int       m_activeParameterSetsSEIEnabled;                  ///< enable active parameter set SEI message
    … …  
    867872  TComVPS *getVPS() { return &m_cVPS; }
    868873#endif
     874
     875#if DLT_DIFF_CODING_IN_PPS
     876  Void      setDLT           ( TComDLT *p ) { m_cDLT = p; }
     877  TComDLT*  getDLT           ()             { return m_cDLT; }
     878#endif
     879
    869880  Void      setUseRecalculateQPAccordingToLambda ( Bool b ) { m_recalculateQPAccordingToLambda = b;    }
    870881  Bool      getUseRecalculateQPAccordingToLambda ()         { return m_recalculateQPAccordingToLambda; }

  • trunk/source/Lib/TLibEncoder/TEncSbac.cpp

    r724 r758  
    632632
    633633#if H_3D_DIM_DLT
     634#if DLT_DIFF_CODING_IN_PPS
     635  UInt uiMaxResidualBits = pcCU->getSlice()->getPPS()->getDLT()->getBitsPerDepthValue( pcCU->getSlice()->getLayerIdInVps() );
     636#else
    634637  UInt uiMaxResidualBits = pcCU->getSlice()->getVPS()->getBitsPerDepthValue( pcCU->getSlice()->getLayerIdInVps() );
     638#endif
    635639#else
    636640  UInt uiMaxResidualBits = g_bitDepthY;
    … …  
    653657   
    654658#if H_3D_DIM_DLT
    655     UInt uiNumDepthValues = pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() );
     659#if DLT_DIFF_CODING_IN_PPS
     660      UInt uiNumDepthValues = pcCU->getSlice()->getPPS()->getDLT()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() );
     661#else
     662      UInt uiNumDepthValues = pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() );
     663#endif
    656664#else
    657665    UInt uiNumDepthValues = ((1 << g_bitDepthY)-1);

  • trunk/source/Lib/TLibEncoder/TEncSearch.cpp

    r735 r758  
    11271127      {
    11281128#if LGE_PRED_RES_CODING_DLT_DOMAIN_F0159
    1129           if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getVPS()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     1129#if DLT_DIFF_CODING_IN_PPS
     1130        if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getPPS()->getDLT()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     1131#else
     1132        if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getVPS()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     1133#endif
    11301134          {
    1131               pResi[ uiX ] = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pOrg[ uiX ] ) - pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] );
     1135#if DLT_DIFF_CODING_IN_PPS
     1136            pResi[ uiX ] = pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pOrg[ uiX ] ) - pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] );
     1137#else
     1138            pResi[ uiX ] = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pOrg[ uiX ] ) - pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] );
     1139#endif
    11321140          }
    11331141          else
    … …  
    12021210      {
    12031211#if LGE_PRED_RES_CODING_DLT_DOMAIN_F0159
    1204           if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getVPS()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     1212#if DLT_DIFF_CODING_IN_PPS
     1213        if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getPPS()->getDLT()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     1214#else
     1215        if( (isDimMode( uiLumaPredMode ) || uiLumaPredMode == HOR_IDX || uiLumaPredMode == VER_IDX || uiLumaPredMode == DC_IDX) && pcCU->getSlice()->getIsDepth() && pcCU->getSlice()->getVPS()->getUseDLTFlag(pcCU->getSlice()->getLayerIdInVps()) )
     1216#endif
    12051217          {
    1206               pReco    [ uiX ] = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), Clip3( 0, pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() ) - 1, pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] ) + pResi[ uiX ] ) );
     1218#if DLT_DIFF_CODING_IN_PPS
     1219            pReco    [ uiX ] = pcCU->getSlice()->getPPS()->getDLT()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), Clip3( 0, pcCU->getSlice()->getPPS()->getDLT()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() ) - 1, pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] ) + pResi[ uiX ] ) );
     1220#else
     1221            pReco    [ uiX ] = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), Clip3( 0, pcCU->getSlice()->getVPS()->getNumDepthValues( pcCU->getSlice()->getLayerIdInVps() ) - 1, pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pPred[ uiX ] ) + pResi[ uiX ] ) );
     1222#endif
    12071223          }
    12081224          else
    … …  
    19351951    // get residual (idx)
    19361952#if H_3D_DIM_DLT
     1953#if DLT_DIFF_CODING_IN_PPS
     1954    Pel pResidualIdx = pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pDCRec ) - pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
     1955#else
    19371956    Pel pResidualIdx = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), pDCRec ) - pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
     1957#endif
    19381958#else
    19391959    Pel pResidualIdx = pDCRec - apDCPredValues[uiSegment];
    … …  
    19491969  {
    19501970#if H_3D_DIM_DLT
     1971#if DLT_DIFF_CODING_IN_PPS
     1972    Pel   pPredIdx    = pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
     1973    Pel   pResiIdx    = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
     1974    Pel   pRecoValue  = pcCU->getSlice()->getPPS()->getDLT()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pPredIdx + pResiIdx );
     1975#else
    19511976    Pel   pPredIdx    = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), apDCPredValues[uiSegment] );
    19521977    Pel   pResiIdx    = pcCU->getSDCSegmentDCOffset(uiSegment, uiAbsPartIdx);
    19531978    Pel   pRecoValue  = pcCU->getSlice()->getVPS()->idx2DepthValue( pcCU->getSlice()->getLayerIdInVps(), pPredIdx + pResiIdx );
    1954    
     1979#endif
     1980
    19551981    apDCResiValues[uiSegment]  = pRecoValue - apDCPredValues[uiSegment];
    19561982#else
    … …  
    73467372
    73477373#if H_3D_DIM_DLT
     7374#if DLT_DIFF_CODING_IN_PPS
     7375  rDeltaDC1 = pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), ClipY(predDC1 + rDeltaDC1) ) - pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 );
     7376  rDeltaDC2 = pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), ClipY(predDC2 + rDeltaDC2) ) - pcCU->getSlice()->getPPS()->getDLT()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 );
     7377#else
    73487378  rDeltaDC1 = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), ClipY(predDC1 + rDeltaDC1) ) - pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC1 );
    73497379  rDeltaDC2 = pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), ClipY(predDC2 + rDeltaDC2) ) - pcCU->getSlice()->getVPS()->depthValue2idx( pcCU->getSlice()->getLayerIdInVps(), predDC2 );
     7380#endif
    73507381#endif
    73517382}

  • trunk/source/Lib/TLibEncoder/TEncTop.cpp

    r738 r758  
    299299{
    300300  // initialize SPS
     301#if DLT_DIFF_CODING_IN_PPS
     302  // Assuming that all PPS indirectly refer to the same VPS via different SPS
     303  m_cSPS.setVPS(m_cVPS);
     304#endif
    301305  xInitSPS();
    302306 
    … …  
    850854  }
    851855#if H_3D
     856#if !CAM_HLS_F0136_F0045_F0082
    852857#if !QC_DEPTH_IV_MRG_F0125
    853858  if ( !m_isDepth )
    … …  
    857862  }
    858863#endif
     864#endif
    859865}
    860866
    … …  
    870876  m_cPPS.setSPSId( getLayerIdInVps() );
    871877#endif
     878
     879#if DLT_DIFF_CODING_IN_PPS
     880  m_cPPS.setDLT( getDLT() );
     881#endif
     882
    872883  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
    873884  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
    … …  
    10011012  }
    10021013#if H_3D
     1014#if CAM_HLS_F0136_F0045_F0082
     1015  if( m_cVPS->hasCamParInSliceHeader( getViewIndex() ) )
     1016#else
    10031017  if( m_cSPS.hasCamParInSliceHeader() )
     1018#endif
    10041019  {
    10051020    m_cPPS.setSliceHeaderExtensionPresentFlag( true );
Note: See TracChangeset for help on using the changeset viewer.