Changeset 414 in SHVCSoftware for branches


Ignore:
Timestamp:
8 Oct 2013, 11:25:37 (11 years ago)
Author:
sony
Message:

IL_SL_SIGNALLING_N0371

Location:
branches/SHM-3.1-dev/source
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-3.1-dev/source/App/TAppEncoder/TAppEncTop.cpp

    r412 r414  
    10551055#endif
    10561056  }
     1057#if IL_SL_SIGNALLING_N0371
     1058  for(i = 1; i < vps->getMaxLayers(); i++)
     1059  {
     1060    for(Int j = 0; j < i; j++)
     1061    {
     1062      vps->setScalingListLayerDependency( i, j, vps->checkLayerDependency( i,j ) );
     1063    }
     1064  }
     1065#endif
    10571066#endif
    10581067#if JCTVC_M0458_INTERLAYER_RPS_SIG       

  • branches/SHM-3.1-dev/source/Lib/TLibCommon/TComRom.cpp

    r370 r414  
    526526Int g_mvScalingFactor  [MAX_LAYERS][2] = {{0,0}, {0,0}};
    527527Int g_posScalingFactor [MAX_LAYERS][2] = {{0,0}, {0,0}};
     528
     529#if IL_SL_SIGNALLING_N0371
     530Int ref_scalingListDC         [MAX_LAYERS][SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
     531Int ref_scalingListCoef       [MAX_LAYERS][SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM][MAX_MATRIX_COEF_NUM];
     532Int activeRefPPSId            [MAX_LAYERS];
     533Int activeRefSPSId            [MAX_LAYERS];
     534#endif
    528535#endif
    529536

  • branches/SHM-3.1-dev/source/Lib/TLibCommon/TComRom.h

    r370 r414  
    282282extern Int g_mvScalingFactor  [MAX_LAYERS][2];
    283283extern Int g_posScalingFactor [MAX_LAYERS][2];
     284
     285#if IL_SL_SIGNALLING_N0371
     286extern Int ref_scalingListDC         [MAX_LAYERS][SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
     287extern Int ref_scalingListCoef       [MAX_LAYERS][SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM][MAX_MATRIX_COEF_NUM];
     288extern Int activeRefPPSId            [MAX_LAYERS];
     289extern Int activeRefSPSId            [MAX_LAYERS]; 
     290#endif   
    284291#endif
    285292

  • branches/SHM-3.1-dev/source/Lib/TLibCommon/TComSlice.cpp

    r412 r414  
    4646
    4747#if SVC_EXTENSION
    48   ParameterSetMap<TComVPS> ParameterSetManager::m_vpsMap(MAX_NUM_VPS);
    49   Int ParameterSetManager::m_activeVPSId = -1;
     48ParameterSetMap<TComVPS> ParameterSetManager::m_vpsMap(MAX_NUM_VPS);
     49Int ParameterSetManager::m_activeVPSId = -1;
     50#if IL_SL_SIGNALLING_N0371
     51TComSPS* TComSPS::m_pcSPS[MAX_LAYERS];
     52TComPPS* TComPPS::m_pcPPS[MAX_LAYERS];
     53#endif
    5054#endif
    5155
    … …  
    18791883}
    18801884#endif
     1885<<<<<<< .mine
     1886
     1887#if IL_SL_SIGNALLING_N0371
     1888Bool TComVPS::checkLayerDependency(UInt i, UInt j)
     1889{
     1890  if( this->getDirectDependencyFlag(i, j) == true )
     1891  {                                                                                                                                   
     1892    return true;                                                                                                                       
     1893  }                                                                                                                                   
     1894  else                                                                                                                                   
     1895  {                                                                                                                                   
     1896    for(UInt k=i-1; k>j; k--)
     1897    {                                                                                                                               
     1898      if( this->getDirectDependencyFlag(i, k) == true )
     1899      {                                                                                                                           
     1900        checkLayerDependency( k,j );                                                                                           
     1901      }
     1902    }
     1903  }
     1904  return false;       
     1905}
     1906#endif
     1907
     1908=======
    18811909#if VIEW_ID_RELATED_SIGNALING
    18821910Int TComVPS::getNumViews()
    … …  
    19121940}
    19131941#endif
     1942>>>>>>> .r413
    19141943// ------------------------------------------------------------------------------------------------
    19151944// Sequence parameter set (SPS)
    … …  
    23822411/** set default quantization matrix to array
    23832412*/
     2413#if IL_SL_SIGNALLING_N0371
     2414Void TComSlice::setDefaultScalingList( UInt layerId )
     2415#else
    23842416Void TComSlice::setDefaultScalingList()
     2417#endif
    23852418{
    23862419  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
    … …  
    23882421    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
    23892422    {
     2423#if IL_SL_SIGNALLING_N0371
     2424      getScalingList()->processDefaultMarix(sizeId, listId, layerId);
     2425#else
    23902426      getScalingList()->processDefaultMarix(sizeId, listId);
     2427#endif
    23912428    }
    23922429  }
    … …  
    24492486    {
    24502487      src = getScalingListAddress(sizeIdc, listIdc);
    2451 
    24522488      fseek(fp,0,0);
    24532489      do
    … …  
    25632599 * \param Index of input matrix
    25642600 */
     2601#if IL_SL_SIGNALLING_N0371
     2602Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId, UInt layerId)
     2603#else
    25652604Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId)
    2566 {
     2605#endif
     2606{
     2607#if IL_SL_SIGNALLING_N0371
     2608  Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
     2609  UInt* scan  = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] :  g_sigLastScanCG32x32;
     2610  Int *src = getScalingListDefaultAddress(sizeId, listId);   
     2611#endif
     2612
    25672613  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
     2614
     2615#if IL_SL_SIGNALLING_N0371
     2616  for(i = 0; i < coefNum; i++)
     2617  {
     2618    ref_scalingListCoef[layerId][sizeId][listId][i] = src[scan[i]];
     2619  }
     2620#endif
     2621
    25682622  setScalingListDC(sizeId,listId,SCALING_LIST_DC);
     2623#if IL_SL_SIGNALLING_N0371
     2624  ref_scalingListDC[layerId][sizeId][listId] = SCALING_LIST_DC;
     2625#endif
    25692626}
    25702627
    25712628/** check DC value of matrix for default matrix signaling
    25722629 */
     2630#if IL_SL_SIGNALLING_N0371
     2631Void TComScalingList::checkDcOfMatrix( UInt layerId )
     2632#else
    25732633Void TComScalingList::checkDcOfMatrix()
     2634#endif
    25742635{
    25752636  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
    … …  
    25802641      if(getScalingListDC(sizeId,listId) == 0)
    25812642      {
     2643#if IL_SL_SIGNALLING_N0371
     2644        processDefaultMarix(sizeId, listId, layerId);
     2645#else
    25822646        processDefaultMarix(sizeId, listId);
     2647#endif
    25832648      }
    25842649    }
    … …  
    26612726        m_activeVPSId = vpsId;
    26622727        m_activeSPSId = spsId;
     2728
     2729#if IL_SL_SIGNALLING_N0371
     2730        activeRefPPSId[ sps->getLayerId() ] = ppsId;
     2731        activeRefSPSId[ sps->getLayerId() ] = spsId;
     2732#endif
     2733
    26632734        return true;
    26642735      }

  • branches/SHM-3.1-dev/source/Lib/TLibCommon/TComSlice.h

    r411 r414  
    156156  Void     setScalingListPresentFlag    (Bool b)                               { m_scalingListPresentFlag = b;    }
    157157  Bool     getScalingListPresentFlag    ()                                     { return m_scalingListPresentFlag; }
     158
     159#if IL_SL_SIGNALLING_N0371
     160  UInt     m_layerId;
     161
     162  Void     setPredScalingListFlag    (Bool b)                               { m_predScalingListFlag = b;    }
     163  Bool     getPredScalingListFlag    ()                                     { return m_predScalingListFlag; }
     164  Void     setScalingListRefLayerId  (UInt b)                               { m_scalingListRefLayerId = b;  }
     165  UInt     getScalingListRefLayerId  ()                                     { return m_scalingListRefLayerId; }
     166#endif
     167
    158168  Bool     getUseTransformSkip    ()                                     { return m_useTransformSkip; }     
    159169  Void     setUseTransformSkip    (Bool b)                               { m_useTransformSkip = b;    }
     170
    160171  Int*     getScalingListAddress          (UInt sizeId, UInt listId)           { return m_scalingListCoef[sizeId][listId]; } //!< get matrix coefficient
     172
    161173  Bool     checkPredMode                  (UInt sizeId, UInt listId);
     174
    162175  Void     setRefMatrixId                 (UInt sizeId, UInt listId, UInt u)   { m_refMatrixId[sizeId][listId] = u;    }     //!< set reference matrix ID
    163176  UInt     getRefMatrixId                 (UInt sizeId, UInt listId)           { return m_refMatrixId[sizeId][listId]; }     //!< get reference matrix ID
    164177  Int*     getScalingListDefaultAddress   (UInt sizeId, UInt listId);                                                        //!< get default matrix coefficient
     178
     179#if IL_SL_SIGNALLING_N0371
     180  Void     processDefaultMarix            (UInt sizeId, UInt listId, UInt layerId );
     181#else
    165182  Void     processDefaultMarix            (UInt sizeId, UInt listId);
     183#endif
     184
    166185  Void     setScalingListDC               (UInt sizeId, UInt listId, UInt u)   { m_scalingListDC[sizeId][listId] = u; }      //!< set DC value
    167186
    168187  Int      getScalingListDC               (UInt sizeId, UInt listId)           { return m_scalingListDC[sizeId][listId]; }   //!< get DC value
     188
     189#if IL_SL_SIGNALLING_N0371
     190  Void     setLayerId(UInt layerId) { m_layerId = layerId; }
     191  UInt     getLayerId() { return m_layerId; }
     192  Void     checkDcOfMatrix                ( UInt m_layerId );
     193#else
    169194  Void     checkDcOfMatrix                ();
     195#endif
     196
    170197  Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
    171198  Bool     xParseScalingList              (Char* pchFile);
    … …  
    174201  Void     init                    ();
    175202  Void     destroy                 ();
     203
    176204  Int      m_scalingListDC               [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
    177205  Bool     m_useDefaultScalingMatrixFlag [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< UseDefaultScalingMatrixFlag
    178206  UInt     m_refMatrixId                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
    179207  Bool     m_scalingListPresentFlag;                                                //!< flag for using default matrix
     208
     209#if IL_SL_SIGNALLING_N0371
     210  Bool     m_predScalingListFlag;                                                   //!< flag for inter-layer scaling-list prediction
     211  UInt     m_scalingListRefLayerId;                                                 //!< scaling_list_ref_layer_id 
     212#endif
     213
    180214  UInt     m_predMatrixId                [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
     215
    181216  Int      *m_scalingListCoef            [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
     217
    182218  Bool     m_useTransformSkip;                                                      //!< transform skipping flag for setting default scaling matrix for 4x4
    183219};
    … …  
    469505  Int         m_numLayerInIdList[MAX_VPS_LAYER_SETS_PLUS1];
    470506#endif
     507#if IL_SL_SIGNALLING_N0371
     508  Bool        m_scalingListLayerDependency[MAX_LAYERS][MAX_LAYERS];  // layer dependency for scaling list
     509#endif
    471510  TComPTL     m_pcPTL;
    472511  TimingInfo  m_timingInfo;
    … …  
    554593  Int         m_avgPicRate          [MAX_VPS_LAYER_SETS_PLUS1][MAX_TLAYER];
    555594#endif
     595<<<<<<< .mine
     596
     597=======
    556598#if REPN_FORMAT_IN_VPS
    557599  Bool       m_repFormatIdxPresentFlag;
    … …  
    564606  Int         m_viewIdVal                [MAX_LAYERS];
    565607#endif
     608>>>>>>> .r413
    566609public:
    567610  TComVPS();
    … …  
    629672  Void    deriveLayerIdListVariables();
    630673#endif
     674
     675#if IL_SL_SIGNALLING_N0371
     676  Bool    checkLayerDependency(UInt i, UInt j);
     677  Bool    getScalingListLayerDependency  ( UInt layerId, UInt refLayerId )            { return m_scalingListLayerDependency[layerId][refLayerId]; }
     678  Void    setScalingListLayerDependency  ( UInt layerId, UInt refLayerId, Bool val  ) { m_scalingListLayerDependency[layerId][refLayerId] = val;  }
     679#endif
     680
    631681  TComPTL* getPTL() { return &m_pcPTL; }
    632682  TimingInfo* getTimingInfo() { return &m_timingInfo; }
    … …  
    10831133  Bool        m_scalingListEnabledFlag;
    10841134  Bool        m_scalingListPresentFlag;
     1135
    10851136  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
     1137
    10861138  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER];
    10871139  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];  // Really max latency increase plus 1 (value 0 expresses no limit)
    … …  
    11071159#if SVC_EXTENSION
    11081160  UInt m_layerId;
     1161
     1162#if IL_SL_SIGNALLING_N0371
     1163  TComVPS*    m_pVPS;
     1164  static TComSPS* m_pcSPS[MAX_LAYERS];
     1165  Bool        m_predScalingListFlag;
     1166  UInt        m_scalingListRefLayerId;
     1167#endif
     1168
    11091169#endif
    11101170#if REF_IDX_MFM
    … …  
    12291289  Bool getScalingListPresentFlag()         { return m_scalingListPresentFlag;     }
    12301290  Void setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag  = b;       }
     1291
     1292#if IL_SL_SIGNALLING_N0371
     1293  Bool getPredScalingListFlag()         { return m_predScalingListFlag;     }
     1294  Void setPredScalingListFlag( Bool b ) { m_predScalingListFlag  = b;       }
     1295  UInt getScalingListRefLayerId()         { return m_scalingListRefLayerId;   }
     1296  Void setScalingListRefLayerId( UInt b ) { m_scalingListRefLayerId  = b;       }
     1297
     1298  TComVPS*  getVPS()                      { return  m_pVPS; }
     1299  Void      setVPS( TComVPS* vps )        { m_pVPS = vps;   }
     1300  static   TComSPS* getSPS(UInt layerId)               { return m_pcSPS[layerId]; }
     1301  static   Void     setSPS(UInt layerId, TComSPS* sps) { m_pcSPS[layerId] = sps;  }
     1302#endif
     1303
    12311304  Void setScalingList      ( TComScalingList *scalingList);
    12321305  TComScalingList* getScalingList ()       { return m_scalingList; }               //!< get ScalingList class pointer in SPS
     1306
    12331307  UInt getMaxDecPicBuffering  (UInt tlayer)            { return m_uiMaxDecPicBuffering[tlayer]; }
    12341308  Void setMaxDecPicBuffering  ( UInt ui, UInt tlayer ) { m_uiMaxDecPicBuffering[tlayer] = ui;   }
    … …  
    13641438  Int      m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
    13651439  Bool     m_scalingListPresentFlag;
     1440
     1441#if SVC_EXTENSION
     1442  UInt m_layerId;
     1443
     1444#if IL_SL_SIGNALLING_N0371
     1445  static TComPPS* m_pcPPS[MAX_LAYERS];
     1446  Bool     m_predScalingListFlag;
     1447  UInt     m_scalingListRefLayerId;
     1448#endif
     1449
     1450#endif
     1451
    13661452  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
     1453
    13671454  Bool m_listsModificationPresentFlag;
    13681455  UInt m_log2ParallelMergeLevelMinus2;
    … …  
    14781565  Bool     getScalingListPresentFlag()         { return m_scalingListPresentFlag;     }
    14791566  Void     setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag  = b;       }
     1567
     1568#if IL_SL_SIGNALLING_N0371
     1569  Void     setLayerId(UInt layerId) { m_layerId = layerId; }
     1570  UInt     getLayerId() { return m_layerId; }
     1571
     1572  Bool     getPredScalingListFlag()         { return m_predScalingListFlag;     }
     1573  Void     setPredScalingListFlag( Bool b ) { m_predScalingListFlag  = b;       }
     1574  UInt     getScalingListRefLayerId()         { return m_scalingListRefLayerId;     }
     1575  Void     setScalingListRefLayerId( UInt b ) { m_scalingListRefLayerId  = b;       }
     1576
     1577  static   TComPPS* getPPS(UInt layerId)               { return m_pcPPS[layerId]; }
     1578  static   Void     setPPS(UInt layerId, TComPPS* pps) { m_pcPPS[layerId] = pps;  }
     1579#endif
     1580
    14801581  Void     setScalingList      ( TComScalingList *scalingList);
    14811582  TComScalingList* getScalingList ()          { return m_scalingList; }         //!< get ScalingList class pointer in PPS
    … …  
    18791980  Void  setScalingList              ( TComScalingList* scalingList ) { m_scalingList = scalingList; }
    18801981  TComScalingList*   getScalingList ()                               { return m_scalingList; }
     1982
     1983#if IL_SL_SIGNALLING_N0371
     1984  Void  setDefaultScalingList       ( UInt m_layerId );
     1985#else
    18811986  Void  setDefaultScalingList       ();
     1987#endif
     1988
    18821989  Bool  checkDefaultScalingList     ();
    18831990  Void      setCabacInitFlag  ( Bool val ) { m_cabacInitFlag = val;      }  //!< set CABAC initial flag

  • branches/SHM-3.1-dev/source/Lib/TLibCommon/TComTrQuant.cpp

    r389 r414  
    24942494/** set flat matrix value to quantized coefficient
    24952495 */
     2496#if IL_SL_SIGNALLING_N0371
     2497Void TComTrQuant::setFlatScalingList( UInt m_layerId )
     2498#else
    24962499Void TComTrQuant::setFlatScalingList()
     2500#endif
    24972501{
    24982502  UInt size,list;
    … …  
    25032507    for(list = 0; list <  g_scalingListNum[size]; list++)
    25042508    {
     2509#if IL_SL_SIGNALLING_N0371
     2510      ref_scalingListDC[m_layerId][size][list] = SCALING_LIST_DC;
     2511      for(UInt i=0; i<MAX_MATRIX_COEF_NUM; i++)
     2512      {
     2513        ref_scalingListCoef[m_layerId][size][list][i] = SCALING_LIST_DC;
     2514      }
     2515#endif
     2516
    25052517      for(qp=0;qp<SCALING_LIST_REM_NUM;qp++)
    25062518      {

  • branches/SHM-3.1-dev/source/Lib/TLibCommon/TComTrQuant.h

    r313 r414  
    181181  Void setUseScalingList   ( Bool bUseScalingList){ m_scalingListEnabledFlag = bUseScalingList; };
    182182  Bool getUseScalingList   (){ return m_scalingListEnabledFlag; };
     183
     184#if IL_SL_SIGNALLING_N0371
     185  Void setFlatScalingList  ( UInt m_layerId );
     186#else
    183187  Void setFlatScalingList  ();
     188#endif
     189
    184190  Void xsetFlatScalingList ( UInt list, UInt size, UInt qp);
    185191  Void xSetScalingListEnc  ( TComScalingList *scalingList, UInt list, UInt size, UInt qp);

  • branches/SHM-3.1-dev/source/Lib/TLibCommon/TypeDef.h

    r413 r414  
    6060#define TEMP_SCALABILITY_FIX             1      ///< fix for temporal scalability
    6161#endif
     62<<<<<<< .mine
     63#define IL_SL_SIGNALLING_N0371           1      ///< JCTVC-N0371: inter-layer scaling list
     64#define M0464_TILE_BOUNDARY_ALIGNED_FLAG 0      ///< VUI flag to indicate tile boundary alignment
     65=======
     66>>>>>>> .r413
    6267#define M0463_VUI_EXT_ILP_REF            0      ///< VUI extension inter-layer dependency offset signalling
    6368#define SPS_EXTENSION                    1      ///< Define sps_extension() syntax structure

  • branches/SHM-3.1-dev/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r411 r414  
    291291  }
    292292  READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" );           pcPPS->setScalingListPresentFlag( uiCode ? true : false );
     293
     294#if IL_SL_SIGNALLING_N0371
     295  pcPPS->setPPS( pcPPS->getLayerId(), pcPPS ); 
     296#endif
     297
    293298  if(pcPPS->getScalingListPresentFlag ())
    294299  {
     300#if IL_SL_SIGNALLING_N0371
     301    pcPPS->getScalingList()->setLayerId( pcPPS->getLayerId() );
     302
     303    if( pcPPS->getLayerId() > 0 )
     304    {
     305      READ_FLAG( uiCode, "pps_pred_scaling_list_flag" );           pcPPS->setPredScalingListFlag( uiCode ? true : false );
     306      pcPPS->getScalingList()->setPredScalingListFlag( pcPPS->getPredScalingListFlag() );
     307     
     308      if( pcPPS->getPredScalingListFlag() )
     309      {
     310        READ_UVLC ( uiCode, "scaling_list_pps_ref_layer_id" );   pcPPS->setScalingListRefLayerId( uiCode );
     311
     312        // The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
     313        assert( pcPPS->getScalingListRefLayerId() >= 0 && pcPPS->getScalingListRefLayerId() <= 62 );
     314
     315        // When avc_base_layer_flag is equal to 1, it is a requirement of bitstream conformance that the value of pps_scaling_list_ref_layer_id shall be greater than 0
     316        if( pcPPS->getSPS()->getVPS()->getAvcBaseLayerFlag() )
     317        {
     318          assert( pcPPS->getScalingListRefLayerId() > 0 );
     319        }
     320
     321        // It is a requirement of bitstream conformance that, when a PPS with nuh_layer_id equal to nuhLayerIdA is active for a layer with nuh_layer_id equal to nuhLayerIdB and
     322        // pps_infer_scaling_list_flag in the PPS is equal to 1, pps_infer_scaling_list_flag shall be equal to 0 for the PPS that is active for the layer with nuh_layer_id equal to pps_scaling_list_ref_layer_id
     323        assert( pcPPS->getPPS( pcPPS->getScalingListRefLayerId() )->getPredScalingListFlag() == false );
     324
     325        // It is a requirement of bitstream conformance that, when a PPS with nuh_layer_id equal to nuhLayerIdA is active for a layer with nuh_layer_id equal to nuhLayerIdB,
     326        // the layer with nuh_layer_id equal to pps_scaling_list_ref_layer_id shall be a direct or indirect reference layer of the layer with nuh_layer_id equal to nuhLayerIdB
     327        assert( pcPPS->getSPS()->getVPS()->getScalingListLayerDependency( pcPPS->getLayerId(), pcPPS->getScalingListRefLayerId() ) == true );
     328
     329        pcPPS->getScalingList()->setScalingListRefLayerId( pcPPS->getScalingListRefLayerId() );
     330        parseScalingList( pcPPS->getScalingList() );
     331      }
     332      else
     333      {
     334        parseScalingList( pcPPS->getScalingList() );
     335      }
     336    }
     337    else
     338    {
     339      parseScalingList( pcPPS->getScalingList() );
     340    }
     341#else
    295342    parseScalingList( pcPPS->getScalingList() );
     343#endif
    296344  }
    297345
    … …  
    522570  }
    523571#endif
     572#if IL_SL_SIGNALLING_N0371
     573  pcSPS->setVPS( parameterSetManager->getPrefetchedVPS(pcSPS->getVPSId()) );
     574  pcSPS->setSPS( pcSPS->getLayerId(), pcSPS );
     575#endif
    524576  if ( pcSPS->getMaxTLayers() == 1 )
    525577  {
    … …  
    647699  Int addCuDepth = max (0, log2MinCUSize - (Int)pcSPS->getQuadtreeTULog2MinSize() );
    648700  pcSPS->setMaxCUDepth( maxCUDepthDelta + addCuDepth );
    649 
    650701  READ_FLAG( uiCode, "scaling_list_enabled_flag" );                 pcSPS->setScalingListFlag ( uiCode );
     702
    651703  if(pcSPS->getScalingListFlag())
    652704  {
    … …  
    654706    if(pcSPS->getScalingListPresentFlag ())
    655707    {
     708
     709#if IL_SL_SIGNALLING_N0371
     710      pcSPS->getScalingList()->setLayerId( pcSPS->getLayerId() );
     711
     712      if( pcSPS->getLayerId() > 0 )
     713      {
     714        READ_FLAG( uiCode, "sps_pred_scaling_list_flag" );  pcSPS->setPredScalingListFlag ( uiCode );
     715        pcSPS->getScalingList()->setPredScalingListFlag( pcSPS->getPredScalingListFlag() );
     716
     717        if( pcSPS->getPredScalingListFlag() )
     718        {
     719          READ_UVLC( uiCode, "scaling_list_sps_ref_layer_id" );    pcSPS->setScalingListRefLayerId( uiCode );
     720
     721          // The value of sps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
     722          assert( pcSPS->getScalingListRefLayerId() >= 0 && pcSPS->getScalingListRefLayerId() <= 62 );
     723
     724          // When avc_base_layer_flag is equal to 1, it is a requirement of bitstream conformance that the value of sps_scaling_list_ref_layer_id shall be greater than 0
     725          if( pcSPS->getVPS()->getAvcBaseLayerFlag() )
     726          {
     727            assert( pcSPS->getScalingListRefLayerId() > 0 );
     728          }
     729
     730          // It is a requirement of bitstream conformance that, when an SPS with nuh_layer_id equal to nuhLayerIdA is active for a layer with nuh_layer_id equal to nuhLayerIdB and
     731          // sps_infer_scaling_list_flag in the SPS is equal to 1, sps_infer_scaling_list_flag shall be equal to 0 for the SPS that is active for the layer with nuh_layer_id equal to sps_scaling_list_ref_layer_id
     732          assert( pcSPS->getSPS( pcSPS->getScalingListRefLayerId() )->getPredScalingListFlag() == false );
     733
     734          // It is a requirement of bitstream conformance that, when an SPS with nuh_layer_id equal to nuhLayerIdA is active for a layer with nuh_layer_id equal to nuhLayerIdB,
     735          // the layer with nuh_layer_id equal to sps_scaling_list_ref_layer_id shall be a direct or indirect reference layer of the layer with nuh_layer_id equal to nuhLayerIdB
     736          assert( pcSPS->getVPS()->getScalingListLayerDependency( pcSPS->getLayerId(), pcSPS->getScalingListRefLayerId() ) == true );
     737
     738          pcSPS->getScalingList()->setScalingListRefLayerId( pcSPS->getScalingListRefLayerId() );
     739          parseScalingList( pcSPS->getScalingList() );
     740        }
     741        else
     742        {
     743          parseScalingList( pcSPS->getScalingList() );
     744        }
     745      }
     746      else
     747      {
     748        parseScalingList( pcSPS->getScalingList() );
     749      }
     750#else
    656751      parseScalingList( pcSPS->getScalingList() );
     752#endif
     753
    657754    }
    658755  }
    … …  
    12431340    }
    12441341  }
    1245 #endif
     1342
     1343#endif
     1344
     1345#if IL_SL_SIGNALLING_N0371
     1346  for(i = 1; i < vps->getMaxLayers(); i++)
     1347    {
     1348      for(j = 0; j < i; j++)
     1349        {     
     1350          vps->setScalingListLayerDependency( i, j, vps->checkLayerDependency( i,j ) );
     1351        }
     1352    }
     1353#endif
     1354
    12461355#if M0040_ADAPTIVE_RESOLUTION_CHANGE
    12471356  READ_FLAG(uiCode, "single_layer_for_non_irap_flag" ); vps->setSingleLayerForNonIrapFlag(uiCode == 1 ? true : false);
    … …  
    24472556  UInt  code, sizeId, listId;
    24482557  Bool scalingListPredModeFlag;
     2558
    24492559  //for each size
    24502560  for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
    … …  
    24522562    for(listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
    24532563    {
     2564#if IL_SL_SIGNALLING_N0371
     2565      if ( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
     2566      {
     2567        READ_FLAG( code, "scaling_list_pred_mode_flag");
     2568        scalingListPredModeFlag = (code) ? true : false;
     2569        if(!scalingListPredModeFlag) //Copy Mode
     2570        {
     2571          READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
     2572          scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
     2573          if( sizeId > SCALING_LIST_8x8 )
     2574          {
     2575            scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
     2576          }
     2577          scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
     2578
     2579        }
     2580        else //DPCM Mode
     2581        {
     2582          xDecodeScalingList(scalingList, sizeId, listId);
     2583        }
     2584      }
     2585      else
     2586      {
     2587        READ_FLAG( code, "scaling_list_pred_mode_flag");
     2588        scalingListPredModeFlag = (code) ? true : false;
     2589        if(!scalingListPredModeFlag) //Copy Mode
     2590        {
     2591          READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
     2592          scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
     2593          if( sizeId > SCALING_LIST_8x8 )
     2594          {
     2595            scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
     2596          }
     2597          scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
     2598
     2599        }
     2600        else //DPCM Mode
     2601        {
     2602          xDecodeScalingList(scalingList, sizeId, listId);
     2603        }
     2604      }
     2605#else
    24542606      READ_FLAG( code, "scaling_list_pred_mode_flag");
    24552607      scalingListPredModeFlag = (code) ? true : false;
    … …  
    24692621        xDecodeScalingList(scalingList, sizeId, listId);
    24702622      }
     2623#endif
    24712624    }
    24722625  }
    … …  
    24902643  if( sizeId > SCALING_LIST_8x8 )
    24912644  {
     2645#if IL_SL_SIGNALLING_N0371
     2646    if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
     2647    {
     2648      ref_scalingListDC[scalingList->getLayerId()][sizeId][listId] = scalingList->getScalingListDC(sizeId,listId);
     2649      scalingList->setScalingListDC(sizeId,listId,ref_scalingListDC[scalingList->getScalingListRefLayerId()][sizeId][listId]);
     2650    }
     2651    else
     2652    {
     2653      READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
     2654      scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
     2655      nextCoef = scalingList->getScalingListDC(sizeId,listId);
     2656      ref_scalingListDC[scalingList->getLayerId()][sizeId][listId] = scalingList->getScalingListDC(sizeId,listId);
     2657    }
     2658#else
    24922659    READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
    24932660    scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
    24942661    nextCoef = scalingList->getScalingListDC(sizeId,listId);
     2662#endif
    24952663  }
    24962664
    24972665  for(i = 0; i < coefNum; i++)
    24982666  {
     2667#if IL_SL_SIGNALLING_N0371
     2668    if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
     2669    {
     2670      ref_scalingListCoef[scalingList->getLayerId()][sizeId][listId][i] = dst[scan[i]];
     2671      dst[scan[i]] = ref_scalingListCoef[scalingList->getScalingListRefLayerId()][sizeId][listId][i];
     2672    }
     2673    else
     2674    {
     2675      READ_SVLC( data, "scaling_list_delta_coef");
     2676      nextCoef = (nextCoef + data + 256 ) % 256;
     2677      dst[scan[i]] = nextCoef;
     2678      ref_scalingListCoef[scalingList->getLayerId()][sizeId][listId][i] = dst[scan[i]];
     2679    }
     2680#else
    24992681    READ_SVLC( data, "scaling_list_delta_coef");
    25002682    nextCoef = (nextCoef + data + 256 ) % 256;
    25012683    dst[scan[i]] = nextCoef;
     2684#endif
    25022685  }
    25032686}

  • branches/SHM-3.1-dev/source/Lib/TLibDecoder/TDecCAVLC.h

    r389 r414  
    7575  Void  parseVPSExtension   ( TComVPS* pcVPS );
    7676#endif
     77
    7778#if VPS_VUI
    7879  Void  parseVPSVUI   ( TComVPS* pcVPS );

  • branches/SHM-3.1-dev/source/Lib/TLibDecoder/TDecTop.cpp

    r412 r414  
    12321232  if(pcSlice->getSPS()->getScalingListFlag())
    12331233  {
     1234#if IL_SL_SIGNALLING_N0371
     1235    pcSlice->getSPS()->getScalingList()->setLayerId( m_layerId );
     1236#endif
     1237
    12341238    pcSlice->setScalingList ( pcSlice->getSPS()->getScalingList()  );
     1239
    12351240    if(pcSlice->getPPS()->getScalingListPresentFlag())
    12361241    {
     1242#if IL_SL_SIGNALLING_N0371
     1243      pcSlice->getPPS()->getScalingList()->setLayerId( m_layerId );
     1244#endif
     1245
    12371246      pcSlice->setScalingList ( pcSlice->getPPS()->getScalingList()  );
    12381247    }
    … …  
    12401249    if(!pcSlice->getPPS()->getScalingListPresentFlag() && !pcSlice->getSPS()->getScalingListPresentFlag())
    12411250    {
     1251#if IL_SL_SIGNALLING_N0371
     1252      pcSlice->setDefaultScalingList( m_layerId );
     1253#else
    12421254      pcSlice->setDefaultScalingList();
     1255#endif
    12431256    }
    12441257    m_cTrQuant.setScalingListDec(pcSlice->getScalingList());
    … …  
    12471260  else
    12481261  {
     1262#if IL_SL_SIGNALLING_N0371
     1263    m_cTrQuant.setFlatScalingList( m_layerId );
     1264#else
    12491265    m_cTrQuant.setFlatScalingList();
     1266#endif
    12501267    m_cTrQuant.setUseScalingList(false);
    12511268  }
    … …  
    12781295  sps->setLayerId(m_layerId);
    12791296#endif
     1297
    12801298#if SPS_SUB_LAYER_INFO
    12811299  m_cEntropyDecoder.decodeSPS( sps, &m_parameterSetManagerDecoder[0] );
    … …  
    13011319{
    13021320  TComPPS* pps = new TComPPS();
     1321
     1322#if IL_SL_SIGNALLING_N0371
     1323  pps->setLayerId(m_layerId);
     1324#endif
     1325
    13031326  m_cEntropyDecoder.decodePPS( pps );
    13041327#if SVC_EXTENSION

  • branches/SHM-3.1-dev/source/Lib/TLibDecoder/TDecTop.h

    r411 r414  
    7979
    8080  TComSlice*              m_apcSlicePilot;
    81  
     81
    8282  SEIMessages             m_SEIs; ///< List of SEI messages that have been received before the first slice and between slices
    8383

  • branches/SHM-3.1-dev/source/Lib/TLibEncoder/TEncCavlc.cpp

    r411 r414  
    221221  }
    222222  WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0,                          "pps_scaling_list_data_present_flag" );
     223
     224#if IL_SL_SIGNALLING_N0371
     225  pcPPS->setPPS( pcPPS->getLayerId(), pcPPS ); 
     226#endif
     227
    223228  if( pcPPS->getScalingListPresentFlag() )
    224229  {
    … …  
    226231    printf("PPS\n");
    227232#endif
     233
     234#if IL_SL_SIGNALLING_N0371
     235    m_pcSlice->getScalingList()->setLayerId( pcPPS->getLayerId() );
     236
     237    if( pcPPS->getLayerId() > 0 )
     238    {
     239      WRITE_FLAG( pcPPS->getPredScalingListFlag() ? 1 : 0,                          "pps_pred_scaling_list_flag" );
     240      m_pcSlice->getScalingList()->setPredScalingListFlag( pcPPS->getPredScalingListFlag() );
     241
     242      if( pcPPS->getPredScalingListFlag() )
     243      {
     244        // The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
     245        assert( pcPPS->getScalingListRefLayerId() >= 0 && pcPPS->getScalingListRefLayerId() <= 62 );
     246
     247        // When avc_base_layer_flag is equal to 1, it is a requirement of bitstream conformance that the value of pps_scaling_list_ref_layer_id shall be greater than 0
     248        if( pcPPS->getSPS()->getVPS()->getAvcBaseLayerFlag() )
     249        {
     250          assert( pcPPS->getScalingListRefLayerId() > 0 );
     251        }
     252
     253        // It is a requirement of bitstream conformance that, when a PPS with nuh_layer_id equal to nuhLayerIdA is active for a layer with nuh_layer_id equal to nuhLayerIdB and
     254        // pps_infer_scaling_list_flag in the PPS is equal to 1, pps_infer_scaling_list_flag shall be equal to 0 for the PPS that is active for the layer with nuh_layer_id equal to pps_scaling_list_ref_layer_id
     255        assert( pcPPS->getPPS( pcPPS->getScalingListRefLayerId() )->getPredScalingListFlag() == false );
     256
     257        // It is a requirement of bitstream conformance that, when a PPS with nuh_layer_id equal to nuhLayerIdA is active for a layer with nuh_layer_id equal to nuhLayerIdB,
     258        // the layer with nuh_layer_id equal to pps_scaling_list_ref_layer_id shall be a direct or indirect reference layer of the layer with nuh_layer_id equal to nuhLayerIdB
     259        assert( pcPPS->getSPS()->getVPS()->getScalingListLayerDependency( pcPPS->getLayerId(), pcPPS->getScalingListRefLayerId() ) == true );
     260       
     261        WRITE_UVLC( pcPPS->getScalingListRefLayerId(),                            "scaling_list_pps_ref_layer_id" );
     262        m_pcSlice->getScalingList()->setScalingListRefLayerId( pcPPS->getScalingListRefLayerId() );
     263        codeScalingList( m_pcSlice->getScalingList() );
     264      }
     265      else
     266      {
     267        codeScalingList( m_pcSlice->getScalingList() );
     268      }
     269    }
     270    else
     271    {
     272      codeScalingList( m_pcSlice->getScalingList() );
     273    }
     274#else
    228275    codeScalingList( m_pcSlice->getScalingList() );
     276#endif
     277
    229278  }
    230279  WRITE_FLAG( pcPPS->getListsModificationPresentFlag(), "lists_modification_present_flag");
    … …  
    489538  WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthIntra() - 1,                               "max_transform_hierarchy_depth_intra" );
    490539  WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0,                                   "scaling_list_enabled_flag" );
     540
     541#if IL_SL_SIGNALLING_N0371
     542  pcSPS->setSPS( pcSPS->getLayerId(), pcSPS );
     543#endif
     544
    491545  if(pcSPS->getScalingListFlag())
    492546  {
    … …  
    497551    printf("SPS\n");
    498552#endif
     553
     554#if IL_SL_SIGNALLING_N0371
     555    m_pcSlice->getScalingList()->setLayerId( pcSPS->getLayerId() );
     556
     557    if( pcSPS->getLayerId() > 0 )
     558    {
     559      WRITE_FLAG( pcSPS->getPredScalingListFlag() ? 1 : 0,                          "sps_pred_scaling_list_flag" );
     560      m_pcSlice->getScalingList()->setPredScalingListFlag( pcSPS->getPredScalingListFlag() );
     561
     562      if( pcSPS->getPredScalingListFlag() )
     563      {
     564
     565        // The value of sps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
     566        assert( pcSPS->getScalingListRefLayerId() >= 0 && pcSPS->getScalingListRefLayerId() <= 62 );
     567       
     568        // When avc_base_layer_flag is equal to 1, it is a requirement of bitstream conformance that the value of sps_scaling_list_ref_layer_id shall be greater than 0
     569        if( pcSPS->getVPS()->getAvcBaseLayerFlag() )
     570        {
     571          assert( pcSPS->getScalingListRefLayerId() > 0 );
     572        }
     573
     574        // It is a requirement of bitstream conformance that, when an SPS with nuh_layer_id equal to nuhLayerIdA is active for a layer with nuh_layer_id equal to nuhLayerIdB and
     575        // sps_infer_scaling_list_flag in the SPS is equal to 1, sps_infer_scaling_list_flag shall be equal to 0 for the SPS that is active for the layer with nuh_layer_id equal to sps_scaling_list_ref_layer_id
     576        assert( pcSPS->getSPS( pcSPS->getScalingListRefLayerId() )->getPredScalingListFlag() == false );
     577
     578        // It is a requirement of bitstream conformance that, when an SPS with nuh_layer_id equal to nuhLayerIdA is active for a layer with nuh_layer_id equal to nuhLayerIdB,
     579        // the layer with nuh_layer_id equal to sps_scaling_list_ref_layer_id shall be a direct or indirect reference layer of the layer with nuh_layer_id equal to nuhLayerIdB
     580        assert( pcSPS->getVPS()->getScalingListLayerDependency( pcSPS->getLayerId(), pcSPS->getScalingListRefLayerId() ) == true );
     581
     582        WRITE_UVLC( pcSPS->getScalingListRefLayerId(),                            "scaling_list_sps_ref_layer_id" );
     583        m_pcSlice->getScalingList()->setScalingListRefLayerId( pcSPS->getScalingListRefLayerId() );
     584        codeScalingList( m_pcSlice->getScalingList() );
     585      }
     586      else
     587      {
     588        codeScalingList( m_pcSlice->getScalingList() );
     589      }
     590    }
     591    else
     592    {
    499593      codeScalingList( m_pcSlice->getScalingList() );
     594    }
     595#else
     596      codeScalingList( m_pcSlice->getScalingList() );
     597#endif
     598
    500599    }
    501600  }
    … …  
    517616  TComRPSList* rpsList = pcSPS->getRPSList();
    518617  TComReferencePictureSet*      rps;
    519 
     618 
    520619  WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
    521620  for(Int i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
    … …  
    9491048    }
    9501049  }
     1050
     1051#if IL_SL_SIGNALLING_N0371
     1052  for(i = 1; i < vps->getMaxLayers(); i++)
     1053  {
     1054    for(j = 0; j < i; j++)
     1055    {
     1056      vps->setScalingListLayerDependency( i, j, vps->checkLayerDependency( i,j ) );
     1057    }
     1058  }
     1059#endif
     1060
    9511061#endif
    9521062#if M0040_ADAPTIVE_RESOLUTION_CHANGE
    … …  
    19012011        startBit = m_pcBitIf->getNumberOfWrittenBits();
    19022012#endif
     2013
     2014#if IL_SL_SIGNALLING_N0371
     2015        if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
     2016        {
     2017          scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
     2018          WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
     2019          if(!scalingListPredModeFlag)// Copy Mode
     2020          {
     2021            WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId), "scaling_list_pred_matrix_id_delta");
     2022          }
     2023          else// DPCM Mode
     2024          {
     2025            xCodeScalingList(scalingList, sizeId, listId);
     2026          }
     2027        }
     2028        else
     2029        {
     2030          scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
     2031          WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
     2032          if(!scalingListPredModeFlag)// Copy Mode
     2033          {
     2034            WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId), "scaling_list_pred_matrix_id_delta");
     2035          }
     2036          else// DPCM Mode
     2037          {
     2038            xCodeScalingList(scalingList, sizeId, listId);
     2039          }
     2040        }
     2041#else
    19032042        scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
    19042043        WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
    … …  
    19112050          xCodeScalingList(scalingList, sizeId, listId);
    19122051        }
     2052#endif
     2053
    19132054#if SCALING_LIST_OUTPUT_RESULT
    19142055        printf("Matrix [%d][%d] Bit %d\n",sizeId,listId,m_pcBitIf->getNumberOfWrittenBits() - startBit);
    19152056#endif
     2057
    19162058      }
    19172059    }
    … …  
    19332075  Int data;
    19342076  Int *src = scalingList->getScalingListAddress(sizeId, listId);
     2077
    19352078    if( sizeId > SCALING_LIST_8x8 )
    19362079    {
     2080#if IL_SL_SIGNALLING_N0371
     2081      if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
     2082      {
     2083        ref_scalingListDC[scalingList->getLayerId()][sizeId][listId] = scalingList->getScalingListDC(sizeId,listId);
     2084        scalingList->setScalingListDC(sizeId,listId,ref_scalingListDC[scalingList->getScalingListRefLayerId()][sizeId][listId]);
     2085      }
     2086      else
     2087      {
     2088        WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
     2089        nextCoef = scalingList->getScalingListDC(sizeId,listId);
     2090        ref_scalingListDC[scalingList->getLayerId()][sizeId][listId] = scalingList->getScalingListDC(sizeId,listId);
     2091      }
     2092#else
    19372093      WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
    19382094      nextCoef = scalingList->getScalingListDC(sizeId,listId);
     2095#endif
    19392096    }
    19402097    for(Int i=0;i<coefNum;i++)
    19412098    {
     2099#if IL_SL_SIGNALLING_N0371
     2100      if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
     2101      {
     2102        ref_scalingListCoef[scalingList->getLayerId()][sizeId][listId][i] = src[scan[i]];
     2103        src[scan[i]] = ref_scalingListCoef[scalingList->getScalingListRefLayerId()][sizeId][listId][i];
     2104      }
     2105      else
     2106      {
     2107        data = src[scan[i]] - nextCoef;
     2108        ref_scalingListCoef[scalingList->getLayerId()][sizeId][listId][i] = src[scan[i]];
     2109        nextCoef = src[scan[i]];
     2110        if(data > 127)
     2111        {
     2112          data = data - 256;
     2113        }
     2114        if(data < -128)
     2115        {
     2116          data = data + 256;
     2117        }
     2118
     2119        WRITE_SVLC( data,  "scaling_list_delta_coef");
     2120      }
     2121#else
    19422122      data = src[scan[i]] - nextCoef;
    19432123      nextCoef = src[scan[i]];
    … …  
    19522132
    19532133      WRITE_SVLC( data,  "scaling_list_delta_coef");
     2134#endif
    19542135    }
    19552136}

  • branches/SHM-3.1-dev/source/Lib/TLibEncoder/TEncCavlc.h

    r389 r414  
    8787  Void  codeVPSExtension        ( TComVPS* pcVPS );
    8888#endif
     89
    8990#if VPS_VUI
    9091  Void codeVPSVUI               (TComVPS *vps);

  • branches/SHM-3.1-dev/source/Lib/TLibEncoder/TEncGOP.cpp

    r413 r414  
    593593#endif
    594594
     595#if IL_SL_SIGNALLING_N0371
     596    m_pcEncTop->getScalingList()->setLayerId( m_layerId );
     597#endif
     598
    595599    pcSlice->setLastIDR(m_iLastIDR);
    596600    pcSlice->setSliceIdx(0);
    … …  
    601605    if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_OFF)
    602606    {
     607#if IL_SL_SIGNALLING_N0371
     608      m_pcEncTop->getTrQuant()->setFlatScalingList( m_layerId );
     609#else
    603610      m_pcEncTop->getTrQuant()->setFlatScalingList();
     611#endif
    604612      m_pcEncTop->getTrQuant()->setUseScalingList(false);
    605613      m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
    … …  
    608616    else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_DEFAULT)
    609617    {
     618#if IL_SL_SIGNALLING_N0371
     619      pcSlice->getScalingList()->setLayerId( m_layerId );
     620#endif
     621
     622#if IL_SL_SIGNALLING_N0371
     623      pcSlice->setDefaultScalingList ( m_layerId );
     624#else
    610625      pcSlice->setDefaultScalingList ();
     626#endif
     627
    611628      m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
    612629      m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
    … …  
    616633    else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_FILE_READ)
    617634    {
     635#if IL_SL_SIGNALLING_N0371
     636      pcSlice->getScalingList()->setLayerId( m_layerId );
     637#endif
     638
    618639      if(pcSlice->getScalingList()->xParseScalingList(m_pcCfg->getScalingListFile()))
    619640      {
     641#if IL_SL_SIGNALLING_N0371
     642        pcSlice->setDefaultScalingList ( m_layerId );
     643#else
    620644        pcSlice->setDefaultScalingList ();
    621       }
     645#endif
     646      }
     647#if IL_SL_SIGNALLING_N0371
     648      pcSlice->getScalingList()->checkDcOfMatrix( m_layerId );
     649#else
    622650      pcSlice->getScalingList()->checkDcOfMatrix();
     651#endif
    623652      m_pcEncTop->getSPS()->setScalingListPresentFlag(pcSlice->checkDefaultScalingList());
     653
     654#if IL_SL_SIGNALLING_N0371
     655      if( m_layerId > 0 )
     656      {
     657        m_pcEncTop->getSPS()->setPredScalingListFlag  (true);
     658        m_pcEncTop->getSPS()->setScalingListRefLayerId( 0 );
     659      }
     660#endif
     661
    624662      m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
     663
     664#if IL_SL_SIGNALLING_N0371
     665      if( m_layerId > 0 )
     666      {
     667        m_pcEncTop->getPPS()->setPredScalingListFlag  (false);
     668        m_pcEncTop->getPPS()->setScalingListRefLayerId( 0   );
     669      }
     670#endif
     671
    625672      m_pcEncTop->getTrQuant()->setScalingList(pcSlice->getScalingList());
    626673      m_pcEncTop->getTrQuant()->setUseScalingList(true);
    … …  
    14931540#if SVC_EXTENSION
    14941541      nalu = NALUnit(NAL_UNIT_SPS, 0, m_layerId);
     1542#if IL_SL_SIGNALLING_N0371
     1543      pcSlice->getSPS()->setVPS( pcSlice->getVPS() );
     1544#endif
    14951545#else
    14961546      nalu = NALUnit(NAL_UNIT_SPS);

  • branches/SHM-3.1-dev/source/Lib/TLibEncoder/TEncTop.cpp

    r411 r414  
    110110  initROM();
    111111#endif
    112  
     112
    113113  // create processing unit classes
    114114#if SVC_EXTENSION
    … …  
    761761Void TEncTop::xInitPPS()
    762762{
     763#if IL_SL_SIGNALLING_N0371
     764  m_cPPS.setLayerId(m_layerId);
     765#endif
     766
    763767  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
    764768  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;

  • branches/SHM-3.1-dev/source/Lib/TLibEncoder/TEncTop.h

    r411 r414  
    130130 
    131131#if SVC_EXTENSION
     132
    132133  TEncTop**               m_ppcTEncTop;
    133134  TEncTop*                getLayerEnc(UInt layer)   { return m_ppcTEncTop[layer]; }
Note: See TracChangeset for help on using the changeset viewer.