H265Settings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/BandwidthReductionFilter.h>
#include <aws/mediaconvert/model/FrameMetricType.h>
#include <aws/mediaconvert/model/H265AdaptiveQuantization.h>
#include <aws/mediaconvert/model/H265AlternateTransferFunctionSei.h>
#include <aws/mediaconvert/model/H265CodecLevel.h>
#include <aws/mediaconvert/model/H265CodecProfile.h>
#include <aws/mediaconvert/model/H265Deblocking.h>
#include <aws/mediaconvert/model/H265DynamicSubGop.h>
#include <aws/mediaconvert/model/H265EndOfStreamMarkers.h>
#include <aws/mediaconvert/model/H265FlickerAdaptiveQuantization.h>
#include <aws/mediaconvert/model/H265FramerateControl.h>
#include <aws/mediaconvert/model/H265FramerateConversionAlgorithm.h>
#include <aws/mediaconvert/model/H265GopBReference.h>
#include <aws/mediaconvert/model/H265GopSizeUnits.h>
#include <aws/mediaconvert/model/H265InterlaceMode.h>
#include <aws/mediaconvert/model/H265MvOverPictureBoundaries.h>
#include <aws/mediaconvert/model/H265MvTemporalPredictor.h>
#include <aws/mediaconvert/model/H265ParControl.h>
#include <aws/mediaconvert/model/H265QualityTuningLevel.h>
#include <aws/mediaconvert/model/H265QvbrSettings.h>
#include <aws/mediaconvert/model/H265RateControlMode.h>
#include <aws/mediaconvert/model/H265SampleAdaptiveOffsetFilterMode.h>
#include <aws/mediaconvert/model/H265ScanTypeConversionMode.h>
#include <aws/mediaconvert/model/H265SceneChangeDetect.h>
#include <aws/mediaconvert/model/H265SlowPal.h>
#include <aws/mediaconvert/model/H265SpatialAdaptiveQuantization.h>
#include <aws/mediaconvert/model/H265Telecine.h>
#include <aws/mediaconvert/model/H265TemporalAdaptiveQuantization.h>
#include <aws/mediaconvert/model/H265TemporalIds.h>
#include <aws/mediaconvert/model/H265TilePadding.h>
#include <aws/mediaconvert/model/H265Tiles.h>
#include <aws/mediaconvert/model/H265TreeBlockSize.h>
#include <aws/mediaconvert/model/H265UnregisteredSeiTimecode.h>
#include <aws/mediaconvert/model/H265WriteMp4PackagingType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class H265Settings {
 public:
  AWS_MEDIACONVERT_API H265Settings() = default;
  AWS_MEDIACONVERT_API H265Settings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API H265Settings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline H265AdaptiveQuantization GetAdaptiveQuantization() const { return m_adaptiveQuantization; }
  inline bool AdaptiveQuantizationHasBeenSet() const { return m_adaptiveQuantizationHasBeenSet; }
  inline void SetAdaptiveQuantization(H265AdaptiveQuantization value) {
    m_adaptiveQuantizationHasBeenSet = true;
    m_adaptiveQuantization = value;
  }
  inline H265Settings& WithAdaptiveQuantization(H265AdaptiveQuantization value) {
    SetAdaptiveQuantization(value);
    return *this;
  }
 
 
  inline H265AlternateTransferFunctionSei GetAlternateTransferFunctionSei() const { return m_alternateTransferFunctionSei; }
  inline bool AlternateTransferFunctionSeiHasBeenSet() const { return m_alternateTransferFunctionSeiHasBeenSet; }
  inline void SetAlternateTransferFunctionSei(H265AlternateTransferFunctionSei value) {
    m_alternateTransferFunctionSeiHasBeenSet = true;
    m_alternateTransferFunctionSei = value;
  }
  inline H265Settings& WithAlternateTransferFunctionSei(H265AlternateTransferFunctionSei value) {
    SetAlternateTransferFunctionSei(value);
    return *this;
  }
 
 
  inline const BandwidthReductionFilter& GetBandwidthReductionFilter() const { return m_bandwidthReductionFilter; }
  inline bool BandwidthReductionFilterHasBeenSet() const { return m_bandwidthReductionFilterHasBeenSet; }
  template <typename BandwidthReductionFilterT = BandwidthReductionFilter>
  void SetBandwidthReductionFilter(BandwidthReductionFilterT&& value) {
    m_bandwidthReductionFilterHasBeenSet = true;
    m_bandwidthReductionFilter = std::forward<BandwidthReductionFilterT>(value);
  }
  template <typename BandwidthReductionFilterT = BandwidthReductionFilter>
  H265Settings& WithBandwidthReductionFilter(BandwidthReductionFilterT&& value) {
    SetBandwidthReductionFilter(std::forward<BandwidthReductionFilterT>(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 H265CodecLevel GetCodecLevel() const { return m_codecLevel; }
  inline bool CodecLevelHasBeenSet() const { return m_codecLevelHasBeenSet; }
  inline void SetCodecLevel(H265CodecLevel value) {
    m_codecLevelHasBeenSet = true;
    m_codecLevel = value;
  }
  inline H265Settings& WithCodecLevel(H265CodecLevel value) {
    SetCodecLevel(value);
    return *this;
  }
 
 
  inline H265CodecProfile GetCodecProfile() const { return m_codecProfile; }
  inline bool CodecProfileHasBeenSet() const { return m_codecProfileHasBeenSet; }
  inline void SetCodecProfile(H265CodecProfile value) {
    m_codecProfileHasBeenSet = true;
    m_codecProfile = value;
  }
  inline H265Settings& WithCodecProfile(H265CodecProfile value) {
    SetCodecProfile(value);
    return *this;
  }
 
 
  inline H265Deblocking GetDeblocking() const { return m_deblocking; }
  inline bool DeblockingHasBeenSet() const { return m_deblockingHasBeenSet; }
  inline void SetDeblocking(H265Deblocking value) {
    m_deblockingHasBeenSet = true;
    m_deblocking = value;
  }
  inline H265Settings& WithDeblocking(H265Deblocking value) {
    SetDeblocking(value);
    return *this;
  }
 
 
  inline H265DynamicSubGop GetDynamicSubGop() const { return m_dynamicSubGop; }
  inline bool DynamicSubGopHasBeenSet() const { return m_dynamicSubGopHasBeenSet; }
  inline void SetDynamicSubGop(H265DynamicSubGop value) {
    m_dynamicSubGopHasBeenSet = true;
    m_dynamicSubGop = value;
  }
  inline H265Settings& WithDynamicSubGop(H265DynamicSubGop value) {
    SetDynamicSubGop(value);
    return *this;
  }
 
 
  inline H265EndOfStreamMarkers GetEndOfStreamMarkers() const { return m_endOfStreamMarkers; }
  inline bool EndOfStreamMarkersHasBeenSet() const { return m_endOfStreamMarkersHasBeenSet; }
  inline void SetEndOfStreamMarkers(H265EndOfStreamMarkers value) {
    m_endOfStreamMarkersHasBeenSet = true;
    m_endOfStreamMarkers = value;
  }
  inline H265Settings& WithEndOfStreamMarkers(H265EndOfStreamMarkers value) {
    SetEndOfStreamMarkers(value);
    return *this;
  }
 
 
  inline H265FlickerAdaptiveQuantization GetFlickerAdaptiveQuantization() const { return m_flickerAdaptiveQuantization; }
  inline bool FlickerAdaptiveQuantizationHasBeenSet() const { return m_flickerAdaptiveQuantizationHasBeenSet; }
  inline void SetFlickerAdaptiveQuantization(H265FlickerAdaptiveQuantization value) {
    m_flickerAdaptiveQuantizationHasBeenSet = true;
    m_flickerAdaptiveQuantization = value;
  }
  inline H265Settings& WithFlickerAdaptiveQuantization(H265FlickerAdaptiveQuantization value) {
    SetFlickerAdaptiveQuantization(value);
    return *this;
  }
 
 
  inline H265FramerateControl GetFramerateControl() const { return m_framerateControl; }
  inline bool FramerateControlHasBeenSet() const { return m_framerateControlHasBeenSet; }
  inline void SetFramerateControl(H265FramerateControl value) {
    m_framerateControlHasBeenSet = true;
    m_framerateControl = value;
  }
  inline H265Settings& WithFramerateControl(H265FramerateControl value) {
    SetFramerateControl(value);
    return *this;
  }
 
 
  inline H265FramerateConversionAlgorithm GetFramerateConversionAlgorithm() const { return m_framerateConversionAlgorithm; }
  inline bool FramerateConversionAlgorithmHasBeenSet() const { return m_framerateConversionAlgorithmHasBeenSet; }
  inline void SetFramerateConversionAlgorithm(H265FramerateConversionAlgorithm value) {
    m_framerateConversionAlgorithmHasBeenSet = true;
    m_framerateConversionAlgorithm = value;
  }
  inline H265Settings& WithFramerateConversionAlgorithm(H265FramerateConversionAlgorithm value) {
    SetFramerateConversionAlgorithm(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 H265GopBReference GetGopBReference() const { return m_gopBReference; }
  inline bool GopBReferenceHasBeenSet() const { return m_gopBReferenceHasBeenSet; }
  inline void SetGopBReference(H265GopBReference value) {
    m_gopBReferenceHasBeenSet = true;
    m_gopBReference = value;
  }
  inline H265Settings& WithGopBReference(H265GopBReference value) {
    SetGopBReference(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 H265GopSizeUnits GetGopSizeUnits() const { return m_gopSizeUnits; }
  inline bool GopSizeUnitsHasBeenSet() const { return m_gopSizeUnitsHasBeenSet; }
  inline void SetGopSizeUnits(H265GopSizeUnits value) {
    m_gopSizeUnitsHasBeenSet = true;
    m_gopSizeUnits = value;
  }
  inline H265Settings& WithGopSizeUnits(H265GopSizeUnits value) {
    SetGopSizeUnits(value);
    return *this;
  }
 
 
  inline int GetHrdBufferFinalFillPercentage() const { return m_hrdBufferFinalFillPercentage; }
  inline bool HrdBufferFinalFillPercentageHasBeenSet() const { return m_hrdBufferFinalFillPercentageHasBeenSet; }
  inline void SetHrdBufferFinalFillPercentage(int value) {
    m_hrdBufferFinalFillPercentageHasBeenSet = true;
    m_hrdBufferFinalFillPercentage = value;
  }
  inline H265Settings& WithHrdBufferFinalFillPercentage(int value) {
    SetHrdBufferFinalFillPercentage(value);
    return *this;
  }
 
 
  inline int GetHrdBufferInitialFillPercentage() const { return m_hrdBufferInitialFillPercentage; }
  inline bool HrdBufferInitialFillPercentageHasBeenSet() const { return m_hrdBufferInitialFillPercentageHasBeenSet; }
  inline void SetHrdBufferInitialFillPercentage(int value) {
    m_hrdBufferInitialFillPercentageHasBeenSet = true;
    m_hrdBufferInitialFillPercentage = value;
  }
  inline H265Settings& WithHrdBufferInitialFillPercentage(int value) {
    SetHrdBufferInitialFillPercentage(value);
    return *this;
  }
 
 
  inline int GetHrdBufferSize() const { return m_hrdBufferSize; }
  inline bool HrdBufferSizeHasBeenSet() const { return m_hrdBufferSizeHasBeenSet; }
  inline void SetHrdBufferSize(int value) {
    m_hrdBufferSizeHasBeenSet = true;
    m_hrdBufferSize = value;
  }
  inline H265Settings& WithHrdBufferSize(int value) {
    SetHrdBufferSize(value);
    return *this;
  }
 
 
  inline H265InterlaceMode GetInterlaceMode() const { return m_interlaceMode; }
  inline bool InterlaceModeHasBeenSet() const { return m_interlaceModeHasBeenSet; }
  inline void SetInterlaceMode(H265InterlaceMode value) {
    m_interlaceModeHasBeenSet = true;
    m_interlaceMode = value;
  }
  inline H265Settings& WithInterlaceMode(H265InterlaceMode value) {
    SetInterlaceMode(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 H265MvOverPictureBoundaries GetMvOverPictureBoundaries() const { return m_mvOverPictureBoundaries; }
  inline bool MvOverPictureBoundariesHasBeenSet() const { return m_mvOverPictureBoundariesHasBeenSet; }
  inline void SetMvOverPictureBoundaries(H265MvOverPictureBoundaries value) {
    m_mvOverPictureBoundariesHasBeenSet = true;
    m_mvOverPictureBoundaries = value;
  }
  inline H265Settings& WithMvOverPictureBoundaries(H265MvOverPictureBoundaries value) {
    SetMvOverPictureBoundaries(value);
    return *this;
  }
 
 
  inline H265MvTemporalPredictor GetMvTemporalPredictor() const { return m_mvTemporalPredictor; }
  inline bool MvTemporalPredictorHasBeenSet() const { return m_mvTemporalPredictorHasBeenSet; }
  inline void SetMvTemporalPredictor(H265MvTemporalPredictor value) {
    m_mvTemporalPredictorHasBeenSet = true;
    m_mvTemporalPredictor = value;
  }
  inline H265Settings& WithMvTemporalPredictor(H265MvTemporalPredictor value) {
    SetMvTemporalPredictor(value);
    return *this;
  }
 
 
  inline int GetNumberBFramesBetweenReferenceFrames() const { return m_numberBFramesBetweenReferenceFrames; }
  inline bool NumberBFramesBetweenReferenceFramesHasBeenSet() const { return m_numberBFramesBetweenReferenceFramesHasBeenSet; }
  inline void SetNumberBFramesBetweenReferenceFrames(int value) {
    m_numberBFramesBetweenReferenceFramesHasBeenSet = true;
    m_numberBFramesBetweenReferenceFrames = value;
  }
  inline H265Settings& WithNumberBFramesBetweenReferenceFrames(int value) {
    SetNumberBFramesBetweenReferenceFrames(value);
    return *this;
  }
 
 
  inline int GetNumberReferenceFrames() const { return m_numberReferenceFrames; }
  inline bool NumberReferenceFramesHasBeenSet() const { return m_numberReferenceFramesHasBeenSet; }
  inline void SetNumberReferenceFrames(int value) {
    m_numberReferenceFramesHasBeenSet = true;
    m_numberReferenceFrames = value;
  }
  inline H265Settings& WithNumberReferenceFrames(int value) {
    SetNumberReferenceFrames(value);
    return *this;
  }
 
 
  inline H265ParControl GetParControl() const { return m_parControl; }
  inline bool ParControlHasBeenSet() const { return m_parControlHasBeenSet; }
  inline void SetParControl(H265ParControl value) {
    m_parControlHasBeenSet = true;
    m_parControl = value;
  }
  inline H265Settings& WithParControl(H265ParControl value) {
    SetParControl(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 Aws::Vector<FrameMetricType>& GetPerFrameMetrics() const { return m_perFrameMetrics; }
  inline bool PerFrameMetricsHasBeenSet() const { return m_perFrameMetricsHasBeenSet; }
  template <typename PerFrameMetricsT = Aws::Vector<FrameMetricType>>
  void SetPerFrameMetrics(PerFrameMetricsT&& value) {
    m_perFrameMetricsHasBeenSet = true;
    m_perFrameMetrics = std::forward<PerFrameMetricsT>(value);
  }
  template <typename PerFrameMetricsT = Aws::Vector<FrameMetricType>>
  H265Settings& WithPerFrameMetrics(PerFrameMetricsT&& value) {
    SetPerFrameMetrics(std::forward<PerFrameMetricsT>(value));
    return *this;
  }
  inline H265Settings& AddPerFrameMetrics(FrameMetricType value) {
    m_perFrameMetricsHasBeenSet = true;
    m_perFrameMetrics.push_back(value);
    return *this;
  }
 
 
  inline H265QualityTuningLevel GetQualityTuningLevel() const { return m_qualityTuningLevel; }
  inline bool QualityTuningLevelHasBeenSet() const { return m_qualityTuningLevelHasBeenSet; }
  inline void SetQualityTuningLevel(H265QualityTuningLevel value) {
    m_qualityTuningLevelHasBeenSet = true;
    m_qualityTuningLevel = value;
  }
  inline H265Settings& WithQualityTuningLevel(H265QualityTuningLevel value) {
    SetQualityTuningLevel(value);
    return *this;
  }
 
 
  inline const H265QvbrSettings& GetQvbrSettings() const { return m_qvbrSettings; }
  inline bool QvbrSettingsHasBeenSet() const { return m_qvbrSettingsHasBeenSet; }
  template <typename QvbrSettingsT = H265QvbrSettings>
  void SetQvbrSettings(QvbrSettingsT&& value) {
    m_qvbrSettingsHasBeenSet = true;
    m_qvbrSettings = std::forward<QvbrSettingsT>(value);
  }
  template <typename QvbrSettingsT = H265QvbrSettings>
  H265Settings& WithQvbrSettings(QvbrSettingsT&& value) {
    SetQvbrSettings(std::forward<QvbrSettingsT>(value));
    return *this;
  }
 
 
  inline H265RateControlMode GetRateControlMode() const { return m_rateControlMode; }
  inline bool RateControlModeHasBeenSet() const { return m_rateControlModeHasBeenSet; }
  inline void SetRateControlMode(H265RateControlMode value) {
    m_rateControlModeHasBeenSet = true;
    m_rateControlMode = value;
  }
  inline H265Settings& WithRateControlMode(H265RateControlMode value) {
    SetRateControlMode(value);
    return *this;
  }
 
 
  inline H265SampleAdaptiveOffsetFilterMode GetSampleAdaptiveOffsetFilterMode() const { return m_sampleAdaptiveOffsetFilterMode; }
  inline bool SampleAdaptiveOffsetFilterModeHasBeenSet() const { return m_sampleAdaptiveOffsetFilterModeHasBeenSet; }
  inline void SetSampleAdaptiveOffsetFilterMode(H265SampleAdaptiveOffsetFilterMode value) {
    m_sampleAdaptiveOffsetFilterModeHasBeenSet = true;
    m_sampleAdaptiveOffsetFilterMode = value;
  }
  inline H265Settings& WithSampleAdaptiveOffsetFilterMode(H265SampleAdaptiveOffsetFilterMode value) {
    SetSampleAdaptiveOffsetFilterMode(value);
    return *this;
  }
 
 
  inline H265ScanTypeConversionMode GetScanTypeConversionMode() const { return m_scanTypeConversionMode; }
  inline bool ScanTypeConversionModeHasBeenSet() const { return m_scanTypeConversionModeHasBeenSet; }
  inline void SetScanTypeConversionMode(H265ScanTypeConversionMode value) {
    m_scanTypeConversionModeHasBeenSet = true;
    m_scanTypeConversionMode = value;
  }
  inline H265Settings& WithScanTypeConversionMode(H265ScanTypeConversionMode value) {
    SetScanTypeConversionMode(value);
    return *this;
  }
 
 
  inline H265SceneChangeDetect GetSceneChangeDetect() const { return m_sceneChangeDetect; }
  inline bool SceneChangeDetectHasBeenSet() const { return m_sceneChangeDetectHasBeenSet; }
  inline void SetSceneChangeDetect(H265SceneChangeDetect value) {
    m_sceneChangeDetectHasBeenSet = true;
    m_sceneChangeDetect = value;
  }
  inline H265Settings& WithSceneChangeDetect(H265SceneChangeDetect value) {
    SetSceneChangeDetect(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 int GetSlidingWindowMs() const { return m_slidingWindowMs; }
  inline bool SlidingWindowMsHasBeenSet() const { return m_slidingWindowMsHasBeenSet; }
  inline void SetSlidingWindowMs(int value) {
    m_slidingWindowMsHasBeenSet = true;
    m_slidingWindowMs = value;
  }
  inline H265Settings& WithSlidingWindowMs(int value) {
    SetSlidingWindowMs(value);
    return *this;
  }
 
 
  inline int GetSlidingWindowPeakBitrate() const { return m_slidingWindowPeakBitrate; }
  inline bool SlidingWindowPeakBitrateHasBeenSet() const { return m_slidingWindowPeakBitrateHasBeenSet; }
  inline void SetSlidingWindowPeakBitrate(int value) {
    m_slidingWindowPeakBitrateHasBeenSet = true;
    m_slidingWindowPeakBitrate = value;
  }
  inline H265Settings& WithSlidingWindowPeakBitrate(int value) {
    SetSlidingWindowPeakBitrate(value);
    return *this;
  }
 
 
  inline H265SlowPal GetSlowPal() const { return m_slowPal; }
  inline bool SlowPalHasBeenSet() const { return m_slowPalHasBeenSet; }
  inline void SetSlowPal(H265SlowPal value) {
    m_slowPalHasBeenSet = true;
    m_slowPal = value;
  }
  inline H265Settings& WithSlowPal(H265SlowPal value) {
    SetSlowPal(value);
    return *this;
  }
 
 
  inline H265SpatialAdaptiveQuantization GetSpatialAdaptiveQuantization() const { return m_spatialAdaptiveQuantization; }
  inline bool SpatialAdaptiveQuantizationHasBeenSet() const { return m_spatialAdaptiveQuantizationHasBeenSet; }
  inline void SetSpatialAdaptiveQuantization(H265SpatialAdaptiveQuantization value) {
    m_spatialAdaptiveQuantizationHasBeenSet = true;
    m_spatialAdaptiveQuantization = value;
  }
  inline H265Settings& WithSpatialAdaptiveQuantization(H265SpatialAdaptiveQuantization value) {
    SetSpatialAdaptiveQuantization(value);
    return *this;
  }
 
 
  inline H265Telecine GetTelecine() const { return m_telecine; }
  inline bool TelecineHasBeenSet() const { return m_telecineHasBeenSet; }
  inline void SetTelecine(H265Telecine value) {
    m_telecineHasBeenSet = true;
    m_telecine = value;
  }
  inline H265Settings& WithTelecine(H265Telecine value) {
    SetTelecine(value);
    return *this;
  }
 
 
  inline H265TemporalAdaptiveQuantization GetTemporalAdaptiveQuantization() const { return m_temporalAdaptiveQuantization; }
  inline bool TemporalAdaptiveQuantizationHasBeenSet() const { return m_temporalAdaptiveQuantizationHasBeenSet; }
  inline void SetTemporalAdaptiveQuantization(H265TemporalAdaptiveQuantization value) {
    m_temporalAdaptiveQuantizationHasBeenSet = true;
    m_temporalAdaptiveQuantization = value;
  }
  inline H265Settings& WithTemporalAdaptiveQuantization(H265TemporalAdaptiveQuantization value) {
    SetTemporalAdaptiveQuantization(value);
    return *this;
  }
 
 
  inline H265TemporalIds GetTemporalIds() const { return m_temporalIds; }
  inline bool TemporalIdsHasBeenSet() const { return m_temporalIdsHasBeenSet; }
  inline void SetTemporalIds(H265TemporalIds value) {
    m_temporalIdsHasBeenSet = true;
    m_temporalIds = value;
  }
  inline H265Settings& WithTemporalIds(H265TemporalIds value) {
    SetTemporalIds(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 H265TilePadding GetTilePadding() const { return m_tilePadding; }
  inline bool TilePaddingHasBeenSet() const { return m_tilePaddingHasBeenSet; }
  inline void SetTilePadding(H265TilePadding value) {
    m_tilePaddingHasBeenSet = true;
    m_tilePadding = value;
  }
  inline H265Settings& WithTilePadding(H265TilePadding value) {
    SetTilePadding(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 H265Tiles GetTiles() const { return m_tiles; }
  inline bool TilesHasBeenSet() const { return m_tilesHasBeenSet; }
  inline void SetTiles(H265Tiles value) {
    m_tilesHasBeenSet = true;
    m_tiles = value;
  }
  inline H265Settings& WithTiles(H265Tiles value) {
    SetTiles(value);
    return *this;
  }
 
 
  inline H265TreeBlockSize GetTreeBlockSize() const { return m_treeBlockSize; }
  inline bool TreeBlockSizeHasBeenSet() const { return m_treeBlockSizeHasBeenSet; }
  inline void SetTreeBlockSize(H265TreeBlockSize value) {
    m_treeBlockSizeHasBeenSet = true;
    m_treeBlockSize = value;
  }
  inline H265Settings& WithTreeBlockSize(H265TreeBlockSize value) {
    SetTreeBlockSize(value);
    return *this;
  }
 
 
  inline H265UnregisteredSeiTimecode GetUnregisteredSeiTimecode() const { return m_unregisteredSeiTimecode; }
  inline bool UnregisteredSeiTimecodeHasBeenSet() const { return m_unregisteredSeiTimecodeHasBeenSet; }
  inline void SetUnregisteredSeiTimecode(H265UnregisteredSeiTimecode value) {
    m_unregisteredSeiTimecodeHasBeenSet = true;
    m_unregisteredSeiTimecode = value;
  }
  inline H265Settings& WithUnregisteredSeiTimecode(H265UnregisteredSeiTimecode value) {
    SetUnregisteredSeiTimecode(value);
    return *this;
  }
 
 
  inline H265WriteMp4PackagingType GetWriteMp4PackagingType() const { return m_writeMp4PackagingType; }
  inline bool WriteMp4PackagingTypeHasBeenSet() const { return m_writeMp4PackagingTypeHasBeenSet; }
  inline void SetWriteMp4PackagingType(H265WriteMp4PackagingType value) {
    m_writeMp4PackagingTypeHasBeenSet = true;
    m_writeMp4PackagingType = value;
  }
  inline H265Settings& WithWriteMp4PackagingType(H265WriteMp4PackagingType value) {
    SetWriteMp4PackagingType(value);
    return *this;
  }
 private:
  H265AdaptiveQuantization m_adaptiveQuantization{H265AdaptiveQuantization::NOT_SET};
 
  H265AlternateTransferFunctionSei m_alternateTransferFunctionSei{H265AlternateTransferFunctionSei::NOT_SET};
 
  BandwidthReductionFilter m_bandwidthReductionFilter;
 
  int m_bitrate{0};
 
  H265CodecLevel m_codecLevel{H265CodecLevel::NOT_SET};
 
  H265CodecProfile m_codecProfile{H265CodecProfile::NOT_SET};
 
  H265Deblocking m_deblocking{H265Deblocking::NOT_SET};
 
  H265DynamicSubGop m_dynamicSubGop{H265DynamicSubGop::NOT_SET};
 
  H265EndOfStreamMarkers m_endOfStreamMarkers{H265EndOfStreamMarkers::NOT_SET};
 
  H265FlickerAdaptiveQuantization m_flickerAdaptiveQuantization{H265FlickerAdaptiveQuantization::NOT_SET};
 
  H265FramerateControl m_framerateControl{H265FramerateControl::NOT_SET};
 
  H265FramerateConversionAlgorithm m_framerateConversionAlgorithm{H265FramerateConversionAlgorithm::NOT_SET};
 
  int m_framerateDenominator{0};
 
  int m_framerateNumerator{0};
 
  H265GopBReference m_gopBReference{H265GopBReference::NOT_SET};
 
  int m_gopClosedCadence{0};
 
  double m_gopSize{0.0};
 
  H265GopSizeUnits m_gopSizeUnits{H265GopSizeUnits::NOT_SET};
 
  int m_hrdBufferFinalFillPercentage{0};
 
  int m_hrdBufferInitialFillPercentage{0};
 
  int m_hrdBufferSize{0};
 
  H265InterlaceMode m_interlaceMode{H265InterlaceMode::NOT_SET};
 
  int m_maxBitrate{0};
 
  int m_minIInterval{0};
 
  H265MvOverPictureBoundaries m_mvOverPictureBoundaries{H265MvOverPictureBoundaries::NOT_SET};
 
  H265MvTemporalPredictor m_mvTemporalPredictor{H265MvTemporalPredictor::NOT_SET};
 
  int m_numberBFramesBetweenReferenceFrames{0};
 
  int m_numberReferenceFrames{0};
 
  H265ParControl m_parControl{H265ParControl::NOT_SET};
 
  int m_parDenominator{0};
 
  int m_parNumerator{0};
 
  Aws::Vector<FrameMetricType> m_perFrameMetrics;
 
  H265QualityTuningLevel m_qualityTuningLevel{H265QualityTuningLevel::NOT_SET};
 
  H265QvbrSettings m_qvbrSettings;
 
  H265RateControlMode m_rateControlMode{H265RateControlMode::NOT_SET};
 
  H265SampleAdaptiveOffsetFilterMode m_sampleAdaptiveOffsetFilterMode{H265SampleAdaptiveOffsetFilterMode::NOT_SET};
 
  H265ScanTypeConversionMode m_scanTypeConversionMode{H265ScanTypeConversionMode::NOT_SET};
 
  H265SceneChangeDetect m_sceneChangeDetect{H265SceneChangeDetect::NOT_SET};
 
  int m_slices{0};
 
  int m_slidingWindowMs{0};
 
  int m_slidingWindowPeakBitrate{0};
 
  H265SlowPal m_slowPal{H265SlowPal::NOT_SET};
 
  H265SpatialAdaptiveQuantization m_spatialAdaptiveQuantization{H265SpatialAdaptiveQuantization::NOT_SET};
 
  H265Telecine m_telecine{H265Telecine::NOT_SET};
 
  H265TemporalAdaptiveQuantization m_temporalAdaptiveQuantization{H265TemporalAdaptiveQuantization::NOT_SET};
 
  H265TemporalIds m_temporalIds{H265TemporalIds::NOT_SET};
 
  int m_tileHeight{0};
 
  H265TilePadding m_tilePadding{H265TilePadding::NOT_SET};
 
  int m_tileWidth{0};
 
  H265Tiles m_tiles{H265Tiles::NOT_SET};
 
  H265TreeBlockSize m_treeBlockSize{H265TreeBlockSize::NOT_SET};
 
  H265UnregisteredSeiTimecode m_unregisteredSeiTimecode{H265UnregisteredSeiTimecode::NOT_SET};
 
  H265WriteMp4PackagingType m_writeMp4PackagingType{H265WriteMp4PackagingType::NOT_SET};
  bool m_adaptiveQuantizationHasBeenSet = false;
  bool m_alternateTransferFunctionSeiHasBeenSet = false;
  bool m_bandwidthReductionFilterHasBeenSet = false;
  bool m_bitrateHasBeenSet = false;
  bool m_codecLevelHasBeenSet = false;
  bool m_codecProfileHasBeenSet = false;
  bool m_deblockingHasBeenSet = false;
  bool m_dynamicSubGopHasBeenSet = false;
  bool m_endOfStreamMarkersHasBeenSet = false;
  bool m_flickerAdaptiveQuantizationHasBeenSet = false;
  bool m_framerateControlHasBeenSet = false;
  bool m_framerateConversionAlgorithmHasBeenSet = false;
  bool m_framerateDenominatorHasBeenSet = false;
  bool m_framerateNumeratorHasBeenSet = false;
  bool m_gopBReferenceHasBeenSet = false;
  bool m_gopClosedCadenceHasBeenSet = false;
  bool m_gopSizeHasBeenSet = false;
  bool m_gopSizeUnitsHasBeenSet = false;
  bool m_hrdBufferFinalFillPercentageHasBeenSet = false;
  bool m_hrdBufferInitialFillPercentageHasBeenSet = false;
  bool m_hrdBufferSizeHasBeenSet = false;
  bool m_interlaceModeHasBeenSet = false;
  bool m_maxBitrateHasBeenSet = false;
  bool m_minIIntervalHasBeenSet = false;
  bool m_mvOverPictureBoundariesHasBeenSet = false;
  bool m_mvTemporalPredictorHasBeenSet = false;
  bool m_numberBFramesBetweenReferenceFramesHasBeenSet = false;
  bool m_numberReferenceFramesHasBeenSet = false;
  bool m_parControlHasBeenSet = false;
  bool m_parDenominatorHasBeenSet = false;
  bool m_parNumeratorHasBeenSet = false;
  bool m_perFrameMetricsHasBeenSet = false;
  bool m_qualityTuningLevelHasBeenSet = false;
  bool m_qvbrSettingsHasBeenSet = false;
  bool m_rateControlModeHasBeenSet = false;
  bool m_sampleAdaptiveOffsetFilterModeHasBeenSet = false;
  bool m_scanTypeConversionModeHasBeenSet = false;
  bool m_sceneChangeDetectHasBeenSet = false;
  bool m_slicesHasBeenSet = false;
  bool m_slidingWindowMsHasBeenSet = false;
  bool m_slidingWindowPeakBitrateHasBeenSet = false;
  bool m_slowPalHasBeenSet = false;
  bool m_spatialAdaptiveQuantizationHasBeenSet = false;
  bool m_telecineHasBeenSet = false;
  bool m_temporalAdaptiveQuantizationHasBeenSet = false;
  bool m_temporalIdsHasBeenSet = false;
  bool m_tileHeightHasBeenSet = false;
  bool m_tilePaddingHasBeenSet = false;
  bool m_tileWidthHasBeenSet = false;
  bool m_tilesHasBeenSet = false;
  bool m_treeBlockSizeHasBeenSet = false;
  bool m_unregisteredSeiTimecodeHasBeenSet = false;
  bool m_writeMp4PackagingTypeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws