Av1Settings.h

 
#pragma once
#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/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/model/Av1QvbrSettings.h>
#include <aws/mediaconvert/model/Av1RateControlMode.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 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 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 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};
    bool m_adaptiveQuantizationHasBeenSet = false;
 
    Av1BitDepth m_bitDepth{Av1BitDepth::NOT_SET};
    bool m_bitDepthHasBeenSet = false;
 
    Av1FilmGrainSynthesis m_filmGrainSynthesis{Av1FilmGrainSynthesis::NOT_SET};
    bool m_filmGrainSynthesisHasBeenSet = false;
 
    Av1FramerateControl m_framerateControl{Av1FramerateControl::NOT_SET};
    bool m_framerateControlHasBeenSet = false;
 
    Av1FramerateConversionAlgorithm m_framerateConversionAlgorithm{Av1FramerateConversionAlgorithm::NOT_SET};
    bool m_framerateConversionAlgorithmHasBeenSet = false;
 
    int m_framerateDenominator{0};
    bool m_framerateDenominatorHasBeenSet = false;
 
    int m_framerateNumerator{0};
    bool m_framerateNumeratorHasBeenSet = false;
 
    double m_gopSize{0.0};
    bool m_gopSizeHasBeenSet = false;
 
    int m_maxBitrate{0};
    bool m_maxBitrateHasBeenSet = false;
 
    int m_numberBFramesBetweenReferenceFrames{0};
    bool m_numberBFramesBetweenReferenceFramesHasBeenSet = false;
 
    Aws::Vector<FrameMetricType> m_perFrameMetrics;
    bool m_perFrameMetricsHasBeenSet = false;
 
    Av1QvbrSettings m_qvbrSettings;
    bool m_qvbrSettingsHasBeenSet = false;
 
    Av1RateControlMode m_rateControlMode{Av1RateControlMode::NOT_SET};
    bool m_rateControlModeHasBeenSet = false;
 
    int m_slices{0};
    bool m_slicesHasBeenSet = false;
 
    Av1SpatialAdaptiveQuantization m_spatialAdaptiveQuantization{Av1SpatialAdaptiveQuantization::NOT_SET};
    bool m_spatialAdaptiveQuantizationHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaConvert
} // namespace Aws