VideoDescription.h

 
#pragma once
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/AfdSignaling.h>
#include <aws/mediaconvert/model/AntiAlias.h>
#include <aws/mediaconvert/model/ChromaPositionMode.h>
#include <aws/mediaconvert/model/ColorMetadata.h>
#include <aws/mediaconvert/model/DropFrameTimecode.h>
#include <aws/mediaconvert/model/Rectangle.h>
#include <aws/mediaconvert/model/RespondToAfd.h>
#include <aws/mediaconvert/model/ScalingBehavior.h>
#include <aws/mediaconvert/model/TimecodeTrack.h>
#include <aws/mediaconvert/model/VideoCodecSettings.h>
#include <aws/mediaconvert/model/VideoPreprocessor.h>
#include <aws/mediaconvert/model/VideoTimecodeInsertion.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class VideoDescription {
 public:
  AWS_MEDIACONVERT_API VideoDescription() = default;
  AWS_MEDIACONVERT_API VideoDescription(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API VideoDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline AfdSignaling GetAfdSignaling() const { return m_afdSignaling; }
  inline bool AfdSignalingHasBeenSet() const { return m_afdSignalingHasBeenSet; }
  inline void SetAfdSignaling(AfdSignaling value) {
    m_afdSignalingHasBeenSet = true;
    m_afdSignaling = value;
  }
  inline VideoDescription& WithAfdSignaling(AfdSignaling value) {
    SetAfdSignaling(value);
    return *this;
  }
 
 
  inline AntiAlias GetAntiAlias() const { return m_antiAlias; }
  inline bool AntiAliasHasBeenSet() const { return m_antiAliasHasBeenSet; }
  inline void SetAntiAlias(AntiAlias value) {
    m_antiAliasHasBeenSet = true;
    m_antiAlias = value;
  }
  inline VideoDescription& WithAntiAlias(AntiAlias value) {
    SetAntiAlias(value);
    return *this;
  }
 
 
  inline ChromaPositionMode GetChromaPositionMode() const { return m_chromaPositionMode; }
  inline bool ChromaPositionModeHasBeenSet() const { return m_chromaPositionModeHasBeenSet; }
  inline void SetChromaPositionMode(ChromaPositionMode value) {
    m_chromaPositionModeHasBeenSet = true;
    m_chromaPositionMode = value;
  }
  inline VideoDescription& WithChromaPositionMode(ChromaPositionMode value) {
    SetChromaPositionMode(value);
    return *this;
  }
 
 
  inline const VideoCodecSettings& GetCodecSettings() const { return m_codecSettings; }
  inline bool CodecSettingsHasBeenSet() const { return m_codecSettingsHasBeenSet; }
  template <typename CodecSettingsT = VideoCodecSettings>
  void SetCodecSettings(CodecSettingsT&& value) {
    m_codecSettingsHasBeenSet = true;
    m_codecSettings = std::forward<CodecSettingsT>(value);
  }
  template <typename CodecSettingsT = VideoCodecSettings>
  VideoDescription& WithCodecSettings(CodecSettingsT&& value) {
    SetCodecSettings(std::forward<CodecSettingsT>(value));
    return *this;
  }
 
 
  inline ColorMetadata GetColorMetadata() const { return m_colorMetadata; }
  inline bool ColorMetadataHasBeenSet() const { return m_colorMetadataHasBeenSet; }
  inline void SetColorMetadata(ColorMetadata value) {
    m_colorMetadataHasBeenSet = true;
    m_colorMetadata = value;
  }
  inline VideoDescription& WithColorMetadata(ColorMetadata value) {
    SetColorMetadata(value);
    return *this;
  }
 
 
  inline const Rectangle& GetCrop() const { return m_crop; }
  inline bool CropHasBeenSet() const { return m_cropHasBeenSet; }
  template <typename CropT = Rectangle>
  void SetCrop(CropT&& value) {
    m_cropHasBeenSet = true;
    m_crop = std::forward<CropT>(value);
  }
  template <typename CropT = Rectangle>
  VideoDescription& WithCrop(CropT&& value) {
    SetCrop(std::forward<CropT>(value));
    return *this;
  }
 
 
  inline DropFrameTimecode GetDropFrameTimecode() const { return m_dropFrameTimecode; }
  inline bool DropFrameTimecodeHasBeenSet() const { return m_dropFrameTimecodeHasBeenSet; }
  inline void SetDropFrameTimecode(DropFrameTimecode value) {
    m_dropFrameTimecodeHasBeenSet = true;
    m_dropFrameTimecode = value;
  }
  inline VideoDescription& WithDropFrameTimecode(DropFrameTimecode value) {
    SetDropFrameTimecode(value);
    return *this;
  }
 
 
  inline int GetFixedAfd() const { return m_fixedAfd; }
  inline bool FixedAfdHasBeenSet() const { return m_fixedAfdHasBeenSet; }
  inline void SetFixedAfd(int value) {
    m_fixedAfdHasBeenSet = true;
    m_fixedAfd = value;
  }
  inline VideoDescription& WithFixedAfd(int value) {
    SetFixedAfd(value);
    return *this;
  }
 
 
  inline int GetHeight() const { return m_height; }
  inline bool HeightHasBeenSet() const { return m_heightHasBeenSet; }
  inline void SetHeight(int value) {
    m_heightHasBeenSet = true;
    m_height = value;
  }
  inline VideoDescription& WithHeight(int value) {
    SetHeight(value);
    return *this;
  }
 
 
  inline const Rectangle& GetPosition() const { return m_position; }
  inline bool PositionHasBeenSet() const { return m_positionHasBeenSet; }
  template <typename PositionT = Rectangle>
  void SetPosition(PositionT&& value) {
    m_positionHasBeenSet = true;
    m_position = std::forward<PositionT>(value);
  }
  template <typename PositionT = Rectangle>
  VideoDescription& WithPosition(PositionT&& value) {
    SetPosition(std::forward<PositionT>(value));
    return *this;
  }
 
 
  inline RespondToAfd GetRespondToAfd() const { return m_respondToAfd; }
  inline bool RespondToAfdHasBeenSet() const { return m_respondToAfdHasBeenSet; }
  inline void SetRespondToAfd(RespondToAfd value) {
    m_respondToAfdHasBeenSet = true;
    m_respondToAfd = value;
  }
  inline VideoDescription& WithRespondToAfd(RespondToAfd value) {
    SetRespondToAfd(value);
    return *this;
  }
 
 
  inline ScalingBehavior GetScalingBehavior() const { return m_scalingBehavior; }
  inline bool ScalingBehaviorHasBeenSet() const { return m_scalingBehaviorHasBeenSet; }
  inline void SetScalingBehavior(ScalingBehavior value) {
    m_scalingBehaviorHasBeenSet = true;
    m_scalingBehavior = value;
  }
  inline VideoDescription& WithScalingBehavior(ScalingBehavior value) {
    SetScalingBehavior(value);
    return *this;
  }
 
 
  inline int GetSharpness() const { return m_sharpness; }
  inline bool SharpnessHasBeenSet() const { return m_sharpnessHasBeenSet; }
  inline void SetSharpness(int value) {
    m_sharpnessHasBeenSet = true;
    m_sharpness = value;
  }
  inline VideoDescription& WithSharpness(int value) {
    SetSharpness(value);
    return *this;
  }
 
 
  inline VideoTimecodeInsertion GetTimecodeInsertion() const { return m_timecodeInsertion; }
  inline bool TimecodeInsertionHasBeenSet() const { return m_timecodeInsertionHasBeenSet; }
  inline void SetTimecodeInsertion(VideoTimecodeInsertion value) {
    m_timecodeInsertionHasBeenSet = true;
    m_timecodeInsertion = value;
  }
  inline VideoDescription& WithTimecodeInsertion(VideoTimecodeInsertion value) {
    SetTimecodeInsertion(value);
    return *this;
  }
 
 
  inline TimecodeTrack GetTimecodeTrack() const { return m_timecodeTrack; }
  inline bool TimecodeTrackHasBeenSet() const { return m_timecodeTrackHasBeenSet; }
  inline void SetTimecodeTrack(TimecodeTrack value) {
    m_timecodeTrackHasBeenSet = true;
    m_timecodeTrack = value;
  }
  inline VideoDescription& WithTimecodeTrack(TimecodeTrack value) {
    SetTimecodeTrack(value);
    return *this;
  }
 
 
  inline const VideoPreprocessor& GetVideoPreprocessors() const { return m_videoPreprocessors; }
  inline bool VideoPreprocessorsHasBeenSet() const { return m_videoPreprocessorsHasBeenSet; }
  template <typename VideoPreprocessorsT = VideoPreprocessor>
  void SetVideoPreprocessors(VideoPreprocessorsT&& value) {
    m_videoPreprocessorsHasBeenSet = true;
    m_videoPreprocessors = std::forward<VideoPreprocessorsT>(value);
  }
  template <typename VideoPreprocessorsT = VideoPreprocessor>
  VideoDescription& WithVideoPreprocessors(VideoPreprocessorsT&& value) {
    SetVideoPreprocessors(std::forward<VideoPreprocessorsT>(value));
    return *this;
  }
 
 
  inline int GetWidth() const { return m_width; }
  inline bool WidthHasBeenSet() const { return m_widthHasBeenSet; }
  inline void SetWidth(int value) {
    m_widthHasBeenSet = true;
    m_width = value;
  }
  inline VideoDescription& WithWidth(int value) {
    SetWidth(value);
    return *this;
  }
 private:
  AfdSignaling m_afdSignaling{AfdSignaling::NOT_SET};
 
  AntiAlias m_antiAlias{AntiAlias::NOT_SET};
 
  ChromaPositionMode m_chromaPositionMode{ChromaPositionMode::NOT_SET};
 
  VideoCodecSettings m_codecSettings;
 
  ColorMetadata m_colorMetadata{ColorMetadata::NOT_SET};
 
  Rectangle m_crop;
 
  DropFrameTimecode m_dropFrameTimecode{DropFrameTimecode::NOT_SET};
 
  int m_fixedAfd{0};
 
  int m_height{0};
 
  Rectangle m_position;
 
  RespondToAfd m_respondToAfd{RespondToAfd::NOT_SET};
 
  ScalingBehavior m_scalingBehavior{ScalingBehavior::NOT_SET};
 
  int m_sharpness{0};
 
  VideoTimecodeInsertion m_timecodeInsertion{VideoTimecodeInsertion::NOT_SET};
 
  TimecodeTrack m_timecodeTrack{TimecodeTrack::NOT_SET};
 
  VideoPreprocessor m_videoPreprocessors;
 
  int m_width{0};
  bool m_afdSignalingHasBeenSet = false;
  bool m_antiAliasHasBeenSet = false;
  bool m_chromaPositionModeHasBeenSet = false;
  bool m_codecSettingsHasBeenSet = false;
  bool m_colorMetadataHasBeenSet = false;
  bool m_cropHasBeenSet = false;
  bool m_dropFrameTimecodeHasBeenSet = false;
  bool m_fixedAfdHasBeenSet = false;
  bool m_heightHasBeenSet = false;
  bool m_positionHasBeenSet = false;
  bool m_respondToAfdHasBeenSet = false;
  bool m_scalingBehaviorHasBeenSet = false;
  bool m_sharpnessHasBeenSet = false;
  bool m_timecodeInsertionHasBeenSet = false;
  bool m_timecodeTrackHasBeenSet = false;
  bool m_videoPreprocessorsHasBeenSet = false;
  bool m_widthHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws