Changeset 529 in SHVCSoftware


Ignore:
Timestamp:
25 Dec 2013, 05:53:40 (11 years ago)
Author:
seregin
Message:

remove IL_SL_SIGNALLING_N0371 macro and related code

Location:
branches/SHM-4.1-dev/source
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

    r527 r529  
    13181318  }
    13191319#endif
    1320 #if IL_SL_SIGNALLING_N0371
    1321   for(i = 1; i < vps->getMaxLayers(); i++)
    1322   {
    1323     for(Int j = 0; j < i; j++)
    1324     {
    1325       vps->setScalingListLayerDependency( i, j, vps->checkLayerDependency( i,j ) );
    1326     }
    1327   }
    1328 #endif
    13291320#endif
    13301321#if JCTVC_M0458_INTERLAYER_RPS_SIG

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

    r494 r529  
    541541Int g_mvScalingFactor  [MAX_LAYERS][2] = {{0,0}, {0,0}};
    542542Int g_posScalingFactor [MAX_LAYERS][2] = {{0,0}, {0,0}};
    543 
    544 #if IL_SL_SIGNALLING_N0371
    545 Int ref_scalingListDC         [MAX_LAYERS][SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
    546 Int ref_scalingListCoef       [MAX_LAYERS][SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM][MAX_MATRIX_COEF_NUM];
    547 Int activeRefPPSId            [MAX_LAYERS];
    548 Int activeRefSPSId            [MAX_LAYERS];
    549 #endif
    550543#endif
    551544

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

    r494 r529  
    291291#if SVC_EXTENSION
    292292extern Int g_mvScalingFactor  [MAX_LAYERS][2];
    293 extern Int g_posScalingFactor [MAX_LAYERS][2];
    294 
    295 #if IL_SL_SIGNALLING_N0371
    296 extern Int ref_scalingListDC         [MAX_LAYERS][SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
    297 extern Int ref_scalingListCoef       [MAX_LAYERS][SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM][MAX_MATRIX_COEF_NUM];
    298 extern Int activeRefPPSId            [MAX_LAYERS];
    299 extern Int activeRefSPSId            [MAX_LAYERS]; 
    300 #endif   
     293extern Int g_posScalingFactor [MAX_LAYERS][2];
    301294#endif
    302295

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

    r528 r529  
    4848ParameterSetMap<TComVPS> ParameterSetManager::m_vpsMap(MAX_NUM_VPS);
    4949Int ParameterSetManager::m_activeVPSId = -1;
    50 #if IL_SL_SIGNALLING_N0371
    51 TComSPS* TComSPS::m_pcSPS[MAX_LAYERS];
    52 TComPPS* TComPPS::m_pcPPS[MAX_LAYERS];
    53 #endif
    5450#endif
    5551
    … …  
    22332229    setNumSubDpbs( i, getNumLayersInIdList( getOutputLayerSetIdx(i)) );
    22342230  }
    2235 }
    2236 #endif
    2237 
    2238 #if IL_SL_SIGNALLING_N0371
    2239 Bool TComVPS::checkLayerDependency(UInt i, UInt j)
    2240 {
    2241   if( this->getDirectDependencyFlag(i, j) == true )
    2242   {                                                                                                                                   
    2243     return true;                                                                                                                       
    2244   }                                                                                                                                   
    2245   else                                                                                                                                   
    2246   {                                                                                                                                   
    2247     for(UInt k=i-1; k>j; k--)
    2248     {                                                                                                                               
    2249       if( this->getDirectDependencyFlag(i, k) == true )
    2250       {                                                                                                                           
    2251         checkLayerDependency( k,j );                                                                                           
    2252       }
    2253     }
    2254   }
    2255   return false;       
    22562231}
    22572232#endif
    … …  
    28222797/** set default quantization matrix to array
    28232798*/
    2824 #if IL_SL_SIGNALLING_N0371
    2825 Void TComSlice::setDefaultScalingList( UInt layerId )
    2826 #else
    28272799Void TComSlice::setDefaultScalingList()
    2828 #endif
    28292800{
    28302801  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
    … …  
    28322803    for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
    28332804    {
    2834 #if IL_SL_SIGNALLING_N0371
    2835       getScalingList()->processDefaultMarix(sizeId, listId, layerId);
    2836 #else
    28372805      getScalingList()->processDefaultMarix(sizeId, listId);
    2838 #endif
    28392806    }
    28402807  }
    … …  
    30112978 * \param Index of input matrix
    30122979 */
    3013 #if IL_SL_SIGNALLING_N0371
    3014 Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId, UInt layerId)
    3015 #else
    30162980Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId)
    3017 #endif
    3018 {
    3019 #if IL_SL_SIGNALLING_N0371
    3020   Int i,coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
    3021   UInt* scan  = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] :  g_sigLastScanCG32x32;
    3022   Int *src = getScalingListDefaultAddress(sizeId, listId);   
    3023 #endif
    3024 
     2981{
    30252982  ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
    3026 
    3027 #if IL_SL_SIGNALLING_N0371
    3028   for(i = 0; i < coefNum; i++)
    3029   {
    3030     ref_scalingListCoef[layerId][sizeId][listId][i] = src[scan[i]];
    3031   }
    3032 #endif
    3033 
    30342983  setScalingListDC(sizeId,listId,SCALING_LIST_DC);
    3035 #if IL_SL_SIGNALLING_N0371
    3036   ref_scalingListDC[layerId][sizeId][listId] = SCALING_LIST_DC;
    3037 #endif
    30382984}
    30392985
    30402986/** check DC value of matrix for default matrix signaling
    30412987 */
    3042 #if IL_SL_SIGNALLING_N0371
    3043 Void TComScalingList::checkDcOfMatrix( UInt layerId )
    3044 #else
    30452988Void TComScalingList::checkDcOfMatrix()
    3046 #endif
    30472989{
    30482990  for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
    … …  
    30532995      if(getScalingListDC(sizeId,listId) == 0)
    30542996      {
    3055 #if IL_SL_SIGNALLING_N0371
    3056         processDefaultMarix(sizeId, listId, layerId);
    3057 #else
    30582997        processDefaultMarix(sizeId, listId);
    3059 #endif
    30602998      }
    30612999    }
    … …  
    31383076        m_activeVPSId = vpsId;
    31393077        m_activeSPSId = spsId;
    3140 
    3141 #if IL_SL_SIGNALLING_N0371
    3142         activeRefPPSId[ sps->getLayerId() ] = ppsId;
    3143         activeRefSPSId[ sps->getLayerId() ] = spsId;
    3144 #endif
    31453078
    31463079        return true;

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

    r528 r529  
    157157  Bool     getScalingListPresentFlag    ()                                     { return m_scalingListPresentFlag; }
    158158
    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 
    168159  Int*     getScalingListAddress          (UInt sizeId, UInt listId)           { return m_scalingListCoef[sizeId][listId]; } //!< get matrix coefficient
    169160  Bool     checkPredMode                  (UInt sizeId, UInt listId);
    … …  
    171162  UInt     getRefMatrixId                 (UInt sizeId, UInt listId)           { return m_refMatrixId[sizeId][listId]; }     //!< get reference matrix ID
    172163  Int*     getScalingListDefaultAddress   (UInt sizeId, UInt listId);                                                        //!< get default matrix coefficient
    173 
    174 #if IL_SL_SIGNALLING_N0371
    175   Void     processDefaultMarix            (UInt sizeId, UInt listId, UInt layerId );
    176 #else
    177164  Void     processDefaultMarix            (UInt sizeId, UInt listId);
    178 #endif
    179 
    180165  Void     setScalingListDC               (UInt sizeId, UInt listId, UInt u)   { m_scalingListDC[sizeId][listId] = u; }      //!< set DC value
    181 
    182166  Int      getScalingListDC               (UInt sizeId, UInt listId)           { return m_scalingListDC[sizeId][listId]; }   //!< get DC value
    183 
    184 #if IL_SL_SIGNALLING_N0371
    185   Void     setLayerId(UInt layerId) { m_layerId = layerId; }
    186   UInt     getLayerId() { return m_layerId; }
    187   Void     checkDcOfMatrix                ( UInt m_layerId );
    188 #else
    189167  Void     checkDcOfMatrix                ();
    190 #endif
    191 
    192168  Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
    193169  Bool     xParseScalingList              (Char* pchFile);
    … …  
    200176  UInt     m_refMatrixId                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
    201177  Bool     m_scalingListPresentFlag;                                                //!< flag for using default matrix
    202 
    203 #if IL_SL_SIGNALLING_N0371
    204   Bool     m_predScalingListFlag;                                                   //!< flag for inter-layer scaling-list prediction
    205   UInt     m_scalingListRefLayerId;                                                 //!< scaling_list_ref_layer_id 
    206 #endif
    207 
    208178  UInt     m_predMatrixId                [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
    209179  Int      *m_scalingListCoef            [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix                                           
    … …  
    512482  Int         m_layerSetLayerIdList[MAX_VPS_LAYER_SETS_PLUS1][MAX_VPS_LAYER_ID_PLUS1];
    513483  Int         m_numLayerInIdList[MAX_VPS_LAYER_SETS_PLUS1];
    514 #endif
    515 #if IL_SL_SIGNALLING_N0371
    516   Bool        m_scalingListLayerDependency[MAX_LAYERS][MAX_LAYERS];  // layer dependency for scaling list
    517484#endif
    518485#if VPS_EXTN_OFFSET
    … …  
    730697#if VPS_DPB_SIZE_TABLE
    731698Void      deriveNumberOfSubDpbs();
    732 #endif
    733 #if IL_SL_SIGNALLING_N0371
    734   Bool    checkLayerDependency(UInt i, UInt j);
    735   Bool    getScalingListLayerDependency  ( UInt layerId, UInt refLayerId )            { return m_scalingListLayerDependency[layerId][refLayerId]; }
    736   Void    setScalingListLayerDependency  ( UInt layerId, UInt refLayerId, Bool val  ) { m_scalingListLayerDependency[layerId][refLayerId] = val;  }
    737699#endif
    738700
    … …  
    12931255
    12941256  UInt m_layerId;
    1295 
    1296 #if IL_SL_SIGNALLING_N0371
    1297   TComVPS*    m_pVPS;
    1298   static TComSPS* m_pcSPS[MAX_LAYERS];
    1299   Bool        m_predScalingListFlag;
    1300   UInt        m_scalingListRefLayerId;
    1301 #endif
    13021257
    13031258#if REF_IDX_MFM
    … …  
    14411396  Void setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag  = b;       }
    14421397
    1443 #if IL_SL_SIGNALLING_N0371
    1444   Bool getPredScalingListFlag()         { return m_predScalingListFlag;     }
    1445   Void setPredScalingListFlag( Bool b ) { m_predScalingListFlag  = b;       }
    1446   UInt getScalingListRefLayerId()         { return m_scalingListRefLayerId;   }
    1447   Void setScalingListRefLayerId( UInt b ) { m_scalingListRefLayerId  = b;       }
    1448 
    1449   TComVPS*  getVPS()                      { return  m_pVPS; }
    1450   Void      setVPS( TComVPS* vps )        { m_pVPS = vps;   }
    1451   static   TComSPS* getSPS(UInt layerId)               { return m_pcSPS[layerId]; }
    1452   static   Void     setSPS(UInt layerId, TComSPS* sps) { m_pcSPS[layerId] = sps;  }
    1453 #endif
    1454 
    14551398#if SCALINGLIST_INFERRING
    14561399  Void setScalingList( TComScalingList *scalingList ) { m_scalingList = scalingList; }
    … …  
    16071550  Bool     m_scalingListPresentFlag;
    16081551
    1609 #if SVC_EXTENSION
    1610   UInt m_layerId;
    1611 
    1612 #if IL_SL_SIGNALLING_N0371
    1613   static TComPPS* m_pcPPS[MAX_LAYERS];
    1614   Bool     m_predScalingListFlag;
    1615   UInt     m_scalingListRefLayerId;
    1616 #endif
    1617 
    1618 #endif
    1619 
    16201552  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
    16211553
    … …  
    16241556  Int m_numExtraSliceHeaderBits;
    16251557
     1558#if SVC_EXTENSION
    16261559#if SCALINGLIST_INFERRING
     1560  UInt     m_layerId;
    16271561  Bool     m_inferScalingListFlag;
    16281562  UInt     m_scalingListRefLayerId;
     1563#endif
    16291564#endif
    16301565
    … …  
    17461681  Void     setInferScalingListFlag( Bool flag )     { m_inferScalingListFlag = flag;     }
    17471682  Void     setScalingListRefLayerId( UInt layerId ) { m_scalingListRefLayerId = layerId; }
    1748 #endif
    1749 #if IL_SL_SIGNALLING_N0371
    1750   Void     setLayerId(UInt layerId) { m_layerId = layerId; }
    1751   UInt     getLayerId() { return m_layerId; }
    1752 
    1753   Bool     getPredScalingListFlag()         { return m_predScalingListFlag;     }
    1754   Void     setPredScalingListFlag( Bool b ) { m_predScalingListFlag  = b;       }
    1755   UInt     getScalingListRefLayerId()         { return m_scalingListRefLayerId;     }
    1756   Void     setScalingListRefLayerId( UInt b ) { m_scalingListRefLayerId  = b;       }
    1757 
    1758   static   TComPPS* getPPS(UInt layerId)               { return m_pcPPS[layerId]; }
    1759   static   Void     setPPS(UInt layerId, TComPPS* pps) { m_pcPPS[layerId] = pps;  }
    17601683#endif
    17611684
    … …  
    21592082  Void  setScalingList              ( TComScalingList* scalingList ) { m_scalingList = scalingList; }
    21602083  TComScalingList*   getScalingList ()                               { return m_scalingList; }
    2161 
    2162 #if IL_SL_SIGNALLING_N0371
    2163   Void  setDefaultScalingList       ( UInt m_layerId );
    2164 #else
    21652084  Void  setDefaultScalingList       ();
    2166 #endif
    2167 
    21682085  Bool  checkDefaultScalingList     ();
    21692086  Void      setCabacInitFlag  ( Bool val ) { m_cabacInitFlag = val;      }  //!< set CABAC initial flag

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

    r442 r529  
    24942494/** set flat matrix value to quantized coefficient
    24952495 */
    2496 #if IL_SL_SIGNALLING_N0371
    2497 Void TComTrQuant::setFlatScalingList( UInt m_layerId )
    2498 #else
    24992496Void TComTrQuant::setFlatScalingList()
    2500 #endif
    25012497{
    25022498  UInt size,list;
    … …  
    25072503    for(list = 0; list <  g_scalingListNum[size]; list++)
    25082504    {
    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 
    25172505      for(qp=0;qp<SCALING_LIST_REM_NUM;qp++)
    25182506      {

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

    r442 r529  
    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
    187183  Void setFlatScalingList  ();
    188 #endif
    189 
    190184  Void xsetFlatScalingList ( UInt list, UInt size, UInt qp);
    191185  Void xSetScalingListEnc  ( TComScalingList *scalingList, UInt list, UInt size, UInt qp);

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

    r528 r529  
    6363#define RPL_INIT_N0316_N0082             1      ///< JCTVC-N0316, JCTVC-N0082: initial reference picture list construction
    6464
    65 #define IL_SL_SIGNALLING_N0371           0      ///< JCTVC-N0371: inter-layer scaling list
    6665#define SCALINGLIST_INFERRING            1      ///< JCTVC-N0371: inter-layer scaling list
    6766#define M0463_VUI_EXT_ILP_REF            0      ///< JCTVC-M0463: VUI extension inter-layer dependency offset signalling

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

    r528 r529  
    313313  READ_FLAG( uiCode, "pps_scaling_list_data_present_flag" );           pcPPS->setScalingListPresentFlag( uiCode ? true : false );
    314314
    315 #if IL_SL_SIGNALLING_N0371
    316   pcPPS->setPPS( pcPPS->getLayerId(), pcPPS );
    317 #endif
    318 
    319315  if(pcPPS->getScalingListPresentFlag ())
    320316  {
    321 #if IL_SL_SIGNALLING_N0371
    322     pcPPS->getScalingList()->setLayerId( pcPPS->getLayerId() );
    323 
    324     if( pcPPS->getLayerId() > 0 )
    325     {
    326       READ_FLAG( uiCode, "pps_pred_scaling_list_flag" );           pcPPS->setPredScalingListFlag( uiCode ? true : false );
    327       pcPPS->getScalingList()->setPredScalingListFlag( pcPPS->getPredScalingListFlag() );
    328 
    329       if( pcPPS->getPredScalingListFlag() )
    330       {
    331         READ_UVLC ( uiCode, "scaling_list_pps_ref_layer_id" );   pcPPS->setScalingListRefLayerId( uiCode );
    332 
    333         // The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
    334         assert( /*pcPPS->getScalingListRefLayerId() >= 0 &&*/ pcPPS->getScalingListRefLayerId() <= 62 );
    335 
    336         // 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
    337         if( pcPPS->getSPS()->getVPS()->getAvcBaseLayerFlag() )
    338         {
    339           assert( pcPPS->getScalingListRefLayerId() > 0 );
    340         }
    341 
    342         // 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
    343         // 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
    344         assert( pcPPS->getPPS( pcPPS->getScalingListRefLayerId() )->getPredScalingListFlag() == false );
    345 
    346         // 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,
    347         // 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
    348         assert( pcPPS->getSPS()->getVPS()->getScalingListLayerDependency( pcPPS->getLayerId(), pcPPS->getScalingListRefLayerId() ) == true );
    349 
    350         pcPPS->getScalingList()->setScalingListRefLayerId( pcPPS->getScalingListRefLayerId() );
    351         parseScalingList( pcPPS->getScalingList() );
    352       }
    353       else
    354       {
    355         parseScalingList( pcPPS->getScalingList() );
    356       }
    357     }
    358     else
    359     {
    360       parseScalingList( pcPPS->getScalingList() );
    361     }
    362 #else
    363317    parseScalingList( pcPPS->getScalingList() );
    364 #endif
    365318  }
    366319
    … …  
    588541    pcSPS->setTemporalIdNestingFlag( parameterSetManager->getPrefetchedVPS(pcSPS->getVPSId())->getTemporalNestingFlag() );
    589542  }
    590 #if IL_SL_SIGNALLING_N0371
    591   pcSPS->setVPS( parameterSetManager->getPrefetchedVPS(pcSPS->getVPSId()) );
    592   pcSPS->setSPS( pcSPS->getLayerId(), pcSPS );
    593 #endif
    594543#endif
    595544  if ( pcSPS->getMaxTLayers() == 1 )
    … …  
    762711    if(pcSPS->getScalingListPresentFlag ())
    763712    {
    764 
    765 #if IL_SL_SIGNALLING_N0371
    766       pcSPS->getScalingList()->setLayerId( pcSPS->getLayerId() );
    767 
    768       if( pcSPS->getLayerId() > 0 )
    769       {
    770         READ_FLAG( uiCode, "sps_pred_scaling_list_flag" );  pcSPS->setPredScalingListFlag ( uiCode );
    771         pcSPS->getScalingList()->setPredScalingListFlag( pcSPS->getPredScalingListFlag() );
    772 
    773         if( pcSPS->getPredScalingListFlag() )
    774         {
    775           READ_UVLC( uiCode, "scaling_list_sps_ref_layer_id" );    pcSPS->setScalingListRefLayerId( uiCode );
    776 
    777           // The value of sps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
    778           assert( /*pcSPS->getScalingListRefLayerId() >= 0 &&*/ pcSPS->getScalingListRefLayerId() <= 62 );
    779 
    780           // 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
    781           if( pcSPS->getVPS()->getAvcBaseLayerFlag() )
    782           {
    783             assert( pcSPS->getScalingListRefLayerId() > 0 );
    784           }
    785 
    786           // 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
    787           // 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
    788           assert( pcSPS->getSPS( pcSPS->getScalingListRefLayerId() )->getPredScalingListFlag() == false );
    789 
    790           // 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,
    791           // 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
    792           assert( pcSPS->getVPS()->getScalingListLayerDependency( pcSPS->getLayerId(), pcSPS->getScalingListRefLayerId() ) == true );
    793 
    794           pcSPS->getScalingList()->setScalingListRefLayerId( pcSPS->getScalingListRefLayerId() );
    795           parseScalingList( pcSPS->getScalingList() );
    796         }
    797         else
    798         {
    799           parseScalingList( pcSPS->getScalingList() );
    800         }
    801       }
    802       else
    803       {
    804         parseScalingList( pcSPS->getScalingList() );
    805       }
    806 #else
    807713      parseScalingList( pcSPS->getScalingList() );
    808 #endif
    809 
    810714    }
    811715#if SCALINGLIST_INFERRING
    … …  
    15021406    }
    15031407  }
    1504 #endif
    1505 
    1506 #if IL_SL_SIGNALLING_N0371
    1507   for(i = 1; i < vps->getMaxLayers(); i++)
    1508     {
    1509       for(j = 0; j < i; j++)
    1510         {
    1511           vps->setScalingListLayerDependency( i, j, vps->checkLayerDependency( i,j ) );
    1512         }
    1513     }
    15141408#endif
    15151409
    … …  
    29302824    for(listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
    29312825    {
    2932 #if IL_SL_SIGNALLING_N0371
    2933       if ( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
    2934       {
    2935         READ_FLAG( code, "scaling_list_pred_mode_flag");
    2936         scalingListPredModeFlag = (code) ? true : false;
    2937         if(!scalingListPredModeFlag) //Copy Mode
    2938         {
    2939           READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
    2940           scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
    2941           if( sizeId > SCALING_LIST_8x8 )
    2942           {
    2943             scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
    2944           }
    2945           scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
    2946 
    2947         }
    2948         else //DPCM Mode
    2949         {
    2950           xDecodeScalingList(scalingList, sizeId, listId);
    2951         }
    2952       }
    2953       else
    2954       {
    2955         READ_FLAG( code, "scaling_list_pred_mode_flag");
    2956         scalingListPredModeFlag = (code) ? true : false;
    2957         if(!scalingListPredModeFlag) //Copy Mode
    2958         {
    2959           READ_UVLC( code, "scaling_list_pred_matrix_id_delta");
    2960           scalingList->setRefMatrixId (sizeId,listId,(UInt)((Int)(listId)-(code)));
    2961           if( sizeId > SCALING_LIST_8x8 )
    2962           {
    2963             scalingList->setScalingListDC(sizeId,listId,((listId == scalingList->getRefMatrixId (sizeId,listId))? 16 :scalingList->getScalingListDC(sizeId, scalingList->getRefMatrixId (sizeId,listId))));
    2964           }
    2965           scalingList->processRefMatrix( sizeId, listId, scalingList->getRefMatrixId (sizeId,listId));
    2966 
    2967         }
    2968         else //DPCM Mode
    2969         {
    2970           xDecodeScalingList(scalingList, sizeId, listId);
    2971         }
    2972       }
    2973 #else
    29742826      READ_FLAG( code, "scaling_list_pred_mode_flag");
    29752827      scalingListPredModeFlag = (code) ? true : false;
    … …  
    29892841        xDecodeScalingList(scalingList, sizeId, listId);
    29902842      }
    2991 #endif
    29922843    }
    29932844  }
    … …  
    30112862  if( sizeId > SCALING_LIST_8x8 )
    30122863  {
    3013 #if IL_SL_SIGNALLING_N0371
    3014     if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
    3015     {
    3016       ref_scalingListDC[scalingList->getLayerId()][sizeId][listId] = scalingList->getScalingListDC(sizeId,listId);
    3017       scalingList->setScalingListDC(sizeId,listId,ref_scalingListDC[scalingList->getScalingListRefLayerId()][sizeId][listId]);
    3018     }
    3019     else
    3020     {
    3021       READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
    3022       scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
    3023       nextCoef = scalingList->getScalingListDC(sizeId,listId);
    3024       ref_scalingListDC[scalingList->getLayerId()][sizeId][listId] = scalingList->getScalingListDC(sizeId,listId);
    3025     }
    3026 #else
    30272864    READ_SVLC( scalingListDcCoefMinus8, "scaling_list_dc_coef_minus8");
    30282865    scalingList->setScalingListDC(sizeId,listId,scalingListDcCoefMinus8 + 8);
    30292866    nextCoef = scalingList->getScalingListDC(sizeId,listId);
    3030 #endif
    30312867  }
    30322868
    30332869  for(i = 0; i < coefNum; i++)
    30342870  {
    3035 #if IL_SL_SIGNALLING_N0371
    3036     if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
    3037     {
    3038       ref_scalingListCoef[scalingList->getLayerId()][sizeId][listId][i] = dst[scan[i]];
    3039       dst[scan[i]] = ref_scalingListCoef[scalingList->getScalingListRefLayerId()][sizeId][listId][i];
    3040     }
    3041     else
    3042     {
    3043       READ_SVLC( data, "scaling_list_delta_coef");
    3044       nextCoef = (nextCoef + data + 256 ) % 256;
    3045       dst[scan[i]] = nextCoef;
    3046       ref_scalingListCoef[scalingList->getLayerId()][sizeId][listId][i] = dst[scan[i]];
    3047     }
    3048 #else
    30492871    READ_SVLC( data, "scaling_list_delta_coef");
    30502872    nextCoef = (nextCoef + data + 256 ) % 256;
    30512873    dst[scan[i]] = nextCoef;
    3052 #endif
    30532874  }
    30542875}

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

    r528 r529  
    14651465  if(pcSlice->getSPS()->getScalingListFlag())
    14661466  {
    1467 #if IL_SL_SIGNALLING_N0371
    1468     pcSlice->getSPS()->getScalingList()->setLayerId( m_layerId );
    1469 #endif
    1470 
    14711467    pcSlice->setScalingList ( pcSlice->getSPS()->getScalingList()  );
    14721468
    14731469    if(pcSlice->getPPS()->getScalingListPresentFlag())
    14741470    {
    1475 #if IL_SL_SIGNALLING_N0371
    1476       pcSlice->getPPS()->getScalingList()->setLayerId( m_layerId );
    1477 #endif
    1478 
    14791471      pcSlice->setScalingList ( pcSlice->getPPS()->getScalingList()  );
    14801472    }
    … …  
    14841476    if(!pcSlice->getPPS()->getScalingListPresentFlag() && !pcSlice->getSPS()->getScalingListPresentFlag())
    14851477    {
    1486 #if IL_SL_SIGNALLING_N0371
    1487       pcSlice->setDefaultScalingList( m_layerId );
    1488 #else
    14891478      pcSlice->setDefaultScalingList();
    1490 #endif
    14911479    }
    14921480    m_cTrQuant.setScalingListDec(pcSlice->getScalingList());
    … …  
    14951483  else
    14961484  {
    1497 #if IL_SL_SIGNALLING_N0371
    1498     m_cTrQuant.setFlatScalingList( m_layerId );
    1499 #else
    15001485    m_cTrQuant.setFlatScalingList();
    1501 #endif
    15021486    m_cTrQuant.setUseScalingList(false);
    15031487  }
    … …  
    15431527  TComPPS* pps = new TComPPS();
    15441528
    1545 #if SCALINGLIST_INFERRING || IL_SL_SIGNALLING_N0371
     1529#if SCALINGLIST_INFERRING
    15461530  pps->setLayerId( m_layerId );
    15471531#endif

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

    r528 r529  
    240240  WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0,                          "pps_scaling_list_data_present_flag" );
    241241
    242 #if IL_SL_SIGNALLING_N0371
    243   pcPPS->setPPS( pcPPS->getLayerId(), pcPPS ); 
    244 #endif
    245 
    246242  if( pcPPS->getScalingListPresentFlag() )
    247243  {
    … …  
    249245    printf("PPS\n");
    250246#endif
    251 
    252 #if IL_SL_SIGNALLING_N0371
    253     m_pcSlice->getScalingList()->setLayerId( pcPPS->getLayerId() );
    254 
    255     if( pcPPS->getLayerId() > 0 )
    256     {
    257       WRITE_FLAG( pcPPS->getPredScalingListFlag() ? 1 : 0,                          "pps_pred_scaling_list_flag" );
    258       m_pcSlice->getScalingList()->setPredScalingListFlag( pcPPS->getPredScalingListFlag() );
    259 
    260       if( pcPPS->getPredScalingListFlag() )
    261       {
    262         // The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
    263         assert( /*pcPPS->getScalingListRefLayerId() >= 0 &&*/ pcPPS->getScalingListRefLayerId() <= 62 );
    264 
    265         // 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
    266         if( pcPPS->getSPS()->getVPS()->getAvcBaseLayerFlag() )
    267         {
    268           assert( pcPPS->getScalingListRefLayerId() > 0 );
    269         }
    270 
    271         // 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
    272         // 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
    273         assert( pcPPS->getPPS( pcPPS->getScalingListRefLayerId() )->getPredScalingListFlag() == false );
    274 
    275         // 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,
    276         // 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
    277         assert( pcPPS->getSPS()->getVPS()->getScalingListLayerDependency( pcPPS->getLayerId(), pcPPS->getScalingListRefLayerId() ) == true );
    278        
    279         WRITE_UVLC( pcPPS->getScalingListRefLayerId(),                            "scaling_list_pps_ref_layer_id" );
    280         m_pcSlice->getScalingList()->setScalingListRefLayerId( pcPPS->getScalingListRefLayerId() );
    281         codeScalingList( m_pcSlice->getScalingList() );
    282       }
    283       else
    284       {
    285         codeScalingList( m_pcSlice->getScalingList() );
    286       }
    287     }
    288     else
    289     {
    290       codeScalingList( m_pcSlice->getScalingList() );
    291     }
    292 #else
    293247    codeScalingList( m_pcSlice->getScalingList() );
    294 #endif
    295248  }
    296249
    … …  
    569522  WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0,                                   "scaling_list_enabled_flag" );
    570523
    571 #if IL_SL_SIGNALLING_N0371
    572   pcSPS->setSPS( pcSPS->getLayerId(), pcSPS );
    573 #endif
    574 
    575524  if(pcSPS->getScalingListFlag())
    576525  {
    … …  
    597546    printf("SPS\n");
    598547#endif
    599 
    600 #if IL_SL_SIGNALLING_N0371
    601     m_pcSlice->getScalingList()->setLayerId( pcSPS->getLayerId() );
    602 
    603     if( pcSPS->getLayerId() > 0 )
    604     {
    605       WRITE_FLAG( pcSPS->getPredScalingListFlag() ? 1 : 0,                          "sps_pred_scaling_list_flag" );
    606       m_pcSlice->getScalingList()->setPredScalingListFlag( pcSPS->getPredScalingListFlag() );
    607 
    608       if( pcSPS->getPredScalingListFlag() )
    609       {
    610 
    611         // The value of sps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
    612         assert( /*pcSPS->getScalingListRefLayerId() >= 0 &&*/ pcSPS->getScalingListRefLayerId() <= 62 );
    613        
    614         // 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
    615         if( pcSPS->getVPS()->getAvcBaseLayerFlag() )
    616         {
    617           assert( pcSPS->getScalingListRefLayerId() > 0 );
    618         }
    619 
    620         // 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
    621         // 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
    622         assert( pcSPS->getSPS( pcSPS->getScalingListRefLayerId() )->getPredScalingListFlag() == false );
    623 
    624         // 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,
    625         // 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
    626         assert( pcSPS->getVPS()->getScalingListLayerDependency( pcSPS->getLayerId(), pcSPS->getScalingListRefLayerId() ) == true );
    627 
    628         WRITE_UVLC( pcSPS->getScalingListRefLayerId(),                            "scaling_list_sps_ref_layer_id" );
    629         m_pcSlice->getScalingList()->setScalingListRefLayerId( pcSPS->getScalingListRefLayerId() );
    630         codeScalingList( m_pcSlice->getScalingList() );
    631       }
    632       else
    633       {
    634         codeScalingList( m_pcSlice->getScalingList() );
    635       }
    636     }
    637     else
    638     {
    639548      codeScalingList( m_pcSlice->getScalingList() );
    640     }
    641 #else
    642       codeScalingList( m_pcSlice->getScalingList() );
    643 #endif
    644 
    645549    }
    646550#if SCALINGLIST_INFERRING
    … …  
    11751079  }
    11761080#endif
    1177 
    1178 #if IL_SL_SIGNALLING_N0371
    1179   for(i = 1; i < vps->getMaxLayers(); i++)
    1180   {
    1181     for(j = 0; j < i; j++)
    1182     {
    1183       vps->setScalingListLayerDependency( i, j, vps->checkLayerDependency( i,j ) );
    1184     }
    1185   }
    1186 #endif
    1187 
    11881081#endif
    11891082#if M0040_ADAPTIVE_RESOLUTION_CHANGE
    … …  
    22262119        startBit = m_pcBitIf->getNumberOfWrittenBits();
    22272120#endif
    2228 
    2229 #if IL_SL_SIGNALLING_N0371
    2230         if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
    2231         {
    2232           scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
    2233           WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
    2234           if(!scalingListPredModeFlag)// Copy Mode
    2235           {
    2236             WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId), "scaling_list_pred_matrix_id_delta");
    2237           }
    2238           else// DPCM Mode
    2239           {
    2240             xCodeScalingList(scalingList, sizeId, listId);
    2241           }
    2242         }
    2243         else
    2244         {
    2245           scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
    2246           WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
    2247           if(!scalingListPredModeFlag)// Copy Mode
    2248           {
    2249             WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId), "scaling_list_pred_matrix_id_delta");
    2250           }
    2251           else// DPCM Mode
    2252           {
    2253             xCodeScalingList(scalingList, sizeId, listId);
    2254           }
    2255         }
    2256 #else
    22572121        scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
    22582122        WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
    … …  
    22652129          xCodeScalingList(scalingList, sizeId, listId);
    22662130        }
    2267 #endif
    22682131
    22692132#if SCALING_LIST_OUTPUT_RESULT
    … …  
    22912154  Int *src = scalingList->getScalingListAddress(sizeId, listId);
    22922155
    2293     if( sizeId > SCALING_LIST_8x8 )
    2294     {
    2295 #if IL_SL_SIGNALLING_N0371
    2296       if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
    2297       {
    2298         ref_scalingListDC[scalingList->getLayerId()][sizeId][listId] = scalingList->getScalingListDC(sizeId,listId);
    2299         scalingList->setScalingListDC(sizeId,listId,ref_scalingListDC[scalingList->getScalingListRefLayerId()][sizeId][listId]);
    2300       }
    2301       else
    2302       {
    2303         WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
    2304         nextCoef = scalingList->getScalingListDC(sizeId,listId);
    2305         ref_scalingListDC[scalingList->getLayerId()][sizeId][listId] = scalingList->getScalingListDC(sizeId,listId);
    2306       }
    2307 #else
    2308       WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
    2309       nextCoef = scalingList->getScalingListDC(sizeId,listId);
    2310 #endif
    2311     }
    2312     for(Int i=0;i<coefNum;i++)
    2313     {
    2314 #if IL_SL_SIGNALLING_N0371
    2315       if( scalingList->getLayerId() > 0 && scalingList->getPredScalingListFlag() )
    2316       {
    2317         ref_scalingListCoef[scalingList->getLayerId()][sizeId][listId][i] = src[scan[i]];
    2318         src[scan[i]] = ref_scalingListCoef[scalingList->getScalingListRefLayerId()][sizeId][listId][i];
    2319       }
    2320       else
    2321       {
    2322         data = src[scan[i]] - nextCoef;
    2323         ref_scalingListCoef[scalingList->getLayerId()][sizeId][listId][i] = src[scan[i]];
    2324         nextCoef = src[scan[i]];
    2325         if(data > 127)
    2326         {
    2327           data = data - 256;
    2328         }
    2329         if(data < -128)
    2330         {
    2331           data = data + 256;
    2332         }
    2333 
    2334         WRITE_SVLC( data,  "scaling_list_delta_coef");
    2335       }
    2336 #else
    2337       data = src[scan[i]] - nextCoef;
    2338       nextCoef = src[scan[i]];
    2339       if(data > 127)
    2340       {
    2341         data = data - 256;
    2342       }
    2343       if(data < -128)
    2344       {
    2345         data = data + 256;
    2346       }
    2347 
    2348       WRITE_SVLC( data,  "scaling_list_delta_coef");
    2349 #endif
    2350     }
     2156  if( sizeId > SCALING_LIST_8x8 )
     2157  {
     2158    WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
     2159    nextCoef = scalingList->getScalingListDC(sizeId,listId);
     2160  }
     2161  for(Int i=0;i<coefNum;i++)
     2162  {
     2163    data = src[scan[i]] - nextCoef;
     2164    nextCoef = src[scan[i]];
     2165    if(data > 127)
     2166    {
     2167      data = data - 256;
     2168    }
     2169    if(data < -128)
     2170    {
     2171      data = data + 256;
     2172    }
     2173
     2174    WRITE_SVLC( data,  "scaling_list_delta_coef");
     2175  }
    23512176}
    23522177Bool TEncCavlc::findMatchingLTRP ( TComSlice* pcSlice, UInt *ltrpsIndex, Int ltrpPOC, Bool usedFlag )

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

    r528 r529  
    661661#endif
    662662
    663 #if IL_SL_SIGNALLING_N0371
    664     m_pcEncTop->getScalingList()->setLayerId( m_layerId );
    665 #endif
    666 
    667663    pcSlice->setLastIDR(m_iLastIDR);
    668664    pcSlice->setSliceIdx(0);
    … …  
    672668    if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_OFF)
    673669    {
    674 #if IL_SL_SIGNALLING_N0371
    675       m_pcEncTop->getTrQuant()->setFlatScalingList( m_layerId );
    676 #else
    677670      m_pcEncTop->getTrQuant()->setFlatScalingList();
    678 #endif
    679671      m_pcEncTop->getTrQuant()->setUseScalingList(false);
    680672      m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
    … …  
    700692      {
    701693#endif
    702 #if IL_SL_SIGNALLING_N0371
    703       pcSlice->getScalingList()->setLayerId( m_layerId );
    704 #endif
    705 
    706 #if IL_SL_SIGNALLING_N0371
    707       pcSlice->setDefaultScalingList ( m_layerId );
    708 #else
    709694      pcSlice->setDefaultScalingList ();
    710 #endif
    711 
    712695      m_pcEncTop->getSPS()->setScalingListPresentFlag(false);
    713696      m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
    … …  
    722705    else if(m_pcEncTop->getUseScalingListId() == SCALING_LIST_FILE_READ)
    723706    {
    724 #if IL_SL_SIGNALLING_N0371
    725       pcSlice->getScalingList()->setLayerId( m_layerId );
    726 #endif
    727 
    728707#if SCALINGLIST_INFERRING
    729708      // inferring of the scaling list can be moved to the config file
    … …  
    746725      if(pcSlice->getScalingList()->xParseScalingList(m_pcCfg->getScalingListFile()))
    747726      {
    748 #if IL_SL_SIGNALLING_N0371
    749         pcSlice->setDefaultScalingList ( m_layerId );
    750 #else
    751727        pcSlice->setDefaultScalingList ();
    752 #endif
    753       }
    754 #if IL_SL_SIGNALLING_N0371
    755       pcSlice->getScalingList()->checkDcOfMatrix( m_layerId );
    756 #else
     728      }
     729
    757730      pcSlice->getScalingList()->checkDcOfMatrix();
    758 #endif
    759731      m_pcEncTop->getSPS()->setScalingListPresentFlag(pcSlice->checkDefaultScalingList());
    760 
    761 #if IL_SL_SIGNALLING_N0371
    762       if( m_layerId > 0 )
    763       {
    764         m_pcEncTop->getSPS()->setPredScalingListFlag  (true);
    765         m_pcEncTop->getSPS()->setScalingListRefLayerId( 0 );
    766       }
    767 #endif
    768 
    769732      m_pcEncTop->getPPS()->setScalingListPresentFlag(false);
    770 
    771 #if IL_SL_SIGNALLING_N0371
    772       if( m_layerId > 0 )
    773       {
    774         m_pcEncTop->getPPS()->setPredScalingListFlag  (false);
    775         m_pcEncTop->getPPS()->setScalingListRefLayerId( 0   );
    776       }
    777 #endif
    778733
    779734#if SCALINGLIST_INFERRING
    … …  
    17781733#if SVC_EXTENSION
    17791734      nalu = NALUnit(NAL_UNIT_SPS, 0, m_layerId);
    1780 #if IL_SL_SIGNALLING_N0371
    1781       pcSlice->getSPS()->setVPS( pcSlice->getVPS() );
    1782 #endif
    17831735#else
    17841736      nalu = NALUnit(NAL_UNIT_SPS);

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

    r528 r529  
    10741074Void TEncTop::xInitPPS()
    10751075{
    1076 #if SCALINGLIST_INFERRING ||  IL_SL_SIGNALLING_N0371
     1076#if SCALINGLIST_INFERRING
    10771077  m_cPPS.setLayerId( m_layerId );
    10781078#endif
Note: See TracChangeset for help on using the changeset viewer.