VideoPreprocessor.h

 
#pragma once
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/ColorCorrector.h>
#include <aws/mediaconvert/model/Deinterlacer.h>
#include <aws/mediaconvert/model/DolbyVision.h>
#include <aws/mediaconvert/model/DurationControl.h>
#include <aws/mediaconvert/model/Hdr10Plus.h>
#include <aws/mediaconvert/model/ImageInserter.h>
#include <aws/mediaconvert/model/NoiseReducer.h>
#include <aws/mediaconvert/model/PartnerWatermarking.h>
#include <aws/mediaconvert/model/TimecodeBurnin.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class VideoPreprocessor {
 public:
  AWS_MEDIACONVERT_API VideoPreprocessor() = default;
  AWS_MEDIACONVERT_API VideoPreprocessor(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API VideoPreprocessor& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const ColorCorrector& GetColorCorrector() const { return m_colorCorrector; }
  inline bool ColorCorrectorHasBeenSet() const { return m_colorCorrectorHasBeenSet; }
  template <typename ColorCorrectorT = ColorCorrector>
  void SetColorCorrector(ColorCorrectorT&& value) {
    m_colorCorrectorHasBeenSet = true;
    m_colorCorrector = std::forward<ColorCorrectorT>(value);
  }
  template <typename ColorCorrectorT = ColorCorrector>
  VideoPreprocessor& WithColorCorrector(ColorCorrectorT&& value) {
    SetColorCorrector(std::forward<ColorCorrectorT>(value));
    return *this;
  }
 
 
  inline const Deinterlacer& GetDeinterlacer() const { return m_deinterlacer; }
  inline bool DeinterlacerHasBeenSet() const { return m_deinterlacerHasBeenSet; }
  template <typename DeinterlacerT = Deinterlacer>
  void SetDeinterlacer(DeinterlacerT&& value) {
    m_deinterlacerHasBeenSet = true;
    m_deinterlacer = std::forward<DeinterlacerT>(value);
  }
  template <typename DeinterlacerT = Deinterlacer>
  VideoPreprocessor& WithDeinterlacer(DeinterlacerT&& value) {
    SetDeinterlacer(std::forward<DeinterlacerT>(value));
    return *this;
  }
 
 
  inline const DolbyVision& GetDolbyVision() const { return m_dolbyVision; }
  inline bool DolbyVisionHasBeenSet() const { return m_dolbyVisionHasBeenSet; }
  template <typename DolbyVisionT = DolbyVision>
  void SetDolbyVision(DolbyVisionT&& value) {
    m_dolbyVisionHasBeenSet = true;
    m_dolbyVision = std::forward<DolbyVisionT>(value);
  }
  template <typename DolbyVisionT = DolbyVision>
  VideoPreprocessor& WithDolbyVision(DolbyVisionT&& value) {
    SetDolbyVision(std::forward<DolbyVisionT>(value));
    return *this;
  }
 
 
  inline const DurationControl& GetDurationControl() const { return m_durationControl; }
  inline bool DurationControlHasBeenSet() const { return m_durationControlHasBeenSet; }
  template <typename DurationControlT = DurationControl>
  void SetDurationControl(DurationControlT&& value) {
    m_durationControlHasBeenSet = true;
    m_durationControl = std::forward<DurationControlT>(value);
  }
  template <typename DurationControlT = DurationControl>
  VideoPreprocessor& WithDurationControl(DurationControlT&& value) {
    SetDurationControl(std::forward<DurationControlT>(value));
    return *this;
  }
 
 
  inline const Hdr10Plus& GetHdr10Plus() const { return m_hdr10Plus; }
  inline bool Hdr10PlusHasBeenSet() const { return m_hdr10PlusHasBeenSet; }
  template <typename Hdr10PlusT = Hdr10Plus>
  void SetHdr10Plus(Hdr10PlusT&& value) {
    m_hdr10PlusHasBeenSet = true;
    m_hdr10Plus = std::forward<Hdr10PlusT>(value);
  }
  template <typename Hdr10PlusT = Hdr10Plus>
  VideoPreprocessor& WithHdr10Plus(Hdr10PlusT&& value) {
    SetHdr10Plus(std::forward<Hdr10PlusT>(value));
    return *this;
  }
 
 
  inline const ImageInserter& GetImageInserter() const { return m_imageInserter; }
  inline bool ImageInserterHasBeenSet() const { return m_imageInserterHasBeenSet; }
  template <typename ImageInserterT = ImageInserter>
  void SetImageInserter(ImageInserterT&& value) {
    m_imageInserterHasBeenSet = true;
    m_imageInserter = std::forward<ImageInserterT>(value);
  }
  template <typename ImageInserterT = ImageInserter>
  VideoPreprocessor& WithImageInserter(ImageInserterT&& value) {
    SetImageInserter(std::forward<ImageInserterT>(value));
    return *this;
  }
 
 
  inline const NoiseReducer& GetNoiseReducer() const { return m_noiseReducer; }
  inline bool NoiseReducerHasBeenSet() const { return m_noiseReducerHasBeenSet; }
  template <typename NoiseReducerT = NoiseReducer>
  void SetNoiseReducer(NoiseReducerT&& value) {
    m_noiseReducerHasBeenSet = true;
    m_noiseReducer = std::forward<NoiseReducerT>(value);
  }
  template <typename NoiseReducerT = NoiseReducer>
  VideoPreprocessor& WithNoiseReducer(NoiseReducerT&& value) {
    SetNoiseReducer(std::forward<NoiseReducerT>(value));
    return *this;
  }
 
 
  inline const PartnerWatermarking& GetPartnerWatermarking() const { return m_partnerWatermarking; }
  inline bool PartnerWatermarkingHasBeenSet() const { return m_partnerWatermarkingHasBeenSet; }
  template <typename PartnerWatermarkingT = PartnerWatermarking>
  void SetPartnerWatermarking(PartnerWatermarkingT&& value) {
    m_partnerWatermarkingHasBeenSet = true;
    m_partnerWatermarking = std::forward<PartnerWatermarkingT>(value);
  }
  template <typename PartnerWatermarkingT = PartnerWatermarking>
  VideoPreprocessor& WithPartnerWatermarking(PartnerWatermarkingT&& value) {
    SetPartnerWatermarking(std::forward<PartnerWatermarkingT>(value));
    return *this;
  }
 
 
  inline const TimecodeBurnin& GetTimecodeBurnin() const { return m_timecodeBurnin; }
  inline bool TimecodeBurninHasBeenSet() const { return m_timecodeBurninHasBeenSet; }
  template <typename TimecodeBurninT = TimecodeBurnin>
  void SetTimecodeBurnin(TimecodeBurninT&& value) {
    m_timecodeBurninHasBeenSet = true;
    m_timecodeBurnin = std::forward<TimecodeBurninT>(value);
  }
  template <typename TimecodeBurninT = TimecodeBurnin>
  VideoPreprocessor& WithTimecodeBurnin(TimecodeBurninT&& value) {
    SetTimecodeBurnin(std::forward<TimecodeBurninT>(value));
    return *this;
  }
 private:
  ColorCorrector m_colorCorrector;
 
  Deinterlacer m_deinterlacer;
 
  DolbyVision m_dolbyVision;
 
  DurationControl m_durationControl;
 
  Hdr10Plus m_hdr10Plus;
 
  ImageInserter m_imageInserter;
 
  NoiseReducer m_noiseReducer;
 
  PartnerWatermarking m_partnerWatermarking;
 
  TimecodeBurnin m_timecodeBurnin;
  bool m_colorCorrectorHasBeenSet = false;
  bool m_deinterlacerHasBeenSet = false;
  bool m_dolbyVisionHasBeenSet = false;
  bool m_durationControlHasBeenSet = false;
  bool m_hdr10PlusHasBeenSet = false;
  bool m_imageInserterHasBeenSet = false;
  bool m_noiseReducerHasBeenSet = false;
  bool m_partnerWatermarkingHasBeenSet = false;
  bool m_timecodeBurninHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws