Av1Settings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/Av1AdaptiveQuantization.h>
#include <aws/mediaconvert/model/Av1BitDepth.h>
#include <aws/mediaconvert/model/Av1FilmGrainSynthesis.h>
#include <aws/mediaconvert/model/Av1FramerateControl.h>
#include <aws/mediaconvert/model/Av1FramerateConversionAlgorithm.h>
#include <aws/mediaconvert/model/Av1QvbrSettings.h>
#include <aws/mediaconvert/model/Av1RateControlMode.h>
#include <aws/mediaconvert/model/Av1SceneChangeDetect.h>
#include <aws/mediaconvert/model/Av1SpatialAdaptiveQuantization.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 Av1Settings {
 public:
  AWS_MEDIACONVERT_API Av1Settings() = default;
  AWS_MEDIACONVERT_API Av1Settings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Av1Settings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline Av1AdaptiveQuantization GetAdaptiveQuantization() const { return m_adaptiveQuantization; }
  inline bool AdaptiveQuantizationHasBeenSet() const { return m_adaptiveQuantizationHasBeenSet; }
  inline void SetAdaptiveQuantization(Av1AdaptiveQuantization value) {
    m_adaptiveQuantizationHasBeenSet = true;
    m_adaptiveQuantization = value;
  }
  inline Av1Settings& WithAdaptiveQuantization(Av1AdaptiveQuantization value) {
    SetAdaptiveQuantization(value);
    return *this;
  }
 
 
  inline Av1BitDepth GetBitDepth() const { return m_bitDepth; }
  inline bool BitDepthHasBeenSet() const { return m_bitDepthHasBeenSet; }
  inline void SetBitDepth(Av1BitDepth value) {
    m_bitDepthHasBeenSet = true;
    m_bitDepth = value;
  }
  inline Av1Settings& WithBitDepth(Av1BitDepth value) {
    SetBitDepth(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 Av1Settings& WithBitrate(int value) {
    SetBitrate(value);
    return *this;
  }
 
 
  inline Av1FilmGrainSynthesis GetFilmGrainSynthesis() const { return m_filmGrainSynthesis; }
  inline bool FilmGrainSynthesisHasBeenSet() const { return m_filmGrainSynthesisHasBeenSet; }
  inline void SetFilmGrainSynthesis(Av1FilmGrainSynthesis value) {
    m_filmGrainSynthesisHasBeenSet = true;
    m_filmGrainSynthesis = value;
  }
  inline Av1Settings& WithFilmGrainSynthesis(Av1FilmGrainSynthesis value) {
    SetFilmGrainSynthesis(value);
    return *this;
  }
 
 
  inline Av1FramerateControl GetFramerateControl() const { return m_framerateControl; }
  inline bool FramerateControlHasBeenSet() const { return m_framerateControlHasBeenSet; }
  inline void SetFramerateControl(Av1FramerateControl value) {
    m_framerateControlHasBeenSet = true;
    m_framerateControl = value;
  }
  inline Av1Settings& WithFramerateControl(Av1FramerateControl value) {
    SetFramerateControl(value);
    return *this;
  }
 
 
  inline Av1FramerateConversionAlgorithm GetFramerateConversionAlgorithm() const { return m_framerateConversionAlgorithm; }
  inline bool FramerateConversionAlgorithmHasBeenSet() const { return m_framerateConversionAlgorithmHasBeenSet; }
  inline void SetFramerateConversionAlgorithm(Av1FramerateConversionAlgorithm value) {
    m_framerateConversionAlgorithmHasBeenSet = true;
    m_framerateConversionAlgorithm = value;
  }
  inline Av1Settings& WithFramerateConversionAlgorithm(Av1FramerateConversionAlgorithm 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 Av1Settings& 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 Av1Settings& WithFramerateNumerator(int value) {
    SetFramerateNumerator(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 Av1Settings& WithGopSize(double value) {
    SetGopSize(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 Av1Settings& WithMaxBitrate(int value) {
    SetMaxBitrate(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 Av1Settings& WithNumberBFramesBetweenReferenceFrames(int value) {
    SetNumberBFramesBetweenReferenceFrames(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>>
  Av1Settings& WithPerFrameMetrics(PerFrameMetricsT&& value) {
    SetPerFrameMetrics(std::forward<PerFrameMetricsT>(value));
    return *this;
  }
  inline Av1Settings& AddPerFrameMetrics(FrameMetricType value) {
    m_perFrameMetricsHasBeenSet = true;
    m_perFrameMetrics.push_back(value);
    return *this;
  }
 
 
  inline const Av1QvbrSettings& GetQvbrSettings() const { return m_qvbrSettings; }
  inline bool QvbrSettingsHasBeenSet() const { return m_qvbrSettingsHasBeenSet; }
  template <typename QvbrSettingsT = Av1QvbrSettings>
  void SetQvbrSettings(QvbrSettingsT&& value) {
    m_qvbrSettingsHasBeenSet = true;
    m_qvbrSettings = std::forward<QvbrSettingsT>(value);
  }
  template <typename QvbrSettingsT = Av1QvbrSettings>
  Av1Settings& WithQvbrSettings(QvbrSettingsT&& value) {
    SetQvbrSettings(std::forward<QvbrSettingsT>(value));
    return *this;
  }
 
 
  inline Av1RateControlMode GetRateControlMode() const { return m_rateControlMode; }
  inline bool RateControlModeHasBeenSet() const { return m_rateControlModeHasBeenSet; }
  inline void SetRateControlMode(Av1RateControlMode value) {
    m_rateControlModeHasBeenSet = true;
    m_rateControlMode = value;
  }
  inline Av1Settings& WithRateControlMode(Av1RateControlMode value) {
    SetRateControlMode(value);
    return *this;
  }
 
 
  inline Av1SceneChangeDetect GetSceneChangeDetect() const { return m_sceneChangeDetect; }
  inline bool SceneChangeDetectHasBeenSet() const { return m_sceneChangeDetectHasBeenSet; }
  inline void SetSceneChangeDetect(Av1SceneChangeDetect value) {
    m_sceneChangeDetectHasBeenSet = true;
    m_sceneChangeDetect = value;
  }
  inline Av1Settings& WithSceneChangeDetect(Av1SceneChangeDetect 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 Av1Settings& 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 Av1Settings& 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 Av1Settings& WithSlidingWindowPeakBitrate(int value) {
    SetSlidingWindowPeakBitrate(value);
    return *this;
  }
 
 
  inline Av1SpatialAdaptiveQuantization GetSpatialAdaptiveQuantization() const { return m_spatialAdaptiveQuantization; }
  inline bool SpatialAdaptiveQuantizationHasBeenSet() const { return m_spatialAdaptiveQuantizationHasBeenSet; }
  inline void SetSpatialAdaptiveQuantization(Av1SpatialAdaptiveQuantization value) {
    m_spatialAdaptiveQuantizationHasBeenSet = true;
    m_spatialAdaptiveQuantization = value;
  }
  inline Av1Settings& WithSpatialAdaptiveQuantization(Av1SpatialAdaptiveQuantization value) {
    SetSpatialAdaptiveQuantization(value);
    return *this;
  }
 private:
  Av1AdaptiveQuantization m_adaptiveQuantization{Av1AdaptiveQuantization::NOT_SET};
 
  Av1BitDepth m_bitDepth{Av1BitDepth::NOT_SET};
 
  int m_bitrate{0};
 
  Av1FilmGrainSynthesis m_filmGrainSynthesis{Av1FilmGrainSynthesis::NOT_SET};
 
  Av1FramerateControl m_framerateControl{Av1FramerateControl::NOT_SET};
 
  Av1FramerateConversionAlgorithm m_framerateConversionAlgorithm{Av1FramerateConversionAlgorithm::NOT_SET};
 
  int m_framerateDenominator{0};
 
  int m_framerateNumerator{0};
 
  double m_gopSize{0.0};
 
  int m_maxBitrate{0};
 
  int m_numberBFramesBetweenReferenceFrames{0};
 
  Aws::Vector<FrameMetricType> m_perFrameMetrics;
 
  Av1QvbrSettings m_qvbrSettings;
 
  Av1RateControlMode m_rateControlMode{Av1RateControlMode::NOT_SET};
 
  Av1SceneChangeDetect m_sceneChangeDetect{Av1SceneChangeDetect::NOT_SET};
 
  int m_slices{0};
 
  int m_slidingWindowMs{0};
 
  int m_slidingWindowPeakBitrate{0};
 
  Av1SpatialAdaptiveQuantization m_spatialAdaptiveQuantization{Av1SpatialAdaptiveQuantization::NOT_SET};
  bool m_adaptiveQuantizationHasBeenSet = false;
  bool m_bitDepthHasBeenSet = false;
  bool m_bitrateHasBeenSet = false;
  bool m_filmGrainSynthesisHasBeenSet = false;
  bool m_framerateControlHasBeenSet = false;
  bool m_framerateConversionAlgorithmHasBeenSet = false;
  bool m_framerateDenominatorHasBeenSet = false;
  bool m_framerateNumeratorHasBeenSet = false;
  bool m_gopSizeHasBeenSet = false;
  bool m_maxBitrateHasBeenSet = false;
  bool m_numberBFramesBetweenReferenceFramesHasBeenSet = false;
  bool m_perFrameMetricsHasBeenSet = false;
  bool m_qvbrSettingsHasBeenSet = false;
  bool m_rateControlModeHasBeenSet = false;
  bool m_sceneChangeDetectHasBeenSet = false;
  bool m_slicesHasBeenSet = false;
  bool m_slidingWindowMsHasBeenSet = false;
  bool m_slidingWindowPeakBitrateHasBeenSet = false;
  bool m_spatialAdaptiveQuantizationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws