Changeset 608 in 3DVCSoftware for trunk/source/Lib/TLibCommon/TComSlice.h


Ignore:
Timestamp:
1 Sep 2013, 22:47:26 (11 years ago)
Author:
tech
Message:

Merged DEV-2.0-dev0@604.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibCommon/TComSlice.h

    r443 r608  
    44 * granted under this license. 
    55 *
    6  * Copyright (c) 2010-2012, ITU/ISO/IEC
     6 * Copyright (c) 2010-2013, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
     
    5151class TComPic;
    5252class TComTrQuant;
    53 #if DEPTH_MAP_GENERATION
    54 class TComDepthMapGenerator;
    55 #endif
    56 #if H3D_IVRP & !QC_ARP_D0177
    57 class TComResidualGenerator;
     53#if H_MV
     54class TComPicLists;
    5855#endif
    5956// ====================================================================================================================
    6057// Constants
    6158// ====================================================================================================================
    62 
    63 /// max number of supported APS in software
    64 #define MAX_NUM_SUPPORTED_APS 1
    6559
    6660// ====================================================================================================================
     
    8478  Int  m_numRefIdc;
    8579  Int  m_refIdc[MAX_NUM_REF_PICS+1];
     80  Bool m_bCheckLTMSB[MAX_NUM_REF_PICS];
     81  Int  m_pocLSBLT[MAX_NUM_REF_PICS];
     82  Int  m_deltaPOCMSBCycleLT[MAX_NUM_REF_PICS];
     83  Bool m_deltaPocMSBPresentFlag[MAX_NUM_REF_PICS];
    8684
    8785public:
    8886  TComReferencePictureSet();
    8987  virtual ~TComReferencePictureSet();
    90 
     88  Int   getPocLSBLT(Int i)                       { return m_pocLSBLT[i]; }
     89  Void  setPocLSBLT(Int i, Int x)                { m_pocLSBLT[i] = x; }
     90  Int   getDeltaPocMSBCycleLT(Int i)             { return m_deltaPOCMSBCycleLT[i]; }
     91  Void  setDeltaPocMSBCycleLT(Int i, Int x)      { m_deltaPOCMSBCycleLT[i] = x; }
     92  Bool  getDeltaPocMSBPresentFlag(Int i)         { return m_deltaPocMSBPresentFlag[i]; }
     93  Void  setDeltaPocMSBPresentFlag(Int i, Bool x) { m_deltaPocMSBPresentFlag[i] = x;    }
     94  Void setUsed(Int bufferNum, Bool used);
     95  Void setDeltaPOC(Int bufferNum, Int deltaPOC);
     96  Void setPOC(Int bufferNum, Int deltaPOC);
    9197  Void setNumberOfPictures(Int numberOfPictures);
     98  Void setCheckLTMSBPresent(Int bufferNum, Bool b );
     99  Bool getCheckLTMSBPresent(Int bufferNum);
     100
     101  Int  getUsed(Int bufferNum);
     102  Int  getDeltaPOC(Int bufferNum);
     103  Int  getPOC(Int bufferNum);
    92104  Int  getNumberOfPictures();
     105
    93106  Void setNumberOfNegativePictures(Int number)  { m_numberOfNegativePictures = number; }
    94107  Int  getNumberOfNegativePictures()            { return m_numberOfNegativePictures; }
     
    97110  Void setNumberOfLongtermPictures(Int number)  { m_numberOfLongtermPictures = number; }
    98111  Int  getNumberOfLongtermPictures()            { return m_numberOfLongtermPictures; }
    99 
    100   Void setDeltaPOC(Int bufferNum, Int deltaPOC);
    101   Int  getDeltaPOC(Int bufferNum);
    102   Void setPOC(Int bufferNum, Int deltaPOC);
    103   Int  getPOC(Int bufferNum);
    104 
    105   Void setUsed(Int bufferNum, Bool used);
    106   Int  getUsed(Int bufferNum);
    107112
    108113  Void setInterRPSPrediction(Bool flag)         { m_interRPSPrediction = flag; }
     
    142147};
    143148
    144 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
     149/// SCALING_LIST class
     150class TComScalingList
     151{
     152public:
     153  TComScalingList();
     154  virtual ~TComScalingList();
     155  Void     setScalingListPresentFlag    (Bool b)                               { m_scalingListPresentFlag = b;    }
     156  Bool     getScalingListPresentFlag    ()                                     { return m_scalingListPresentFlag; }
     157  Bool     getUseTransformSkip    ()                                     { return m_useTransformSkip; }     
     158  Void     setUseTransformSkip    (Bool b)                               { m_useTransformSkip = b;    }
     159  Int*     getScalingListAddress          (UInt sizeId, UInt listId)           { return m_scalingListCoef[sizeId][listId]; } //!< get matrix coefficient
     160  Bool     checkPredMode                  (UInt sizeId, UInt listId);
     161  Void     setRefMatrixId                 (UInt sizeId, UInt listId, UInt u)   { m_refMatrixId[sizeId][listId] = u;    }     //!< set reference matrix ID
     162  UInt     getRefMatrixId                 (UInt sizeId, UInt listId)           { return m_refMatrixId[sizeId][listId]; }     //!< get reference matrix ID
     163  Int*     getScalingListDefaultAddress   (UInt sizeId, UInt listId);                                                        //!< get default matrix coefficient
     164  Void     processDefaultMarix            (UInt sizeId, UInt listId);
     165  Void     setScalingListDC               (UInt sizeId, UInt listId, UInt u)   { m_scalingListDC[sizeId][listId] = u; }      //!< set DC value
     166
     167  Int      getScalingListDC               (UInt sizeId, UInt listId)           { return m_scalingListDC[sizeId][listId]; }   //!< get DC value
     168  Void     checkDcOfMatrix                ();
     169  Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
     170  Bool     xParseScalingList              (Char* pchFile);
     171
     172private:
     173  Void     init                    ();
     174  Void     destroy                 ();
     175  Int      m_scalingListDC               [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
     176  Bool     m_useDefaultScalingMatrixFlag [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< UseDefaultScalingMatrixFlag
     177  UInt     m_refMatrixId                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
     178  Bool     m_scalingListPresentFlag;                                                //!< flag for using default matrix
     179  UInt     m_predMatrixId                [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
     180  Int      *m_scalingListCoef            [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
     181  Bool     m_useTransformSkip;                                                      //!< transform skipping flag for setting default scaling matrix for 4x4
     182};
     183
     184class ProfileTierLevel
     185{
     186  Int     m_profileSpace;
     187  Bool    m_tierFlag;
     188  Int     m_profileIdc;
     189  Bool    m_profileCompatibilityFlag[32];
     190  Int     m_levelIdc;
     191
     192  Bool m_progressiveSourceFlag;
     193  Bool m_interlacedSourceFlag;
     194  Bool m_nonPackedConstraintFlag;
     195  Bool m_frameOnlyConstraintFlag;
     196 
     197public:
     198  ProfileTierLevel();
     199
     200  Int   getProfileSpace() const   { return m_profileSpace; }
     201  Void  setProfileSpace(Int x)    { m_profileSpace = x; }
     202
     203  Bool  getTierFlag()     const   { return m_tierFlag; }
     204  Void  setTierFlag(Bool x)       { m_tierFlag = x; }
     205
     206  Int   getProfileIdc()   const   { return m_profileIdc; }
     207  Void  setProfileIdc(Int x)      { m_profileIdc = x; }
     208
     209  Bool  getProfileCompatibilityFlag(Int i) const    { return m_profileCompatibilityFlag[i]; }
     210  Void  setProfileCompatibilityFlag(Int i, Bool x)  { m_profileCompatibilityFlag[i] = x; }
     211
     212  Int   getLevelIdc()   const   { return m_levelIdc; }
     213  Void  setLevelIdc(Int x)      { m_levelIdc = x; }
     214 
     215  Bool getProgressiveSourceFlag() const { return m_progressiveSourceFlag; }
     216  Void setProgressiveSourceFlag(Bool b) { m_progressiveSourceFlag = b; }
     217 
     218  Bool getInterlacedSourceFlag() const { return m_interlacedSourceFlag; }
     219  Void setInterlacedSourceFlag(Bool b) { m_interlacedSourceFlag = b; }
     220 
     221  Bool getNonPackedConstraintFlag() const { return m_nonPackedConstraintFlag; }
     222  Void setNonPackedConstraintFlag(Bool b) { m_nonPackedConstraintFlag = b; }
     223 
     224  Bool getFrameOnlyConstraintFlag() const { return m_frameOnlyConstraintFlag; }
     225  Void setFrameOnlyConstraintFlag(Bool b) { m_frameOnlyConstraintFlag = b; }
     226};
     227
     228
     229class TComPTL
     230{
     231  ProfileTierLevel m_generalPTL;
     232  ProfileTierLevel m_subLayerPTL[6];      // max. value of max_sub_layers_minus1 is 6
     233  Bool m_subLayerProfilePresentFlag[6];
     234  Bool m_subLayerLevelPresentFlag[6];
     235
     236public:
     237  TComPTL();
     238  Bool getSubLayerProfilePresentFlag(Int i) const { return m_subLayerProfilePresentFlag[i]; }
     239  Void setSubLayerProfilePresentFlag(Int i, Bool x) { m_subLayerProfilePresentFlag[i] = x; }
     240 
     241  Bool getSubLayerLevelPresentFlag(Int i) const { return m_subLayerLevelPresentFlag[i]; }
     242  Void setSubLayerLevelPresentFlag(Int i, Bool x) { m_subLayerLevelPresentFlag[i] = x; }
     243
     244  ProfileTierLevel* getGeneralPTL()  { return &m_generalPTL; }
     245  ProfileTierLevel* getSubLayerPTL(Int i)  { return &m_subLayerPTL[i]; }
     246#if H_MV
     247  Void copyLevelFrom( TComPTL* source );
     248#endif
     249};
    145250/// VPS class
     251
     252struct HrdSubLayerInfo
     253{
     254  Bool fixedPicRateFlag;
     255  Bool fixedPicRateWithinCvsFlag;
     256  UInt picDurationInTcMinus1;
     257  Bool lowDelayHrdFlag;
     258  UInt cpbCntMinus1;
     259  UInt bitRateValueMinus1[MAX_CPB_CNT][2];
     260  UInt cpbSizeValue      [MAX_CPB_CNT][2];
     261  UInt ducpbSizeValue    [MAX_CPB_CNT][2];
     262  UInt cbrFlag           [MAX_CPB_CNT][2];
     263  UInt duBitRateValue    [MAX_CPB_CNT][2];
     264};
     265
     266class TComHRD
     267{
     268private:
     269  Bool m_nalHrdParametersPresentFlag;
     270  Bool m_vclHrdParametersPresentFlag;
     271  Bool m_subPicCpbParamsPresentFlag;
     272  UInt m_tickDivisorMinus2;
     273  UInt m_duCpbRemovalDelayLengthMinus1;
     274  Bool m_subPicCpbParamsInPicTimingSEIFlag;
     275  UInt m_dpbOutputDelayDuLengthMinus1;
     276  UInt m_bitRateScale;
     277  UInt m_cpbSizeScale;
     278  UInt m_ducpbSizeScale;
     279  UInt m_initialCpbRemovalDelayLengthMinus1;
     280  UInt m_cpbRemovalDelayLengthMinus1;
     281  UInt m_dpbOutputDelayLengthMinus1;
     282  UInt m_numDU;
     283  HrdSubLayerInfo m_HRD[MAX_TLAYER];
     284
     285public:
     286  TComHRD()
     287  :m_nalHrdParametersPresentFlag(0)
     288  ,m_vclHrdParametersPresentFlag(0)
     289  ,m_subPicCpbParamsPresentFlag(false)
     290  ,m_tickDivisorMinus2(0)
     291  ,m_duCpbRemovalDelayLengthMinus1(0)
     292  ,m_subPicCpbParamsInPicTimingSEIFlag(false)
     293  ,m_dpbOutputDelayDuLengthMinus1(0)
     294  ,m_bitRateScale(0)
     295  ,m_cpbSizeScale(0)
     296  ,m_initialCpbRemovalDelayLengthMinus1(0)
     297  ,m_cpbRemovalDelayLengthMinus1(0)
     298  ,m_dpbOutputDelayLengthMinus1(0)
     299  {}
     300
     301  virtual ~TComHRD() {}
     302
     303  Void setNalHrdParametersPresentFlag       ( Bool flag )  { m_nalHrdParametersPresentFlag = flag;         }
     304  Bool getNalHrdParametersPresentFlag       ( )            { return m_nalHrdParametersPresentFlag;         }
     305
     306  Void setVclHrdParametersPresentFlag       ( Bool flag )  { m_vclHrdParametersPresentFlag = flag;         }
     307  Bool getVclHrdParametersPresentFlag       ( )            { return m_vclHrdParametersPresentFlag;         }
     308
     309  Void setSubPicCpbParamsPresentFlag        ( Bool flag )  { m_subPicCpbParamsPresentFlag = flag;          }
     310  Bool getSubPicCpbParamsPresentFlag        ( )            { return m_subPicCpbParamsPresentFlag;          }
     311 
     312  Void setTickDivisorMinus2                 ( UInt value ) { m_tickDivisorMinus2 = value;                  }
     313  UInt getTickDivisorMinus2                 ( )            { return m_tickDivisorMinus2;                   }
     314
     315  Void setDuCpbRemovalDelayLengthMinus1     ( UInt value ) { m_duCpbRemovalDelayLengthMinus1 = value;      }
     316  UInt getDuCpbRemovalDelayLengthMinus1     ( )            { return m_duCpbRemovalDelayLengthMinus1;       }
     317
     318  Void setSubPicCpbParamsInPicTimingSEIFlag ( Bool flag)   { m_subPicCpbParamsInPicTimingSEIFlag = flag;   }
     319  Bool getSubPicCpbParamsInPicTimingSEIFlag ()             { return m_subPicCpbParamsInPicTimingSEIFlag;   }
     320
     321  Void setDpbOutputDelayDuLengthMinus1      (UInt value )  { m_dpbOutputDelayDuLengthMinus1 = value;       }
     322  UInt getDpbOutputDelayDuLengthMinus1      ()             { return m_dpbOutputDelayDuLengthMinus1;        }
     323
     324  Void setBitRateScale                      ( UInt value ) { m_bitRateScale = value;                       }
     325  UInt getBitRateScale                      ( )            { return m_bitRateScale;                        }
     326
     327  Void setCpbSizeScale                      ( UInt value ) { m_cpbSizeScale = value;                       }
     328  UInt getCpbSizeScale                      ( )            { return m_cpbSizeScale;                        }
     329  Void setDuCpbSizeScale                    ( UInt value ) { m_ducpbSizeScale = value;                     }
     330  UInt getDuCpbSizeScale                    ( )            { return m_ducpbSizeScale;                      }
     331
     332  Void setInitialCpbRemovalDelayLengthMinus1( UInt value ) { m_initialCpbRemovalDelayLengthMinus1 = value; }
     333  UInt getInitialCpbRemovalDelayLengthMinus1( )            { return m_initialCpbRemovalDelayLengthMinus1;  }
     334
     335  Void setCpbRemovalDelayLengthMinus1       ( UInt value ) { m_cpbRemovalDelayLengthMinus1 = value;        }
     336  UInt getCpbRemovalDelayLengthMinus1       ( )            { return m_cpbRemovalDelayLengthMinus1;         }
     337
     338  Void setDpbOutputDelayLengthMinus1        ( UInt value ) { m_dpbOutputDelayLengthMinus1 = value;         }
     339  UInt getDpbOutputDelayLengthMinus1        ( )            { return m_dpbOutputDelayLengthMinus1;          }
     340
     341  Void setFixedPicRateFlag       ( Int layer, Bool flag )  { m_HRD[layer].fixedPicRateFlag = flag;         }
     342  Bool getFixedPicRateFlag       ( Int layer            )  { return m_HRD[layer].fixedPicRateFlag;         }
     343
     344  Void setFixedPicRateWithinCvsFlag       ( Int layer, Bool flag )  { m_HRD[layer].fixedPicRateWithinCvsFlag = flag;         }
     345  Bool getFixedPicRateWithinCvsFlag       ( Int layer            )  { return m_HRD[layer].fixedPicRateWithinCvsFlag;         }
     346
     347  Void setPicDurationInTcMinus1  ( Int layer, UInt value ) { m_HRD[layer].picDurationInTcMinus1 = value;   }
     348  UInt getPicDurationInTcMinus1  ( Int layer             ) { return m_HRD[layer].picDurationInTcMinus1;    }
     349
     350  Void setLowDelayHrdFlag        ( Int layer, Bool flag )  { m_HRD[layer].lowDelayHrdFlag = flag;          }
     351  Bool getLowDelayHrdFlag        ( Int layer            )  { return m_HRD[layer].lowDelayHrdFlag;          }
     352
     353  Void setCpbCntMinus1           ( Int layer, UInt value ) { m_HRD[layer].cpbCntMinus1 = value; }
     354  UInt getCpbCntMinus1           ( Int layer            )  { return m_HRD[layer].cpbCntMinus1; }
     355
     356  Void setBitRateValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl] = value; }
     357  UInt getBitRateValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl             ) { return m_HRD[layer].bitRateValueMinus1[cpbcnt][nalOrVcl];  }
     358
     359  Void setCpbSizeValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl] = value;       }
     360  UInt getCpbSizeValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl            )  { return m_HRD[layer].cpbSizeValue[cpbcnt][nalOrVcl];        }
     361  Void setDuCpbSizeValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl] = value;       }
     362  UInt getDuCpbSizeValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl            )  { return m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl];        }
     363  Void setDuBitRateValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl] = value;       }
     364  UInt getDuBitRateValueMinus1     (Int layer, Int cpbcnt, Int nalOrVcl )              { return m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl];        }
     365  Void setCbrFlag                ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl] = value;            }
     366  Bool getCbrFlag                ( Int layer, Int cpbcnt, Int nalOrVcl             ) { return m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl];             }
     367
     368  Void setNumDU                              ( UInt value ) { m_numDU = value;                            }
     369  UInt getNumDU                              ( )            { return m_numDU;          }
     370  Bool getCpbDpbDelaysPresentFlag() { return getNalHrdParametersPresentFlag() || getVclHrdParametersPresentFlag(); }
     371};
     372
     373class TimingInfo
     374{
     375  Bool m_timingInfoPresentFlag;
     376  UInt m_numUnitsInTick;
     377  UInt m_timeScale;
     378  Bool m_pocProportionalToTimingFlag;
     379  Int  m_numTicksPocDiffOneMinus1;
     380public:
     381  TimingInfo()
     382  : m_timingInfoPresentFlag(false)
     383  , m_numUnitsInTick(1001)
     384  , m_timeScale(60000)
     385  , m_pocProportionalToTimingFlag(false)
     386  , m_numTicksPocDiffOneMinus1(0) {}
     387
     388  Void setTimingInfoPresentFlag             ( Bool flag )  { m_timingInfoPresentFlag = flag;               }
     389  Bool getTimingInfoPresentFlag             ( )            { return m_timingInfoPresentFlag;               }
     390
     391  Void setNumUnitsInTick                    ( UInt value ) { m_numUnitsInTick = value;                     }
     392  UInt getNumUnitsInTick                    ( )            { return m_numUnitsInTick;                      }
     393
     394  Void setTimeScale                         ( UInt value ) { m_timeScale = value;                          }
     395  UInt getTimeScale                         ( )            { return m_timeScale;                           }
     396 
     397  Bool getPocProportionalToTimingFlag       ( )            { return m_pocProportionalToTimingFlag;         }
     398  Void setPocProportionalToTimingFlag       (Bool x      ) { m_pocProportionalToTimingFlag = x;            }
     399 
     400  Int  getNumTicksPocDiffOneMinus1          ( )            { return m_numTicksPocDiffOneMinus1;            }
     401  Void setNumTicksPocDiffOneMinus1          (Int x       ) { m_numTicksPocDiffOneMinus1 = x;               }
     402};
    146403
    147404class TComVPS
     
    152409  UInt        m_uiMaxLayers;
    153410  Bool        m_bTemporalIdNestingFlag;
    154 
    155   UInt        m_uiExtensionType;
    156 #if !QC_MVHEVC_B0046 
    157   Bool        m_bDependentFlag[MAX_LAYER_NUM];
    158 #else
    159   UInt        m_uiNumHRDParameter;
    160   UInt        m_numAddiLayerOperationPoints;
    161   UInt        m_numAddiProLevelSets;
    162   UInt        m_numDirectRefLayer[MAX_LAYER_NUM];
    163   UInt        m_numDirectRefID[MAX_LAYER_NUM][MAX_LAYER_NUM];
    164   UInt        m_numOpLayerIdMinus1[MAX_LAYER_NUM];
    165   UInt        m_numOpLayerId[MAX_LAYER_NUM][MAX_LAYER_NUM];
    166 #endif
    167   UInt        m_uiViewId[MAX_LAYER_NUM];
    168 #if !QC_MVHEVC_B0046 
    169   Bool        m_bDepthFlag[MAX_LAYER_NUM];
    170 #endif
    171   Int         m_iViewOrderIdx[MAX_LAYER_NUM];
    172 #if !QC_MVHEVC_B0046 
    173   UInt        m_uiDependentLayer[MAX_LAYER_NUM];
    174 #endif
    175 
     411 
    176412  UInt        m_numReorderPics[MAX_TLAYER];
    177413  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER];
    178   UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
    179 #if INTER_VIEW_VECTOR_SCALING_C0115
    180   Bool          m_bIVScalingFlag;
    181 #endif
    182 
    183 #if MTK_D0156
    184 #if MERL_VSP_COMPENSATION_C0152
    185   Bool      m_abUseVSPCompensation[ MAX_TLAYER ];
    186 #endif
    187   Bool      m_abUseDVPRefine[ MAX_TLAYER ];
    188 #endif
    189 
     414  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER]; // Really max latency increase plus 1 (value 0 expresses no limit)
     415
     416  UInt        m_numHrdParameters;
     417#if H_MV
     418  UInt        m_maxLayerId;
     419#else
     420  UInt        m_maxNuhReservedZeroLayerId;
     421#endif
     422  TComHRD*    m_hrdParameters;
     423  UInt*       m_hrdOpSetIdx;
     424  Bool*       m_cprmsPresentFlag;
     425#if H_MV
     426  UInt        m_vpsNumLayerSetsMinus1;
     427  Bool        m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_LAYER_ID_PLUS1];
     428#else
     429  UInt        m_numOpSets;
     430  Bool        m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1];
     431#endif
     432
     433#if H_MV
     434  TComPTL     m_pcPTL[MAX_VPS_OP_SETS_PLUS1];
     435#else
     436  TComPTL     m_pcPTL;
     437#endif
     438  TimingInfo  m_timingInfo;
     439#if H_MV
     440  /// VPS EXTENSION SYNTAX ELEMENTS
     441  Bool        m_avcBaseLayerFlag;
     442  Bool        m_splittingFlag;
     443  Bool        m_scalabilityMask          [MAX_NUM_SCALABILITY_TYPES];
     444  Int         m_dimensionIdLen           [MAX_NUM_SCALABILITY_TYPES];
     445  Bool        m_vpsNuhLayerIdPresentFlag;
     446  Int         m_layerIdInNuh             [MAX_NUM_LAYER_IDS];
     447  Int         m_dimensionId              [MAX_NUM_LAYER_IDS][MAX_NUM_SCALABILITY_TYPES]; 
     448  Bool        m_directDependencyFlag     [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
     449  Int         m_maxTidIlRefPicPlus1      [MAX_NUM_LAYERS];
     450  Int         m_vpsNumberLayerSetsMinus1;
     451  Int         m_vpsNumProfileTierLevelMinus1;   
     452  Bool        m_vpsProfilePresentFlag    [MAX_VPS_OP_SETS_PLUS1];
     453  Int         m_profileRefMinus1         [MAX_VPS_PROFILE_TIER_LEVEL];
     454  Bool        m_moreOutputLayerSetsThanDefaultFlag;
     455  Int         m_numAddOutputLayerSetsMinus1;   
     456  Bool        m_defaultOneTargetOutputLayerFlag;
     457  Int         m_outputLayerSetIdxMinus1  [MAX_VPS_OUTPUTLAYER_SETS]; 
     458  Bool        m_outputLayerFlag          [MAX_VPS_OUTPUTLAYER_SETS][MAX_VPS_NUH_LAYER_ID_PLUS1];
     459  Int         m_profileLevelTierIdx      [MAX_VPS_OUTPUTLAYER_SETS ];
     460  Bool        m_maxOneActiveRefLayerFlag;       
     461  Int         m_directDepTypeLenMinus2;         
     462  Int         m_directDependencyType     [MAX_NUM_LAYERS] [MAX_NUM_LAYERS];
     463
     464  // VPS EXTENSION SEMANTICS VARIABLES
     465  Int         m_layerIdInVps             [MAX_NUM_LAYERS   ];
     466
     467  Int         m_numDirectRefLayers       [MAX_NUM_LAYERS];
     468  Int         m_refLayerId               [MAX_NUM_LAYERS][MAX_NUM_LAYERS]; 
     469
     470  Int         m_numSamplePredRefLayers   [MAX_NUM_LAYERS];
     471  Bool        m_samplePredEnabledFlag    [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     472  Int         m_samplePredRefLayerId     [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     473
     474  Int         m_numMotionPredRefLayers   [MAX_NUM_LAYERS];
     475  Bool        m_motionPredEnabledFlag    [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     476  Int         m_motionPredRefLayerId     [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     477#if H_3D
     478  Int         m_viewIndex                [MAX_NUM_LAYERS   ];
     479#endif
     480
     481  Int         xCeilLog2       ( Int val );
     482  Int         xGetDimBitOffset( Int j );
     483 
     484#if H_3D_ARP
     485  UInt        m_uiUseAdvResPred          [MAX_NUM_LAYERS   ];
     486  UInt        m_uiARPStepNum             [MAX_NUM_LAYERS   ];
     487#endif
     488#if H_3D_IV_MERGE
     489  Bool        m_ivMvPredFlag             [ MAX_NUM_LAYERS ];
     490#endif
     491#if H_3D_VSP
     492  Bool        m_viewSynthesisPredFlag    [ MAX_NUM_LAYERS ];
     493#endif
     494#if H_3D_NBDV_REF
     495  Bool        m_depthRefinementFlag      [ MAX_NUM_LAYERS ];
     496#endif
     497  Bool        m_vpsDepthModesFlag        [MAX_NUM_LAYERS   ];
     498#if H_3D_DIM_DLT
     499  Bool        m_bUseDLTFlag              [MAX_NUM_LAYERS   ];
     500 
     501  Int         m_iBitsPerDepthValue       [MAX_NUM_LAYERS   ];
     502  Int         m_iNumDepthmapValues       [MAX_NUM_LAYERS   ];
     503  Int*        m_iDepthValue2Idx          [MAX_NUM_LAYERS   ];
     504  Int*        m_iIdx2DepthValue          [MAX_NUM_LAYERS   ];
     505#endif
     506#if H_3D_TMVP
     507  Bool        m_ivMvScalingFlag;
     508#endif
     509#if LGE_INTER_SDC_E0156
     510  Bool        m_bInterSDCFlag[MAX_NUM_LAYERS   ];
     511#endif
     512
     513#endif
    190514public:
    191515  TComVPS();
    192516  virtual ~TComVPS();
    193  
     517
     518  Void    createHrdParamBuffer()
     519  {
     520    m_hrdParameters    = new TComHRD[ getNumHrdParameters() ];
     521    m_hrdOpSetIdx      = new UInt   [ getNumHrdParameters() ];
     522    m_cprmsPresentFlag = new Bool   [ getNumHrdParameters() ];
     523  }
     524
     525  TComHRD* getHrdParameters   ( UInt i )             { return &m_hrdParameters[ i ]; }
     526  UInt    getHrdOpSetIdx      ( UInt i )             { return m_hrdOpSetIdx[ i ]; }
     527  Void    setHrdOpSetIdx      ( UInt val, UInt i )   { m_hrdOpSetIdx[ i ] = val;  }
     528  Bool    getCprmsPresentFlag ( UInt i )             { return m_cprmsPresentFlag[ i ]; }
     529  Void    setCprmsPresentFlag ( Bool val, UInt i )   { m_cprmsPresentFlag[ i ] = val;  }
     530
    194531  Int     getVPSId       ()                   { return m_VPSId;          }
    195532  Void    setVPSId       (Int i)              { m_VPSId = i;             }
    196  
     533
    197534  UInt    getMaxTLayers  ()                   { return m_uiMaxTLayers;   }
    198535  Void    setMaxTLayers  (UInt t)             { m_uiMaxTLayers = t; }
    199    
     536 
    200537  UInt    getMaxLayers   ()                   { return m_uiMaxLayers;   }
    201538  Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
    202  
    203   Bool    getTemporalNestingFlag   ()         { return m_uiMaxLayers;   }
    204   Void    setTemporalNestingFlag   (UInt t)   { m_bTemporalIdNestingFlag = t; }
    205 #if !QC_MVHEVC_B0046
    206   Void    setExtensionType(UInt v)                     { m_uiExtensionType = v;    }
    207   UInt    getExtensionType()                             { return m_uiExtensionType; }
    208  
    209   Void    setDependentFlag(Bool d, UInt layer)              { m_bDependentFlag[layer] = d;    }
    210   Bool    getDependentFlag(UInt layer)                      { return m_bDependentFlag[layer]; }
    211 #endif
    212   Void    setViewId(UInt v, UInt layer)                     { m_uiViewId[layer] = v;    }
    213   UInt    getViewId(UInt layer)                             { return m_uiViewId[layer]; }
    214 #if !QC_MVHEVC_B0046
    215   Void    setDepthFlag(Bool d, UInt layer)                  { m_bDepthFlag[layer] = d;    }
    216   Bool    getDepthFlag(UInt layer)                          { return m_bDepthFlag[layer]; }
    217 #endif
    218   Void    setViewOrderIdx(Int v, UInt layer)                { m_iViewOrderIdx[layer] = v;    }
    219   Int     getViewOrderIdx(UInt layer)                       { return m_iViewOrderIdx[layer]; }
    220 #if !QC_MVHEVC_B0046   
    221   Void    setDependentLayer(UInt v, UInt layer)                     { m_uiDependentLayer[layer] = v;    }
    222   UInt    getDependentLayer(UInt layer)                             { return m_uiDependentLayer[layer]; }
    223 #endif
    224 #if INTER_VIEW_VECTOR_SCALING_C0115
    225   Bool getIVScalingFlag( )                                   { return m_bIVScalingFlag; }
    226   Void setIVScalingFlag(Bool b)                              { m_bIVScalingFlag = b;    }
    227 #endif
     539
     540  Bool    getTemporalNestingFlag   ()         { return m_bTemporalIdNestingFlag;   }
     541  Void    setTemporalNestingFlag   (Bool t)   { m_bTemporalIdNestingFlag = t; }
     542 
    228543  Void    setNumReorderPics(UInt v, UInt tLayer)                { m_numReorderPics[tLayer] = v;    }
    229544  UInt    getNumReorderPics(UInt tLayer)                        { return m_numReorderPics[tLayer]; }
    230545 
    231   Void    setMaxDecPicBuffering(UInt v, UInt tLayer)          { m_uiMaxDecPicBuffering[tLayer] = v;    }
    232   UInt    getMaxDecPicBuffering(UInt tLayer)                  { return m_uiMaxDecPicBuffering[tLayer]; }
    233  
    234   Void    setMaxLatencyIncrease(UInt v, UInt tLayer)                { m_uiMaxLatencyIncrease[tLayer] = v;    }
    235   UInt    getMaxLatencyIncrease(UInt tLayer)                        { return m_uiMaxLatencyIncrease[tLayer]; }
    236 #if QC_MVHEVC_B0046
    237   Void    setNumHRDParameters(UInt n)                                { m_uiNumHRDParameter = n;    }
    238   UInt    getNumHRDParameters()                                      { return m_uiNumHRDParameter; }
    239   Void    setNumDirectRefLayer(UInt n, UInt layer)                   { m_numDirectRefLayer[layer] = n;        };
    240   UInt    getNumDirectRefLayer(UInt layer)                           { return m_numDirectRefLayer[layer];     };
    241   Void    setDirectRefLayerId (UInt n, UInt layer, UInt refId)       { m_numDirectRefID[layer][refId] = n;   assert(refId < MAX_NUM_REF ); };
    242   UInt    getDirectRefLayerId (        UInt layer, UInt refId)       { return m_numDirectRefID[layer][refId]; };
    243   UInt    getNumAddiLayerOperationPoints(      )               { return m_numAddiLayerOperationPoints;  };
    244   Void    setNumAddiLayerOperationPoints(UInt n)                {  m_numAddiLayerOperationPoints = n;  };
    245   Void    setNumAddiProLevelSets        (UInt n)                     {  m_numAddiProLevelSets = n;}
    246   UInt    getNumAddiProLevelSets        (      )                     { return m_numAddiProLevelSets;}
    247 
    248   Void    setNumOpLayerIdMinus1         (UInt n, UInt layer)                     {  m_numOpLayerIdMinus1[layer] = n;}
    249   UInt    getNumOpLayerIdMinus1         (UInt layer      )                       { return m_numOpLayerIdMinus1[layer];}
    250 
    251   Void    setNumOpLayerId               (UInt n, UInt layer, UInt OpId)                     {  m_numOpLayerId[layer][OpId] = n;}
    252   UInt    getNumOpLayerId               (UInt layer, UInt OpId        )                     { return m_numOpLayerId[layer][OpId];}
    253  
    254 #endif
    255 
    256 #if MTK_D0156
    257 #if MERL_VSP_COMPENSATION_C0152
    258   Bool    getUseVSPCompensation( UInt tLayer ){  return m_abUseVSPCompensation[ tLayer ];}
    259   Void    setUseVSPCompensation( Bool bValue, UInt tLayer ){ m_abUseVSPCompensation[ tLayer ] = bValue;}
    260 #endif
    261   Bool    getUseDVPRefine( UInt tLayer ){  return m_abUseDVPRefine[ tLayer ];}
    262   Void    setUseDVPRefine( Bool bValue, UInt tLayer ){ m_abUseDVPRefine[ tLayer ] = bValue;}
     546  Void    setMaxDecPicBuffering(UInt v, UInt tLayer)            { m_uiMaxDecPicBuffering[tLayer] = v;    }
     547  UInt    getMaxDecPicBuffering(UInt tLayer)                    { return m_uiMaxDecPicBuffering[tLayer]; }
     548 
     549  Void    setMaxLatencyIncrease(UInt v, UInt tLayer)            { m_uiMaxLatencyIncrease[tLayer] = v;    }
     550  UInt    getMaxLatencyIncrease(UInt tLayer)                    { return m_uiMaxLatencyIncrease[tLayer]; }
     551
     552  UInt    getNumHrdParameters()                                 { return m_numHrdParameters; }
     553  Void    setNumHrdParameters(UInt v)                           { m_numHrdParameters = v;    }
     554
     555#if H_MV
     556  UInt    getVpsMaxLayerId()                                    { return m_maxLayerId; }
     557  Void    setVpsMaxLayerId(UInt v)                              { m_maxLayerId = v;    }
     558
     559  UInt    getVpsNumLayerSetsMinus1()                            { return m_vpsNumLayerSetsMinus1; }
     560  Void    setVpsNumLayerSetsMinus1(UInt v)                      { m_vpsNumLayerSetsMinus1 = v;    }
     561#else
     562  UInt    getMaxNuhReservedZeroLayerId()                        { return m_maxNuhReservedZeroLayerId; }
     563  Void    setMaxNuhReservedZeroLayerId(UInt v)                  { m_maxNuhReservedZeroLayerId = v;    }
     564
     565  UInt    getMaxOpSets()                                        { return m_numOpSets; }
     566  Void    setMaxOpSets(UInt v)                                  { m_numOpSets = v;    }
     567#endif
     568  Bool    getLayerIdIncludedFlag(UInt opsIdx, UInt id)          { return m_layerIdIncludedFlag[opsIdx][id]; }
     569  Void    setLayerIdIncludedFlag(Bool v, UInt opsIdx, UInt id)  { m_layerIdIncludedFlag[opsIdx][id] = v;    }
     570
     571#if H_MV
     572  TComPTL* getPTL( Int layerSet = 0 ) { return &m_pcPTL[layerSet]; }
     573#else
     574  TComPTL* getPTL() { return &m_pcPTL; }
     575#endif
     576  TimingInfo* getTimingInfo() { return &m_timingInfo; }
     577#if H_MV
     578  Void    setAvcBaseLayerFlag( Bool val )                                  { m_avcBaseLayerFlag = val;  }
     579  Bool    getAvcBaseLayerFlag()                                            { return m_avcBaseLayerFlag; }
     580
     581  Void    setSplittingFlag( Bool val )                                     { m_splittingFlag = val;  }
     582  Bool    getSplittingFlag()                                               { return m_splittingFlag; }
     583
     584  Void    setScalabilityMask( UInt val );
     585
     586  Void    setScalabilityMask( Int scalType, Bool val )              { m_scalabilityMask[scalType] = val;  }
     587  Bool    getScalabilityMask( Int scalType )                        { return m_scalabilityMask[scalType]; }
     588
     589  Int     getNumScalabilityTypes( );
     590
     591  Void    setDimensionIdLen( Int sIdx, Int val )                           { m_dimensionIdLen[sIdx] = val;  }
     592  Int     getDimensionIdLen( Int sIdx )                                    { assert( m_dimensionIdLen[sIdx] > 0) ; return m_dimensionIdLen[sIdx]; } 
     593
     594  Void    setVpsNuhLayerIdPresentFlag( Bool val )                          { m_vpsNuhLayerIdPresentFlag = val; }
     595  Bool    getVpsNuhLayerIdPresentFlag()                                    { return m_vpsNuhLayerIdPresentFlag; }
     596
     597  Void    setLayerIdInNuh( Int layerIdInVps, Int val )                     { m_layerIdInNuh[layerIdInVps] = val;  }
     598  Int     getLayerIdInNuh( Int layerIdInVps )                              { assert( m_layerIdInNuh[layerIdInVps] >= 0 ); return m_layerIdInNuh[layerIdInVps]; }
     599
     600  Bool    nuhLayerIdIncluded( Int layerIdinNuh )                           { return ( m_layerIdInVps[ layerIdinNuh ] > 0 );  }
     601
     602  Void    setDimensionId( Int layerIdInVps, Int scalIdx, Int val )         { m_dimensionId[layerIdInVps][scalIdx] = val;  }
     603  Int     getDimensionId( Int layerIdInVps, Int scalIdx )                  { return m_dimensionId[layerIdInVps][scalIdx]; }
     604
     605  Void    setDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Bool val ) { m_directDependencyFlag[depLayeridInVps][refLayeridInVps] = val;  }
     606  Bool    getDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps )           { return m_directDependencyFlag[depLayeridInVps][refLayeridInVps]; }
     607
     608  Void    setMaxTidIlRefPicPlus1( Int layerIdInVps, Int val )              { m_maxTidIlRefPicPlus1[ layerIdInVps ] = val;  }
     609  Int     getMaxTidIlRefPicPlus1( Int layerIdInVps )                       { return m_maxTidIlRefPicPlus1[ layerIdInVps ]; }
     610 
     611  Void    setVpsNumberLayerSetsMinus1( Int val )                           { m_vpsNumberLayerSetsMinus1 = val;  }
     612  Int     getVpsNumberLayerSetsMinus1( )                                   { return m_vpsNumberLayerSetsMinus1; }
     613 
     614  Void    setVpsNumProfileTierLevelMinus1( Int val )                       { m_vpsNumProfileTierLevelMinus1 = val;  }
     615  Int     getVpsNumProfileTierLevelMinus1( )                               { return m_vpsNumProfileTierLevelMinus1; }
     616 
     617  Void    setVpsProfilePresentFlag( Int idx, Bool val )                    { m_vpsProfilePresentFlag[idx] = val;  }
     618  Bool    getVpsProfilePresentFlag( Int idx )                              { return m_vpsProfilePresentFlag[idx]; }
     619
     620  Void    setProfileRefMinus1( Int profileTierLevelIdx, Int val )          { m_profileRefMinus1[ profileTierLevelIdx ] = val;  }
     621  Int     getProfileRefMinus1( Int profileTierLevelIdx )                   { return m_profileRefMinus1[ profileTierLevelIdx ]; }
     622
     623  Void    setMoreOutputLayerSetsThanDefaultFlag( Bool flag )               { m_moreOutputLayerSetsThanDefaultFlag = flag; }
     624  Bool    getMoreOutputLayerSetsThanDefaultFlag()                          { return m_moreOutputLayerSetsThanDefaultFlag; }
     625 
     626  Void    setNumAddOutputLayerSetsMinus1( Int val )                        { m_numAddOutputLayerSetsMinus1 = val; }
     627  Int     getNumAddOutputLayerSetsMinus1( )                                { return m_numAddOutputLayerSetsMinus1; }
     628 
     629  Void    setDefaultOneTargetOutputLayerFlag( Bool flag )                  { m_defaultOneTargetOutputLayerFlag = flag; }
     630  Bool    getDefaultOneTargetOutputLayerFlag( )                            { return m_defaultOneTargetOutputLayerFlag; }
     631 
     632  Void    setOutputLayerSetIdxMinus1( Int outLayerSetIdx, Int val )        { m_outputLayerSetIdxMinus1[ outLayerSetIdx ]  = val; }
     633  Int     getOutputLayerSetIdxMinus1( Int outLayerSetIdx )                 { return m_outputLayerSetIdxMinus1[ outLayerSetIdx ]; }
     634
     635  Void    setOutputLayerFlag( Int outLayerSetIdx, Int i, Bool flag )       { m_outputLayerFlag[ outLayerSetIdx ][ i ] = flag; }
     636  Bool    getOutputLayerFlag( Int outLayerSetIdx, Int i )                  { return m_outputLayerFlag[ outLayerSetIdx ][ i ]; }
     637
     638  Void    setProfileLevelTierIdx( Int outLayerSetIdx, Int val )            { m_profileLevelTierIdx[ outLayerSetIdx  = val ]; }
     639  Int     getProfileLevelTierIdx( Int outLayerSetIdx )                     { return m_profileLevelTierIdx[ outLayerSetIdx ]; }
     640
     641  Void    setMaxOneActiveRefLayerFlag( Bool flag)                          { m_maxOneActiveRefLayerFlag = flag; }
     642  Bool    getMaxOneActiveRefLayerFlag( )                                   { return m_maxOneActiveRefLayerFlag; }
     643
     644  Void    setDirectDepTypeLenMinus2( Int val)                              { m_directDepTypeLenMinus2 = val; }
     645  Int     getDirectDepTypeLenMinus2( )                                     { return m_directDepTypeLenMinus2; }
     646
     647  Void    setDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps, Int val) { m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ] = val; }
     648  Int     getDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps)   { return m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ]; }
     649
     650
     651  // VPS EXTENSION SEMANTICS VARIABLES
     652  Void    setLayerIdInVps( Int layerIdInNuh, Int val )                     { m_layerIdInVps[layerIdInNuh] = val;  }
     653  Int     getLayerIdInVps( Int layerIdInNuh )                              { assert( m_layerIdInVps[layerIdInNuh] >= 0 ); return m_layerIdInVps[layerIdInNuh]; }
     654
     655  Int     getScalabilityId ( Int layerIdInVps, ScalabilityType scalType );
     656  Int     getViewId  ( Int layerIdInVps )                                  { return getScalabilityId( layerIdInVps, VIEW_ID  ); }
     657
     658  Void    setRefLayers();
     659
     660  Int     getNumDirectRefLayers( Int layerIdInVps )          { return m_numDirectRefLayers[ layerIdInVps ];  };                               
     661  Int     getRefLayerId        ( Int layerIdInVps, Int idx );;
     662 
     663  Int     getNumSamplePredRefLayers( Int layerIdInVps )          { return m_numSamplePredRefLayers[layerIdInVps]; }
     664  Bool    getSamplePredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_samplePredEnabledFlag [layerIdInVps][idx]; }
     665  Int     getSamplePredRefLayerId  ( Int layerIdInVps, Int idx ) { return m_samplePredRefLayerId  [layerIdInVps][idx]; }
     666
     667  Int     getNumMotionPredRefLayers( Int layerIdInVps )          { return m_numMotionPredRefLayers[layerIdInVps]; }
     668  Bool    getMotionPredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_motionPredEnabledFlag [layerIdInVps][idx]; }
     669  Int     getMotionPredRefLayerId  ( Int layerIdInVps, Int idx ) { return m_motionPredRefLayerId  [layerIdInVps][idx]; }
     670
     671  Bool    checkVPSExtensionSyntax();
     672  Int     scalTypeToScalIdx   ( ScalabilityType scalType );
     673
     674  Int     getProfileLevelTierIdxLen() { return xCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
     675  Int     getNumLayersInIdList              ( Int lsIdx );;
     676
     677  // inference
     678  Int     inferDimensionId     ( Int i, Int j );
     679  Int     inferLastDimsionIdLenMinus1();
     680
     681#if H_3D 
     682  Void    initViewIndex();
     683  Int     getViewIndex    ( Int layerIdInVps )                             { return m_viewIndex[ layerIdInVps ]; }   
     684  Int     getDepthId      ( Int layerIdInVps )                             { return getScalabilityId( layerIdInVps, DEPTH_ID ); }
     685  Int     getLayerIdInNuh( Int viewIndex, Bool depthFlag );   
     686
     687#if H_3D_ARP
     688  UInt    getUseAdvRP  ( Int layerIdInVps )                                { return m_uiUseAdvResPred[layerIdInVps];    }
     689  UInt    getARPStepNum( Int layerIdInVps )                                { return m_uiARPStepNum[layerIdInVps];       }
     690  Void    setUseAdvRP  ( Int layerIdInVps, UInt val )                      { m_uiUseAdvResPred[layerIdInVps] = val;     }
     691  Void    setARPStepNum( Int layerIdInVps, UInt val )                      { m_uiARPStepNum[layerIdInVps]    = val;     }
     692#endif
     693#if H_3D_IV_MERGE
     694  Void    setIvMvPredFlag     ( Int layerIdInVps, Bool val )  { m_ivMvPredFlag[ layerIdInVps ] = val; }
     695  Bool    getIvMvPredFlag     ( Int layerIdInVps )            { return m_ivMvPredFlag[ layerIdInVps ]; };
     696#endif
     697#if H_3D_VSP
     698  Void    setViewSynthesisPredFlag  ( Int layerIdInVps, Bool val )  { m_viewSynthesisPredFlag[ layerIdInVps ] = val; }
     699  Bool    getViewSynthesisPredFlag  ( Int layerIdInVps )            { return m_viewSynthesisPredFlag[ layerIdInVps ]; };
     700#endif
     701#if H_3D_NBDV_REF
     702  Void    setDepthRefinementFlag  ( Int layerIdInVps, Bool val )  { m_depthRefinementFlag[ layerIdInVps ] = val; }
     703  Bool    getDepthRefinementFlag  ( Int layerIdInVps )            { return m_depthRefinementFlag[ layerIdInVps ]; };
     704#endif
     705  Void    setVpsDepthModesFlag( Int layerIdInVps, Bool val )               { m_vpsDepthModesFlag[ layerIdInVps ] = val; }
     706  Bool    getVpsDepthModesFlag( Int layerIdInVps )                         { return m_vpsDepthModesFlag[ layerIdInVps ]; }
     707#if H_3D_DIM_DLT
     708  Bool    getUseDLTFlag      ( Int layerIdInVps )                         { return m_bUseDLTFlag[ layerIdInVps ]; }
     709  Void    setUseDLTFlag      ( Int layerIdInVps, Bool b ) { m_bUseDLTFlag[ layerIdInVps ]  = b;          }
     710 
     711  Int     getBitsPerDepthValue( Int layerIdInVps )        { return getUseDLTFlag(layerIdInVps)?m_iBitsPerDepthValue[layerIdInVps]:g_bitDepthY; }
     712  Int     getNumDepthValues( Int layerIdInVps )           { return getUseDLTFlag(layerIdInVps)?m_iNumDepthmapValues[layerIdInVps]:((1 << g_bitDepthY)-1); }
     713  Int     depthValue2idx( Int layerIdInVps, Pel value )   { return getUseDLTFlag(layerIdInVps)?m_iDepthValue2Idx[layerIdInVps][value]:value; }
     714  Pel     idx2DepthValue( Int layerIdInVps, UInt uiIdx )  { return getUseDLTFlag(layerIdInVps)?m_iIdx2DepthValue[layerIdInVps][uiIdx]:uiIdx; }
     715  Void    setDepthLUTs( Int layerIdInVps, Int* idx2DepthValue = NULL, Int iNumDepthValues = 0 );
     716#endif
     717
     718#if H_3D_TMVP
     719  Bool    getIvMvScalingFlag   (  )                       { return m_ivMvScalingFlag; }
     720  Void    setIvMvScalingFlag   ( Bool b )                 { m_ivMvScalingFlag = b;    } 
     721#endif
     722#if LGE_INTER_SDC_E0156
     723  Bool    getInterSDCFlag      ( Int layerIdInVps )           { return m_bInterSDCFlag[layerIdInVps]; }
     724  Void    setInterSDCFlag      ( Int layerIdInVps, Bool bval ){ m_bInterSDCFlag[layerIdInVps] = bval; }
     725#endif
     726
     727#endif 
    263728#endif
    264729};
    265730
    266 #endif
     731class Window
     732{
     733private:
     734  Bool          m_enabledFlag;
     735  Int           m_winLeftOffset;
     736  Int           m_winRightOffset;
     737  Int           m_winTopOffset;
     738  Int           m_winBottomOffset;
     739public:
     740  Window()
     741  : m_enabledFlag (false)
     742  , m_winLeftOffset     (0)
     743  , m_winRightOffset    (0)
     744  , m_winTopOffset      (0)
     745  , m_winBottomOffset   (0)
     746  { }
     747
     748  Bool          getWindowEnabledFlag() const      { return m_enabledFlag; }
     749  Void          resetWindow()                     { m_enabledFlag = false; m_winLeftOffset = m_winRightOffset = m_winTopOffset = m_winBottomOffset = 0; }
     750  Int           getWindowLeftOffset() const       { return m_enabledFlag ? m_winLeftOffset : 0; }
     751  Void          setWindowLeftOffset(Int val)      { m_winLeftOffset = val; m_enabledFlag = true; }
     752  Int           getWindowRightOffset() const      { return m_enabledFlag ? m_winRightOffset : 0; }
     753  Void          setWindowRightOffset(Int val)     { m_winRightOffset = val; m_enabledFlag = true; }
     754  Int           getWindowTopOffset() const        { return m_enabledFlag ? m_winTopOffset : 0; }
     755  Void          setWindowTopOffset(Int val)       { m_winTopOffset = val; m_enabledFlag = true; }
     756  Int           getWindowBottomOffset() const     { return m_enabledFlag ? m_winBottomOffset: 0; }
     757  Void          setWindowBottomOffset(Int val)    { m_winBottomOffset = val; m_enabledFlag = true; }
     758
     759  Void          setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
     760  {
     761    m_enabledFlag       = true;
     762    m_winLeftOffset     = offsetLeft;
     763    m_winRightOffset    = offsetLRight;
     764    m_winTopOffset      = offsetLTop;
     765    m_winBottomOffset   = offsetLBottom;
     766  }
     767};
     768
     769
     770class TComVUI
     771{
     772private:
     773  Bool m_aspectRatioInfoPresentFlag;
     774  Int  m_aspectRatioIdc;
     775  Int  m_sarWidth;
     776  Int  m_sarHeight;
     777  Bool m_overscanInfoPresentFlag;
     778  Bool m_overscanAppropriateFlag;
     779  Bool m_videoSignalTypePresentFlag;
     780  Int  m_videoFormat;
     781  Bool m_videoFullRangeFlag;
     782  Bool m_colourDescriptionPresentFlag;
     783  Int  m_colourPrimaries;
     784  Int  m_transferCharacteristics;
     785  Int  m_matrixCoefficients;
     786  Bool m_chromaLocInfoPresentFlag;
     787  Int  m_chromaSampleLocTypeTopField;
     788  Int  m_chromaSampleLocTypeBottomField;
     789  Bool m_neutralChromaIndicationFlag;
     790  Bool m_fieldSeqFlag;
     791
     792  Window m_defaultDisplayWindow;
     793  Bool m_frameFieldInfoPresentFlag;
     794  Bool m_hrdParametersPresentFlag;
     795  Bool m_bitstreamRestrictionFlag;
     796  Bool m_tilesFixedStructureFlag;
     797  Bool m_motionVectorsOverPicBoundariesFlag;
     798  Bool m_restrictedRefPicListsFlag;
     799  Int  m_minSpatialSegmentationIdc;
     800  Int  m_maxBytesPerPicDenom;
     801  Int  m_maxBitsPerMinCuDenom;
     802  Int  m_log2MaxMvLengthHorizontal;
     803  Int  m_log2MaxMvLengthVertical;
     804  TComHRD m_hrdParameters;
     805  TimingInfo m_timingInfo;
     806#if H_MV
     807  Bool m_tileBoundariesAlignedFlag;
     808#endif
     809
     810public:
     811  TComVUI()
     812    :m_aspectRatioInfoPresentFlag(false)
     813    ,m_aspectRatioIdc(0)
     814    ,m_sarWidth(0)
     815    ,m_sarHeight(0)
     816    ,m_overscanInfoPresentFlag(false)
     817    ,m_overscanAppropriateFlag(false)
     818    ,m_videoSignalTypePresentFlag(false)
     819    ,m_videoFormat(5)
     820    ,m_videoFullRangeFlag(false)
     821    ,m_colourDescriptionPresentFlag(false)
     822    ,m_colourPrimaries(2)
     823    ,m_transferCharacteristics(2)
     824    ,m_matrixCoefficients(2)
     825    ,m_chromaLocInfoPresentFlag(false)
     826    ,m_chromaSampleLocTypeTopField(0)
     827    ,m_chromaSampleLocTypeBottomField(0)
     828    ,m_neutralChromaIndicationFlag(false)
     829    ,m_fieldSeqFlag(false)
     830    ,m_frameFieldInfoPresentFlag(false)
     831    ,m_hrdParametersPresentFlag(false)
     832    ,m_bitstreamRestrictionFlag(false)
     833    ,m_tilesFixedStructureFlag(false)
     834    ,m_motionVectorsOverPicBoundariesFlag(true)
     835    ,m_restrictedRefPicListsFlag(1)
     836    ,m_minSpatialSegmentationIdc(0)
     837    ,m_maxBytesPerPicDenom(2)
     838    ,m_maxBitsPerMinCuDenom(1)
     839    ,m_log2MaxMvLengthHorizontal(15)
     840    ,m_log2MaxMvLengthVertical(15)
     841#if H_MV
     842    ,m_tileBoundariesAlignedFlag(true)
     843#endif
     844  {}
     845
     846  virtual ~TComVUI() {}
     847
     848  Bool getAspectRatioInfoPresentFlag() { return m_aspectRatioInfoPresentFlag; }
     849  Void setAspectRatioInfoPresentFlag(Bool i) { m_aspectRatioInfoPresentFlag = i; }
     850
     851  Int getAspectRatioIdc() { return m_aspectRatioIdc; }
     852  Void setAspectRatioIdc(Int i) { m_aspectRatioIdc = i; }
     853
     854  Int getSarWidth() { return m_sarWidth; }
     855  Void setSarWidth(Int i) { m_sarWidth = i; }
     856
     857  Int getSarHeight() { return m_sarHeight; }
     858  Void setSarHeight(Int i) { m_sarHeight = i; }
     859
     860  Bool getOverscanInfoPresentFlag() { return m_overscanInfoPresentFlag; }
     861  Void setOverscanInfoPresentFlag(Bool i) { m_overscanInfoPresentFlag = i; }
     862
     863  Bool getOverscanAppropriateFlag() { return m_overscanAppropriateFlag; }
     864  Void setOverscanAppropriateFlag(Bool i) { m_overscanAppropriateFlag = i; }
     865
     866  Bool getVideoSignalTypePresentFlag() { return m_videoSignalTypePresentFlag; }
     867  Void setVideoSignalTypePresentFlag(Bool i) { m_videoSignalTypePresentFlag = i; }
     868
     869  Int getVideoFormat() { return m_videoFormat; }
     870  Void setVideoFormat(Int i) { m_videoFormat = i; }
     871
     872  Bool getVideoFullRangeFlag() { return m_videoFullRangeFlag; }
     873  Void setVideoFullRangeFlag(Bool i) { m_videoFullRangeFlag = i; }
     874
     875  Bool getColourDescriptionPresentFlag() { return m_colourDescriptionPresentFlag; }
     876  Void setColourDescriptionPresentFlag(Bool i) { m_colourDescriptionPresentFlag = i; }
     877
     878  Int getColourPrimaries() { return m_colourPrimaries; }
     879  Void setColourPrimaries(Int i) { m_colourPrimaries = i; }
     880
     881  Int getTransferCharacteristics() { return m_transferCharacteristics; }
     882  Void setTransferCharacteristics(Int i) { m_transferCharacteristics = i; }
     883
     884  Int getMatrixCoefficients() { return m_matrixCoefficients; }
     885  Void setMatrixCoefficients(Int i) { m_matrixCoefficients = i; }
     886
     887  Bool getChromaLocInfoPresentFlag() { return m_chromaLocInfoPresentFlag; }
     888  Void setChromaLocInfoPresentFlag(Bool i) { m_chromaLocInfoPresentFlag = i; }
     889
     890  Int getChromaSampleLocTypeTopField() { return m_chromaSampleLocTypeTopField; }
     891  Void setChromaSampleLocTypeTopField(Int i) { m_chromaSampleLocTypeTopField = i; }
     892
     893  Int getChromaSampleLocTypeBottomField() { return m_chromaSampleLocTypeBottomField; }
     894  Void setChromaSampleLocTypeBottomField(Int i) { m_chromaSampleLocTypeBottomField = i; }
     895
     896  Bool getNeutralChromaIndicationFlag() { return m_neutralChromaIndicationFlag; }
     897  Void setNeutralChromaIndicationFlag(Bool i) { m_neutralChromaIndicationFlag = i; }
     898
     899  Bool getFieldSeqFlag() { return m_fieldSeqFlag; }
     900  Void setFieldSeqFlag(Bool i) { m_fieldSeqFlag = i; }
     901
     902  Bool getFrameFieldInfoPresentFlag() { return m_frameFieldInfoPresentFlag; }
     903  Void setFrameFieldInfoPresentFlag(Bool i) { m_frameFieldInfoPresentFlag = i; }
     904
     905  Window& getDefaultDisplayWindow()                              { return m_defaultDisplayWindow;                }
     906  Void    setDefaultDisplayWindow(Window& defaultDisplayWindow ) { m_defaultDisplayWindow = defaultDisplayWindow; }
     907
     908  Bool getHrdParametersPresentFlag() { return m_hrdParametersPresentFlag; }
     909  Void setHrdParametersPresentFlag(Bool i) { m_hrdParametersPresentFlag = i; }
     910
     911  Bool getBitstreamRestrictionFlag() { return m_bitstreamRestrictionFlag; }
     912  Void setBitstreamRestrictionFlag(Bool i) { m_bitstreamRestrictionFlag = i; }
     913
     914  Bool getTilesFixedStructureFlag() { return m_tilesFixedStructureFlag; }
     915  Void setTilesFixedStructureFlag(Bool i) { m_tilesFixedStructureFlag = i; }
     916
     917  Bool getMotionVectorsOverPicBoundariesFlag() { return m_motionVectorsOverPicBoundariesFlag; }
     918  Void setMotionVectorsOverPicBoundariesFlag(Bool i) { m_motionVectorsOverPicBoundariesFlag = i; }
     919
     920  Bool getRestrictedRefPicListsFlag() { return m_restrictedRefPicListsFlag; }
     921  Void setRestrictedRefPicListsFlag(Bool b) { m_restrictedRefPicListsFlag = b; }
     922
     923  Int getMinSpatialSegmentationIdc() { return m_minSpatialSegmentationIdc; }
     924  Void setMinSpatialSegmentationIdc(Int i) { m_minSpatialSegmentationIdc = i; }
     925  Int getMaxBytesPerPicDenom() { return m_maxBytesPerPicDenom; }
     926  Void setMaxBytesPerPicDenom(Int i) { m_maxBytesPerPicDenom = i; }
     927
     928  Int getMaxBitsPerMinCuDenom() { return m_maxBitsPerMinCuDenom; }
     929  Void setMaxBitsPerMinCuDenom(Int i) { m_maxBitsPerMinCuDenom = i; }
     930
     931  Int getLog2MaxMvLengthHorizontal() { return m_log2MaxMvLengthHorizontal; }
     932  Void setLog2MaxMvLengthHorizontal(Int i) { m_log2MaxMvLengthHorizontal = i; }
     933
     934  Int getLog2MaxMvLengthVertical() { return m_log2MaxMvLengthVertical; }
     935  Void setLog2MaxMvLengthVertical(Int i) { m_log2MaxMvLengthVertical = i; }
     936
     937  TComHRD* getHrdParameters                 ()             { return &m_hrdParameters; }
     938  TimingInfo* getTimingInfo() { return &m_timingInfo; }
     939#if H_MV
     940Bool getTileBoundariesAlignedFlag(  ) { return m_tileBoundariesAlignedFlag; }
     941  Void setTileBoundariesAlignedFlag( Bool flag ) { m_tileBoundariesAlignedFlag = flag; }
     942#endif
     943};
    267944
    268945/// SPS class
     
    270947{
    271948private:
    272 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
    273   Int          m_VPSId;
    274 #endif
    275949  Int         m_SPSId;
    276   Int         m_ProfileIdc;
    277   Int         m_LevelIdc;
     950  Int         m_VPSId;
    278951  Int         m_chromaFormatIdc;
    279952
    280953  UInt        m_uiMaxTLayers;           // maximum number of temporal layers
    281 
    282   UInt        m_uiViewId;
    283   Int         m_iViewOrderIdx;
    284   Bool        m_bDepth;
    285   UInt        m_uiCamParPrecision;
    286   Bool        m_bCamParInSliceHeader;
    287   Int         m_aaiCodedScale [2][MAX_VIEW_NUM];
    288   Int         m_aaiCodedOffset[2][MAX_VIEW_NUM];
    289954
    290955  // Structure
    291956  UInt        m_picWidthInLumaSamples;
    292957  UInt        m_picHeightInLumaSamples;
    293   Bool        m_picCroppingFlag;
    294   Int         m_picCropLeftOffset;
    295   Int         m_picCropRightOffset;
    296   Int         m_picCropTopOffset;
    297   Int         m_picCropBottomOffset;
     958 
     959  Int         m_log2MinCodingBlockSize;
     960  Int         m_log2DiffMaxMinCodingBlockSize;
    298961  UInt        m_uiMaxCUWidth;
    299962  UInt        m_uiMaxCUHeight;
    300963  UInt        m_uiMaxCUDepth;
    301   UInt        m_uiMinTrDepth;
    302   UInt        m_uiMaxTrDepth;
    303   TComRPSList* m_RPSList;
     964
     965  Window      m_conformanceWindow;
     966
     967  TComRPSList m_RPSList;
    304968  Bool        m_bLongTermRefsPresent;
     969  Bool        m_TMVPFlagsPresent;
    305970  Int         m_numReorderPics[MAX_TLAYER];
    306971 
    307   Int         m_iNumberOfUsableInterViewRefs;
    308   Int         m_aiUsableInterViewRefs[MAX_VIEW_NUM];
    309 
    310972  // Tool list
    311973  UInt        m_uiQuadtreeTULog2MaxSize;
     
    316978  UInt        m_pcmLog2MaxSize;
    317979  UInt        m_uiPCMLog2MinSize;
    318   Bool        m_bDisInter4x4;
    319980  Bool        m_useAMP;
    320   Bool        m_bUseALF;
    321   Bool        m_bALFCoefInSlice;
    322   Bool        m_bUseLMChroma; // JL:
    323 
    324   Bool        m_bUseLComb;
    325   Bool        m_bLCMod;
    326   Bool        m_useNSQT;
    327  
    328   Bool        m_restrictedRefPicListsFlag;
    329   Bool        m_listsModificationPresentFlag;
    330 
     981
     982#if H_3D_QTLPC
     983  Bool        m_bUseQTL;
     984  Bool        m_bUsePC;
     985#endif
    331986  // Parameter
    332   AMVP_MODE   m_aeAMVPMode[MAX_CU_DEPTH];
    333   UInt        m_uiBitDepth;
    334   UInt        m_uiBitIncrement;
     987  Int         m_bitDepthY;
     988  Int         m_bitDepthC;
    335989  Int         m_qpBDOffsetY;
    336990  Int         m_qpBDOffsetC;
    337991
    338 #if LOSSLESS_CODING
    339992  Bool        m_useLossless;
    340 #endif
    341993
    342994  UInt        m_uiPCMBitDepthLuma;
     
    345997
    346998  UInt        m_uiBitsForPOC;
     999  UInt        m_numLongTermRefPicSPS;
     1000  UInt        m_ltRefPicPocLsbSps[33];
     1001  Bool        m_usedByCurrPicLtSPSFlag[33];
    3471002  // Max physical transform size
    3481003  UInt        m_uiMaxTrSize;
    3491004 
    3501005  Int m_iAMPAcc[MAX_CU_DEPTH];
    351 
    352   Bool        m_bLFCrossSliceBoundaryFlag;
    3531006  Bool        m_bUseSAO;
    354 #if HHI_MPI
    355   Bool        m_bUseMVI;
    356 #endif
    357  
    358 #if RWTH_SDC_DLT_B0036
    359   Bool        m_bUseDLT;
    360  
    361   UInt        m_uiBitsPerDepthValue;
    362   UInt        m_uiNumDepthmapValues;
    363   UInt*       m_uiDepthValue2Idx;
    364   UInt*       m_uiIdx2DepthValue;
    365 #endif
    366 
    367   Bool     m_bLFCrossTileBoundaryFlag;
    368   Int      m_iUniformSpacingIdr;
    369   Int      m_iTileBoundaryIndependenceIdr;
    370   Int      m_iNumColumnsMinus1;
    371   UInt*    m_puiColumnWidth;
    372   Int      m_iNumRowsMinus1;
    373   UInt*    m_puiRowHeight;
    374  
     1007
    3751008  Bool        m_bTemporalIdNestingFlag; // temporal_id_nesting_flag
    3761009
    3771010  Bool        m_scalingListEnabledFlag;
     1011  Bool        m_scalingListPresentFlag;
     1012  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
    3781013  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER];
    379   UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
     1014  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];  // Really max latency increase plus 1 (value 0 expresses no limit)
    3801015
    3811016  Bool        m_useDF;
    382 
    383   UInt        m_tilesOrEntropyCodingSyncIdc;
    384   Int         m_numSubstreams;
    385 
    386 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    387   Bool  m_bUseDMM;
    388 #endif
    389 
    390 #if HHI_DMM_PRED_TEX && FLEX_CODING_ORDER_M23723
    391   Bool  m_bUseDMM34;
    392 #endif
    393 
    394 #if H3D_QTL
    395   Bool m_bUseQTLPC;
    396 #endif
    397 
    398 #if DEPTH_MAP_GENERATION
    399   UInt  m_uiPredDepthMapGeneration;
    400   UInt  m_uiPdmPrecision;
    401   Int   m_aiPdmScaleNomDelta[MAX_VIEW_NUM];
    402   Int   m_aiPdmOffset       [MAX_VIEW_NUM];
    403 #endif
    404 
    405 #if H3D_IVMP
    406   UInt  m_uiMultiviewMvPredMode;
    407 #endif
    408 #if H3D_IVRP
    409 #if QC_ARP_D0177
    410   UInt         m_nUseAdvResPred;
    411   UInt         m_nARPStepNum;
    412 #else
    413   UInt  m_uiMultiviewResPredMode;
    414 #endif
    415 #endif
    416 
    417 #if DEPTH_MAP_GENERATION
    418   TComDepthMapGenerator* m_pcDepthMapGenerator;
    419 #endif
    420 #if H3D_IVRP & !QC_ARP_D0177
    421   TComResidualGenerator* m_pcResidualGenerator;
    422 #endif
    423 
    424 #if MTK_D0156
    425 #if MERL_VSP_COMPENSATION_C0152
    426   Bool      m_bUseVSPCompensation;
    427 #endif
    428   Bool      m_bUseDVPRefine;
    429 #endif
    430 
     1017  Bool        m_useStrongIntraSmoothing;
     1018
     1019  Bool        m_vuiParametersPresentFlag;
     1020  TComVUI     m_vuiParameters;
     1021
     1022  static const Int   m_winUnitX[MAX_CHROMA_FORMAT_IDC+1];
     1023  static const Int   m_winUnitY[MAX_CHROMA_FORMAT_IDC+1];
     1024  TComPTL     m_pcPTL;
     1025#if H_MV
     1026  Bool        m_interViewMvVertConstraintFlag;
     1027  Int         m_numIlpRestrictedRefLayers        ;
     1028  Int         m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS];
     1029  Bool        m_ctuBasedOffsetEnabledFlag   [MAX_NUM_LAYERS];
     1030  Int         m_minHorizontalCtuOffsetPlus1 [MAX_NUM_LAYERS];
     1031#endif
     1032#if H_3D
     1033  UInt        m_uiCamParPrecision;
     1034  Bool        m_bCamParInSliceHeader;
     1035  Int         m_aaiCodedScale [2][MAX_NUM_LAYERS];
     1036  Int         m_aaiCodedOffset[2][MAX_NUM_LAYERS];
     1037#endif
     1038#if H_MV
     1039  Int         m_layerId;
     1040#endif
    4311041public:
    4321042  TComSPS();
    4331043  virtual ~TComSPS();
    434 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
     1044
    4351045  Int  getVPSId       ()         { return m_VPSId;          }
    4361046  Void setVPSId       (Int i)    { m_VPSId = i;             }
    437 #endif
    4381047  Int  getSPSId       ()         { return m_SPSId;          }
    4391048  Void setSPSId       (Int i)    { m_SPSId = i;             }
    440   Int  getProfileIdc  ()         { return m_ProfileIdc;     }
    441   Void setProfileIdc  (Int i)    { m_ProfileIdc = i;        }
    442   Int  getLevelIdc    ()         { return m_LevelIdc;       }
    443   Void setLevelIdc    (Int i)    { m_LevelIdc = i;          }
    444 
    4451049  Int  getChromaFormatIdc ()         { return m_chromaFormatIdc;       }
    4461050  Void setChromaFormatIdc (Int i)    { m_chromaFormatIdc = i;          }
     1051
     1052  static Int getWinUnitX (Int chromaFormatIdc) { assert (chromaFormatIdc > 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_winUnitX[chromaFormatIdc];      }
     1053  static Int getWinUnitY (Int chromaFormatIdc) { assert (chromaFormatIdc > 0 && chromaFormatIdc <= MAX_CHROMA_FORMAT_IDC); return m_winUnitY[chromaFormatIdc];      }
    4471054 
    4481055  // structure
     
    4521059  UInt getPicHeightInLumaSamples      ()         { return  m_picHeightInLumaSamples;   }
    4531060
    454   Bool getPicCroppingFlag() const          { return m_picCroppingFlag; }
    455   Void setPicCroppingFlag(Bool val)        { m_picCroppingFlag = val; }
    456   Int  getPicCropLeftOffset() const        { return m_picCropLeftOffset; }
    457   Void setPicCropLeftOffset(Int val)       { m_picCropLeftOffset = val; }
    458   Int  getPicCropRightOffset() const       { return m_picCropRightOffset; }
    459   Void setPicCropRightOffset(Int val)      { m_picCropRightOffset = val; }
    460   Int  getPicCropTopOffset() const         { return m_picCropTopOffset; }
    461   Void setPicCropTopOffset(Int val)        { m_picCropTopOffset = val; }
    462   Int  getPicCropBottomOffset() const      { return m_picCropBottomOffset; }
    463   Void setPicCropBottomOffset(Int val)     { m_picCropBottomOffset = val; }
     1061  Window& getConformanceWindow()                           { return  m_conformanceWindow;             }
     1062  Void    setConformanceWindow(Window& conformanceWindow ) { m_conformanceWindow = conformanceWindow; }
     1063
     1064  UInt  getNumLongTermRefPicSPS()             { return m_numLongTermRefPicSPS; }
     1065  Void  setNumLongTermRefPicSPS(UInt val)     { m_numLongTermRefPicSPS = val; }
     1066
     1067  UInt  getLtRefPicPocLsbSps(UInt index)             { return m_ltRefPicPocLsbSps[index]; }
     1068  Void  setLtRefPicPocLsbSps(UInt index, UInt val)     { m_ltRefPicPocLsbSps[index] = val; }
     1069
     1070  Bool getUsedByCurrPicLtSPSFlag(Int i)        {return m_usedByCurrPicLtSPSFlag[i];}
     1071  Void setUsedByCurrPicLtSPSFlag(Int i, Bool x)      { m_usedByCurrPicLtSPSFlag[i] = x;}
     1072
     1073  Int  getLog2MinCodingBlockSize() const           { return m_log2MinCodingBlockSize; }
     1074  Void setLog2MinCodingBlockSize(Int val)          { m_log2MinCodingBlockSize = val; }
     1075  Int  getLog2DiffMaxMinCodingBlockSize() const    { return m_log2DiffMaxMinCodingBlockSize; }
     1076  Void setLog2DiffMaxMinCodingBlockSize(Int val)   { m_log2DiffMaxMinCodingBlockSize = val; }
    4641077
    4651078  Void setMaxCUWidth  ( UInt u ) { m_uiMaxCUWidth = u;      }
     
    4771090  Void setBitsForPOC  ( UInt u ) { m_uiBitsForPOC = u;      }
    4781091  UInt getBitsForPOC  ()         { return m_uiBitsForPOC;   }
    479   Bool getDisInter4x4()         { return m_bDisInter4x4;        }
    480   Void setDisInter4x4      ( Bool b ) { m_bDisInter4x4  = b;          }
    4811092  Bool getUseAMP() { return m_useAMP; }
    4821093  Void setUseAMP( Bool b ) { m_useAMP = b; }
    483   Void setMinTrDepth  ( UInt u ) { m_uiMinTrDepth = u;      }
    484   UInt getMinTrDepth  ()         { return  m_uiMinTrDepth;  }
    485   Void setMaxTrDepth  ( UInt u ) { m_uiMaxTrDepth = u;      }
    486   UInt getMaxTrDepth  ()         { return  m_uiMaxTrDepth;  }
    4871094  Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u;    }
    4881095  UInt getQuadtreeTULog2MaxSize()         { return m_uiQuadtreeTULog2MaxSize; }
     
    4951102  Void setNumReorderPics(Int i, UInt tlayer)              { m_numReorderPics[tlayer] = i;    }
    4961103  Int  getNumReorderPics(UInt tlayer)                     { return m_numReorderPics[tlayer]; }
    497   Void      setRPSList( TComRPSList* RPSList )   { m_RPSList = RPSList;       }
    498   TComRPSList* getRPSList()                      { return m_RPSList;          }
     1104  Void         createRPSList( Int numRPS );
     1105  TComRPSList* getRPSList()                      { return &m_RPSList;          }
    4991106  Bool      getLongTermRefsPresent()         { return m_bLongTermRefsPresent; }
    5001107  Void      setLongTermRefsPresent(Bool b)   { m_bLongTermRefsPresent=b;      }
    501 
    502   Void setNumberOfUsableInterViewRefs( Int number )      { m_iNumberOfUsableInterViewRefs = number;    }
    503   Int  getNumberOfUsableInterViewRefs()                  { return m_iNumberOfUsableInterViewRefs;      }
    504   Void setUsableInterViewRef( Int pos, Int deltaViewId ) { m_aiUsableInterViewRefs[pos] = deltaViewId; }
    505   Int  getUsableInterViewRef( Int pos )                  { return m_aiUsableInterViewRefs[pos];        }
    506 
    507  
     1108  Bool      getTMVPFlagsPresent()         { return m_TMVPFlagsPresent; }
     1109  Void      setTMVPFlagsPresent(Bool b)   { m_TMVPFlagsPresent=b;      } 
    5081110  // physical transform
    5091111  Void setMaxTrSize   ( UInt u ) { m_uiMaxTrSize = u;       }
     
    5111113 
    5121114  // Tool list
    513   Bool getUseALF      ()         { return m_bUseALF;        }
    514   Void setUseALFCoefInSlice(Bool b) {m_bALFCoefInSlice = b;}
    515   Bool getUseALFCoefInSlice()    {return m_bALFCoefInSlice;}
    516 
    517   Void setUseALF      ( Bool b ) { m_bUseALF  = b;          }
    518   Void setUseLComb    (Bool b)   { m_bUseLComb = b;         }
    519   Bool getUseLComb    ()         { return m_bUseLComb;      }
    520   Void setLCMod       (Bool b)   { m_bLCMod = b;     }
    521   Bool getLCMod       ()         { return m_bLCMod;  }
    522 
    523   Bool getUseLMChroma ()         { return m_bUseLMChroma;        }
    524   Void setUseLMChroma ( Bool b ) { m_bUseLMChroma  = b;          }
    525 
    526 #if LOSSLESS_CODING
    5271115  Bool getUseLossless ()         { return m_useLossless; }
    5281116  Void setUseLossless ( Bool b ) { m_useLossless  = b; }
    529 #endif
    530   Bool getUseNSQT() { return m_useNSQT; }
    531   Void setUseNSQT( Bool b ) { m_useNSQT = b; }
    532  
    533   Bool getRestrictedRefPicListsFlag    ()          { return m_restrictedRefPicListsFlag;   }
    534   Void setRestrictedRefPicListsFlag    ( Bool b )  { m_restrictedRefPicListsFlag = b;      }
    535   Bool getListsModificationPresentFlag ()          { return m_listsModificationPresentFlag; }
    536   Void setListsModificationPresentFlag ( Bool b )  { m_listsModificationPresentFlag = b;    }
    537 
    538   // AMVP mode (for each depth)
    539   AMVP_MODE getAMVPMode ( UInt uiDepth ) { assert(uiDepth < g_uiMaxCUDepth);  return m_aeAMVPMode[uiDepth]; }
    540   Void      setAMVPMode ( UInt uiDepth, AMVP_MODE eMode) { assert(uiDepth < g_uiMaxCUDepth);  m_aeAMVPMode[uiDepth] = eMode; }
    5411117 
    5421118  // AMP accuracy
     
    5451121
    5461122  // Bit-depth
    547   UInt      getBitDepth     ()         { return m_uiBitDepth;    }
    548   Void      setBitDepth     ( UInt u ) { m_uiBitDepth = u;        }
    549   UInt      getBitIncrement ()         { return m_uiBitIncrement; }
    550   Void      setBitIncrement ( UInt u ) { m_uiBitIncrement = u;    }
     1123  Int      getBitDepthY() { return m_bitDepthY; }
     1124  Void     setBitDepthY(Int u) { m_bitDepthY = u; }
     1125  Int      getBitDepthC() { return m_bitDepthC; }
     1126  Void     setBitDepthC(Int u) { m_bitDepthC = u; }
    5511127  Int       getQpBDOffsetY  ()             { return m_qpBDOffsetY;   }
    5521128  Void      setQpBDOffsetY  ( Int value  ) { m_qpBDOffsetY = value;  }
    5531129  Int       getQpBDOffsetC  ()             { return m_qpBDOffsetC;   }
    5541130  Void      setQpBDOffsetC  ( Int value  ) { m_qpBDOffsetC = value;  }
    555 
    556   Void      setLFCrossSliceBoundaryFlag     ( Bool   bValue  )    { m_bLFCrossSliceBoundaryFlag = bValue; }
    557   Bool      getLFCrossSliceBoundaryFlag     ()                    { return m_bLFCrossSliceBoundaryFlag;   }
    558 
    559   Void setUseDF                   ( Bool b ) { m_useDF = b; }
    560   Bool getUseDF                   ()         { return m_useDF; }
    561 
    5621131  Void setUseSAO                  (Bool bVal)  {m_bUseSAO = bVal;}
    5631132  Bool getUseSAO                  ()           {return m_bUseSAO;}
    564 
    565 #if HHI_MPI
    566   Void setUseMVI                  (Bool bVal)  {m_bUseMVI = bVal;}
    567   Bool getUseMVI                  ()           {return m_bUseMVI;}
    568 #endif
    569  
    570 #if RWTH_SDC_DLT_B0036
    571   Bool getUseDLT      ()          { return m_bUseDLT; }
    572   Void setUseDLT      ( Bool b ) { m_bUseDLT  = b;          }
    573  
    574   UInt getBitsPerDepthValue()       { return m_bUseDLT?m_uiBitsPerDepthValue:g_uiBitDepth; }
    575   UInt getNumDepthValues()          { return m_bUseDLT?m_uiNumDepthmapValues:g_uiIBDI_MAX; }
    576   UInt depthValue2idx(Pel uiValue)  { return m_bUseDLT?m_uiDepthValue2Idx[uiValue]:uiValue; }
    577   Pel  idx2DepthValue(UInt uiIdx)   { return m_bUseDLT?m_uiIdx2DepthValue[uiIdx]:uiIdx; }
    578   Void setDepthLUTs   (UInt* uidx2DepthValue = NULL, UInt uiNumDepthValues = 0);
    579 #endif
    5801133
    5811134  UInt      getMaxTLayers()                           { return m_uiMaxTLayers; }
     
    5911144  Bool      getPCMFilterDisableFlag     ()                    { return m_bPCMFilterDisableFlag;   }
    5921145
    593   Void    setLFCrossTileBoundaryFlag               ( Bool   bValue  )    { m_bLFCrossTileBoundaryFlag = bValue; }
    594   Bool    getLFCrossTileBoundaryFlag               ()                    { return m_bLFCrossTileBoundaryFlag;   }
    595   Void     setUniformSpacingIdr             ( Int i )           { m_iUniformSpacingIdr = i; }
    596   Int      getUniformSpacingIdr             ()                  { return m_iUniformSpacingIdr; }
    597   Void     setNumColumnsMinus1              ( Int i )           { m_iNumColumnsMinus1 = i; }
    598   Int      getNumColumnsMinus1              ()                  { return m_iNumColumnsMinus1; }
    599   Void     setColumnWidth ( UInt* columnWidth )
    600   {
    601     if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
    602     {
    603       m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
    604 
    605       for(Int i=0; i<m_iNumColumnsMinus1; i++)
    606       {
    607         m_puiColumnWidth[i] = columnWidth[i];
    608      }
    609     }
    610   }
    611   UInt     getColumnWidth  (UInt columnIdx) { return *( m_puiColumnWidth + columnIdx ); }
    612   Void     setNumRowsMinus1( Int i )        { m_iNumRowsMinus1 = i; }
    613   Int      getNumRowsMinus1()               { return m_iNumRowsMinus1; }
    614   Void     setRowHeight    ( UInt* rowHeight )
    615   {
    616     if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
    617     {
    618       m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
    619 
    620       for(Int i=0; i<m_iNumRowsMinus1; i++)
    621       {
    622         m_puiRowHeight[i] = rowHeight[i];
    623       }
    624     }
    625   }
    626   UInt     getRowHeight           (UInt rowIdx)    { return *( m_puiRowHeight + rowIdx ); }
    6271146  Bool getScalingListFlag       ()         { return m_scalingListEnabledFlag;     }
    6281147  Void setScalingListFlag       ( Bool b ) { m_scalingListEnabledFlag  = b;       }
     1148  Bool getScalingListPresentFlag()         { return m_scalingListPresentFlag;     }
     1149  Void setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag  = b;       }
     1150  Void setScalingList      ( TComScalingList *scalingList);
     1151  TComScalingList* getScalingList ()       { return m_scalingList; }               //!< get ScalingList class pointer in SPS
    6291152  UInt getMaxDecPicBuffering  (UInt tlayer)            { return m_uiMaxDecPicBuffering[tlayer]; }
    6301153  Void setMaxDecPicBuffering  ( UInt ui, UInt tlayer ) { m_uiMaxDecPicBuffering[tlayer] = ui;   }
    6311154  UInt getMaxLatencyIncrease  (UInt tlayer)            { return m_uiMaxLatencyIncrease[tlayer];   }
    6321155  Void setMaxLatencyIncrease  ( UInt ui , UInt tlayer) { m_uiMaxLatencyIncrease[tlayer] = ui;      }
    633   UInt getTilesOrEntropyCodingSyncIdc ()                    { return m_tilesOrEntropyCodingSyncIdc;   }
    634   Void setTilesOrEntropyCodingSyncIdc ( UInt val )          { m_tilesOrEntropyCodingSyncIdc = val;    }
    635   Int  getNumSubstreams               ()                    { return m_numSubstreams;                 }
    636   Void setNumSubstreams               ( Int numSubstreams ) { m_numSubstreams = numSubstreams;        }
    637 
    638 #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    639   Bool getUseDMM()         { return m_bUseDMM; }
    640   Void setUseDMM( Bool b ) { m_bUseDMM = b;    }
    641 #endif
    642 
    643 #if HHI_DMM_PRED_TEX && FLEX_CODING_ORDER_M23723
    644   Bool getUseDMM34()         { return m_bUseDMM34; }
    645   Void setUseDMM34( Bool b ) { m_bUseDMM34 = b;    }
    646 #endif
    647 
    648 #if H3D_QTL
    649   Void setUseQTLPC( Bool b ) { m_bUseQTLPC = b;    }
    650   Bool getUseQTLPC()         { return m_bUseQTLPC; }
    651 #endif
    652 
    653   Void initMultiviewSPS      ( UInt uiViewId, Int iViewOrderIdx = 0, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
    654 #if FCO_FIX_SPS_CHANGE
    655   Void initMultiviewSPSDepth ( UInt uiViewId, Int iViewOrderIdx, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
    656 #else
    657   Void initMultiviewSPSDepth ( UInt uiViewId, Int iViewOrderIdx );
    658 #endif
    659 
    660   UInt getViewId             ()  { return m_uiViewId; }
    661   Int  getViewOrderIdx       ()  { return m_iViewOrderIdx; }
    662   Bool isDepth               ()  { return m_bDepth; }
     1156
     1157  Void setUseStrongIntraSmoothing (Bool bVal)  {m_useStrongIntraSmoothing = bVal;}
     1158  Bool getUseStrongIntraSmoothing ()           {return m_useStrongIntraSmoothing;}
     1159
     1160  Bool getVuiParametersPresentFlag() { return m_vuiParametersPresentFlag; }
     1161  Void setVuiParametersPresentFlag(Bool b) { m_vuiParametersPresentFlag = b; }
     1162  TComVUI* getVuiParameters() { return &m_vuiParameters; }
     1163  Void setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess );
     1164
     1165  TComPTL* getPTL()     { return &m_pcPTL; }
     1166#if H_MV
     1167  Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; }
     1168  Bool getInterViewMvVertConstraintFlag()         { return m_interViewMvVertConstraintFlag;}
     1169
     1170  ////  sps_extension_vui_parameters( )
     1171  Void setNumIlpRestrictedRefLayers   ( Int val )        { m_numIlpRestrictedRefLayers         = val;}
     1172  Int  getNumIlpRestrictedRefLayers   ( )                { return m_numIlpRestrictedRefLayers        ;}
     1173 
     1174  Void setMinSpatialSegmentOffsetPlus1( Int i, Int val ) { m_minSpatialSegmentOffsetPlus1[ i ] = val;}
     1175  Int  getMinSpatialSegmentOffsetPlus1( Int i )          { return m_minSpatialSegmentOffsetPlus1[ i ];}
     1176 
     1177  Void setCtuBasedOffsetEnabledFlag   ( Int i, Bool flag ) { m_ctuBasedOffsetEnabledFlag   [ i ] = flag;}
     1178  Bool getCtuBasedOffsetEnabledFlag   ( Int i )            { return m_ctuBasedOffsetEnabledFlag   [ i ];}
     1179
     1180  Void setMinHorizontalCtuOffsetPlus1 ( Int i, Int val )   { m_minHorizontalCtuOffsetPlus1 [ i ] = val;}
     1181  Int  getMinHorizontalCtuOffsetPlus1 ( Int i )            { return m_minHorizontalCtuOffsetPlus1 [ i ];}
     1182#endif
     1183#if H_3D_QTLPC
     1184  Void setUseQTL( Bool b ) { m_bUseQTL = b;    }
     1185  Bool getUseQTL()         { return m_bUseQTL; }
     1186  Void setUsePC ( Bool b ) { m_bUsePC  = b;    }
     1187  Bool getUsePC ()         { return m_bUsePC;  }
     1188#endif
     1189#if H_3D
     1190  Void initCamParaSPS      (  UInt uiViewIndex, UInt uiCamParPrecision = 0, Bool bCamParSlice = false, Int** aaiScale = 0, Int** aaiOffset = 0 );
    6631191  UInt getCamParPrecision    ()  { return m_uiCamParPrecision; }
    6641192  Bool hasCamParInSliceHeader()  { return m_bCamParInSliceHeader; }
     
    6671195  Int* getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
    6681196  Int* getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
    669 
    670 
    671 #if DEPTH_MAP_GENERATION
    672   Void setPredDepthMapGeneration( UInt uiViewId, Bool bIsDepth, UInt uiPdmGenMode = 0, UInt uiPdmMvPredMode = 0, UInt uiPdmPrec = 0, Int** aaiPdmScaleNomDelta = 0, Int** aaiPdmOffset = 0 );
    673 #endif
    674 #if H3D_IVRP & !QC_ARP_D0177
    675   Void  setMultiviewResPredMode  ( UInt uiResPrdMode ) { m_uiMultiviewResPredMode = uiResPrdMode; }
    676 #endif
    677 
    678 #if DEPTH_MAP_GENERATION
    679   UInt getPredDepthMapGeneration()          { return m_uiPredDepthMapGeneration; }
    680   UInt getPdmPrecision          ()          { return m_uiPdmPrecision;           }
    681   Int* getPdmScaleNomDelta      ()          { return m_aiPdmScaleNomDelta;       }
    682   Int* getPdmOffset             ()          { return m_aiPdmOffset;              }
    683 #endif
    684 
    685 #if H3D_IVMP
    686   UInt  getMultiviewMvPredMode   ()          { return m_uiMultiviewMvPredMode;    }
    687 #endif
    688 #if H3D_IVRP
    689 #if QC_ARP_D0177
    690   UInt  getUseAdvRP()              { return m_nUseAdvResPred;   }
    691   Void  setUseAdvRP(UInt n)        { m_nUseAdvResPred = n;      }
    692   UInt  getARPStepNum()            { return m_nARPStepNum;      }
    693   Void  setARPStepNum(UInt n)      { m_nARPStepNum = n;         }
    694 #else
    695   UInt  getMultiviewResPredMode  ()          { return m_uiMultiviewResPredMode;   }
    696 #endif
    697 #endif
    698 
    699 #if DEPTH_MAP_GENERATION
    700   Void                    setDepthMapGenerator( TComDepthMapGenerator* pcDepthMapGenerator )  { m_pcDepthMapGenerator = pcDepthMapGenerator; }
    701   TComDepthMapGenerator*  getDepthMapGenerator()                                              { return m_pcDepthMapGenerator; }
    702 #endif
    703 #if H3D_IVRP & !QC_ARP_D0177
    704   Void                    setResidualGenerator( TComResidualGenerator* pcResidualGenerator )  { m_pcResidualGenerator = pcResidualGenerator; }
    705   TComResidualGenerator*  getResidualGenerator()                                              { return m_pcResidualGenerator; }
    706 #endif
    707 
    708 #if MTK_D0156
    709 
    710 #if MERL_VSP_COMPENSATION_C0152
    711   Bool    getUseVSPCompensation( ){  return m_bUseVSPCompensation;}
    712   Void    setUseVSPCompensation( Bool bValue ){ m_bUseVSPCompensation = bValue;}
    713 #endif
    714 
    715   Bool    getUseDVPRefine( ){  return m_bUseDVPRefine;}
    716   Void    setUseDVPRefine( Bool bValue ){ m_bUseDVPRefine = bValue;}
    717 
    718 #endif
     1197#endif
     1198#if H_MV
     1199  Int  getLayerId            ()           { return m_layerId; }
     1200  Void setLayerId            ( Int val )  { m_layerId = val; }
     1201#endif
     1202
    7191203};
    720 
    7211204
    7221205/// Reference Picture Lists class
     
    7441227  Void       setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL1[idx] = refPicSetIdx; }
    7451228  UInt       getRefPicSetIdxL1(UInt idx) { return m_RefPicSetIdxL1[idx]; }
     1229#if H_MV
     1230  // Why not an listIdx for all members, would avoid code duplication??
     1231  Void       setRefPicSetIdxL(UInt li, UInt idx, UInt refPicSetIdx) {( li==0 ? m_RefPicSetIdxL0[idx] : m_RefPicSetIdxL1[idx] ) = refPicSetIdx; }
     1232  UInt       getRefPicSetIdxL(UInt li, UInt idx ) { return ( li == 0 ) ? m_RefPicSetIdxL0[idx] : m_RefPicSetIdxL1[idx] ; }
     1233  Void       setRefPicListModificationFlagL(UInt li, Bool flag) { ( li==0  ? m_bRefPicListModificationFlagL0 : m_bRefPicListModificationFlagL1 ) = flag;  }
     1234  Bool       getRefPicListModificationFlagL(UInt li ) { return ( li== 0) ? m_bRefPicListModificationFlagL0 : m_bRefPicListModificationFlagL1; }
     1235#endif
    7461236};
    7471237
     
    7551245  Bool        m_useDQP;
    7561246  Bool        m_bConstrainedIntraPred;    // constrained_intra_pred_flag
    757  
     1247  Bool        m_bSliceChromaQpFlag;       // slicelevel_chroma_qp_flag
     1248
    7581249  // access channel
    7591250  TComSPS*    m_pcSPS;
     
    7611252  UInt        m_uiMinCuDQPSize;
    7621253
    763   Int        m_iChromaQpOffset;
    764   Int        m_iChromaQpOffset2nd;
    765 
    766 
    767 
    768   Int         m_iSliceGranularity;
     1254  Int         m_chromaCbQpOffset;
     1255  Int         m_chromaCrQpOffset;
     1256
     1257  UInt        m_numRefIdxL0DefaultActive;
     1258  UInt        m_numRefIdxL1DefaultActive;
    7691259
    7701260  Bool        m_bUseWeightPred;           // Use of Weighting Prediction (P_SLICE)
    771   UInt        m_uiBiPredIdc;              // Use of Weighting Bi-Prediction (B_SLICE)
    772 
     1261  Bool        m_useWeightedBiPred;        // Use of Weighting Bi-Prediction (B_SLICE)
    7731262  Bool        m_OutputFlagPresentFlag;   // Indicates the presence of output_flag in slice header
    7741263
    775   Int      m_iTileBehaviorControlPresentFlag;
    776   Bool     m_bLFCrossTileBoundaryFlag;
    777   Int      m_iColumnRowInfoPresent;
    778   Int      m_iUniformSpacingIdr;
     1264  Bool        m_TransquantBypassEnableFlag; // Indicates presence of cu_transquant_bypass_flag in CUs.
     1265  Bool        m_useTransformSkip;
     1266  Bool        m_dependentSliceSegmentsEnabledFlag;     //!< Indicates the presence of dependent slices
     1267  Bool        m_tilesEnabledFlag;              //!< Indicates the presence of tiles
     1268  Bool        m_entropyCodingSyncEnabledFlag;  //!< Indicates the presence of wavefronts
     1269 
     1270  Bool     m_loopFilterAcrossTilesEnabledFlag;
     1271  Int      m_uniformSpacingFlag;
    7791272  Int      m_iNumColumnsMinus1;
    7801273  UInt*    m_puiColumnWidth;
    7811274  Int      m_iNumRowsMinus1;
    7821275  UInt*    m_puiRowHeight;
    783  
    784   Int      m_iEntropyCodingMode; // !!! in PPS now, but also remains in slice header!
     1276
    7851277  Int      m_iNumSubstreams;
    7861278
    787   Bool     m_enableTMVPFlag;
    788 
    7891279  Int      m_signHideFlag;
    790   Int      m_signHidingThreshold;
    791 
    792 #if CABAC_INIT_FLAG
     1280
    7931281  Bool     m_cabacInitPresentFlag;
    7941282  UInt     m_encCABACTableIdx;           // Used to transmit table selection across slices
    795 #if FIX_POZNAN_CABAC_INIT_FLAG
    796   UInt     m_encPrevPOC;
    797 #endif
    798 #endif
    799   Bool     m_DeblockingFilterControlPresent;
     1283
     1284  Bool     m_sliceHeaderExtensionPresentFlag;
     1285  Bool     m_loopFilterAcrossSlicesEnabledFlag;
     1286  Bool     m_deblockingFilterControlPresentFlag;
     1287  Bool     m_deblockingFilterOverrideEnabledFlag;
     1288  Bool     m_picDisableDeblockingFilterFlag;
     1289  Int      m_deblockingFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
     1290  Int      m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
     1291  Bool     m_scalingListPresentFlag;
     1292  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
     1293  Bool m_listsModificationPresentFlag;
    8001294  UInt m_log2ParallelMergeLevelMinus2;
     1295  Int m_numExtraSliceHeaderBits;
     1296
    8011297public:
    8021298  TComPPS();
     
    8081304  Void      setSPSId (Int i) { m_SPSId = i; }
    8091305 
    810   Int       getSliceGranularity()        { return m_iSliceGranularity; }
    811   Void      setSliceGranularity( Int i ) { m_iSliceGranularity = i;    }
    8121306  Int       getPicInitQPMinus26 ()         { return  m_picInitQPMinus26; }
    8131307  Void      setPicInitQPMinus26 ( Int i )  { m_picInitQPMinus26 = i;     }
     
    8161310  Bool      getConstrainedIntraPred ()         { return  m_bConstrainedIntraPred; }
    8171311  Void      setConstrainedIntraPred ( Bool b ) { m_bConstrainedIntraPred = b;     }
    818 
     1312  Bool      getSliceChromaQpFlag ()         { return  m_bSliceChromaQpFlag; }
     1313  Void      setSliceChromaQpFlag ( Bool b ) { m_bSliceChromaQpFlag = b;     }
    8191314
    8201315  Void      setSPS              ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
     
    8251320  UInt      getMinCuDQPSize     ()         { return m_uiMinCuDQPSize; }
    8261321
    827   Void      setChromaQpOffset   ( Int i ) { m_iChromaQpOffset = i; }
    828   Int       getChromaQpOffset   () { return m_iChromaQpOffset;}
    829   Void      setChromaQpOffset2nd( Int i ) { m_iChromaQpOffset2nd = i; }
    830   Int       getChromaQpOffset2nd() { return m_iChromaQpOffset2nd;}
     1322  Void      setChromaCbQpOffset( Int i ) { m_chromaCbQpOffset = i;    }
     1323  Int       getChromaCbQpOffset()        { return m_chromaCbQpOffset; }
     1324  Void      setChromaCrQpOffset( Int i ) { m_chromaCrQpOffset = i;    }
     1325  Int       getChromaCrQpOffset()        { return m_chromaCrQpOffset; }
     1326
     1327  Void      setNumRefIdxL0DefaultActive(UInt ui)    { m_numRefIdxL0DefaultActive=ui;     }
     1328  UInt      getNumRefIdxL0DefaultActive()           { return m_numRefIdxL0DefaultActive; }
     1329  Void      setNumRefIdxL1DefaultActive(UInt ui)    { m_numRefIdxL1DefaultActive=ui;     }
     1330  UInt      getNumRefIdxL1DefaultActive()           { return m_numRefIdxL1DefaultActive; }
    8311331
    8321332  Bool getUseWP                     ()          { return m_bUseWeightPred;  }
    833   UInt getWPBiPredIdc               ()          { return m_uiBiPredIdc;     }
    834 
     1333  Bool getWPBiPred                  ()          { return m_useWeightedBiPred;     }
    8351334  Void setUseWP                     ( Bool b )  { m_bUseWeightPred = b;     }
    836   Void setWPBiPredIdc               ( UInt u )  { m_uiBiPredIdc = u;        }
    837 
     1335  Void setWPBiPred                  ( Bool b )  { m_useWeightedBiPred = b;  }
    8381336  Void      setOutputFlagPresentFlag( Bool b )  { m_OutputFlagPresentFlag = b;    }
    8391337  Bool      getOutputFlagPresentFlag()          { return m_OutputFlagPresentFlag; }
    840 
    841   Void    setTileBehaviorControlPresentFlag        ( Int i )             { m_iTileBehaviorControlPresentFlag = i;    }
    842   Int     getTileBehaviorControlPresentFlag        ()                    { return m_iTileBehaviorControlPresentFlag; }
    843   Void    setLFCrossTileBoundaryFlag               ( Bool   bValue  )    { m_bLFCrossTileBoundaryFlag = bValue; }
    844   Bool    getLFCrossTileBoundaryFlag               ()                    { return m_bLFCrossTileBoundaryFlag;   }
    845   Void     setColumnRowInfoPresent          ( Int i )           { m_iColumnRowInfoPresent = i; }
    846   Int      getColumnRowInfoPresent          ()                  { return m_iColumnRowInfoPresent; }
    847   Void     setUniformSpacingIdr             ( Int i )           { m_iUniformSpacingIdr = i; }
    848   Int      getUniformSpacingIdr             ()                  { return m_iUniformSpacingIdr; }
     1338  Void      setTransquantBypassEnableFlag( Bool b ) { m_TransquantBypassEnableFlag = b; }
     1339  Bool      getTransquantBypassEnableFlag()         { return m_TransquantBypassEnableFlag; }
     1340
     1341  Bool      getUseTransformSkip       ()         { return m_useTransformSkip;     }
     1342  Void      setUseTransformSkip       ( Bool b ) { m_useTransformSkip  = b;       }
     1343
     1344  Void    setLoopFilterAcrossTilesEnabledFlag  (Bool b)    { m_loopFilterAcrossTilesEnabledFlag = b; }
     1345  Bool    getLoopFilterAcrossTilesEnabledFlag  ()          { return m_loopFilterAcrossTilesEnabledFlag;   }
     1346  Bool    getDependentSliceSegmentsEnabledFlag() const     { return m_dependentSliceSegmentsEnabledFlag; }
     1347  Void    setDependentSliceSegmentsEnabledFlag(Bool val)   { m_dependentSliceSegmentsEnabledFlag = val; }
     1348  Bool    getTilesEnabledFlag() const                      { return m_tilesEnabledFlag; }
     1349  Void    setTilesEnabledFlag(Bool val)                    { m_tilesEnabledFlag = val; }
     1350  Bool    getEntropyCodingSyncEnabledFlag() const          { return m_entropyCodingSyncEnabledFlag; }
     1351  Void    setEntropyCodingSyncEnabledFlag(Bool val)        { m_entropyCodingSyncEnabledFlag = val; }
     1352  Void     setUniformSpacingFlag            ( Bool b )          { m_uniformSpacingFlag = b; }
     1353  Bool     getUniformSpacingFlag            ()                  { return m_uniformSpacingFlag; }
    8491354  Void     setNumColumnsMinus1              ( Int i )           { m_iNumColumnsMinus1 = i; }
    8501355  Int      getNumColumnsMinus1              ()                  { return m_iNumColumnsMinus1; }
    8511356  Void     setColumnWidth ( UInt* columnWidth )
    8521357  {
    853     if( m_iUniformSpacingIdr == 0 && m_iNumColumnsMinus1 > 0 )
     1358    if( m_uniformSpacingFlag == 0 && m_iNumColumnsMinus1 > 0 )
    8541359    {
    8551360      m_puiColumnWidth = new UInt[ m_iNumColumnsMinus1 ];
     
    8661371  Void     setRowHeight    ( UInt* rowHeight )
    8671372  {
    868     if( m_iUniformSpacingIdr == 0 && m_iNumRowsMinus1 > 0 )
     1373    if( m_uniformSpacingFlag == 0 && m_iNumRowsMinus1 > 0 )
    8691374    {
    8701375      m_puiRowHeight = new UInt[ m_iNumRowsMinus1 ];
     
    8771382  }
    8781383  UInt     getRowHeight           (UInt rowIdx)    { return *( m_puiRowHeight + rowIdx ); }
    879   Void     setEntropyCodingMode(Int iEntropyCodingMode)       { m_iEntropyCodingMode = iEntropyCodingMode; }
    880   Int      getEntropyCodingMode()                             { return m_iEntropyCodingMode; }
    8811384  Void     setNumSubstreams(Int iNumSubstreams)               { m_iNumSubstreams = iNumSubstreams; }
    8821385  Int      getNumSubstreams()                                 { return m_iNumSubstreams; }
    8831386
    8841387  Void      setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
    885   Void      setTSIG( Int tsig )                 { m_signHidingThreshold = tsig; }
    8861388  Int       getSignHideFlag()                    { return m_signHideFlag; }
    887   Int       getTSIG()                            { return m_signHidingThreshold; }
    888 
    889   Void     setEnableTMVPFlag( Bool b )  { m_enableTMVPFlag = b;    }
    890   Bool     getEnableTMVPFlag()          { return m_enableTMVPFlag; }
    891 
    892 #if CABAC_INIT_FLAG
     1389
    8931390  Void     setCabacInitPresentFlag( Bool flag )     { m_cabacInitPresentFlag = flag;    }
    8941391  Void     setEncCABACTableIdx( Int idx )           { m_encCABACTableIdx = idx;         }
    8951392  Bool     getCabacInitPresentFlag()                { return m_cabacInitPresentFlag;    }
    8961393  UInt     getEncCABACTableIdx()                    { return m_encCABACTableIdx;        }
    897 #if FIX_POZNAN_CABAC_INIT_FLAG
    898   Void     setEncPrevPOC(UInt uiPOC)                { m_encPrevPOC = uiPOC;             }
    899   UInt     getEncPrevPOC()                          { return m_encPrevPOC;              }
    900 #endif
    901 #endif
    902   Void setDeblockingFilterControlPresent    ( Bool bValue )       { m_DeblockingFilterControlPresent = bValue; }
    903   Bool getDeblockingFilterControlPresent    ()                    { return m_DeblockingFilterControlPresent; }
     1394  Void     setDeblockingFilterControlPresentFlag( Bool val )  { m_deblockingFilterControlPresentFlag = val; }
     1395  Bool     getDeblockingFilterControlPresentFlag()            { return m_deblockingFilterControlPresentFlag; }
     1396  Void     setDeblockingFilterOverrideEnabledFlag( Bool val ) { m_deblockingFilterOverrideEnabledFlag = val; }
     1397  Bool     getDeblockingFilterOverrideEnabledFlag()           { return m_deblockingFilterOverrideEnabledFlag; }
     1398  Void     setPicDisableDeblockingFilterFlag(Bool val)        { m_picDisableDeblockingFilterFlag = val; }       //!< set offset for deblocking filter disabled
     1399  Bool     getPicDisableDeblockingFilterFlag()                { return m_picDisableDeblockingFilterFlag; }      //!< get offset for deblocking filter disabled
     1400  Void     setDeblockingFilterBetaOffsetDiv2(Int val)         { m_deblockingFilterBetaOffsetDiv2 = val; }       //!< set beta offset for deblocking filter
     1401  Int      getDeblockingFilterBetaOffsetDiv2()                { return m_deblockingFilterBetaOffsetDiv2; }      //!< get beta offset for deblocking filter
     1402  Void     setDeblockingFilterTcOffsetDiv2(Int val)           { m_deblockingFilterTcOffsetDiv2 = val; }               //!< set tc offset for deblocking filter
     1403  Int      getDeblockingFilterTcOffsetDiv2()                  { return m_deblockingFilterTcOffsetDiv2; }              //!< get tc offset for deblocking filter
     1404  Bool     getScalingListPresentFlag()         { return m_scalingListPresentFlag;     }
     1405  Void     setScalingListPresentFlag( Bool b ) { m_scalingListPresentFlag  = b;       }
     1406  Void     setScalingList      ( TComScalingList *scalingList);
     1407  TComScalingList* getScalingList ()          { return m_scalingList; }         //!< get ScalingList class pointer in PPS
     1408  Bool getListsModificationPresentFlag ()          { return m_listsModificationPresentFlag; }
     1409  Void setListsModificationPresentFlag ( Bool b )  { m_listsModificationPresentFlag = b;    }
    9041410  UInt getLog2ParallelMergeLevelMinus2      ()                    { return m_log2ParallelMergeLevelMinus2; }
    9051411  Void setLog2ParallelMergeLevelMinus2      (UInt mrgLevel)       { m_log2ParallelMergeLevelMinus2 = mrgLevel; }
     1412  Int getNumExtraSliceHeaderBits() { return m_numExtraSliceHeaderBits; }
     1413  Void setNumExtraSliceHeaderBits(Int i) { m_numExtraSliceHeaderBits = i; }
     1414  Void      setLoopFilterAcrossSlicesEnabledFlag ( Bool   bValue  )    { m_loopFilterAcrossSlicesEnabledFlag = bValue; }
     1415  Bool      getLoopFilterAcrossSlicesEnabledFlag ()                    { return m_loopFilterAcrossSlicesEnabledFlag;   }
     1416  Bool getSliceHeaderExtensionPresentFlag   ()                    { return m_sliceHeaderExtensionPresentFlag; }
     1417  Void setSliceHeaderExtensionPresentFlag   (Bool val)            { m_sliceHeaderExtensionPresentFlag = val; }
    9061418};
    9071419
    908 /// SCALING_LIST class
    909 class TComScalingList
     1420typedef struct
    9101421{
    911 public:
    912   TComScalingList();
    913   virtual ~TComScalingList();
    914   Void     setScalingListPresentFlag    (Bool b)                               { m_scalingListPresentFlag = b;    }
    915   Bool     getScalingListPresentFlag    ()                                     { return m_scalingListPresentFlag; }
    916   Int*     getScalingListAddress          (UInt sizeId, UInt listId)           { return m_scalingListCoef[sizeId][listId]; } //!< get matrix coefficient
    917   Bool     checkPredMode                  (UInt sizeId, UInt listId);
    918   Void     setRefMatrixId                 (UInt sizeId, UInt listId, UInt u)   { m_refMatrixId[sizeId][listId] = u;    }     //!< set reference matrix ID
    919   UInt     getRefMatrixId                 (UInt sizeId, UInt listId)           { return m_refMatrixId[sizeId][listId]; }     //!< get reference matrix ID
    920   Int*     getScalingListDefaultAddress   (UInt sizeId, UInt listId);                                                        //!< get default matrix coefficient
    921   Void     processDefaultMarix            (UInt sizeId, UInt listId);
    922   Void     setScalingListDC               (UInt sizeId, UInt listId, UInt u)   { m_scalingListDC[sizeId][listId] = u; }      //!< set DC value
    923   Int      getScalingListDC               (UInt sizeId, UInt listId)           { return m_scalingListDC[sizeId][listId]; }   //!< get DC value
    924   Void     checkDcOfMatrix                ();
    925   Void     setUseDefaultScalingMatrixFlag (UInt sizeId, UInt listId, Bool b)   { m_useDefaultScalingMatrixFlag[sizeId][listId] = b;    } //!< set default matrix enabled/disabled in each matrix
    926   Bool     getUseDefaultScalingMatrixFlag (UInt sizeId, UInt listId)           { return m_useDefaultScalingMatrixFlag[sizeId][listId]; } //!< get default matrix enabled/disabled in each matrix
    927   Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
    928   Bool     xParseScalingList              (char* pchFile);
    929 
    930 private:
    931   Void     init                    ();
    932   Void     destroy                 ();
    933   Int      m_scalingListDC               [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
    934   Bool     m_useDefaultScalingMatrixFlag [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< UseDefaultScalingMatrixFlag
    935   UInt     m_refMatrixId                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
    936   Bool     m_scalingListPresentFlag;                                                //!< flag for using default matrix
    937   UInt     m_predMatrixId                [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
    938   Int      *m_scalingListCoef            [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
    939 };
    940 
    941 /// APS class
    942 class TComAPS
    943 {
    944 public:
    945   TComAPS();
    946   virtual ~TComAPS();
    947 
    948   Void      setAPSID      (Int iID)   {m_apsID = iID;            }  //!< set APS ID
    949   Int       getAPSID      ()          {return m_apsID;           }  //!< get APS ID
    950   Void      setSaoEnabled (Bool bVal) {m_bSaoEnabled = bVal;     }  //!< set SAO enabled/disabled in APS
    951   Bool      getSaoEnabled ()          {return m_bSaoEnabled;     }  //!< get SAO enabled/disabled in APS
    952   Void      setAlfEnabled (Bool bVal) {m_bAlfEnabled = bVal;     }  //!< set ALF enabled/disabled in APS
    953   Bool      getAlfEnabled ()          {return m_bAlfEnabled;     }  //!< get ALF enabled/disabled in APS
    954 
    955   AlfParamSet* getAlfParam   ()          {return m_alfParamSet;}
    956   SAOParam* getSaoParam   ()          {return m_pSaoParam;       }  //!< get SAO parameters in APS
    957 
    958   Void      createSaoParam();   //!< create SAO parameter object
    959   Void      destroySaoParam();  //!< destroy SAO parameter object
    960 
    961   Void      createAlfParam();   //!< create ALF parameter object
    962   Void      destroyAlfParam();  //!< destroy ALF parameter object
    963 
    964   Void      setLoopFilterOffsetInAPS(Bool val)  {m_loopFilterOffsetInAPS = val; }      //!< set offset for deblocking filter enabled/disabled in APS
    965   Bool      getLoopFilterOffsetInAPS()          {return m_loopFilterOffsetInAPS; }     //!< get offset for deblocking filter enabled/disabled in APS
    966   Void      setLoopFilterDisable(Bool val)      {m_loopFilterDisable = val; }          //!< set offset for deblocking filter disabled
    967   Bool      getLoopFilterDisable()              {return m_loopFilterDisable; }         //!< get offset for deblocking filter disabled
    968   Void      setLoopFilterBetaOffset(Int val)    {m_loopFilterBetaOffsetDiv2 = val; }    //!< set beta offset for deblocking filter
    969   Int       getLoopFilterBetaOffset()           {return m_loopFilterBetaOffsetDiv2; }   //!< get beta offset for deblocking filter
    970   Void      setLoopFilterTcOffset(Int val)      {m_loopFilterTcOffsetDiv2 = val; }      //!< set tc offset for deblocking filter
    971   Int       getLoopFilterTcOffset()             {return m_loopFilterTcOffsetDiv2; }     //!< get tc offset for deblocking filter
    972 
    973   Void      createScalingList();
    974   Void      destroyScalingList();
    975   Void      setScalingListEnabled (Bool bVal) { m_scalingListEnabled = bVal; }  //!< set ScalingList enabled/disabled in APS
    976   Bool      getScalingListEnabled ()          { return m_scalingListEnabled; }  //!< get ScalingList enabled/disabled in APS
    977   TComScalingList* getScalingList ()          { return m_scalingList; }         //!< get ScalingList class pointer in APS
    978 #if !LGE_SAO_MIGRATION_D0091
    979   Bool     getSaoInterleavingFlag() {return m_saoInterleavingFlag;}             //!< get SAO interleaving flag in APS
    980   Void     setSaoInterleavingFlag(Bool bVal) {m_saoInterleavingFlag = bVal;}    //!< set SAO interleaving flag in APS
    981 #endif
    982 
    983 private:
    984   Int         m_apsID;        //!< APS ID
    985   Bool        m_bSaoEnabled;  //!< SAO enabled/disabled in APS (true for enabled)
    986   Bool        m_bAlfEnabled;  //!< ALF enabled/disabled in APS (true for enabled)
    987   SAOParam*   m_pSaoParam;    //!< SAO parameter object pointer
    988   AlfParamSet*   m_alfParamSet;
    989   Bool        m_loopFilterOffsetInAPS;       //< offset for deblocking filter in 0 = slice header, 1 = APS
    990   Bool        m_loopFilterDisable;           //< Deblocking filter enabled/disabled in APS
    991   Int         m_loopFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
    992   Int         m_loopFilterTcOffsetDiv2;      //< tc offset for deblocking filter
    993   Bool        m_scalingListEnabled;     //!< ScalingList enabled/disabled in APS (true for enabled)
    994   TComScalingList*     m_scalingList;   //!< ScalingList class pointer
    995 #if !LGE_SAO_MIGRATION_D0091
    996   Bool        m_saoInterleavingFlag;    //!< SAO interleaving flag
    997 #endif
    998 
    999 public:
    1000   TComAPS& operator= (const TComAPS& src);  //!< "=" operator for APS object
    1001 };
    1002 
    1003 typedef struct {
    10041422  // Explicit weighted prediction parameters parsed in slice header,
    10051423  // or Implicit weighted prediction parameters (8 bits depth values).
     
    10131431} wpScalingParam;
    10141432
    1015 typedef struct {
     1433typedef struct
     1434{
    10161435  Int64 iAC;
    10171436  Int64 iDC;
     
    10241443private:
    10251444  //  Bitstream writing
    1026   Int         m_iAPSId; //!< APS ID in slice header
    1027   bool       m_alfEnabledFlag;
    1028   bool       m_saoEnabledFlag;
    1029 #if LGE_SAO_MIGRATION_D0091
    1030   bool       m_saoEnabledFlagChroma;      ///< SAO Cb&Cr enabled flag
    1031 #else
    1032   bool       m_saoInterleavingFlag;   ///< SAO interleaving flag
    1033   bool       m_saoEnabledFlagCb;      ///< SAO Cb enabled flag
    1034   bool       m_saoEnabledFlagCr;      ///< SAO Cr enabled flag
    1035 #endif
     1445  Bool       m_saoEnabledFlag;
     1446  Bool       m_saoEnabledFlagChroma;      ///< SAO Cb&Cr enabled flag
    10361447  Int         m_iPPSId;               ///< picture parameter set ID
    10371448  Bool        m_PicOutputFlag;        ///< pic_output_flag
     
    10421453  TComReferencePictureSet m_LocalRPS;
    10431454  Int         m_iBDidx;
    1044   Int         m_iCombinationBDidx;
    1045   Bool        m_bCombineWithReferenceFlag;
    10461455  TComRefPicListModification m_RefPicListModification;
    1047   NalUnitType m_eNalUnitType;            ///< Nal unit type for the slice
    1048   NalUnitType m_eNalUnitTypeBaseViewMvc; ///< Nal unit type of the base view slice for multiview coding
     1456  NalUnitType m_eNalUnitType;         ///< Nal unit type for the slice
    10491457  SliceType   m_eSliceType;
    10501458  Int         m_iSliceQp;
     1459  Bool        m_dependentSliceSegmentFlag;
    10511460#if ADAPTIVE_QP_SELECTION
    10521461  Int         m_iSliceQpBase;
    10531462#endif
    1054   Bool        m_bLoopFilterDisable;
    1055   Bool        m_loopFilterOffsetInAPS;
    1056   Bool        m_inheritDblParamFromAPS;      //< offsets for deblocking filter inherit from APS
    1057   Int         m_loopFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
    1058   Int         m_loopFilterTcOffsetDiv2;      //< tc offset for deblocking filter
    1059  
    1060   Int         m_aiNumRefIdx   [3];    //  for multiple reference of current slice
    1061 
    1062   Int         m_iRefIdxOfLC[2][MAX_NUM_REF_LC];
    1063   Int         m_eListIdFromIdxOfLC[MAX_NUM_REF_LC];
    1064   Int         m_iRefIdxFromIdxOfLC[MAX_NUM_REF_LC];
    1065   Int         m_iRefIdxOfL1FromRefIdxOfL0[MAX_NUM_REF_LC];
    1066   Int         m_iRefIdxOfL0FromRefIdxOfL1[MAX_NUM_REF_LC];
    1067   Bool        m_bRefPicListModificationFlagLC;
    1068   Bool        m_bRefPicListCombinationFlag;
     1463  Bool        m_deblockingFilterDisable;
     1464  Bool        m_deblockingFilterOverrideFlag;      //< offsets for deblocking filter inherit from PPS
     1465  Int         m_deblockingFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
     1466  Int         m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
     1467  Int         m_list1IdxToList0Idx[MAX_NUM_REF];
     1468  Int         m_aiNumRefIdx   [2];    //  for multiple reference of current slice
    10691469
    10701470  Bool        m_bCheckLDC;
    1071 #if QC_TMVP_MRG_REFIDX_C0047
    1072   Int         m_aiNewRefIdx    [2];
    1073 #endif
    10741471
    10751472  //  Data
    10761473  Int         m_iSliceQpDelta;
    1077   TComPic*    m_apcRefPicList  [2][MAX_NUM_REF+1];
    1078   Int         m_aiRefPOCList   [2][MAX_NUM_REF+1];
    1079   Int         m_aiRefViewIdList[2][MAX_NUM_REF+1];
    1080   TComPic*    m_pcTexturePic;
     1474  Int         m_iSliceQpDeltaCb;
     1475  Int         m_iSliceQpDeltaCr;
     1476  TComPic*    m_apcRefPicList [2][MAX_NUM_REF+1];
     1477  Int         m_aiRefPOCList  [2][MAX_NUM_REF+1];
     1478#if H_MV
     1479  Int         m_aiRefLayerIdList[2][MAX_NUM_REF+1];
     1480#endif
     1481  Bool        m_bIsUsedAsLongTerm[2][MAX_NUM_REF+1];
    10811482  Int         m_iDepth;
    10821483 
     
    10851486 
    10861487  // access channel
    1087 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
    10881488  TComVPS*    m_pcVPS;
    1089 #endif
    1090 #if QC_IV_AS_LT_B0046
    1091   Bool        m_bWasLongTerm[2][MAX_NUM_REF+1]; //was long-term picture
    1092 #endif
    10931489  TComSPS*    m_pcSPS;
    10941490  TComPPS*    m_pcPPS;
     
    10971493  TComTrQuant* m_pcTrQuant;
    10981494#endif 
    1099   TComAPS*    m_pcAPS;  //!< pointer to APS parameter object
    1100 
    1101   UInt        m_uiColDir;  // direction to get colocated CUs
    1102  
    1103 #if COLLOCATED_REF_IDX
     1495  UInt        m_colFromL0Flag;  // collocated picture from List0 flag
     1496 
    11041497  UInt        m_colRefIdx;
    1105 #endif
    1106 
    1107 #if ALF_CHROMA_LAMBDA || SAO_CHROMA_LAMBDA
     1498  UInt        m_maxNumMergeCand;
     1499
     1500
     1501#if SAO_CHROMA_LAMBDA
    11081502  Double      m_dLambdaLuma;
    11091503  Double      m_dLambdaChroma;
     
    11131507
    11141508  Bool        m_abEqualRef  [2][MAX_NUM_REF][MAX_NUM_REF];
    1115  
    1116   Bool        m_bNoBackPredFlag;
    1117   Bool        m_bRefIdxCombineCoding;
    1118 
    11191509  UInt        m_uiTLayer;
    11201510  Bool        m_bTLayerSwitchingFlag;
    11211511
    1122   UInt        m_uiSliceMode;
    1123   UInt        m_uiSliceArgument;
    1124   UInt        m_uiSliceCurStartCUAddr;
    1125   UInt        m_uiSliceCurEndCUAddr;
    1126   UInt        m_uiSliceIdx;
    1127   UInt        m_uiEntropySliceMode;
    1128   UInt        m_uiEntropySliceArgument;
    1129   UInt        m_uiEntropySliceCurStartCUAddr;
    1130   UInt        m_uiEntropySliceCurEndCUAddr;
    1131   Bool        m_bNextSlice;
    1132   Bool        m_bNextEntropySlice;
    1133   UInt        m_uiSliceBits;
    1134   UInt        m_uiEntropySliceCounter;
     1512  UInt        m_sliceMode;
     1513  UInt        m_sliceArgument;
     1514  UInt        m_sliceCurStartCUAddr;
     1515  UInt        m_sliceCurEndCUAddr;
     1516  UInt        m_sliceIdx;
     1517  UInt        m_sliceSegmentMode;
     1518  UInt        m_sliceSegmentArgument;
     1519  UInt        m_sliceSegmentCurStartCUAddr;
     1520  UInt        m_sliceSegmentCurEndCUAddr;
     1521  Bool        m_nextSlice;
     1522  Bool        m_nextSliceSegment;
     1523  UInt        m_sliceBits;
     1524  UInt        m_sliceSegmentBits;
    11351525  Bool        m_bFinalized;
    11361526
    11371527  wpScalingParam  m_weightPredTable[2][MAX_NUM_REF][3]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
    11381528  wpACDCParam    m_weightACDCParam[3];                 // [0:Y, 1:U, 2:V]
    1139   wpScalingParam  m_weightPredTableLC[2*MAX_NUM_REF][3]; // [refIdxLC][0:Y, 1:U, 2:V]
    1140 
    1141   UInt        *m_uiTileByteLocation;
    1142   UInt        m_uiTileCount;
    1143   Int         m_iTileMarkerFlag;
     1529
     1530  std::vector<UInt> m_tileByteLocation;
    11441531  UInt        m_uiTileOffstForMultES;
    11451532
    11461533  UInt*       m_puiSubstreamSizes;
    11471534  TComScalingList*     m_scalingList;                 //!< pointer of quantization matrix
    1148 #if CABAC_INIT_FLAG
    11491535  Bool        m_cabacInitFlag;
    1150 #else
    1151   Int         m_cabacInitIdc;
    1152 #endif
    11531536
    11541537  Bool       m_bLMvdL1Zero;
    11551538  Int         m_numEntryPointOffsets;
    1156 
     1539  Bool       m_temporalLayerNonReferenceFlag;
     1540  Bool       m_LFCrossSliceBoundaryFlag;
     1541
     1542  Bool       m_enableTMVPFlag;
     1543#if H_MV
     1544  std::vector<TComPic*>* m_refPicSetInterLayer;
     1545  Int        m_layerId;
    11571546  Int        m_viewId;
     1547#if H_3D
     1548  Int        m_viewIndex;
    11581549  Bool       m_isDepth;
    1159   Int        m_aaiCodedScale [2][MAX_VIEW_NUM];
    1160   Int        m_aaiCodedOffset[2][MAX_VIEW_NUM];
    1161 
    1162 #if LGE_ILLUCOMP_B0045
    1163   Bool        m_bApplyIC;
    1164 #if SHARP_ILLUCOMP_PARSE_D0060
    1165   Bool        m_icSkipParseFlag;
    1166 #endif
    1167 #endif
    1168 #if MERL_VSP_NBDV_RefVId_Fix_D0166
    1169   TComList<TComPic*>*  m_pcListDepthPic[MAX_VIEW_NUM]; // For encoder, the list may also include texture pictures. Three views with ViewIdx = 0, 1, 2
    1170 #endif
    1171 #if QC_ARP_D0177
    1172   TComList<TComPic*> * m_pBaseViewRefPicList[MAX_VIEW_NUM];
     1550#endif
     1551
     1552// Additional slice header syntax elements
     1553  Bool       m_discardableFlag;
     1554  Bool       m_interLayerPredEnabledFlag;
     1555  Int        m_numInterLayerRefPicsMinus1;
     1556  Int        m_interLayerPredLayerIdc       [MAX_NUM_LAYERS];
     1557  Bool       m_interLayerSamplePredOnlyFlag;
     1558  Bool       m_altCollocatedIndicationFlag;
     1559  Int        m_collocatedRefLayerIdx;
     1560// Additional slice header semantics variables
     1561  Int        m_numActiveMotionPredRefLayers;
     1562  Int        m_activeMotionPredRefLayerId   [ MAX_NUM_LAYER_IDS ];
     1563
     1564  Int        m_aaiCodedScale [2][MAX_NUM_LAYERS];
     1565  Int        m_aaiCodedOffset[2][MAX_NUM_LAYERS];
     1566#if H_3D_TMVP
     1567  Int        m_aiAlterRefIdx   [2];
     1568#endif
     1569#if H_3D_ARP
     1570  TComList<TComPic*> * m_pBaseViewRefPicList[MAX_NUM_LAYERS];
    11731571  UInt                 m_nARPStepNum;
    11741572#endif
    1175 #if INTER_VIEW_VECTOR_SCALING_C0115|QC_MVHEVC_B0046
    1176   Bool       m_bIVScalingFlag;
    1177   Int        m_iViewOrderIdx;    // will be changed to view_id
    1178 #endif
    1179 
    1180 #if MERL_VSP_C0152
    1181   TComPic*     m_apcRefPicBaseTxt;
    1182   TComPic*     m_apcRefPicBaseDepth;
    1183 #if MERL_VSP_NBDV_RefVId_Fix_D0166
    1184   Int*         m_aiShiftLUT[2]; // For reference views
    1185 #else
    1186   Int*         m_aiShiftLUT;
    1187 #endif
    1188   Int          m_iShiftPrec;
    1189 #endif
    1190 
     1573#if H_3D_IC
     1574  Bool      m_bApplyIC;
     1575  Bool      m_icSkipParseFlag;
     1576#endif
     1577#if H_3D
     1578  TComPic*   m_ivPicsCurrPoc [2][MAX_NUM_LAYERS]; 
     1579  Int**      m_depthToDisparityB;
     1580  Int**      m_depthToDisparityF;
     1581#endif
     1582#endif
    11911583public:
    11921584  TComSlice();
    1193   virtual ~TComSlice();
    1194  
     1585  virtual ~TComSlice();
    11951586  Void      initSlice       ();
    1196   Void      initTiles();
    1197 
    1198 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
     1587
    11991588  Void      setVPS          ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
    12001589  TComVPS*  getVPS          () { return m_pcVPS; }
    1201 #endif
    1202 #if QC_IV_AS_LT_B0046
    1203   Void          setWasLongTerm( Bool lt,  RefPicList e, Int iRefIdx ) { m_bWasLongTerm[e][iRefIdx] = lt; }
    1204   Bool          getWasLongTerm( RefPicList e, Int iRefIdx           ) { return m_bWasLongTerm[e][iRefIdx] ; }
    1205 #endif
    1206 
    12071590  Void      setSPS          ( TComSPS* pcSPS ) { m_pcSPS = pcSPS; }
    12081591  TComSPS*  getSPS          () { return m_pcSPS; }
     
    12181601  Void      setPPSId        ( Int PPSId )         { m_iPPSId = PPSId; }
    12191602  Int       getPPSId        () { return m_iPPSId; }
    1220   Void      setAPS          ( TComAPS* pcAPS ) { m_pcAPS = pcAPS; } //!< set APS pointer
    1221   TComAPS*  getAPS          ()                 { return m_pcAPS;  } //!< get APS pointer
    1222   Void      setAPSId        ( Int Id)          { m_iAPSId =Id;    } //!< set APS ID
    1223   Int       getAPSId        ()                 { return m_iAPSId; } //!< get APS ID
    12241603  Void      setPicOutputFlag( Bool b )         { m_PicOutputFlag = b;    }
    12251604  Bool      getPicOutputFlag()                 { return m_PicOutputFlag; }
    1226   Void      setAlfEnabledFlag(Bool s) {m_alfEnabledFlag =s; }
    1227   Bool      getAlfEnabledFlag() { return m_alfEnabledFlag; }
    12281605  Void      setSaoEnabledFlag(Bool s) {m_saoEnabledFlag =s; }
    12291606  Bool      getSaoEnabledFlag() { return m_saoEnabledFlag; }
    1230 #if LGE_SAO_MIGRATION_D0091
    12311607  Void      setSaoEnabledFlagChroma(Bool s) {m_saoEnabledFlagChroma =s; }       //!< set SAO Cb&Cr enabled flag
    12321608  Bool      getSaoEnabledFlagChroma() { return m_saoEnabledFlagChroma; }        //!< get SAO Cb&Cr enabled flag
    1233 #else
    1234   Void      setSaoInterleavingFlag(Bool s) {m_saoInterleavingFlag =s; } //!< set SAO interleaving flag
    1235   Bool      getSaoInterleavingFlag() { return m_saoInterleavingFlag;  } //!< get SAO interleaving flag
    1236   Void      setSaoEnabledFlagCb(Bool s) {m_saoEnabledFlagCb =s; }       //!< set SAO Cb enabled flag
    1237   Bool      getSaoEnabledFlagCb() { return m_saoEnabledFlagCb; }        //!< get SAO Cb enabled flag
    1238   Void      setSaoEnabledFlagCr(Bool s) {m_saoEnabledFlagCr =s; }       //!< set SAO Cr enabled flag
    1239   Bool      getSaoEnabledFlagCr() { return m_saoEnabledFlagCr; }        //!< get SAO Cr enabled flag
    1240 #endif
    12411609  Void      setRPS          ( TComReferencePictureSet *pcRPS ) { m_pcRPS = pcRPS; }
    12421610  TComReferencePictureSet*  getRPS          () { return m_pcRPS; }
     
    12451613  Void      setRPSidx          ( Int iBDidx ) { m_iBDidx = iBDidx; }
    12461614  Int       getRPSidx          () { return m_iBDidx; }
    1247   Void      setCombinationBDidx          ( Int iCombinationBDidx ) { m_iCombinationBDidx = iCombinationBDidx; }
    1248   Int       getCombinationBDidx          () { return m_iCombinationBDidx; }
    1249   Void      setCombineWithReferenceFlag          ( Bool bCombineWithReferenceFlag ) { m_bCombineWithReferenceFlag = bCombineWithReferenceFlag; }
    1250   Bool      getCombineWithReferenceFlag          () { return m_bCombineWithReferenceFlag; }
    12511615  Int       getPrevPOC      ()                          { return  m_prevPOC;       }
    1252 
    12531616  TComRefPicListModification* getRefPicListModification() { return &m_RefPicListModification; }
    12541617  Void      setLastIDR(Int iIDRPOC)                       { m_iLastIDR = iIDRPOC; }
     
    12571620  Int       getPOC          ()                          { return  m_iPOC;           }
    12581621  Int       getSliceQp      ()                          { return  m_iSliceQp;           }
     1622  Bool      getDependentSliceSegmentFlag() const        { return m_dependentSliceSegmentFlag; }
     1623  void      setDependentSliceSegmentFlag(Bool val)      { m_dependentSliceSegmentFlag = val; }
    12591624#if ADAPTIVE_QP_SELECTION
    12601625  Int       getSliceQpBase  ()                          { return  m_iSliceQpBase;       }
    12611626#endif
    12621627  Int       getSliceQpDelta ()                          { return  m_iSliceQpDelta;      }
    1263   Bool      getLoopFilterDisable()                      { return  m_bLoopFilterDisable; }
    1264   Bool      getLoopFilterOffsetInAPS()                  { return  m_loopFilterOffsetInAPS;}
    1265   Bool      getInheritDblParamFromAPS()                 { return  m_inheritDblParamFromAPS; }
    1266   Int       getLoopFilterBetaOffset()                   { return  m_loopFilterBetaOffsetDiv2; }
    1267   Int       getLoopFilterTcOffset()                     { return  m_loopFilterTcOffsetDiv2; }
     1628  Int       getSliceQpDeltaCb ()                          { return  m_iSliceQpDeltaCb;      }
     1629  Int       getSliceQpDeltaCr ()                          { return  m_iSliceQpDeltaCr;      }
     1630  Bool      getDeblockingFilterDisable()                { return  m_deblockingFilterDisable; }
     1631  Bool      getDeblockingFilterOverrideFlag()           { return  m_deblockingFilterOverrideFlag; }
     1632  Int       getDeblockingFilterBetaOffsetDiv2()         { return  m_deblockingFilterBetaOffsetDiv2; }
     1633  Int       getDeblockingFilterTcOffsetDiv2()           { return  m_deblockingFilterTcOffsetDiv2; }
    12681634
    12691635  Int       getNumRefIdx        ( RefPicList e )                { return  m_aiNumRefIdx[e];             }
     
    12711637  TComPic*  getRefPic           ( RefPicList e, Int iRefIdx)    { return  m_apcRefPicList[e][iRefIdx];  }
    12721638  Int       getRefPOC           ( RefPicList e, Int iRefIdx)    { return  m_aiRefPOCList[e][iRefIdx];   }
    1273   Int       getRefViewId        ( RefPicList e, Int iRefIdx)    { return  m_aiRefViewIdList[e][iRefIdx]; }
    1274   TComPic*  getTexturePic       () const                        { return  m_pcTexturePic; }
     1639#if H_3D
     1640  TComPic*  getIvPic            ( Bool depthFlag, Int viewIndex){ return  m_ivPicsCurrPoc[ depthFlag ? 1 : 0 ][ viewIndex ]; }
     1641#endif
     1642#if H_3D_IV_MERGE
     1643  TComPic*  getTexturePic       ()                              { return  m_ivPicsCurrPoc[0][ m_viewIndex ]; }
     1644#endif
     1645#if H_3D_IC
     1646  Void      setApplyIC( Bool b )                                { m_bApplyIC = b; }
     1647  Bool      getApplyIC()                                        { return m_bApplyIC; }
     1648  Void      xSetApplyIC();
     1649  Void      setIcSkipParseFlag( Bool b )                        { m_icSkipParseFlag = b; }
     1650  Bool      getIcSkipParseFlag()                                { return m_icSkipParseFlag; }
     1651#endif
     1652#if H_3D_ARP
     1653  Void      setBaseViewRefPicList( TComList<TComPic*> *pListPic, Int iViewIdx )      { m_pBaseViewRefPicList[iViewIdx] = pListPic;                   }
     1654  Void      setARPStepNum();                                 
     1655  TComPic*  getBaseViewRefPic    ( UInt uiPOC , Int iViewIdx )                       { return xGetRefPic( *m_pBaseViewRefPicList[iViewIdx], uiPOC ); }
     1656  UInt      getARPStepNum( )                                                         { return m_nARPStepNum;                                         } 
     1657#endif
    12751658  Int       getDepth            ()                              { return  m_iDepth;                     }
    1276   UInt      getColDir           ()                              { return  m_uiColDir;                   }
    1277 #if COLLOCATED_REF_IDX
    1278   Bool      getColRefIdx        ()                              { return  m_colRefIdx;                  }
     1659  UInt      getColFromL0Flag    ()                              { return  m_colFromL0Flag;              }
     1660  UInt      getColRefIdx        ()                              { return  m_colRefIdx;                  }
    12791661  Void      checkColRefIdx      (UInt curSliceIdx, TComPic* pic);
    1280 #endif
     1662  Bool      getIsUsedAsLongTerm (Int i, Int j)                  { return m_bIsUsedAsLongTerm[i][j]; }
    12811663  Bool      getCheckLDC     ()                                  { return m_bCheckLDC; }
    12821664  Bool      getMvdL1ZeroFlag ()                                  { return m_bLMvdL1Zero;    }
    1283   Int       getRefIdxOfLC       (RefPicList e, Int iRefIdx)     { return m_iRefIdxOfLC[e][iRefIdx];           }
    1284   Int       getListIdFromIdxOfLC(Int iRefIdx)                   { return m_eListIdFromIdxOfLC[iRefIdx];       }
    1285   Int       getRefIdxFromIdxOfLC(Int iRefIdx)                   { return m_iRefIdxFromIdxOfLC[iRefIdx];       }
    1286   Int       getRefIdxOfL0FromRefIdxOfL1(Int iRefIdx)            { return m_iRefIdxOfL0FromRefIdxOfL1[iRefIdx];}
    1287   Int       getRefIdxOfL1FromRefIdxOfL0(Int iRefIdx)            { return m_iRefIdxOfL1FromRefIdxOfL0[iRefIdx];}
    1288   Bool      getRefPicListModificationFlagLC()                   {return m_bRefPicListModificationFlagLC;}
    1289   Void      setRefPicListModificationFlagLC(Bool bflag)         {m_bRefPicListModificationFlagLC=bflag;}     
    1290   Bool      getRefPicListCombinationFlag()                      {return m_bRefPicListCombinationFlag;}
    1291   Void      setRefPicListCombinationFlag(Bool bflag)            {m_bRefPicListCombinationFlag=bflag;}     
    1292   Void      setListIdFromIdxOfLC(Int  iRefIdx, UInt uiVal)      { m_eListIdFromIdxOfLC[iRefIdx]=uiVal; }
    1293   Void      setRefIdxFromIdxOfLC(Int  iRefIdx, UInt uiVal)      { m_iRefIdxFromIdxOfLC[iRefIdx]=uiVal; }
    1294   Void      setRefIdxOfLC       (RefPicList e, Int iRefIdx, Int RefIdxLC)     { m_iRefIdxOfLC[e][iRefIdx]=RefIdxLC;}
    1295 
     1665  Int       getNumRpsCurrTempList();
     1666  Int       getList1IdxToList0Idx ( Int list1Idx )               { return m_list1IdxToList0Idx[list1Idx]; }
    12961667  Void      setReferenced(Bool b)                               { m_bRefenced = b; }
    12971668  Bool      isReferenced()                                      { return m_bRefenced; }
    1298  
    12991669  Void      setPOC              ( Int i )                       { m_iPOC              = i; if(getTLayer()==0) m_prevPOC=i; }
    13001670  Void      setNalUnitType      ( NalUnitType e )               { m_eNalUnitType      = e;      }
    1301   NalUnitType getNalUnitType    ()                              { return m_eNalUnitType;        }
    1302   Void      setNalUnitTypeBaseViewMvc  ( NalUnitType e )        { m_eNalUnitTypeBaseViewMvc = e;    }
    1303   NalUnitType getNalUnitTypeBaseViewMvc()                       { return m_eNalUnitTypeBaseViewMvc; }
    1304   Void      checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, TComList<TComPic*>& rcListPic);
     1671  NalUnitType getNalUnitType    () const                        { return m_eNalUnitType;        }
     1672  Bool      getRapPicFlag       (); 
     1673  Bool      getIdrPicFlag       ()                              { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; }
     1674  Bool      isIRAP              () const                        { return (getNalUnitType() >= 16) && (getNalUnitType() <= 23); } 
     1675  Void      checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA, TComList<TComPic *>& rcListPic);
    13051676  Void      decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList<TComPic*>& rcListPic);
    13061677  Void      setSliceType        ( SliceType e )                 { m_eSliceType        = e;      }
     
    13101681#endif
    13111682  Void      setSliceQpDelta     ( Int i )                       { m_iSliceQpDelta     = i;      }
    1312   Void      setLoopFilterDisable( Bool b )                      { m_bLoopFilterDisable= b;      }
    1313   Void      setLoopFilterOffsetInAPS( Bool b )                  { m_loopFilterOffsetInAPS = b;}
    1314   Void      setInheritDblParamFromAPS( Bool b )                 { m_inheritDblParamFromAPS = b; }
    1315   Void      setLoopFilterBetaOffset( Int i )                    { m_loopFilterBetaOffsetDiv2 = i; }
    1316   Void      setLoopFilterTcOffset( Int i )                      { m_loopFilterTcOffsetDiv2 = i; }
     1683  Void      setSliceQpDeltaCb   ( Int i )                       { m_iSliceQpDeltaCb   = i;      }
     1684  Void      setSliceQpDeltaCr   ( Int i )                       { m_iSliceQpDeltaCr   = i;      }
     1685  Void      setDeblockingFilterDisable( Bool b )                { m_deblockingFilterDisable= b;      }
     1686  Void      setDeblockingFilterOverrideFlag( Bool b )           { m_deblockingFilterOverrideFlag = b; }
     1687  Void      setDeblockingFilterBetaOffsetDiv2( Int i )          { m_deblockingFilterBetaOffsetDiv2 = i; }
     1688  Void      setDeblockingFilterTcOffsetDiv2( Int i )            { m_deblockingFilterTcOffsetDiv2 = i; }
    13171689 
    13181690  Void      setRefPic           ( TComPic* p, RefPicList e, Int iRefIdx ) { m_apcRefPicList[e][iRefIdx] = p; }
    13191691  Void      setRefPOC           ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefPOCList[e][iRefIdx] = i; }
    1320   Void      setRefViewId        ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefViewIdList[e][iRefIdx] = i; }
    1321   Void      setTexturePic       ( TComPic *pcTexturePic )       { m_pcTexturePic = pcTexturePic; }
    13221692  Void      setNumRefIdx        ( RefPicList e, Int i )         { m_aiNumRefIdx[e]    = i;      }
    13231693  Void      setPic              ( TComPic* p )                  { m_pcPic             = p;      }
    13241694  Void      setDepth            ( Int iDepth )                  { m_iDepth            = iDepth; }
    13251695 
    1326   Int       getNumPocTotalCurr();
    1327   Int       getNumPocTotalCurrMvc();
    1328   Void      setRefPicListMvc    ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcInterViewRefPics );
    1329   Void      setRefPOCnViewListsMvc();
    1330 #if QC_ARP_D0177
    1331   Void      setBaseViewRefPicList( TComList<TComPic*> *pListPic, Int iViewIdx )      { m_pBaseViewRefPicList[iViewIdx] = pListPic; }
    1332   TComPic*  getBaseViewRefPic    ( UInt uiPOC , Int iViewIdx )                       { return xGetRefPic( *m_pBaseViewRefPicList[iViewIdx], uiPOC ); }
    1333   Void      setARPStepNum();                                 
    1334   UInt      getARPStepNum( )                                      { return m_nARPStepNum;      } 
    1335 #endif
    1336   Void      setColDir           ( UInt uiDir ) { m_uiColDir = uiDir; }
    1337 #if COLLOCATED_REF_IDX
     1696#if H_MV
     1697  Int       getRefLayerId        ( RefPicList e, Int iRefIdx)    { return  m_aiRefLayerIdList[e][iRefIdx]; }
     1698  Void      setRefLayerId        ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefLayerIdList[e][iRefIdx] = i; }
     1699#endif
     1700#if H_MV
     1701  Void      setRefPicList       ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& interLayerRefPicSet , Bool checkNumPocTotalCurr = false );
     1702#else
     1703#if FIX1071
     1704  Void      setRefPicList       ( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr = false );
     1705#else
     1706  Void      setRefPicList       ( TComList<TComPic*>& rcListPic );
     1707#endif
     1708#endif
     1709  Void      setRefPOCList       ();
     1710  Void      setColFromL0Flag    ( UInt colFromL0 ) { m_colFromL0Flag = colFromL0; }
    13381711  Void      setColRefIdx        ( UInt refIdx) { m_colRefIdx = refIdx; }
    1339 #endif
    13401712  Void      setCheckLDC         ( Bool b )                      { m_bCheckLDC = b; }
    13411713  Void      setMvdL1ZeroFlag     ( Bool b)                       { m_bLMvdL1Zero = b; }
     
    13451717  Bool      isInterP        ()                          { return  m_eSliceType == P_SLICE;  }
    13461718 
    1347 #if ALF_CHROMA_LAMBDA || SAO_CHROMA_LAMBDA 
     1719#if SAO_CHROMA_LAMBDA 
    13481720  Void      setLambda( Double d, Double e ) { m_dLambdaLuma = d; m_dLambdaChroma = e;}
    13491721  Double    getLambdaLuma() { return m_dLambdaLuma;        }
     
    13671739 
    13681740  static Void      sortPicList         ( TComList<TComPic*>& rcListPic );
    1369  
    1370   Bool getNoBackPredFlag() { return m_bNoBackPredFlag; }
    1371   Void setNoBackPredFlag( Bool b ) { m_bNoBackPredFlag = b; }
    1372   Bool getRefIdxCombineCoding() { return m_bRefIdxCombineCoding; }
    1373   Void setRefIdxCombineCoding( Bool b ) { m_bRefIdxCombineCoding = b; }
    1374   Void generateCombinedList       ();
     1741  Void setList1IdxToList0Idx();
    13751742
    13761743  UInt getTLayer             ()                            { return m_uiTLayer;                      }
    13771744  Void setTLayer             ( UInt uiTLayer )             { m_uiTLayer = uiTLayer;                  }
    1378 
    13791745
    13801746  Void setTLayerInfo( UInt uiTLayer );
    13811747  Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum );
    13821748  Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
    1383 #if H0566_TLA_SET_FOR_SWITCHING_POINTS
    1384   Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
    1385 #endif
    1386   Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool outputFlag, Int pocRandomAccess = 0);
     1749#if H_MV
     1750  Void createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer );
     1751  static Void markIvRefPicsAsShortTerm    ( std::vector<TComPic*> refPicSetInterLayer );
     1752  static Void markCurrPic                 ( TComPic* currPic );;
     1753  static Void markIvRefPicsAsUnused       ( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc  );
     1754  Void        xPrintRefPicList();
     1755#endif
     1756  Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
     1757  Bool isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic );
     1758  Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess = 0);
     1759#if FIX1071
     1760  Void      createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP);
     1761#else
    13871762  Void      createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet);
    1388 
    1389   Void decodingMarkingForNoTMVP( TComList<TComPic*>& rcListPic, Int currentPOC );
    1390 
    1391   UInt m_uiMaxNumMergeCand;
    1392   Void setMaxNumMergeCand               (UInt maxNumMergeCand ) { m_uiMaxNumMergeCand = maxNumMergeCand;  }
    1393   UInt getMaxNumMergeCand               ()                  {return m_uiMaxNumMergeCand;                  }
    1394 
    1395   Void setSliceMode                     ( UInt uiMode )     { m_uiSliceMode = uiMode;                     }
    1396   UInt getSliceMode                     ()                  { return m_uiSliceMode;                       }
    1397   Void setSliceArgument                 ( UInt uiArgument ) { m_uiSliceArgument = uiArgument;             }
    1398   UInt getSliceArgument                 ()                  { return m_uiSliceArgument;                   }
    1399   Void setSliceCurStartCUAddr           ( UInt uiAddr )     { m_uiSliceCurStartCUAddr = uiAddr;           }
    1400   UInt getSliceCurStartCUAddr           ()                  { return m_uiSliceCurStartCUAddr;             }
    1401   Void setSliceCurEndCUAddr             ( UInt uiAddr )     { m_uiSliceCurEndCUAddr = uiAddr;             }
    1402   UInt getSliceCurEndCUAddr             ()                  { return m_uiSliceCurEndCUAddr;               }
    1403   Void setSliceIdx                      ( UInt i)           { m_uiSliceIdx = i;                           }
    1404   UInt getSliceIdx                      ()                  { return  m_uiSliceIdx;                       }
     1763#endif
     1764
     1765  Void setMaxNumMergeCand               (UInt val )         { m_maxNumMergeCand = val;                    }
     1766  UInt getMaxNumMergeCand               ()                  { return m_maxNumMergeCand;                   }
     1767
     1768  Void setSliceMode                     ( UInt uiMode )     { m_sliceMode = uiMode;                     }
     1769  UInt getSliceMode                     ()                  { return m_sliceMode;                       }
     1770  Void setSliceArgument                 ( UInt uiArgument ) { m_sliceArgument = uiArgument;             }
     1771  UInt getSliceArgument                 ()                  { return m_sliceArgument;                   }
     1772  Void setSliceCurStartCUAddr           ( UInt uiAddr )     { m_sliceCurStartCUAddr = uiAddr;           }
     1773  UInt getSliceCurStartCUAddr           ()                  { return m_sliceCurStartCUAddr;             }
     1774  Void setSliceCurEndCUAddr             ( UInt uiAddr )     { m_sliceCurEndCUAddr = uiAddr;             }
     1775  UInt getSliceCurEndCUAddr             ()                  { return m_sliceCurEndCUAddr;               }
     1776  Void setSliceIdx                      ( UInt i)           { m_sliceIdx = i;                           }
     1777  UInt getSliceIdx                      ()                  { return  m_sliceIdx;                       }
    14051778  Void copySliceInfo                    (TComSlice *pcSliceSrc);
    1406   Void setEntropySliceMode              ( UInt uiMode )     { m_uiEntropySliceMode = uiMode;              }
    1407   UInt getEntropySliceMode              ()                  { return m_uiEntropySliceMode;                }
    1408   Void setEntropySliceArgument          ( UInt uiArgument ) { m_uiEntropySliceArgument = uiArgument;      }
    1409   UInt getEntropySliceArgument          ()                  { return m_uiEntropySliceArgument;            }
    1410   Void setEntropySliceCurStartCUAddr    ( UInt uiAddr )     { m_uiEntropySliceCurStartCUAddr = uiAddr;    }
    1411   UInt getEntropySliceCurStartCUAddr    ()                  { return m_uiEntropySliceCurStartCUAddr;      }
    1412   Void setEntropySliceCurEndCUAddr      ( UInt uiAddr )     { m_uiEntropySliceCurEndCUAddr = uiAddr;      }
    1413   UInt getEntropySliceCurEndCUAddr      ()                  { return m_uiEntropySliceCurEndCUAddr;        }
    1414   Void setNextSlice                     ( Bool b )          { m_bNextSlice = b;                           }
    1415   Bool isNextSlice                      ()                  { return m_bNextSlice;                        }
    1416   Void setNextEntropySlice              ( Bool b )          { m_bNextEntropySlice = b;                    }
    1417   Bool isNextEntropySlice               ()                  { return m_bNextEntropySlice;                 }
    1418   Void setSliceBits                     ( UInt uiVal )      { m_uiSliceBits = uiVal;                      }
    1419   UInt getSliceBits                     ()                  { return m_uiSliceBits;                       } 
    1420   Void setEntropySliceCounter           ( UInt uiVal )      { m_uiEntropySliceCounter = uiVal;            }
    1421   UInt getEntropySliceCounter           ()                  { return m_uiEntropySliceCounter;             }
     1779  Void setSliceSegmentMode              ( UInt uiMode )     { m_sliceSegmentMode = uiMode;              }
     1780  UInt getSliceSegmentMode              ()                  { return m_sliceSegmentMode;                }
     1781  Void setSliceSegmentArgument          ( UInt uiArgument ) { m_sliceSegmentArgument = uiArgument;      }
     1782  UInt getSliceSegmentArgument          ()                  { return m_sliceSegmentArgument;            }
     1783  Void setSliceSegmentCurStartCUAddr    ( UInt uiAddr )     { m_sliceSegmentCurStartCUAddr = uiAddr;    }
     1784  UInt getSliceSegmentCurStartCUAddr    ()                  { return m_sliceSegmentCurStartCUAddr;      }
     1785  Void setSliceSegmentCurEndCUAddr      ( UInt uiAddr )     { m_sliceSegmentCurEndCUAddr = uiAddr;      }
     1786  UInt getSliceSegmentCurEndCUAddr      ()                  { return m_sliceSegmentCurEndCUAddr;        }
     1787  Void setNextSlice                     ( Bool b )          { m_nextSlice = b;                           }
     1788  Bool isNextSlice                      ()                  { return m_nextSlice;                        }
     1789  Void setNextSliceSegment              ( Bool b )          { m_nextSliceSegment = b;                    }
     1790  Bool isNextSliceSegment               ()                  { return m_nextSliceSegment;                 }
     1791  Void setSliceBits                     ( UInt uiVal )      { m_sliceBits = uiVal;                      }
     1792  UInt getSliceBits                     ()                  { return m_sliceBits;                       } 
     1793  Void setSliceSegmentBits              ( UInt uiVal )      { m_sliceSegmentBits = uiVal;            }
     1794  UInt getSliceSegmentBits              ()                  { return m_sliceSegmentBits;             }
    14221795  Void setFinalized                     ( Bool uiVal )      { m_bFinalized = uiVal;                       }
    14231796  Bool getFinalized                     ()                  { return m_bFinalized;                        }
     
    14251798  Void  getWpScaling    ( RefPicList e, Int iRefIdx, wpScalingParam *&wp);
    14261799
    1427   Void  resetWpScaling  (wpScalingParam  wp[2][MAX_NUM_REF][3]);
    1428   Void  initWpScaling    (wpScalingParam  wp[2][MAX_NUM_REF][3]);
     1800  Void  resetWpScaling  ();
    14291801  Void  initWpScaling   ();
    1430   inline Bool applyWP   () { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) || (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPredIdc()) ); }
    1431  
     1802  inline Bool applyWP   () { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) || (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPred()) ); }
     1803
    14321804  Void  setWpAcDcParam  ( wpACDCParam wp[3] ) { memcpy(m_weightACDCParam, wp, sizeof(wpACDCParam)*3); }
    14331805  Void  getWpAcDcParam  ( wpACDCParam *&wp );
    14341806  Void  initWpAcDcParam ();
    1435   Void  copyWPtable     (wpScalingParam *&wp_src, wpScalingParam *&wp_dst);
    1436   Void  getWpScalingLC  ( Int iRefIdx, wpScalingParam *&wp);
    1437   Void  resetWpScalingLC(wpScalingParam  wp[2*MAX_NUM_REF][3]);
    1438   Void  setWpParamforLC();
    1439   Void setTileLocationCount             ( UInt uiCount )      { m_uiTileCount = uiCount;                  }
    1440   UInt getTileLocationCount             ()                    { return m_uiTileCount;                     }
    1441   Void setTileLocation                  ( Int i, UInt uiLOC ) { m_uiTileByteLocation[i] = uiLOC;          }
    1442   UInt getTileLocation                  ( Int i )             { return m_uiTileByteLocation[i];           }
    1443   Void setTileMarkerFlag                ( Int iFlag )         { m_iTileMarkerFlag = iFlag;                }
    1444   Int  getTileMarkerFlag                ()                    { return m_iTileMarkerFlag;                 }
     1807 
     1808  Void setTileLocationCount             ( UInt cnt )               { return m_tileByteLocation.resize(cnt);    }
     1809  UInt getTileLocationCount             ()                         { return (UInt) m_tileByteLocation.size();  }
     1810  Void setTileLocation                  ( Int idx, UInt location ) { assert (idx<m_tileByteLocation.size());
     1811                                                                     m_tileByteLocation[idx] = location;       }
     1812  Void addTileLocation                  ( UInt location )          { m_tileByteLocation.push_back(location);   }
     1813  UInt getTileLocation                  ( Int idx )                { return m_tileByteLocation[idx];           }
     1814
    14451815  Void setTileOffstForMultES            (UInt uiOffset )      { m_uiTileOffstForMultES = uiOffset;        }
    14461816  UInt getTileOffstForMultES            ()                    { return m_uiTileOffstForMultES;            }
     
    14511821  Void  setDefaultScalingList       ();
    14521822  Bool  checkDefaultScalingList     ();
    1453 #if CABAC_INIT_FLAG
    14541823  Void      setCabacInitFlag  ( Bool val ) { m_cabacInitFlag = val;      }  //!< set CABAC initial flag
    14551824  Bool      getCabacInitFlag  ()           { return m_cabacInitFlag;     }  //!< get CABAC initial flag
    1456 #else
    1457   Void      setCABACinitIDC(Int iVal) {m_cabacInitIdc = iVal;    }  //!< set CABAC initial IDC number
    1458   Int       getCABACinitIDC()         {return m_cabacInitIdc;    }  //!< get CABAC initial IDC number
    1459 #endif
    14601825  Void      setNumEntryPointOffsets(Int val)  { m_numEntryPointOffsets = val;     }
    14611826  Int       getNumEntryPointOffsets()         { return m_numEntryPointOffsets;    }
    1462 
    1463   Void setViewId( Int viewId )       { m_viewId = viewId;   }
    1464   Int  getViewId()                   { return m_viewId;     }
    1465 #if QC_MVHEVC_B0046
    1466   Void    setViewOrderIdx(Int v, UInt layer)                { m_iViewOrderIdx = v;    }
    1467   Int     getViewOrderIdx()                                 { return m_iViewOrderIdx; }
    1468 #endif
    1469   Void setIsDepth( Bool isDepth )    { m_isDepth = isDepth; }
    1470   Bool getIsDepth()                  { return m_isDepth;    }
    1471  
    1472   Void      initMultiviewSlice    ( Int** aaiScale = 0, Int** aaiOffset = 0 );
    1473 
     1827  Bool      getTemporalLayerNonReferenceFlag()       { return m_temporalLayerNonReferenceFlag;}
     1828  Void      setTemporalLayerNonReferenceFlag(Bool x) { m_temporalLayerNonReferenceFlag = x;}
     1829  Void      setLFCrossSliceBoundaryFlag     ( Bool   val )    { m_LFCrossSliceBoundaryFlag = val; }
     1830  Bool      getLFCrossSliceBoundaryFlag     ()                { return m_LFCrossSliceBoundaryFlag;}
     1831
     1832  Void      setEnableTMVPFlag     ( Bool   b )    { m_enableTMVPFlag = b; }
     1833  Bool      getEnableTMVPFlag     ()              { return m_enableTMVPFlag;}
     1834
     1835#if H_MV
     1836  Void      setLayerId            ( Int layerId )    { m_layerId      = layerId; }
     1837  Int       getLayerId            ()                 { return m_layerId;    }
     1838  Int       getLayerIdInVps       ()                 { return getVPS()->getLayerIdInVps( m_layerId ); };
     1839  Void      setViewId             ( Int viewId )     { m_viewId = viewId;   }
     1840  Int       getViewId             ()                 { return m_viewId;     }
     1841#if H_3D
     1842#if H_3D_TMVP
     1843  Void      generateAlterRefforTMVP ();   
     1844  Void      setAlterRefIdx          ( RefPicList e, Int i ) { m_aiAlterRefIdx[e]    = i;      }
     1845  Int       getAlterRefIdx          ( RefPicList e )        { return  m_aiAlterRefIdx[e];     }
     1846#endif
     1847  Void      setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
     1848  Int       getViewIndex          ()                 { return m_viewIndex;     }
     1849  Void      setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
     1850  Bool      getIsDepth            ()                 { return m_isDepth; }
     1851  Void      setCamparaSlice       ( Int** aaiScale = 0, Int** aaiOffset = 0 );
    14741852  Int*      getCodedScale         ()  { return m_aaiCodedScale [0]; }
    14751853  Int*      getCodedOffset        ()  { return m_aaiCodedOffset[0]; }
    14761854  Int*      getInvCodedScale      ()  { return m_aaiCodedScale [1]; }
    14771855  Int*      getInvCodedOffset     ()  { return m_aaiCodedOffset[1]; }
    1478 
    1479 #if LGE_ILLUCOMP_B0045
    1480   Void      setApplyIC            ( Bool b ) { m_bApplyIC = b; }
    1481   Bool      getApplyIC            ()  { return m_bApplyIC; }
    1482   Void      xSetApplyIC           ();
    1483 #if SHARP_ILLUCOMP_PARSE_D0060
    1484   Void      setIcSkipParseFlag( Bool b ) { m_icSkipParseFlag = b; }
    1485   Bool      getIcSkipParseFlag() { return m_icSkipParseFlag; }
    1486 #endif
    1487 #endif
    1488 #if QC_TMVP_MRG_REFIDX_C0047
    1489   Int       getNewRefIdx        ( RefPicList e )                { return  m_aiNewRefIdx[e];     }
    1490   Void      setNewRefIdx        ( RefPicList e, Int i )         { m_aiNewRefIdx[e]    = i;      }
    1491 #endif
    1492 #if INTER_VIEW_VECTOR_SCALING_C0115
    1493   Void setIVScalingFlag( Bool val )         { m_bIVScalingFlag = val;     }
    1494   Bool getIVScalingFlag()                   { return m_bIVScalingFlag;    }
    1495   Void setViewOrderIdx     ( Int i )        { m_iViewOrderIdx     = i;    }   // will be changed to view_id
    1496   Int  getViewOrderIdx     ()               { return  m_iViewOrderIdx;    }   // will be changed to view_id
    1497 #endif
    1498 
    1499 #if MERL_VSP_C0152
    1500   TComPic*     getRefPicBaseTxt          ()                        { return  m_apcRefPicBaseTxt; }
    1501   Void         setRefPicBaseTxt          ( TComPic* RefPic)        { m_apcRefPicBaseTxt = RefPic; }
    1502   TComPic*     getRefPicBaseDepth        ()                        { return  m_apcRefPicBaseDepth; }
    1503   Void         setRefPicBaseDepth        ( TComPic* RefPic)        { m_apcRefPicBaseDepth = RefPic; }
    1504 #if MERL_VSP_NBDV_RefVId_Fix_D0166
    1505   Void setBWVSPLUTParam( Int *pShiftLUT, Int iLoG2LUTPrec, Int iNeighborViewId) { m_aiShiftLUT[iNeighborViewId] = pShiftLUT; m_iShiftPrec = iLoG2LUTPrec; }
    1506   Void getBWVSPLUTParam( Int*&pShiftLUT, Int&iLoG2LUTPrec, Int iNeighborViewId) { pShiftLUT = m_aiShiftLUT[iNeighborViewId]; iLoG2LUTPrec = m_iShiftPrec; }
    1507 #else
    1508   Void setBWVSPLUTParam( Int *pShiftLUT, Int iLoG2LUTPrec) { m_aiShiftLUT = pShiftLUT; m_iShiftPrec = iLoG2LUTPrec; }
    1509   Void getBWVSPLUTParam( Int*&pShiftLUT, Int&iLoG2LUTPrec) { pShiftLUT = m_aiShiftLUT; iLoG2LUTPrec = m_iShiftPrec; }
    1510 #endif
    1511 #endif
    1512 
    1513 #if MERL_VSP_NBDV_RefVId_Fix_D0166
    1514   Void setListDepthPic( TComList<TComPic*>* pListDepthPic, Int viewId) { m_pcListDepthPic[viewId] = pListDepthPic; }
    1515   TComList<TComPic*>* getListDepthPic(Int viewId) { return m_pcListDepthPic[viewId]; }
    1516   TComPic*            getDepthRefPic(Int viewId, Int poc);
    1517   TComPic*            getDepthRefPic(Int refIdx);
    1518 #endif
    1519 
     1856#endif
     1857#endif
     1858#if H_3D
     1859  Void    setIvPicLists( TComPicLists* m_ivPicLists );
     1860  Void    setDepthToDisparityLUTs();
     1861
     1862  Int* getDepthToDisparityB( Int refViewIdx ) { return m_depthToDisparityB[ refViewIdx ]; };
     1863  Int* getDepthToDisparityF( Int refViewIdx ) { return m_depthToDisparityF[ refViewIdx ]; };
     1864  Bool getVpsDepthModesFlag  ()  { return getVPS()->getVpsDepthModesFlag( getVPS()->getLayerIdInVps( m_layerId ) ); }
     1865
     1866#endif
     1867#if H_MV
     1868// Additional slice header syntax elements
     1869Void setDiscardableFlag( Bool flag ) { m_discardableFlag = flag; }
     1870Bool getDiscardableFlag(  ) { return m_discardableFlag; }
     1871
     1872Void setInterLayerPredEnabledFlag( Bool flag ) { m_interLayerPredEnabledFlag = flag; }
     1873Bool getInterLayerPredEnabledFlag(  ) { return m_interLayerPredEnabledFlag; }
     1874
     1875Void setNumInterLayerRefPicsMinus1( Int  val ) { m_numInterLayerRefPicsMinus1 = val; }
     1876Int  getNumInterLayerRefPicsMinus1(  ) { return m_numInterLayerRefPicsMinus1; }
     1877
     1878Void setInterLayerPredLayerIdc( Int i, Int  val ) { m_interLayerPredLayerIdc[i] = val; }
     1879Int  getInterLayerPredLayerIdc( Int i ) { return m_interLayerPredLayerIdc[i]; }
     1880
     1881Void setInterLayerSamplePredOnlyFlag( Bool flag ) { m_interLayerSamplePredOnlyFlag = flag; }
     1882Bool getInterLayerSamplePredOnlyFlag(  ) { return m_interLayerSamplePredOnlyFlag; }
     1883
     1884Void setAltCollocatedIndicationFlag( Bool flag ) { m_altCollocatedIndicationFlag = flag; }
     1885Bool getAltCollocatedIndicationFlag(  ) { return m_altCollocatedIndicationFlag; }
     1886
     1887Void setCollocatedRefLayerIdx( Int  val ) { m_collocatedRefLayerIdx = val; }
     1888Int  getCollocatedRefLayerIdx(  ) { return m_collocatedRefLayerIdx; }
     1889
     1890// Additional variables derived in slice header semantics
     1891Int  getNumInterLayerRefPicsMinus1Len( ) { return xCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerIdInVps() )); }
     1892Int  getInterLayerPredLayerIdcLen    ( ) { return xCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerIdInVps() )); }
     1893
     1894Int  getNumActiveRefLayerPics( );
     1895Int  getRefPicLayerId               ( Int i );
     1896
     1897Void setActiveMotionPredRefLayers   ( );
     1898
     1899Int  getNumActiveMotionPredRefLayers(  )      { return m_numActiveMotionPredRefLayers; }
     1900Int  getActiveMotionPredRefLayerId  ( Int i ) { return m_activeMotionPredRefLayerId[i]; }
     1901
     1902Bool getInterRefEnabledInRPLFlag( );
     1903
     1904Void     setRefPicSetInterLayer       ( std::vector<TComPic*>* m_refPicSetInterLayer );
     1905TComPic* getPicFromRefPicSetInterLayer( Int layerId );
     1906
     1907#endif
    15201908protected:
    1521   TComPic*  xGetRefPic        (TComList<TComPic*>& rcListPic, UInt uiPOC);
    1522   TComPic*  xGetLongTermRefPic(TComList<TComPic*>& rcListPic, UInt uiPOC);
    1523   TComPic*  xGetInterViewRefPic( std::vector<TComPic*>& rcListIvPic, UInt uiViewId );
     1909  TComPic*  xGetRefPic  (TComList<TComPic*>& rcListPic,
     1910                         Int                 poc);
     1911TComPic*  xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
     1912#if H_MV
     1913  Int       xCeilLog2( Int val );
     1914  TComPic*  xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId ); 
     1915#endif
    15241916};// END CLASS DEFINITION TComSlice
    15251917
     
    15701962  }
    15711963
    1572 #if QC_MVHEVC_B0046
    1573   Void clearPSList()
    1574   {
    1575     m_paramsetMap.clear();
    1576   }
    1577 #endif
    15781964private:
    15791965  std::map<Int,T *> m_paramsetMap;
     
    15861972  ParameterSetManager();
    15871973  virtual ~ParameterSetManager();
    1588 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
    1589   //! store video parameter set and take ownership of it
     1974
     1975  //! store sequence parameter set and take ownership of it
    15901976  Void storeVPS(TComVPS *vps) { m_vpsMap.storePS( vps->getVPSId(), vps); };
    15911977  //! get pointer to existing video parameter set 
    15921978  TComVPS* getVPS(Int vpsId)  { return m_vpsMap.getPS(vpsId); };
    15931979  TComVPS* getFirstVPS()      { return m_vpsMap.getFirstPS(); };
    1594 #if QC_MVHEVC_B0046
    1595   Void     clearVPS()         { m_vpsMap.clearPSList(); };
    1596   Void     clearSPS()         { m_spsMap.clearPSList(); };
    1597   Void     clearPPS()         { m_ppsMap.clearPSList(); };
    1598 #endif
    1599 #endif
     1980 
    16001981  //! store sequence parameter set and take ownership of it
    16011982  Void storeSPS(TComSPS *sps) { m_spsMap.storePS( sps->getSPSId(), sps); };
     
    16101991  TComPPS* getFirstPPS()      { return m_ppsMap.getFirstPS(); };
    16111992
    1612   //! store adaptation parameter set and take ownership of it
    1613   Void storeAPS(TComAPS *aps) { m_apsMap.storePS( aps->getAPSID(), aps); };
    1614   //! getPointer to existing adaptation parameter set 
    1615   TComAPS* getAPS(Int apsId)  { return m_apsMap.getPS(apsId); };
     1993  //! activate a SPS from a active parameter sets SEI message
     1994  //! \returns true, if activation is successful
     1995  Bool activateSPSWithSEI(Int SPSId);
     1996
     1997  //! activate a PPS and depending on isIDR parameter also SPS and VPS
     1998  //! \returns true, if activation is successful
     1999  Bool activatePPS(Int ppsId, Bool isIRAP);
     2000
     2001  TComVPS* getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); };
     2002  TComSPS* getActiveSPS(){ return m_spsMap.getPS(m_activeSPSId); };
     2003  TComPPS* getActivePPS(){ return m_ppsMap.getPS(m_activePPSId); };
    16162004
    16172005protected:
     2006 
     2007  ParameterSetMap<TComVPS> m_vpsMap;
    16182008  ParameterSetMap<TComSPS> m_spsMap;
    1619   ParameterSetMap<TComPPS> m_ppsMap; 
    1620   ParameterSetMap<TComAPS> m_apsMap;
    1621 #if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
    1622   ParameterSetMap<TComVPS> m_vpsMap;
    1623 #endif
     2009  ParameterSetMap<TComPPS> m_ppsMap;
     2010
     2011  Int m_activeVPSId;
     2012  Int m_activeSPSId;
     2013  Int m_activePPSId;
    16242014};
    16252015
Note: See TracChangeset for help on using the changeset viewer.