From 469d8956d0a1d9eab2e12401f6bcf9fe90cf550b Mon Sep 17 00:00:00 2001 From: aws-sdk-cpp-automation Date: Mon, 6 May 2024 18:17:13 +0000 Subject: [PATCH] AWS Elemental MediaLive now supports configuring how SCTE 35 passthrough triggers segment breaks in HLS and MediaPackage output groups. Previously, messages triggered breaks in all these output groups. The new option is to trigger segment breaks only in groups that have SCTE 35 passthrough enabled. --- VERSION | 2 +- .../aws/medialive/model/AvailConfiguration.h | 101 ++++++++++++++++++ .../medialive/model/Scte35SegmentationScope.h | 31 ++++++ .../source/model/AvailConfiguration.cpp | 20 +++- .../source/model/Scte35SegmentationScope.cpp | 72 +++++++++++++ .../include/aws/core/VersionConfig.h | 4 +- .../medialive-2017-10-14.normal.json | 13 +++ 7 files changed, 238 insertions(+), 5 deletions(-) create mode 100644 generated/src/aws-cpp-sdk-medialive/include/aws/medialive/model/Scte35SegmentationScope.h create mode 100644 generated/src/aws-cpp-sdk-medialive/source/model/Scte35SegmentationScope.cpp diff --git a/VERSION b/VERSION index 36212f5e2ab..373a9d971e7 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.11.321 \ No newline at end of file +1.11.322 \ No newline at end of file diff --git a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/model/AvailConfiguration.h b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/model/AvailConfiguration.h index 61b9740dc39..4978d90b03a 100644 --- a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/model/AvailConfiguration.h +++ b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/model/AvailConfiguration.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include namespace Aws @@ -85,10 +86,110 @@ namespace Model */ inline AvailConfiguration& WithAvailSettings(AvailSettings&& value) { SetAvailSettings(std::move(value)); return *this;} + + /** + * Configures whether SCTE 35 passthrough triggers segment breaks in all output + * groups that use segmented outputs. Insertion of a SCTE 35 message typically + * results in a segment break, in addition to the regular cadence of breaks. The + * segment breaks appear in video outputs, audio outputs, and captions outputs (if + * any). + +ALL_OUTPUT_GROUPS: Default. Insert the segment break in in all output + * groups that have segmented outputs. This is the legacy + * behavior. +SCTE35_ENABLED_OUTPUT_GROUPS: Insert the segment break only in output + * groups that have SCTE 35 passthrough enabled. This is the recommended value, + * because it reduces unnecessary segment breaks. + */ + inline const Scte35SegmentationScope& GetScte35SegmentationScope() const{ return m_scte35SegmentationScope; } + + /** + * Configures whether SCTE 35 passthrough triggers segment breaks in all output + * groups that use segmented outputs. Insertion of a SCTE 35 message typically + * results in a segment break, in addition to the regular cadence of breaks. The + * segment breaks appear in video outputs, audio outputs, and captions outputs (if + * any). + +ALL_OUTPUT_GROUPS: Default. Insert the segment break in in all output + * groups that have segmented outputs. This is the legacy + * behavior. +SCTE35_ENABLED_OUTPUT_GROUPS: Insert the segment break only in output + * groups that have SCTE 35 passthrough enabled. This is the recommended value, + * because it reduces unnecessary segment breaks. + */ + inline bool Scte35SegmentationScopeHasBeenSet() const { return m_scte35SegmentationScopeHasBeenSet; } + + /** + * Configures whether SCTE 35 passthrough triggers segment breaks in all output + * groups that use segmented outputs. Insertion of a SCTE 35 message typically + * results in a segment break, in addition to the regular cadence of breaks. The + * segment breaks appear in video outputs, audio outputs, and captions outputs (if + * any). + +ALL_OUTPUT_GROUPS: Default. Insert the segment break in in all output + * groups that have segmented outputs. This is the legacy + * behavior. +SCTE35_ENABLED_OUTPUT_GROUPS: Insert the segment break only in output + * groups that have SCTE 35 passthrough enabled. This is the recommended value, + * because it reduces unnecessary segment breaks. + */ + inline void SetScte35SegmentationScope(const Scte35SegmentationScope& value) { m_scte35SegmentationScopeHasBeenSet = true; m_scte35SegmentationScope = value; } + + /** + * Configures whether SCTE 35 passthrough triggers segment breaks in all output + * groups that use segmented outputs. Insertion of a SCTE 35 message typically + * results in a segment break, in addition to the regular cadence of breaks. The + * segment breaks appear in video outputs, audio outputs, and captions outputs (if + * any). + +ALL_OUTPUT_GROUPS: Default. Insert the segment break in in all output + * groups that have segmented outputs. This is the legacy + * behavior. +SCTE35_ENABLED_OUTPUT_GROUPS: Insert the segment break only in output + * groups that have SCTE 35 passthrough enabled. This is the recommended value, + * because it reduces unnecessary segment breaks. + */ + inline void SetScte35SegmentationScope(Scte35SegmentationScope&& value) { m_scte35SegmentationScopeHasBeenSet = true; m_scte35SegmentationScope = std::move(value); } + + /** + * Configures whether SCTE 35 passthrough triggers segment breaks in all output + * groups that use segmented outputs. Insertion of a SCTE 35 message typically + * results in a segment break, in addition to the regular cadence of breaks. The + * segment breaks appear in video outputs, audio outputs, and captions outputs (if + * any). + +ALL_OUTPUT_GROUPS: Default. Insert the segment break in in all output + * groups that have segmented outputs. This is the legacy + * behavior. +SCTE35_ENABLED_OUTPUT_GROUPS: Insert the segment break only in output + * groups that have SCTE 35 passthrough enabled. This is the recommended value, + * because it reduces unnecessary segment breaks. + */ + inline AvailConfiguration& WithScte35SegmentationScope(const Scte35SegmentationScope& value) { SetScte35SegmentationScope(value); return *this;} + + /** + * Configures whether SCTE 35 passthrough triggers segment breaks in all output + * groups that use segmented outputs. Insertion of a SCTE 35 message typically + * results in a segment break, in addition to the regular cadence of breaks. The + * segment breaks appear in video outputs, audio outputs, and captions outputs (if + * any). + +ALL_OUTPUT_GROUPS: Default. Insert the segment break in in all output + * groups that have segmented outputs. This is the legacy + * behavior. +SCTE35_ENABLED_OUTPUT_GROUPS: Insert the segment break only in output + * groups that have SCTE 35 passthrough enabled. This is the recommended value, + * because it reduces unnecessary segment breaks. + */ + inline AvailConfiguration& WithScte35SegmentationScope(Scte35SegmentationScope&& value) { SetScte35SegmentationScope(std::move(value)); return *this;} + private: AvailSettings m_availSettings; bool m_availSettingsHasBeenSet = false; + + Scte35SegmentationScope m_scte35SegmentationScope; + bool m_scte35SegmentationScopeHasBeenSet = false; }; } // namespace Model diff --git a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/model/Scte35SegmentationScope.h b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/model/Scte35SegmentationScope.h new file mode 100644 index 00000000000..817f1bd1cbb --- /dev/null +++ b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/model/Scte35SegmentationScope.h @@ -0,0 +1,31 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include + +namespace Aws +{ +namespace MediaLive +{ +namespace Model +{ + enum class Scte35SegmentationScope + { + NOT_SET, + ALL_OUTPUT_GROUPS, + SCTE35_ENABLED_OUTPUT_GROUPS + }; + +namespace Scte35SegmentationScopeMapper +{ +AWS_MEDIALIVE_API Scte35SegmentationScope GetScte35SegmentationScopeForName(const Aws::String& name); + +AWS_MEDIALIVE_API Aws::String GetNameForScte35SegmentationScope(Scte35SegmentationScope value); +} // namespace Scte35SegmentationScopeMapper +} // namespace Model +} // namespace MediaLive +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-medialive/source/model/AvailConfiguration.cpp b/generated/src/aws-cpp-sdk-medialive/source/model/AvailConfiguration.cpp index f7e4ce72e7b..dc5358b65ee 100644 --- a/generated/src/aws-cpp-sdk-medialive/source/model/AvailConfiguration.cpp +++ b/generated/src/aws-cpp-sdk-medialive/source/model/AvailConfiguration.cpp @@ -19,12 +19,16 @@ namespace Model { AvailConfiguration::AvailConfiguration() : - m_availSettingsHasBeenSet(false) + m_availSettingsHasBeenSet(false), + m_scte35SegmentationScope(Scte35SegmentationScope::NOT_SET), + m_scte35SegmentationScopeHasBeenSet(false) { } AvailConfiguration::AvailConfiguration(JsonView jsonValue) : - m_availSettingsHasBeenSet(false) + m_availSettingsHasBeenSet(false), + m_scte35SegmentationScope(Scte35SegmentationScope::NOT_SET), + m_scte35SegmentationScopeHasBeenSet(false) { *this = jsonValue; } @@ -38,6 +42,13 @@ AvailConfiguration& AvailConfiguration::operator =(JsonView jsonValue) m_availSettingsHasBeenSet = true; } + if(jsonValue.ValueExists("scte35SegmentationScope")) + { + m_scte35SegmentationScope = Scte35SegmentationScopeMapper::GetScte35SegmentationScopeForName(jsonValue.GetString("scte35SegmentationScope")); + + m_scte35SegmentationScopeHasBeenSet = true; + } + return *this; } @@ -51,6 +62,11 @@ JsonValue AvailConfiguration::Jsonize() const } + if(m_scte35SegmentationScopeHasBeenSet) + { + payload.WithString("scte35SegmentationScope", Scte35SegmentationScopeMapper::GetNameForScte35SegmentationScope(m_scte35SegmentationScope)); + } + return payload; } diff --git a/generated/src/aws-cpp-sdk-medialive/source/model/Scte35SegmentationScope.cpp b/generated/src/aws-cpp-sdk-medialive/source/model/Scte35SegmentationScope.cpp new file mode 100644 index 00000000000..16a0719339b --- /dev/null +++ b/generated/src/aws-cpp-sdk-medialive/source/model/Scte35SegmentationScope.cpp @@ -0,0 +1,72 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#include +#include +#include +#include + +using namespace Aws::Utils; + + +namespace Aws +{ + namespace MediaLive + { + namespace Model + { + namespace Scte35SegmentationScopeMapper + { + + static const int ALL_OUTPUT_GROUPS_HASH = HashingUtils::HashString("ALL_OUTPUT_GROUPS"); + static const int SCTE35_ENABLED_OUTPUT_GROUPS_HASH = HashingUtils::HashString("SCTE35_ENABLED_OUTPUT_GROUPS"); + + + Scte35SegmentationScope GetScte35SegmentationScopeForName(const Aws::String& name) + { + int hashCode = HashingUtils::HashString(name.c_str()); + if (hashCode == ALL_OUTPUT_GROUPS_HASH) + { + return Scte35SegmentationScope::ALL_OUTPUT_GROUPS; + } + else if (hashCode == SCTE35_ENABLED_OUTPUT_GROUPS_HASH) + { + return Scte35SegmentationScope::SCTE35_ENABLED_OUTPUT_GROUPS; + } + EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer(); + if(overflowContainer) + { + overflowContainer->StoreOverflow(hashCode, name); + return static_cast(hashCode); + } + + return Scte35SegmentationScope::NOT_SET; + } + + Aws::String GetNameForScte35SegmentationScope(Scte35SegmentationScope enumValue) + { + switch(enumValue) + { + case Scte35SegmentationScope::NOT_SET: + return {}; + case Scte35SegmentationScope::ALL_OUTPUT_GROUPS: + return "ALL_OUTPUT_GROUPS"; + case Scte35SegmentationScope::SCTE35_ENABLED_OUTPUT_GROUPS: + return "SCTE35_ENABLED_OUTPUT_GROUPS"; + default: + EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer(); + if(overflowContainer) + { + return overflowContainer->RetrieveOverflow(static_cast(enumValue)); + } + + return {}; + } + } + + } // namespace Scte35SegmentationScopeMapper + } // namespace Model + } // namespace MediaLive +} // namespace Aws diff --git a/src/aws-cpp-sdk-core/include/aws/core/VersionConfig.h b/src/aws-cpp-sdk-core/include/aws/core/VersionConfig.h index 270448f7453..2149c0e1560 100644 --- a/src/aws-cpp-sdk-core/include/aws/core/VersionConfig.h +++ b/src/aws-cpp-sdk-core/include/aws/core/VersionConfig.h @@ -4,7 +4,7 @@ */ #pragma once -#define AWS_SDK_VERSION_STRING "1.11.321" +#define AWS_SDK_VERSION_STRING "1.11.322" #define AWS_SDK_VERSION_MAJOR 1 #define AWS_SDK_VERSION_MINOR 11 -#define AWS_SDK_VERSION_PATCH 321 +#define AWS_SDK_VERSION_PATCH 322 diff --git a/tools/code-generation/api-descriptions/medialive-2017-10-14.normal.json b/tools/code-generation/api-descriptions/medialive-2017-10-14.normal.json index c87daf8adc0..7f9f2da0d5a 100644 --- a/tools/code-generation/api-descriptions/medialive-2017-10-14.normal.json +++ b/tools/code-generation/api-descriptions/medialive-2017-10-14.normal.json @@ -5012,6 +5012,11 @@ "shape": "AvailSettings", "locationName": "availSettings", "documentation": "Controls how SCTE-35 messages create cues. Splice Insert mode treats all segmentation signals traditionally. With Time Signal APOS mode only Time Signal Placement Opportunity and Break messages create segment breaks. With ESAM mode, signals are forwarded to an ESAM server for possible update." + }, + "Scte35SegmentationScope": { + "shape": "Scte35SegmentationScope", + "locationName": "scte35SegmentationScope", + "documentation": "Configures whether SCTE 35 passthrough triggers segment breaks in all output groups that use segmented outputs. Insertion of a SCTE 35 message typically results in a segment break, in addition to the regular cadence of breaks. The segment breaks appear in video outputs, audio outputs, and captions outputs (if any).\n\nALL_OUTPUT_GROUPS: Default. Insert the segment break in in all output groups that have segmented outputs. This is the legacy behavior.\nSCTE35_ENABLED_OUTPUT_GROUPS: Insert the segment break only in output groups that have SCTE 35 passthrough enabled. This is the recommended value, because it reduces unnecessary segment breaks." } }, "documentation": "Avail Configuration" @@ -23687,6 +23692,14 @@ "type": "string", "pattern": "^[^\\s]+$", "documentation": "Placeholder documentation for __stringPatternS" + }, + "Scte35SegmentationScope": { + "type": "string", + "documentation": "Scte35 Segmentation Scope", + "enum": [ + "ALL_OUTPUT_GROUPS", + "SCTE35_ENABLED_OUTPUT_GROUPS" + ] } }, "documentation": "API for AWS Elemental MediaLive"