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 <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();
    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 const AlphaBehavior& GetAlphaBehavior() const{ return m_alphaBehavior; }
    inline bool AlphaBehaviorHasBeenSet() const { return m_alphaBehaviorHasBeenSet; }
    inline void SetAlphaBehavior(const AlphaBehavior& value) { m_alphaBehaviorHasBeenSet = true; m_alphaBehavior = value; }
    inline void SetAlphaBehavior(AlphaBehavior&& value) { m_alphaBehaviorHasBeenSet = true; m_alphaBehavior = std::move(value); }
    inline VideoSelector& WithAlphaBehavior(const AlphaBehavior& value) { SetAlphaBehavior(value); return *this;}
    inline VideoSelector& WithAlphaBehavior(AlphaBehavior&& value) { SetAlphaBehavior(std::move(value)); return *this;}
 
 
    inline const ColorSpace& GetColorSpace() const{ return m_colorSpace; }
    inline bool ColorSpaceHasBeenSet() const { return m_colorSpaceHasBeenSet; }
    inline void SetColorSpace(const ColorSpace& value) { m_colorSpaceHasBeenSet = true; m_colorSpace = value; }
    inline void SetColorSpace(ColorSpace&& value) { m_colorSpaceHasBeenSet = true; m_colorSpace = std::move(value); }
    inline VideoSelector& WithColorSpace(const ColorSpace& value) { SetColorSpace(value); return *this;}
    inline VideoSelector& WithColorSpace(ColorSpace&& value) { SetColorSpace(std::move(value)); return *this;}
 
 
    inline const ColorSpaceUsage& GetColorSpaceUsage() const{ return m_colorSpaceUsage; }
    inline bool ColorSpaceUsageHasBeenSet() const { return m_colorSpaceUsageHasBeenSet; }
    inline void SetColorSpaceUsage(const ColorSpaceUsage& value) { m_colorSpaceUsageHasBeenSet = true; m_colorSpaceUsage = value; }
    inline void SetColorSpaceUsage(ColorSpaceUsage&& value) { m_colorSpaceUsageHasBeenSet = true; m_colorSpaceUsage = std::move(value); }
    inline VideoSelector& WithColorSpaceUsage(const ColorSpaceUsage& value) { SetColorSpaceUsage(value); return *this;}
    inline VideoSelector& WithColorSpaceUsage(ColorSpaceUsage&& value) { SetColorSpaceUsage(std::move(value)); return *this;}
 
 
    inline const EmbeddedTimecodeOverride& GetEmbeddedTimecodeOverride() const{ return m_embeddedTimecodeOverride; }
    inline bool EmbeddedTimecodeOverrideHasBeenSet() const { return m_embeddedTimecodeOverrideHasBeenSet; }
    inline void SetEmbeddedTimecodeOverride(const EmbeddedTimecodeOverride& value) { m_embeddedTimecodeOverrideHasBeenSet = true; m_embeddedTimecodeOverride = value; }
    inline void SetEmbeddedTimecodeOverride(EmbeddedTimecodeOverride&& value) { m_embeddedTimecodeOverrideHasBeenSet = true; m_embeddedTimecodeOverride = std::move(value); }
    inline VideoSelector& WithEmbeddedTimecodeOverride(const EmbeddedTimecodeOverride& value) { SetEmbeddedTimecodeOverride(value); return *this;}
    inline VideoSelector& WithEmbeddedTimecodeOverride(EmbeddedTimecodeOverride&& value) { SetEmbeddedTimecodeOverride(std::move(value)); return *this;}
 
 
    inline const Hdr10Metadata& GetHdr10Metadata() const{ return m_hdr10Metadata; }
    inline bool Hdr10MetadataHasBeenSet() const { return m_hdr10MetadataHasBeenSet; }
    inline void SetHdr10Metadata(const Hdr10Metadata& value) { m_hdr10MetadataHasBeenSet = true; m_hdr10Metadata = value; }
    inline void SetHdr10Metadata(Hdr10Metadata&& value) { m_hdr10MetadataHasBeenSet = true; m_hdr10Metadata = std::move(value); }
    inline VideoSelector& WithHdr10Metadata(const Hdr10Metadata& value) { SetHdr10Metadata(value); return *this;}
    inline VideoSelector& WithHdr10Metadata(Hdr10Metadata&& value) { SetHdr10Metadata(std::move(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 const PadVideo& GetPadVideo() const{ return m_padVideo; }
    inline bool PadVideoHasBeenSet() const { return m_padVideoHasBeenSet; }
    inline void SetPadVideo(const PadVideo& value) { m_padVideoHasBeenSet = true; m_padVideo = value; }
    inline void SetPadVideo(PadVideo&& value) { m_padVideoHasBeenSet = true; m_padVideo = std::move(value); }
    inline VideoSelector& WithPadVideo(const PadVideo& value) { SetPadVideo(value); return *this;}
    inline VideoSelector& WithPadVideo(PadVideo&& value) { SetPadVideo(std::move(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 const InputRotate& GetRotate() const{ return m_rotate; }
    inline bool RotateHasBeenSet() const { return m_rotateHasBeenSet; }
    inline void SetRotate(const InputRotate& value) { m_rotateHasBeenSet = true; m_rotate = value; }
    inline void SetRotate(InputRotate&& value) { m_rotateHasBeenSet = true; m_rotate = std::move(value); }
    inline VideoSelector& WithRotate(const InputRotate& value) { SetRotate(value); return *this;}
    inline VideoSelector& WithRotate(InputRotate&& value) { SetRotate(std::move(value)); return *this;}
 
 
    inline const InputSampleRange& GetSampleRange() const{ return m_sampleRange; }
    inline bool SampleRangeHasBeenSet() const { return m_sampleRangeHasBeenSet; }
    inline void SetSampleRange(const InputSampleRange& value) { m_sampleRangeHasBeenSet = true; m_sampleRange = value; }
    inline void SetSampleRange(InputSampleRange&& value) { m_sampleRangeHasBeenSet = true; m_sampleRange = std::move(value); }
    inline VideoSelector& WithSampleRange(const InputSampleRange& value) { SetSampleRange(value); return *this;}
    inline VideoSelector& WithSampleRange(InputSampleRange&& value) { SetSampleRange(std::move(value)); return *this;}
  private:
 
    AlphaBehavior m_alphaBehavior;
    bool m_alphaBehaviorHasBeenSet = false;
 
    ColorSpace m_colorSpace;
    bool m_colorSpaceHasBeenSet = false;
 
    ColorSpaceUsage m_colorSpaceUsage;
    bool m_colorSpaceUsageHasBeenSet = false;
 
    EmbeddedTimecodeOverride m_embeddedTimecodeOverride;
    bool m_embeddedTimecodeOverrideHasBeenSet = false;
 
    Hdr10Metadata m_hdr10Metadata;
    bool m_hdr10MetadataHasBeenSet = false;
 
    int m_maxLuminance;
    bool m_maxLuminanceHasBeenSet = false;
 
    PadVideo m_padVideo;
    bool m_padVideoHasBeenSet = false;
 
    int m_pid;
    bool m_pidHasBeenSet = false;
 
    int m_programNumber;
    bool m_programNumberHasBeenSet = false;
 
    InputRotate m_rotate;
    bool m_rotateHasBeenSet = false;
 
    InputSampleRange m_sampleRange;
    bool m_sampleRangeHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaConvert
} // namespace Aws