H265Settings.h

 
#pragma once
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/H265AdaptiveQuantization.h>
#include <aws/mediaconvert/model/H265AlternateTransferFunctionSei.h>
#include <aws/mediaconvert/model/BandwidthReductionFilter.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/H265ParControl.h>
#include <aws/core/utils/memory/stl/AWSVector.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/H265Tiles.h>
#include <aws/mediaconvert/model/H265UnregisteredSeiTimecode.h>
#include <aws/mediaconvert/model/H265WriteMp4PackagingType.h>
#include <aws/mediaconvert/model/FrameMetricType.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 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 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 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 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};
    bool m_adaptiveQuantizationHasBeenSet = false;
 
    H265AlternateTransferFunctionSei m_alternateTransferFunctionSei{H265AlternateTransferFunctionSei::NOT_SET};
    bool m_alternateTransferFunctionSeiHasBeenSet = false;
 
    BandwidthReductionFilter m_bandwidthReductionFilter;
    bool m_bandwidthReductionFilterHasBeenSet = false;
 
    int m_bitrate{0};
    bool m_bitrateHasBeenSet = false;
 
    H265CodecLevel m_codecLevel{H265CodecLevel::NOT_SET};
    bool m_codecLevelHasBeenSet = false;
 
    H265CodecProfile m_codecProfile{H265CodecProfile::NOT_SET};
    bool m_codecProfileHasBeenSet = false;
 
    H265Deblocking m_deblocking{H265Deblocking::NOT_SET};
    bool m_deblockingHasBeenSet = false;
 
    H265DynamicSubGop m_dynamicSubGop{H265DynamicSubGop::NOT_SET};
    bool m_dynamicSubGopHasBeenSet = false;
 
    H265EndOfStreamMarkers m_endOfStreamMarkers{H265EndOfStreamMarkers::NOT_SET};
    bool m_endOfStreamMarkersHasBeenSet = false;
 
    H265FlickerAdaptiveQuantization m_flickerAdaptiveQuantization{H265FlickerAdaptiveQuantization::NOT_SET};
    bool m_flickerAdaptiveQuantizationHasBeenSet = false;
 
    H265FramerateControl m_framerateControl{H265FramerateControl::NOT_SET};
    bool m_framerateControlHasBeenSet = false;
 
    H265FramerateConversionAlgorithm m_framerateConversionAlgorithm{H265FramerateConversionAlgorithm::NOT_SET};
    bool m_framerateConversionAlgorithmHasBeenSet = false;
 
    int m_framerateDenominator{0};
    bool m_framerateDenominatorHasBeenSet = false;
 
    int m_framerateNumerator{0};
    bool m_framerateNumeratorHasBeenSet = false;
 
    H265GopBReference m_gopBReference{H265GopBReference::NOT_SET};
    bool m_gopBReferenceHasBeenSet = false;
 
    int m_gopClosedCadence{0};
    bool m_gopClosedCadenceHasBeenSet = false;
 
    double m_gopSize{0.0};
    bool m_gopSizeHasBeenSet = false;
 
    H265GopSizeUnits m_gopSizeUnits{H265GopSizeUnits::NOT_SET};
    bool m_gopSizeUnitsHasBeenSet = false;
 
    int m_hrdBufferFinalFillPercentage{0};
    bool m_hrdBufferFinalFillPercentageHasBeenSet = false;
 
    int m_hrdBufferInitialFillPercentage{0};
    bool m_hrdBufferInitialFillPercentageHasBeenSet = false;
 
    int m_hrdBufferSize{0};
    bool m_hrdBufferSizeHasBeenSet = false;
 
    H265InterlaceMode m_interlaceMode{H265InterlaceMode::NOT_SET};
    bool m_interlaceModeHasBeenSet = false;
 
    int m_maxBitrate{0};
    bool m_maxBitrateHasBeenSet = false;
 
    int m_minIInterval{0};
    bool m_minIIntervalHasBeenSet = false;
 
    int m_numberBFramesBetweenReferenceFrames{0};
    bool m_numberBFramesBetweenReferenceFramesHasBeenSet = false;
 
    int m_numberReferenceFrames{0};
    bool m_numberReferenceFramesHasBeenSet = false;
 
    H265ParControl m_parControl{H265ParControl::NOT_SET};
    bool m_parControlHasBeenSet = false;
 
    int m_parDenominator{0};
    bool m_parDenominatorHasBeenSet = false;
 
    int m_parNumerator{0};
    bool m_parNumeratorHasBeenSet = false;
 
    Aws::Vector<FrameMetricType> m_perFrameMetrics;
    bool m_perFrameMetricsHasBeenSet = false;
 
    H265QualityTuningLevel m_qualityTuningLevel{H265QualityTuningLevel::NOT_SET};
    bool m_qualityTuningLevelHasBeenSet = false;
 
    H265QvbrSettings m_qvbrSettings;
    bool m_qvbrSettingsHasBeenSet = false;
 
    H265RateControlMode m_rateControlMode{H265RateControlMode::NOT_SET};
    bool m_rateControlModeHasBeenSet = false;
 
    H265SampleAdaptiveOffsetFilterMode m_sampleAdaptiveOffsetFilterMode{H265SampleAdaptiveOffsetFilterMode::NOT_SET};
    bool m_sampleAdaptiveOffsetFilterModeHasBeenSet = false;
 
    H265ScanTypeConversionMode m_scanTypeConversionMode{H265ScanTypeConversionMode::NOT_SET};
    bool m_scanTypeConversionModeHasBeenSet = false;
 
    H265SceneChangeDetect m_sceneChangeDetect{H265SceneChangeDetect::NOT_SET};
    bool m_sceneChangeDetectHasBeenSet = false;
 
    int m_slices{0};
    bool m_slicesHasBeenSet = false;
 
    H265SlowPal m_slowPal{H265SlowPal::NOT_SET};
    bool m_slowPalHasBeenSet = false;
 
    H265SpatialAdaptiveQuantization m_spatialAdaptiveQuantization{H265SpatialAdaptiveQuantization::NOT_SET};
    bool m_spatialAdaptiveQuantizationHasBeenSet = false;
 
    H265Telecine m_telecine{H265Telecine::NOT_SET};
    bool m_telecineHasBeenSet = false;
 
    H265TemporalAdaptiveQuantization m_temporalAdaptiveQuantization{H265TemporalAdaptiveQuantization::NOT_SET};
    bool m_temporalAdaptiveQuantizationHasBeenSet = false;
 
    H265TemporalIds m_temporalIds{H265TemporalIds::NOT_SET};
    bool m_temporalIdsHasBeenSet = false;
 
    H265Tiles m_tiles{H265Tiles::NOT_SET};
    bool m_tilesHasBeenSet = false;
 
    H265UnregisteredSeiTimecode m_unregisteredSeiTimecode{H265UnregisteredSeiTimecode::NOT_SET};
    bool m_unregisteredSeiTimecodeHasBeenSet = false;
 
    H265WriteMp4PackagingType m_writeMp4PackagingType{H265WriteMp4PackagingType::NOT_SET};
    bool m_writeMp4PackagingTypeHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaConvert
} // namespace Aws