@aws-cdk/aws-medialive-alpha 2.268.0-alpha.0

package/lib/audio-selector.d.ts

@@ -0,0 +1,170 @@
+import type { AudioNormalizationSettings, RemixSettings } from './encode-configuration';
+/**
+ * Policy for how MediaLive identifies the audio stream when selecting by language, on a
+ * transport-stream PMT update.
+ */
+export declare class AudioLanguageSelectionPolicy {
+    /**
+     * Strictly identify audio by its language descriptor. If the matching language is no
+     * longer present after a PMT update, mute is encoded until the language returns.
+     */
+    static readonly STRICT: AudioLanguageSelectionPolicy;
+    /**
+     * On a PMT update, fall back to another audio stream of the same type in the program if a
+     * stream with the same language can't be found.
+     */
+    static readonly LOOSE: AudioLanguageSelectionPolicy;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): AudioLanguageSelectionPolicy;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Options for selecting an HLS audio rendition.
+ */
+export interface HlsRenditionSelectionOptions {
+    /** The `GROUP-ID` in the `#EXT-X-MEDIA` tag of the target HLS audio rendition. */
+    readonly groupId: string;
+    /** The `NAME` in the `#EXT-X-MEDIA` tag of the target HLS audio rendition. */
+    readonly renditionName: string;
+}
+/**
+ * Which Dolby E program to decode from a selected audio track.
+ */
+export declare class DolbyEProgramSelection {
+    /** Decode all channels. */
+    static readonly ALL_CHANNELS: DolbyEProgramSelection;
+    /** Decode Dolby E program 1. */
+    static readonly PROGRAM_1: DolbyEProgramSelection;
+    /** Decode Dolby E program 2. */
+    static readonly PROGRAM_2: DolbyEProgramSelection;
+    /** Decode Dolby E program 3. */
+    static readonly PROGRAM_3: DolbyEProgramSelection;
+    /** Decode Dolby E program 4. */
+    static readonly PROGRAM_4: DolbyEProgramSelection;
+    /** Decode Dolby E program 5. */
+    static readonly PROGRAM_5: DolbyEProgramSelection;
+    /** Decode Dolby E program 6. */
+    static readonly PROGRAM_6: DolbyEProgramSelection;
+    /** Decode Dolby E program 7. */
+    static readonly PROGRAM_7: DolbyEProgramSelection;
+    /** Decode Dolby E program 8. */
+    static readonly PROGRAM_8: DolbyEProgramSelection;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): DolbyEProgramSelection;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Configuration for a single audio PID in a PID-based selector.
+ */
+export interface AudioPidConfig {
+    /** The packet identifier (PID) value from within the source. */
+    readonly pid: number;
+    /**
+     * Which Dolby E program to decode from this PID.
+     * @default - no Dolby E decoding
+     */
+    readonly dolbyEDecode?: DolbyEProgramSelection;
+    /**
+     * Pre-mixer settings for this PID (gain, channel remix, loudness normalization).
+     * @default - no pre-mixing
+     */
+    readonly premixSettings?: AudioPreMixerSettings;
+}
+/**
+ * Configuration for a single audio track in a track-based selector.
+ */
+export interface AudioTrackConfig {
+    /** The 1-based track number to extract. */
+    readonly track: number;
+    /**
+     * Pre-mixer settings for this track (gain, channel remix, loudness normalization).
+     * @default - no pre-mixing
+     */
+    readonly premixSettings?: AudioPreMixerSettings;
+}
+/**
+ * Audio pre-mixer settings for normalizing audio before interleaving.
+ * Applied per-PID or per-track before tracks are combined.
+ */
+export declare class AudioPreMixerSettings {
+    private readonly props;
+    /**
+     * Create pre-mixer settings.
+     */
+    static of(props: AudioPreMixerSettingsProps): AudioPreMixerSettings;
+    private constructor();
+}
+/**
+ * Properties for audio pre-mixer settings.
+ */
+export interface AudioPreMixerSettingsProps {
+    /**
+     * The gain adjustment in decibels (dB).
+     * @default - no gain adjustment
+     */
+    readonly gainDb?: number;
+    /**
+     * The number of audio channels to remix to. Overridden by `remixSettings` if specified.
+     * @default - pass through original channel count
+     */
+    readonly channels?: number;
+    /**
+     * Remix settings for fine-grained channel mapping and gain levels.
+     * @default - no remixing
+     */
+    readonly remixSettings?: RemixSettings;
+    /**
+     * Audio normalization settings for loudness control.
+     * @default - no normalization
+     */
+    readonly audioNormalizationSettings?: AudioNormalizationSettings;
+}
+/**
+ * An audio selector that identifies which audio to extract from the input.
+ */
+export declare abstract class AudioSelector {
+    /**
+     * Select audio by language code.
+     *
+     * @param name a name for this selector
+     * @param languageCode the three-letter (ISO 639-2) language code to select
+     * @param languageSelectionPolicy how strictly to identify the stream by language on a PMT update
+     */
+    static byLanguage(name: string, languageCode: string, languageSelectionPolicy?: AudioLanguageSelectionPolicy): AudioSelector;
+    /**
+     * Select one or more audio PIDs from the source.
+     *
+     * @param name a name for this selector
+     * @param pids the PID configurations (each with optional Dolby E decode and pre-mix settings)
+     */
+    static byPid(name: string, pids: AudioPidConfig[]): AudioSelector;
+    /**
+     * Select one or more audio tracks (1-based) from the source.
+     *
+     * @param name a name for this selector
+     * @param tracks the track configurations (each with optional pre-mix settings)
+     * @param dolbyEProgramSelection which Dolby E program to decode from the selected track(s)
+     */
+    static byTrack(name: string, tracks: AudioTrackConfig[], dolbyEProgramSelection?: DolbyEProgramSelection): AudioSelector;
+    /**
+     * Select an HLS audio rendition by its `#EXT-X-MEDIA` `GROUP-ID` and `NAME`.
+     *
+     * @param name a name for this selector
+     * @param options the target rendition's group id and name
+     */
+    static hlsRendition(name: string, options: HlsRenditionSelectionOptions): AudioSelector;
+    /**
+     * Select the default audio track (no specific selector settings).
+     */
+    static default(name: string): AudioSelector;
+    /**
+     * The name of this audio selector. Reference it from features that monitor a specific
+     * selector, such as an audio-silence {@link FailoverCondition}.
+     */
+    readonly name: string;
+    protected constructor(name: string);
+}

package/lib/audio-selector.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioSelector = exports.AudioPreMixerSettings = exports.DolbyEProgramSelection = exports.AudioLanguageSelectionPolicy = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+/**
+ * Policy for how MediaLive identifies the audio stream when selecting by language, on a
+ * transport-stream PMT update.
+ */
+class AudioLanguageSelectionPolicy {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.AudioLanguageSelectionPolicy", version: "2.268.0-alpha.0" };
+    /**
+     * Strictly identify audio by its language descriptor. If the matching language is no
+     * longer present after a PMT update, mute is encoded until the language returns.
+     */
+    static STRICT = new AudioLanguageSelectionPolicy('STRICT');
+    /**
+     * On a PMT update, fall back to another audio stream of the same type in the program if a
+     * stream with the same language can't be found.
+     */
+    static LOOSE = new AudioLanguageSelectionPolicy('LOOSE');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new AudioLanguageSelectionPolicy(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.AudioLanguageSelectionPolicy = AudioLanguageSelectionPolicy;
+/**
+ * Which Dolby E program to decode from a selected audio track.
+ */
+class DolbyEProgramSelection {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.DolbyEProgramSelection", version: "2.268.0-alpha.0" };
+    /** Decode all channels. */
+    static ALL_CHANNELS = new DolbyEProgramSelection('ALL_CHANNELS');
+    /** Decode Dolby E program 1. */
+    static PROGRAM_1 = new DolbyEProgramSelection('PROGRAM_1');
+    /** Decode Dolby E program 2. */
+    static PROGRAM_2 = new DolbyEProgramSelection('PROGRAM_2');
+    /** Decode Dolby E program 3. */
+    static PROGRAM_3 = new DolbyEProgramSelection('PROGRAM_3');
+    /** Decode Dolby E program 4. */
+    static PROGRAM_4 = new DolbyEProgramSelection('PROGRAM_4');
+    /** Decode Dolby E program 5. */
+    static PROGRAM_5 = new DolbyEProgramSelection('PROGRAM_5');
+    /** Decode Dolby E program 6. */
+    static PROGRAM_6 = new DolbyEProgramSelection('PROGRAM_6');
+    /** Decode Dolby E program 7. */
+    static PROGRAM_7 = new DolbyEProgramSelection('PROGRAM_7');
+    /** Decode Dolby E program 8. */
+    static PROGRAM_8 = new DolbyEProgramSelection('PROGRAM_8');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new DolbyEProgramSelection(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.DolbyEProgramSelection = DolbyEProgramSelection;
+/**
+ * Audio pre-mixer settings for normalizing audio before interleaving.
+ * Applied per-PID or per-track before tracks are combined.
+ */
+class AudioPreMixerSettings {
+    props;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.AudioPreMixerSettings", version: "2.268.0-alpha.0" };
+    /**
+     * Create pre-mixer settings.
+     */
+    static of(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_AudioPreMixerSettingsProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.of);
+            }
+            throw error;
+        }
+        return new AudioPreMixerSettings(props);
+    }
+    constructor(props) {
+        this.props = props;
+    }
+    /** @internal */
+    _bind() {
+        return {
+            gainDb: this.props.gainDb,
+            channels: this.props.channels,
+            remixSettings: this.props.remixSettings ? {
+                channelMappings: this.props.remixSettings.channelMappings.map(m => ({
+                    outputChannel: m.outputChannel,
+                    inputChannelLevels: m.inputChannelLevels.map(l => ({
+                        inputChannel: l.inputChannel,
+                        gain: l.gain ?? 0,
+                    })),
+                })),
+                channelsIn: this.props.remixSettings.channelsIn,
+                channelsOut: this.props.remixSettings.channelsOut,
+            } : undefined,
+            audioNormalizationSettings: this.props.audioNormalizationSettings ? {
+                algorithm: this.props.audioNormalizationSettings.algorithm?.value,
+                algorithmControl: this.props.audioNormalizationSettings.algorithmControl?.value,
+                targetLkfs: this.props.audioNormalizationSettings.targetLkfs,
+                peakCalculation: this.props.audioNormalizationSettings.peakCalculation?.value,
+                peakLimiterThreshold: this.props.audioNormalizationSettings.peakLimiterThreshold,
+            } : undefined,
+        };
+    }
+}
+exports.AudioPreMixerSettings = AudioPreMixerSettings;
+/**
+ * An audio selector that identifies which audio to extract from the input.
+ */
+class AudioSelector {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.AudioSelector", version: "2.268.0-alpha.0" };
+    /**
+     * Select audio by language code.
+     *
+     * @param name a name for this selector
+     * @param languageCode the three-letter (ISO 639-2) language code to select
+     * @param languageSelectionPolicy how strictly to identify the stream by language on a PMT update
+     */
+    static byLanguage(name, languageCode, languageSelectionPolicy) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_AudioLanguageSelectionPolicy(languageSelectionPolicy);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.byLanguage);
+            }
+            throw error;
+        }
+        return new LanguageAudioSelector(name, languageCode, languageSelectionPolicy);
+    }
+    /**
+     * Select one or more audio PIDs from the source.
+     *
+     * @param name a name for this selector
+     * @param pids the PID configurations (each with optional Dolby E decode and pre-mix settings)
+     */
+    static byPid(name, pids) {
+        return new PidAudioSelector(name, pids);
+    }
+    /**
+     * Select one or more audio tracks (1-based) from the source.
+     *
+     * @param name a name for this selector
+     * @param tracks the track configurations (each with optional pre-mix settings)
+     * @param dolbyEProgramSelection which Dolby E program to decode from the selected track(s)
+     */
+    static byTrack(name, tracks, dolbyEProgramSelection) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_DolbyEProgramSelection(dolbyEProgramSelection);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.byTrack);
+            }
+            throw error;
+        }
+        return new TrackAudioSelector(name, tracks, dolbyEProgramSelection);
+    }
+    /**
+     * Select an HLS audio rendition by its `#EXT-X-MEDIA` `GROUP-ID` and `NAME`.
+     *
+     * @param name a name for this selector
+     * @param options the target rendition's group id and name
+     */
+    static hlsRendition(name, options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_HlsRenditionSelectionOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.hlsRendition);
+            }
+            throw error;
+        }
+        return new HlsRenditionAudioSelector(name, options);
+    }
+    /**
+     * Select the default audio track (no specific selector settings).
+     */
+    static default(name) {
+        return new DefaultAudioSelector(name);
+    }
+    /**
+     * The name of this audio selector. Reference it from features that monitor a specific
+     * selector, such as an audio-silence {@link FailoverCondition}.
+     */
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+exports.AudioSelector = AudioSelector;
+/** @internal */
+class LanguageAudioSelector extends AudioSelector {
+    languageCode;
+    policy;
+    constructor(name, languageCode, policy) {
+        super(name);
+        this.languageCode = languageCode;
+        this.policy = policy;
+    }
+    _bind() {
+        return {
+            name: this.name,
+            selectorSettings: {
+                audioLanguageSelection: {
+                    languageCode: this.languageCode,
+                    languageSelectionPolicy: this.policy?.value,
+                },
+            },
+        };
+    }
+}
+/** @internal */
+class PidAudioSelector extends AudioSelector {
+    pids;
+    constructor(name, pids) {
+        super(name);
+        this.pids = pids;
+        if (pids.length === 0) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `AudioPidSelectorEmpty`, 'byPid() requires at least one PID configuration');
+        }
+    }
+    _bind() {
+        return {
+            name: this.name,
+            selectorSettings: {
+                audioPidSelection: {
+                    pids: this.pids.map(p => ({
+                        pid: p.pid,
+                        dolbyEDecode: p.dolbyEDecode ? { programSelection: p.dolbyEDecode.value } : undefined,
+                        premixSettings: p.premixSettings?._bind(),
+                    })),
+                },
+            },
+        };
+    }
+}
+/** @internal */
+class TrackAudioSelector extends AudioSelector {
+    tracks;
+    dolbyEProgramSelection;
+    constructor(name, tracks, dolbyEProgramSelection) {
+        super(name);
+        this.tracks = tracks;
+        this.dolbyEProgramSelection = dolbyEProgramSelection;
+        if (tracks.length === 0) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `AudioTrackSelectorEmpty`, 'byTrack() requires at least one track configuration');
+        }
+    }
+    _bind() {
+        return {
+            name: this.name,
+            selectorSettings: {
+                audioTrackSelection: {
+                    tracks: this.tracks.map(t => ({
+                        track: t.track,
+                        premixSettings: t.premixSettings?._bind(),
+                    })),
+                    dolbyEDecode: this.dolbyEProgramSelection ? { programSelection: this.dolbyEProgramSelection.value } : undefined,
+                },
+            },
+        };
+    }
+}
+/** @internal */
+class HlsRenditionAudioSelector extends AudioSelector {
+    options;
+    constructor(name, options) {
+        super(name);
+        this.options = options;
+    }
+    _bind() {
+        return {
+            name: this.name,
+            selectorSettings: {
+                audioHlsRenditionSelection: {
+                    groupId: this.options.groupId,
+                    name: this.options.renditionName,
+                },
+            },
+        };
+    }
+}
+/** @internal */
+class DefaultAudioSelector extends AudioSelector {
+    constructor(name) { super(name); }
+    _bind() {
+        return { name: this.name };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audio-selector.js","sourceRoot":"","sources":["audio-selector.ts"],"names":[],"mappings":"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","sourcesContent":["import { UnscopedValidationError } from 'aws-cdk-lib';\nimport type { CfnChannel } from 'aws-cdk-lib/aws-medialive';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport type { AudioNormalizationSettings, RemixSettings } from './encode-configuration';\n\n/**\n * Policy for how MediaLive identifies the audio stream when selecting by language, on a\n * transport-stream PMT update.\n */\nexport class AudioLanguageSelectionPolicy {\n  /**\n   * Strictly identify audio by its language descriptor. If the matching language is no\n   * longer present after a PMT update, mute is encoded until the language returns.\n   */\n  public static readonly STRICT = new AudioLanguageSelectionPolicy('STRICT');\n  /**\n   * On a PMT update, fall back to another audio stream of the same type in the program if a\n   * stream with the same language can't be found.\n   */\n  public static readonly LOOSE = new AudioLanguageSelectionPolicy('LOOSE');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): AudioLanguageSelectionPolicy {\n    return new AudioLanguageSelectionPolicy(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * Options for selecting an HLS audio rendition.\n */\nexport interface HlsRenditionSelectionOptions {\n  /** The `GROUP-ID` in the `#EXT-X-MEDIA` tag of the target HLS audio rendition. */\n  readonly groupId: string;\n  /** The `NAME` in the `#EXT-X-MEDIA` tag of the target HLS audio rendition. */\n  readonly renditionName: string;\n}\n\n/**\n * Which Dolby E program to decode from a selected audio track.\n */\nexport class DolbyEProgramSelection {\n  /** Decode all channels. */\n  public static readonly ALL_CHANNELS = new DolbyEProgramSelection('ALL_CHANNELS');\n  /** Decode Dolby E program 1. */\n  public static readonly PROGRAM_1 = new DolbyEProgramSelection('PROGRAM_1');\n  /** Decode Dolby E program 2. */\n  public static readonly PROGRAM_2 = new DolbyEProgramSelection('PROGRAM_2');\n  /** Decode Dolby E program 3. */\n  public static readonly PROGRAM_3 = new DolbyEProgramSelection('PROGRAM_3');\n  /** Decode Dolby E program 4. */\n  public static readonly PROGRAM_4 = new DolbyEProgramSelection('PROGRAM_4');\n  /** Decode Dolby E program 5. */\n  public static readonly PROGRAM_5 = new DolbyEProgramSelection('PROGRAM_5');\n  /** Decode Dolby E program 6. */\n  public static readonly PROGRAM_6 = new DolbyEProgramSelection('PROGRAM_6');\n  /** Decode Dolby E program 7. */\n  public static readonly PROGRAM_7 = new DolbyEProgramSelection('PROGRAM_7');\n  /** Decode Dolby E program 8. */\n  public static readonly PROGRAM_8 = new DolbyEProgramSelection('PROGRAM_8');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): DolbyEProgramSelection {\n    return new DolbyEProgramSelection(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * Configuration for a single audio PID in a PID-based selector.\n */\nexport interface AudioPidConfig {\n  /** The packet identifier (PID) value from within the source. */\n  readonly pid: number;\n  /**\n   * Which Dolby E program to decode from this PID.\n   * @default - no Dolby E decoding\n   */\n  readonly dolbyEDecode?: DolbyEProgramSelection;\n  /**\n   * Pre-mixer settings for this PID (gain, channel remix, loudness normalization).\n   * @default - no pre-mixing\n   */\n  readonly premixSettings?: AudioPreMixerSettings;\n}\n\n/**\n * Configuration for a single audio track in a track-based selector.\n */\nexport interface AudioTrackConfig {\n  /** The 1-based track number to extract. */\n  readonly track: number;\n  /**\n   * Pre-mixer settings for this track (gain, channel remix, loudness normalization).\n   * @default - no pre-mixing\n   */\n  readonly premixSettings?: AudioPreMixerSettings;\n}\n\n/**\n * Audio pre-mixer settings for normalizing audio before interleaving.\n * Applied per-PID or per-track before tracks are combined.\n */\nexport class AudioPreMixerSettings {\n  /**\n   * Create pre-mixer settings.\n   */\n  public static of(props: AudioPreMixerSettingsProps): AudioPreMixerSettings {\n    return new AudioPreMixerSettings(props);\n  }\n\n  private constructor(private readonly props: AudioPreMixerSettingsProps) {}\n\n  /** @internal */\n  public _bind(): CfnChannel.AudioPreMixerSettingsProperty {\n    return {\n      gainDb: this.props.gainDb,\n      channels: this.props.channels,\n      remixSettings: this.props.remixSettings ? {\n        channelMappings: this.props.remixSettings.channelMappings.map(m => ({\n          outputChannel: m.outputChannel,\n          inputChannelLevels: m.inputChannelLevels.map(l => ({\n            inputChannel: l.inputChannel,\n            gain: l.gain ?? 0,\n          })),\n        })),\n        channelsIn: this.props.remixSettings.channelsIn,\n        channelsOut: this.props.remixSettings.channelsOut,\n      } : undefined,\n      audioNormalizationSettings: this.props.audioNormalizationSettings ? {\n        algorithm: this.props.audioNormalizationSettings.algorithm?.value,\n        algorithmControl: this.props.audioNormalizationSettings.algorithmControl?.value,\n        targetLkfs: this.props.audioNormalizationSettings.targetLkfs,\n        peakCalculation: this.props.audioNormalizationSettings.peakCalculation?.value,\n        peakLimiterThreshold: this.props.audioNormalizationSettings.peakLimiterThreshold,\n      } : undefined,\n    };\n  }\n}\n\n/**\n * Properties for audio pre-mixer settings.\n */\nexport interface AudioPreMixerSettingsProps {\n  /**\n   * The gain adjustment in decibels (dB).\n   * @default - no gain adjustment\n   */\n  readonly gainDb?: number;\n  /**\n   * The number of audio channels to remix to. Overridden by `remixSettings` if specified.\n   * @default - pass through original channel count\n   */\n  readonly channels?: number;\n  /**\n   * Remix settings for fine-grained channel mapping and gain levels.\n   * @default - no remixing\n   */\n  readonly remixSettings?: RemixSettings;\n  /**\n   * Audio normalization settings for loudness control.\n   * @default - no normalization\n   */\n  readonly audioNormalizationSettings?: AudioNormalizationSettings;\n}\n\n/**\n * An audio selector that identifies which audio to extract from the input.\n */\nexport abstract class AudioSelector {\n  /**\n   * Select audio by language code.\n   *\n   * @param name a name for this selector\n   * @param languageCode the three-letter (ISO 639-2) language code to select\n   * @param languageSelectionPolicy how strictly to identify the stream by language on a PMT update\n   */\n  public static byLanguage(name: string, languageCode: string, languageSelectionPolicy?: AudioLanguageSelectionPolicy): AudioSelector {\n    return new LanguageAudioSelector(name, languageCode, languageSelectionPolicy);\n  }\n\n  /**\n   * Select one or more audio PIDs from the source.\n   *\n   * @param name a name for this selector\n   * @param pids the PID configurations (each with optional Dolby E decode and pre-mix settings)\n   */\n  public static byPid(name: string, pids: AudioPidConfig[]): AudioSelector {\n    return new PidAudioSelector(name, pids);\n  }\n\n  /**\n   * Select one or more audio tracks (1-based) from the source.\n   *\n   * @param name a name for this selector\n   * @param tracks the track configurations (each with optional pre-mix settings)\n   * @param dolbyEProgramSelection which Dolby E program to decode from the selected track(s)\n   */\n  public static byTrack(name: string, tracks: AudioTrackConfig[], dolbyEProgramSelection?: DolbyEProgramSelection): AudioSelector {\n    return new TrackAudioSelector(name, tracks, dolbyEProgramSelection);\n  }\n\n  /**\n   * Select an HLS audio rendition by its `#EXT-X-MEDIA` `GROUP-ID` and `NAME`.\n   *\n   * @param name a name for this selector\n   * @param options the target rendition's group id and name\n   */\n  public static hlsRendition(name: string, options: HlsRenditionSelectionOptions): AudioSelector {\n    return new HlsRenditionAudioSelector(name, options);\n  }\n\n  /**\n   * Select the default audio track (no specific selector settings).\n   */\n  public static default(name: string): AudioSelector {\n    return new DefaultAudioSelector(name);\n  }\n\n  /**\n   * The name of this audio selector. Reference it from features that monitor a specific\n   * selector, such as an audio-silence {@link FailoverCondition}.\n   */\n  public readonly name: string;\n\n  protected constructor(name: string) {\n    this.name = name;\n  }\n\n  /** @internal */\n  public abstract _bind(): CfnChannel.AudioSelectorProperty;\n}\n\n/** @internal */\nclass LanguageAudioSelector extends AudioSelector {\n  constructor(name: string, private readonly languageCode: string, private readonly policy?: AudioLanguageSelectionPolicy) { super(name); }\n  public _bind(): CfnChannel.AudioSelectorProperty {\n    return {\n      name: this.name,\n      selectorSettings: {\n        audioLanguageSelection: {\n          languageCode: this.languageCode,\n          languageSelectionPolicy: this.policy?.value,\n        },\n      },\n    };\n  }\n}\n\n/** @internal */\nclass PidAudioSelector extends AudioSelector {\n  constructor(name: string, private readonly pids: AudioPidConfig[]) {\n    super(name);\n    if (pids.length === 0) {\n      throw new UnscopedValidationError(lit`AudioPidSelectorEmpty`, 'byPid() requires at least one PID configuration');\n    }\n  }\n  public _bind(): CfnChannel.AudioSelectorProperty {\n    return {\n      name: this.name,\n      selectorSettings: {\n        audioPidSelection: {\n          pids: this.pids.map(p => ({\n            pid: p.pid,\n            dolbyEDecode: p.dolbyEDecode ? { programSelection: p.dolbyEDecode.value } : undefined,\n            premixSettings: p.premixSettings?._bind(),\n          })),\n        },\n      },\n    };\n  }\n}\n\n/** @internal */\nclass TrackAudioSelector extends AudioSelector {\n  constructor(name: string, private readonly tracks: AudioTrackConfig[],\n    private readonly dolbyEProgramSelection?: DolbyEProgramSelection) {\n    super(name);\n    if (tracks.length === 0) {\n      throw new UnscopedValidationError(lit`AudioTrackSelectorEmpty`, 'byTrack() requires at least one track configuration');\n    }\n  }\n  public _bind(): CfnChannel.AudioSelectorProperty {\n    return {\n      name: this.name,\n      selectorSettings: {\n        audioTrackSelection: {\n          tracks: this.tracks.map(t => ({\n            track: t.track,\n            premixSettings: t.premixSettings?._bind(),\n          })),\n          dolbyEDecode: this.dolbyEProgramSelection ? { programSelection: this.dolbyEProgramSelection.value } : undefined,\n        },\n      },\n    };\n  }\n}\n\n/** @internal */\nclass HlsRenditionAudioSelector extends AudioSelector {\n  constructor(name: string, private readonly options: HlsRenditionSelectionOptions) { super(name); }\n  public _bind(): CfnChannel.AudioSelectorProperty {\n    return {\n      name: this.name,\n      selectorSettings: {\n        audioHlsRenditionSelection: {\n          groupId: this.options.groupId,\n          name: this.options.renditionName,\n        },\n      },\n    };\n  }\n}\n\n/** @internal */\nclass DefaultAudioSelector extends AudioSelector {\n  constructor(name: string) { super(name); }\n  public _bind(): CfnChannel.AudioSelectorProperty {\n    return { name: this.name };\n  }\n}\n"]}