Input.h

 
#pragma once
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/AdvancedInputFilter.h>
#include <aws/mediaconvert/model/AdvancedInputFilterSettings.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/mediaconvert/model/Rectangle.h>
#include <aws/mediaconvert/model/InputDeblockFilter.h>
#include <aws/mediaconvert/model/InputDecryptionSettings.h>
#include <aws/mediaconvert/model/InputDenoiseFilter.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/mediaconvert/model/InputFilterEnable.h>
#include <aws/mediaconvert/model/ImageInserter.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/model/InputScanType.h>
#include <aws/mediaconvert/model/InputPsiControl.h>
#include <aws/mediaconvert/model/InputTamsSettings.h>
#include <aws/mediaconvert/model/InputTimecodeSource.h>
#include <aws/mediaconvert/model/InputVideoGenerator.h>
#include <aws/mediaconvert/model/VideoSelector.h>
#include <aws/mediaconvert/model/AudioSelectorGroup.h>
#include <aws/mediaconvert/model/AudioSelector.h>
#include <aws/mediaconvert/model/CaptionSelector.h>
#include <aws/mediaconvert/model/DynamicAudioSelector.h>
#include <aws/mediaconvert/model/InputClipping.h>
#include <aws/mediaconvert/model/VideoOverlay.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace MediaConvert
{
namespace Model
{
 
  class Input
  {
  public:
    AWS_MEDIACONVERT_API Input() = default;
    AWS_MEDIACONVERT_API Input(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIACONVERT_API Input& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline AdvancedInputFilter GetAdvancedInputFilter() const { return m_advancedInputFilter; }
    inline bool AdvancedInputFilterHasBeenSet() const { return m_advancedInputFilterHasBeenSet; }
    inline void SetAdvancedInputFilter(AdvancedInputFilter value) { m_advancedInputFilterHasBeenSet = true; m_advancedInputFilter = value; }
    inline Input& WithAdvancedInputFilter(AdvancedInputFilter value) { SetAdvancedInputFilter(value); return *this;}
 
 
    inline const AdvancedInputFilterSettings& GetAdvancedInputFilterSettings() const { return m_advancedInputFilterSettings; }
    inline bool AdvancedInputFilterSettingsHasBeenSet() const { return m_advancedInputFilterSettingsHasBeenSet; }
    template<typename AdvancedInputFilterSettingsT = AdvancedInputFilterSettings>
    void SetAdvancedInputFilterSettings(AdvancedInputFilterSettingsT&& value) { m_advancedInputFilterSettingsHasBeenSet = true; m_advancedInputFilterSettings = std::forward<AdvancedInputFilterSettingsT>(value); }
    template<typename AdvancedInputFilterSettingsT = AdvancedInputFilterSettings>
    Input& WithAdvancedInputFilterSettings(AdvancedInputFilterSettingsT&& value) { SetAdvancedInputFilterSettings(std::forward<AdvancedInputFilterSettingsT>(value)); return *this;}
 
 
    inline const Aws::Map<Aws::String, AudioSelectorGroup>& GetAudioSelectorGroups() const { return m_audioSelectorGroups; }
    inline bool AudioSelectorGroupsHasBeenSet() const { return m_audioSelectorGroupsHasBeenSet; }
    template<typename AudioSelectorGroupsT = Aws::Map<Aws::String, AudioSelectorGroup>>
    void SetAudioSelectorGroups(AudioSelectorGroupsT&& value) { m_audioSelectorGroupsHasBeenSet = true; m_audioSelectorGroups = std::forward<AudioSelectorGroupsT>(value); }
    template<typename AudioSelectorGroupsT = Aws::Map<Aws::String, AudioSelectorGroup>>
    Input& WithAudioSelectorGroups(AudioSelectorGroupsT&& value) { SetAudioSelectorGroups(std::forward<AudioSelectorGroupsT>(value)); return *this;}
    template<typename AudioSelectorGroupsKeyT = Aws::String, typename AudioSelectorGroupsValueT = AudioSelectorGroup>
    Input& AddAudioSelectorGroups(AudioSelectorGroupsKeyT&& key, AudioSelectorGroupsValueT&& value) {
      m_audioSelectorGroupsHasBeenSet = true; m_audioSelectorGroups.emplace(std::forward<AudioSelectorGroupsKeyT>(key), std::forward<AudioSelectorGroupsValueT>(value)); return *this;
    }
 
 
    inline const Aws::Map<Aws::String, AudioSelector>& GetAudioSelectors() const { return m_audioSelectors; }
    inline bool AudioSelectorsHasBeenSet() const { return m_audioSelectorsHasBeenSet; }
    template<typename AudioSelectorsT = Aws::Map<Aws::String, AudioSelector>>
    void SetAudioSelectors(AudioSelectorsT&& value) { m_audioSelectorsHasBeenSet = true; m_audioSelectors = std::forward<AudioSelectorsT>(value); }
    template<typename AudioSelectorsT = Aws::Map<Aws::String, AudioSelector>>
    Input& WithAudioSelectors(AudioSelectorsT&& value) { SetAudioSelectors(std::forward<AudioSelectorsT>(value)); return *this;}
    template<typename AudioSelectorsKeyT = Aws::String, typename AudioSelectorsValueT = AudioSelector>
    Input& AddAudioSelectors(AudioSelectorsKeyT&& key, AudioSelectorsValueT&& value) {
      m_audioSelectorsHasBeenSet = true; m_audioSelectors.emplace(std::forward<AudioSelectorsKeyT>(key), std::forward<AudioSelectorsValueT>(value)); return *this;
    }
 
 
    inline const Aws::Map<Aws::String, CaptionSelector>& GetCaptionSelectors() const { return m_captionSelectors; }
    inline bool CaptionSelectorsHasBeenSet() const { return m_captionSelectorsHasBeenSet; }
    template<typename CaptionSelectorsT = Aws::Map<Aws::String, CaptionSelector>>
    void SetCaptionSelectors(CaptionSelectorsT&& value) { m_captionSelectorsHasBeenSet = true; m_captionSelectors = std::forward<CaptionSelectorsT>(value); }
    template<typename CaptionSelectorsT = Aws::Map<Aws::String, CaptionSelector>>
    Input& WithCaptionSelectors(CaptionSelectorsT&& value) { SetCaptionSelectors(std::forward<CaptionSelectorsT>(value)); return *this;}
    template<typename CaptionSelectorsKeyT = Aws::String, typename CaptionSelectorsValueT = CaptionSelector>
    Input& AddCaptionSelectors(CaptionSelectorsKeyT&& key, CaptionSelectorsValueT&& value) {
      m_captionSelectorsHasBeenSet = true; m_captionSelectors.emplace(std::forward<CaptionSelectorsKeyT>(key), std::forward<CaptionSelectorsValueT>(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>
    Input& WithCrop(CropT&& value) { SetCrop(std::forward<CropT>(value)); return *this;}
 
 
    inline InputDeblockFilter GetDeblockFilter() const { return m_deblockFilter; }
    inline bool DeblockFilterHasBeenSet() const { return m_deblockFilterHasBeenSet; }
    inline void SetDeblockFilter(InputDeblockFilter value) { m_deblockFilterHasBeenSet = true; m_deblockFilter = value; }
    inline Input& WithDeblockFilter(InputDeblockFilter value) { SetDeblockFilter(value); return *this;}
 
 
    inline const InputDecryptionSettings& GetDecryptionSettings() const { return m_decryptionSettings; }
    inline bool DecryptionSettingsHasBeenSet() const { return m_decryptionSettingsHasBeenSet; }
    template<typename DecryptionSettingsT = InputDecryptionSettings>
    void SetDecryptionSettings(DecryptionSettingsT&& value) { m_decryptionSettingsHasBeenSet = true; m_decryptionSettings = std::forward<DecryptionSettingsT>(value); }
    template<typename DecryptionSettingsT = InputDecryptionSettings>
    Input& WithDecryptionSettings(DecryptionSettingsT&& value) { SetDecryptionSettings(std::forward<DecryptionSettingsT>(value)); return *this;}
 
 
    inline InputDenoiseFilter GetDenoiseFilter() const { return m_denoiseFilter; }
    inline bool DenoiseFilterHasBeenSet() const { return m_denoiseFilterHasBeenSet; }
    inline void SetDenoiseFilter(InputDenoiseFilter value) { m_denoiseFilterHasBeenSet = true; m_denoiseFilter = value; }
    inline Input& WithDenoiseFilter(InputDenoiseFilter value) { SetDenoiseFilter(value); return *this;}
 
 
    inline const Aws::String& GetDolbyVisionMetadataXml() const { return m_dolbyVisionMetadataXml; }
    inline bool DolbyVisionMetadataXmlHasBeenSet() const { return m_dolbyVisionMetadataXmlHasBeenSet; }
    template<typename DolbyVisionMetadataXmlT = Aws::String>
    void SetDolbyVisionMetadataXml(DolbyVisionMetadataXmlT&& value) { m_dolbyVisionMetadataXmlHasBeenSet = true; m_dolbyVisionMetadataXml = std::forward<DolbyVisionMetadataXmlT>(value); }
    template<typename DolbyVisionMetadataXmlT = Aws::String>
    Input& WithDolbyVisionMetadataXml(DolbyVisionMetadataXmlT&& value) { SetDolbyVisionMetadataXml(std::forward<DolbyVisionMetadataXmlT>(value)); return *this;}
 
 
    inline const Aws::Map<Aws::String, DynamicAudioSelector>& GetDynamicAudioSelectors() const { return m_dynamicAudioSelectors; }
    inline bool DynamicAudioSelectorsHasBeenSet() const { return m_dynamicAudioSelectorsHasBeenSet; }
    template<typename DynamicAudioSelectorsT = Aws::Map<Aws::String, DynamicAudioSelector>>
    void SetDynamicAudioSelectors(DynamicAudioSelectorsT&& value) { m_dynamicAudioSelectorsHasBeenSet = true; m_dynamicAudioSelectors = std::forward<DynamicAudioSelectorsT>(value); }
    template<typename DynamicAudioSelectorsT = Aws::Map<Aws::String, DynamicAudioSelector>>
    Input& WithDynamicAudioSelectors(DynamicAudioSelectorsT&& value) { SetDynamicAudioSelectors(std::forward<DynamicAudioSelectorsT>(value)); return *this;}
    template<typename DynamicAudioSelectorsKeyT = Aws::String, typename DynamicAudioSelectorsValueT = DynamicAudioSelector>
    Input& AddDynamicAudioSelectors(DynamicAudioSelectorsKeyT&& key, DynamicAudioSelectorsValueT&& value) {
      m_dynamicAudioSelectorsHasBeenSet = true; m_dynamicAudioSelectors.emplace(std::forward<DynamicAudioSelectorsKeyT>(key), std::forward<DynamicAudioSelectorsValueT>(value)); return *this;
    }
 
 
    inline const Aws::String& GetFileInput() const { return m_fileInput; }
    inline bool FileInputHasBeenSet() const { return m_fileInputHasBeenSet; }
    template<typename FileInputT = Aws::String>
    void SetFileInput(FileInputT&& value) { m_fileInputHasBeenSet = true; m_fileInput = std::forward<FileInputT>(value); }
    template<typename FileInputT = Aws::String>
    Input& WithFileInput(FileInputT&& value) { SetFileInput(std::forward<FileInputT>(value)); return *this;}
 
 
    inline InputFilterEnable GetFilterEnable() const { return m_filterEnable; }
    inline bool FilterEnableHasBeenSet() const { return m_filterEnableHasBeenSet; }
    inline void SetFilterEnable(InputFilterEnable value) { m_filterEnableHasBeenSet = true; m_filterEnable = value; }
    inline Input& WithFilterEnable(InputFilterEnable value) { SetFilterEnable(value); return *this;}
 
 
    inline int GetFilterStrength() const { return m_filterStrength; }
    inline bool FilterStrengthHasBeenSet() const { return m_filterStrengthHasBeenSet; }
    inline void SetFilterStrength(int value) { m_filterStrengthHasBeenSet = true; m_filterStrength = value; }
    inline Input& WithFilterStrength(int value) { SetFilterStrength(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>
    Input& WithImageInserter(ImageInserterT&& value) { SetImageInserter(std::forward<ImageInserterT>(value)); return *this;}
 
 
    inline const Aws::Vector<InputClipping>& GetInputClippings() const { return m_inputClippings; }
    inline bool InputClippingsHasBeenSet() const { return m_inputClippingsHasBeenSet; }
    template<typename InputClippingsT = Aws::Vector<InputClipping>>
    void SetInputClippings(InputClippingsT&& value) { m_inputClippingsHasBeenSet = true; m_inputClippings = std::forward<InputClippingsT>(value); }
    template<typename InputClippingsT = Aws::Vector<InputClipping>>
    Input& WithInputClippings(InputClippingsT&& value) { SetInputClippings(std::forward<InputClippingsT>(value)); return *this;}
    template<typename InputClippingsT = InputClipping>
    Input& AddInputClippings(InputClippingsT&& value) { m_inputClippingsHasBeenSet = true; m_inputClippings.emplace_back(std::forward<InputClippingsT>(value)); return *this; }
 
 
    inline InputScanType GetInputScanType() const { return m_inputScanType; }
    inline bool InputScanTypeHasBeenSet() const { return m_inputScanTypeHasBeenSet; }
    inline void SetInputScanType(InputScanType value) { m_inputScanTypeHasBeenSet = true; m_inputScanType = value; }
    inline Input& WithInputScanType(InputScanType value) { SetInputScanType(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>
    Input& WithPosition(PositionT&& value) { SetPosition(std::forward<PositionT>(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 Input& WithProgramNumber(int value) { SetProgramNumber(value); return *this;}
 
 
    inline InputPsiControl GetPsiControl() const { return m_psiControl; }
    inline bool PsiControlHasBeenSet() const { return m_psiControlHasBeenSet; }
    inline void SetPsiControl(InputPsiControl value) { m_psiControlHasBeenSet = true; m_psiControl = value; }
    inline Input& WithPsiControl(InputPsiControl value) { SetPsiControl(value); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetSupplementalImps() const { return m_supplementalImps; }
    inline bool SupplementalImpsHasBeenSet() const { return m_supplementalImpsHasBeenSet; }
    template<typename SupplementalImpsT = Aws::Vector<Aws::String>>
    void SetSupplementalImps(SupplementalImpsT&& value) { m_supplementalImpsHasBeenSet = true; m_supplementalImps = std::forward<SupplementalImpsT>(value); }
    template<typename SupplementalImpsT = Aws::Vector<Aws::String>>
    Input& WithSupplementalImps(SupplementalImpsT&& value) { SetSupplementalImps(std::forward<SupplementalImpsT>(value)); return *this;}
    template<typename SupplementalImpsT = Aws::String>
    Input& AddSupplementalImps(SupplementalImpsT&& value) { m_supplementalImpsHasBeenSet = true; m_supplementalImps.emplace_back(std::forward<SupplementalImpsT>(value)); return *this; }
 
 
    inline const InputTamsSettings& GetTamsSettings() const { return m_tamsSettings; }
    inline bool TamsSettingsHasBeenSet() const { return m_tamsSettingsHasBeenSet; }
    template<typename TamsSettingsT = InputTamsSettings>
    void SetTamsSettings(TamsSettingsT&& value) { m_tamsSettingsHasBeenSet = true; m_tamsSettings = std::forward<TamsSettingsT>(value); }
    template<typename TamsSettingsT = InputTamsSettings>
    Input& WithTamsSettings(TamsSettingsT&& value) { SetTamsSettings(std::forward<TamsSettingsT>(value)); return *this;}
 
 
    inline InputTimecodeSource GetTimecodeSource() const { return m_timecodeSource; }
    inline bool TimecodeSourceHasBeenSet() const { return m_timecodeSourceHasBeenSet; }
    inline void SetTimecodeSource(InputTimecodeSource value) { m_timecodeSourceHasBeenSet = true; m_timecodeSource = value; }
    inline Input& WithTimecodeSource(InputTimecodeSource value) { SetTimecodeSource(value); return *this;}
 
 
    inline const Aws::String& GetTimecodeStart() const { return m_timecodeStart; }
    inline bool TimecodeStartHasBeenSet() const { return m_timecodeStartHasBeenSet; }
    template<typename TimecodeStartT = Aws::String>
    void SetTimecodeStart(TimecodeStartT&& value) { m_timecodeStartHasBeenSet = true; m_timecodeStart = std::forward<TimecodeStartT>(value); }
    template<typename TimecodeStartT = Aws::String>
    Input& WithTimecodeStart(TimecodeStartT&& value) { SetTimecodeStart(std::forward<TimecodeStartT>(value)); return *this;}
 
 
    inline const InputVideoGenerator& GetVideoGenerator() const { return m_videoGenerator; }
    inline bool VideoGeneratorHasBeenSet() const { return m_videoGeneratorHasBeenSet; }
    template<typename VideoGeneratorT = InputVideoGenerator>
    void SetVideoGenerator(VideoGeneratorT&& value) { m_videoGeneratorHasBeenSet = true; m_videoGenerator = std::forward<VideoGeneratorT>(value); }
    template<typename VideoGeneratorT = InputVideoGenerator>
    Input& WithVideoGenerator(VideoGeneratorT&& value) { SetVideoGenerator(std::forward<VideoGeneratorT>(value)); return *this;}
 
 
    inline const Aws::Vector<VideoOverlay>& GetVideoOverlays() const { return m_videoOverlays; }
    inline bool VideoOverlaysHasBeenSet() const { return m_videoOverlaysHasBeenSet; }
    template<typename VideoOverlaysT = Aws::Vector<VideoOverlay>>
    void SetVideoOverlays(VideoOverlaysT&& value) { m_videoOverlaysHasBeenSet = true; m_videoOverlays = std::forward<VideoOverlaysT>(value); }
    template<typename VideoOverlaysT = Aws::Vector<VideoOverlay>>
    Input& WithVideoOverlays(VideoOverlaysT&& value) { SetVideoOverlays(std::forward<VideoOverlaysT>(value)); return *this;}
    template<typename VideoOverlaysT = VideoOverlay>
    Input& AddVideoOverlays(VideoOverlaysT&& value) { m_videoOverlaysHasBeenSet = true; m_videoOverlays.emplace_back(std::forward<VideoOverlaysT>(value)); return *this; }
 
 
    inline const VideoSelector& GetVideoSelector() const { return m_videoSelector; }
    inline bool VideoSelectorHasBeenSet() const { return m_videoSelectorHasBeenSet; }
    template<typename VideoSelectorT = VideoSelector>
    void SetVideoSelector(VideoSelectorT&& value) { m_videoSelectorHasBeenSet = true; m_videoSelector = std::forward<VideoSelectorT>(value); }
    template<typename VideoSelectorT = VideoSelector>
    Input& WithVideoSelector(VideoSelectorT&& value) { SetVideoSelector(std::forward<VideoSelectorT>(value)); return *this;}
  private:
 
    AdvancedInputFilter m_advancedInputFilter{AdvancedInputFilter::NOT_SET};
    bool m_advancedInputFilterHasBeenSet = false;
 
    AdvancedInputFilterSettings m_advancedInputFilterSettings;
    bool m_advancedInputFilterSettingsHasBeenSet = false;
 
    Aws::Map<Aws::String, AudioSelectorGroup> m_audioSelectorGroups;
    bool m_audioSelectorGroupsHasBeenSet = false;
 
    Aws::Map<Aws::String, AudioSelector> m_audioSelectors;
    bool m_audioSelectorsHasBeenSet = false;
 
    Aws::Map<Aws::String, CaptionSelector> m_captionSelectors;
    bool m_captionSelectorsHasBeenSet = false;
 
    Rectangle m_crop;
    bool m_cropHasBeenSet = false;
 
    InputDeblockFilter m_deblockFilter{InputDeblockFilter::NOT_SET};
    bool m_deblockFilterHasBeenSet = false;
 
    InputDecryptionSettings m_decryptionSettings;
    bool m_decryptionSettingsHasBeenSet = false;
 
    InputDenoiseFilter m_denoiseFilter{InputDenoiseFilter::NOT_SET};
    bool m_denoiseFilterHasBeenSet = false;
 
    Aws::String m_dolbyVisionMetadataXml;
    bool m_dolbyVisionMetadataXmlHasBeenSet = false;
 
    Aws::Map<Aws::String, DynamicAudioSelector> m_dynamicAudioSelectors;
    bool m_dynamicAudioSelectorsHasBeenSet = false;
 
    Aws::String m_fileInput;
    bool m_fileInputHasBeenSet = false;
 
    InputFilterEnable m_filterEnable{InputFilterEnable::NOT_SET};
    bool m_filterEnableHasBeenSet = false;
 
    int m_filterStrength{0};
    bool m_filterStrengthHasBeenSet = false;
 
    ImageInserter m_imageInserter;
    bool m_imageInserterHasBeenSet = false;
 
    Aws::Vector<InputClipping> m_inputClippings;
    bool m_inputClippingsHasBeenSet = false;
 
    InputScanType m_inputScanType{InputScanType::NOT_SET};
    bool m_inputScanTypeHasBeenSet = false;
 
    Rectangle m_position;
    bool m_positionHasBeenSet = false;
 
    int m_programNumber{0};
    bool m_programNumberHasBeenSet = false;
 
    InputPsiControl m_psiControl{InputPsiControl::NOT_SET};
    bool m_psiControlHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_supplementalImps;
    bool m_supplementalImpsHasBeenSet = false;
 
    InputTamsSettings m_tamsSettings;
    bool m_tamsSettingsHasBeenSet = false;
 
    InputTimecodeSource m_timecodeSource{InputTimecodeSource::NOT_SET};
    bool m_timecodeSourceHasBeenSet = false;
 
    Aws::String m_timecodeStart;
    bool m_timecodeStartHasBeenSet = false;
 
    InputVideoGenerator m_videoGenerator;
    bool m_videoGeneratorHasBeenSet = false;
 
    Aws::Vector<VideoOverlay> m_videoOverlays;
    bool m_videoOverlaysHasBeenSet = false;
 
    VideoSelector m_videoSelector;
    bool m_videoSelectorHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaConvert
} // namespace Aws