H265Settings.h

 
#pragma once
#include <aws/medialive/MediaLive_EXPORTS.h>
#include <aws/medialive/model/H265AdaptiveQuantization.h>
#include <aws/medialive/model/AfdSignaling.h>
#include <aws/medialive/model/H265AlternativeTransferFunction.h>
#include <aws/medialive/model/H265ColorMetadata.h>
#include <aws/medialive/model/H265ColorSpaceSettings.h>
#include <aws/medialive/model/H265FilterSettings.h>
#include <aws/medialive/model/FixedAfd.h>
#include <aws/medialive/model/H265FlickerAq.h>
#include <aws/medialive/model/H265GopSizeUnits.h>
#include <aws/medialive/model/H265Level.h>
#include <aws/medialive/model/H265LookAheadRateControl.h>
#include <aws/medialive/model/H265Profile.h>
#include <aws/medialive/model/H265RateControlMode.h>
#include <aws/medialive/model/H265ScanType.h>
#include <aws/medialive/model/H265SceneChangeDetect.h>
#include <aws/medialive/model/H265Tier.h>
#include <aws/medialive/model/H265TimecodeInsertionBehavior.h>
#include <aws/medialive/model/TimecodeBurninSettings.h>
#include <aws/medialive/model/H265MvOverPictureBoundaries.h>
#include <aws/medialive/model/H265MvTemporalPredictor.h>
#include <aws/medialive/model/H265TilePadding.h>
#include <aws/medialive/model/H265TreeblockSize.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace MediaLive
{
namespace Model
{
 
  class H265Settings
  {
  public:
    AWS_MEDIALIVE_API H265Settings();
    AWS_MEDIALIVE_API H265Settings(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIALIVE_API H265Settings& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIALIVE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const H265AdaptiveQuantization& GetAdaptiveQuantization() const{ return m_adaptiveQuantization; }
    inline bool AdaptiveQuantizationHasBeenSet() const { return m_adaptiveQuantizationHasBeenSet; }
    inline void SetAdaptiveQuantization(const H265AdaptiveQuantization& value) { m_adaptiveQuantizationHasBeenSet = true; m_adaptiveQuantization = value; }
    inline void SetAdaptiveQuantization(H265AdaptiveQuantization&& value) { m_adaptiveQuantizationHasBeenSet = true; m_adaptiveQuantization = std::move(value); }
    inline H265Settings& WithAdaptiveQuantization(const H265AdaptiveQuantization& value) { SetAdaptiveQuantization(value); return *this;}
    inline H265Settings& WithAdaptiveQuantization(H265AdaptiveQuantization&& value) { SetAdaptiveQuantization(std::move(value)); return *this;}
 
 
    inline const AfdSignaling& GetAfdSignaling() const{ return m_afdSignaling; }
    inline bool AfdSignalingHasBeenSet() const { return m_afdSignalingHasBeenSet; }
    inline void SetAfdSignaling(const AfdSignaling& value) { m_afdSignalingHasBeenSet = true; m_afdSignaling = value; }
    inline void SetAfdSignaling(AfdSignaling&& value) { m_afdSignalingHasBeenSet = true; m_afdSignaling = std::move(value); }
    inline H265Settings& WithAfdSignaling(const AfdSignaling& value) { SetAfdSignaling(value); return *this;}
    inline H265Settings& WithAfdSignaling(AfdSignaling&& value) { SetAfdSignaling(std::move(value)); return *this;}
 
 
    inline const H265AlternativeTransferFunction& GetAlternativeTransferFunction() const{ return m_alternativeTransferFunction; }
    inline bool AlternativeTransferFunctionHasBeenSet() const { return m_alternativeTransferFunctionHasBeenSet; }
    inline void SetAlternativeTransferFunction(const H265AlternativeTransferFunction& value) { m_alternativeTransferFunctionHasBeenSet = true; m_alternativeTransferFunction = value; }
    inline void SetAlternativeTransferFunction(H265AlternativeTransferFunction&& value) { m_alternativeTransferFunctionHasBeenSet = true; m_alternativeTransferFunction = std::move(value); }
    inline H265Settings& WithAlternativeTransferFunction(const H265AlternativeTransferFunction& value) { SetAlternativeTransferFunction(value); return *this;}
    inline H265Settings& WithAlternativeTransferFunction(H265AlternativeTransferFunction&& value) { SetAlternativeTransferFunction(std::move(value)); return *this;}
 
 
    inline int GetBitrate() const{ return m_bitrate; }
    inline bool BitrateHasBeenSet() const { return m_bitrateHasBeenSet; }
    inline void SetBitrate(int value) { m_bitrateHasBeenSet = true; m_bitrate = value; }
    inline H265Settings& WithBitrate(int value) { SetBitrate(value); return *this;}
 
 
    inline int GetBufSize() const{ return m_bufSize; }
    inline bool BufSizeHasBeenSet() const { return m_bufSizeHasBeenSet; }
    inline void SetBufSize(int value) { m_bufSizeHasBeenSet = true; m_bufSize = value; }
    inline H265Settings& WithBufSize(int value) { SetBufSize(value); return *this;}
 
 
    inline const H265ColorMetadata& GetColorMetadata() const{ return m_colorMetadata; }
    inline bool ColorMetadataHasBeenSet() const { return m_colorMetadataHasBeenSet; }
    inline void SetColorMetadata(const H265ColorMetadata& value) { m_colorMetadataHasBeenSet = true; m_colorMetadata = value; }
    inline void SetColorMetadata(H265ColorMetadata&& value) { m_colorMetadataHasBeenSet = true; m_colorMetadata = std::move(value); }
    inline H265Settings& WithColorMetadata(const H265ColorMetadata& value) { SetColorMetadata(value); return *this;}
    inline H265Settings& WithColorMetadata(H265ColorMetadata&& value) { SetColorMetadata(std::move(value)); return *this;}
 
 
    inline const H265ColorSpaceSettings& GetColorSpaceSettings() const{ return m_colorSpaceSettings; }
    inline bool ColorSpaceSettingsHasBeenSet() const { return m_colorSpaceSettingsHasBeenSet; }
    inline void SetColorSpaceSettings(const H265ColorSpaceSettings& value) { m_colorSpaceSettingsHasBeenSet = true; m_colorSpaceSettings = value; }
    inline void SetColorSpaceSettings(H265ColorSpaceSettings&& value) { m_colorSpaceSettingsHasBeenSet = true; m_colorSpaceSettings = std::move(value); }
    inline H265Settings& WithColorSpaceSettings(const H265ColorSpaceSettings& value) { SetColorSpaceSettings(value); return *this;}
    inline H265Settings& WithColorSpaceSettings(H265ColorSpaceSettings&& value) { SetColorSpaceSettings(std::move(value)); return *this;}
 
 
    inline const H265FilterSettings& GetFilterSettings() const{ return m_filterSettings; }
    inline bool FilterSettingsHasBeenSet() const { return m_filterSettingsHasBeenSet; }
    inline void SetFilterSettings(const H265FilterSettings& value) { m_filterSettingsHasBeenSet = true; m_filterSettings = value; }
    inline void SetFilterSettings(H265FilterSettings&& value) { m_filterSettingsHasBeenSet = true; m_filterSettings = std::move(value); }
    inline H265Settings& WithFilterSettings(const H265FilterSettings& value) { SetFilterSettings(value); return *this;}
    inline H265Settings& WithFilterSettings(H265FilterSettings&& value) { SetFilterSettings(std::move(value)); return *this;}
 
 
    inline const FixedAfd& GetFixedAfd() const{ return m_fixedAfd; }
    inline bool FixedAfdHasBeenSet() const { return m_fixedAfdHasBeenSet; }
    inline void SetFixedAfd(const FixedAfd& value) { m_fixedAfdHasBeenSet = true; m_fixedAfd = value; }
    inline void SetFixedAfd(FixedAfd&& value) { m_fixedAfdHasBeenSet = true; m_fixedAfd = std::move(value); }
    inline H265Settings& WithFixedAfd(const FixedAfd& value) { SetFixedAfd(value); return *this;}
    inline H265Settings& WithFixedAfd(FixedAfd&& value) { SetFixedAfd(std::move(value)); return *this;}
 
 
    inline const H265FlickerAq& GetFlickerAq() const{ return m_flickerAq; }
    inline bool FlickerAqHasBeenSet() const { return m_flickerAqHasBeenSet; }
    inline void SetFlickerAq(const H265FlickerAq& value) { m_flickerAqHasBeenSet = true; m_flickerAq = value; }
    inline void SetFlickerAq(H265FlickerAq&& value) { m_flickerAqHasBeenSet = true; m_flickerAq = std::move(value); }
    inline H265Settings& WithFlickerAq(const H265FlickerAq& value) { SetFlickerAq(value); return *this;}
    inline H265Settings& WithFlickerAq(H265FlickerAq&& value) { SetFlickerAq(std::move(value)); return *this;}
 
 
    inline int GetFramerateDenominator() const{ return m_framerateDenominator; }
    inline bool FramerateDenominatorHasBeenSet() const { return m_framerateDenominatorHasBeenSet; }
    inline void SetFramerateDenominator(int value) { m_framerateDenominatorHasBeenSet = true; m_framerateDenominator = value; }
    inline H265Settings& WithFramerateDenominator(int value) { SetFramerateDenominator(value); return *this;}
 
 
    inline int GetFramerateNumerator() const{ return m_framerateNumerator; }
    inline bool FramerateNumeratorHasBeenSet() const { return m_framerateNumeratorHasBeenSet; }
    inline void SetFramerateNumerator(int value) { m_framerateNumeratorHasBeenSet = true; m_framerateNumerator = value; }
    inline H265Settings& WithFramerateNumerator(int value) { SetFramerateNumerator(value); return *this;}
 
 
    inline int GetGopClosedCadence() const{ return m_gopClosedCadence; }
    inline bool GopClosedCadenceHasBeenSet() const { return m_gopClosedCadenceHasBeenSet; }
    inline void SetGopClosedCadence(int value) { m_gopClosedCadenceHasBeenSet = true; m_gopClosedCadence = value; }
    inline H265Settings& WithGopClosedCadence(int value) { SetGopClosedCadence(value); return *this;}
 
 
    inline double GetGopSize() const{ return m_gopSize; }
    inline bool GopSizeHasBeenSet() const { return m_gopSizeHasBeenSet; }
    inline void SetGopSize(double value) { m_gopSizeHasBeenSet = true; m_gopSize = value; }
    inline H265Settings& WithGopSize(double value) { SetGopSize(value); return *this;}
 
 
    inline const H265GopSizeUnits& GetGopSizeUnits() const{ return m_gopSizeUnits; }
    inline bool GopSizeUnitsHasBeenSet() const { return m_gopSizeUnitsHasBeenSet; }
    inline void SetGopSizeUnits(const H265GopSizeUnits& value) { m_gopSizeUnitsHasBeenSet = true; m_gopSizeUnits = value; }
    inline void SetGopSizeUnits(H265GopSizeUnits&& value) { m_gopSizeUnitsHasBeenSet = true; m_gopSizeUnits = std::move(value); }
    inline H265Settings& WithGopSizeUnits(const H265GopSizeUnits& value) { SetGopSizeUnits(value); return *this;}
    inline H265Settings& WithGopSizeUnits(H265GopSizeUnits&& value) { SetGopSizeUnits(std::move(value)); return *this;}
 
 
    inline const H265Level& GetLevel() const{ return m_level; }
    inline bool LevelHasBeenSet() const { return m_levelHasBeenSet; }
    inline void SetLevel(const H265Level& value) { m_levelHasBeenSet = true; m_level = value; }
    inline void SetLevel(H265Level&& value) { m_levelHasBeenSet = true; m_level = std::move(value); }
    inline H265Settings& WithLevel(const H265Level& value) { SetLevel(value); return *this;}
    inline H265Settings& WithLevel(H265Level&& value) { SetLevel(std::move(value)); return *this;}
 
 
    inline const H265LookAheadRateControl& GetLookAheadRateControl() const{ return m_lookAheadRateControl; }
    inline bool LookAheadRateControlHasBeenSet() const { return m_lookAheadRateControlHasBeenSet; }
    inline void SetLookAheadRateControl(const H265LookAheadRateControl& value) { m_lookAheadRateControlHasBeenSet = true; m_lookAheadRateControl = value; }
    inline void SetLookAheadRateControl(H265LookAheadRateControl&& value) { m_lookAheadRateControlHasBeenSet = true; m_lookAheadRateControl = std::move(value); }
    inline H265Settings& WithLookAheadRateControl(const H265LookAheadRateControl& value) { SetLookAheadRateControl(value); return *this;}
    inline H265Settings& WithLookAheadRateControl(H265LookAheadRateControl&& value) { SetLookAheadRateControl(std::move(value)); return *this;}
 
 
    inline int GetMaxBitrate() const{ return m_maxBitrate; }
    inline bool MaxBitrateHasBeenSet() const { return m_maxBitrateHasBeenSet; }
    inline void SetMaxBitrate(int value) { m_maxBitrateHasBeenSet = true; m_maxBitrate = value; }
    inline H265Settings& WithMaxBitrate(int value) { SetMaxBitrate(value); return *this;}
 
 
    inline int GetMinIInterval() const{ return m_minIInterval; }
    inline bool MinIIntervalHasBeenSet() const { return m_minIIntervalHasBeenSet; }
    inline void SetMinIInterval(int value) { m_minIIntervalHasBeenSet = true; m_minIInterval = value; }
    inline H265Settings& WithMinIInterval(int value) { SetMinIInterval(value); return *this;}
 
 
    inline int GetParDenominator() const{ return m_parDenominator; }
    inline bool ParDenominatorHasBeenSet() const { return m_parDenominatorHasBeenSet; }
    inline void SetParDenominator(int value) { m_parDenominatorHasBeenSet = true; m_parDenominator = value; }
    inline H265Settings& WithParDenominator(int value) { SetParDenominator(value); return *this;}
 
 
    inline int GetParNumerator() const{ return m_parNumerator; }
    inline bool ParNumeratorHasBeenSet() const { return m_parNumeratorHasBeenSet; }
    inline void SetParNumerator(int value) { m_parNumeratorHasBeenSet = true; m_parNumerator = value; }
    inline H265Settings& WithParNumerator(int value) { SetParNumerator(value); return *this;}
 
 
    inline const H265Profile& GetProfile() const{ return m_profile; }
    inline bool ProfileHasBeenSet() const { return m_profileHasBeenSet; }
    inline void SetProfile(const H265Profile& value) { m_profileHasBeenSet = true; m_profile = value; }
    inline void SetProfile(H265Profile&& value) { m_profileHasBeenSet = true; m_profile = std::move(value); }
    inline H265Settings& WithProfile(const H265Profile& value) { SetProfile(value); return *this;}
    inline H265Settings& WithProfile(H265Profile&& value) { SetProfile(std::move(value)); return *this;}
 
 
    inline int GetQvbrQualityLevel() const{ return m_qvbrQualityLevel; }
    inline bool QvbrQualityLevelHasBeenSet() const { return m_qvbrQualityLevelHasBeenSet; }
    inline void SetQvbrQualityLevel(int value) { m_qvbrQualityLevelHasBeenSet = true; m_qvbrQualityLevel = value; }
    inline H265Settings& WithQvbrQualityLevel(int value) { SetQvbrQualityLevel(value); return *this;}
 
 
    inline const H265RateControlMode& GetRateControlMode() const{ return m_rateControlMode; }
    inline bool RateControlModeHasBeenSet() const { return m_rateControlModeHasBeenSet; }
    inline void SetRateControlMode(const H265RateControlMode& value) { m_rateControlModeHasBeenSet = true; m_rateControlMode = value; }
    inline void SetRateControlMode(H265RateControlMode&& value) { m_rateControlModeHasBeenSet = true; m_rateControlMode = std::move(value); }
    inline H265Settings& WithRateControlMode(const H265RateControlMode& value) { SetRateControlMode(value); return *this;}
    inline H265Settings& WithRateControlMode(H265RateControlMode&& value) { SetRateControlMode(std::move(value)); return *this;}
 
 
    inline const H265ScanType& GetScanType() const{ return m_scanType; }
    inline bool ScanTypeHasBeenSet() const { return m_scanTypeHasBeenSet; }
    inline void SetScanType(const H265ScanType& value) { m_scanTypeHasBeenSet = true; m_scanType = value; }
    inline void SetScanType(H265ScanType&& value) { m_scanTypeHasBeenSet = true; m_scanType = std::move(value); }
    inline H265Settings& WithScanType(const H265ScanType& value) { SetScanType(value); return *this;}
    inline H265Settings& WithScanType(H265ScanType&& value) { SetScanType(std::move(value)); return *this;}
 
 
    inline const H265SceneChangeDetect& GetSceneChangeDetect() const{ return m_sceneChangeDetect; }
    inline bool SceneChangeDetectHasBeenSet() const { return m_sceneChangeDetectHasBeenSet; }
    inline void SetSceneChangeDetect(const H265SceneChangeDetect& value) { m_sceneChangeDetectHasBeenSet = true; m_sceneChangeDetect = value; }
    inline void SetSceneChangeDetect(H265SceneChangeDetect&& value) { m_sceneChangeDetectHasBeenSet = true; m_sceneChangeDetect = std::move(value); }
    inline H265Settings& WithSceneChangeDetect(const H265SceneChangeDetect& value) { SetSceneChangeDetect(value); return *this;}
    inline H265Settings& WithSceneChangeDetect(H265SceneChangeDetect&& value) { SetSceneChangeDetect(std::move(value)); return *this;}
 
 
    inline int GetSlices() const{ return m_slices; }
    inline bool SlicesHasBeenSet() const { return m_slicesHasBeenSet; }
    inline void SetSlices(int value) { m_slicesHasBeenSet = true; m_slices = value; }
    inline H265Settings& WithSlices(int value) { SetSlices(value); return *this;}
 
 
    inline const H265Tier& GetTier() const{ return m_tier; }
    inline bool TierHasBeenSet() const { return m_tierHasBeenSet; }
    inline void SetTier(const H265Tier& value) { m_tierHasBeenSet = true; m_tier = value; }
    inline void SetTier(H265Tier&& value) { m_tierHasBeenSet = true; m_tier = std::move(value); }
    inline H265Settings& WithTier(const H265Tier& value) { SetTier(value); return *this;}
    inline H265Settings& WithTier(H265Tier&& value) { SetTier(std::move(value)); return *this;}
 
 
    inline const H265TimecodeInsertionBehavior& GetTimecodeInsertion() const{ return m_timecodeInsertion; }
    inline bool TimecodeInsertionHasBeenSet() const { return m_timecodeInsertionHasBeenSet; }
    inline void SetTimecodeInsertion(const H265TimecodeInsertionBehavior& value) { m_timecodeInsertionHasBeenSet = true; m_timecodeInsertion = value; }
    inline void SetTimecodeInsertion(H265TimecodeInsertionBehavior&& value) { m_timecodeInsertionHasBeenSet = true; m_timecodeInsertion = std::move(value); }
    inline H265Settings& WithTimecodeInsertion(const H265TimecodeInsertionBehavior& value) { SetTimecodeInsertion(value); return *this;}
    inline H265Settings& WithTimecodeInsertion(H265TimecodeInsertionBehavior&& value) { SetTimecodeInsertion(std::move(value)); return *this;}
 
 
    inline const TimecodeBurninSettings& GetTimecodeBurninSettings() const{ return m_timecodeBurninSettings; }
    inline bool TimecodeBurninSettingsHasBeenSet() const { return m_timecodeBurninSettingsHasBeenSet; }
    inline void SetTimecodeBurninSettings(const TimecodeBurninSettings& value) { m_timecodeBurninSettingsHasBeenSet = true; m_timecodeBurninSettings = value; }
    inline void SetTimecodeBurninSettings(TimecodeBurninSettings&& value) { m_timecodeBurninSettingsHasBeenSet = true; m_timecodeBurninSettings = std::move(value); }
    inline H265Settings& WithTimecodeBurninSettings(const TimecodeBurninSettings& value) { SetTimecodeBurninSettings(value); return *this;}
    inline H265Settings& WithTimecodeBurninSettings(TimecodeBurninSettings&& value) { SetTimecodeBurninSettings(std::move(value)); return *this;}
 
 
    inline const H265MvOverPictureBoundaries& GetMvOverPictureBoundaries() const{ return m_mvOverPictureBoundaries; }
    inline bool MvOverPictureBoundariesHasBeenSet() const { return m_mvOverPictureBoundariesHasBeenSet; }
    inline void SetMvOverPictureBoundaries(const H265MvOverPictureBoundaries& value) { m_mvOverPictureBoundariesHasBeenSet = true; m_mvOverPictureBoundaries = value; }
    inline void SetMvOverPictureBoundaries(H265MvOverPictureBoundaries&& value) { m_mvOverPictureBoundariesHasBeenSet = true; m_mvOverPictureBoundaries = std::move(value); }
    inline H265Settings& WithMvOverPictureBoundaries(const H265MvOverPictureBoundaries& value) { SetMvOverPictureBoundaries(value); return *this;}
    inline H265Settings& WithMvOverPictureBoundaries(H265MvOverPictureBoundaries&& value) { SetMvOverPictureBoundaries(std::move(value)); return *this;}
 
 
    inline const H265MvTemporalPredictor& GetMvTemporalPredictor() const{ return m_mvTemporalPredictor; }
    inline bool MvTemporalPredictorHasBeenSet() const { return m_mvTemporalPredictorHasBeenSet; }
    inline void SetMvTemporalPredictor(const H265MvTemporalPredictor& value) { m_mvTemporalPredictorHasBeenSet = true; m_mvTemporalPredictor = value; }
    inline void SetMvTemporalPredictor(H265MvTemporalPredictor&& value) { m_mvTemporalPredictorHasBeenSet = true; m_mvTemporalPredictor = std::move(value); }
    inline H265Settings& WithMvTemporalPredictor(const H265MvTemporalPredictor& value) { SetMvTemporalPredictor(value); return *this;}
    inline H265Settings& WithMvTemporalPredictor(H265MvTemporalPredictor&& value) { SetMvTemporalPredictor(std::move(value)); return *this;}
 
 
    inline int GetTileHeight() const{ return m_tileHeight; }
    inline bool TileHeightHasBeenSet() const { return m_tileHeightHasBeenSet; }
    inline void SetTileHeight(int value) { m_tileHeightHasBeenSet = true; m_tileHeight = value; }
    inline H265Settings& WithTileHeight(int value) { SetTileHeight(value); return *this;}
 
 
    inline const H265TilePadding& GetTilePadding() const{ return m_tilePadding; }
    inline bool TilePaddingHasBeenSet() const { return m_tilePaddingHasBeenSet; }
    inline void SetTilePadding(const H265TilePadding& value) { m_tilePaddingHasBeenSet = true; m_tilePadding = value; }
    inline void SetTilePadding(H265TilePadding&& value) { m_tilePaddingHasBeenSet = true; m_tilePadding = std::move(value); }
    inline H265Settings& WithTilePadding(const H265TilePadding& value) { SetTilePadding(value); return *this;}
    inline H265Settings& WithTilePadding(H265TilePadding&& value) { SetTilePadding(std::move(value)); return *this;}
 
 
    inline int GetTileWidth() const{ return m_tileWidth; }
    inline bool TileWidthHasBeenSet() const { return m_tileWidthHasBeenSet; }
    inline void SetTileWidth(int value) { m_tileWidthHasBeenSet = true; m_tileWidth = value; }
    inline H265Settings& WithTileWidth(int value) { SetTileWidth(value); return *this;}
 
 
    inline const H265TreeblockSize& GetTreeblockSize() const{ return m_treeblockSize; }
    inline bool TreeblockSizeHasBeenSet() const { return m_treeblockSizeHasBeenSet; }
    inline void SetTreeblockSize(const H265TreeblockSize& value) { m_treeblockSizeHasBeenSet = true; m_treeblockSize = value; }
    inline void SetTreeblockSize(H265TreeblockSize&& value) { m_treeblockSizeHasBeenSet = true; m_treeblockSize = std::move(value); }
    inline H265Settings& WithTreeblockSize(const H265TreeblockSize& value) { SetTreeblockSize(value); return *this;}
    inline H265Settings& WithTreeblockSize(H265TreeblockSize&& value) { SetTreeblockSize(std::move(value)); return *this;}
 
 
    inline int GetMinQp() const{ return m_minQp; }
    inline bool MinQpHasBeenSet() const { return m_minQpHasBeenSet; }
    inline void SetMinQp(int value) { m_minQpHasBeenSet = true; m_minQp = value; }
    inline H265Settings& WithMinQp(int value) { SetMinQp(value); return *this;}
  private:
 
    H265AdaptiveQuantization m_adaptiveQuantization;
    bool m_adaptiveQuantizationHasBeenSet = false;
 
    AfdSignaling m_afdSignaling;
    bool m_afdSignalingHasBeenSet = false;
 
    H265AlternativeTransferFunction m_alternativeTransferFunction;
    bool m_alternativeTransferFunctionHasBeenSet = false;
 
    int m_bitrate;
    bool m_bitrateHasBeenSet = false;
 
    int m_bufSize;
    bool m_bufSizeHasBeenSet = false;
 
    H265ColorMetadata m_colorMetadata;
    bool m_colorMetadataHasBeenSet = false;
 
    H265ColorSpaceSettings m_colorSpaceSettings;
    bool m_colorSpaceSettingsHasBeenSet = false;
 
    H265FilterSettings m_filterSettings;
    bool m_filterSettingsHasBeenSet = false;
 
    FixedAfd m_fixedAfd;
    bool m_fixedAfdHasBeenSet = false;
 
    H265FlickerAq m_flickerAq;
    bool m_flickerAqHasBeenSet = false;
 
    int m_framerateDenominator;
    bool m_framerateDenominatorHasBeenSet = false;
 
    int m_framerateNumerator;
    bool m_framerateNumeratorHasBeenSet = false;
 
    int m_gopClosedCadence;
    bool m_gopClosedCadenceHasBeenSet = false;
 
    double m_gopSize;
    bool m_gopSizeHasBeenSet = false;
 
    H265GopSizeUnits m_gopSizeUnits;
    bool m_gopSizeUnitsHasBeenSet = false;
 
    H265Level m_level;
    bool m_levelHasBeenSet = false;
 
    H265LookAheadRateControl m_lookAheadRateControl;
    bool m_lookAheadRateControlHasBeenSet = false;
 
    int m_maxBitrate;
    bool m_maxBitrateHasBeenSet = false;
 
    int m_minIInterval;
    bool m_minIIntervalHasBeenSet = false;
 
    int m_parDenominator;
    bool m_parDenominatorHasBeenSet = false;
 
    int m_parNumerator;
    bool m_parNumeratorHasBeenSet = false;
 
    H265Profile m_profile;
    bool m_profileHasBeenSet = false;
 
    int m_qvbrQualityLevel;
    bool m_qvbrQualityLevelHasBeenSet = false;
 
    H265RateControlMode m_rateControlMode;
    bool m_rateControlModeHasBeenSet = false;
 
    H265ScanType m_scanType;
    bool m_scanTypeHasBeenSet = false;
 
    H265SceneChangeDetect m_sceneChangeDetect;
    bool m_sceneChangeDetectHasBeenSet = false;
 
    int m_slices;
    bool m_slicesHasBeenSet = false;
 
    H265Tier m_tier;
    bool m_tierHasBeenSet = false;
 
    H265TimecodeInsertionBehavior m_timecodeInsertion;
    bool m_timecodeInsertionHasBeenSet = false;
 
    TimecodeBurninSettings m_timecodeBurninSettings;
    bool m_timecodeBurninSettingsHasBeenSet = false;
 
    H265MvOverPictureBoundaries m_mvOverPictureBoundaries;
    bool m_mvOverPictureBoundariesHasBeenSet = false;
 
    H265MvTemporalPredictor m_mvTemporalPredictor;
    bool m_mvTemporalPredictorHasBeenSet = false;
 
    int m_tileHeight;
    bool m_tileHeightHasBeenSet = false;
 
    H265TilePadding m_tilePadding;
    bool m_tilePaddingHasBeenSet = false;
 
    int m_tileWidth;
    bool m_tileWidthHasBeenSet = false;
 
    H265TreeblockSize m_treeblockSize;
    bool m_treeblockSizeHasBeenSet = false;
 
    int m_minQp;
    bool m_minQpHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaLive
} // namespace Aws