Newer
Older
Karsten Suehring
committed
void setQpBDOffset(ChannelType type, int i) { m_qpBDOffset[type] = i; }
int getMinQpPrimeTsMinus4(ChannelType type) const { return m_minQpMinus4[type]; }
void setMinQpPrimeTsMinus4(ChannelType type, int i) { m_minQpMinus4[type] = i; }
Karsten Suehring
committed
void setSAOEnabledFlag(bool bVal) { m_saoEnabledFlag = bVal; }
bool getSAOEnabledFlag() const { return m_saoEnabledFlag; }
bool getALFEnabledFlag() const { return m_alfEnabledFlag; }
void setALFEnabledFlag( bool b ) { m_alfEnabledFlag = b; }
void setJointCbCrEnabledFlag(bool bVal) { m_JointCbCrEnabledFlag = bVal; }
bool getJointCbCrEnabledFlag() const { return m_JointCbCrEnabledFlag; }
bool getSBTMVPEnabledFlag() const { return m_sbtmvpEnabledFlag; }
void setSBTMVPEnabledFlag(bool b) { m_sbtmvpEnabledFlag = b; }
void setBDOFEnabledFlag(bool b) { m_bdofEnabledFlag = b; }
bool getBDOFEnabledFlag() const { return m_bdofEnabledFlag; }
bool getFpelMmvdEnabledFlag() const { return m_fpelMmvdEnabledFlag; }
void setFpelMmvdEnabledFlag( bool b ) { m_fpelMmvdEnabledFlag = b; }
bool getUseDMVR()const { return m_DMVR; }
void setUseDMVR(bool b) { m_DMVR = b; }
bool getUseMMVD()const { return m_MMVD; }
void setUseMMVD(bool b) { m_MMVD = b; }
bool getBdofDmvrSlicePresentFlag()const { return m_BdofDmvrSlicePresentFlag; }
void setBdofDmvrSlicePresentFlag(bool b) { m_BdofDmvrSlicePresentFlag = b; }
uint32_t getMaxTLayers() const { return m_uiMaxTLayers; }
void setMaxTLayers( uint32_t uiMaxTLayers ) { CHECK( uiMaxTLayers > MAX_TLAYER, "Invalid number T-layers" ); m_uiMaxTLayers = uiMaxTLayers; }
Karsten Suehring
committed
bool getTemporalIdNestingFlag() const { return m_bTemporalIdNestingFlag; }
void setTemporalIdNestingFlag( bool bValue ) { m_bTemporalIdNestingFlag = bValue; }
bool getScalingListFlag() const { return m_scalingListEnabledFlag; }
void setScalingListFlag( bool b ) { m_scalingListEnabledFlag = b; }
uint32_t getMaxDecPicBuffering(uint32_t tlayer) const { return m_uiMaxDecPicBuffering[tlayer]; }
void setMaxDecPicBuffering( uint32_t ui, uint32_t tlayer ) { CHECK(tlayer >= MAX_TLAYER, "Invalid T-layer"); m_uiMaxDecPicBuffering[tlayer] = ui; }
uint32_t getMaxLatencyIncreasePlus1(uint32_t tlayer) const { return m_uiMaxLatencyIncreasePlus1[tlayer]; }
void setMaxLatencyIncreasePlus1( uint32_t ui , uint32_t tlayer) { m_uiMaxLatencyIncreasePlus1[tlayer] = ui; }
void setAffineAmvrEnabledFlag( bool val ) { m_affineAmvrEnabledFlag = val; }
bool getAffineAmvrEnabledFlag() const { return m_affineAmvrEnabledFlag; }
TimingInfo* getTimingInfo() { return &m_timingInfo; }
const TimingInfo* getTimingInfo() const { return &m_timingInfo; }
bool getHrdParametersPresentFlag() const { return m_hrdParametersPresentFlag; }
void setHrdParametersPresentFlag(bool b) { m_hrdParametersPresentFlag = b; }
HRDParameters* getHrdParameters() { return &m_hrdParameters; }
const HRDParameters* getHrdParameters() const { return &m_hrdParameters; }
Karsten Suehring
committed
bool getVuiParametersPresentFlag() const { return m_vuiParametersPresentFlag; }
void setVuiParametersPresentFlag(bool b) { m_vuiParametersPresentFlag = b; }
VUI* getVuiParameters() { return &m_vuiParameters; }
const VUI* getVuiParameters() const { return &m_vuiParameters; }
const ProfileTierLevel* getProfileTierLevel() const { return &m_profileTierLevel; }
ProfileTierLevel* getProfileTierLevel() { return &m_profileTierLevel; }
Karsten Suehring
committed
const SPSRExt& getSpsRangeExtension() const { return m_spsRangeExtension; }
SPSRExt& getSpsRangeExtension() { return m_spsRangeExtension; }
void setWrapAroundEnabledFlag(bool b) { m_wrapAroundEnabledFlag = b; }
bool getWrapAroundEnabledFlag() const { return m_wrapAroundEnabledFlag; }
void setWrapAroundOffset(unsigned offset) { m_wrapAroundOffset = offset; }
unsigned getWrapAroundOffset() const { return m_wrapAroundOffset; }
void setUseReshaper(bool b) { m_lumaReshapeEnable = b; }
bool getUseReshaper() const { return m_lumaReshapeEnable; }
void setIBCFlag(unsigned IBCFlag) { m_IBCFlag = IBCFlag; }
unsigned getIBCFlag() const { return m_IBCFlag; }
void setPLTMode(unsigned PLTMode) { m_PLTMode = PLTMode; }
unsigned getPLTMode() const { return m_PLTMode; }
Yin Zhao
committed
void setUseSBT( bool b ) { m_SBT = b; }
bool getUseSBT() const { return m_SBT; }
void setUseISP( bool b ) { m_ISP = b; }
bool getUseISP() const { return m_ISP; }
Yin Zhao
committed
void setMaxSbtSize( uint8_t val ) { m_MaxSbtSize = val; }
uint8_t getMaxSbtSize() const { return m_MaxSbtSize; }
void setAMVREnabledFlag ( bool b ) { m_AMVREnabledFlag = b; }
bool getAMVREnabledFlag () const { return m_AMVREnabledFlag; }
void setUseAffine ( bool b ) { m_Affine = b; }
bool getUseAffine () const { return m_Affine; }
void setUseAffineType ( bool b ) { m_AffineType = b; }
bool getUseAffineType () const { return m_AffineType; }
void setUsePROF ( bool b ) { m_PROF = b; }
bool getUsePROF () const { return m_PROF; }
void setUseLMChroma ( bool b ) { m_LMChroma = b; }
bool getUseLMChroma () const { return m_LMChroma; }
void setCclmCollocatedChromaFlag( bool b ) { m_cclmCollocatedChromaFlag = b; }
bool getCclmCollocatedChromaFlag() const { return m_cclmCollocatedChromaFlag; }
void setUseMTS ( bool b ) { m_MTS = b; }
bool getUseMTS () const { return m_MTS; }
Xin Zhao
committed
bool getUseImplicitMTS () const { return m_MTS && !m_IntraMTS; }
void setUseIntraMTS ( bool b ) { m_IntraMTS = b; }
bool getUseIntraMTS () const { return m_IntraMTS; }
void setUseInterMTS ( bool b ) { m_InterMTS = b; }
bool getUseInterMTS () const { return m_InterMTS; }
void setUseLFNST ( bool b ) { m_LFNST = b; }
bool getUseLFNST () const { return m_LFNST; }
void setUseSMVD(bool b) { m_SMVD = b; }
bool getUseSMVD() const { return m_SMVD; }
void setUseGBi ( bool b ) { m_GBi = b; }
bool getUseGBi () const { return m_GBi; }
#if LUMA_ADAPTIVE_DEBLOCKING_FILTER_QP_OFFSET
void setLadfEnabled ( bool b ) { m_LadfEnabled = b; }
bool getLadfEnabled () const { return m_LadfEnabled; }
void setLadfNumIntervals ( int i ) { m_LadfNumIntervals = i; }
int getLadfNumIntervals () const { return m_LadfNumIntervals; }
void setLadfQpOffset ( int value, int idx ) { m_LadfQpOffset[ idx ] = value; }
int getLadfQpOffset ( int idx ) const { return m_LadfQpOffset[ idx ]; }
void setLadfIntervalLowerBound( int value, int idx ) { m_LadfIntervalLowerBound[ idx ] = value; }
int getLadfIntervalLowerBound( int idx ) const { return m_LadfIntervalLowerBound[ idx ]; }
#endif
void setUseMHIntra ( bool b ) { m_MHIntra = b; }
bool getUseMHIntra () const { return m_MHIntra; }
void setUseTriangle ( bool b ) { m_Triangle = b; }
bool getUseTriangle () const { return m_Triangle; }
void setUseMIP ( bool b ) { m_MIP = b; }
bool getUseMIP () const { return m_MIP; }
bool getUseWP () const { return m_useWeightPred; }
bool getUseWPBiPred () const { return m_useWeightedBiPred; }
void setUseWP ( bool b ) { m_useWeightPred = b; }
void setUseWPBiPred ( bool b ) { m_useWeightedBiPred = b; }
void setChromaQpMappingTableFromParams(const ChromaQpMappingTableParams ¶ms, const int qpBdOffset) { m_chromaQpMappingTable.setParams(params, qpBdOffset); }
void derivedChromaQPMappingTables() { m_chromaQpMappingTable.derivedChromaQPMappingTables(); }
const ChromaQpMappingTable& getChromaQpMappingTable() const { return m_chromaQpMappingTable;}
int getMappedChromaQpValue(ComponentID compID, int qpVal) const { return m_chromaQpMappingTable.getMappedChromaQpValue(compID, qpVal); }
void setGDREnabledFlag(bool flag) { m_GDREnabledFlag = flag; }
bool getGDREnabledFlag() const { return m_GDREnabledFlag; }
void setSubLayerParametersPresentFlag(bool flag) { m_SubLayerCbpParametersPresentFlag = flag; }
bool getSubLayerParametersPresentFlag() const { return m_SubLayerCbpParametersPresentFlag; }
Karsten Suehring
committed
};
/// Reference Picture Lists class
/// PPS RExt class
class PPSRExt // Names aligned to text specification
{
private:
bool m_crossComponentPredictionEnabledFlag;
uint32_t m_log2SaoOffsetScale[MAX_NUM_CHANNEL_TYPE];
public:
PPSRExt();
bool settingsDifferFromDefaults(const bool bTransformSkipEnabledFlag) const
{
Remy Foray
committed
return (getCrossComponentPredictionEnabledFlag() )
Karsten Suehring
committed
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
|| (getLog2SaoOffsetScale(CHANNEL_TYPE_LUMA) !=0 )
|| (getLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA) !=0 );
}
bool getCrossComponentPredictionEnabledFlag() const { return m_crossComponentPredictionEnabledFlag; }
void setCrossComponentPredictionEnabledFlag(bool value) { m_crossComponentPredictionEnabledFlag = value; }
// Now: getPpsRangeExtension().getLog2SaoOffsetScale and getPpsRangeExtension().setLog2SaoOffsetScale
uint32_t getLog2SaoOffsetScale(ChannelType type) const { return m_log2SaoOffsetScale[type]; }
void setLog2SaoOffsetScale(ChannelType type, uint32_t uiBitShift) { m_log2SaoOffsetScale[type] = uiBitShift; }
};
/// PPS class
class PPS
{
private:
int m_PPSId; // pic_parameter_set_id
int m_SPSId; // seq_parameter_set_id
int m_picInitQPMinus26;
bool m_useDQP;
bool m_bConstrainedIntraPred; // constrained_intra_pred_flag
bool m_bSliceChromaQpFlag; // slicelevel_chroma_qp_flag
Vadim Seregin
committed
int m_layerId;
int m_temporalId;
Karsten Suehring
committed
// access channel
uint32_t m_cuQpDeltaSubdiv; // cu_qp_delta_subdiv
Karsten Suehring
committed
int m_chromaCbQpOffset;
int m_chromaCrQpOffset;
#if JVET_P0667_QP_OFFSET_TABLE_SIGNALING_JCCR
bool m_chromaJointCbCrQpOffsetPresentFlag;
#endif
Karsten Suehring
committed
// Chroma QP Adjustments
int m_cuChromaQpOffsetSubdiv;
int m_chromaQpOffsetListLen; // size (excludes the null entry used in the following array).
ChromaQpAdj m_ChromaQpAdjTableIncludingNullEntry[1+MAX_QP_OFFSET_LIST_SIZE]; //!< Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
Karsten Suehring
committed
uint32_t m_numRefIdxL0DefaultActive;
uint32_t m_numRefIdxL1DefaultActive;
Karsten Suehring
committed
bool m_bUseWeightPred; //!< Use of Weighting Prediction (P_SLICE)
bool m_useWeightedBiPred; //!< Use of Weighting Bi-Prediction (B_SLICE)
bool m_OutputFlagPresentFlag; //!< Indicates the presence of output_flag in slice header
bool m_TransquantBypassEnabledFlag; //!< Indicates presence of cu_transquant_bypass_flag in CUs.
int m_log2MaxTransformSkipBlockSize;
Karsten Suehring
committed
bool m_entropyCodingSyncEnabledFlag; //!< Indicates the presence of wavefronts
bool m_loopFilterAcrossBricksEnabledFlag;
bool m_uniformTileSpacingFlag;
Karsten Suehring
committed
int m_numTileColumnsMinus1;
int m_numTileRowsMinus1;
std::vector<int> m_tileColumnWidth;
std::vector<int> m_tileRowHeight;
std::vector<int> m_tileHeight;
Karsten Suehring
committed
bool m_singleTileInPicFlag;
int m_tileColsWidthMinus1;
int m_tileRowsHeightMinus1;
bool m_brickSplittingPresentFlag;
std::vector<bool> m_brickSplitFlag;
std::vector<bool> m_uniformBrickSpacingFlag;
std::vector<int> m_brickHeightMinus1;
std::vector<int> m_numBrickRowsMinus2;
std::vector<std::vector<int>> m_brickRowHeightMinus1;
bool m_singleBrickPerSliceFlag;
bool m_rectSliceFlag;
int m_numSlicesInPicMinus1;
std::vector<int> m_topLeftBrickIdx;
std::vector<int> m_bottomRightBrickIdx;
std::vector<int> m_bottomRightBrickIdxDelta;
int m_numTilesInPic;
int m_numBricksInPic;
bool m_signalledSliceIdFlag;
int m_signalledSliceIdLengthMinus1;
std::vector<int> m_sliceId;
bool m_constantSliceHeaderParamsEnabledFlag;
int m_PPSDepQuantEnabledIdc;
int m_PPSRefPicListSPSIdc0;
int m_PPSRefPicListSPSIdc1;
int m_PPSTemporalMVPEnabledIdc;
int m_PPSMvdL1ZeroIdc;
int m_PPSCollocatedFromL0Idc;
uint32_t m_PPSSixMinusMaxNumMergeCandPlus1;
uint32_t m_PPSFiveMinusMaxNumSubblockMergeCandPlus1;
uint32_t m_PPSMaxNumMergeCandMinusMaxNumTriangleCandPlus1;
Karsten Suehring
committed
bool m_cabacInitPresentFlag;
bool m_sliceHeaderExtensionPresentFlag;
bool m_loopFilterAcrossSlicesEnabledFlag;
bool m_deblockingFilterControlPresentFlag;
bool m_deblockingFilterOverrideEnabledFlag;
bool m_ppsDeblockingFilterDisabledFlag;
int m_deblockingFilterBetaOffsetDiv2; //< beta offset for deblocking filter
int m_deblockingFilterTcOffsetDiv2; //< tc offset for deblocking filter
bool m_listsModificationPresentFlag;
uint32_t m_log2ParallelMergeLevelMinus2;
int m_numExtraSliceHeaderBits;
Sheng-Yen Lin
committed
bool m_loopFilterAcrossVirtualBoundariesDisabledFlag;
unsigned m_numVerVirtualBoundaries;
unsigned m_numHorVirtualBoundaries;
unsigned m_virtualBoundariesPosX[3];
unsigned m_virtualBoundariesPosY[3];
uint32_t m_picWidthInLumaSamples;
uint32_t m_picHeightInLumaSamples;
Window m_conformanceWindow;
Karsten Suehring
committed
PPSRExt m_ppsRangeExtension;
public:
PreCalcValues *pcv;
public:
PPS();
virtual ~PPS();
int getPPSId() const { return m_PPSId; }
void setPPSId(int i) { m_PPSId = i; }
int getSPSId() const { return m_SPSId; }
void setSPSId(int i) { m_SPSId = i; }
Vadim Seregin
committed
void setTemporalId( int i ) { m_temporalId = i; }
int getTemporalId() const { return m_temporalId; }
void setLayerId( int i ) { m_layerId = i; }
int getLayerId() const { return m_layerId; }
Karsten Suehring
committed
int getPicInitQPMinus26() const { return m_picInitQPMinus26; }
void setPicInitQPMinus26( int i ) { m_picInitQPMinus26 = i; }
bool getUseDQP() const { return m_useDQP; }
void setUseDQP( bool b ) { m_useDQP = b; }
bool getConstrainedIntraPred() const { return m_bConstrainedIntraPred; }
void setConstrainedIntraPred( bool b ) { m_bConstrainedIntraPred = b; }
bool getSliceChromaQpFlag() const { return m_bSliceChromaQpFlag; }
void setSliceChromaQpFlag( bool b ) { m_bSliceChromaQpFlag = b; }
void setCuQpDeltaSubdiv( uint32_t u ) { m_cuQpDeltaSubdiv = u; }
uint32_t getCuQpDeltaSubdiv() const { return m_cuQpDeltaSubdiv; }
Karsten Suehring
committed
#if JVET_P0667_QP_OFFSET_TABLE_SIGNALING_JCCR
bool getJointCbCrQpOffsetPresentFlag() const { return m_chromaJointCbCrQpOffsetPresentFlag; }
void setJointCbCrQpOffsetPresentFlag(bool b) { m_chromaJointCbCrQpOffsetPresentFlag = b; }
#endif
Karsten Suehring
committed
void setQpOffset(ComponentID compID, int i )
{
if (compID==COMPONENT_Cb)
{
m_chromaCbQpOffset = i;
}
else if (compID==COMPONENT_Cr)
{
m_chromaCrQpOffset = i;
}
else if (compID==JOINT_CbCr)
{
m_chromaCbCrQpOffset = i;
}
Karsten Suehring
committed
else
{
THROW( "Invalid chroma QP offset" );
}
}
int getQpOffset(ComponentID compID) const
{
return (compID==COMPONENT_Y) ? 0 : (compID==COMPONENT_Cb ? m_chromaCbQpOffset : compID==COMPONENT_Cr ? m_chromaCrQpOffset : m_chromaCbCrQpOffset );
Karsten Suehring
committed
}
uint32_t getCuChromaQpOffsetSubdiv () const { return m_cuChromaQpOffsetSubdiv; }
void setCuChromaQpOffsetSubdiv ( uint32_t u ) { m_cuChromaQpOffsetSubdiv = u; }
bool getCuChromaQpOffsetEnabledFlag() const { return getChromaQpOffsetListLen()>0; }
int getChromaQpOffsetListLen() const { return m_chromaQpOffsetListLen; }
void clearChromaQpOffsetList() { m_chromaQpOffsetListLen = 0; }
const ChromaQpAdj& getChromaQpOffsetListEntry( int cuChromaQpOffsetIdxPlus1 ) const
{
CHECK(cuChromaQpOffsetIdxPlus1 >= m_chromaQpOffsetListLen+1, "Invalid chroma QP offset");
return m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1]; // Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
}
void setChromaQpOffsetListEntry( int cuChromaQpOffsetIdxPlus1, int cbOffset, int crOffset, int jointCbCrOffset )
{
CHECK(cuChromaQpOffsetIdxPlus1 == 0 || cuChromaQpOffsetIdxPlus1 > MAX_QP_OFFSET_LIST_SIZE, "Invalid chroma QP offset");
m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1].u.comp.CbOffset = cbOffset; // Array includes entry [0] for the null offset used when cu_chroma_qp_offset_flag=0, and entries [cu_chroma_qp_offset_idx+1...] otherwise
m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1].u.comp.CrOffset = crOffset;
m_ChromaQpAdjTableIncludingNullEntry[cuChromaQpOffsetIdxPlus1].u.comp.JointCbCrOffset = jointCbCrOffset;
m_chromaQpOffsetListLen = std::max(m_chromaQpOffsetListLen, cuChromaQpOffsetIdxPlus1);
}
Karsten Suehring
committed
void setNumRefIdxL0DefaultActive(uint32_t ui) { m_numRefIdxL0DefaultActive=ui; }
uint32_t getNumRefIdxL0DefaultActive() const { return m_numRefIdxL0DefaultActive; }
void setNumRefIdxL1DefaultActive(uint32_t ui) { m_numRefIdxL1DefaultActive=ui; }
uint32_t getNumRefIdxL1DefaultActive() const { return m_numRefIdxL1DefaultActive; }
void setRpl1IdxPresentFlag(bool isPresent) { m_rpl1IdxPresentFlag = isPresent; }
uint32_t getRpl1IdxPresentFlag() const { return m_rpl1IdxPresentFlag; }
Karsten Suehring
committed
bool getUseWP() const { return m_bUseWeightPred; }
bool getWPBiPred() const { return m_useWeightedBiPred; }
void setUseWP( bool b ) { m_bUseWeightPred = b; }
void setWPBiPred( bool b ) { m_useWeightedBiPred = b; }
void setOutputFlagPresentFlag( bool b ) { m_OutputFlagPresentFlag = b; }
bool getOutputFlagPresentFlag() const { return m_OutputFlagPresentFlag; }
void setTransquantBypassEnabledFlag( bool b ) { m_TransquantBypassEnabledFlag = b; }
bool getTransquantBypassEnabledFlag() const { return m_TransquantBypassEnabledFlag; }
uint32_t getLog2MaxTransformSkipBlockSize() const { return m_log2MaxTransformSkipBlockSize; }
void setLog2MaxTransformSkipBlockSize(uint32_t u) { m_log2MaxTransformSkipBlockSize = u; }
Karsten Suehring
committed
void setLoopFilterAcrossBricksEnabledFlag(bool b) { m_loopFilterAcrossBricksEnabledFlag = b; }
bool getLoopFilterAcrossBricksEnabledFlag() const { return m_loopFilterAcrossBricksEnabledFlag; }
Karsten Suehring
committed
bool getEntropyCodingSyncEnabledFlag() const { return m_entropyCodingSyncEnabledFlag; }
void setEntropyCodingSyncEnabledFlag(bool val) { m_entropyCodingSyncEnabledFlag = val; }
void setUniformTileSpacingFlag(bool b) { m_uniformTileSpacingFlag = b; }
bool getUniformTileSpacingFlag() const { return m_uniformTileSpacingFlag; }
Karsten Suehring
committed
void setNumTileColumnsMinus1(int i) { m_numTileColumnsMinus1 = i; }
int getNumTileColumnsMinus1() const { return m_numTileColumnsMinus1; }
void setTileColumnWidth(const std::vector<int>& columnWidth ) { m_tileColumnWidth = columnWidth; }
uint32_t getTileColumnWidth(uint32_t columnIdx) const { return m_tileColumnWidth[columnIdx]; }
Karsten Suehring
committed
void setNumTileRowsMinus1(int i) { m_numTileRowsMinus1 = i; }
int getNumTileRowsMinus1() const { return m_numTileRowsMinus1; }
void setTileRowHeight(const std::vector<int>& rowHeight) { m_tileRowHeight = rowHeight; }
uint32_t getTileRowHeight(uint32_t rowIdx) const { return m_tileRowHeight[rowIdx]; }
void setTileHeight(const std::vector<int>& tileHeight) { m_tileHeight = tileHeight; }
uint32_t getTileHeight(uint32_t tileIdx) const { return m_tileHeight[tileIdx]; }
bool getSingleTileInPicFlag() const { return m_singleTileInPicFlag; }
void setSingleTileInPicFlag(bool val) { m_singleTileInPicFlag = val; }
int getTileColsWidthMinus1() const { return m_tileColsWidthMinus1; }
void setTileColsWidthMinus1(int w) { m_tileColsWidthMinus1 = w; }
int getTileRowsHeightMinus1() const { return m_tileRowsHeightMinus1; }
void setTileRowsHeightMinus1(int h) { m_tileRowsHeightMinus1 = h; }
bool getBrickSplittingPresentFlag() const { return m_brickSplittingPresentFlag; }
void setBrickSplittingPresentFlag(bool b) { m_brickSplittingPresentFlag = b; }
bool getBrickSplitFlag(int i) const { return m_brickSplitFlag[i]; }
void setBrickSplitFlag(std::vector<bool>& val) { m_brickSplitFlag = val; }
bool getUniformBrickSpacingFlag(int i) const { return m_uniformBrickSpacingFlag[i]; }
void setUniformBrickSpacingFlag(std::vector<bool>& val) { m_uniformBrickSpacingFlag = val; }
int getBrickHeightMinus1(int i) const { return m_brickHeightMinus1[i]; }
void setBrickHeightMinus1(std::vector<int>& val) { m_brickHeightMinus1 = val; }
int getNumBrickRowsMinus2(int i) const { return m_numBrickRowsMinus2[i]; }
void setNumBrickRowsMinus2(std::vector<int> &val) { m_numBrickRowsMinus2 = val; }
int getBrickRowHeightMinus1(int i, int j) const { return m_brickRowHeightMinus1[i][j]; }
void setBrickRowHeightMinus1(std::vector<std::vector<int>>& val) { m_brickRowHeightMinus1 = val; }
bool getSingleBrickPerSliceFlag() const { return m_singleBrickPerSliceFlag; }
void setSingleBrickPerSliceFlag(bool val) { m_singleBrickPerSliceFlag = val; }
bool getRectSliceFlag() const { return m_rectSliceFlag; }
void setRectSliceFlag(bool val) { m_rectSliceFlag = val; }
int getNumSlicesInPicMinus1() const { return m_numSlicesInPicMinus1; }
void setNumSlicesInPicMinus1(int val) { m_numSlicesInPicMinus1 = val; }
int getTopLeftBrickIdx(uint32_t columnIdx) const { return m_topLeftBrickIdx[columnIdx]; }
void setTopLeftBrickIdx(const std::vector<int>& val) { m_topLeftBrickIdx = val; }
int getBottomRightBrickIdx(uint32_t columnIdx) const { return m_bottomRightBrickIdx[columnIdx]; }
void setBottomRightBrickIdx(const std::vector<int>& val) { m_bottomRightBrickIdx = val; }
int getBottomRightBrickIdxDelta(uint32_t delta) const { return m_bottomRightBrickIdxDelta[delta]; }
void setBottomRightBrickIdxDelta(const std::vector<int>& val) { m_bottomRightBrickIdxDelta = val; }
int getNumTilesInPic() const { return m_numTilesInPic; }
void setNumTilesInPic(int val) { m_numTilesInPic = val; }
int getNumBricksInPic() const { return m_numBricksInPic; }
void setNumBricksInPic(int val) { m_numBricksInPic = val; }
bool getSignalledSliceIdFlag() const { return m_signalledSliceIdFlag; }
void setSignalledSliceIdFlag(bool val) { m_signalledSliceIdFlag = val; }
int getSignalledSliceIdLengthMinus1() const { return m_signalledSliceIdLengthMinus1; }
void setSignalledSliceIdLengthMinus1(int val) { m_signalledSliceIdLengthMinus1 = val; }
int getSliceId(uint32_t columnIdx) const { return m_sliceId[columnIdx]; }
void setSliceId(const std::vector<int>& val) { m_sliceId = val; }
Karsten Suehring
committed
bool getConstantSliceHeaderParamsEnabledFlag() const { return m_constantSliceHeaderParamsEnabledFlag; }
void setConstantSliceHeaderParamsEnabledFlag(bool b) { m_constantSliceHeaderParamsEnabledFlag = b; }
int getPPSDepQuantEnabledIdc() const { return m_PPSDepQuantEnabledIdc; }
void setPPSDepQuantEnabledIdc(int u) { m_PPSDepQuantEnabledIdc = u; }
int getPPSRefPicListSPSIdc0() const { return m_PPSRefPicListSPSIdc0; }
void setPPSRefPicListSPSIdc0(int u) { m_PPSRefPicListSPSIdc0 = u; }
int getPPSRefPicListSPSIdc1() const { return m_PPSRefPicListSPSIdc1; }
void setPPSRefPicListSPSIdc1(int u) { m_PPSRefPicListSPSIdc1 = u; }
int getPPSTemporalMVPEnabledIdc() const { return m_PPSTemporalMVPEnabledIdc; }
void setPPSTemporalMVPEnabledIdc(int u) { m_PPSTemporalMVPEnabledIdc = u; }
int getPPSMvdL1ZeroIdc() const { return m_PPSMvdL1ZeroIdc; }
void setPPSMvdL1ZeroIdc(int u) { m_PPSMvdL1ZeroIdc = u; }
int getPPSCollocatedFromL0Idc() const { return m_PPSCollocatedFromL0Idc; }
void setPPSCollocatedFromL0Idc(int u) { m_PPSCollocatedFromL0Idc = u; }
uint32_t getPPSSixMinusMaxNumMergeCandPlus1() const { return m_PPSSixMinusMaxNumMergeCandPlus1; }
void setPPSSixMinusMaxNumMergeCandPlus1(uint32_t u) { m_PPSSixMinusMaxNumMergeCandPlus1 = u; }
uint32_t getPPSFiveMinusMaxNumSubblockMergeCandPlus1() const { return m_PPSFiveMinusMaxNumSubblockMergeCandPlus1; }
void setPPSFiveMinusMaxNumSubblockMergeCandPlus1(uint32_t u) { m_PPSFiveMinusMaxNumSubblockMergeCandPlus1 = u; }
uint32_t getPPSMaxNumMergeCandMinusMaxNumTriangleCandPlus1() const { return m_PPSMaxNumMergeCandMinusMaxNumTriangleCandPlus1; }
void setPPSMaxNumMergeCandMinusMaxNumTriangleCandPlus1(uint32_t u) { m_PPSMaxNumMergeCandMinusMaxNumTriangleCandPlus1 = u; }
Karsten Suehring
committed
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
void setCabacInitPresentFlag( bool flag ) { m_cabacInitPresentFlag = flag; }
bool getCabacInitPresentFlag() const { return m_cabacInitPresentFlag; }
void setDeblockingFilterControlPresentFlag( bool val ) { m_deblockingFilterControlPresentFlag = val; }
bool getDeblockingFilterControlPresentFlag() const { return m_deblockingFilterControlPresentFlag; }
void setDeblockingFilterOverrideEnabledFlag( bool val ) { m_deblockingFilterOverrideEnabledFlag = val; }
bool getDeblockingFilterOverrideEnabledFlag() const { return m_deblockingFilterOverrideEnabledFlag; }
void setPPSDeblockingFilterDisabledFlag(bool val) { m_ppsDeblockingFilterDisabledFlag = val; } //!< set offset for deblocking filter disabled
bool getPPSDeblockingFilterDisabledFlag() const { return m_ppsDeblockingFilterDisabledFlag; } //!< get offset for deblocking filter disabled
void setDeblockingFilterBetaOffsetDiv2(int val) { m_deblockingFilterBetaOffsetDiv2 = val; } //!< set beta offset for deblocking filter
int getDeblockingFilterBetaOffsetDiv2() const { return m_deblockingFilterBetaOffsetDiv2; } //!< get beta offset for deblocking filter
void setDeblockingFilterTcOffsetDiv2(int val) { m_deblockingFilterTcOffsetDiv2 = val; } //!< set tc offset for deblocking filter
int getDeblockingFilterTcOffsetDiv2() const { return m_deblockingFilterTcOffsetDiv2; } //!< get tc offset for deblocking filter
bool getListsModificationPresentFlag() const { return m_listsModificationPresentFlag; }
void setListsModificationPresentFlag( bool b ) { m_listsModificationPresentFlag = b; }
uint32_t getLog2ParallelMergeLevelMinus2() const { return m_log2ParallelMergeLevelMinus2; }
void setLog2ParallelMergeLevelMinus2(uint32_t mrgLevel) { m_log2ParallelMergeLevelMinus2 = mrgLevel; }
int getNumExtraSliceHeaderBits() const { return m_numExtraSliceHeaderBits; }
void setNumExtraSliceHeaderBits(int i) { m_numExtraSliceHeaderBits = i; }
void setLoopFilterAcrossSlicesEnabledFlag( bool bValue ) { m_loopFilterAcrossSlicesEnabledFlag = bValue; }
bool getLoopFilterAcrossSlicesEnabledFlag() const { return m_loopFilterAcrossSlicesEnabledFlag; }
bool getSliceHeaderExtensionPresentFlag() const { return m_sliceHeaderExtensionPresentFlag; }
void setSliceHeaderExtensionPresentFlag(bool val) { m_sliceHeaderExtensionPresentFlag = val; }
Sheng-Yen Lin
committed
void setLoopFilterAcrossVirtualBoundariesDisabledFlag(bool b) { m_loopFilterAcrossVirtualBoundariesDisabledFlag = b; }
bool getLoopFilterAcrossVirtualBoundariesDisabledFlag() const { return m_loopFilterAcrossVirtualBoundariesDisabledFlag; }
void setNumVerVirtualBoundaries(unsigned u) { m_numVerVirtualBoundaries = u; }
unsigned getNumVerVirtualBoundaries() const { return m_numVerVirtualBoundaries; }
void setNumHorVirtualBoundaries(unsigned u) { m_numHorVirtualBoundaries = u; }
unsigned getNumHorVirtualBoundaries() const { return m_numHorVirtualBoundaries; }
void setVirtualBoundariesPosX(unsigned u, unsigned idx) { m_virtualBoundariesPosX[idx] = u; }
unsigned getVirtualBoundariesPosX(unsigned idx) const { return m_virtualBoundariesPosX[idx]; }
void setVirtualBoundariesPosY(unsigned u, unsigned idx) { m_virtualBoundariesPosY[idx] = u; }
unsigned getVirtualBoundariesPosY(unsigned idx) const { return m_virtualBoundariesPosY[idx]; }
Karsten Suehring
committed
const PPSRExt& getPpsRangeExtension() const { return m_ppsRangeExtension; }
PPSRExt& getPpsRangeExtension() { return m_ppsRangeExtension; }
void setPicWidthInLumaSamples( uint32_t u ) { m_picWidthInLumaSamples = u; }
uint32_t getPicWidthInLumaSamples() const { return m_picWidthInLumaSamples; }
void setPicHeightInLumaSamples( uint32_t u ) { m_picHeightInLumaSamples = u; }
uint32_t getPicHeightInLumaSamples() const { return m_picHeightInLumaSamples; }
Window& getConformanceWindow() { return m_conformanceWindow; }
const Window& getConformanceWindow() const { return m_conformanceWindow; }
void setConformanceWindow( Window& conformanceWindow ) { m_conformanceWindow = conformanceWindow; }
Karsten Suehring
committed
};
class APS
{
private:
int m_APSId; // adaptation_parameter_set_id
Vadim Seregin
committed
int m_temporalId;
int m_layerId;
ApsType m_APSType; // aps_params_type
SliceReshapeInfo m_reshapeAPSInfo;
ScalingList m_scalingListApsInfo;
public:
APS();
virtual ~APS();
int getAPSId() const { return m_APSId; }
void setAPSId(int i) { m_APSId = i; }
Vadim Seregin
committed
ApsType getAPSType() const { return m_APSType; }
void setAPSType( ApsType type ) { m_APSType = type; }
void setAlfAPSParam(AlfParam& alfAPSParam) { m_alfAPSParam = alfAPSParam; }
Vadim Seregin
committed
void setTemporalId( int i ) { m_temporalId = i; }
int getTemporalId() const { return m_temporalId; }
void setLayerId( int i ) { m_layerId = i; }
int getLayerId() const { return m_layerId; }
AlfParam& getAlfAPSParam() { return m_alfAPSParam; }
void setReshaperAPSInfo(SliceReshapeInfo& reshapeAPSInfo) { m_reshapeAPSInfo = reshapeAPSInfo; }
SliceReshapeInfo& getReshaperAPSInfo() { return m_reshapeAPSInfo; }
void setScalingList( ScalingList& scalingListAPSInfo ) { m_scalingListApsInfo = scalingListAPSInfo; }
ScalingList& getScalingList() { return m_scalingListApsInfo; }
Karsten Suehring
committed
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
struct WPScalingParam
{
// Explicit weighted prediction parameters parsed in slice header,
// or Implicit weighted prediction parameters (8 bits depth values).
bool bPresentFlag;
uint32_t uiLog2WeightDenom;
int iWeight;
int iOffset;
// Weighted prediction scaling values built from above parameters (bitdepth scaled):
int w;
int o;
int offset;
int shift;
int round;
};
struct WPACDCParam
{
int64_t iAC;
int64_t iDC;
};
/// slice header class
class Slice
{
private:
// Bitstream writing
bool m_saoEnabledFlag[MAX_NUM_CHANNEL_TYPE];
int m_iPPSId; ///< picture parameter set ID
bool m_PicOutputFlag; ///< pic_output_flag
int m_iPOC;
int m_iLastIDR;
int m_iAssociatedIRAP;
NalUnitType m_iAssociatedIRAPType;
bool m_enableDRAPSEI;
bool m_useLTforDRAP;
bool m_isDRAP;
int m_latestDRAPPOC;
const ReferencePictureList* m_pRPL0; //< pointer to RPL for L0, either in the SPS or the local RPS in the same slice header
const ReferencePictureList* m_pRPL1; //< pointer to RPL for L1, either in the SPS or the local RPS in the same slice header
ReferencePictureList m_localRPL0; //< RPL for L0 when present in slice header
ReferencePictureList m_localRPL1; //< RPL for L1 when present in slice header
int m_rpl0Idx; //< index of used RPL in the SPS or -1 for local RPL in the slice header
int m_rpl1Idx; //< index of used RPL in the SPS or -1 for local RPL in the slice header
Karsten Suehring
committed
NalUnitType m_eNalUnitType; ///< Nal unit type for the slice
SliceType m_eSliceType;
int m_iSliceQp;
int m_iSliceQpBase;
bool m_ChromaQpAdjEnabled;
bool m_deblockingFilterDisable;
bool m_deblockingFilterOverrideFlag; //< offsets for deblocking filter inherit from PPS
int m_deblockingFilterBetaOffsetDiv2; //< beta offset for deblocking filter
int m_deblockingFilterTcOffsetDiv2; //< tc offset for deblocking filter
int m_list1IdxToList0Idx[MAX_NUM_REF];
int m_aiNumRefIdx [NUM_REF_PIC_LIST_01]; // for multiple reference of current slice
bool m_pendingRasInit;
bool m_depQuantEnabledFlag;
bool m_signDataHidingEnabledFlag;
bool m_bCheckLDC;
Daniel
committed
bool m_biDirPred;
Karsten Suehring
committed
// Data
int m_iSliceQpDelta;
int m_iSliceChromaQpDelta[MAX_NUM_COMPONENT+1];
Karsten Suehring
committed
Picture* m_apcRefPicList [NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
int m_aiRefPOCList [NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
bool m_bIsUsedAsLongTerm[NUM_REF_PIC_LIST_01][MAX_NUM_REF+1];
int m_iDepth;
Picture* m_scaledRefPicList[NUM_REF_PIC_LIST_01][MAX_NUM_REF + 1];
Picture* m_savedRefPicList[NUM_REF_PIC_LIST_01][MAX_NUM_REF + 1];
std::pair<int, int> m_scalingRatio[NUM_REF_PIC_LIST_01][MAX_NUM_REF_PICS];
Karsten Suehring
committed
// access channel
Karsten Suehring
committed
const SPS* m_pcSPS;
const PPS* m_pcPPS;
Picture* m_pcPic;
bool m_colFromL0Flag; // collocated picture from List0 flag
bool m_noOutputPriorPicsFlag;
bool m_noIncorrectPicOutputFlag;
Karsten Suehring
committed
uint32_t m_colRefIdx;
uint32_t m_maxNumMergeCand;
uint32_t m_maxNumAffineMergeCand;
bool m_disFracMMVD;
bool m_disBdofDmvrFlag;
Karsten Suehring
committed
double m_lambdas[MAX_NUM_COMPONENT];
bool m_abEqualRef [NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_REF];
uint32_t m_uiTLayer;
bool m_bTLayerSwitchingFlag;
SliceConstraint m_sliceMode;
uint32_t m_sliceArgument;
uint32_t m_sliceCurStartCtuTsAddr;
uint32_t m_sliceCurEndCtuTsAddr;
uint32_t m_independentSliceIdx;
bool m_nextSlice;
uint32_t m_sliceBits;
bool m_bFinalized;
uint32_t m_sliceCurStartBrickIdx;
uint32_t m_sliceCurEndBrickIdx;
uint32_t m_sliceNumBricks;
uint32_t m_sliceIdx;
Karsten Suehring
committed
bool m_bTestWeightPred;
bool m_bTestWeightBiPred;
WPScalingParam m_weightPredTable[NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_COMPONENT]; // [REF_PIC_LIST_0 or REF_PIC_LIST_1][refIdx][0:Y, 1:U, 2:V]
WPACDCParam m_weightACDCParam[MAX_NUM_COMPONENT];
ClpRngs m_clpRngs;
std::vector<uint32_t> m_substreamSizes;
bool m_cabacInitFlag;
bool m_jointCbCrSignFlag;
Karsten Suehring
committed
bool m_bLMvdL1Zero;
bool m_LFCrossSliceBoundaryFlag;
bool m_enableTMVPFlag;
SliceType m_encCABACTableIdx; // Used to transmit table selection across slices.
clock_t m_iProcessingStartTime;
double m_dProcessingTime;
bool m_splitConsOverrideFlag;
uint32_t m_uiMinQTSize;
uint32_t m_uiMaxTTSize;
uint32_t m_uiMinQTSizeIChroma;
uint32_t m_uiMaxBTSizeIChroma;
uint32_t m_uiMaxTTSizeIChroma;
uint32_t m_uiMaxBTSize;
int m_recoveryPocCnt;
int m_rpPicOrderCntVal;
bool m_tileGroupAlfEnabledFlag[MAX_NUM_COMPONENT];
int m_tileGroupNumAps;
std::vector<int> m_tileGroupLumaApsId;
int m_tileGroupChromaApsId;
int m_lmcsApsId;
APS* m_lmcsAps;
bool m_tileGroupLmcsEnabledFlag;
bool m_tileGroupLmcsChromaResidualScaleFlag;
int m_scalingListApsId;
APS* m_scalingListAps;
bool m_tileGroupscalingListPresentFlag;
Karsten Suehring
committed
public:
Slice();
virtual ~Slice();
void initSlice();
int getRefIdx4MVPair( RefPicList eCurRefPicList, int nCurRefIdx );
void setDPS( DPS* dps ) { m_dps = dps; }
const DPS* getDPS() const { return m_dps; }
Karsten Suehring
committed
void setSPS( const SPS* pcSPS ) { m_pcSPS = pcSPS; }
const SPS* getSPS() const { return m_pcSPS; }
void setPPS( const PPS* pcPPS ) { m_pcPPS = pcPPS; m_iPPSId = (pcPPS) ? pcPPS->getPPSId() : -1; }
const PPS* getPPS() const { return m_pcPPS; }
void setPPSId( int PPSId ) { m_iPPSId = PPSId; }
int getPPSId() const { return m_iPPSId; }
void setAlfAPSs(APS** apss) { memcpy(m_alfApss, apss, sizeof(m_alfApss)); }
APS** getAlfAPSs() { return m_alfApss; }
void setLmcsAPS(APS* lmcsAps) { m_lmcsAps = lmcsAps; m_lmcsApsId = (lmcsAps) ? lmcsAps->getAPSId() : -1; }
APS* getLmcsAPS() { return m_lmcsAps; }
void setLmcsAPSId(int lmcsApsId) { m_lmcsApsId = lmcsApsId; }
int getLmcsAPSId() const { return m_lmcsApsId; }
void setLmcsEnabledFlag(bool b) { m_tileGroupLmcsEnabledFlag = b; }
bool getLmcsEnabledFlag() { return m_tileGroupLmcsEnabledFlag; }
const bool getLmcsEnabledFlag() const { return m_tileGroupLmcsEnabledFlag; }
void setLmcsChromaResidualScaleFlag(bool b) { m_tileGroupLmcsChromaResidualScaleFlag = b; }
bool getLmcsChromaResidualScaleFlag() { return m_tileGroupLmcsChromaResidualScaleFlag; }
const bool getLmcsChromaResidualScaleFlag() const { return m_tileGroupLmcsChromaResidualScaleFlag; }
void setscalingListAPS( APS* scalingListAps ) { m_scalingListAps = scalingListAps; m_scalingListApsId = ( scalingListAps ) ? scalingListAps->getAPSId() : -1; }
APS* getscalingListAPS() { return m_scalingListAps; }
void setscalingListAPSId( int scalingListApsId ) { m_scalingListApsId = scalingListApsId; }
int getscalingListAPSId() const { return m_scalingListApsId; }
void setscalingListPresentFlag( bool b ) { m_tileGroupscalingListPresentFlag = b; }
bool getscalingListPresentFlag() { return m_tileGroupscalingListPresentFlag; }
Moonmo Koo
committed
const bool getscalingListPresentFlag() const { return m_tileGroupscalingListPresentFlag; }
Karsten Suehring
committed
void setPicOutputFlag( bool b ) { m_PicOutputFlag = b; }
bool getPicOutputFlag() const { return m_PicOutputFlag; }
void setSaoEnabledFlag(ChannelType chType, bool s) {m_saoEnabledFlag[chType] =s; }
bool getSaoEnabledFlag(ChannelType chType) const { return m_saoEnabledFlag[chType]; }
void setRPL0(const ReferencePictureList *pcRPL) { m_pRPL0 = pcRPL; }
void setRPL1(const ReferencePictureList *pcRPL) { m_pRPL1 = pcRPL; }
const ReferencePictureList* getRPL0() { return m_pRPL0; }
const ReferencePictureList* getRPL1() { return m_pRPL1; }
ReferencePictureList* getLocalRPL0() { return &m_localRPL0; }
ReferencePictureList* getLocalRPL1() { return &m_localRPL1; }
void setRPL0idx(int rplIdx) { m_rpl0Idx = rplIdx; }
void setRPL1idx(int rplIdx) { m_rpl1Idx = rplIdx; }
int getRPL0idx() const { return m_rpl0Idx; }
int getRPL1idx() const { return m_rpl1Idx; }
Karsten Suehring
committed
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
void setLastIDR(int iIDRPOC) { m_iLastIDR = iIDRPOC; }
int getLastIDR() const { return m_iLastIDR; }
void setAssociatedIRAPPOC(int iAssociatedIRAPPOC) { m_iAssociatedIRAP = iAssociatedIRAPPOC; }
int getAssociatedIRAPPOC() const { return m_iAssociatedIRAP; }
void setAssociatedIRAPType(NalUnitType associatedIRAPType) { m_iAssociatedIRAPType = associatedIRAPType; }
NalUnitType getAssociatedIRAPType() const { return m_iAssociatedIRAPType; }
SliceType getSliceType() const { return m_eSliceType; }
int getPOC() const { return m_iPOC; }
int getSliceQp() const { return m_iSliceQp; }
bool getUseWeightedPrediction() const { return( (m_eSliceType==P_SLICE && testWeightPred()) || (m_eSliceType==B_SLICE && testWeightBiPred()) ); }
int getSliceQpDelta() const { return m_iSliceQpDelta; }
int getSliceChromaQpDelta(ComponentID compID) const { return isLuma(compID) ? 0 : m_iSliceChromaQpDelta[compID]; }
bool getUseChromaQpAdj() const { return m_ChromaQpAdjEnabled; }
bool getDeblockingFilterDisable() const { return m_deblockingFilterDisable; }
bool getDeblockingFilterOverrideFlag() const { return m_deblockingFilterOverrideFlag; }
int getDeblockingFilterBetaOffsetDiv2()const { return m_deblockingFilterBetaOffsetDiv2; }
int getDeblockingFilterTcOffsetDiv2() const { return m_deblockingFilterTcOffsetDiv2; }
bool getPendingRasInit() const { return m_pendingRasInit; }
void setPendingRasInit( bool val ) { m_pendingRasInit = val; }
int getNumRefIdx( RefPicList e ) const { return m_aiNumRefIdx[e]; }
Picture* getPic() { return m_pcPic; }
const Picture* getPic() const { return m_pcPic; }
const Picture* getRefPic( RefPicList e, int iRefIdx) const { return m_apcRefPicList[e][iRefIdx]; }
int getRefPOC( RefPicList e, int iRefIdx) const { return m_aiRefPOCList[e][iRefIdx]; }
int getDepth() const { return m_iDepth; }
bool getColFromL0Flag() const { return m_colFromL0Flag; }
uint32_t getColRefIdx() const { return m_colRefIdx; }
void checkColRefIdx(uint32_t curSliceSegmentIdx, const Picture* pic);
bool getIsUsedAsLongTerm(int i, int j) const { return m_bIsUsedAsLongTerm[i][j]; }
void setIsUsedAsLongTerm(int i, int j, bool value) { m_bIsUsedAsLongTerm[i][j] = value; }
bool getCheckLDC() const { return m_bCheckLDC; }
bool getMvdL1ZeroFlag() const { return m_bLMvdL1Zero; }
int getList1IdxToList0Idx( int list1Idx ) const { return m_list1IdxToList0Idx[list1Idx]; }
void setPOC( int i ) { m_iPOC = i; }
void setNalUnitType( NalUnitType e ) { m_eNalUnitType = e; }
NalUnitType getNalUnitType() const { return m_eNalUnitType; }
bool getRapPicFlag() const;
bool getIdrPicFlag() const { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; }
bool isIRAP() const { return (getNalUnitType() >= NAL_UNIT_CODED_SLICE_IDR_W_RADL) && (getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA); }
bool isIDRorBLA() const { return (getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL) || (getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP); }
void checkCRA(const ReferencePictureList *pRPL0, const ReferencePictureList *pRPL1, int& pocCRA, NalUnitType& associatedIRAPType, PicList& rcListPic);
Karsten Suehring
committed
void decodingRefreshMarking(int& pocCRA, bool& bRefreshPending, PicList& rcListPic, const bool bEfficientFieldIRAPEnabled);
void setSliceType( SliceType e ) { m_eSliceType = e; }
void setSliceQp( int i ) { m_iSliceQp = i; }
void setSliceQpDelta( int i ) { m_iSliceQpDelta = i; }
void setSliceChromaQpDelta( ComponentID compID, int i ) { m_iSliceChromaQpDelta[compID] = isLuma(compID) ? 0 : i; }
void setUseChromaQpAdj( bool b ) { m_ChromaQpAdjEnabled = b; }
void setDeblockingFilterDisable( bool b ) { m_deblockingFilterDisable= b; }
void setDeblockingFilterOverrideFlag( bool b ) { m_deblockingFilterOverrideFlag = b; }
void setDeblockingFilterBetaOffsetDiv2( int i ) { m_deblockingFilterBetaOffsetDiv2 = i; }
void setDeblockingFilterTcOffsetDiv2( int i ) { m_deblockingFilterTcOffsetDiv2 = i; }
void setNumRefIdx( RefPicList e, int i ) { m_aiNumRefIdx[e] = i; }
void setPic( Picture* p ) { m_pcPic = p; }
void setDepth( int iDepth ) { m_iDepth = iDepth; }
Karsten Suehring
committed
void setRefPOCList();
void setColFromL0Flag( bool colFromL0 ) { m_colFromL0Flag = colFromL0; }
void setColRefIdx( uint32_t refIdx) { m_colRefIdx = refIdx; }
void setCheckLDC( bool b ) { m_bCheckLDC = b; }
void setMvdL1ZeroFlag( bool b) { m_bLMvdL1Zero = b; }
Daniel
committed
void setBiDirPred( bool b, int refIdx0, int refIdx1 ) { m_biDirPred = b; m_symRefIdx[0] = refIdx0; m_symRefIdx[1] = refIdx1; }
bool getBiDirPred() const { return m_biDirPred; }
int getSymRefIdx( int refList ) const { return m_symRefIdx[refList]; }
Karsten Suehring
committed
bool isIntra() const { return m_eSliceType == I_SLICE; }
bool isInterB() const { return m_eSliceType == B_SLICE; }
bool isInterP() const { return m_eSliceType == P_SLICE; }
bool getEnableDRAPSEI () const { return m_enableDRAPSEI; }
void setEnableDRAPSEI ( bool b ) { m_enableDRAPSEI = b; }
bool getUseLTforDRAP () const { return m_useLTforDRAP; }
void setUseLTforDRAP ( bool b ) { m_useLTforDRAP = b; }
bool isDRAP () const { return m_isDRAP; }
void setDRAP ( bool b ) { m_isDRAP = b; }
void setLatestDRAPPOC ( int i ) { m_latestDRAPPOC = i; }
int getLatestDRAPPOC () const { return m_latestDRAPPOC; }
bool cvsHasPreviousDRAP() const { return m_latestDRAPPOC != MAX_INT; }
bool isPocRestrictedByDRAP( int poc, bool precedingDRAPinDecodingOrder );
bool isPOCInRefPicList( const ReferencePictureList *rpl, int poc );
void checkConformanceForDRAP( uint32_t temporalId );
Karsten Suehring
committed
void setLambdas( const double lambdas[MAX_NUM_COMPONENT] ) { for (int component = 0; component < MAX_NUM_COMPONENT; component++) m_lambdas[component] = lambdas[component]; }
const double* getLambdas() const { return m_lambdas; }
void setSplitConsOverrideFlag(bool b) { m_splitConsOverrideFlag = b; }
bool getSplitConsOverrideFlag() const { return m_splitConsOverrideFlag; }
void setMinQTSize(int i) { m_uiMinQTSize = i; }
uint32_t getMinQTSize() const { return m_uiMinQTSize; }
void setMaxMTTHierarchyDepth(int i) { m_uiMaxMTTHierarchyDepth = i; }
uint32_t getMaxMTTHierarchyDepth() const { return m_uiMaxMTTHierarchyDepth; }
void setMaxTTSize(int i) { m_uiMaxTTSize = i; }
uint32_t getMaxTTSize() const { return m_uiMaxTTSize; }
void setMinQTSizeIChroma(int i) { m_uiMinQTSizeIChroma = i; }
uint32_t getMinQTSizeIChroma() const { return m_uiMinQTSizeIChroma; }
void setMaxMTTHierarchyDepthIChroma(int i) { m_uiMaxMTTHierarchyDepthIChroma = i; }
uint32_t getMaxMTTHierarchyDepthIChroma() const { return m_uiMaxMTTHierarchyDepthIChroma; }
void setMaxBTSizeIChroma(int i) { m_uiMaxBTSizeIChroma = i; }
uint32_t getMaxBTSizeIChroma() const { return m_uiMaxBTSizeIChroma; }
void setMaxTTSizeIChroma(int i) { m_uiMaxTTSizeIChroma = i; }
uint32_t getMaxTTSizeIChroma() const { return m_uiMaxTTSizeIChroma; }
Karsten Suehring
committed
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
void setMaxBTSize(int i) { m_uiMaxBTSize = i; }
uint32_t getMaxBTSize() const { return m_uiMaxBTSize; }
void setDepQuantEnabledFlag( bool b ) { m_depQuantEnabledFlag = b; }
bool getDepQuantEnabledFlag() const { return m_depQuantEnabledFlag; }
void setSignDataHidingEnabledFlag( bool b ) { m_signDataHidingEnabledFlag = b; }
bool getSignDataHidingEnabledFlag() const { return m_signDataHidingEnabledFlag; }
void initEqualRef();
bool isEqualRef( RefPicList e, int iRefIdx1, int iRefIdx2 )
{
CHECK(e>=NUM_REF_PIC_LIST_01, "Invalid reference picture list");
if (iRefIdx1 < 0 || iRefIdx2 < 0)
{
return false;
}
else
{
return m_abEqualRef[e][iRefIdx1][iRefIdx2];
}
}
void setEqualRef( RefPicList e, int iRefIdx1, int iRefIdx2, bool b)
{
CHECK( e >= NUM_REF_PIC_LIST_01, "Invalid reference picture list" );
m_abEqualRef[e][iRefIdx1][iRefIdx2] = m_abEqualRef[e][iRefIdx2][iRefIdx1] = b;
}
static void sortPicList( PicList& rcListPic );
void setList1IdxToList0Idx();
uint32_t getTLayer() const { return m_uiTLayer; }
void setTLayer( uint32_t uiTLayer ) { m_uiTLayer = uiTLayer; }
void checkLeadingPictureRestrictions( PicList& rcListPic ) const;
int checkThatAllRefPicsAreAvailable(PicList& rcListPic, const ReferencePictureList* pRPL, int rplIdx, bool printErrors, int* refPicIndex) const;
void applyReferencePictureListBasedMarking( PicList& rcListPic, const ReferencePictureList *pRPL0, const ReferencePictureList *pRPL1 ) const;
Karsten Suehring
committed
bool isTemporalLayerSwitchingPoint( PicList& rcListPic ) const;
bool isStepwiseTemporalLayerSwitchingPointCandidate( PicList& rcListPic ) const;
int checkThatAllRefPicsAreAvailable(PicList& rcListPic, const ReferencePictureList *pRPL, int rplIdx, bool printErrors) const;
void createExplicitReferencePictureSetFromReference(PicList& rcListPic, const ReferencePictureList *pRPL0, const ReferencePictureList *pRPL1);
Karsten Suehring
committed
void setMaxNumMergeCand(uint32_t val ) { m_maxNumMergeCand = val; }
uint32_t getMaxNumMergeCand() const { return m_maxNumMergeCand; }
void setMaxNumAffineMergeCand( uint32_t val ) { m_maxNumAffineMergeCand = val; }
uint32_t getMaxNumAffineMergeCand() const { return m_maxNumAffineMergeCand; }
void setMaxNumTriangleCand(uint32_t val) { m_maxNumTriangleCand = val;}
uint32_t getMaxNumTriangleCand() const { return m_maxNumTriangleCand;}
void setMaxNumIBCMergeCand( uint32_t val ) { m_maxNumIBCMergeCand = val; }
uint32_t getMaxNumIBCMergeCand() const { return m_maxNumIBCMergeCand; }
void setDisFracMMVD( bool val ) { m_disFracMMVD = val; }
bool getDisFracMMVD() const { return m_disFracMMVD; }
void setDisBdofDmvrFlag(bool val) { m_disBdofDmvrFlag = val; }
bool getDisBdofDmvrFlag() const { return m_disBdofDmvrFlag; }
Karsten Suehring
committed
void setNoOutputPriorPicsFlag( bool val ) { m_noOutputPriorPicsFlag = val; }
bool getNoOutputPriorPicsFlag() const { return m_noOutputPriorPicsFlag; }
void setNoIncorrectPicOutputFlag(bool val) { m_noIncorrectPicOutputFlag = val; }
bool getNoIncorrectPicOutputFlag() const { return m_noIncorrectPicOutputFlag; }
Karsten Suehring
committed
void setHandleCraAsCvsStartFlag( bool val ) { m_handleCraAsCvsStartFlag = val; }
bool getHandleCraAsCvsStartFlag() const { return m_handleCraAsCvsStartFlag; }
Karsten Suehring
committed
void setSliceMode( SliceConstraint mode ) { m_sliceMode = mode; }
SliceConstraint getSliceMode() const { return m_sliceMode; }
void setSliceArgument( uint32_t uiArgument ) { m_sliceArgument = uiArgument; }
uint32_t getSliceArgument() const { return m_sliceArgument; }
void setSliceCurStartCtuTsAddr( uint32_t ctuTsAddr ) { m_sliceCurStartCtuTsAddr = ctuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
uint32_t getSliceCurStartCtuTsAddr() const { return m_sliceCurStartCtuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
void setSliceCurEndCtuTsAddr( uint32_t ctuTsAddr ) { m_sliceCurEndCtuTsAddr = ctuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
uint32_t getSliceCurEndCtuTsAddr() const { return m_sliceCurEndCtuTsAddr; } // CTU Tile-scan address (as opposed to raster-scan)
void setIndependentSliceIdx( uint32_t i) { m_independentSliceIdx = i; }
uint32_t getIndependentSliceIdx() const { return m_independentSliceIdx; }
void copySliceInfo(Slice *pcSliceSrc, bool cpyAlmostAll = true);
void setSliceBits( uint32_t uiVal ) { m_sliceBits = uiVal; }
uint32_t getSliceBits() const { return m_sliceBits; }
void setFinalized( bool uiVal ) { m_bFinalized = uiVal; }
bool getFinalized() const { return m_bFinalized; }
void setSliceCurStartBrickIdx(uint32_t brickIdx) { m_sliceCurStartBrickIdx = brickIdx; }
uint32_t getSliceCurStartBrickIdx() const { return m_sliceCurStartBrickIdx; }
void setSliceCurEndBrickIdx(uint32_t brickIdx) { m_sliceCurEndBrickIdx = brickIdx; }
uint32_t getSliceCurEndBrickIdx() const { return m_sliceCurEndBrickIdx; }
void setSliceNumBricks(uint32_t numBricks) { m_sliceNumBricks = numBricks; }
uint32_t getSliceNumBricks() const { return m_sliceNumBricks; }
void setSliceIndex(uint32_t idx) { m_sliceIdx = idx; }
uint32_t getSliceIndex() const { return m_sliceIdx; }
Karsten Suehring
committed
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
bool testWeightPred( ) const { return m_bTestWeightPred; }
void setTestWeightPred( bool bValue ) { m_bTestWeightPred = bValue; }
bool testWeightBiPred( ) const { return m_bTestWeightBiPred; }
void setTestWeightBiPred( bool bValue ) { m_bTestWeightBiPred = bValue; }
void setWpScaling( WPScalingParam wp[NUM_REF_PIC_LIST_01][MAX_NUM_REF][MAX_NUM_COMPONENT] )
{
memcpy(m_weightPredTable, wp, sizeof(WPScalingParam)*NUM_REF_PIC_LIST_01*MAX_NUM_REF*MAX_NUM_COMPONENT);
}
void getWpScaling( RefPicList e, int iRefIdx, WPScalingParam *&wp) const;
void resetWpScaling();
void initWpScaling(const SPS *sps);
void setWpAcDcParam( WPACDCParam wp[MAX_NUM_COMPONENT] ) { memcpy(m_weightACDCParam, wp, sizeof(WPACDCParam)*MAX_NUM_COMPONENT); }
void getWpAcDcParam( const WPACDCParam *&wp ) const;
void initWpAcDcParam();
void clearSubstreamSizes( ) { return m_substreamSizes.clear(); }
uint32_t getNumberOfSubstreamSizes( ) { return (uint32_t) m_substreamSizes.size(); }
void addSubstreamSize( uint32_t size ) { m_substreamSizes.push_back(size); }
uint32_t getSubstreamSize( uint32_t idx ) { CHECK(idx>=getNumberOfSubstreamSizes(),"Invalid index"); return m_substreamSizes[idx]; }
void setCabacInitFlag( bool val ) { m_cabacInitFlag = val; } //!< set CABAC initial flag
bool getCabacInitFlag() const { return m_cabacInitFlag; } //!< get CABAC initial flag
void setJointCbCrSignFlag( bool b ) { m_jointCbCrSignFlag = b; }
bool getJointCbCrSignFlag() const { return m_jointCbCrSignFlag; }
Karsten Suehring
committed
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
void setLFCrossSliceBoundaryFlag( bool val ) { m_LFCrossSliceBoundaryFlag = val; }
bool getLFCrossSliceBoundaryFlag() const { return m_LFCrossSliceBoundaryFlag; }
void setEnableTMVPFlag( bool b ) { m_enableTMVPFlag = b; }
bool getEnableTMVPFlag() const { return m_enableTMVPFlag; }
void setEncCABACTableIdx( SliceType idx ) { m_encCABACTableIdx = idx; }
SliceType getEncCABACTableIdx() const { return m_encCABACTableIdx; }
void setSliceQpBase( int i ) { m_iSliceQpBase = i; }
int getSliceQpBase() const { return m_iSliceQpBase; }
void setDefaultClpRng( const SPS& sps );
const ClpRngs& clpRngs() const { return m_clpRngs;}
const ClpRng& clpRng( ComponentID id) const { return m_clpRngs.comp[id];}
ClpRngs& getClpRngs() { return m_clpRngs;}
unsigned getMinPictureDistance() const ;
void startProcessingTimer();
void stopProcessingTimer();
void resetProcessingTime() { m_dProcessingTime = m_iProcessingStartTime = 0; }
double getProcessingTime() const { return m_dProcessingTime; }
void resetTileGroupAlfEnabledFlag() { memset(m_tileGroupAlfEnabledFlag, 0, sizeof(m_tileGroupAlfEnabledFlag)); }
bool getTileGroupAlfEnabledFlag(ComponentID compId) const { return m_tileGroupAlfEnabledFlag[compId]; }
void setTileGroupAlfEnabledFlag(ComponentID compId, bool b) { m_tileGroupAlfEnabledFlag[compId] = b; }
int getTileGroupNumAps() const { return m_tileGroupNumAps; }
void setTileGroupNumAps(int i) { m_tileGroupNumAps = i; }
int getTileGroupApsIdChroma() const { return m_tileGroupChromaApsId; }
void setTileGroupApsIdChroma(int i) { m_tileGroupChromaApsId = i; }
std::vector<int32_t> getTileGroupApsIdLuma() const { return m_tileGroupLumaApsId; }
void setAlfAPSs(std::vector<int> ApsIDs)