Mpeg2Settings.h

 
#pragma once
#include <aws/medialive/MediaLive_EXPORTS.h>
#include <aws/medialive/model/Mpeg2AdaptiveQuantization.h>
#include <aws/medialive/model/AfdSignaling.h>
#include <aws/medialive/model/Mpeg2ColorMetadata.h>
#include <aws/medialive/model/Mpeg2ColorSpace.h>
#include <aws/medialive/model/Mpeg2DisplayRatio.h>
#include <aws/medialive/model/Mpeg2FilterSettings.h>
#include <aws/medialive/model/FixedAfd.h>
#include <aws/medialive/model/Mpeg2GopSizeUnits.h>
#include <aws/medialive/model/Mpeg2ScanType.h>
#include <aws/medialive/model/Mpeg2SubGopLength.h>
#include <aws/medialive/model/Mpeg2TimecodeInsertionBehavior.h>
#include <aws/medialive/model/TimecodeBurninSettings.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace MediaLive
{
namespace Model
{
 
  class Mpeg2Settings
  {
  public:
    AWS_MEDIALIVE_API Mpeg2Settings();
    AWS_MEDIALIVE_API Mpeg2Settings(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIALIVE_API Mpeg2Settings& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIALIVE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Mpeg2AdaptiveQuantization& GetAdaptiveQuantization() const{ return m_adaptiveQuantization; }
    inline bool AdaptiveQuantizationHasBeenSet() const { return m_adaptiveQuantizationHasBeenSet; }
    inline void SetAdaptiveQuantization(const Mpeg2AdaptiveQuantization& value) { m_adaptiveQuantizationHasBeenSet = true; m_adaptiveQuantization = value; }
    inline void SetAdaptiveQuantization(Mpeg2AdaptiveQuantization&& value) { m_adaptiveQuantizationHasBeenSet = true; m_adaptiveQuantization = std::move(value); }
    inline Mpeg2Settings& WithAdaptiveQuantization(const Mpeg2AdaptiveQuantization& value) { SetAdaptiveQuantization(value); return *this;}
    inline Mpeg2Settings& WithAdaptiveQuantization(Mpeg2AdaptiveQuantization&& value) { SetAdaptiveQuantization(std::move(value)); return *this;}
 
 
    inline const AfdSignaling& GetAfdSignaling() const{ return m_afdSignaling; }
    inline bool AfdSignalingHasBeenSet() const { return m_afdSignalingHasBeenSet; }
    inline void SetAfdSignaling(const AfdSignaling& value) { m_afdSignalingHasBeenSet = true; m_afdSignaling = value; }
    inline void SetAfdSignaling(AfdSignaling&& value) { m_afdSignalingHasBeenSet = true; m_afdSignaling = std::move(value); }
    inline Mpeg2Settings& WithAfdSignaling(const AfdSignaling& value) { SetAfdSignaling(value); return *this;}
    inline Mpeg2Settings& WithAfdSignaling(AfdSignaling&& value) { SetAfdSignaling(std::move(value)); return *this;}
 
 
    inline const Mpeg2ColorMetadata& GetColorMetadata() const{ return m_colorMetadata; }
    inline bool ColorMetadataHasBeenSet() const { return m_colorMetadataHasBeenSet; }
    inline void SetColorMetadata(const Mpeg2ColorMetadata& value) { m_colorMetadataHasBeenSet = true; m_colorMetadata = value; }
    inline void SetColorMetadata(Mpeg2ColorMetadata&& value) { m_colorMetadataHasBeenSet = true; m_colorMetadata = std::move(value); }
    inline Mpeg2Settings& WithColorMetadata(const Mpeg2ColorMetadata& value) { SetColorMetadata(value); return *this;}
    inline Mpeg2Settings& WithColorMetadata(Mpeg2ColorMetadata&& value) { SetColorMetadata(std::move(value)); return *this;}
 
 
    inline const Mpeg2ColorSpace& GetColorSpace() const{ return m_colorSpace; }
    inline bool ColorSpaceHasBeenSet() const { return m_colorSpaceHasBeenSet; }
    inline void SetColorSpace(const Mpeg2ColorSpace& value) { m_colorSpaceHasBeenSet = true; m_colorSpace = value; }
    inline void SetColorSpace(Mpeg2ColorSpace&& value) { m_colorSpaceHasBeenSet = true; m_colorSpace = std::move(value); }
    inline Mpeg2Settings& WithColorSpace(const Mpeg2ColorSpace& value) { SetColorSpace(value); return *this;}
    inline Mpeg2Settings& WithColorSpace(Mpeg2ColorSpace&& value) { SetColorSpace(std::move(value)); return *this;}
 
 
    inline const Mpeg2DisplayRatio& GetDisplayAspectRatio() const{ return m_displayAspectRatio; }
    inline bool DisplayAspectRatioHasBeenSet() const { return m_displayAspectRatioHasBeenSet; }
    inline void SetDisplayAspectRatio(const Mpeg2DisplayRatio& value) { m_displayAspectRatioHasBeenSet = true; m_displayAspectRatio = value; }
    inline void SetDisplayAspectRatio(Mpeg2DisplayRatio&& value) { m_displayAspectRatioHasBeenSet = true; m_displayAspectRatio = std::move(value); }
    inline Mpeg2Settings& WithDisplayAspectRatio(const Mpeg2DisplayRatio& value) { SetDisplayAspectRatio(value); return *this;}
    inline Mpeg2Settings& WithDisplayAspectRatio(Mpeg2DisplayRatio&& value) { SetDisplayAspectRatio(std::move(value)); return *this;}
 
 
    inline const Mpeg2FilterSettings& GetFilterSettings() const{ return m_filterSettings; }
    inline bool FilterSettingsHasBeenSet() const { return m_filterSettingsHasBeenSet; }
    inline void SetFilterSettings(const Mpeg2FilterSettings& value) { m_filterSettingsHasBeenSet = true; m_filterSettings = value; }
    inline void SetFilterSettings(Mpeg2FilterSettings&& value) { m_filterSettingsHasBeenSet = true; m_filterSettings = std::move(value); }
    inline Mpeg2Settings& WithFilterSettings(const Mpeg2FilterSettings& value) { SetFilterSettings(value); return *this;}
    inline Mpeg2Settings& WithFilterSettings(Mpeg2FilterSettings&& value) { SetFilterSettings(std::move(value)); return *this;}
 
 
    inline const FixedAfd& GetFixedAfd() const{ return m_fixedAfd; }
    inline bool FixedAfdHasBeenSet() const { return m_fixedAfdHasBeenSet; }
    inline void SetFixedAfd(const FixedAfd& value) { m_fixedAfdHasBeenSet = true; m_fixedAfd = value; }
    inline void SetFixedAfd(FixedAfd&& value) { m_fixedAfdHasBeenSet = true; m_fixedAfd = std::move(value); }
    inline Mpeg2Settings& WithFixedAfd(const FixedAfd& value) { SetFixedAfd(value); return *this;}
    inline Mpeg2Settings& WithFixedAfd(FixedAfd&& value) { SetFixedAfd(std::move(value)); return *this;}
 
 
    inline int GetFramerateDenominator() const{ return m_framerateDenominator; }
    inline bool FramerateDenominatorHasBeenSet() const { return m_framerateDenominatorHasBeenSet; }
    inline void SetFramerateDenominator(int value) { m_framerateDenominatorHasBeenSet = true; m_framerateDenominator = value; }
    inline Mpeg2Settings& WithFramerateDenominator(int value) { SetFramerateDenominator(value); return *this;}
 
 
    inline int GetFramerateNumerator() const{ return m_framerateNumerator; }
    inline bool FramerateNumeratorHasBeenSet() const { return m_framerateNumeratorHasBeenSet; }
    inline void SetFramerateNumerator(int value) { m_framerateNumeratorHasBeenSet = true; m_framerateNumerator = value; }
    inline Mpeg2Settings& WithFramerateNumerator(int value) { SetFramerateNumerator(value); return *this;}
 
 
    inline int GetGopClosedCadence() const{ return m_gopClosedCadence; }
    inline bool GopClosedCadenceHasBeenSet() const { return m_gopClosedCadenceHasBeenSet; }
    inline void SetGopClosedCadence(int value) { m_gopClosedCadenceHasBeenSet = true; m_gopClosedCadence = value; }
    inline Mpeg2Settings& WithGopClosedCadence(int value) { SetGopClosedCadence(value); return *this;}
 
 
    inline int GetGopNumBFrames() const{ return m_gopNumBFrames; }
    inline bool GopNumBFramesHasBeenSet() const { return m_gopNumBFramesHasBeenSet; }
    inline void SetGopNumBFrames(int value) { m_gopNumBFramesHasBeenSet = true; m_gopNumBFrames = value; }
    inline Mpeg2Settings& WithGopNumBFrames(int value) { SetGopNumBFrames(value); return *this;}
 
 
    inline double GetGopSize() const{ return m_gopSize; }
    inline bool GopSizeHasBeenSet() const { return m_gopSizeHasBeenSet; }
    inline void SetGopSize(double value) { m_gopSizeHasBeenSet = true; m_gopSize = value; }
    inline Mpeg2Settings& WithGopSize(double value) { SetGopSize(value); return *this;}
 
 
    inline const Mpeg2GopSizeUnits& GetGopSizeUnits() const{ return m_gopSizeUnits; }
    inline bool GopSizeUnitsHasBeenSet() const { return m_gopSizeUnitsHasBeenSet; }
    inline void SetGopSizeUnits(const Mpeg2GopSizeUnits& value) { m_gopSizeUnitsHasBeenSet = true; m_gopSizeUnits = value; }
    inline void SetGopSizeUnits(Mpeg2GopSizeUnits&& value) { m_gopSizeUnitsHasBeenSet = true; m_gopSizeUnits = std::move(value); }
    inline Mpeg2Settings& WithGopSizeUnits(const Mpeg2GopSizeUnits& value) { SetGopSizeUnits(value); return *this;}
    inline Mpeg2Settings& WithGopSizeUnits(Mpeg2GopSizeUnits&& value) { SetGopSizeUnits(std::move(value)); return *this;}
 
 
    inline const Mpeg2ScanType& GetScanType() const{ return m_scanType; }
    inline bool ScanTypeHasBeenSet() const { return m_scanTypeHasBeenSet; }
    inline void SetScanType(const Mpeg2ScanType& value) { m_scanTypeHasBeenSet = true; m_scanType = value; }
    inline void SetScanType(Mpeg2ScanType&& value) { m_scanTypeHasBeenSet = true; m_scanType = std::move(value); }
    inline Mpeg2Settings& WithScanType(const Mpeg2ScanType& value) { SetScanType(value); return *this;}
    inline Mpeg2Settings& WithScanType(Mpeg2ScanType&& value) { SetScanType(std::move(value)); return *this;}
 
 
    inline const Mpeg2SubGopLength& GetSubgopLength() const{ return m_subgopLength; }
    inline bool SubgopLengthHasBeenSet() const { return m_subgopLengthHasBeenSet; }
    inline void SetSubgopLength(const Mpeg2SubGopLength& value) { m_subgopLengthHasBeenSet = true; m_subgopLength = value; }
    inline void SetSubgopLength(Mpeg2SubGopLength&& value) { m_subgopLengthHasBeenSet = true; m_subgopLength = std::move(value); }
    inline Mpeg2Settings& WithSubgopLength(const Mpeg2SubGopLength& value) { SetSubgopLength(value); return *this;}
    inline Mpeg2Settings& WithSubgopLength(Mpeg2SubGopLength&& value) { SetSubgopLength(std::move(value)); return *this;}
 
 
    inline const Mpeg2TimecodeInsertionBehavior& GetTimecodeInsertion() const{ return m_timecodeInsertion; }
    inline bool TimecodeInsertionHasBeenSet() const { return m_timecodeInsertionHasBeenSet; }
    inline void SetTimecodeInsertion(const Mpeg2TimecodeInsertionBehavior& value) { m_timecodeInsertionHasBeenSet = true; m_timecodeInsertion = value; }
    inline void SetTimecodeInsertion(Mpeg2TimecodeInsertionBehavior&& value) { m_timecodeInsertionHasBeenSet = true; m_timecodeInsertion = std::move(value); }
    inline Mpeg2Settings& WithTimecodeInsertion(const Mpeg2TimecodeInsertionBehavior& value) { SetTimecodeInsertion(value); return *this;}
    inline Mpeg2Settings& WithTimecodeInsertion(Mpeg2TimecodeInsertionBehavior&& value) { SetTimecodeInsertion(std::move(value)); return *this;}
 
 
    inline const TimecodeBurninSettings& GetTimecodeBurninSettings() const{ return m_timecodeBurninSettings; }
    inline bool TimecodeBurninSettingsHasBeenSet() const { return m_timecodeBurninSettingsHasBeenSet; }
    inline void SetTimecodeBurninSettings(const TimecodeBurninSettings& value) { m_timecodeBurninSettingsHasBeenSet = true; m_timecodeBurninSettings = value; }
    inline void SetTimecodeBurninSettings(TimecodeBurninSettings&& value) { m_timecodeBurninSettingsHasBeenSet = true; m_timecodeBurninSettings = std::move(value); }
    inline Mpeg2Settings& WithTimecodeBurninSettings(const TimecodeBurninSettings& value) { SetTimecodeBurninSettings(value); return *this;}
    inline Mpeg2Settings& WithTimecodeBurninSettings(TimecodeBurninSettings&& value) { SetTimecodeBurninSettings(std::move(value)); return *this;}
  private:
 
    Mpeg2AdaptiveQuantization m_adaptiveQuantization;
    bool m_adaptiveQuantizationHasBeenSet = false;
 
    AfdSignaling m_afdSignaling;
    bool m_afdSignalingHasBeenSet = false;
 
    Mpeg2ColorMetadata m_colorMetadata;
    bool m_colorMetadataHasBeenSet = false;
 
    Mpeg2ColorSpace m_colorSpace;
    bool m_colorSpaceHasBeenSet = false;
 
    Mpeg2DisplayRatio m_displayAspectRatio;
    bool m_displayAspectRatioHasBeenSet = false;
 
    Mpeg2FilterSettings m_filterSettings;
    bool m_filterSettingsHasBeenSet = false;
 
    FixedAfd m_fixedAfd;
    bool m_fixedAfdHasBeenSet = false;
 
    int m_framerateDenominator;
    bool m_framerateDenominatorHasBeenSet = false;
 
    int m_framerateNumerator;
    bool m_framerateNumeratorHasBeenSet = false;
 
    int m_gopClosedCadence;
    bool m_gopClosedCadenceHasBeenSet = false;
 
    int m_gopNumBFrames;
    bool m_gopNumBFramesHasBeenSet = false;
 
    double m_gopSize;
    bool m_gopSizeHasBeenSet = false;
 
    Mpeg2GopSizeUnits m_gopSizeUnits;
    bool m_gopSizeUnitsHasBeenSet = false;
 
    Mpeg2ScanType m_scanType;
    bool m_scanTypeHasBeenSet = false;
 
    Mpeg2SubGopLength m_subgopLength;
    bool m_subgopLengthHasBeenSet = false;
 
    Mpeg2TimecodeInsertionBehavior m_timecodeInsertion;
    bool m_timecodeInsertionHasBeenSet = false;
 
    TimecodeBurninSettings m_timecodeBurninSettings;
    bool m_timecodeBurninSettingsHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaLive
} // namespace Aws