M2tsSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/DvbNitSettings.h>
#include <aws/mediaconvert/model/DvbSdtSettings.h>
#include <aws/mediaconvert/model/DvbTdtSettings.h>
#include <aws/mediaconvert/model/M2tsAudioBufferModel.h>
#include <aws/mediaconvert/model/M2tsAudioDuration.h>
#include <aws/mediaconvert/model/M2tsBufferModel.h>
#include <aws/mediaconvert/model/M2tsDataPtsControl.h>
#include <aws/mediaconvert/model/M2tsEbpAudioInterval.h>
#include <aws/mediaconvert/model/M2tsEbpPlacement.h>
#include <aws/mediaconvert/model/M2tsEsRateInPes.h>
#include <aws/mediaconvert/model/M2tsForceTsVideoEbpOrder.h>
#include <aws/mediaconvert/model/M2tsKlvMetadata.h>
#include <aws/mediaconvert/model/M2tsNielsenId3.h>
#include <aws/mediaconvert/model/M2tsPcrControl.h>
#include <aws/mediaconvert/model/M2tsPreventBufferUnderflow.h>
#include <aws/mediaconvert/model/M2tsRateMode.h>
#include <aws/mediaconvert/model/M2tsScte35Esam.h>
#include <aws/mediaconvert/model/M2tsScte35Source.h>
#include <aws/mediaconvert/model/M2tsSegmentationMarkers.h>
#include <aws/mediaconvert/model/M2tsSegmentationStyle.h>
#include <aws/mediaconvert/model/TsPtsOffset.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class M2tsSettings {
 public:
  AWS_MEDIACONVERT_API M2tsSettings() = default;
  AWS_MEDIACONVERT_API M2tsSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API M2tsSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline M2tsAudioBufferModel GetAudioBufferModel() const { return m_audioBufferModel; }
  inline bool AudioBufferModelHasBeenSet() const { return m_audioBufferModelHasBeenSet; }
  inline void SetAudioBufferModel(M2tsAudioBufferModel value) {
    m_audioBufferModelHasBeenSet = true;
    m_audioBufferModel = value;
  }
  inline M2tsSettings& WithAudioBufferModel(M2tsAudioBufferModel value) {
    SetAudioBufferModel(value);
    return *this;
  }
 
 
  inline M2tsAudioDuration GetAudioDuration() const { return m_audioDuration; }
  inline bool AudioDurationHasBeenSet() const { return m_audioDurationHasBeenSet; }
  inline void SetAudioDuration(M2tsAudioDuration value) {
    m_audioDurationHasBeenSet = true;
    m_audioDuration = value;
  }
  inline M2tsSettings& WithAudioDuration(M2tsAudioDuration value) {
    SetAudioDuration(value);
    return *this;
  }
 
 
  inline int GetAudioFramesPerPes() const { return m_audioFramesPerPes; }
  inline bool AudioFramesPerPesHasBeenSet() const { return m_audioFramesPerPesHasBeenSet; }
  inline void SetAudioFramesPerPes(int value) {
    m_audioFramesPerPesHasBeenSet = true;
    m_audioFramesPerPes = value;
  }
  inline M2tsSettings& WithAudioFramesPerPes(int value) {
    SetAudioFramesPerPes(value);
    return *this;
  }
 
 
  inline const Aws::Vector<int>& GetAudioPids() const { return m_audioPids; }
  inline bool AudioPidsHasBeenSet() const { return m_audioPidsHasBeenSet; }
  template <typename AudioPidsT = Aws::Vector<int>>
  void SetAudioPids(AudioPidsT&& value) {
    m_audioPidsHasBeenSet = true;
    m_audioPids = std::forward<AudioPidsT>(value);
  }
  template <typename AudioPidsT = Aws::Vector<int>>
  M2tsSettings& WithAudioPids(AudioPidsT&& value) {
    SetAudioPids(std::forward<AudioPidsT>(value));
    return *this;
  }
  inline M2tsSettings& AddAudioPids(int value) {
    m_audioPidsHasBeenSet = true;
    m_audioPids.push_back(value);
    return *this;
  }
 
 
  inline int GetAudioPtsOffsetDelta() const { return m_audioPtsOffsetDelta; }
  inline bool AudioPtsOffsetDeltaHasBeenSet() const { return m_audioPtsOffsetDeltaHasBeenSet; }
  inline void SetAudioPtsOffsetDelta(int value) {
    m_audioPtsOffsetDeltaHasBeenSet = true;
    m_audioPtsOffsetDelta = value;
  }
  inline M2tsSettings& WithAudioPtsOffsetDelta(int value) {
    SetAudioPtsOffsetDelta(value);
    return *this;
  }
 
 
  inline int GetBitrate() const { return m_bitrate; }
  inline bool BitrateHasBeenSet() const { return m_bitrateHasBeenSet; }
  inline void SetBitrate(int value) {
    m_bitrateHasBeenSet = true;
    m_bitrate = value;
  }
  inline M2tsSettings& WithBitrate(int value) {
    SetBitrate(value);
    return *this;
  }
 
 
  inline M2tsBufferModel GetBufferModel() const { return m_bufferModel; }
  inline bool BufferModelHasBeenSet() const { return m_bufferModelHasBeenSet; }
  inline void SetBufferModel(M2tsBufferModel value) {
    m_bufferModelHasBeenSet = true;
    m_bufferModel = value;
  }
  inline M2tsSettings& WithBufferModel(M2tsBufferModel value) {
    SetBufferModel(value);
    return *this;
  }
 
 
  inline M2tsDataPtsControl GetDataPTSControl() const { return m_dataPTSControl; }
  inline bool DataPTSControlHasBeenSet() const { return m_dataPTSControlHasBeenSet; }
  inline void SetDataPTSControl(M2tsDataPtsControl value) {
    m_dataPTSControlHasBeenSet = true;
    m_dataPTSControl = value;
  }
  inline M2tsSettings& WithDataPTSControl(M2tsDataPtsControl value) {
    SetDataPTSControl(value);
    return *this;
  }
 
 
  inline const DvbNitSettings& GetDvbNitSettings() const { return m_dvbNitSettings; }
  inline bool DvbNitSettingsHasBeenSet() const { return m_dvbNitSettingsHasBeenSet; }
  template <typename DvbNitSettingsT = DvbNitSettings>
  void SetDvbNitSettings(DvbNitSettingsT&& value) {
    m_dvbNitSettingsHasBeenSet = true;
    m_dvbNitSettings = std::forward<DvbNitSettingsT>(value);
  }
  template <typename DvbNitSettingsT = DvbNitSettings>
  M2tsSettings& WithDvbNitSettings(DvbNitSettingsT&& value) {
    SetDvbNitSettings(std::forward<DvbNitSettingsT>(value));
    return *this;
  }
 
 
  inline const DvbSdtSettings& GetDvbSdtSettings() const { return m_dvbSdtSettings; }
  inline bool DvbSdtSettingsHasBeenSet() const { return m_dvbSdtSettingsHasBeenSet; }
  template <typename DvbSdtSettingsT = DvbSdtSettings>
  void SetDvbSdtSettings(DvbSdtSettingsT&& value) {
    m_dvbSdtSettingsHasBeenSet = true;
    m_dvbSdtSettings = std::forward<DvbSdtSettingsT>(value);
  }
  template <typename DvbSdtSettingsT = DvbSdtSettings>
  M2tsSettings& WithDvbSdtSettings(DvbSdtSettingsT&& value) {
    SetDvbSdtSettings(std::forward<DvbSdtSettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<int>& GetDvbSubPids() const { return m_dvbSubPids; }
  inline bool DvbSubPidsHasBeenSet() const { return m_dvbSubPidsHasBeenSet; }
  template <typename DvbSubPidsT = Aws::Vector<int>>
  void SetDvbSubPids(DvbSubPidsT&& value) {
    m_dvbSubPidsHasBeenSet = true;
    m_dvbSubPids = std::forward<DvbSubPidsT>(value);
  }
  template <typename DvbSubPidsT = Aws::Vector<int>>
  M2tsSettings& WithDvbSubPids(DvbSubPidsT&& value) {
    SetDvbSubPids(std::forward<DvbSubPidsT>(value));
    return *this;
  }
  inline M2tsSettings& AddDvbSubPids(int value) {
    m_dvbSubPidsHasBeenSet = true;
    m_dvbSubPids.push_back(value);
    return *this;
  }
 
 
  inline const DvbTdtSettings& GetDvbTdtSettings() const { return m_dvbTdtSettings; }
  inline bool DvbTdtSettingsHasBeenSet() const { return m_dvbTdtSettingsHasBeenSet; }
  template <typename DvbTdtSettingsT = DvbTdtSettings>
  void SetDvbTdtSettings(DvbTdtSettingsT&& value) {
    m_dvbTdtSettingsHasBeenSet = true;
    m_dvbTdtSettings = std::forward<DvbTdtSettingsT>(value);
  }
  template <typename DvbTdtSettingsT = DvbTdtSettings>
  M2tsSettings& WithDvbTdtSettings(DvbTdtSettingsT&& value) {
    SetDvbTdtSettings(std::forward<DvbTdtSettingsT>(value));
    return *this;
  }
 
 
  inline int GetDvbTeletextPid() const { return m_dvbTeletextPid; }
  inline bool DvbTeletextPidHasBeenSet() const { return m_dvbTeletextPidHasBeenSet; }
  inline void SetDvbTeletextPid(int value) {
    m_dvbTeletextPidHasBeenSet = true;
    m_dvbTeletextPid = value;
  }
  inline M2tsSettings& WithDvbTeletextPid(int value) {
    SetDvbTeletextPid(value);
    return *this;
  }
 
 
  inline M2tsEbpAudioInterval GetEbpAudioInterval() const { return m_ebpAudioInterval; }
  inline bool EbpAudioIntervalHasBeenSet() const { return m_ebpAudioIntervalHasBeenSet; }
  inline void SetEbpAudioInterval(M2tsEbpAudioInterval value) {
    m_ebpAudioIntervalHasBeenSet = true;
    m_ebpAudioInterval = value;
  }
  inline M2tsSettings& WithEbpAudioInterval(M2tsEbpAudioInterval value) {
    SetEbpAudioInterval(value);
    return *this;
  }
 
 
  inline M2tsEbpPlacement GetEbpPlacement() const { return m_ebpPlacement; }
  inline bool EbpPlacementHasBeenSet() const { return m_ebpPlacementHasBeenSet; }
  inline void SetEbpPlacement(M2tsEbpPlacement value) {
    m_ebpPlacementHasBeenSet = true;
    m_ebpPlacement = value;
  }
  inline M2tsSettings& WithEbpPlacement(M2tsEbpPlacement value) {
    SetEbpPlacement(value);
    return *this;
  }
 
 
  inline M2tsEsRateInPes GetEsRateInPes() const { return m_esRateInPes; }
  inline bool EsRateInPesHasBeenSet() const { return m_esRateInPesHasBeenSet; }
  inline void SetEsRateInPes(M2tsEsRateInPes value) {
    m_esRateInPesHasBeenSet = true;
    m_esRateInPes = value;
  }
  inline M2tsSettings& WithEsRateInPes(M2tsEsRateInPes value) {
    SetEsRateInPes(value);
    return *this;
  }
 
 
  inline M2tsForceTsVideoEbpOrder GetForceTsVideoEbpOrder() const { return m_forceTsVideoEbpOrder; }
  inline bool ForceTsVideoEbpOrderHasBeenSet() const { return m_forceTsVideoEbpOrderHasBeenSet; }
  inline void SetForceTsVideoEbpOrder(M2tsForceTsVideoEbpOrder value) {
    m_forceTsVideoEbpOrderHasBeenSet = true;
    m_forceTsVideoEbpOrder = value;
  }
  inline M2tsSettings& WithForceTsVideoEbpOrder(M2tsForceTsVideoEbpOrder value) {
    SetForceTsVideoEbpOrder(value);
    return *this;
  }
 
 
  inline double GetFragmentTime() const { return m_fragmentTime; }
  inline bool FragmentTimeHasBeenSet() const { return m_fragmentTimeHasBeenSet; }
  inline void SetFragmentTime(double value) {
    m_fragmentTimeHasBeenSet = true;
    m_fragmentTime = value;
  }
  inline M2tsSettings& WithFragmentTime(double value) {
    SetFragmentTime(value);
    return *this;
  }
 
 
  inline M2tsKlvMetadata GetKlvMetadata() const { return m_klvMetadata; }
  inline bool KlvMetadataHasBeenSet() const { return m_klvMetadataHasBeenSet; }
  inline void SetKlvMetadata(M2tsKlvMetadata value) {
    m_klvMetadataHasBeenSet = true;
    m_klvMetadata = value;
  }
  inline M2tsSettings& WithKlvMetadata(M2tsKlvMetadata value) {
    SetKlvMetadata(value);
    return *this;
  }
 
 
  inline int GetMaxPcrInterval() const { return m_maxPcrInterval; }
  inline bool MaxPcrIntervalHasBeenSet() const { return m_maxPcrIntervalHasBeenSet; }
  inline void SetMaxPcrInterval(int value) {
    m_maxPcrIntervalHasBeenSet = true;
    m_maxPcrInterval = value;
  }
  inline M2tsSettings& WithMaxPcrInterval(int value) {
    SetMaxPcrInterval(value);
    return *this;
  }
 
 
  inline int GetMinEbpInterval() const { return m_minEbpInterval; }
  inline bool MinEbpIntervalHasBeenSet() const { return m_minEbpIntervalHasBeenSet; }
  inline void SetMinEbpInterval(int value) {
    m_minEbpIntervalHasBeenSet = true;
    m_minEbpInterval = value;
  }
  inline M2tsSettings& WithMinEbpInterval(int value) {
    SetMinEbpInterval(value);
    return *this;
  }
 
 
  inline M2tsNielsenId3 GetNielsenId3() const { return m_nielsenId3; }
  inline bool NielsenId3HasBeenSet() const { return m_nielsenId3HasBeenSet; }
  inline void SetNielsenId3(M2tsNielsenId3 value) {
    m_nielsenId3HasBeenSet = true;
    m_nielsenId3 = value;
  }
  inline M2tsSettings& WithNielsenId3(M2tsNielsenId3 value) {
    SetNielsenId3(value);
    return *this;
  }
 
 
  inline double GetNullPacketBitrate() const { return m_nullPacketBitrate; }
  inline bool NullPacketBitrateHasBeenSet() const { return m_nullPacketBitrateHasBeenSet; }
  inline void SetNullPacketBitrate(double value) {
    m_nullPacketBitrateHasBeenSet = true;
    m_nullPacketBitrate = value;
  }
  inline M2tsSettings& WithNullPacketBitrate(double value) {
    SetNullPacketBitrate(value);
    return *this;
  }
 
 
  inline int GetPatInterval() const { return m_patInterval; }
  inline bool PatIntervalHasBeenSet() const { return m_patIntervalHasBeenSet; }
  inline void SetPatInterval(int value) {
    m_patIntervalHasBeenSet = true;
    m_patInterval = value;
  }
  inline M2tsSettings& WithPatInterval(int value) {
    SetPatInterval(value);
    return *this;
  }
 
 
  inline M2tsPcrControl GetPcrControl() const { return m_pcrControl; }
  inline bool PcrControlHasBeenSet() const { return m_pcrControlHasBeenSet; }
  inline void SetPcrControl(M2tsPcrControl value) {
    m_pcrControlHasBeenSet = true;
    m_pcrControl = value;
  }
  inline M2tsSettings& WithPcrControl(M2tsPcrControl value) {
    SetPcrControl(value);
    return *this;
  }
 
 
  inline int GetPcrPid() const { return m_pcrPid; }
  inline bool PcrPidHasBeenSet() const { return m_pcrPidHasBeenSet; }
  inline void SetPcrPid(int value) {
    m_pcrPidHasBeenSet = true;
    m_pcrPid = value;
  }
  inline M2tsSettings& WithPcrPid(int value) {
    SetPcrPid(value);
    return *this;
  }
 
 
  inline int GetPmtInterval() const { return m_pmtInterval; }
  inline bool PmtIntervalHasBeenSet() const { return m_pmtIntervalHasBeenSet; }
  inline void SetPmtInterval(int value) {
    m_pmtIntervalHasBeenSet = true;
    m_pmtInterval = value;
  }
  inline M2tsSettings& WithPmtInterval(int value) {
    SetPmtInterval(value);
    return *this;
  }
 
 
  inline int GetPmtPid() const { return m_pmtPid; }
  inline bool PmtPidHasBeenSet() const { return m_pmtPidHasBeenSet; }
  inline void SetPmtPid(int value) {
    m_pmtPidHasBeenSet = true;
    m_pmtPid = value;
  }
  inline M2tsSettings& WithPmtPid(int value) {
    SetPmtPid(value);
    return *this;
  }
 
 
  inline M2tsPreventBufferUnderflow GetPreventBufferUnderflow() const { return m_preventBufferUnderflow; }
  inline bool PreventBufferUnderflowHasBeenSet() const { return m_preventBufferUnderflowHasBeenSet; }
  inline void SetPreventBufferUnderflow(M2tsPreventBufferUnderflow value) {
    m_preventBufferUnderflowHasBeenSet = true;
    m_preventBufferUnderflow = value;
  }
  inline M2tsSettings& WithPreventBufferUnderflow(M2tsPreventBufferUnderflow value) {
    SetPreventBufferUnderflow(value);
    return *this;
  }
 
 
  inline int GetPrivateMetadataPid() const { return m_privateMetadataPid; }
  inline bool PrivateMetadataPidHasBeenSet() const { return m_privateMetadataPidHasBeenSet; }
  inline void SetPrivateMetadataPid(int value) {
    m_privateMetadataPidHasBeenSet = true;
    m_privateMetadataPid = value;
  }
  inline M2tsSettings& WithPrivateMetadataPid(int value) {
    SetPrivateMetadataPid(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 M2tsSettings& WithProgramNumber(int value) {
    SetProgramNumber(value);
    return *this;
  }
 
 
  inline int GetPtsOffset() const { return m_ptsOffset; }
  inline bool PtsOffsetHasBeenSet() const { return m_ptsOffsetHasBeenSet; }
  inline void SetPtsOffset(int value) {
    m_ptsOffsetHasBeenSet = true;
    m_ptsOffset = value;
  }
  inline M2tsSettings& WithPtsOffset(int value) {
    SetPtsOffset(value);
    return *this;
  }
 
 
  inline TsPtsOffset GetPtsOffsetMode() const { return m_ptsOffsetMode; }
  inline bool PtsOffsetModeHasBeenSet() const { return m_ptsOffsetModeHasBeenSet; }
  inline void SetPtsOffsetMode(TsPtsOffset value) {
    m_ptsOffsetModeHasBeenSet = true;
    m_ptsOffsetMode = value;
  }
  inline M2tsSettings& WithPtsOffsetMode(TsPtsOffset value) {
    SetPtsOffsetMode(value);
    return *this;
  }
 
 
  inline M2tsRateMode GetRateMode() const { return m_rateMode; }
  inline bool RateModeHasBeenSet() const { return m_rateModeHasBeenSet; }
  inline void SetRateMode(M2tsRateMode value) {
    m_rateModeHasBeenSet = true;
    m_rateMode = value;
  }
  inline M2tsSettings& WithRateMode(M2tsRateMode value) {
    SetRateMode(value);
    return *this;
  }
 
 
  inline const M2tsScte35Esam& GetScte35Esam() const { return m_scte35Esam; }
  inline bool Scte35EsamHasBeenSet() const { return m_scte35EsamHasBeenSet; }
  template <typename Scte35EsamT = M2tsScte35Esam>
  void SetScte35Esam(Scte35EsamT&& value) {
    m_scte35EsamHasBeenSet = true;
    m_scte35Esam = std::forward<Scte35EsamT>(value);
  }
  template <typename Scte35EsamT = M2tsScte35Esam>
  M2tsSettings& WithScte35Esam(Scte35EsamT&& value) {
    SetScte35Esam(std::forward<Scte35EsamT>(value));
    return *this;
  }
 
 
  inline int GetScte35Pid() const { return m_scte35Pid; }
  inline bool Scte35PidHasBeenSet() const { return m_scte35PidHasBeenSet; }
  inline void SetScte35Pid(int value) {
    m_scte35PidHasBeenSet = true;
    m_scte35Pid = value;
  }
  inline M2tsSettings& WithScte35Pid(int value) {
    SetScte35Pid(value);
    return *this;
  }
 
 
  inline M2tsScte35Source GetScte35Source() const { return m_scte35Source; }
  inline bool Scte35SourceHasBeenSet() const { return m_scte35SourceHasBeenSet; }
  inline void SetScte35Source(M2tsScte35Source value) {
    m_scte35SourceHasBeenSet = true;
    m_scte35Source = value;
  }
  inline M2tsSettings& WithScte35Source(M2tsScte35Source value) {
    SetScte35Source(value);
    return *this;
  }
 
 
  inline M2tsSegmentationMarkers GetSegmentationMarkers() const { return m_segmentationMarkers; }
  inline bool SegmentationMarkersHasBeenSet() const { return m_segmentationMarkersHasBeenSet; }
  inline void SetSegmentationMarkers(M2tsSegmentationMarkers value) {
    m_segmentationMarkersHasBeenSet = true;
    m_segmentationMarkers = value;
  }
  inline M2tsSettings& WithSegmentationMarkers(M2tsSegmentationMarkers value) {
    SetSegmentationMarkers(value);
    return *this;
  }
 
 
  inline M2tsSegmentationStyle GetSegmentationStyle() const { return m_segmentationStyle; }
  inline bool SegmentationStyleHasBeenSet() const { return m_segmentationStyleHasBeenSet; }
  inline void SetSegmentationStyle(M2tsSegmentationStyle value) {
    m_segmentationStyleHasBeenSet = true;
    m_segmentationStyle = value;
  }
  inline M2tsSettings& WithSegmentationStyle(M2tsSegmentationStyle value) {
    SetSegmentationStyle(value);
    return *this;
  }
 
 
  inline double GetSegmentationTime() const { return m_segmentationTime; }
  inline bool SegmentationTimeHasBeenSet() const { return m_segmentationTimeHasBeenSet; }
  inline void SetSegmentationTime(double value) {
    m_segmentationTimeHasBeenSet = true;
    m_segmentationTime = value;
  }
  inline M2tsSettings& WithSegmentationTime(double value) {
    SetSegmentationTime(value);
    return *this;
  }
 
 
  inline int GetTimedMetadataPid() const { return m_timedMetadataPid; }
  inline bool TimedMetadataPidHasBeenSet() const { return m_timedMetadataPidHasBeenSet; }
  inline void SetTimedMetadataPid(int value) {
    m_timedMetadataPidHasBeenSet = true;
    m_timedMetadataPid = value;
  }
  inline M2tsSettings& WithTimedMetadataPid(int value) {
    SetTimedMetadataPid(value);
    return *this;
  }
 
 
  inline int GetTransportStreamId() const { return m_transportStreamId; }
  inline bool TransportStreamIdHasBeenSet() const { return m_transportStreamIdHasBeenSet; }
  inline void SetTransportStreamId(int value) {
    m_transportStreamIdHasBeenSet = true;
    m_transportStreamId = value;
  }
  inline M2tsSettings& WithTransportStreamId(int value) {
    SetTransportStreamId(value);
    return *this;
  }
 
 
  inline int GetVideoPid() const { return m_videoPid; }
  inline bool VideoPidHasBeenSet() const { return m_videoPidHasBeenSet; }
  inline void SetVideoPid(int value) {
    m_videoPidHasBeenSet = true;
    m_videoPid = value;
  }
  inline M2tsSettings& WithVideoPid(int value) {
    SetVideoPid(value);
    return *this;
  }
 private:
  M2tsAudioBufferModel m_audioBufferModel{M2tsAudioBufferModel::NOT_SET};
 
  M2tsAudioDuration m_audioDuration{M2tsAudioDuration::NOT_SET};
 
  int m_audioFramesPerPes{0};
 
  Aws::Vector<int> m_audioPids;
 
  int m_audioPtsOffsetDelta{0};
 
  int m_bitrate{0};
 
  M2tsBufferModel m_bufferModel{M2tsBufferModel::NOT_SET};
 
  M2tsDataPtsControl m_dataPTSControl{M2tsDataPtsControl::NOT_SET};
 
  DvbNitSettings m_dvbNitSettings;
 
  DvbSdtSettings m_dvbSdtSettings;
 
  Aws::Vector<int> m_dvbSubPids;
 
  DvbTdtSettings m_dvbTdtSettings;
 
  int m_dvbTeletextPid{0};
 
  M2tsEbpAudioInterval m_ebpAudioInterval{M2tsEbpAudioInterval::NOT_SET};
 
  M2tsEbpPlacement m_ebpPlacement{M2tsEbpPlacement::NOT_SET};
 
  M2tsEsRateInPes m_esRateInPes{M2tsEsRateInPes::NOT_SET};
 
  M2tsForceTsVideoEbpOrder m_forceTsVideoEbpOrder{M2tsForceTsVideoEbpOrder::NOT_SET};
 
  double m_fragmentTime{0.0};
 
  M2tsKlvMetadata m_klvMetadata{M2tsKlvMetadata::NOT_SET};
 
  int m_maxPcrInterval{0};
 
  int m_minEbpInterval{0};
 
  M2tsNielsenId3 m_nielsenId3{M2tsNielsenId3::NOT_SET};
 
  double m_nullPacketBitrate{0.0};
 
  int m_patInterval{0};
 
  M2tsPcrControl m_pcrControl{M2tsPcrControl::NOT_SET};
 
  int m_pcrPid{0};
 
  int m_pmtInterval{0};
 
  int m_pmtPid{0};
 
  M2tsPreventBufferUnderflow m_preventBufferUnderflow{M2tsPreventBufferUnderflow::NOT_SET};
 
  int m_privateMetadataPid{0};
 
  int m_programNumber{0};
 
  int m_ptsOffset{0};
 
  TsPtsOffset m_ptsOffsetMode{TsPtsOffset::NOT_SET};
 
  M2tsRateMode m_rateMode{M2tsRateMode::NOT_SET};
 
  M2tsScte35Esam m_scte35Esam;
 
  int m_scte35Pid{0};
 
  M2tsScte35Source m_scte35Source{M2tsScte35Source::NOT_SET};
 
  M2tsSegmentationMarkers m_segmentationMarkers{M2tsSegmentationMarkers::NOT_SET};
 
  M2tsSegmentationStyle m_segmentationStyle{M2tsSegmentationStyle::NOT_SET};
 
  double m_segmentationTime{0.0};
 
  int m_timedMetadataPid{0};
 
  int m_transportStreamId{0};
 
  int m_videoPid{0};
  bool m_audioBufferModelHasBeenSet = false;
  bool m_audioDurationHasBeenSet = false;
  bool m_audioFramesPerPesHasBeenSet = false;
  bool m_audioPidsHasBeenSet = false;
  bool m_audioPtsOffsetDeltaHasBeenSet = false;
  bool m_bitrateHasBeenSet = false;
  bool m_bufferModelHasBeenSet = false;
  bool m_dataPTSControlHasBeenSet = false;
  bool m_dvbNitSettingsHasBeenSet = false;
  bool m_dvbSdtSettingsHasBeenSet = false;
  bool m_dvbSubPidsHasBeenSet = false;
  bool m_dvbTdtSettingsHasBeenSet = false;
  bool m_dvbTeletextPidHasBeenSet = false;
  bool m_ebpAudioIntervalHasBeenSet = false;
  bool m_ebpPlacementHasBeenSet = false;
  bool m_esRateInPesHasBeenSet = false;
  bool m_forceTsVideoEbpOrderHasBeenSet = false;
  bool m_fragmentTimeHasBeenSet = false;
  bool m_klvMetadataHasBeenSet = false;
  bool m_maxPcrIntervalHasBeenSet = false;
  bool m_minEbpIntervalHasBeenSet = false;
  bool m_nielsenId3HasBeenSet = false;
  bool m_nullPacketBitrateHasBeenSet = false;
  bool m_patIntervalHasBeenSet = false;
  bool m_pcrControlHasBeenSet = false;
  bool m_pcrPidHasBeenSet = false;
  bool m_pmtIntervalHasBeenSet = false;
  bool m_pmtPidHasBeenSet = false;
  bool m_preventBufferUnderflowHasBeenSet = false;
  bool m_privateMetadataPidHasBeenSet = false;
  bool m_programNumberHasBeenSet = false;
  bool m_ptsOffsetHasBeenSet = false;
  bool m_ptsOffsetModeHasBeenSet = false;
  bool m_rateModeHasBeenSet = false;
  bool m_scte35EsamHasBeenSet = false;
  bool m_scte35PidHasBeenSet = false;
  bool m_scte35SourceHasBeenSet = false;
  bool m_segmentationMarkersHasBeenSet = false;
  bool m_segmentationStyleHasBeenSet = false;
  bool m_segmentationTimeHasBeenSet = false;
  bool m_timedMetadataPidHasBeenSet = false;
  bool m_transportStreamIdHasBeenSet = false;
  bool m_videoPidHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws