VideoSelector.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/AlphaBehavior.h>
#include <aws/mediaconvert/model/ColorSpace.h>
#include <aws/mediaconvert/model/ColorSpaceUsage.h>
#include <aws/mediaconvert/model/EmbeddedTimecodeOverride.h>
#include <aws/mediaconvert/model/Hdr10Metadata.h>
#include <aws/mediaconvert/model/InputRotate.h>
#include <aws/mediaconvert/model/InputSampleRange.h>
#include <aws/mediaconvert/model/PadVideo.h>
#include <aws/mediaconvert/model/VideoSelectorType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class VideoSelector {
 public:
  AWS_MEDIACONVERT_API VideoSelector() = default;
  AWS_MEDIACONVERT_API VideoSelector(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API VideoSelector& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline AlphaBehavior GetAlphaBehavior() const { return m_alphaBehavior; }
  inline bool AlphaBehaviorHasBeenSet() const { return m_alphaBehaviorHasBeenSet; }
  inline void SetAlphaBehavior(AlphaBehavior value) {
    m_alphaBehaviorHasBeenSet = true;
    m_alphaBehavior = value;
  }
  inline VideoSelector& WithAlphaBehavior(AlphaBehavior value) {
    SetAlphaBehavior(value);
    return *this;
  }
 
 
  inline ColorSpace GetColorSpace() const { return m_colorSpace; }
  inline bool ColorSpaceHasBeenSet() const { return m_colorSpaceHasBeenSet; }
  inline void SetColorSpace(ColorSpace value) {
    m_colorSpaceHasBeenSet = true;
    m_colorSpace = value;
  }
  inline VideoSelector& WithColorSpace(ColorSpace value) {
    SetColorSpace(value);
    return *this;
  }
 
 
  inline ColorSpaceUsage GetColorSpaceUsage() const { return m_colorSpaceUsage; }
  inline bool ColorSpaceUsageHasBeenSet() const { return m_colorSpaceUsageHasBeenSet; }
  inline void SetColorSpaceUsage(ColorSpaceUsage value) {
    m_colorSpaceUsageHasBeenSet = true;
    m_colorSpaceUsage = value;
  }
  inline VideoSelector& WithColorSpaceUsage(ColorSpaceUsage value) {
    SetColorSpaceUsage(value);
    return *this;
  }
 
 
  inline EmbeddedTimecodeOverride GetEmbeddedTimecodeOverride() const { return m_embeddedTimecodeOverride; }
  inline bool EmbeddedTimecodeOverrideHasBeenSet() const { return m_embeddedTimecodeOverrideHasBeenSet; }
  inline void SetEmbeddedTimecodeOverride(EmbeddedTimecodeOverride value) {
    m_embeddedTimecodeOverrideHasBeenSet = true;
    m_embeddedTimecodeOverride = value;
  }
  inline VideoSelector& WithEmbeddedTimecodeOverride(EmbeddedTimecodeOverride value) {
    SetEmbeddedTimecodeOverride(value);
    return *this;
  }
 
 
  inline const Hdr10Metadata& GetHdr10Metadata() const { return m_hdr10Metadata; }
  inline bool Hdr10MetadataHasBeenSet() const { return m_hdr10MetadataHasBeenSet; }
  template <typename Hdr10MetadataT = Hdr10Metadata>
  void SetHdr10Metadata(Hdr10MetadataT&& value) {
    m_hdr10MetadataHasBeenSet = true;
    m_hdr10Metadata = std::forward<Hdr10MetadataT>(value);
  }
  template <typename Hdr10MetadataT = Hdr10Metadata>
  VideoSelector& WithHdr10Metadata(Hdr10MetadataT&& value) {
    SetHdr10Metadata(std::forward<Hdr10MetadataT>(value));
    return *this;
  }
 
 
  inline int GetMaxLuminance() const { return m_maxLuminance; }
  inline bool MaxLuminanceHasBeenSet() const { return m_maxLuminanceHasBeenSet; }
  inline void SetMaxLuminance(int value) {
    m_maxLuminanceHasBeenSet = true;
    m_maxLuminance = value;
  }
  inline VideoSelector& WithMaxLuminance(int value) {
    SetMaxLuminance(value);
    return *this;
  }
 
 
  inline PadVideo GetPadVideo() const { return m_padVideo; }
  inline bool PadVideoHasBeenSet() const { return m_padVideoHasBeenSet; }
  inline void SetPadVideo(PadVideo value) {
    m_padVideoHasBeenSet = true;
    m_padVideo = value;
  }
  inline VideoSelector& WithPadVideo(PadVideo value) {
    SetPadVideo(value);
    return *this;
  }
 
 
  inline int GetPid() const { return m_pid; }
  inline bool PidHasBeenSet() const { return m_pidHasBeenSet; }
  inline void SetPid(int value) {
    m_pidHasBeenSet = true;
    m_pid = value;
  }
  inline VideoSelector& WithPid(int value) {
    SetPid(value);
    return *this;
  }
 
 
  inline int GetProgramNumber() const { return m_programNumber; }
  inline bool ProgramNumberHasBeenSet() const { return m_programNumberHasBeenSet; }
  inline void SetProgramNumber(int value) {
    m_programNumberHasBeenSet = true;
    m_programNumber = value;
  }
  inline VideoSelector& WithProgramNumber(int value) {
    SetProgramNumber(value);
    return *this;
  }
 
 
  inline InputRotate GetRotate() const { return m_rotate; }
  inline bool RotateHasBeenSet() const { return m_rotateHasBeenSet; }
  inline void SetRotate(InputRotate value) {
    m_rotateHasBeenSet = true;
    m_rotate = value;
  }
  inline VideoSelector& WithRotate(InputRotate value) {
    SetRotate(value);
    return *this;
  }
 
 
  inline InputSampleRange GetSampleRange() const { return m_sampleRange; }
  inline bool SampleRangeHasBeenSet() const { return m_sampleRangeHasBeenSet; }
  inline void SetSampleRange(InputSampleRange value) {
    m_sampleRangeHasBeenSet = true;
    m_sampleRange = value;
  }
  inline VideoSelector& WithSampleRange(InputSampleRange value) {
    SetSampleRange(value);
    return *this;
  }
 
 
  inline VideoSelectorType GetSelectorType() const { return m_selectorType; }
  inline bool SelectorTypeHasBeenSet() const { return m_selectorTypeHasBeenSet; }
  inline void SetSelectorType(VideoSelectorType value) {
    m_selectorTypeHasBeenSet = true;
    m_selectorType = value;
  }
  inline VideoSelector& WithSelectorType(VideoSelectorType value) {
    SetSelectorType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<int>& GetStreams() const { return m_streams; }
  inline bool StreamsHasBeenSet() const { return m_streamsHasBeenSet; }
  template <typename StreamsT = Aws::Vector<int>>
  void SetStreams(StreamsT&& value) {
    m_streamsHasBeenSet = true;
    m_streams = std::forward<StreamsT>(value);
  }
  template <typename StreamsT = Aws::Vector<int>>
  VideoSelector& WithStreams(StreamsT&& value) {
    SetStreams(std::forward<StreamsT>(value));
    return *this;
  }
  inline VideoSelector& AddStreams(int value) {
    m_streamsHasBeenSet = true;
    m_streams.push_back(value);
    return *this;
  }
 private:
  AlphaBehavior m_alphaBehavior{AlphaBehavior::NOT_SET};
 
  ColorSpace m_colorSpace{ColorSpace::NOT_SET};
 
  ColorSpaceUsage m_colorSpaceUsage{ColorSpaceUsage::NOT_SET};
 
  EmbeddedTimecodeOverride m_embeddedTimecodeOverride{EmbeddedTimecodeOverride::NOT_SET};
 
  Hdr10Metadata m_hdr10Metadata;
 
  int m_maxLuminance{0};
 
  PadVideo m_padVideo{PadVideo::NOT_SET};
 
  int m_pid{0};
 
  int m_programNumber{0};
 
  InputRotate m_rotate{InputRotate::NOT_SET};
 
  InputSampleRange m_sampleRange{InputSampleRange::NOT_SET};
 
  VideoSelectorType m_selectorType{VideoSelectorType::NOT_SET};
 
  Aws::Vector<int> m_streams;
  bool m_alphaBehaviorHasBeenSet = false;
  bool m_colorSpaceHasBeenSet = false;
  bool m_colorSpaceUsageHasBeenSet = false;
  bool m_embeddedTimecodeOverrideHasBeenSet = false;
  bool m_hdr10MetadataHasBeenSet = false;
  bool m_maxLuminanceHasBeenSet = false;
  bool m_padVideoHasBeenSet = false;
  bool m_pidHasBeenSet = false;
  bool m_programNumberHasBeenSet = false;
  bool m_rotateHasBeenSet = false;
  bool m_sampleRangeHasBeenSet = false;
  bool m_selectorTypeHasBeenSet = false;
  bool m_streamsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws