Mpeg2Settings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/FrameMetricType.h>
#include <aws/mediaconvert/model/Mpeg2AdaptiveQuantization.h>
#include <aws/mediaconvert/model/Mpeg2CodecLevel.h>
#include <aws/mediaconvert/model/Mpeg2CodecProfile.h>
#include <aws/mediaconvert/model/Mpeg2DynamicSubGop.h>
#include <aws/mediaconvert/model/Mpeg2FramerateControl.h>
#include <aws/mediaconvert/model/Mpeg2FramerateConversionAlgorithm.h>
#include <aws/mediaconvert/model/Mpeg2GopSizeUnits.h>
#include <aws/mediaconvert/model/Mpeg2InterlaceMode.h>
#include <aws/mediaconvert/model/Mpeg2IntraDcPrecision.h>
#include <aws/mediaconvert/model/Mpeg2ParControl.h>
#include <aws/mediaconvert/model/Mpeg2QualityTuningLevel.h>
#include <aws/mediaconvert/model/Mpeg2RateControlMode.h>
#include <aws/mediaconvert/model/Mpeg2ScanTypeConversionMode.h>
#include <aws/mediaconvert/model/Mpeg2SceneChangeDetect.h>
#include <aws/mediaconvert/model/Mpeg2SlowPal.h>
#include <aws/mediaconvert/model/Mpeg2SpatialAdaptiveQuantization.h>
#include <aws/mediaconvert/model/Mpeg2Syntax.h>
#include <aws/mediaconvert/model/Mpeg2Telecine.h>
#include <aws/mediaconvert/model/Mpeg2TemporalAdaptiveQuantization.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class Mpeg2Settings {
 public:
  AWS_MEDIACONVERT_API Mpeg2Settings() = default;
  AWS_MEDIACONVERT_API Mpeg2Settings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Mpeg2Settings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline Mpeg2AdaptiveQuantization GetAdaptiveQuantization() const { return m_adaptiveQuantization; }
  inline bool AdaptiveQuantizationHasBeenSet() const { return m_adaptiveQuantizationHasBeenSet; }
  inline void SetAdaptiveQuantization(Mpeg2AdaptiveQuantization value) {
    m_adaptiveQuantizationHasBeenSet = true;
    m_adaptiveQuantization = value;
  }
  inline Mpeg2Settings& WithAdaptiveQuantization(Mpeg2AdaptiveQuantization value) {
    SetAdaptiveQuantization(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 Mpeg2Settings& WithBitrate(int value) {
    SetBitrate(value);
    return *this;
  }
 
 
  inline Mpeg2CodecLevel GetCodecLevel() const { return m_codecLevel; }
  inline bool CodecLevelHasBeenSet() const { return m_codecLevelHasBeenSet; }
  inline void SetCodecLevel(Mpeg2CodecLevel value) {
    m_codecLevelHasBeenSet = true;
    m_codecLevel = value;
  }
  inline Mpeg2Settings& WithCodecLevel(Mpeg2CodecLevel value) {
    SetCodecLevel(value);
    return *this;
  }
 
 
  inline Mpeg2CodecProfile GetCodecProfile() const { return m_codecProfile; }
  inline bool CodecProfileHasBeenSet() const { return m_codecProfileHasBeenSet; }
  inline void SetCodecProfile(Mpeg2CodecProfile value) {
    m_codecProfileHasBeenSet = true;
    m_codecProfile = value;
  }
  inline Mpeg2Settings& WithCodecProfile(Mpeg2CodecProfile value) {
    SetCodecProfile(value);
    return *this;
  }
 
 
  inline Mpeg2DynamicSubGop GetDynamicSubGop() const { return m_dynamicSubGop; }
  inline bool DynamicSubGopHasBeenSet() const { return m_dynamicSubGopHasBeenSet; }
  inline void SetDynamicSubGop(Mpeg2DynamicSubGop value) {
    m_dynamicSubGopHasBeenSet = true;
    m_dynamicSubGop = value;
  }
  inline Mpeg2Settings& WithDynamicSubGop(Mpeg2DynamicSubGop value) {
    SetDynamicSubGop(value);
    return *this;
  }
 
 
  inline Mpeg2FramerateControl GetFramerateControl() const { return m_framerateControl; }
  inline bool FramerateControlHasBeenSet() const { return m_framerateControlHasBeenSet; }
  inline void SetFramerateControl(Mpeg2FramerateControl value) {
    m_framerateControlHasBeenSet = true;
    m_framerateControl = value;
  }
  inline Mpeg2Settings& WithFramerateControl(Mpeg2FramerateControl value) {
    SetFramerateControl(value);
    return *this;
  }
 
 
  inline Mpeg2FramerateConversionAlgorithm GetFramerateConversionAlgorithm() const { return m_framerateConversionAlgorithm; }
  inline bool FramerateConversionAlgorithmHasBeenSet() const { return m_framerateConversionAlgorithmHasBeenSet; }
  inline void SetFramerateConversionAlgorithm(Mpeg2FramerateConversionAlgorithm value) {
    m_framerateConversionAlgorithmHasBeenSet = true;
    m_framerateConversionAlgorithm = value;
  }
  inline Mpeg2Settings& WithFramerateConversionAlgorithm(Mpeg2FramerateConversionAlgorithm 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 Mpeg2Settings& 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 Mpeg2Settings& 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 Mpeg2Settings& 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 Mpeg2Settings& WithGopSize(double value) {
    SetGopSize(value);
    return *this;
  }
 
 
  inline Mpeg2GopSizeUnits GetGopSizeUnits() const { return m_gopSizeUnits; }
  inline bool GopSizeUnitsHasBeenSet() const { return m_gopSizeUnitsHasBeenSet; }
  inline void SetGopSizeUnits(Mpeg2GopSizeUnits value) {
    m_gopSizeUnitsHasBeenSet = true;
    m_gopSizeUnits = value;
  }
  inline Mpeg2Settings& WithGopSizeUnits(Mpeg2GopSizeUnits 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 Mpeg2Settings& 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 Mpeg2Settings& 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 Mpeg2Settings& WithHrdBufferSize(int value) {
    SetHrdBufferSize(value);
    return *this;
  }
 
 
  inline Mpeg2InterlaceMode GetInterlaceMode() const { return m_interlaceMode; }
  inline bool InterlaceModeHasBeenSet() const { return m_interlaceModeHasBeenSet; }
  inline void SetInterlaceMode(Mpeg2InterlaceMode value) {
    m_interlaceModeHasBeenSet = true;
    m_interlaceMode = value;
  }
  inline Mpeg2Settings& WithInterlaceMode(Mpeg2InterlaceMode value) {
    SetInterlaceMode(value);
    return *this;
  }
 
 
  inline Mpeg2IntraDcPrecision GetIntraDcPrecision() const { return m_intraDcPrecision; }
  inline bool IntraDcPrecisionHasBeenSet() const { return m_intraDcPrecisionHasBeenSet; }
  inline void SetIntraDcPrecision(Mpeg2IntraDcPrecision value) {
    m_intraDcPrecisionHasBeenSet = true;
    m_intraDcPrecision = value;
  }
  inline Mpeg2Settings& WithIntraDcPrecision(Mpeg2IntraDcPrecision value) {
    SetIntraDcPrecision(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 Mpeg2Settings& 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 Mpeg2Settings& 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 Mpeg2Settings& WithNumberBFramesBetweenReferenceFrames(int value) {
    SetNumberBFramesBetweenReferenceFrames(value);
    return *this;
  }
 
 
  inline Mpeg2ParControl GetParControl() const { return m_parControl; }
  inline bool ParControlHasBeenSet() const { return m_parControlHasBeenSet; }
  inline void SetParControl(Mpeg2ParControl value) {
    m_parControlHasBeenSet = true;
    m_parControl = value;
  }
  inline Mpeg2Settings& WithParControl(Mpeg2ParControl 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 Mpeg2Settings& 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 Mpeg2Settings& 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>>
  Mpeg2Settings& WithPerFrameMetrics(PerFrameMetricsT&& value) {
    SetPerFrameMetrics(std::forward<PerFrameMetricsT>(value));
    return *this;
  }
  inline Mpeg2Settings& AddPerFrameMetrics(FrameMetricType value) {
    m_perFrameMetricsHasBeenSet = true;
    m_perFrameMetrics.push_back(value);
    return *this;
  }
 
 
  inline Mpeg2QualityTuningLevel GetQualityTuningLevel() const { return m_qualityTuningLevel; }
  inline bool QualityTuningLevelHasBeenSet() const { return m_qualityTuningLevelHasBeenSet; }
  inline void SetQualityTuningLevel(Mpeg2QualityTuningLevel value) {
    m_qualityTuningLevelHasBeenSet = true;
    m_qualityTuningLevel = value;
  }
  inline Mpeg2Settings& WithQualityTuningLevel(Mpeg2QualityTuningLevel value) {
    SetQualityTuningLevel(value);
    return *this;
  }
 
 
  inline Mpeg2RateControlMode GetRateControlMode() const { return m_rateControlMode; }
  inline bool RateControlModeHasBeenSet() const { return m_rateControlModeHasBeenSet; }
  inline void SetRateControlMode(Mpeg2RateControlMode value) {
    m_rateControlModeHasBeenSet = true;
    m_rateControlMode = value;
  }
  inline Mpeg2Settings& WithRateControlMode(Mpeg2RateControlMode value) {
    SetRateControlMode(value);
    return *this;
  }
 
 
  inline Mpeg2ScanTypeConversionMode GetScanTypeConversionMode() const { return m_scanTypeConversionMode; }
  inline bool ScanTypeConversionModeHasBeenSet() const { return m_scanTypeConversionModeHasBeenSet; }
  inline void SetScanTypeConversionMode(Mpeg2ScanTypeConversionMode value) {
    m_scanTypeConversionModeHasBeenSet = true;
    m_scanTypeConversionMode = value;
  }
  inline Mpeg2Settings& WithScanTypeConversionMode(Mpeg2ScanTypeConversionMode value) {
    SetScanTypeConversionMode(value);
    return *this;
  }
 
 
  inline Mpeg2SceneChangeDetect GetSceneChangeDetect() const { return m_sceneChangeDetect; }
  inline bool SceneChangeDetectHasBeenSet() const { return m_sceneChangeDetectHasBeenSet; }
  inline void SetSceneChangeDetect(Mpeg2SceneChangeDetect value) {
    m_sceneChangeDetectHasBeenSet = true;
    m_sceneChangeDetect = value;
  }
  inline Mpeg2Settings& WithSceneChangeDetect(Mpeg2SceneChangeDetect value) {
    SetSceneChangeDetect(value);
    return *this;
  }
 
 
  inline Mpeg2SlowPal GetSlowPal() const { return m_slowPal; }
  inline bool SlowPalHasBeenSet() const { return m_slowPalHasBeenSet; }
  inline void SetSlowPal(Mpeg2SlowPal value) {
    m_slowPalHasBeenSet = true;
    m_slowPal = value;
  }
  inline Mpeg2Settings& WithSlowPal(Mpeg2SlowPal value) {
    SetSlowPal(value);
    return *this;
  }
 
 
  inline int GetSoftness() const { return m_softness; }
  inline bool SoftnessHasBeenSet() const { return m_softnessHasBeenSet; }
  inline void SetSoftness(int value) {
    m_softnessHasBeenSet = true;
    m_softness = value;
  }
  inline Mpeg2Settings& WithSoftness(int value) {
    SetSoftness(value);
    return *this;
  }
 
 
  inline Mpeg2SpatialAdaptiveQuantization GetSpatialAdaptiveQuantization() const { return m_spatialAdaptiveQuantization; }
  inline bool SpatialAdaptiveQuantizationHasBeenSet() const { return m_spatialAdaptiveQuantizationHasBeenSet; }
  inline void SetSpatialAdaptiveQuantization(Mpeg2SpatialAdaptiveQuantization value) {
    m_spatialAdaptiveQuantizationHasBeenSet = true;
    m_spatialAdaptiveQuantization = value;
  }
  inline Mpeg2Settings& WithSpatialAdaptiveQuantization(Mpeg2SpatialAdaptiveQuantization value) {
    SetSpatialAdaptiveQuantization(value);
    return *this;
  }
 
 
  inline Mpeg2Syntax GetSyntax() const { return m_syntax; }
  inline bool SyntaxHasBeenSet() const { return m_syntaxHasBeenSet; }
  inline void SetSyntax(Mpeg2Syntax value) {
    m_syntaxHasBeenSet = true;
    m_syntax = value;
  }
  inline Mpeg2Settings& WithSyntax(Mpeg2Syntax value) {
    SetSyntax(value);
    return *this;
  }
 
 
  inline Mpeg2Telecine GetTelecine() const { return m_telecine; }
  inline bool TelecineHasBeenSet() const { return m_telecineHasBeenSet; }
  inline void SetTelecine(Mpeg2Telecine value) {
    m_telecineHasBeenSet = true;
    m_telecine = value;
  }
  inline Mpeg2Settings& WithTelecine(Mpeg2Telecine value) {
    SetTelecine(value);
    return *this;
  }
 
 
  inline Mpeg2TemporalAdaptiveQuantization GetTemporalAdaptiveQuantization() const { return m_temporalAdaptiveQuantization; }
  inline bool TemporalAdaptiveQuantizationHasBeenSet() const { return m_temporalAdaptiveQuantizationHasBeenSet; }
  inline void SetTemporalAdaptiveQuantization(Mpeg2TemporalAdaptiveQuantization value) {
    m_temporalAdaptiveQuantizationHasBeenSet = true;
    m_temporalAdaptiveQuantization = value;
  }
  inline Mpeg2Settings& WithTemporalAdaptiveQuantization(Mpeg2TemporalAdaptiveQuantization value) {
    SetTemporalAdaptiveQuantization(value);
    return *this;
  }
 private:
  Mpeg2AdaptiveQuantization m_adaptiveQuantization{Mpeg2AdaptiveQuantization::NOT_SET};
 
  int m_bitrate{0};
 
  Mpeg2CodecLevel m_codecLevel{Mpeg2CodecLevel::NOT_SET};
 
  Mpeg2CodecProfile m_codecProfile{Mpeg2CodecProfile::NOT_SET};
 
  Mpeg2DynamicSubGop m_dynamicSubGop{Mpeg2DynamicSubGop::NOT_SET};
 
  Mpeg2FramerateControl m_framerateControl{Mpeg2FramerateControl::NOT_SET};
 
  Mpeg2FramerateConversionAlgorithm m_framerateConversionAlgorithm{Mpeg2FramerateConversionAlgorithm::NOT_SET};
 
  int m_framerateDenominator{0};
 
  int m_framerateNumerator{0};
 
  int m_gopClosedCadence{0};
 
  double m_gopSize{0.0};
 
  Mpeg2GopSizeUnits m_gopSizeUnits{Mpeg2GopSizeUnits::NOT_SET};
 
  int m_hrdBufferFinalFillPercentage{0};
 
  int m_hrdBufferInitialFillPercentage{0};
 
  int m_hrdBufferSize{0};
 
  Mpeg2InterlaceMode m_interlaceMode{Mpeg2InterlaceMode::NOT_SET};
 
  Mpeg2IntraDcPrecision m_intraDcPrecision{Mpeg2IntraDcPrecision::NOT_SET};
 
  int m_maxBitrate{0};
 
  int m_minIInterval{0};
 
  int m_numberBFramesBetweenReferenceFrames{0};
 
  Mpeg2ParControl m_parControl{Mpeg2ParControl::NOT_SET};
 
  int m_parDenominator{0};
 
  int m_parNumerator{0};
 
  Aws::Vector<FrameMetricType> m_perFrameMetrics;
 
  Mpeg2QualityTuningLevel m_qualityTuningLevel{Mpeg2QualityTuningLevel::NOT_SET};
 
  Mpeg2RateControlMode m_rateControlMode{Mpeg2RateControlMode::NOT_SET};
 
  Mpeg2ScanTypeConversionMode m_scanTypeConversionMode{Mpeg2ScanTypeConversionMode::NOT_SET};
 
  Mpeg2SceneChangeDetect m_sceneChangeDetect{Mpeg2SceneChangeDetect::NOT_SET};
 
  Mpeg2SlowPal m_slowPal{Mpeg2SlowPal::NOT_SET};
 
  int m_softness{0};
 
  Mpeg2SpatialAdaptiveQuantization m_spatialAdaptiveQuantization{Mpeg2SpatialAdaptiveQuantization::NOT_SET};
 
  Mpeg2Syntax m_syntax{Mpeg2Syntax::NOT_SET};
 
  Mpeg2Telecine m_telecine{Mpeg2Telecine::NOT_SET};
 
  Mpeg2TemporalAdaptiveQuantization m_temporalAdaptiveQuantization{Mpeg2TemporalAdaptiveQuantization::NOT_SET};
  bool m_adaptiveQuantizationHasBeenSet = false;
  bool m_bitrateHasBeenSet = false;
  bool m_codecLevelHasBeenSet = false;
  bool m_codecProfileHasBeenSet = false;
  bool m_dynamicSubGopHasBeenSet = false;
  bool m_framerateControlHasBeenSet = false;
  bool m_framerateConversionAlgorithmHasBeenSet = false;
  bool m_framerateDenominatorHasBeenSet = false;
  bool m_framerateNumeratorHasBeenSet = 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_intraDcPrecisionHasBeenSet = false;
  bool m_maxBitrateHasBeenSet = false;
  bool m_minIIntervalHasBeenSet = false;
  bool m_numberBFramesBetweenReferenceFramesHasBeenSet = false;
  bool m_parControlHasBeenSet = false;
  bool m_parDenominatorHasBeenSet = false;
  bool m_parNumeratorHasBeenSet = false;
  bool m_perFrameMetricsHasBeenSet = false;
  bool m_qualityTuningLevelHasBeenSet = false;
  bool m_rateControlModeHasBeenSet = false;
  bool m_scanTypeConversionModeHasBeenSet = false;
  bool m_sceneChangeDetectHasBeenSet = false;
  bool m_slowPalHasBeenSet = false;
  bool m_softnessHasBeenSet = false;
  bool m_spatialAdaptiveQuantizationHasBeenSet = false;
  bool m_syntaxHasBeenSet = false;
  bool m_telecineHasBeenSet = false;
  bool m_temporalAdaptiveQuantizationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws