VideoSelector.h

 
#pragma once
#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/PadVideo.h>
#include <aws/mediaconvert/model/InputRotate.h>
#include <aws/mediaconvert/model/InputSampleRange.h>
#include <aws/mediaconvert/model/VideoSelectorType.h>
#include <aws/core/utils/memory/stl/AWSVector.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};
    bool m_alphaBehaviorHasBeenSet = false;
 
    ColorSpace m_colorSpace{ColorSpace::NOT_SET};
    bool m_colorSpaceHasBeenSet = false;
 
    ColorSpaceUsage m_colorSpaceUsage{ColorSpaceUsage::NOT_SET};
    bool m_colorSpaceUsageHasBeenSet = false;
 
    EmbeddedTimecodeOverride m_embeddedTimecodeOverride{EmbeddedTimecodeOverride::NOT_SET};
    bool m_embeddedTimecodeOverrideHasBeenSet = false;
 
    Hdr10Metadata m_hdr10Metadata;
    bool m_hdr10MetadataHasBeenSet = false;
 
    int m_maxLuminance{0};
    bool m_maxLuminanceHasBeenSet = false;
 
    PadVideo m_padVideo{PadVideo::NOT_SET};
    bool m_padVideoHasBeenSet = false;
 
    int m_pid{0};
    bool m_pidHasBeenSet = false;
 
    int m_programNumber{0};
    bool m_programNumberHasBeenSet = false;
 
    InputRotate m_rotate{InputRotate::NOT_SET};
    bool m_rotateHasBeenSet = false;
 
    InputSampleRange m_sampleRange{InputSampleRange::NOT_SET};
    bool m_sampleRangeHasBeenSet = false;
 
    VideoSelectorType m_selectorType{VideoSelectorType::NOT_SET};
    bool m_selectorTypeHasBeenSet = false;
 
    Aws::Vector<int> m_streams;
    bool m_streamsHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaConvert
} // namespace Aws