CmafGroupSettings.h

 
#pragma once
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/mediaconvert/model/CmafClientCache.h>
#include <aws/mediaconvert/model/CmafCodecSpecification.h>
#include <aws/mediaconvert/model/DashManifestStyle.h>
#include <aws/mediaconvert/model/DestinationSettings.h>
#include <aws/mediaconvert/model/CmafEncryptionSettings.h>
#include <aws/mediaconvert/model/CmafImageBasedTrickPlay.h>
#include <aws/mediaconvert/model/CmafImageBasedTrickPlaySettings.h>
#include <aws/mediaconvert/model/CmafManifestCompression.h>
#include <aws/mediaconvert/model/CmafManifestDurationFormat.h>
#include <aws/mediaconvert/model/CmafMpdManifestBandwidthType.h>
#include <aws/mediaconvert/model/CmafMpdProfile.h>
#include <aws/mediaconvert/model/CmafPtsOffsetHandlingForBFrames.h>
#include <aws/mediaconvert/model/CmafSegmentControl.h>
#include <aws/mediaconvert/model/CmafSegmentLengthControl.h>
#include <aws/mediaconvert/model/CmafStreamInfResolution.h>
#include <aws/mediaconvert/model/CmafTargetDurationCompatibilityMode.h>
#include <aws/mediaconvert/model/CmafVideoCompositionOffsets.h>
#include <aws/mediaconvert/model/CmafWriteDASHManifest.h>
#include <aws/mediaconvert/model/CmafWriteHLSManifest.h>
#include <aws/mediaconvert/model/CmafWriteSegmentTimelineInRepresentation.h>
#include <aws/mediaconvert/model/CmafAdditionalManifest.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace MediaConvert
{
namespace Model
{
 
  class CmafGroupSettings
  {
  public:
    AWS_MEDIACONVERT_API CmafGroupSettings() = default;
    AWS_MEDIACONVERT_API CmafGroupSettings(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIACONVERT_API CmafGroupSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::Vector<CmafAdditionalManifest>& GetAdditionalManifests() const { return m_additionalManifests; }
    inline bool AdditionalManifestsHasBeenSet() const { return m_additionalManifestsHasBeenSet; }
    template<typename AdditionalManifestsT = Aws::Vector<CmafAdditionalManifest>>
    void SetAdditionalManifests(AdditionalManifestsT&& value) { m_additionalManifestsHasBeenSet = true; m_additionalManifests = std::forward<AdditionalManifestsT>(value); }
    template<typename AdditionalManifestsT = Aws::Vector<CmafAdditionalManifest>>
    CmafGroupSettings& WithAdditionalManifests(AdditionalManifestsT&& value) { SetAdditionalManifests(std::forward<AdditionalManifestsT>(value)); return *this;}
    template<typename AdditionalManifestsT = CmafAdditionalManifest>
    CmafGroupSettings& AddAdditionalManifests(AdditionalManifestsT&& value) { m_additionalManifestsHasBeenSet = true; m_additionalManifests.emplace_back(std::forward<AdditionalManifestsT>(value)); return *this; }
 
 
    inline const Aws::String& GetBaseUrl() const { return m_baseUrl; }
    inline bool BaseUrlHasBeenSet() const { return m_baseUrlHasBeenSet; }
    template<typename BaseUrlT = Aws::String>
    void SetBaseUrl(BaseUrlT&& value) { m_baseUrlHasBeenSet = true; m_baseUrl = std::forward<BaseUrlT>(value); }
    template<typename BaseUrlT = Aws::String>
    CmafGroupSettings& WithBaseUrl(BaseUrlT&& value) { SetBaseUrl(std::forward<BaseUrlT>(value)); return *this;}
 
 
    inline CmafClientCache GetClientCache() const { return m_clientCache; }
    inline bool ClientCacheHasBeenSet() const { return m_clientCacheHasBeenSet; }
    inline void SetClientCache(CmafClientCache value) { m_clientCacheHasBeenSet = true; m_clientCache = value; }
    inline CmafGroupSettings& WithClientCache(CmafClientCache value) { SetClientCache(value); return *this;}
 
 
    inline CmafCodecSpecification GetCodecSpecification() const { return m_codecSpecification; }
    inline bool CodecSpecificationHasBeenSet() const { return m_codecSpecificationHasBeenSet; }
    inline void SetCodecSpecification(CmafCodecSpecification value) { m_codecSpecificationHasBeenSet = true; m_codecSpecification = value; }
    inline CmafGroupSettings& WithCodecSpecification(CmafCodecSpecification value) { SetCodecSpecification(value); return *this;}
 
 
    inline const Aws::String& GetDashIFrameTrickPlayNameModifier() const { return m_dashIFrameTrickPlayNameModifier; }
    inline bool DashIFrameTrickPlayNameModifierHasBeenSet() const { return m_dashIFrameTrickPlayNameModifierHasBeenSet; }
    template<typename DashIFrameTrickPlayNameModifierT = Aws::String>
    void SetDashIFrameTrickPlayNameModifier(DashIFrameTrickPlayNameModifierT&& value) { m_dashIFrameTrickPlayNameModifierHasBeenSet = true; m_dashIFrameTrickPlayNameModifier = std::forward<DashIFrameTrickPlayNameModifierT>(value); }
    template<typename DashIFrameTrickPlayNameModifierT = Aws::String>
    CmafGroupSettings& WithDashIFrameTrickPlayNameModifier(DashIFrameTrickPlayNameModifierT&& value) { SetDashIFrameTrickPlayNameModifier(std::forward<DashIFrameTrickPlayNameModifierT>(value)); return *this;}
 
 
    inline DashManifestStyle GetDashManifestStyle() const { return m_dashManifestStyle; }
    inline bool DashManifestStyleHasBeenSet() const { return m_dashManifestStyleHasBeenSet; }
    inline void SetDashManifestStyle(DashManifestStyle value) { m_dashManifestStyleHasBeenSet = true; m_dashManifestStyle = value; }
    inline CmafGroupSettings& WithDashManifestStyle(DashManifestStyle value) { SetDashManifestStyle(value); return *this;}
 
 
    inline const Aws::String& GetDestination() const { return m_destination; }
    inline bool DestinationHasBeenSet() const { return m_destinationHasBeenSet; }
    template<typename DestinationT = Aws::String>
    void SetDestination(DestinationT&& value) { m_destinationHasBeenSet = true; m_destination = std::forward<DestinationT>(value); }
    template<typename DestinationT = Aws::String>
    CmafGroupSettings& WithDestination(DestinationT&& value) { SetDestination(std::forward<DestinationT>(value)); return *this;}
 
 
    inline const DestinationSettings& GetDestinationSettings() const { return m_destinationSettings; }
    inline bool DestinationSettingsHasBeenSet() const { return m_destinationSettingsHasBeenSet; }
    template<typename DestinationSettingsT = DestinationSettings>
    void SetDestinationSettings(DestinationSettingsT&& value) { m_destinationSettingsHasBeenSet = true; m_destinationSettings = std::forward<DestinationSettingsT>(value); }
    template<typename DestinationSettingsT = DestinationSettings>
    CmafGroupSettings& WithDestinationSettings(DestinationSettingsT&& value) { SetDestinationSettings(std::forward<DestinationSettingsT>(value)); return *this;}
 
 
    inline const CmafEncryptionSettings& GetEncryption() const { return m_encryption; }
    inline bool EncryptionHasBeenSet() const { return m_encryptionHasBeenSet; }
    template<typename EncryptionT = CmafEncryptionSettings>
    void SetEncryption(EncryptionT&& value) { m_encryptionHasBeenSet = true; m_encryption = std::forward<EncryptionT>(value); }
    template<typename EncryptionT = CmafEncryptionSettings>
    CmafGroupSettings& WithEncryption(EncryptionT&& value) { SetEncryption(std::forward<EncryptionT>(value)); return *this;}
 
 
    inline int GetFragmentLength() const { return m_fragmentLength; }
    inline bool FragmentLengthHasBeenSet() const { return m_fragmentLengthHasBeenSet; }
    inline void SetFragmentLength(int value) { m_fragmentLengthHasBeenSet = true; m_fragmentLength = value; }
    inline CmafGroupSettings& WithFragmentLength(int value) { SetFragmentLength(value); return *this;}
 
 
    inline CmafImageBasedTrickPlay GetImageBasedTrickPlay() const { return m_imageBasedTrickPlay; }
    inline bool ImageBasedTrickPlayHasBeenSet() const { return m_imageBasedTrickPlayHasBeenSet; }
    inline void SetImageBasedTrickPlay(CmafImageBasedTrickPlay value) { m_imageBasedTrickPlayHasBeenSet = true; m_imageBasedTrickPlay = value; }
    inline CmafGroupSettings& WithImageBasedTrickPlay(CmafImageBasedTrickPlay value) { SetImageBasedTrickPlay(value); return *this;}
 
 
    inline const CmafImageBasedTrickPlaySettings& GetImageBasedTrickPlaySettings() const { return m_imageBasedTrickPlaySettings; }
    inline bool ImageBasedTrickPlaySettingsHasBeenSet() const { return m_imageBasedTrickPlaySettingsHasBeenSet; }
    template<typename ImageBasedTrickPlaySettingsT = CmafImageBasedTrickPlaySettings>
    void SetImageBasedTrickPlaySettings(ImageBasedTrickPlaySettingsT&& value) { m_imageBasedTrickPlaySettingsHasBeenSet = true; m_imageBasedTrickPlaySettings = std::forward<ImageBasedTrickPlaySettingsT>(value); }
    template<typename ImageBasedTrickPlaySettingsT = CmafImageBasedTrickPlaySettings>
    CmafGroupSettings& WithImageBasedTrickPlaySettings(ImageBasedTrickPlaySettingsT&& value) { SetImageBasedTrickPlaySettings(std::forward<ImageBasedTrickPlaySettingsT>(value)); return *this;}
 
 
    inline CmafManifestCompression GetManifestCompression() const { return m_manifestCompression; }
    inline bool ManifestCompressionHasBeenSet() const { return m_manifestCompressionHasBeenSet; }
    inline void SetManifestCompression(CmafManifestCompression value) { m_manifestCompressionHasBeenSet = true; m_manifestCompression = value; }
    inline CmafGroupSettings& WithManifestCompression(CmafManifestCompression value) { SetManifestCompression(value); return *this;}
 
 
    inline CmafManifestDurationFormat GetManifestDurationFormat() const { return m_manifestDurationFormat; }
    inline bool ManifestDurationFormatHasBeenSet() const { return m_manifestDurationFormatHasBeenSet; }
    inline void SetManifestDurationFormat(CmafManifestDurationFormat value) { m_manifestDurationFormatHasBeenSet = true; m_manifestDurationFormat = value; }
    inline CmafGroupSettings& WithManifestDurationFormat(CmafManifestDurationFormat value) { SetManifestDurationFormat(value); return *this;}
 
 
    inline int GetMinBufferTime() const { return m_minBufferTime; }
    inline bool MinBufferTimeHasBeenSet() const { return m_minBufferTimeHasBeenSet; }
    inline void SetMinBufferTime(int value) { m_minBufferTimeHasBeenSet = true; m_minBufferTime = value; }
    inline CmafGroupSettings& WithMinBufferTime(int value) { SetMinBufferTime(value); return *this;}
 
 
    inline double GetMinFinalSegmentLength() const { return m_minFinalSegmentLength; }
    inline bool MinFinalSegmentLengthHasBeenSet() const { return m_minFinalSegmentLengthHasBeenSet; }
    inline void SetMinFinalSegmentLength(double value) { m_minFinalSegmentLengthHasBeenSet = true; m_minFinalSegmentLength = value; }
    inline CmafGroupSettings& WithMinFinalSegmentLength(double value) { SetMinFinalSegmentLength(value); return *this;}
 
 
    inline CmafMpdManifestBandwidthType GetMpdManifestBandwidthType() const { return m_mpdManifestBandwidthType; }
    inline bool MpdManifestBandwidthTypeHasBeenSet() const { return m_mpdManifestBandwidthTypeHasBeenSet; }
    inline void SetMpdManifestBandwidthType(CmafMpdManifestBandwidthType value) { m_mpdManifestBandwidthTypeHasBeenSet = true; m_mpdManifestBandwidthType = value; }
    inline CmafGroupSettings& WithMpdManifestBandwidthType(CmafMpdManifestBandwidthType value) { SetMpdManifestBandwidthType(value); return *this;}
 
 
    inline CmafMpdProfile GetMpdProfile() const { return m_mpdProfile; }
    inline bool MpdProfileHasBeenSet() const { return m_mpdProfileHasBeenSet; }
    inline void SetMpdProfile(CmafMpdProfile value) { m_mpdProfileHasBeenSet = true; m_mpdProfile = value; }
    inline CmafGroupSettings& WithMpdProfile(CmafMpdProfile value) { SetMpdProfile(value); return *this;}
 
 
    inline CmafPtsOffsetHandlingForBFrames GetPtsOffsetHandlingForBFrames() const { return m_ptsOffsetHandlingForBFrames; }
    inline bool PtsOffsetHandlingForBFramesHasBeenSet() const { return m_ptsOffsetHandlingForBFramesHasBeenSet; }
    inline void SetPtsOffsetHandlingForBFrames(CmafPtsOffsetHandlingForBFrames value) { m_ptsOffsetHandlingForBFramesHasBeenSet = true; m_ptsOffsetHandlingForBFrames = value; }
    inline CmafGroupSettings& WithPtsOffsetHandlingForBFrames(CmafPtsOffsetHandlingForBFrames value) { SetPtsOffsetHandlingForBFrames(value); return *this;}
 
 
    inline CmafSegmentControl GetSegmentControl() const { return m_segmentControl; }
    inline bool SegmentControlHasBeenSet() const { return m_segmentControlHasBeenSet; }
    inline void SetSegmentControl(CmafSegmentControl value) { m_segmentControlHasBeenSet = true; m_segmentControl = value; }
    inline CmafGroupSettings& WithSegmentControl(CmafSegmentControl value) { SetSegmentControl(value); return *this;}
 
 
    inline int GetSegmentLength() const { return m_segmentLength; }
    inline bool SegmentLengthHasBeenSet() const { return m_segmentLengthHasBeenSet; }
    inline void SetSegmentLength(int value) { m_segmentLengthHasBeenSet = true; m_segmentLength = value; }
    inline CmafGroupSettings& WithSegmentLength(int value) { SetSegmentLength(value); return *this;}
 
 
    inline CmafSegmentLengthControl GetSegmentLengthControl() const { return m_segmentLengthControl; }
    inline bool SegmentLengthControlHasBeenSet() const { return m_segmentLengthControlHasBeenSet; }
    inline void SetSegmentLengthControl(CmafSegmentLengthControl value) { m_segmentLengthControlHasBeenSet = true; m_segmentLengthControl = value; }
    inline CmafGroupSettings& WithSegmentLengthControl(CmafSegmentLengthControl value) { SetSegmentLengthControl(value); return *this;}
 
 
    inline CmafStreamInfResolution GetStreamInfResolution() const { return m_streamInfResolution; }
    inline bool StreamInfResolutionHasBeenSet() const { return m_streamInfResolutionHasBeenSet; }
    inline void SetStreamInfResolution(CmafStreamInfResolution value) { m_streamInfResolutionHasBeenSet = true; m_streamInfResolution = value; }
    inline CmafGroupSettings& WithStreamInfResolution(CmafStreamInfResolution value) { SetStreamInfResolution(value); return *this;}
 
 
    inline CmafTargetDurationCompatibilityMode GetTargetDurationCompatibilityMode() const { return m_targetDurationCompatibilityMode; }
    inline bool TargetDurationCompatibilityModeHasBeenSet() const { return m_targetDurationCompatibilityModeHasBeenSet; }
    inline void SetTargetDurationCompatibilityMode(CmafTargetDurationCompatibilityMode value) { m_targetDurationCompatibilityModeHasBeenSet = true; m_targetDurationCompatibilityMode = value; }
    inline CmafGroupSettings& WithTargetDurationCompatibilityMode(CmafTargetDurationCompatibilityMode value) { SetTargetDurationCompatibilityMode(value); return *this;}
 
 
    inline CmafVideoCompositionOffsets GetVideoCompositionOffsets() const { return m_videoCompositionOffsets; }
    inline bool VideoCompositionOffsetsHasBeenSet() const { return m_videoCompositionOffsetsHasBeenSet; }
    inline void SetVideoCompositionOffsets(CmafVideoCompositionOffsets value) { m_videoCompositionOffsetsHasBeenSet = true; m_videoCompositionOffsets = value; }
    inline CmafGroupSettings& WithVideoCompositionOffsets(CmafVideoCompositionOffsets value) { SetVideoCompositionOffsets(value); return *this;}
 
 
    inline CmafWriteDASHManifest GetWriteDashManifest() const { return m_writeDashManifest; }
    inline bool WriteDashManifestHasBeenSet() const { return m_writeDashManifestHasBeenSet; }
    inline void SetWriteDashManifest(CmafWriteDASHManifest value) { m_writeDashManifestHasBeenSet = true; m_writeDashManifest = value; }
    inline CmafGroupSettings& WithWriteDashManifest(CmafWriteDASHManifest value) { SetWriteDashManifest(value); return *this;}
 
 
    inline CmafWriteHLSManifest GetWriteHlsManifest() const { return m_writeHlsManifest; }
    inline bool WriteHlsManifestHasBeenSet() const { return m_writeHlsManifestHasBeenSet; }
    inline void SetWriteHlsManifest(CmafWriteHLSManifest value) { m_writeHlsManifestHasBeenSet = true; m_writeHlsManifest = value; }
    inline CmafGroupSettings& WithWriteHlsManifest(CmafWriteHLSManifest value) { SetWriteHlsManifest(value); return *this;}
 
 
    inline CmafWriteSegmentTimelineInRepresentation GetWriteSegmentTimelineInRepresentation() const { return m_writeSegmentTimelineInRepresentation; }
    inline bool WriteSegmentTimelineInRepresentationHasBeenSet() const { return m_writeSegmentTimelineInRepresentationHasBeenSet; }
    inline void SetWriteSegmentTimelineInRepresentation(CmafWriteSegmentTimelineInRepresentation value) { m_writeSegmentTimelineInRepresentationHasBeenSet = true; m_writeSegmentTimelineInRepresentation = value; }
    inline CmafGroupSettings& WithWriteSegmentTimelineInRepresentation(CmafWriteSegmentTimelineInRepresentation value) { SetWriteSegmentTimelineInRepresentation(value); return *this;}
  private:
 
    Aws::Vector<CmafAdditionalManifest> m_additionalManifests;
    bool m_additionalManifestsHasBeenSet = false;
 
    Aws::String m_baseUrl;
    bool m_baseUrlHasBeenSet = false;
 
    CmafClientCache m_clientCache{CmafClientCache::NOT_SET};
    bool m_clientCacheHasBeenSet = false;
 
    CmafCodecSpecification m_codecSpecification{CmafCodecSpecification::NOT_SET};
    bool m_codecSpecificationHasBeenSet = false;
 
    Aws::String m_dashIFrameTrickPlayNameModifier;
    bool m_dashIFrameTrickPlayNameModifierHasBeenSet = false;
 
    DashManifestStyle m_dashManifestStyle{DashManifestStyle::NOT_SET};
    bool m_dashManifestStyleHasBeenSet = false;
 
    Aws::String m_destination;
    bool m_destinationHasBeenSet = false;
 
    DestinationSettings m_destinationSettings;
    bool m_destinationSettingsHasBeenSet = false;
 
    CmafEncryptionSettings m_encryption;
    bool m_encryptionHasBeenSet = false;
 
    int m_fragmentLength{0};
    bool m_fragmentLengthHasBeenSet = false;
 
    CmafImageBasedTrickPlay m_imageBasedTrickPlay{CmafImageBasedTrickPlay::NOT_SET};
    bool m_imageBasedTrickPlayHasBeenSet = false;
 
    CmafImageBasedTrickPlaySettings m_imageBasedTrickPlaySettings;
    bool m_imageBasedTrickPlaySettingsHasBeenSet = false;
 
    CmafManifestCompression m_manifestCompression{CmafManifestCompression::NOT_SET};
    bool m_manifestCompressionHasBeenSet = false;
 
    CmafManifestDurationFormat m_manifestDurationFormat{CmafManifestDurationFormat::NOT_SET};
    bool m_manifestDurationFormatHasBeenSet = false;
 
    int m_minBufferTime{0};
    bool m_minBufferTimeHasBeenSet = false;
 
    double m_minFinalSegmentLength{0.0};
    bool m_minFinalSegmentLengthHasBeenSet = false;
 
    CmafMpdManifestBandwidthType m_mpdManifestBandwidthType{CmafMpdManifestBandwidthType::NOT_SET};
    bool m_mpdManifestBandwidthTypeHasBeenSet = false;
 
    CmafMpdProfile m_mpdProfile{CmafMpdProfile::NOT_SET};
    bool m_mpdProfileHasBeenSet = false;
 
    CmafPtsOffsetHandlingForBFrames m_ptsOffsetHandlingForBFrames{CmafPtsOffsetHandlingForBFrames::NOT_SET};
    bool m_ptsOffsetHandlingForBFramesHasBeenSet = false;
 
    CmafSegmentControl m_segmentControl{CmafSegmentControl::NOT_SET};
    bool m_segmentControlHasBeenSet = false;
 
    int m_segmentLength{0};
    bool m_segmentLengthHasBeenSet = false;
 
    CmafSegmentLengthControl m_segmentLengthControl{CmafSegmentLengthControl::NOT_SET};
    bool m_segmentLengthControlHasBeenSet = false;
 
    CmafStreamInfResolution m_streamInfResolution{CmafStreamInfResolution::NOT_SET};
    bool m_streamInfResolutionHasBeenSet = false;
 
    CmafTargetDurationCompatibilityMode m_targetDurationCompatibilityMode{CmafTargetDurationCompatibilityMode::NOT_SET};
    bool m_targetDurationCompatibilityModeHasBeenSet = false;
 
    CmafVideoCompositionOffsets m_videoCompositionOffsets{CmafVideoCompositionOffsets::NOT_SET};
    bool m_videoCompositionOffsetsHasBeenSet = false;
 
    CmafWriteDASHManifest m_writeDashManifest{CmafWriteDASHManifest::NOT_SET};
    bool m_writeDashManifestHasBeenSet = false;
 
    CmafWriteHLSManifest m_writeHlsManifest{CmafWriteHLSManifest::NOT_SET};
    bool m_writeHlsManifestHasBeenSet = false;
 
    CmafWriteSegmentTimelineInRepresentation m_writeSegmentTimelineInRepresentation{CmafWriteSegmentTimelineInRepresentation::NOT_SET};
    bool m_writeSegmentTimelineInRepresentationHasBeenSet = false;
  };
 
} // namespace Model
} // namespace MediaConvert
} // namespace Aws