AWS::MediaLive Construct Library
Version 2.273.0-alpha.0
Separate package
@aws-cdk/aws-medialive-alpha is not part of aws-cdk-lib — install it separately:
sh
npm install @aws-cdk/aws-medialive-alpha
pip install aws-cdk.aws-medialive-alpha
This module is experimental (alpha): its API may change in any release, without a major version bump.
The APIs of higher level constructs in this module are experimental and under active development. They are subject to non-backward compatible changes or removal in any future version. These are not subject to the Semantic Versioning model and breaking changes will be announced in the release notes. This means that while you may use them, you may need to update your source code when upgrading to a newer version of this package.
AWS Elemental MediaLive
AWS Elemental MediaLive is a real-time video service that lets you create live outputs for broadcast and streaming delivery.
This package contains constructs for working with AWS Elemental MediaLive, including Inputs, Input Security Groups, Channels, and MediaLive Anywhere resources (Networks, Clusters, Channel Placement Groups, SDI Sources).
For further information on AWS Elemental MediaLive, see the documentation. See supported codecs per output group.
The following example creates an SRT caller input, encodes it to H.264 + AAC, and outputs HLS segments to an S3 bucket:
ts
declare const stack: Stack;
declare const bucket: s3.IBucket;
const input = new medialive.Input(stack, 'SrtInput', {
inputName: 'my-srt-input',
input: medialive.InputConfiguration.srtCaller([{
srtListenerAddress: '203.0.113.10',
srtListenerPort: 5000,
}]),
});
const video = medialive.EncodeConfiguration.video({
name: 'video_720p',
codec: medialive.VideoCodecSettings.h264({
rateControl: medialive.H264RateControl.cbr({ bitrate: Bitrate.mbps(3) }),
framerate: medialive.Framerate.FPS_30,
}),
width: 1280,
height: 720,
});
const audio = medialive.EncodeConfiguration.audio({
name: 'audio_aac',
codec: medialive.AudioCodecSettings.aac({ bitrate: Bitrate.kbps(192) }),
});
new medialive.Channel(stack, 'Channel', {
inputs: [{ input }],
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video, audio], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# bucket: s3.IBucket
input = medialive.Input(stack, "SrtInput",
input_name="my-srt-input",
input=medialive.InputConfiguration.srt_caller([
srt_listener_address="203.0.113.10",
srt_listener_port=5000
])
)
video = medialive.EncodeConfiguration.video(
name="video_720p",
codec=medialive.VideoCodecSettings.h264(
rate_control=medialive.H264RateControl.cbr(bitrate=Bitrate.mbps(3)),
framerate=medialive.Framerate.FPS_30
),
width=1280,
height=720
)
audio = medialive.EncodeConfiguration.audio(
name="audio_aac",
codec=medialive.AudioCodecSettings.aac(bitrate=Bitrate.kbps(192))
)
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(input=input)],
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video, audio], output_name="hls_out")]
)
]
)
java
Stack stack;
IBucket bucket;
Input input = Input.Builder.create(stack, "SrtInput")
.inputName("my-srt-input")
.input(InputConfiguration.srtCaller(List.of(SrtCallerSourceProps.builder()
.srtListenerAddress("203.0.113.10")
.srtListenerPort(5000)
.build())))
.build();
EncodeConfiguration video = EncodeConfiguration.video(VideoEncodeProps.builder()
.name("video_720p")
.codec(VideoCodecSettings.h264(H264SettingsProps.builder()
.rateControl(H264RateControl.cbr(CbrRateControlProps.builder().bitrate(Bitrate.mbps(3)).build()))
.framerate(Framerate.FPS_30)
.build()))
.width(1280)
.height(720)
.build());
EncodeConfiguration audio = EncodeConfiguration.audio(AudioEncodeProps.builder()
.name("audio_aac")
.codec(AudioCodecSettings.aac(AacSettingsProps.builder().bitrate(Bitrate.kbps(192)).build()))
.build());
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder().input(input).build()))
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video, audio)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
IBucket bucket;
var input = new Input(stack, "SrtInput", new InputProps {
InputName = "my-srt-input",
Input = InputConfiguration.SrtCaller(new [] { new SrtCallerSourceProps {
SrtListenerAddress = "203.0.113.10",
SrtListenerPort = 5000
} })
});
var video = EncodeConfiguration.Video(new VideoEncodeProps {
Name = "video_720p",
Codec = VideoCodecSettings.H264(new H264SettingsProps {
RateControl = H264RateControl.Cbr(new CbrRateControlProps { Bitrate = Bitrate.Mbps(3) }),
Framerate = Framerate.FPS_30
}),
Width = 1280,
Height = 720
});
var audio = EncodeConfiguration.Audio(new AudioEncodeProps {
Name = "audio_aac",
Codec = AudioCodecSettings.Aac(new AacSettingsProps { Bitrate = Bitrate.Kbps(192) })
});
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment { Input = input } },
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video, audio }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var bucket IBucket
input := medialive.NewInput(stack, jsii.String("SrtInput"), &InputProps{
InputName: jsii.String("my-srt-input"),
Input: medialive.InputConfiguration_SrtCaller([]SrtCallerSourceProps{
&SrtCallerSourceProps{
SrtListenerAddress: jsii.String("203.0.113.10"),
SrtListenerPort: jsii.Number(5000),
},
}),
})
video := medialive.EncodeConfiguration_Video(&VideoEncodeProps{
Name: jsii.String("video_720p"),
Codec: medialive.VideoCodecSettings_H264(&H264SettingsProps{
RateControl: medialive.H264RateControl_Cbr(&CbrRateControlProps{
Bitrate: awscdk.Bitrate_Mbps(jsii.Number(3)),
}),
Framerate: medialive.Framerate_FPS_30(),
}),
Width: jsii.Number(1280),
Height: jsii.Number(720),
})
audio := medialive.EncodeConfiguration_Audio(&AudioEncodeProps{
Name: jsii.String("audio_aac"),
Codec: medialive.AudioCodecSettings_Aac(&AacSettingsProps{
Bitrate: awscdk.Bitrate_Kbps(jsii.Number(192)),
}),
})
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
Input
An input represents the upstream source that feeds a MediaLive channel. Use InputConfiguration factory methods to create different input types.
SRT Caller
MediaLive connects to a remote SRT listener:
ts
declare const stack: Stack;
new medialive.Input(stack, 'SrtInput', {
inputName: 'srt-caller',
input: medialive.InputConfiguration.srtCaller([{
srtListenerAddress: '203.0.113.10',
srtListenerPort: 5000,
}]),
});
python
# stack: Stack
medialive.Input(stack, "SrtInput",
input_name="srt-caller",
input=medialive.InputConfiguration.srt_caller([
srt_listener_address="203.0.113.10",
srt_listener_port=5000
])
)
java
Stack stack;
Input.Builder.create(stack, "SrtInput")
.inputName("srt-caller")
.input(InputConfiguration.srtCaller(List.of(SrtCallerSourceProps.builder()
.srtListenerAddress("203.0.113.10")
.srtListenerPort(5000)
.build())))
.build();
csharp
Stack stack;
new Input(stack, "SrtInput", new InputProps {
InputName = "srt-caller",
Input = InputConfiguration.SrtCaller(new [] { new SrtCallerSourceProps {
SrtListenerAddress = "203.0.113.10",
SrtListenerPort = 5000
} })
});
go
var stack Stack
medialive.NewInput(stack, jsii.String("SrtInput"), &InputProps{
InputName: jsii.String("srt-caller"),
Input: medialive.InputConfiguration_SrtCaller([]SrtCallerSourceProps{
&SrtCallerSourceProps{
SrtListenerAddress: jsii.String("203.0.113.10"),
SrtListenerPort: jsii.Number(5000),
},
}),
})
SRT Listener
MediaLive listens for an incoming SRT connection. SRT listener inputs require an input security group. To receive encrypted content, supply a decryption block referencing a Secrets Manager secret that holds the passphrase — the secret is passed by reference, so MediaLive resolves the ARN at synth time:
ts
declare const stack: Stack;
declare const passphrase: secretsmanager.ISecret;
const sg = new medialive.InputSecurityGroup(stack, 'SrtSg', {
allowlistRules: ['203.0.113.0/24'],
});
new medialive.Input(stack, 'SrtListenerInput', {
inputName: 'srt-listener',
input: medialive.InputConfiguration.srtListener({
inputSecurityGroups: [sg],
minimumLatency: Duration.millis(500),
streamId: 'my-stream-id',
decryption: {
algorithm: medialive.SrtDecryptionAlgorithm.AES256,
passphraseSecret: passphrase,
},
}),
});
python
# stack: Stack
# passphrase: secretsmanager.ISecret
sg = medialive.InputSecurityGroup(stack, "SrtSg",
allowlist_rules=["203.0.113.0/24"]
)
medialive.Input(stack, "SrtListenerInput",
input_name="srt-listener",
input=medialive.InputConfiguration.srt_listener(
input_security_groups=[sg],
minimum_latency=Duration.millis(500),
stream_id="my-stream-id",
decryption=medialive.SrtDecryptionProps(
algorithm=medialive.SrtDecryptionAlgorithm.AES256,
passphrase_secret=passphrase
)
)
)
java
Stack stack;
ISecret passphrase;
InputSecurityGroup sg = InputSecurityGroup.Builder.create(stack, "SrtSg")
.allowlistRules(List.of("203.0.113.0/24"))
.build();
Input.Builder.create(stack, "SrtListenerInput")
.inputName("srt-listener")
.input(InputConfiguration.srtListener(SrtListenerInputProps.builder()
.inputSecurityGroups(List.of(sg))
.minimumLatency(Duration.millis(500))
.streamId("my-stream-id")
.decryption(SrtDecryptionProps.builder()
.algorithm(SrtDecryptionAlgorithm.AES256)
.passphraseSecret(passphrase)
.build())
.build()))
.build();
csharp
Stack stack;
ISecret passphrase;
var sg = new InputSecurityGroup(stack, "SrtSg", new InputSecurityGroupProps {
AllowlistRules = new [] { "203.0.113.0/24" }
});
new Input(stack, "SrtListenerInput", new InputProps {
InputName = "srt-listener",
Input = InputConfiguration.SrtListener(new SrtListenerInputProps {
InputSecurityGroups = new [] { sg },
MinimumLatency = Duration.Millis(500),
StreamId = "my-stream-id",
Decryption = new SrtDecryptionProps {
Algorithm = SrtDecryptionAlgorithm.AES256,
PassphraseSecret = passphrase
}
})
});
go
var stack Stack
var passphrase ISecret
sg := medialive.NewInputSecurityGroup(stack, jsii.String("SrtSg"), &InputSecurityGroupProps{
AllowlistRules: []*string{
jsii.String("203.0.113.0/24"),
},
})
medialive.NewInput(stack, jsii.String("SrtListenerInput"), &InputProps{
InputName: jsii.String("srt-listener"),
Input: medialive.InputConfiguration_SrtListener(&SrtListenerInputProps{
InputSecurityGroups: []IInputSecurityGroupRef{
sg,
},
MinimumLatency: awscdk.Duration_Millis(jsii.Number(500)),
StreamId: jsii.String("my-stream-id"),
Decryption: &SrtDecryptionProps{
Algorithm: medialive.SrtDecryptionAlgorithm_AES256(),
PassphraseSecret: passphrase,
},
}),
})
AWS Elemental MediaConnect Router
Creates a MediaConnect Router Input with automatic encryption:
ts
declare const stack: Stack;
new medialive.Input(stack, 'RouterInput', {
inputName: 'mc-router',
input: medialive.InputConfiguration.mediaConnectRouter(),
});
python
# stack: Stack
medialive.Input(stack, "RouterInput",
input_name="mc-router",
input=medialive.InputConfiguration.media_connect_router()
)
java
Stack stack;
Input.Builder.create(stack, "RouterInput")
.inputName("mc-router")
.input(InputConfiguration.mediaConnectRouter())
.build();
csharp
Stack stack;
new Input(stack, "RouterInput", new InputProps {
InputName = "mc-router",
Input = InputConfiguration.MediaConnectRouter()
});
go
var stack Stack
medialive.NewInput(stack, jsii.String("RouterInput"), &InputProps{
InputName: jsii.String("mc-router"),
Input: medialive.InputConfiguration_MediaConnectRouter(),
})
An input created this way is the only kind @aws-cdk/aws-mediaconnect-alpha's RouterOutputConfiguration.mediaLiveInput() can deliver to — pointing it at any other input type synths but fails at deploy.
MP4 File from S3
Use InputSource.fromBucket() to reference an S3 object:
ts
declare const stack: Stack;
declare const bucket: s3.IBucket;
new medialive.Input(stack, 'FileInput', {
inputName: 'mp4-file',
input: medialive.InputConfiguration.mp4File([
medialive.InputSource.fromBucket(bucket, 'media/input.mp4'),
]),
});
python
# stack: Stack
# bucket: s3.IBucket
medialive.Input(stack, "FileInput",
input_name="mp4-file",
input=medialive.InputConfiguration.mp4_file([
medialive.InputSource.from_bucket(bucket, "media/input.mp4")
])
)
java
Stack stack;
IBucket bucket;
Input.Builder.create(stack, "FileInput")
.inputName("mp4-file")
.input(InputConfiguration.mp4File(List.of(InputSource.fromBucket(bucket, "media/input.mp4"))))
.build();
csharp
Stack stack;
IBucket bucket;
new Input(stack, "FileInput", new InputProps {
InputName = "mp4-file",
Input = InputConfiguration.Mp4File(new [] { InputSource.FromBucket(bucket, "media/input.mp4") })
});
go
var stack Stack
var bucket IBucket
medialive.NewInput(stack, jsii.String("FileInput"), &InputProps{
InputName: jsii.String("mp4-file"),
Input: medialive.InputConfiguration_Mp4File([]InputSource{
medialive.InputSource_FromBucket(bucket, jsii.String("media/input.mp4")),
}),
})
Importing an Existing Input
ts
declare const stack: Stack;
const input = medialive.Input.fromInputArn(stack, 'Imported',
'arn:aws:medialive:us-east-1:123456789012:input:1234567');
python
# stack: Stack
input = medialive.Input.from_input_arn(stack, "Imported", "arn:aws:medialive:us-east-1:123456789012:input:1234567")
java
Stack stack;
IInput input = Input.fromInputArn(stack, "Imported", "arn:aws:medialive:us-east-1:123456789012:input:1234567");
csharp
Stack stack;
var input = Input.FromInputArn(stack, "Imported", "arn:aws:medialive:us-east-1:123456789012:input:1234567");
go
var stack Stack
input := medialive.Input_FromInputArn(stack, jsii.String("Imported"), jsii.String("arn:aws:medialive:us-east-1:123456789012:input:1234567"))
Input Security Group
An input security group controls which IPv4 CIDR blocks can push content to a push-type input.
ts
declare const stack: Stack;
const sg = new medialive.InputSecurityGroup(stack, 'SG', {
allowlistRules: ['203.0.113.0/24'],
});
python
# stack: Stack
sg = medialive.InputSecurityGroup(stack, "SG",
allowlist_rules=["203.0.113.0/24"]
)
java
Stack stack;
InputSecurityGroup sg = InputSecurityGroup.Builder.create(stack, "SG")
.allowlistRules(List.of("203.0.113.0/24"))
.build();
csharp
Stack stack;
var sg = new InputSecurityGroup(stack, "SG", new InputSecurityGroupProps {
AllowlistRules = new [] { "203.0.113.0/24" }
});
go
var stack Stack
sg := medialive.NewInputSecurityGroup(stack, jsii.String("SG"), &InputSecurityGroupProps{
AllowlistRules: []*string{
jsii.String("203.0.113.0/24"),
},
})
Importing an Existing Input Security Group
ts
declare const stack: Stack;
const sg = medialive.InputSecurityGroup.fromInputSecurityGroupArn(stack, 'Imported',
'arn:aws:medialive:us-east-1:123456789012:inputSecurityGroup:1234567');
python
# stack: Stack
sg = medialive.InputSecurityGroup.from_input_security_group_arn(stack, "Imported", "arn:aws:medialive:us-east-1:123456789012:inputSecurityGroup:1234567")
java
Stack stack;
IInputSecurityGroup sg = InputSecurityGroup.fromInputSecurityGroupArn(stack, "Imported", "arn:aws:medialive:us-east-1:123456789012:inputSecurityGroup:1234567");
csharp
Stack stack;
var sg = InputSecurityGroup.FromInputSecurityGroupArn(stack, "Imported", "arn:aws:medialive:us-east-1:123456789012:inputSecurityGroup:1234567");
go
var stack Stack
sg := medialive.InputSecurityGroup_FromInputSecurityGroupArn(stack, jsii.String("Imported"), jsii.String("arn:aws:medialive:us-east-1:123456789012:inputSecurityGroup:1234567"))
Channel
A channel takes one or more inputs, encodes them, and produces output groups. If no role is provided, the channel auto-creates an IAM role with the medialive.amazonaws.com service principal.
Minimal example — single input, single HLS output:
ts
declare const stack: Stack;
declare const input: medialive.IInput;
declare const bucket: s3.IBucket;
const video = medialive.EncodeConfiguration.video({
name: 'video_720p',
codec: medialive.VideoCodecSettings.h264({
rateControl: medialive.H264RateControl.cbr({ bitrate: Bitrate.mbps(3) }),
framerate: medialive.Framerate.FPS_30,
}),
width: 1280,
height: 720,
});
const audio = medialive.EncodeConfiguration.audio({
name: 'audio_aac',
codec: medialive.AudioCodecSettings.aac({ bitrate: Bitrate.kbps(192) }),
});
new medialive.Channel(stack, 'Channel', {
inputs: [{ input }],
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video, audio], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# input: medialive.IInput
# bucket: s3.IBucket
video = medialive.EncodeConfiguration.video(
name="video_720p",
codec=medialive.VideoCodecSettings.h264(
rate_control=medialive.H264RateControl.cbr(bitrate=Bitrate.mbps(3)),
framerate=medialive.Framerate.FPS_30
),
width=1280,
height=720
)
audio = medialive.EncodeConfiguration.audio(
name="audio_aac",
codec=medialive.AudioCodecSettings.aac(bitrate=Bitrate.kbps(192))
)
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(input=input)],
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video, audio], output_name="hls_out")]
)
]
)
java
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video = EncodeConfiguration.video(VideoEncodeProps.builder()
.name("video_720p")
.codec(VideoCodecSettings.h264(H264SettingsProps.builder()
.rateControl(H264RateControl.cbr(CbrRateControlProps.builder().bitrate(Bitrate.mbps(3)).build()))
.framerate(Framerate.FPS_30)
.build()))
.width(1280)
.height(720)
.build());
EncodeConfiguration audio = EncodeConfiguration.audio(AudioEncodeProps.builder()
.name("audio_aac")
.codec(AudioCodecSettings.aac(AacSettingsProps.builder().bitrate(Bitrate.kbps(192)).build()))
.build());
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder().input(input).build()))
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video, audio)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
IInput input;
IBucket bucket;
var video = EncodeConfiguration.Video(new VideoEncodeProps {
Name = "video_720p",
Codec = VideoCodecSettings.H264(new H264SettingsProps {
RateControl = H264RateControl.Cbr(new CbrRateControlProps { Bitrate = Bitrate.Mbps(3) }),
Framerate = Framerate.FPS_30
}),
Width = 1280,
Height = 720
});
var audio = EncodeConfiguration.Audio(new AudioEncodeProps {
Name = "audio_aac",
Codec = AudioCodecSettings.Aac(new AacSettingsProps { Bitrate = Bitrate.Kbps(192) })
});
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment { Input = input } },
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video, audio }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var input IInput
var bucket IBucket
video := medialive.EncodeConfiguration_Video(&VideoEncodeProps{
Name: jsii.String("video_720p"),
Codec: medialive.VideoCodecSettings_H264(&H264SettingsProps{
RateControl: medialive.H264RateControl_Cbr(&CbrRateControlProps{
Bitrate: awscdk.Bitrate_Mbps(jsii.Number(3)),
}),
Framerate: medialive.Framerate_FPS_30(),
}),
Width: jsii.Number(1280),
Height: jsii.Number(720),
})
audio := medialive.EncodeConfiguration_Audio(&AudioEncodeProps{
Name: jsii.String("audio_aac"),
Codec: medialive.AudioCodecSettings_Aac(&AacSettingsProps{
Bitrate: awscdk.Bitrate_Kbps(jsii.Number(192)),
}),
})
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
STANDARD Channel with MediaPackage V2
A STANDARD channel runs two pipelines for redundancy. Each output group needs two destinations — one per pipeline.
ts
declare const stack: Stack;
declare const input: medialive.IInput;
declare const mpChannel: mediapackagev2.IChannel;
const hdVideo = medialive.EncodeConfiguration.video({
name: 'video_1080p',
codec: medialive.VideoCodecSettings.h265({
rateControl: medialive.H265RateControl.qvbr({
maxBitrate: Bitrate.mbps(8),
qvbrQualityLevel: 7,
}),
framerate: medialive.Framerate.FPS_30,
}),
width: 1920,
height: 1080,
});
const sdVideo = medialive.EncodeConfiguration.video({
name: 'video_480p',
codec: medialive.VideoCodecSettings.h265({
rateControl: medialive.H265RateControl.qvbr({
maxBitrate: Bitrate.mbps(2),
qvbrQualityLevel: 7,
}),
framerate: medialive.Framerate.FPS_30,
}),
width: 854,
height: 480,
});
const audio = medialive.EncodeConfiguration.audio({
name: 'audio_aac',
codec: medialive.AudioCodecSettings.aac({ bitrate: Bitrate.kbps(192) }),
});
new medialive.Channel(stack, 'Channel', {
channelClass: medialive.ChannelClass.STANDARD,
inputs: [{ input }],
outputGroups: [
medialive.OutputGroupConfiguration.mediaPackageV2({
name: 'emp',
channel: mpChannel,
outputs: [
{ encode: hdVideo, outputName: 'hd' },
{ encode: sdVideo, outputName: 'sd' },
{ encode: audio, outputName: 'audio' },
],
}),
],
});
python
# stack: Stack
# input: medialive.IInput
# mp_channel: mediapackagev2.IChannel
hd_video = medialive.EncodeConfiguration.video(
name="video_1080p",
codec=medialive.VideoCodecSettings.h265(
rate_control=medialive.H265RateControl.qvbr(
max_bitrate=Bitrate.mbps(8),
qvbr_quality_level=7
),
framerate=medialive.Framerate.FPS_30
),
width=1920,
height=1080
)
sd_video = medialive.EncodeConfiguration.video(
name="video_480p",
codec=medialive.VideoCodecSettings.h265(
rate_control=medialive.H265RateControl.qvbr(
max_bitrate=Bitrate.mbps(2),
qvbr_quality_level=7
),
framerate=medialive.Framerate.FPS_30
),
width=854,
height=480
)
audio = medialive.EncodeConfiguration.audio(
name="audio_aac",
codec=medialive.AudioCodecSettings.aac(bitrate=Bitrate.kbps(192))
)
medialive.Channel(stack, "Channel",
channel_class=medialive.ChannelClass.STANDARD,
inputs=[medialive.InputAttachment(input=input)],
output_groups=[
medialive.OutputGroupConfiguration.media_package_v2(
name="emp",
channel=mp_channel,
outputs=[medialive.MediaPackageV2OutputDefinition(encode=hd_video, output_name="hd"), medialive.MediaPackageV2OutputDefinition(encode=sd_video, output_name="sd"), medialive.MediaPackageV2OutputDefinition(encode=audio, output_name="audio")
]
)
]
)
java
Stack stack;
IInput input;
IChannel mpChannel;
EncodeConfiguration hdVideo = EncodeConfiguration.video(VideoEncodeProps.builder()
.name("video_1080p")
.codec(VideoCodecSettings.h265(H265SettingsProps.builder()
.rateControl(H265RateControl.qvbr(QvbrRateControlProps.builder()
.maxBitrate(Bitrate.mbps(8))
.qvbrQualityLevel(7)
.build()))
.framerate(Framerate.FPS_30)
.build()))
.width(1920)
.height(1080)
.build());
EncodeConfiguration sdVideo = EncodeConfiguration.video(VideoEncodeProps.builder()
.name("video_480p")
.codec(VideoCodecSettings.h265(H265SettingsProps.builder()
.rateControl(H265RateControl.qvbr(QvbrRateControlProps.builder()
.maxBitrate(Bitrate.mbps(2))
.qvbrQualityLevel(7)
.build()))
.framerate(Framerate.FPS_30)
.build()))
.width(854)
.height(480)
.build());
EncodeConfiguration audio = EncodeConfiguration.audio(AudioEncodeProps.builder()
.name("audio_aac")
.codec(AudioCodecSettings.aac(AacSettingsProps.builder().bitrate(Bitrate.kbps(192)).build()))
.build());
Channel.Builder.create(stack, "Channel")
.channelClass(ChannelClass.STANDARD)
.inputs(List.of(InputAttachment.builder().input(input).build()))
.outputGroups(List.of(OutputGroupConfiguration.mediaPackageV2(MediaPackageV2OutputGroupProps.builder()
.name("emp")
.channel(mpChannel)
.outputs(List.of(MediaPackageV2OutputDefinition.builder().encode(hdVideo).outputName("hd").build(), MediaPackageV2OutputDefinition.builder().encode(sdVideo).outputName("sd").build(), MediaPackageV2OutputDefinition.builder().encode(audio).outputName("audio").build()))
.build())))
.build();
csharp
Stack stack;
IInput input;
IChannel mpChannel;
var hdVideo = EncodeConfiguration.Video(new VideoEncodeProps {
Name = "video_1080p",
Codec = VideoCodecSettings.H265(new H265SettingsProps {
RateControl = H265RateControl.Qvbr(new QvbrRateControlProps {
MaxBitrate = Bitrate.Mbps(8),
QvbrQualityLevel = 7
}),
Framerate = Framerate.FPS_30
}),
Width = 1920,
Height = 1080
});
var sdVideo = EncodeConfiguration.Video(new VideoEncodeProps {
Name = "video_480p",
Codec = VideoCodecSettings.H265(new H265SettingsProps {
RateControl = H265RateControl.Qvbr(new QvbrRateControlProps {
MaxBitrate = Bitrate.Mbps(2),
QvbrQualityLevel = 7
}),
Framerate = Framerate.FPS_30
}),
Width = 854,
Height = 480
});
var audio = EncodeConfiguration.Audio(new AudioEncodeProps {
Name = "audio_aac",
Codec = AudioCodecSettings.Aac(new AacSettingsProps { Bitrate = Bitrate.Kbps(192) })
});
new Channel(stack, "Channel", new ChannelProps {
ChannelClass = ChannelClass.STANDARD,
Inputs = new [] { new InputAttachment { Input = input } },
OutputGroups = new [] { OutputGroupConfiguration.MediaPackageV2(new MediaPackageV2OutputGroupProps {
Name = "emp",
Channel = mpChannel,
Outputs = new [] { new MediaPackageV2OutputDefinition { Encode = hdVideo, OutputName = "hd" }, new MediaPackageV2OutputDefinition { Encode = sdVideo, OutputName = "sd" }, new MediaPackageV2OutputDefinition { Encode = audio, OutputName = "audio" } }
}) }
});
go
var stack Stack
var input IInput
var mpChannel IChannel
hdVideo := medialive.EncodeConfiguration_Video(&VideoEncodeProps{
Name: jsii.String("video_1080p"),
Codec: medialive.VideoCodecSettings_H265(&H265SettingsProps{
RateControl: medialive.H265RateControl_Qvbr(&QvbrRateControlProps{
MaxBitrate: awscdk.Bitrate_Mbps(jsii.Number(8)),
QvbrQualityLevel: jsii.Number(7),
}),
Framerate: medialive.Framerate_FPS_30(),
}),
Width: jsii.Number(1920),
Height: jsii.Number(1080),
})
sdVideo := medialive.EncodeConfiguration_Video(&VideoEncodeProps{
Name: jsii.String("video_480p"),
Codec: medialive.VideoCodecSettings_*H265(&H265SettingsProps{
RateControl: medialive.H265RateControl_*Qvbr(&QvbrRateControlProps{
MaxBitrate: awscdk.Bitrate_*Mbps(jsii.Number(2)),
QvbrQualityLevel: jsii.Number(7),
}),
Framerate: medialive.Framerate_FPS_30(),
}),
Width: jsii.Number(854),
Height: jsii.Number(480),
})
audio := medialive.EncodeConfiguration_Audio(&AudioEncodeProps{
Name: jsii.String("audio_aac"),
Codec: medialive.AudioCodecSettings_Aac(&AacSettingsProps{
Bitrate: awscdk.Bitrate_Kbps(jsii.Number(192)),
}),
})
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
ChannelClass: medialive.ChannelClass_STANDARD(),
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_MediaPackageV2(&MediaPackageV2OutputGroupProps{
Name: jsii.String("emp"),
Channel: mpChannel,
Outputs: []MediaPackageV2OutputDefinition{
&MediaPackageV2OutputDefinition{
Encode: hdVideo,
OutputName: jsii.String("hd"),
},
&MediaPackageV2OutputDefinition{
Encode: sdVideo,
OutputName: jsii.String("sd"),
},
&MediaPackageV2OutputDefinition{
Encode: audio,
OutputName: jsii.String("audio"),
},
},
}),
},
})
Global Configuration
globalConfiguration sets channel-wide behaviour: how the pipelines are locked together and the output timing source. All fields are optional and fall back to MediaLive defaults.
ts
declare const stack: Stack;
declare const input: medialive.IInput;
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
new medialive.Channel(stack, 'Channel', {
inputs: [{ input }],
timecodeConfig: {
source: medialive.TimecodeSource.EMBEDDED,
},
globalConfiguration: {
outputLocking: medialive.OutputLocking.epoch(),
outputTimingSource: medialive.OutputTimingSource.INPUT_CLOCK,
},
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video, audio], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# input: medialive.IInput
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(input=input)],
timecode_config=medialive.TimecodeConfig(
source=medialive.TimecodeSource.EMBEDDED
),
global_configuration=medialive.GlobalConfiguration(
output_locking=medialive.OutputLocking.epoch(),
output_timing_source=medialive.OutputTimingSource.INPUT_CLOCK
),
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video, audio], output_name="hls_out")]
)
]
)
java
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder().input(input).build()))
.timecodeConfig(TimecodeConfig.builder()
.source(TimecodeSource.EMBEDDED)
.build())
.globalConfiguration(GlobalConfiguration.builder()
.outputLocking(OutputLocking.epoch())
.outputTimingSource(OutputTimingSource.INPUT_CLOCK)
.build())
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video, audio)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment { Input = input } },
TimecodeConfig = new TimecodeConfig {
Source = TimecodeSource.EMBEDDED
},
GlobalConfiguration = new GlobalConfiguration {
OutputLocking = OutputLocking.Epoch(),
OutputTimingSource = OutputTimingSource.INPUT_CLOCK
},
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video, audio }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var input IInput
var bucket IBucket
var video EncodeConfiguration
var audio EncodeConfiguration
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
TimecodeConfig: &TimecodeConfig{
Source: medialive.TimecodeSource_EMBEDDED(),
},
GlobalConfiguration: &GlobalConfiguration{
OutputLocking: medialive.OutputLocking_Epoch(),
OutputTimingSource: medialive.OutputTimingSource_INPUT_CLOCK(),
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
Output locking
outputLocking synchronises the frames emitted by a channel's two pipelines. Pick a strategy with the OutputLocking factory:
OutputLocking.pipeline()— synchronise each pipeline's output to the other. Choose how withmethod:PipelineLockingMethod.SOURCE_TIMECODE(default, needs reliable embedded timecodes) orPipelineLockingMethod.VIDEO_ALIGNMENT(visual content matching, no timecodes required).OutputLocking.epoch()— synchronise to the Unix epoch (optionally acustomEpoch/jamSyncTime). RequiresoutputTimingSource: OutputTimingSource.INPUT_CLOCK(enforced at synth).OutputLocking.disabled()— no synchronisation.
ts
// Video-aligned pipeline locking — useful when sources lack reliable timecodes
const locking = medialive.OutputLocking.pipeline({
method: medialive.PipelineLockingMethod.VIDEO_ALIGNMENT,
});
python
# Video-aligned pipeline locking — useful when sources lack reliable timecodes
locking = medialive.OutputLocking.pipeline(
method=medialive.PipelineLockingMethod.VIDEO_ALIGNMENT
)
java
// Video-aligned pipeline locking — useful when sources lack reliable timecodes
OutputLocking locking = OutputLocking.pipeline(PipelineOutputLockingProps.builder()
.method(PipelineLockingMethod.VIDEO_ALIGNMENT)
.build());
csharp
// Video-aligned pipeline locking — useful when sources lack reliable timecodes
var locking = OutputLocking.Pipeline(new PipelineOutputLockingProps {
Method = PipelineLockingMethod.VIDEO_ALIGNMENT
});
go
// Video-aligned pipeline locking — useful when sources lack reliable timecodes
locking := medialive.OutputLocking_Pipeline(&PipelineOutputLockingProps{
Method: medialive.PipelineLockingMethod_VIDEO_ALIGNMENT(),
})
Input-loss behavior
inputLossBehavior controls what MediaLive emits when the input is lost: a black period, then a repeated frame, then either a solid colour or a slate image. Provide the slate as a FileLocation.
ts
declare const slateBucket: s3.IBucket;
const inputLoss: medialive.InputLossBehavior = {
blackFrame: Duration.seconds(1),
repeatFrame: Duration.seconds(5),
imageType: medialive.InputLossImageType.SLATE,
imageSlate: medialive.FileLocation.fromBucket(slateBucket, 'slates/offline.png'),
};
python
# slate_bucket: s3.IBucket
input_loss = medialive.InputLossBehavior(
black_frame=Duration.seconds(1),
repeat_frame=Duration.seconds(5),
image_type=medialive.InputLossImageType.SLATE,
image_slate=medialive.FileLocation.from_bucket(slate_bucket, "slates/offline.png")
)
java
IBucket slateBucket;
InputLossBehavior inputLoss = InputLossBehavior.builder()
.blackFrame(Duration.seconds(1))
.repeatFrame(Duration.seconds(5))
.imageType(InputLossImageType.SLATE)
.imageSlate(FileLocation.fromBucket(slateBucket, "slates/offline.png"))
.build();
csharp
IBucket slateBucket;
var inputLoss = new InputLossBehavior {
BlackFrame = Duration.Seconds(1),
RepeatFrame = Duration.Seconds(5),
ImageType = InputLossImageType.SLATE,
ImageSlate = FileLocation.FromBucket(slateBucket, "slates/offline.png")
};
go
var slateBucket IBucket
inputLoss := &InputLossBehavior{
BlackFrame: awscdk.Duration_Seconds(jsii.Number(1)),
RepeatFrame: awscdk.Duration_*Seconds(jsii.Number(5)),
ImageType: medialive.InputLossImageType_SLATE(),
ImageSlate: medialive.FileLocation_FromBucket(slateBucket, jsii.String("slates/offline.png")),
}
File locations
Several channel features reference a file MediaLive reads at runtime — an input-loss slate, an avail-blanking image, a blackout-slate image, or a burn-in caption font. These all take a FileLocation, created from an S3 bucket (which auto-grants the channel role read access) or a URL (with optional SSM-backed credentials):
ts
import { StringParameter } from 'aws-cdk-lib/aws-ssm';
declare const bucket: s3.IBucket;
declare const passwordParam: StringParameter;
// From an S3 bucket — the channel role is granted read access automatically
const fromS3 = medialive.FileLocation.fromBucket(bucket, 'assets/slate.png');
// From a URL with optional credentials (SSM parameter read access auto-granted)
const fromUrl = medialive.FileLocation.url('https://origin.example.com/font.ttf', {
username: 'ingest-user',
password: passwordParam,
});
python
from aws_cdk.aws_ssm import StringParameter
# bucket: s3.IBucket
# password_param: StringParameter
# From an S3 bucket — the channel role is granted read access automatically
from_s3 = medialive.FileLocation.from_bucket(bucket, "assets/slate.png")
# From a URL with optional credentials (SSM parameter read access auto-granted)
from_url = medialive.FileLocation.url("https://origin.example.com/font.ttf",
username="ingest-user",
password=password_param
)
java
import software.amazon.awscdk.services.ssm.StringParameter;
IBucket bucket;
StringParameter passwordParam;
// From an S3 bucket — the channel role is granted read access automatically
FileLocation fromS3 = FileLocation.fromBucket(bucket, "assets/slate.png");
// From a URL with optional credentials (SSM parameter read access auto-granted)
FileLocation fromUrl = FileLocation.url("https://origin.example.com/font.ttf", FileLocationOptions.builder()
.username("ingest-user")
.password(passwordParam)
.build());
csharp
using Amazon.CDK.AWS.SSM;
IBucket bucket;
StringParameter passwordParam;
// From an S3 bucket — the channel role is granted read access automatically
var fromS3 = FileLocation.FromBucket(bucket, "assets/slate.png");
// From a URL with optional credentials (SSM parameter read access auto-granted)
var fromUrl = FileLocation.Url("https://origin.example.com/font.ttf", new FileLocationOptions {
Username = "ingest-user",
Password = passwordParam
});
go
import "github.com/aws/aws-cdk-go/awscdk"
var bucket IBucket
var passwordParam StringParameter
// From an S3 bucket — the channel role is granted read access automatically
fromS3 := medialive.FileLocation_FromBucket(bucket, jsii.String("assets/slate.png"))
// From a URL with optional credentials (SSM parameter read access auto-granted)
fromUrl := medialive.FileLocation_Url(jsii.String("https://origin.example.com/font.ttf"), &FileLocationOptions{
Username: jsii.String("ingest-user"),
Password: passwordParam,
})
Color correction
A channel can apply one or more color-space conversions to its video, optionally using a 3D LUT to remap colors. Each ColorCorrection declares the inputColorSpace to match and the outputColorSpace to convert to. MediaLive reads the LUT from S3 at runtime, so it must be an S3 location — provide it via Lut.fromBucket() (which uses the secure s3ssl:// form and auto-grants the channel role read access) or Lut.url() with an s3:///s3ssl:// URL:
ts
declare const stack: Stack;
declare const bucket: s3.IBucket;
declare const input: medialive.IInput;
declare const video: medialive.EncodeConfiguration;
declare const destination: medialive.OutputDestination;
new medialive.Channel(stack, 'Channel', {
inputs: [{ input }],
colorCorrections: [{
inputColorSpace: medialive.ColorSpace.REC_601,
outputColorSpace: medialive.ColorSpace.REC_709,
lut: medialive.Lut.fromBucket(bucket, 'luts/rec601-to-rec709.cube'),
}],
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [destination],
outputs: [{ encodes: [video], outputName: 'video' }],
}),
],
});
python
# stack: Stack
# bucket: s3.IBucket
# input: medialive.IInput
# video: medialive.EncodeConfiguration
# destination: medialive.OutputDestination
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(input=input)],
color_corrections=[medialive.ColorCorrection(
input_color_space=medialive.ColorSpace.REC_601,
output_color_space=medialive.ColorSpace.REC_709,
lut=medialive.Lut.from_bucket(bucket, "luts/rec601-to-rec709.cube")
)],
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[destination],
outputs=[medialive.HlsOutputDefinition(encodes=[video], output_name="video")]
)
]
)
java
Stack stack;
IBucket bucket;
IInput input;
EncodeConfiguration video;
OutputDestination destination;
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder().input(input).build()))
.colorCorrections(List.of(ColorCorrection.builder()
.inputColorSpace(ColorSpace.REC_601)
.outputColorSpace(ColorSpace.REC_709)
.lut(Lut.fromBucket(bucket, "luts/rec601-to-rec709.cube"))
.build()))
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(destination))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video)).outputName("video").build()))
.build())))
.build();
csharp
Stack stack;
IBucket bucket;
IInput input;
EncodeConfiguration video;
OutputDestination destination;
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment { Input = input } },
ColorCorrections = new [] { new ColorCorrection {
InputColorSpace = ColorSpace.REC_601,
OutputColorSpace = ColorSpace.REC_709,
Lut = Lut.FromBucket(bucket, "luts/rec601-to-rec709.cube")
} },
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { destination },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video }, OutputName = "video" } }
}) }
});
go
var stack Stack
var bucket IBucket
var input IInput
var video EncodeConfiguration
var destination OutputDestination
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
ColorCorrections: []ColorCorrection{
&ColorCorrection{
InputColorSpace: medialive.ColorSpace_REC_601(),
OutputColorSpace: medialive.ColorSpace_REC_709(),
Lut: medialive.Lut_FromBucket(bucket, jsii.String("luts/rec601-to-rec709.cube")),
},
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
destination,
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("video"),
},
},
}),
},
})
Encode Configuration
Use EncodeConfiguration.video(), EncodeConfiguration.audio(), and EncodeConfiguration.caption() to define encodes.
Video
ts
// H.264
const h264 = medialive.EncodeConfiguration.video({
name: 'h264_720p',
codec: medialive.VideoCodecSettings.h264({
rateControl: medialive.H264RateControl.cbr({ bitrate: Bitrate.mbps(3) }),
framerate: medialive.Framerate.FPS_30,
profile: medialive.H264Profile.HIGH,
}),
width: 1280,
height: 720,
});
// H.265
const h265 = medialive.EncodeConfiguration.video({
name: 'h265_1080p',
codec: medialive.VideoCodecSettings.h265({
rateControl: medialive.H265RateControl.qvbr({
maxBitrate: Bitrate.mbps(5),
qvbrQualityLevel: 7,
}),
framerate: medialive.Framerate.FPS_30,
profile: medialive.H265Profile.MAIN,
tier: medialive.H265Tier.HIGH,
}),
width: 1920,
height: 1080,
});
python
# H.264
h264 = medialive.EncodeConfiguration.video(
name="h264_720p",
codec=medialive.VideoCodecSettings.h264(
rate_control=medialive.H264RateControl.cbr(bitrate=Bitrate.mbps(3)),
framerate=medialive.Framerate.FPS_30,
profile=medialive.H264Profile.HIGH
),
width=1280,
height=720
)
# H.265
h265 = medialive.EncodeConfiguration.video(
name="h265_1080p",
codec=medialive.VideoCodecSettings.h265(
rate_control=medialive.H265RateControl.qvbr(
max_bitrate=Bitrate.mbps(5),
qvbr_quality_level=7
),
framerate=medialive.Framerate.FPS_30,
profile=medialive.H265Profile.MAIN,
tier=medialive.H265Tier.HIGH
),
width=1920,
height=1080
)
java
// H.264
EncodeConfiguration h264 = EncodeConfiguration.video(VideoEncodeProps.builder()
.name("h264_720p")
.codec(VideoCodecSettings.h264(H264SettingsProps.builder()
.rateControl(H264RateControl.cbr(CbrRateControlProps.builder().bitrate(Bitrate.mbps(3)).build()))
.framerate(Framerate.FPS_30)
.profile(H264Profile.HIGH)
.build()))
.width(1280)
.height(720)
.build());
// H.265
EncodeConfiguration h265 = EncodeConfiguration.video(VideoEncodeProps.builder()
.name("h265_1080p")
.codec(VideoCodecSettings.h265(H265SettingsProps.builder()
.rateControl(H265RateControl.qvbr(QvbrRateControlProps.builder()
.maxBitrate(Bitrate.mbps(5))
.qvbrQualityLevel(7)
.build()))
.framerate(Framerate.FPS_30)
.profile(H265Profile.MAIN)
.tier(H265Tier.HIGH)
.build()))
.width(1920)
.height(1080)
.build());
csharp
// H.264
var h264 = EncodeConfiguration.Video(new VideoEncodeProps {
Name = "h264_720p",
Codec = VideoCodecSettings.H264(new H264SettingsProps {
RateControl = H264RateControl.Cbr(new CbrRateControlProps { Bitrate = Bitrate.Mbps(3) }),
Framerate = Framerate.FPS_30,
Profile = H264Profile.HIGH
}),
Width = 1280,
Height = 720
});
// H.265
var h265 = EncodeConfiguration.Video(new VideoEncodeProps {
Name = "h265_1080p",
Codec = VideoCodecSettings.H265(new H265SettingsProps {
RateControl = H265RateControl.Qvbr(new QvbrRateControlProps {
MaxBitrate = Bitrate.Mbps(5),
QvbrQualityLevel = 7
}),
Framerate = Framerate.FPS_30,
Profile = H265Profile.MAIN,
Tier = H265Tier.HIGH
}),
Width = 1920,
Height = 1080
});
go
// H.264
h264 := medialive.EncodeConfiguration_Video(&VideoEncodeProps{
Name: jsii.String("h264_720p"),
Codec: medialive.VideoCodecSettings_H264(&H264SettingsProps{
RateControl: medialive.H264RateControl_Cbr(&CbrRateControlProps{
Bitrate: awscdk.Bitrate_Mbps(jsii.Number(3)),
}),
Framerate: medialive.Framerate_FPS_30(),
Profile: medialive.H264Profile_HIGH(),
}),
Width: jsii.Number(1280),
Height: jsii.Number(720),
})
// H.265
h265 := medialive.EncodeConfiguration_Video(&VideoEncodeProps{
Name: jsii.String("h265_1080p"),
Codec: medialive.VideoCodecSettings_H265(&H265SettingsProps{
RateControl: medialive.H265RateControl_Qvbr(&QvbrRateControlProps{
MaxBitrate: awscdk.Bitrate_*Mbps(jsii.Number(5)),
QvbrQualityLevel: jsii.Number(7),
}),
Framerate: medialive.Framerate_FPS_30(),
Profile: medialive.H265Profile_MAIN(),
Tier: medialive.H265Tier_HIGH(),
}),
Width: jsii.Number(1920),
Height: jsii.Number(1080),
})
Video codecs accept optional overrides for adaptive quantization, scene-change detection, color space, and more. See the props interfaces for the full list:
ts
const hdr = medialive.EncodeConfiguration.video({
name: 'h265_hdr',
codec: medialive.VideoCodecSettings.h265({
rateControl: medialive.H265RateControl.qvbr({ maxBitrate: Bitrate.mbps(8), qvbrQualityLevel: 8 }),
framerate: medialive.Framerate.FPS_30,
sceneChangeDetect: medialive.H265SceneChangeDetect.ENABLED,
colorSpaceSettings: medialive.H265ColorSpaceSettings.hlg2020(),
}),
width: 1920,
height: 1080,
});
python
hdr = medialive.EncodeConfiguration.video(
name="h265_hdr",
codec=medialive.VideoCodecSettings.h265(
rate_control=medialive.H265RateControl.qvbr(max_bitrate=Bitrate.mbps(8), qvbr_quality_level=8),
framerate=medialive.Framerate.FPS_30,
scene_change_detect=medialive.H265SceneChangeDetect.ENABLED,
color_space_settings=medialive.H265ColorSpaceSettings.hlg2020()
),
width=1920,
height=1080
)
java
EncodeConfiguration hdr = EncodeConfiguration.video(VideoEncodeProps.builder()
.name("h265_hdr")
.codec(VideoCodecSettings.h265(H265SettingsProps.builder()
.rateControl(H265RateControl.qvbr(QvbrRateControlProps.builder().maxBitrate(Bitrate.mbps(8)).qvbrQualityLevel(8).build()))
.framerate(Framerate.FPS_30)
.sceneChangeDetect(H265SceneChangeDetect.ENABLED)
.colorSpaceSettings(H265ColorSpaceSettings.hlg2020())
.build()))
.width(1920)
.height(1080)
.build());
csharp
var hdr = EncodeConfiguration.Video(new VideoEncodeProps {
Name = "h265_hdr",
Codec = VideoCodecSettings.H265(new H265SettingsProps {
RateControl = H265RateControl.Qvbr(new QvbrRateControlProps { MaxBitrate = Bitrate.Mbps(8), QvbrQualityLevel = 8 }),
Framerate = Framerate.FPS_30,
SceneChangeDetect = H265SceneChangeDetect.ENABLED,
ColorSpaceSettings = H265ColorSpaceSettings.Hlg2020()
}),
Width = 1920,
Height = 1080
});
go
hdr := medialive.EncodeConfiguration_Video(&VideoEncodeProps{
Name: jsii.String("h265_hdr"),
Codec: medialive.VideoCodecSettings_H265(&H265SettingsProps{
RateControl: medialive.H265RateControl_Qvbr(&QvbrRateControlProps{
MaxBitrate: awscdk.Bitrate_Mbps(jsii.Number(8)),
QvbrQualityLevel: jsii.Number(8),
}),
Framerate: medialive.Framerate_FPS_30(),
SceneChangeDetect: medialive.H265SceneChangeDetect_ENABLED(),
ColorSpaceSettings: medialive.H265ColorSpaceSettings_Hlg2020(),
}),
Width: jsii.Number(1920),
Height: jsii.Number(1080),
})
Audio
ts
// AAC stereo
const aac = medialive.EncodeConfiguration.audio({
name: 'aac_stereo',
codec: medialive.AudioCodecSettings.aac({
bitrate: Bitrate.kbps(192),
codingMode: medialive.AacCodingMode.CODING_MODE_2_0,
}),
});
// AC3 5.1
const ac3 = medialive.EncodeConfiguration.audio({
name: 'ac3_surround',
codec: medialive.AudioCodecSettings.ac3({
bitrate: Bitrate.kbps(384),
codingMode: medialive.Ac3CodingMode.CODING_MODE_3_2_LFE,
}),
});
python
# AAC stereo
aac = medialive.EncodeConfiguration.audio(
name="aac_stereo",
codec=medialive.AudioCodecSettings.aac(
bitrate=Bitrate.kbps(192),
coding_mode=medialive.AacCodingMode.CODING_MODE_2_0
)
)
# AC3 5.1
ac3 = medialive.EncodeConfiguration.audio(
name="ac3_surround",
codec=medialive.AudioCodecSettings.ac3(
bitrate=Bitrate.kbps(384),
coding_mode=medialive.Ac3CodingMode.CODING_MODE_3_2_LFE
)
)
java
// AAC stereo
EncodeConfiguration aac = EncodeConfiguration.audio(AudioEncodeProps.builder()
.name("aac_stereo")
.codec(AudioCodecSettings.aac(AacSettingsProps.builder()
.bitrate(Bitrate.kbps(192))
.codingMode(AacCodingMode.CODING_MODE_2_0)
.build()))
.build());
// AC3 5.1
EncodeConfiguration ac3 = EncodeConfiguration.audio(AudioEncodeProps.builder()
.name("ac3_surround")
.codec(AudioCodecSettings.ac3(Ac3SettingsProps.builder()
.bitrate(Bitrate.kbps(384))
.codingMode(Ac3CodingMode.CODING_MODE_3_2_LFE)
.build()))
.build());
csharp
// AAC stereo
var aac = EncodeConfiguration.Audio(new AudioEncodeProps {
Name = "aac_stereo",
Codec = AudioCodecSettings.Aac(new AacSettingsProps {
Bitrate = Bitrate.Kbps(192),
CodingMode = AacCodingMode.CODING_MODE_2_0
})
});
// AC3 5.1
var ac3 = EncodeConfiguration.Audio(new AudioEncodeProps {
Name = "ac3_surround",
Codec = AudioCodecSettings.Ac3(new Ac3SettingsProps {
Bitrate = Bitrate.Kbps(384),
CodingMode = Ac3CodingMode.CODING_MODE_3_2_LFE
})
});
go
// AAC stereo
aac := medialive.EncodeConfiguration_Audio(&AudioEncodeProps{
Name: jsii.String("aac_stereo"),
Codec: medialive.AudioCodecSettings_Aac(&AacSettingsProps{
Bitrate: awscdk.Bitrate_Kbps(jsii.Number(192)),
CodingMode: medialive.AacCodingMode_CODING_MODE_2_0(),
}),
})
// AC3 5.1
ac3 := medialive.EncodeConfiguration_Audio(&AudioEncodeProps{
Name: jsii.String("ac3_surround"),
Codec: medialive.AudioCodecSettings_Ac3(&Ac3SettingsProps{
Bitrate: awscdk.Bitrate_*Kbps(jsii.Number(384)),
CodingMode: medialive.Ac3CodingMode_CODING_MODE_3_2_LFE(),
}),
})
Caption
A caption encode converts a source caption track (referenced by captionSelectorName) to an output format via the CaptionDestination factory. One selector can feed multiple encodes:
ts
// Define a caption selector on the input attachment (see Input Attachment Settings below)
const captionSelector = medialive.CaptionSelector.embedded('captions');
// WebVTT captions — packaged alongside the video encode in the same output
const webvtt = medialive.EncodeConfiguration.caption({
name: 'eng_webvtt',
captionSelectorName: captionSelector.name,
languageCode: 'eng',
languageDescription: 'English',
destination: medialive.CaptionDestination.webvtt(),
});
// Burned-in captions — rendered into the video, styled via the burn-in options
const burnIn = medialive.EncodeConfiguration.caption({
name: 'eng_burnin',
captionSelectorName: captionSelector.name,
destination: medialive.CaptionDestination.burnIn({
alignment: medialive.CaptionAlignment.CENTERED,
fontColor: medialive.CaptionFontColor.WHITE,
outlineColor: medialive.CaptionOutlineColor.BLACK,
fontSize: medialive.CaptionFontSize.AUTO,
}),
});
python
# Define a caption selector on the input attachment (see Input Attachment Settings below)
caption_selector = medialive.CaptionSelector.embedded("captions")
# WebVTT captions — packaged alongside the video encode in the same output
webvtt = medialive.EncodeConfiguration.caption(
name="eng_webvtt",
caption_selector_name=caption_selector.name,
language_code="eng",
language_description="English",
destination=medialive.CaptionDestination.webvtt()
)
# Burned-in captions — rendered into the video, styled via the burn-in options
burn_in = medialive.EncodeConfiguration.caption(
name="eng_burnin",
caption_selector_name=caption_selector.name,
destination=medialive.CaptionDestination.burn_in(
alignment=medialive.CaptionAlignment.CENTERED,
font_color=medialive.CaptionFontColor.WHITE,
outline_color=medialive.CaptionOutlineColor.BLACK,
font_size=medialive.CaptionFontSize.AUTO
)
)
java
// Define a caption selector on the input attachment (see Input Attachment Settings below)
CaptionSelector captionSelector = CaptionSelector.embedded("captions");
// WebVTT captions — packaged alongside the video encode in the same output
EncodeConfiguration webvtt = EncodeConfiguration.caption(CaptionEncodeProps.builder()
.name("eng_webvtt")
.captionSelectorName(captionSelector.getName())
.languageCode("eng")
.languageDescription("English")
.destination(CaptionDestination.webvtt())
.build());
// Burned-in captions — rendered into the video, styled via the burn-in options
EncodeConfiguration burnIn = EncodeConfiguration.caption(CaptionEncodeProps.builder()
.name("eng_burnin")
.captionSelectorName(captionSelector.getName())
.destination(CaptionDestination.burnIn(BurnInDestinationProps.builder()
.alignment(CaptionAlignment.CENTERED)
.fontColor(CaptionFontColor.WHITE)
.outlineColor(CaptionOutlineColor.BLACK)
.fontSize(CaptionFontSize.AUTO)
.build()))
.build());
csharp
// Define a caption selector on the input attachment (see Input Attachment Settings below)
var captionSelector = CaptionSelector.Embedded("captions");
// WebVTT captions — packaged alongside the video encode in the same output
var webvtt = EncodeConfiguration.Caption(new CaptionEncodeProps {
Name = "eng_webvtt",
CaptionSelectorName = captionSelector.Name,
LanguageCode = "eng",
LanguageDescription = "English",
Destination = CaptionDestination.Webvtt()
});
// Burned-in captions — rendered into the video, styled via the burn-in options
var burnIn = EncodeConfiguration.Caption(new CaptionEncodeProps {
Name = "eng_burnin",
CaptionSelectorName = captionSelector.Name,
Destination = CaptionDestination.BurnIn(new BurnInDestinationProps {
Alignment = CaptionAlignment.CENTERED,
FontColor = CaptionFontColor.WHITE,
OutlineColor = CaptionOutlineColor.BLACK,
FontSize = CaptionFontSize.AUTO
})
});
go
// Define a caption selector on the input attachment (see Input Attachment Settings below)
captionSelector := medialive.CaptionSelector_Embedded(jsii.String("captions"))
// WebVTT captions — packaged alongside the video encode in the same output
webvtt := medialive.EncodeConfiguration_Caption(&CaptionEncodeProps{
Name: jsii.String("eng_webvtt"),
CaptionSelectorName: captionSelector.Name,
LanguageCode: jsii.String("eng"),
LanguageDescription: jsii.String("English"),
Destination: medialive.CaptionDestination_Webvtt(),
})
// Burned-in captions — rendered into the video, styled via the burn-in options
burnIn := medialive.EncodeConfiguration_Caption(&CaptionEncodeProps{
Name: jsii.String("eng_burnin"),
CaptionSelectorName: captionSelector.*Name,
Destination: medialive.CaptionDestination_BurnIn(&BurnInDestinationProps{
Alignment: medialive.CaptionAlignment_CENTERED(),
FontColor: medialive.CaptionFontColor_WHITE(),
OutlineColor: medialive.CaptionOutlineColor_BLACK(),
FontSize: medialive.CaptionFontSize_AUTO(),
}),
})
Cross-service integrations
| Destination | MediaLive side | Other side | Package |
|---|---|---|---|
| MediaPackage V2 | medialive.OutputGroupConfiguration.mediaPackageV2() | mediapackagev2.Channel | @aws-cdk/aws-mediapackagev2-alpha |
| MediaConnect Router (output) | medialive.OutputGroupConfiguration.mediaConnectRouter() | mediaconnect.RouterInputConfiguration.mediaLiveChannel() | @aws-cdk/aws-mediaconnect-alpha |
| MediaConnect Router (input) | medialive.InputConfiguration.mediaConnectRouter() | mediaconnect.RouterOutputConfiguration.mediaLiveInput() | @aws-cdk/aws-mediaconnect-alpha |
AWS Elemental MediaPackage V2
Use mediaPackageV2() and pass a single channel — MediaLive maps each pipeline to a MediaPackage ingest endpoint automatically (one for SINGLE_PIPELINE, both for STANDARD). Each output contains a single encode (one track per output).
In-band captions (burn-in, embedded) ride alongside a video encode via the captions prop:
ts
declare const mpChannel: mediapackagev2.IChannel;
declare const hdVideo: medialive.EncodeConfiguration;
declare const sdVideo: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
declare const burnIn: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.mediaPackageV2({
name: 'emp',
channel: mpChannel,
outputs: [
{ encode: hdVideo, captions: [burnIn], outputName: 'hd' },
{ encode: sdVideo, outputName: 'sd' },
{ encode: audio, outputName: 'audio' },
],
});
python
# mp_channel: mediapackagev2.IChannel
# hd_video: medialive.EncodeConfiguration
# sd_video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
# burn_in: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.media_package_v2(
name="emp",
channel=mp_channel,
outputs=[medialive.MediaPackageV2OutputDefinition(encode=hd_video, captions=[burn_in], output_name="hd"), medialive.MediaPackageV2OutputDefinition(encode=sd_video, output_name="sd"), medialive.MediaPackageV2OutputDefinition(encode=audio, output_name="audio")
]
)
java
IChannel mpChannel;
EncodeConfiguration hdVideo;
EncodeConfiguration sdVideo;
EncodeConfiguration audio;
EncodeConfiguration burnIn;
OutputGroupConfiguration.mediaPackageV2(MediaPackageV2OutputGroupProps.builder()
.name("emp")
.channel(mpChannel)
.outputs(List.of(MediaPackageV2OutputDefinition.builder().encode(hdVideo).captions(List.of(burnIn)).outputName("hd").build(), MediaPackageV2OutputDefinition.builder().encode(sdVideo).outputName("sd").build(), MediaPackageV2OutputDefinition.builder().encode(audio).outputName("audio").build()))
.build());
csharp
IChannel mpChannel;
EncodeConfiguration hdVideo;
EncodeConfiguration sdVideo;
EncodeConfiguration audio;
EncodeConfiguration burnIn;
OutputGroupConfiguration.MediaPackageV2(new MediaPackageV2OutputGroupProps {
Name = "emp",
Channel = mpChannel,
Outputs = new [] { new MediaPackageV2OutputDefinition { Encode = hdVideo, Captions = new [] { burnIn }, OutputName = "hd" }, new MediaPackageV2OutputDefinition { Encode = sdVideo, OutputName = "sd" }, new MediaPackageV2OutputDefinition { Encode = audio, OutputName = "audio" } }
});
go
var mpChannel IChannel
var hdVideo EncodeConfiguration
var sdVideo EncodeConfiguration
var audio EncodeConfiguration
var burnIn EncodeConfiguration
medialive.OutputGroupConfiguration_MediaPackageV2(&MediaPackageV2OutputGroupProps{
Name: jsii.String("emp"),
Channel: mpChannel,
Outputs: []MediaPackageV2OutputDefinition{
&MediaPackageV2OutputDefinition{
Encode: hdVideo,
Captions: []EncodeConfiguration{
burnIn,
},
OutputName: jsii.String("hd"),
},
&MediaPackageV2OutputDefinition{
Encode: sdVideo,
OutputName: jsii.String("sd"),
},
&MediaPackageV2OutputDefinition{
Encode: audio,
OutputName: jsii.String("audio"),
},
},
})
For per-pipeline control — for example pinning pipeline 0 to a specific endpoint, or delivering each pipeline to a different (cross-region) channel — use mediaPackageV2PerPipeline() with explicit destinations:
ts
declare const primary: mediapackagev2.IChannel;
declare const hdVideo: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.mediaPackageV2PerPipeline({
name: 'emp',
destinations: [
// destinations[0] → Pipeline 0, destinations[1] → Pipeline 1
medialive.MediaPackageV2Destination.channel(primary, medialive.MediaPackageV2EndpointId.ENDPOINT_2),
medialive.MediaPackageV2Destination.channel(primary, medialive.MediaPackageV2EndpointId.ENDPOINT_1),
],
outputs: [
{ encode: hdVideo, outputName: 'hd' },
],
});
python
# primary: mediapackagev2.IChannel
# hd_video: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.media_package_v2_per_pipeline(
name="emp",
destinations=[
# destinations[0] → Pipeline 0, destinations[1] → Pipeline 1
medialive.MediaPackageV2Destination.channel(primary, medialive.MediaPackageV2EndpointId.ENDPOINT_2),
medialive.MediaPackageV2Destination.channel(primary, medialive.MediaPackageV2EndpointId.ENDPOINT_1)
],
outputs=[medialive.MediaPackageV2OutputDefinition(encode=hd_video, output_name="hd")
]
)
java
IChannel primary;
EncodeConfiguration hdVideo;
OutputGroupConfiguration.mediaPackageV2PerPipeline(MediaPackageV2PerPipelineOutputGroupProps.builder()
.name("emp")
.destinations(List.of(MediaPackageV2Destination.channel(primary, MediaPackageV2EndpointId.ENDPOINT_2), MediaPackageV2Destination.channel(primary, MediaPackageV2EndpointId.ENDPOINT_1)))
.outputs(List.of(MediaPackageV2OutputDefinition.builder().encode(hdVideo).outputName("hd").build()))
.build());
csharp
IChannel primary;
EncodeConfiguration hdVideo;
OutputGroupConfiguration.MediaPackageV2PerPipeline(new MediaPackageV2PerPipelineOutputGroupProps {
Name = "emp",
Destinations = new [] { MediaPackageV2Destination.Channel(primary, MediaPackageV2EndpointId.ENDPOINT_2), MediaPackageV2Destination.Channel(primary, MediaPackageV2EndpointId.ENDPOINT_1) },
Outputs = new [] { new MediaPackageV2OutputDefinition { Encode = hdVideo, OutputName = "hd" } }
});
go
var primary IChannel
var hdVideo EncodeConfiguration
medialive.OutputGroupConfiguration_MediaPackageV2PerPipeline(&MediaPackageV2PerPipelineOutputGroupProps{
Name: jsii.String("emp"),
Destinations: []MediaPackageV2Destination{
medialive.MediaPackageV2Destination_Channel(primary, medialive.MediaPackageV2EndpointId_ENDPOINT_2()),
medialive.MediaPackageV2Destination_*Channel(primary, medialive.MediaPackageV2EndpointId_ENDPOINT_1()),
},
Outputs: []MediaPackageV2OutputDefinition{
&MediaPackageV2OutputDefinition{
Encode: hdVideo,
OutputName: jsii.String("hd"),
},
},
})
HLS
Use OutputDestination.url() for HTTP origins or OutputDestination.toBucket() for S3:
ts
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
// HLS to S3
medialive.OutputGroupConfiguration.hls({
name: 'hls_s3',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video, audio], outputName: 'hls_out' }],
});
// HLS to an HTTPS CDN origin.
medialive.OutputGroupConfiguration.hls({
name: 'hls-http',
destinations: [medialive.OutputDestination.url('https://203.0.113.10/ingest/stream')],
hlsCdnSettings: medialive.HlsCdnSettings.basicPut(),
outputs: [{ encodes: [video, audio], outputName: 'hls_out' }],
});
python
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
# HLS to S3
medialive.OutputGroupConfiguration.hls(
name="hls_s3",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video, audio], output_name="hls_out")]
)
# HLS to an HTTPS CDN origin.
medialive.OutputGroupConfiguration.hls(
name="hls-http",
destinations=[medialive.OutputDestination.url("https://203.0.113.10/ingest/stream")],
hls_cdn_settings=medialive.HlsCdnSettings.basic_put(),
outputs=[medialive.HlsOutputDefinition(encodes=[video, audio], output_name="hls_out")]
)
java
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
// HLS to S3
OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls_s3")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video, audio)).outputName("hls_out").build()))
.build());
// HLS to an HTTPS CDN origin.
OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls-http")
.destinations(List.of(OutputDestination.url("https://203.0.113.10/ingest/stream")))
.hlsCdnSettings(HlsCdnSettings.basicPut())
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video, audio)).outputName("hls_out").build()))
.build());
csharp
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
// HLS to S3
OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls_s3",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video, audio }, OutputName = "hls_out" } }
});
// HLS to an HTTPS CDN origin.
OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls-http",
Destinations = new [] { OutputDestination.Url("https://203.0.113.10/ingest/stream") },
HlsCdnSettings = HlsCdnSettings.BasicPut(),
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video, audio }, OutputName = "hls_out" } }
});
go
var bucket IBucket
var video EncodeConfiguration
var audio EncodeConfiguration
// HLS to S3
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls_s3"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("hls_out"),
},
},
})
// HLS to an HTTPS CDN origin.
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls-http"),
Destinations: []OutputDestination{
medialive.OutputDestination_Url(jsii.String("https://203.0.113.10/ingest/stream")),
},
HlsCdnSettings: medialive.HlsCdnSettings_BasicPut(),
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("hls_out"),
},
},
})
Archive
Archive outputs write long-form recordings to S3:
ts
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.archive({
name: 'archive',
destinations: [medialive.S3OutputDestination.toBucket(bucket, 'archive/recording')],
rolloverInterval: Duration.seconds(600),
outputs: [{ encodes: [video, audio], outputName: 'archive_out' }],
});
python
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.archive(
name="archive",
destinations=[medialive.S3OutputDestination.to_bucket(bucket, "archive/recording")],
rollover_interval=Duration.seconds(600),
outputs=[medialive.ArchiveOutputDefinition(encodes=[video, audio], output_name="archive_out")]
)
java
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.archive(ArchiveOutputGroupProps.builder()
.name("archive")
.destinations(List.of(S3OutputDestination.toBucket(bucket, "archive/recording")))
.rolloverInterval(Duration.seconds(600))
.outputs(List.of(ArchiveOutputDefinition.builder().encodes(List.of(video, audio)).outputName("archive_out").build()))
.build());
csharp
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.Archive(new ArchiveOutputGroupProps {
Name = "archive",
Destinations = new [] { S3OutputDestination.ToBucket(bucket, "archive/recording") },
RolloverInterval = Duration.Seconds(600),
Outputs = new [] { new ArchiveOutputDefinition { Encodes = new [] { video, audio }, OutputName = "archive_out" } }
});
go
var bucket IBucket
var video EncodeConfiguration
var audio EncodeConfiguration
medialive.OutputGroupConfiguration_Archive(&ArchiveOutputGroupProps{
Name: jsii.String("archive"),
Destinations: []S3OutputDestination{
medialive.S3OutputDestination_ToBucket(bucket, jsii.String("archive/recording")),
},
RolloverInterval: awscdk.Duration_Seconds(jsii.Number(600)),
Outputs: []ArchiveOutputDefinition{
&ArchiveOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("archive_out"),
},
},
})
RTMP
RTMP outputs support H.264 + AAC only. Each output takes one destination per channel pipeline (the console's "Destination A" / "Destination B") via RtmpDestination.url() — one for SINGLE_PIPELINE, two for STANDARD:
ts
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.rtmp({
name: 'social',
outputs: [{
encodes: [video, audio],
outputName: 'live',
destinations: [
medialive.RtmpDestination.url('rtmp://rtmp.example.com/live', 'your-stream-key'),
],
}],
});
python
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.rtmp(
name="social",
outputs=[medialive.RtmpOutputDefinition(
encodes=[video, audio],
output_name="live",
destinations=[
medialive.RtmpDestination.url("rtmp://rtmp.example.com/live", "your-stream-key")
]
)]
)
java
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.rtmp(RtmpOutputGroupProps.builder()
.name("social")
.outputs(List.of(RtmpOutputDefinition.builder()
.encodes(List.of(video, audio))
.outputName("live")
.destinations(List.of(RtmpDestination.url("rtmp://rtmp.example.com/live", "your-stream-key")))
.build()))
.build());
csharp
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.Rtmp(new RtmpOutputGroupProps {
Name = "social",
Outputs = new [] { new RtmpOutputDefinition {
Encodes = new [] { video, audio },
OutputName = "live",
Destinations = new [] { RtmpDestination.Url("rtmp://rtmp.example.com/live", "your-stream-key") }
} }
});
go
var video EncodeConfiguration
var audio EncodeConfiguration
medialive.OutputGroupConfiguration_Rtmp(&RtmpOutputGroupProps{
Name: jsii.String("social"),
Outputs: []RtmpOutputDefinition{
&RtmpOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("live"),
Destinations: []RtmpDestination{
medialive.RtmpDestination_Url(jsii.String("rtmp://rtmp.example.com/live"), jsii.String("your-stream-key")),
},
},
},
})
SRT
SRT outputs use SrtDestination.caller() for caller mode or SrtDestination.listener() for listener mode. When you already have a full SRT URL rather than a separate host and port, use SrtDestination.callerUrl(). SRT output is always encrypted, so every destination takes an encryptionPassphraseSecret (a Secrets Manager secret). Each output takes one destination per channel pipeline ("Destination A"/"Destination B") — one for SINGLE_PIPELINE, two for STANDARD:
ts
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
declare const passphrase: secretsmanager.ISecret;
// SRT caller to a remote listener
medialive.OutputGroupConfiguration.srt({
name: 'srt_out',
outputs: [{
encodes: [video, audio],
outputName: 'srt_caller',
destinations: [medialive.SrtDestination.caller({
address: '203.0.113.20',
port: 5000,
encryptionPassphraseSecret: passphrase,
})],
}],
});
// SRT listener — MediaLive waits for the downstream system to connect
medialive.OutputGroupConfiguration.srt({
name: 'srt_listen',
outputs: [{
encodes: [video, audio],
outputName: 'srt_listener',
destinations: [medialive.SrtDestination.listener({
listenerPort: 5000,
encryptionPassphraseSecret: passphrase,
})],
}],
});
python
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
# passphrase: secretsmanager.ISecret
# SRT caller to a remote listener
medialive.OutputGroupConfiguration.srt(
name="srt_out",
outputs=[medialive.SrtOutputDefinition(
encodes=[video, audio],
output_name="srt_caller",
destinations=[medialive.SrtDestination.caller(
address="203.0.113.20",
port=5000,
encryption_passphrase_secret=passphrase
)]
)]
)
# SRT listener — MediaLive waits for the downstream system to connect
medialive.OutputGroupConfiguration.srt(
name="srt_listen",
outputs=[medialive.SrtOutputDefinition(
encodes=[video, audio],
output_name="srt_listener",
destinations=[medialive.SrtDestination.listener(
listener_port=5000,
encryption_passphrase_secret=passphrase
)]
)]
)
java
EncodeConfiguration video;
EncodeConfiguration audio;
ISecret passphrase;
// SRT caller to a remote listener
OutputGroupConfiguration.srt(SrtOutputGroupProps.builder()
.name("srt_out")
.outputs(List.of(SrtOutputDefinition.builder()
.encodes(List.of(video, audio))
.outputName("srt_caller")
.destinations(List.of(SrtDestination.caller(SrtCallerDestinationProps.builder()
.address("203.0.113.20")
.port(5000)
.encryptionPassphraseSecret(passphrase)
.build())))
.build()))
.build());
// SRT listener — MediaLive waits for the downstream system to connect
OutputGroupConfiguration.srt(SrtOutputGroupProps.builder()
.name("srt_listen")
.outputs(List.of(SrtOutputDefinition.builder()
.encodes(List.of(video, audio))
.outputName("srt_listener")
.destinations(List.of(SrtDestination.listener(SrtListenerDestinationProps.builder()
.listenerPort(5000)
.encryptionPassphraseSecret(passphrase)
.build())))
.build()))
.build());
csharp
EncodeConfiguration video;
EncodeConfiguration audio;
ISecret passphrase;
// SRT caller to a remote listener
OutputGroupConfiguration.Srt(new SrtOutputGroupProps {
Name = "srt_out",
Outputs = new [] { new SrtOutputDefinition {
Encodes = new [] { video, audio },
OutputName = "srt_caller",
Destinations = new [] { SrtDestination.Caller(new SrtCallerDestinationProps {
Address = "203.0.113.20",
Port = 5000,
EncryptionPassphraseSecret = passphrase
}) }
} }
});
// SRT listener — MediaLive waits for the downstream system to connect
OutputGroupConfiguration.Srt(new SrtOutputGroupProps {
Name = "srt_listen",
Outputs = new [] { new SrtOutputDefinition {
Encodes = new [] { video, audio },
OutputName = "srt_listener",
Destinations = new [] { SrtDestination.Listener(new SrtListenerDestinationProps {
ListenerPort = 5000,
EncryptionPassphraseSecret = passphrase
}) }
} }
});
go
var video EncodeConfiguration
var audio EncodeConfiguration
var passphrase ISecret
// SRT caller to a remote listener
medialive.OutputGroupConfiguration_Srt(&SrtOutputGroupProps{
Name: jsii.String("srt_out"),
Outputs: []SrtOutputDefinition{
&SrtOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("srt_caller"),
Destinations: []SrtDestination{
medialive.SrtDestination_Caller(&SrtCallerDestinationProps{
Address: jsii.String("203.0.113.20"),
Port: jsii.Number(5000),
EncryptionPassphraseSecret: passphrase,
}),
},
},
},
})
// SRT listener — MediaLive waits for the downstream system to connect
medialive.OutputGroupConfiguration_Srt(&SrtOutputGroupProps{
Name: jsii.String("srt_listen"),
Outputs: []SrtOutputDefinition{
&SrtOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("srt_listener"),
Destinations: []SrtDestination{
medialive.SrtDestination_Listener(&SrtListenerDestinationProps{
ListenerPort: jsii.Number(5000),
EncryptionPassphraseSecret: passphrase,
}),
},
},
},
})
AWS Elemental MediaConnect Router
mediaConnectRouter() delivers each channel pipeline to an AWS Elemental MediaConnect Router. Transit encryption defaults to AUTOMATIC; CDK derives one destination per pipeline from the channel class, so the common case needs no per-pipeline configuration. You must specify availabilityZones — exactly one for a SINGLE_PIPELINE channel, or two (one per pipeline) for STANDARD. The downstream wiring — which router input each pipeline feeds — is configured on the MediaConnect side, referencing this group's output by name and pipeline id.
ts
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
declare const passphrase: secretsmanager.ISecret;
declare const passphrase1: secretsmanager.ISecret;
// AUTOMATIC encryption on every pipeline (MPEG-TS container, like UDP)
medialive.OutputGroupConfiguration.mediaConnectRouter({
name: 'router_out',
availabilityZones: ['us-east-1a'],
outputs: [{ encodes: [video, audio], outputName: 'router_ts' }],
});
// One shared Secrets Manager passphrase across all pipelines (SECRETS_MANAGER encryption)
medialive.OutputGroupConfiguration.mediaConnectRouter({
name: 'router_out',
availabilityZones: ['us-east-1a'],
routerSettings: medialive.MediaConnectRouterSettings.shared({ encryptionSecret: passphrase }),
outputs: [{ encodes: [video, audio], outputName: 'router_ts' }],
});
// Distinct encryption per pipeline — an omitted pipeline stays AUTOMATIC (STANDARD channels)
medialive.OutputGroupConfiguration.mediaConnectRouter({
name: 'router_out',
availabilityZones: ['us-east-1a', 'us-east-1b'],
routerSettings: medialive.MediaConnectRouterSettings.perPipeline({
pipeline1: { encryptionSecret: passphrase1 },
}),
outputs: [{ encodes: [video, audio], outputName: 'router_ts' }],
});
python
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
# passphrase: secretsmanager.ISecret
# passphrase1: secretsmanager.ISecret
# AUTOMATIC encryption on every pipeline (MPEG-TS container, like UDP)
medialive.OutputGroupConfiguration.media_connect_router(
name="router_out",
availability_zones=["us-east-1a"],
outputs=[medialive.MediaConnectRouterOutputDefinition(encodes=[video, audio], output_name="router_ts")]
)
# One shared Secrets Manager passphrase across all pipelines (SECRETS_MANAGER encryption)
medialive.OutputGroupConfiguration.media_connect_router(
name="router_out",
availability_zones=["us-east-1a"],
router_settings=medialive.MediaConnectRouterSettings.shared(encryption_secret=passphrase),
outputs=[medialive.MediaConnectRouterOutputDefinition(encodes=[video, audio], output_name="router_ts")]
)
# Distinct encryption per pipeline — an omitted pipeline stays AUTOMATIC (STANDARD channels)
medialive.OutputGroupConfiguration.media_connect_router(
name="router_out",
availability_zones=["us-east-1a", "us-east-1b"],
router_settings=medialive.MediaConnectRouterSettings.per_pipeline(
pipeline1=medialive.MediaConnectRouterPipelineConfig(encryption_secret=passphrase1)
),
outputs=[medialive.MediaConnectRouterOutputDefinition(encodes=[video, audio], output_name="router_ts")]
)
java
EncodeConfiguration video;
EncodeConfiguration audio;
ISecret passphrase;
ISecret passphrase1;
// AUTOMATIC encryption on every pipeline (MPEG-TS container, like UDP)
OutputGroupConfiguration.mediaConnectRouter(MediaConnectRouterOutputGroupProps.builder()
.name("router_out")
.availabilityZones(List.of("us-east-1a"))
.outputs(List.of(MediaConnectRouterOutputDefinition.builder().encodes(List.of(video, audio)).outputName("router_ts").build()))
.build());
// One shared Secrets Manager passphrase across all pipelines (SECRETS_MANAGER encryption)
OutputGroupConfiguration.mediaConnectRouter(MediaConnectRouterOutputGroupProps.builder()
.name("router_out")
.availabilityZones(List.of("us-east-1a"))
.routerSettings(MediaConnectRouterSettings.shared(MediaConnectRouterPipelineConfig.builder().encryptionSecret(passphrase).build()))
.outputs(List.of(MediaConnectRouterOutputDefinition.builder().encodes(List.of(video, audio)).outputName("router_ts").build()))
.build());
// Distinct encryption per pipeline — an omitted pipeline stays AUTOMATIC (STANDARD channels)
OutputGroupConfiguration.mediaConnectRouter(MediaConnectRouterOutputGroupProps.builder()
.name("router_out")
.availabilityZones(List.of("us-east-1a", "us-east-1b"))
.routerSettings(MediaConnectRouterSettings.perPipeline(MediaConnectRouterPerPipelineSettings.builder()
.pipeline1(MediaConnectRouterPipelineConfig.builder().encryptionSecret(passphrase1).build())
.build()))
.outputs(List.of(MediaConnectRouterOutputDefinition.builder().encodes(List.of(video, audio)).outputName("router_ts").build()))
.build());
csharp
EncodeConfiguration video;
EncodeConfiguration audio;
ISecret passphrase;
ISecret passphrase1;
// AUTOMATIC encryption on every pipeline (MPEG-TS container, like UDP)
OutputGroupConfiguration.MediaConnectRouter(new MediaConnectRouterOutputGroupProps {
Name = "router_out",
AvailabilityZones = new [] { "us-east-1a" },
Outputs = new [] { new MediaConnectRouterOutputDefinition { Encodes = new [] { video, audio }, OutputName = "router_ts" } }
});
// One shared Secrets Manager passphrase across all pipelines (SECRETS_MANAGER encryption)
OutputGroupConfiguration.MediaConnectRouter(new MediaConnectRouterOutputGroupProps {
Name = "router_out",
AvailabilityZones = new [] { "us-east-1a" },
RouterSettings = MediaConnectRouterSettings.Shared(new MediaConnectRouterPipelineConfig { EncryptionSecret = passphrase }),
Outputs = new [] { new MediaConnectRouterOutputDefinition { Encodes = new [] { video, audio }, OutputName = "router_ts" } }
});
// Distinct encryption per pipeline — an omitted pipeline stays AUTOMATIC (STANDARD channels)
OutputGroupConfiguration.MediaConnectRouter(new MediaConnectRouterOutputGroupProps {
Name = "router_out",
AvailabilityZones = new [] { "us-east-1a", "us-east-1b" },
RouterSettings = MediaConnectRouterSettings.PerPipeline(new MediaConnectRouterPerPipelineSettings {
Pipeline1 = new MediaConnectRouterPipelineConfig { EncryptionSecret = passphrase1 }
}),
Outputs = new [] { new MediaConnectRouterOutputDefinition { Encodes = new [] { video, audio }, OutputName = "router_ts" } }
});
go
var video EncodeConfiguration
var audio EncodeConfiguration
var passphrase ISecret
var passphrase1 ISecret
// AUTOMATIC encryption on every pipeline (MPEG-TS container, like UDP)
medialive.OutputGroupConfiguration_MediaConnectRouter(&MediaConnectRouterOutputGroupProps{
Name: jsii.String("router_out"),
AvailabilityZones: []*string{
jsii.String("us-east-1a"),
},
Outputs: []MediaConnectRouterOutputDefinition{
&MediaConnectRouterOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("router_ts"),
},
},
})
// One shared Secrets Manager passphrase across all pipelines (SECRETS_MANAGER encryption)
medialive.OutputGroupConfiguration_MediaConnectRouter(&MediaConnectRouterOutputGroupProps{
Name: jsii.String("router_out"),
AvailabilityZones: []*string{
jsii.String("us-east-1a"),
},
RouterSettings: medialive.MediaConnectRouterSettings_Shared(&MediaConnectRouterPipelineConfig{
EncryptionSecret: passphrase,
}),
Outputs: []MediaConnectRouterOutputDefinition{
&MediaConnectRouterOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("router_ts"),
},
},
})
// Distinct encryption per pipeline — an omitted pipeline stays AUTOMATIC (STANDARD channels)
medialive.OutputGroupConfiguration_MediaConnectRouter(&MediaConnectRouterOutputGroupProps{
Name: jsii.String("router_out"),
AvailabilityZones: []*string{
jsii.String("us-east-1a"),
jsii.String("us-east-1b"),
},
RouterSettings: medialive.MediaConnectRouterSettings_PerPipeline(&MediaConnectRouterPerPipelineSettings{
Pipeline1: &MediaConnectRouterPipelineConfig{
EncryptionSecret: passphrase1,
},
}),
Outputs: []MediaConnectRouterOutputDefinition{
&MediaConnectRouterOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("router_ts"),
},
},
})
When a passphrase secret is supplied, the channel's IAM role is automatically granted read access to it.
UDP
UDP outputs deliver MPEG-TS over UDP or RTP. Use UdpOutputDestination.udp() for plain UDP or .rtp() for RTP (required if using FEC):
ts
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.udp({
name: 'udp_out',
destinations: [medialive.UdpOutputDestination.udp({ address: '203.0.113.5', port: 5000 })],
outputs: [{ encodes: [video, audio], outputName: 'ts_out' }],
});
python
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.udp(
name="udp_out",
destinations=[medialive.UdpOutputDestination.udp(address="203.0.113.5", port=5000)],
outputs=[medialive.UdpOutputDefinition(encodes=[video, audio], output_name="ts_out")]
)
java
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.udp(UdpOutputGroupProps.builder()
.name("udp_out")
.destinations(List.of(UdpOutputDestination.udp(TransportOutputDestinationProps.builder().address("203.0.113.5").port(5000).build())))
.outputs(List.of(UdpOutputDefinition.builder().encodes(List.of(video, audio)).outputName("ts_out").build()))
.build());
csharp
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.Udp(new UdpOutputGroupProps {
Name = "udp_out",
Destinations = new [] { UdpOutputDestination.Udp(new TransportOutputDestinationProps { Address = "203.0.113.5", Port = 5000 }) },
Outputs = new [] { new UdpOutputDefinition { Encodes = new [] { video, audio }, OutputName = "ts_out" } }
});
go
var video EncodeConfiguration
var audio EncodeConfiguration
medialive.OutputGroupConfiguration_Udp(&UdpOutputGroupProps{
Name: jsii.String("udp_out"),
Destinations: []UdpOutputDestination{
medialive.UdpOutputDestination_Udp(&TransportOutputDestinationProps{
Address: jsii.String("203.0.113.5"),
Port: jsii.Number(5000),
}),
},
Outputs: []UdpOutputDefinition{
&UdpOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("ts_out"),
},
},
})
Frame Capture
Frame capture outputs write periodic JPEG snapshots to S3:
ts
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.frameCapture({
name: 'thumbnails',
destinations: [medialive.S3OutputDestination.toBucket(bucket, 'thumbnails/live')],
outputs: [{ encodes: [video], outputName: 'thumb' }],
});
python
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.frame_capture(
name="thumbnails",
destinations=[medialive.S3OutputDestination.to_bucket(bucket, "thumbnails/live")],
outputs=[medialive.FrameCaptureOutputDefinition(encodes=[video], output_name="thumb")]
)
java
IBucket bucket;
EncodeConfiguration video;
OutputGroupConfiguration.frameCapture(FrameCaptureOutputGroupProps.builder()
.name("thumbnails")
.destinations(List.of(S3OutputDestination.toBucket(bucket, "thumbnails/live")))
.outputs(List.of(FrameCaptureOutputDefinition.builder().encodes(List.of(video)).outputName("thumb").build()))
.build());
csharp
IBucket bucket;
EncodeConfiguration video;
OutputGroupConfiguration.FrameCapture(new FrameCaptureOutputGroupProps {
Name = "thumbnails",
Destinations = new [] { S3OutputDestination.ToBucket(bucket, "thumbnails/live") },
Outputs = new [] { new FrameCaptureOutputDefinition { Encodes = new [] { video }, OutputName = "thumb" } }
});
go
var bucket IBucket
var video EncodeConfiguration
medialive.OutputGroupConfiguration_FrameCapture(&FrameCaptureOutputGroupProps{
Name: jsii.String("thumbnails"),
Destinations: []S3OutputDestination{
medialive.S3OutputDestination_ToBucket(bucket, jsii.String("thumbnails/live")),
},
Outputs: []FrameCaptureOutputDefinition{
&FrameCaptureOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("thumb"),
},
},
})
Microsoft Smooth Streaming
MS Smooth outputs push fragmented MP4 to an IIS Smooth Streaming endpoint:
ts
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.msSmooth({
name: 'smooth',
destinations: [medialive.OutputDestination.url('https://smooth.example.com/live')],
outputs: [{ encodes: [video, audio], outputName: 'smooth_out' }],
});
python
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.ms_smooth(
name="smooth",
destinations=[medialive.OutputDestination.url("https://smooth.example.com/live")],
outputs=[medialive.MsSmoothOutputDefinition(encodes=[video, audio], output_name="smooth_out")]
)
java
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.msSmooth(MsSmoothOutputGroupProps.builder()
.name("smooth")
.destinations(List.of(OutputDestination.url("https://smooth.example.com/live")))
.outputs(List.of(MsSmoothOutputDefinition.builder().encodes(List.of(video, audio)).outputName("smooth_out").build()))
.build());
csharp
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.MsSmooth(new MsSmoothOutputGroupProps {
Name = "smooth",
Destinations = new [] { OutputDestination.Url("https://smooth.example.com/live") },
Outputs = new [] { new MsSmoothOutputDefinition { Encodes = new [] { video, audio }, OutputName = "smooth_out" } }
});
go
var video EncodeConfiguration
var audio EncodeConfiguration
medialive.OutputGroupConfiguration_MsSmooth(&MsSmoothOutputGroupProps{
Name: jsii.String("smooth"),
Destinations: []OutputDestination{
medialive.OutputDestination_Url(jsii.String("https://smooth.example.com/live")),
},
Outputs: []MsSmoothOutputDefinition{
&MsSmoothOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("smooth_out"),
},
},
})
Per-output HLS settings
HLS outputs accept per-output hlsSettings via the HlsSettings factory — standard() for a video rendition (with optional M3u8Settings for the transport stream), audioOnly() for an audio rendition (with optional cover art as a FileLocation), fmp4(), or frameCapture().
ts
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [
{
encodes: [video],
outputName: 'video',
hlsSettings: medialive.HlsSettings.standard({
m3u8Settings: medialive.M3u8Settings.of({
scte35Behavior: medialive.M3u8Scte35Behavior.PASSTHROUGH,
programNum: 1,
}),
}),
},
{
encodes: [audio],
outputName: 'audio',
hlsSettings: medialive.HlsSettings.audioOnly({
audioGroupId: 'program',
audioOnlyImage: medialive.FileLocation.fromBucket(bucket, 'art/cover.png'),
}),
},
],
});
python
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(
encodes=[video],
output_name="video",
hls_settings=medialive.HlsSettings.standard(
m3u8_settings=medialive.M3u8Settings.of(
scte35_behavior=medialive.M3u8Scte35Behavior.PASSTHROUGH,
program_num=1
)
)
), medialive.HlsOutputDefinition(
encodes=[audio],
output_name="audio",
hls_settings=medialive.HlsSettings.audio_only(
audio_group_id="program",
audio_only_image=medialive.FileLocation.from_bucket(bucket, "art/cover.png")
)
)
]
)
java
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder()
.encodes(List.of(video))
.outputName("video")
.hlsSettings(HlsSettings.standard(StandardHlsSettingsProps.builder()
.m3u8Settings(M3u8Settings.of(M3u8SettingsProps.builder()
.scte35Behavior(M3u8Scte35Behavior.PASSTHROUGH)
.programNum(1)
.build()))
.build()))
.build(), HlsOutputDefinition.builder()
.encodes(List.of(audio))
.outputName("audio")
.hlsSettings(HlsSettings.audioOnly(AudioOnlyHlsSettingsProps.builder()
.audioGroupId("program")
.audioOnlyImage(FileLocation.fromBucket(bucket, "art/cover.png"))
.build()))
.build()))
.build());
csharp
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition {
Encodes = new [] { video },
OutputName = "video",
HlsSettings = HlsSettings.Standard(new StandardHlsSettingsProps {
M3u8Settings = M3u8Settings.Of(new M3u8SettingsProps {
Scte35Behavior = M3u8Scte35Behavior.PASSTHROUGH,
ProgramNum = 1
})
})
}, new HlsOutputDefinition {
Encodes = new [] { audio },
OutputName = "audio",
HlsSettings = HlsSettings.AudioOnly(new AudioOnlyHlsSettingsProps {
AudioGroupId = "program",
AudioOnlyImage = FileLocation.FromBucket(bucket, "art/cover.png")
})
} }
});
go
var bucket IBucket
var video EncodeConfiguration
var audio EncodeConfiguration
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("video"),
HlsSettings: medialive.HlsSettings_Standard(&StandardHlsSettingsProps{
M3u8Settings: medialive.M3u8Settings_Of(&M3u8SettingsProps{
Scte35Behavior: medialive.M3u8Scte35Behavior_PASSTHROUGH(),
ProgramNum: jsii.Number(1),
}),
}),
},
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
audio,
},
OutputName: jsii.String("audio"),
HlsSettings: medialive.HlsSettings_AudioOnly(&AudioOnlyHlsSettingsProps{
AudioGroupId: jsii.String("program"),
AudioOnlyImage: medialive.FileLocation_FromBucket(bucket, jsii.String("art/cover.png")),
}),
},
},
})
Forward Error Correction (UDP)
UDP outputs accept optional fec settings (SMPTE 2022-1) — column-only or column-and-row FEC. FEC requires an rtp:// destination:
ts
declare const video: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.udp({
name: 'udp',
destinations: [medialive.UdpOutputDestination.rtp({ address: '203.0.113.5', port: 5000 })],
outputs: [{
encodes: [video],
outputName: 'ts',
fec: { mode: medialive.FecMode.COLUMN_AND_ROW, columnDepth: 10, rowLength: 10 },
}],
});
python
# video: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.udp(
name="udp",
destinations=[medialive.UdpOutputDestination.rtp(address="203.0.113.5", port=5000)],
outputs=[medialive.UdpOutputDefinition(
encodes=[video],
output_name="ts",
fec=medialive.FecOutputSettings(mode=medialive.FecMode.COLUMN_AND_ROW, column_depth=10, row_length=10)
)]
)
java
EncodeConfiguration video;
OutputGroupConfiguration.udp(UdpOutputGroupProps.builder()
.name("udp")
.destinations(List.of(UdpOutputDestination.rtp(TransportOutputDestinationProps.builder().address("203.0.113.5").port(5000).build())))
.outputs(List.of(UdpOutputDefinition.builder()
.encodes(List.of(video))
.outputName("ts")
.fec(FecOutputSettings.builder().mode(FecMode.COLUMN_AND_ROW).columnDepth(10).rowLength(10).build())
.build()))
.build());
csharp
EncodeConfiguration video;
OutputGroupConfiguration.Udp(new UdpOutputGroupProps {
Name = "udp",
Destinations = new [] { UdpOutputDestination.Rtp(new TransportOutputDestinationProps { Address = "203.0.113.5", Port = 5000 }) },
Outputs = new [] { new UdpOutputDefinition {
Encodes = new [] { video },
OutputName = "ts",
Fec = new FecOutputSettings { Mode = FecMode.COLUMN_AND_ROW, ColumnDepth = 10, RowLength = 10 }
} }
});
go
var video EncodeConfiguration
medialive.OutputGroupConfiguration_Udp(&UdpOutputGroupProps{
Name: jsii.String("udp"),
Destinations: []UdpOutputDestination{
medialive.UdpOutputDestination_Rtp(&TransportOutputDestinationProps{
Address: jsii.String("203.0.113.5"),
Port: jsii.Number(5000),
}),
},
Outputs: []UdpOutputDefinition{
&UdpOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("ts"),
Fec: &FecOutputSettings{
Mode: medialive.FecMode_COLUMN_AND_ROW(),
ColumnDepth: jsii.Number(10),
RowLength: jsii.Number(10),
},
},
},
})
MPEG-TS Container Settings
The MPEG-TS output groups — udp(), archive(), srt(), and mediaConnectRouter() — accept optional per-output m2tsSettings via M2tsSettings.of(). Omit it to use MediaLive's service defaults. Bitrates use Bitrate, intervals use Duration, and closed-value fields use enums (e.g. M2tsRateMode, M2tsScte35Control); PID fields are strings that accept decimal, hexadecimal, ranges, or comma-separated lists.
ts
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
medialive.OutputGroupConfiguration.udp({
name: 'udp_out',
destinations: [medialive.UdpOutputDestination.udp({ address: '203.0.113.5', port: 5000 })],
outputs: [{
encodes: [video, audio],
outputName: 'ts',
m2tsSettings: medialive.M2tsSettings.of({
bitrate: Bitrate.mbps(8),
rateMode: medialive.M2tsRateMode.VBR,
programNum: 1,
patInterval: Duration.millis(100),
pmtInterval: Duration.millis(100),
scte35Control: medialive.M2tsScte35Control.PASSTHROUGH,
dvbSdtSettings: {
outputSdt: medialive.DvbSdtOutputMode.SDT_MANUAL,
serviceName: 'My Service',
repInterval: Duration.millis(2000),
},
}),
}],
});
python
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
medialive.OutputGroupConfiguration.udp(
name="udp_out",
destinations=[medialive.UdpOutputDestination.udp(address="203.0.113.5", port=5000)],
outputs=[medialive.UdpOutputDefinition(
encodes=[video, audio],
output_name="ts",
m2ts_settings=medialive.M2tsSettings.of(
bitrate=Bitrate.mbps(8),
rate_mode=medialive.M2tsRateMode.VBR,
program_num=1,
pat_interval=Duration.millis(100),
pmt_interval=Duration.millis(100),
scte35_control=medialive.M2tsScte35Control.PASSTHROUGH,
dvb_sdt_settings=medialive.DvbSdtSettings(
output_sdt=medialive.DvbSdtOutputMode.SDT_MANUAL,
service_name="My Service",
rep_interval=Duration.millis(2000)
)
)
)]
)
java
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.udp(UdpOutputGroupProps.builder()
.name("udp_out")
.destinations(List.of(UdpOutputDestination.udp(TransportOutputDestinationProps.builder().address("203.0.113.5").port(5000).build())))
.outputs(List.of(UdpOutputDefinition.builder()
.encodes(List.of(video, audio))
.outputName("ts")
.m2tsSettings(M2tsSettings.of(M2tsSettingsProps.builder()
.bitrate(Bitrate.mbps(8))
.rateMode(M2tsRateMode.VBR)
.programNum(1)
.patInterval(Duration.millis(100))
.pmtInterval(Duration.millis(100))
.scte35Control(M2tsScte35Control.PASSTHROUGH)
.dvbSdtSettings(DvbSdtSettings.builder()
.outputSdt(DvbSdtOutputMode.SDT_MANUAL)
.serviceName("My Service")
.repInterval(Duration.millis(2000))
.build())
.build()))
.build()))
.build());
csharp
EncodeConfiguration video;
EncodeConfiguration audio;
OutputGroupConfiguration.Udp(new UdpOutputGroupProps {
Name = "udp_out",
Destinations = new [] { UdpOutputDestination.Udp(new TransportOutputDestinationProps { Address = "203.0.113.5", Port = 5000 }) },
Outputs = new [] { new UdpOutputDefinition {
Encodes = new [] { video, audio },
OutputName = "ts",
M2tsSettings = M2tsSettings.Of(new M2tsSettingsProps {
Bitrate = Bitrate.Mbps(8),
RateMode = M2tsRateMode.VBR,
ProgramNum = 1,
PatInterval = Duration.Millis(100),
PmtInterval = Duration.Millis(100),
Scte35Control = M2tsScte35Control.PASSTHROUGH,
DvbSdtSettings = new DvbSdtSettings {
OutputSdt = DvbSdtOutputMode.SDT_MANUAL,
ServiceName = "My Service",
RepInterval = Duration.Millis(2000)
}
})
} }
});
go
var video EncodeConfiguration
var audio EncodeConfiguration
medialive.OutputGroupConfiguration_Udp(&UdpOutputGroupProps{
Name: jsii.String("udp_out"),
Destinations: []UdpOutputDestination{
medialive.UdpOutputDestination_Udp(&TransportOutputDestinationProps{
Address: jsii.String("203.0.113.5"),
Port: jsii.Number(5000),
}),
},
Outputs: []UdpOutputDefinition{
&UdpOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("ts"),
M2tsSettings: medialive.M2tsSettings_Of(&M2tsSettingsProps{
Bitrate: awscdk.Bitrate_Mbps(jsii.Number(8)),
RateMode: medialive.M2tsRateMode_VBR(),
ProgramNum: jsii.Number(1),
PatInterval: awscdk.Duration_Millis(jsii.Number(100)),
PmtInterval: awscdk.Duration_*Millis(jsii.Number(100)),
Scte35Control: medialive.M2tsScte35Control_PASSTHROUGH(),
DvbSdtSettings: &DvbSdtSettings{
OutputSdt: medialive.DvbSdtOutputMode_SDT_MANUAL(),
ServiceName: jsii.String("My Service"),
RepInterval: awscdk.Duration_*Millis(jsii.Number(2000)),
},
}),
},
},
})
Destinations
Each output group type uses a specific destination class. Destinations are created via static factory methods:
| Destination class | Factory methods | Used by |
|---|---|---|
OutputDestination | url(), toBucket() | HLS, MS Smooth, CMAF Ingest |
S3OutputDestination | url(), toBucket() | Archive, Frame Capture |
UdpOutputDestination | udp(), rtp(), url() | UDP |
MediaPackageV2Destination | channel() | MediaPackage V2 |
RtmpDestination | url() | RTMP |
SrtDestination | caller(), callerUrl(), listener() | SRT |
OutputDestination.toBucket() (and S3OutputDestination.toBucket()) build canonical s3ssl:// URLs and automatically grant the channel's IAM role the required S3 permissions; InputSource.fromBucket() does the same for input reads. MediaPackageV2Destination.channel() automatically grants ingest permissions on the MediaPackage V2 channel.
The MediaConnect Router output group has no destination class — its delivery is configured on the MediaConnect side. Per-pipeline transit encryption is set via the group's routerSettings prop using MediaConnectRouterSettings.shared() / .perPipeline() (see MediaConnect Router above).
Additional Destinations
MediaPackage V2 and CMAF Ingest output groups support additionalDestinations for cross-region delivery or backup packaging. These are separate from pipeline redundancy — they fan out the same content to extra endpoints.
The region for each destination is resolved automatically from the channel's stack. For cross-region imports, pass the region explicitly:
ts
declare const primaryChannel: mediapackagev2.IChannel;
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
// Import a channel from another region — the region travels with the channel
const backupChannel = mediapackagev2.Channel.fromChannelAttributes(this, 'BackupChannel', {
channelName: 'backup-channel',
channelGroupName: 'backup-group',
region: 'us-west-2',
});
medialive.OutputGroupConfiguration.mediaPackageV2({
name: 'emp',
channel: primaryChannel,
additionalDestinations: [
// Cross-region: the destination picks up us-west-2 from the imported channel
medialive.MediaPackageV2Destination.channel(backupChannel, medialive.MediaPackageV2EndpointId.ENDPOINT_1),
],
outputs: [
{ encode: video, outputName: 'video' },
{ encode: audio, outputName: 'audio' },
],
});
python
# primary_channel: mediapackagev2.IChannel
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
# Import a channel from another region — the region travels with the channel
backup_channel = mediapackagev2.Channel.from_channel_attributes(self, "BackupChannel",
channel_name="backup-channel",
channel_group_name="backup-group",
region="us-west-2"
)
medialive.OutputGroupConfiguration.media_package_v2(
name="emp",
channel=primary_channel,
additional_destinations=[
# Cross-region: the destination picks up us-west-2 from the imported channel
medialive.MediaPackageV2Destination.channel(backup_channel, medialive.MediaPackageV2EndpointId.ENDPOINT_1)
],
outputs=[medialive.MediaPackageV2OutputDefinition(encode=video, output_name="video"), medialive.MediaPackageV2OutputDefinition(encode=audio, output_name="audio")
]
)
java
IChannel primaryChannel;
EncodeConfiguration video;
EncodeConfiguration audio;
// Import a channel from another region — the region travels with the channel
IChannel backupChannel = Channel.fromChannelAttributes(this, "BackupChannel", ChannelAttributes.builder()
.channelName("backup-channel")
.channelGroupName("backup-group")
.region("us-west-2")
.build());
OutputGroupConfiguration.mediaPackageV2(MediaPackageV2OutputGroupProps.builder()
.name("emp")
.channel(primaryChannel)
.additionalDestinations(List.of(MediaPackageV2Destination.channel(backupChannel, MediaPackageV2EndpointId.ENDPOINT_1)))
.outputs(List.of(MediaPackageV2OutputDefinition.builder().encode(video).outputName("video").build(), MediaPackageV2OutputDefinition.builder().encode(audio).outputName("audio").build()))
.build());
csharp
IChannel primaryChannel;
EncodeConfiguration video;
EncodeConfiguration audio;
// Import a channel from another region — the region travels with the channel
var backupChannel = Channel.FromChannelAttributes(this, "BackupChannel", new ChannelAttributes {
ChannelName = "backup-channel",
ChannelGroupName = "backup-group",
Region = "us-west-2"
});
OutputGroupConfiguration.MediaPackageV2(new MediaPackageV2OutputGroupProps {
Name = "emp",
Channel = primaryChannel,
AdditionalDestinations = new [] { MediaPackageV2Destination.Channel(backupChannel, MediaPackageV2EndpointId.ENDPOINT_1) },
Outputs = new [] { new MediaPackageV2OutputDefinition { Encode = video, OutputName = "video" }, new MediaPackageV2OutputDefinition { Encode = audio, OutputName = "audio" } }
});
go
var primaryChannel IChannel
var video EncodeConfiguration
var audio EncodeConfiguration
// Import a channel from another region — the region travels with the channel
backupChannel := mediapackagev2.Channel_FromChannelAttributes(this, jsii.String("BackupChannel"), &ChannelAttributes{
ChannelName: jsii.String("backup-channel"),
ChannelGroupName: jsii.String("backup-group"),
Region: jsii.String("us-west-2"),
})
medialive.OutputGroupConfiguration_MediaPackageV2(&MediaPackageV2OutputGroupProps{
Name: jsii.String("emp"),
Channel: primaryChannel,
AdditionalDestinations: []MediaPackageV2Destination{
medialive.MediaPackageV2Destination_Channel(backupChannel, medialive.MediaPackageV2EndpointId_ENDPOINT_1()),
},
Outputs: []MediaPackageV2OutputDefinition{
&MediaPackageV2OutputDefinition{
Encode: video,
OutputName: jsii.String("video"),
},
&MediaPackageV2OutputDefinition{
Encode: audio,
OutputName: jsii.String("audio"),
},
},
})
Pipeline Redundancy
Channels default to SINGLE_PIPELINE. Set channelClass: ChannelClass.STANDARD for two-pipeline redundancy.
When using STANDARD:
- Each output group's
destinationsarray must have two entries —destinations[0]maps to Pipeline 0,destinations[1]maps to Pipeline 1. - For MediaPackage V2, use
ENDPOINT_1for Pipeline 0 andENDPOINT_2for Pipeline 1. additionalDestinationsare separate from pipeline redundancy — they fan out to extra endpoints.
ts
declare const stack: Stack;
declare const input: medialive.IInput;
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
new medialive.Channel(stack, 'StandardChannel', {
channelClass: medialive.ChannelClass.STANDARD,
inputs: [{ input }],
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [
medialive.OutputDestination.toBucket(bucket, 'live/pipeline0'),
medialive.OutputDestination.toBucket(bucket, 'live/pipeline1'),
],
outputs: [{ encodes: [video, audio], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# input: medialive.IInput
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
medialive.Channel(stack, "StandardChannel",
channel_class=medialive.ChannelClass.STANDARD,
inputs=[medialive.InputAttachment(input=input)],
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[
medialive.OutputDestination.to_bucket(bucket, "live/pipeline0"),
medialive.OutputDestination.to_bucket(bucket, "live/pipeline1")
],
outputs=[medialive.HlsOutputDefinition(encodes=[video, audio], output_name="hls_out")]
)
]
)
java
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
Channel.Builder.create(stack, "StandardChannel")
.channelClass(ChannelClass.STANDARD)
.inputs(List.of(InputAttachment.builder().input(input).build()))
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/pipeline0"), OutputDestination.toBucket(bucket, "live/pipeline1")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video, audio)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
EncodeConfiguration audio;
new Channel(stack, "StandardChannel", new ChannelProps {
ChannelClass = ChannelClass.STANDARD,
Inputs = new [] { new InputAttachment { Input = input } },
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/pipeline0"), OutputDestination.ToBucket(bucket, "live/pipeline1") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video, audio }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var input IInput
var bucket IBucket
var video EncodeConfiguration
var audio EncodeConfiguration
medialive.NewChannel(stack, jsii.String("StandardChannel"), &ChannelProps{
ChannelClass: medialive.ChannelClass_STANDARD(),
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/pipeline0")),
medialive.OutputDestination_*ToBucket(bucket, jsii.String("live/pipeline1")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
Input Attachment Settings
Each entry in inputs is an input attachment, which can carry per-input extraction and connection settings beyond the input itself.
Selectors pick specific tracks out of the input. Use AudioSelector (byLanguage(), byPid(), byTrack(), hlsRendition(), default()), CaptionSelector (byLanguage(), embedded(), ancillary(), dvbSub(), scte27(), teletext(), arib()), and videoSelector (color space, HDR10 metadata, and program/PID selection via VideoSelection). A caption encode then references a caption selector by name.
ts
declare const stack: Stack;
declare const input: medialive.IInput;
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
new medialive.Channel(stack, 'Channel', {
inputs: [{
input,
audioSelectors: [
medialive.AudioSelector.byLanguage('eng', 'eng', medialive.AudioLanguageSelectionPolicy.STRICT),
],
captionSelectors: [
medialive.CaptionSelector.embedded('embedded'),
],
videoSelector: {
colorSpace: medialive.VideoColorSpace.HDR10,
colorSpaceUsage: medialive.VideoColorSpaceUsage.FORCE,
selectBy: medialive.VideoSelection.byProgramId(1),
},
}],
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# input: medialive.IInput
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(
input=input,
audio_selectors=[
medialive.AudioSelector.by_language("eng", "eng", medialive.AudioLanguageSelectionPolicy.STRICT)
],
caption_selectors=[
medialive.CaptionSelector.embedded("embedded")
],
video_selector=medialive.VideoSelectorSettings(
color_space=medialive.VideoColorSpace.HDR10,
color_space_usage=medialive.VideoColorSpaceUsage.FORCE,
select_by=medialive.VideoSelection.by_program_id(1)
)
)],
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video], output_name="hls_out")]
)
]
)
java
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder()
.input(input)
.audioSelectors(List.of(AudioSelector.byLanguage("eng", "eng", AudioLanguageSelectionPolicy.STRICT)))
.captionSelectors(List.of(CaptionSelector.embedded("embedded")))
.videoSelector(VideoSelectorSettings.builder()
.colorSpace(VideoColorSpace.HDR10)
.colorSpaceUsage(VideoColorSpaceUsage.FORCE)
.selectBy(VideoSelection.byProgramId(1))
.build())
.build()))
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment {
Input = input,
AudioSelectors = new [] { AudioSelector.ByLanguage("eng", "eng", AudioLanguageSelectionPolicy.STRICT) },
CaptionSelectors = new [] { CaptionSelector.Embedded("embedded") },
VideoSelector = new VideoSelectorSettings {
ColorSpace = VideoColorSpace.HDR10,
ColorSpaceUsage = VideoColorSpaceUsage.FORCE,
SelectBy = VideoSelection.ByProgramId(1)
}
} },
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var input IInput
var bucket IBucket
var video EncodeConfiguration
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
AudioSelectors: []AudioSelector{
medialive.AudioSelector_ByLanguage(jsii.String("eng"), jsii.String("eng"), medialive.AudioLanguageSelectionPolicy_STRICT()),
},
CaptionSelectors: []CaptionSelector{
medialive.CaptionSelector_Embedded(jsii.String("embedded")),
},
VideoSelector: &VideoSelectorSettings{
ColorSpace: medialive.VideoColorSpace_HDR10(),
ColorSpaceUsage: medialive.VideoColorSpaceUsage_FORCE(),
SelectBy: medialive.VideoSelection_ByProgramId(jsii.Number(1)),
},
},
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
Network input settings apply to URL-pull and multicast inputs — HLS bandwidth/buffer/retry behaviour, the SCTE-35 source (HlsScte35Source.SEGMENTS or MANIFEST), HTTPS server validation, and a multicast source IP for source-specific multicast. logicalInterfaceNames maps the input to network interfaces on MediaLive Anywhere nodes.
ts
declare const stack: Stack;
declare const input: medialive.IInput;
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
new medialive.Channel(stack, 'Channel', {
inputs: [{
input,
networkInputSettings: {
serverValidation: medialive.ServerValidation.CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME,
hlsInputSettings: {
bandwidth: Bitrate.mbps(5),
scte35Source: medialive.HlsScte35Source.MANIFEST,
},
},
logicalInterfaceNames: ['eth0', 'eth1'],
}],
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# input: medialive.IInput
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(
input=input,
network_input_settings=medialive.NetworkInputSettings(
server_validation=medialive.ServerValidation.CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME,
hls_input_settings=medialive.HlsInputSettings(
bandwidth=Bitrate.mbps(5),
scte35_source=medialive.HlsScte35Source.MANIFEST
)
),
logical_interface_names=["eth0", "eth1"]
)],
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video], output_name="hls_out")]
)
]
)
java
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder()
.input(input)
.networkInputSettings(NetworkInputSettings.builder()
.serverValidation(ServerValidation.CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME)
.hlsInputSettings(HlsInputSettings.builder()
.bandwidth(Bitrate.mbps(5))
.scte35Source(HlsScte35Source.MANIFEST)
.build())
.build())
.logicalInterfaceNames(List.of("eth0", "eth1"))
.build()))
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment {
Input = input,
NetworkInputSettings = new NetworkInputSettings {
ServerValidation = ServerValidation.CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME,
HlsInputSettings = new HlsInputSettings {
Bandwidth = Bitrate.Mbps(5),
Scte35Source = HlsScte35Source.MANIFEST
}
},
LogicalInterfaceNames = new [] { "eth0", "eth1" }
} },
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var input IInput
var bucket IBucket
var video EncodeConfiguration
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
NetworkInputSettings: &NetworkInputSettings{
ServerValidation: medialive.ServerValidation_CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME(),
HlsInputSettings: &HlsInputSettings{
Bandwidth: awscdk.Bitrate_Mbps(jsii.Number(5)),
Scte35Source: medialive.HlsScte35Source_MANIFEST(),
},
},
LogicalInterfaceNames: []*string{
jsii.String("eth0"),
jsii.String("eth1"),
},
},
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
Automatic Input Failover
Automatic input failover gives you input-source redundancy: attach a secondary input, and MediaLive switches to it without restarting the channel when the active input meets a failover condition. This is separate from the pipeline redundancy of ChannelClass.STANDARD (which duplicates a single source across two pipelines).
Provide automaticInputFailover on the input attachment. If you don't specify conditions, a single input-loss condition is used:
ts
declare const stack: Stack;
declare const primaryInput: medialive.IInput;
declare const secondaryInput: medialive.IInput;
declare const audioSelector: medialive.AudioSelector;
declare const video: medialive.EncodeConfiguration;
declare const audio: medialive.EncodeConfiguration;
declare const bucket: s3.IBucket;
new medialive.Channel(stack, 'Channel', {
inputs: [{
input: primaryInput,
automaticInputFailover: {
secondaryInput,
inputPreference: medialive.InputPreference.PRIMARY_INPUT_PREFERRED,
errorClearTime: Duration.seconds(3),
failoverConditions: [
medialive.FailoverCondition.inputLoss({ threshold: Duration.millis(1500) }),
medialive.FailoverCondition.audioSilence({ audioSelector, threshold: Duration.seconds(2) }),
medialive.FailoverCondition.videoBlack({ blackDetectThreshold: 0.1, threshold: Duration.seconds(1) }),
],
},
}, {
// The secondary input must also be attached to the channel as its own input.
input: secondaryInput,
}],
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video, audio], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# primary_input: medialive.IInput
# secondary_input: medialive.IInput
# audio_selector: medialive.AudioSelector
# video: medialive.EncodeConfiguration
# audio: medialive.EncodeConfiguration
# bucket: s3.IBucket
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(
input=primary_input,
automatic_input_failover=medialive.AutomaticInputFailover(
secondary_input=secondary_input,
input_preference=medialive.InputPreference.PRIMARY_INPUT_PREFERRED,
error_clear_time=Duration.seconds(3),
failover_conditions=[
medialive.FailoverCondition.input_loss(threshold=Duration.millis(1500)),
medialive.FailoverCondition.audio_silence(audio_selector=audio_selector, threshold=Duration.seconds(2)),
medialive.FailoverCondition.video_black(black_detect_threshold=0.1, threshold=Duration.seconds(1))
]
)
), medialive.InputAttachment(
# The secondary input must also be attached to the channel as its own input.
input=secondary_input
)],
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video, audio], output_name="hls_out")]
)
]
)
java
Stack stack;
IInput primaryInput;
IInput secondaryInput;
AudioSelector audioSelector;
EncodeConfiguration video;
EncodeConfiguration audio;
IBucket bucket;
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder()
.input(primaryInput)
.automaticInputFailover(AutomaticInputFailover.builder()
.secondaryInput(secondaryInput)
.inputPreference(InputPreference.PRIMARY_INPUT_PREFERRED)
.errorClearTime(Duration.seconds(3))
.failoverConditions(List.of(FailoverCondition.inputLoss(InputLossFailoverProps.builder().threshold(Duration.millis(1500)).build()), FailoverCondition.audioSilence(AudioSilenceFailoverProps.builder().audioSelector(audioSelector).threshold(Duration.seconds(2)).build()), FailoverCondition.videoBlack(VideoBlackFailoverProps.builder().blackDetectThreshold(0.1).threshold(Duration.seconds(1)).build())))
.build())
.build(), InputAttachment.builder()
// The secondary input must also be attached to the channel as its own input.
.input(secondaryInput)
.build()))
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video, audio)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
IInput primaryInput;
IInput secondaryInput;
AudioSelector audioSelector;
EncodeConfiguration video;
EncodeConfiguration audio;
IBucket bucket;
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment {
Input = primaryInput,
AutomaticInputFailover = new AutomaticInputFailover {
SecondaryInput = secondaryInput,
InputPreference = InputPreference.PRIMARY_INPUT_PREFERRED,
ErrorClearTime = Duration.Seconds(3),
FailoverConditions = new [] { FailoverCondition.InputLoss(new InputLossFailoverProps { Threshold = Duration.Millis(1500) }), FailoverCondition.AudioSilence(new AudioSilenceFailoverProps { AudioSelector = audioSelector, Threshold = Duration.Seconds(2) }), FailoverCondition.VideoBlack(new VideoBlackFailoverProps { BlackDetectThreshold = 0.1, Threshold = Duration.Seconds(1) }) }
}
}, new InputAttachment {
// The secondary input must also be attached to the channel as its own input.
Input = secondaryInput
} },
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video, audio }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var primaryInput IInput
var secondaryInput IInput
var audioSelector AudioSelector
var video EncodeConfiguration
var audio EncodeConfiguration
var bucket IBucket
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: primaryInput,
AutomaticInputFailover: &AutomaticInputFailover{
SecondaryInput: *SecondaryInput,
InputPreference: medialive.InputPreference_PRIMARY_INPUT_PREFERRED(),
ErrorClearTime: awscdk.Duration_Seconds(jsii.Number(3)),
FailoverConditions: []FailoverCondition{
medialive.FailoverCondition_InputLoss(&InputLossFailoverProps{
Threshold: awscdk.Duration_Millis(jsii.Number(1500)),
}),
medialive.FailoverCondition_AudioSilence(&AudioSilenceFailoverProps{
AudioSelector: *AudioSelector,
Threshold: awscdk.Duration_*Seconds(jsii.Number(2)),
}),
medialive.FailoverCondition_VideoBlack(&VideoBlackFailoverProps{
BlackDetectThreshold: jsii.Number(0.1),
Threshold: awscdk.Duration_*Seconds(jsii.Number(1)),
}),
},
},
},
&InputAttachment{
// The secondary input must also be attached to the channel as its own input.
Input: secondaryInput,
},
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
audio,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
The primary and secondary inputs must have the same input class. The channel's IAM role is granted read access to the secondary input's sources automatically, just like the primary.
Ad Avail Handling
MediaLive can blank content during ad avails, insert blackout slates, and signal SCTE-35 ad avails to downstream systems. These are all channel-level props.
availBlanking replaces video/audio/captions with black (or an image) during an ad avail, and blackoutSlate shows a slate when a SCTE-35 blackout is signalled. Both image fields take a FileLocation.
ts
declare const stack: Stack;
declare const input: medialive.IInput;
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
new medialive.Channel(stack, 'Channel', {
inputs: [{ input }],
availBlanking: {
state: medialive.AvailBlankingState.ENABLED,
image: medialive.FileLocation.fromBucket(bucket, 'slates/avail.png'),
},
blackoutSlate: {
state: medialive.BlackoutSlateState.ENABLED,
image: medialive.FileLocation.fromBucket(bucket, 'slates/blackout.png'),
},
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# input: medialive.IInput
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(input=input)],
avail_blanking=medialive.AvailBlanking(
state=medialive.AvailBlankingState.ENABLED,
image=medialive.FileLocation.from_bucket(bucket, "slates/avail.png")
),
blackout_slate=medialive.BlackoutSlate(
state=medialive.BlackoutSlateState.ENABLED,
image=medialive.FileLocation.from_bucket(bucket, "slates/blackout.png")
),
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video], output_name="hls_out")]
)
]
)
java
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder().input(input).build()))
.availBlanking(AvailBlanking.builder()
.state(AvailBlankingState.ENABLED)
.image(FileLocation.fromBucket(bucket, "slates/avail.png"))
.build())
.blackoutSlate(BlackoutSlate.builder()
.state(BlackoutSlateState.ENABLED)
.image(FileLocation.fromBucket(bucket, "slates/blackout.png"))
.build())
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment { Input = input } },
AvailBlanking = new AvailBlanking {
State = AvailBlankingState.ENABLED,
Image = FileLocation.FromBucket(bucket, "slates/avail.png")
},
BlackoutSlate = new BlackoutSlate {
State = BlackoutSlateState.ENABLED,
Image = FileLocation.FromBucket(bucket, "slates/blackout.png")
},
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var input IInput
var bucket IBucket
var video EncodeConfiguration
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
AvailBlanking: &AvailBlanking{
State: medialive.AvailBlankingState_ENABLED(),
Image: medialive.FileLocation_FromBucket(bucket, jsii.String("slates/avail.png")),
},
BlackoutSlate: &BlackoutSlate{
State: medialive.BlackoutSlateState_ENABLED(),
Image: medialive.FileLocation_*FromBucket(bucket, jsii.String("slates/blackout.png")),
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
availSettings selects how SCTE-35 ad avails are handled — AvailSettings.spliceInsert(), AvailSettings.timeSignalApos(), or AvailSettings.esam() for Event Signaling and Management against an external POIS endpoint. scte35SegmentationScope controls which output groups receive the segmentation cues. The ESAM POIS password is supplied as an SSM parameter, and the channel role is granted read access to it automatically.
ts
import { StringParameter } from 'aws-cdk-lib/aws-ssm';
declare const stack: Stack;
declare const input: medialive.IInput;
declare const bucket: s3.IBucket;
declare const video: medialive.EncodeConfiguration;
declare const poisPassword: StringParameter;
new medialive.Channel(stack, 'Channel', {
inputs: [{ input }],
availSettings: medialive.AvailSettings.esam({
pois: {
url: 'https://pois.example.com/esam',
username: 'pois-user',
password: poisPassword,
},
acquisitionPointId: 'acquisition-point-1',
adAvailOffset: Duration.millis(200),
}),
scte35SegmentationScope: medialive.Scte35SegmentationScope.SCTE35_ENABLED_OUTPUT_GROUPS,
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video], outputName: 'hls_out' }],
}),
],
});
python
from aws_cdk.aws_ssm import StringParameter
# stack: Stack
# input: medialive.IInput
# bucket: s3.IBucket
# video: medialive.EncodeConfiguration
# pois_password: StringParameter
medialive.Channel(stack, "Channel",
inputs=[medialive.InputAttachment(input=input)],
avail_settings=medialive.AvailSettings.esam(
pois=medialive.PoisEndpoint(
url="https://pois.example.com/esam",
username="pois-user",
password=pois_password
),
acquisition_point_id="acquisition-point-1",
ad_avail_offset=Duration.millis(200)
),
scte35_segmentation_scope=medialive.Scte35SegmentationScope.SCTE35_ENABLED_OUTPUT_GROUPS,
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video], output_name="hls_out")]
)
]
)
java
import software.amazon.awscdk.services.ssm.StringParameter;
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
StringParameter poisPassword;
Channel.Builder.create(stack, "Channel")
.inputs(List.of(InputAttachment.builder().input(input).build()))
.availSettings(AvailSettings.esam(EsamSettings.builder()
.pois(PoisEndpoint.builder()
.url("https://pois.example.com/esam")
.username("pois-user")
.password(poisPassword)
.build())
.acquisitionPointId("acquisition-point-1")
.adAvailOffset(Duration.millis(200))
.build()))
.scte35SegmentationScope(Scte35SegmentationScope.SCTE35_ENABLED_OUTPUT_GROUPS)
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video)).outputName("hls_out").build()))
.build())))
.build();
csharp
using Amazon.CDK.AWS.SSM;
Stack stack;
IInput input;
IBucket bucket;
EncodeConfiguration video;
StringParameter poisPassword;
new Channel(stack, "Channel", new ChannelProps {
Inputs = new [] { new InputAttachment { Input = input } },
AvailSettings = AvailSettings.Esam(new EsamSettings {
Pois = new PoisEndpoint {
Url = "https://pois.example.com/esam",
Username = "pois-user",
Password = poisPassword
},
AcquisitionPointId = "acquisition-point-1",
AdAvailOffset = Duration.Millis(200)
}),
Scte35SegmentationScope = Scte35SegmentationScope.SCTE35_ENABLED_OUTPUT_GROUPS,
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video }, OutputName = "hls_out" } }
}) }
});
go
import "github.com/aws/aws-cdk-go/awscdk"
var stack Stack
var input IInput
var bucket IBucket
var video EncodeConfiguration
var poisPassword StringParameter
medialive.NewChannel(stack, jsii.String("Channel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
AvailSettings: medialive.AvailSettings_Esam(&EsamSettings{
Pois: &PoisEndpoint{
Url: jsii.String("https://pois.example.com/esam"),
Username: jsii.String("pois-user"),
Password: poisPassword,
},
AcquisitionPointId: jsii.String("acquisition-point-1"),
AdAvailOffset: awscdk.Duration_Millis(jsii.Number(200)),
}),
Scte35SegmentationScope: medialive.Scte35SegmentationScope_SCTE35_ENABLED_OUTPUT_GROUPS(),
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
Auto-Created Role and Grants
When no role is provided, the channel auto-creates an IAM role with the medialive.amazonaws.com service principal and grants it only the permissions your configuration actually needs. These automatic grants apply only to the channel-managed role; if you bring your own role, none are added.
Channel role grants — wired based on what you configure (channel-managed role only):
| Configuration | Grant | Scope |
|---|---|---|
OutputDestination.toBucket() | S3 read/write | The destination bucket/prefix |
InputSource.fromBucket() | S3 read | The input source bucket/prefix |
MediaPackageV2Destination.channel() | mediapackagev2:PutObject | The MediaPackage V2 channel |
SrtDestination with an encryption secret | Secrets Manager read | The secret |
| URL pull input with a password parameter | SSM parameter read | The parameter |
| Thumbnails (on by default) | s3:PutObject | * — uploads to an AWS service-owned bucket |
Channel logging (logLevel set) | CloudWatch Logs write | The ElementalMediaLive log group in your account/region |
VPC output (vpc set) | EC2 ENI create/delete + describe | Scoped to your subnets/SGs; Describe* requires * |
Input role grants — separate from the channel role, used at input create/delete time. Like the channel role, these are added only when the input auto-creates its role; pass a role to mediaConnect() or cdi() and no grants are added:
| Input type | Grant | Scope |
|---|---|---|
InputConfiguration.mediaConnect() | mediaconnect:ManagedDescribeFlow, ManagedAddOutput, ManagedRemoveOutput | * — service rejects flow-scoped grants |
InputConfiguration.cdi() | EC2 ENI create/delete + describe | Scoped to your subnets/SGs; Describe* requires * |
Both channel and input auto-created roles include confused-deputy prevention (aws:SourceAccount + aws:SourceArn conditions). For the full list of trusted-entity requirements, see the documentation.
The auto-created role is available on channel.role if you need to add further permissions.
Bringing your pre-defined role
When you pass a role, the channel makes no automatic grants — you will need to add the permissions that role needs. That covers both the principal policy and any referenced resource policies: S3 output destinations and input sources, Secrets Manager and SSM reads, MediaPackage V2 ingest, CloudWatch Logs, and VPC output ENI management. See the trusted-entity requirements, or pass the account's MediaLiveAccessRole — an IAM role that MediaLive can assume.
CloudWatch Metrics
Channels expose CloudWatch metric helpers in the AWS/MediaLive namespace, dimensioned by ChannelId and Pipeline. Use the named helpers below for the most common metrics, or metric(metricName, pipeline) to access any metric documented by the MediaLive metrics reference.
MediaLive publishes metrics per pipeline. Every helper takes a Pipeline argument so you make an explicit decision about which pipeline you're monitoring. STANDARD channels run two redundant pipelines (PIPELINE_0, PIPELINE_1) — alarm on both to cover the full channel. SINGLE_PIPELINE channels only publish on PIPELINE_0; passing PIPELINE_1 throws at synth time.
ts
declare const channel: medialive.Channel;
declare const stack: Stack;
channel.metricDroppedFrames(medialive.Pipeline.PIPELINE_0).createAlarm(stack, 'DroppedFrames', {
threshold: 1,
evaluationPeriods: 2,
});
channel.metricSvqTime(medialive.Pipeline.PIPELINE_0).createAlarm(stack, 'SvqTime', {
threshold: 0,
evaluationPeriods: 1,
});
// Custom metric by name with sum statistic
channel.metric('Output4xxErrors', medialive.Pipeline.PIPELINE_0, { statistic: 'sum' });
python
# channel: medialive.Channel
# stack: Stack
channel.metric_dropped_frames(medialive.Pipeline.PIPELINE_0).create_alarm(stack, "DroppedFrames",
threshold=1,
evaluation_periods=2
)
channel.metric_svq_time(medialive.Pipeline.PIPELINE_0).create_alarm(stack, "SvqTime",
threshold=0,
evaluation_periods=1
)
# Custom metric by name with sum statistic
channel.metric("Output4xxErrors", medialive.Pipeline.PIPELINE_0, statistic="sum")
java
Channel channel;
Stack stack;
channel.metricDroppedFrames(Pipeline.PIPELINE_0).createAlarm(stack, "DroppedFrames", CreateAlarmOptions.builder()
.threshold(1)
.evaluationPeriods(2)
.build());
channel.metricSvqTime(Pipeline.PIPELINE_0).createAlarm(stack, "SvqTime", CreateAlarmOptions.builder()
.threshold(0)
.evaluationPeriods(1)
.build());
// Custom metric by name with sum statistic
channel.metric("Output4xxErrors", Pipeline.PIPELINE_0, MetricOptions.builder().statistic("sum").build());
csharp
Channel channel;
Stack stack;
channel.MetricDroppedFrames(Pipeline.PIPELINE_0).CreateAlarm(stack, "DroppedFrames", new CreateAlarmOptions {
Threshold = 1,
EvaluationPeriods = 2
});
channel.MetricSvqTime(Pipeline.PIPELINE_0).CreateAlarm(stack, "SvqTime", new CreateAlarmOptions {
Threshold = 0,
EvaluationPeriods = 1
});
// Custom metric by name with sum statistic
channel.Metric("Output4xxErrors", Pipeline.PIPELINE_0, new MetricOptions { Statistic = "sum" });
go
var channel Channel
var stack Stack
channel.metricDroppedFrames(medialive.Pipeline_PIPELINE_0()).CreateAlarm(stack, jsii.String("DroppedFrames"), &CreateAlarmOptions{
Threshold: jsii.Number(1),
EvaluationPeriods: jsii.Number(2),
})
channel.metricSvqTime(medialive.Pipeline_PIPELINE_0()).CreateAlarm(stack, jsii.String("SvqTime"), &CreateAlarmOptions{
Threshold: jsii.Number(0),
EvaluationPeriods: jsii.Number(1),
})
// Custom metric by name with sum statistic
channel.metric(jsii.String("Output4xxErrors"), medialive.Pipeline_PIPELINE_0(), &MetricOptions{
Statistic: jsii.String("sum"),
})
For STANDARD channels, alarm on both pipelines:
ts
declare const standardChannel: medialive.Channel;
declare const stack: Stack;
standardChannel.metricDroppedFrames(medialive.Pipeline.PIPELINE_0).createAlarm(stack, 'Drops0', {
threshold: 1,
evaluationPeriods: 2,
});
standardChannel.metricDroppedFrames(medialive.Pipeline.PIPELINE_1).createAlarm(stack, 'Drops1', {
threshold: 1,
evaluationPeriods: 2,
});
python
# standard_channel: medialive.Channel
# stack: Stack
standard_channel.metric_dropped_frames(medialive.Pipeline.PIPELINE_0).create_alarm(stack, "Drops0",
threshold=1,
evaluation_periods=2
)
standard_channel.metric_dropped_frames(medialive.Pipeline.PIPELINE_1).create_alarm(stack, "Drops1",
threshold=1,
evaluation_periods=2
)
java
Channel standardChannel;
Stack stack;
standardChannel.metricDroppedFrames(Pipeline.PIPELINE_0).createAlarm(stack, "Drops0", CreateAlarmOptions.builder()
.threshold(1)
.evaluationPeriods(2)
.build());
standardChannel.metricDroppedFrames(Pipeline.PIPELINE_1).createAlarm(stack, "Drops1", CreateAlarmOptions.builder()
.threshold(1)
.evaluationPeriods(2)
.build());
csharp
Channel standardChannel;
Stack stack;
standardChannel.MetricDroppedFrames(Pipeline.PIPELINE_0).CreateAlarm(stack, "Drops0", new CreateAlarmOptions {
Threshold = 1,
EvaluationPeriods = 2
});
standardChannel.MetricDroppedFrames(Pipeline.PIPELINE_1).CreateAlarm(stack, "Drops1", new CreateAlarmOptions {
Threshold = 1,
EvaluationPeriods = 2
});
go
var standardChannel Channel
var stack Stack
standardChannel.metricDroppedFrames(medialive.Pipeline_PIPELINE_0()).CreateAlarm(stack, jsii.String("Drops0"), &CreateAlarmOptions{
Threshold: jsii.Number(1),
EvaluationPeriods: jsii.Number(2),
})
standardChannel.metricDroppedFrames(medialive.Pipeline_PIPELINE_1()).CreateAlarm(stack, jsii.String("Drops1"), &CreateAlarmOptions{
Threshold: jsii.Number(1),
EvaluationPeriods: jsii.Number(2),
})
Channel metrics
| Helper | Metric name | Default statistic | Notes |
|---|---|---|---|
metricActiveAlerts(pipeline) | ActiveAlerts | Max | Total active alerts on the channel |
metricNetworkIn(pipeline) | NetworkIn | Avg | Inbound traffic in Mbps |
metricNetworkOut(pipeline) | NetworkOut | Avg | Outbound traffic in Mbps |
metricInputVideoFrameRate(pipeline) | InputVideoFrameRate | Max | Source video frame rate |
metricFillMsec(pipeline) | FillMsec | Max | Time filled with fill frames — non-zero indicates input loss |
metricInputLossSeconds(pipeline) | InputLossSeconds | Sum | Seconds without packets (RTP / MediaConnect inputs) |
metricDroppedFrames(pipeline) | DroppedFrames | Sum | Frames dropped because the encoder fell behind |
metricSvqTime(pipeline) | SvqTime | Max | Percent of time MediaLive reduced quality to keep up |
metric(name, pipeline, props?) | (custom) | (caller-provided) | Build any metric in AWS/MediaLive |
The defaults match the AWS-recommended statistic for each metric. Pass props to override statistic, period, dimensions, or any other MetricOptions field.
MediaLive Anywhere
MediaLive Anywhere lets you run MediaLive channels on your own on-premises hardware.
Certain input types are only available with Anywhere channels (channels configured with anywhereSettings): SDI, SMPTE 2110 Receiver Group, and Multicast. Attempting to use these input types on a cloud channel will throw a validation error at synth time.
Network
A network defines IP address pools and routes for Anywhere resources:
ts
declare const stack: Stack;
const network = new medialive.Network(stack, 'Network', {
networkName: 'on-prem-network',
ipPools: ['10.0.0.0/24'],
routes: [{ cidr: '0.0.0.0/0', gateway: '10.0.0.1' }],
});
python
# stack: Stack
network = medialive.Network(stack, "Network",
network_name="on-prem-network",
ip_pools=["10.0.0.0/24"],
routes=[medialive.NetworkRoute(cidr="0.0.0.0/0", gateway="10.0.0.1")]
)
java
Stack stack;
Network network = Network.Builder.create(stack, "Network")
.networkName("on-prem-network")
.ipPools(List.of("10.0.0.0/24"))
.routes(List.of(NetworkRoute.builder().cidr("0.0.0.0/0").gateway("10.0.0.1").build()))
.build();
csharp
Stack stack;
var network = new Network(stack, "Network", new NetworkProps {
NetworkName = "on-prem-network",
IpPools = new [] { "10.0.0.0/24" },
Routes = new [] { new NetworkRoute { Cidr = "0.0.0.0/0", Gateway = "10.0.0.1" } }
});
go
var stack Stack
network := medialive.NewNetwork(stack, jsii.String("Network"), &NetworkProps{
NetworkName: jsii.String("on-prem-network"),
IpPools: []*string{
jsii.String("10.0.0.0/24"),
},
Routes: []NetworkRoute{
&NetworkRoute{
Cidr: jsii.String("0.0.0.0/0"),
Gateway: jsii.String("10.0.0.1"),
},
},
})
Cluster
A cluster represents a group of on-premises hardware nodes:
ts
declare const stack: Stack;
declare const instanceRole: iam.IRole;
const cluster = new medialive.Cluster(stack, 'Cluster', {
clusterName: 'on-prem-cluster',
clusterType: medialive.ClusterType.ON_PREMISES,
instanceRole,
});
python
# stack: Stack
# instance_role: iam.IRole
cluster = medialive.Cluster(stack, "Cluster",
cluster_name="on-prem-cluster",
cluster_type=medialive.ClusterType.ON_PREMISES,
instance_role=instance_role
)
java
Stack stack;
IRole instanceRole;
Cluster cluster = Cluster.Builder.create(stack, "Cluster")
.clusterName("on-prem-cluster")
.clusterType(ClusterType.ON_PREMISES)
.instanceRole(instanceRole)
.build();
csharp
Stack stack;
IRole instanceRole;
var cluster = new Cluster(stack, "Cluster", new ClusterProps {
ClusterName = "on-prem-cluster",
ClusterType = ClusterType.ON_PREMISES,
InstanceRole = instanceRole
});
go
var stack Stack
var instanceRole IRole
cluster := medialive.NewCluster(stack, jsii.String("Cluster"), &ClusterProps{
ClusterName: jsii.String("on-prem-cluster"),
ClusterType: medialive.ClusterType_ON_PREMISES(),
InstanceRole: InstanceRole,
})
Channel Placement Group
A channel placement group assigns channels to specific nodes within a cluster. Associate it with a channel via anywhereSettings:
ts
declare const stack: Stack;
declare const cluster: medialive.ICluster;
declare const input: medialive.IInput;
declare const video: medialive.EncodeConfiguration;
declare const bucket: s3.IBucket;
const cpg = new medialive.ChannelPlacementGroup(stack, 'CPG', {
channelPlacementGroupName: 'my-cpg',
cluster,
});
new medialive.Channel(stack, 'AnywhereChannel', {
inputs: [{ input }],
anywhereSettings: { cluster, channelPlacementGroup: cpg },
outputGroups: [
medialive.OutputGroupConfiguration.hls({
name: 'hls',
destinations: [medialive.OutputDestination.toBucket(bucket, 'live/stream')],
outputs: [{ encodes: [video], outputName: 'hls_out' }],
}),
],
});
python
# stack: Stack
# cluster: medialive.ICluster
# input: medialive.IInput
# video: medialive.EncodeConfiguration
# bucket: s3.IBucket
cpg = medialive.ChannelPlacementGroup(stack, "CPG",
channel_placement_group_name="my-cpg",
cluster=cluster
)
medialive.Channel(stack, "AnywhereChannel",
inputs=[medialive.InputAttachment(input=input)],
anywhere_settings=medialive.AnywhereSettings(cluster=cluster, channel_placement_group=cpg),
output_groups=[
medialive.OutputGroupConfiguration.hls(
name="hls",
destinations=[medialive.OutputDestination.to_bucket(bucket, "live/stream")],
outputs=[medialive.HlsOutputDefinition(encodes=[video], output_name="hls_out")]
)
]
)
java
Stack stack;
ICluster cluster;
IInput input;
EncodeConfiguration video;
IBucket bucket;
ChannelPlacementGroup cpg = ChannelPlacementGroup.Builder.create(stack, "CPG")
.channelPlacementGroupName("my-cpg")
.cluster(cluster)
.build();
Channel.Builder.create(stack, "AnywhereChannel")
.inputs(List.of(InputAttachment.builder().input(input).build()))
.anywhereSettings(AnywhereSettings.builder().cluster(cluster).channelPlacementGroup(cpg).build())
.outputGroups(List.of(OutputGroupConfiguration.hls(HlsOutputGroupProps.builder()
.name("hls")
.destinations(List.of(OutputDestination.toBucket(bucket, "live/stream")))
.outputs(List.of(HlsOutputDefinition.builder().encodes(List.of(video)).outputName("hls_out").build()))
.build())))
.build();
csharp
Stack stack;
ICluster cluster;
IInput input;
EncodeConfiguration video;
IBucket bucket;
var cpg = new ChannelPlacementGroup(stack, "CPG", new ChannelPlacementGroupProps {
ChannelPlacementGroupName = "my-cpg",
Cluster = cluster
});
new Channel(stack, "AnywhereChannel", new ChannelProps {
Inputs = new [] { new InputAttachment { Input = input } },
AnywhereSettings = new AnywhereSettings { Cluster = cluster, ChannelPlacementGroup = cpg },
OutputGroups = new [] { OutputGroupConfiguration.Hls(new HlsOutputGroupProps {
Name = "hls",
Destinations = new [] { OutputDestination.ToBucket(bucket, "live/stream") },
Outputs = new [] { new HlsOutputDefinition { Encodes = new [] { video }, OutputName = "hls_out" } }
}) }
});
go
var stack Stack
var cluster ICluster
var input IInput
var video EncodeConfiguration
var bucket IBucket
cpg := medialive.NewChannelPlacementGroup(stack, jsii.String("CPG"), &ChannelPlacementGroupProps{
ChannelPlacementGroupName: jsii.String("my-cpg"),
Cluster: Cluster,
})
medialive.NewChannel(stack, jsii.String("AnywhereChannel"), &ChannelProps{
Inputs: []InputAttachment{
&InputAttachment{
Input: *Input,
},
},
AnywhereSettings: &AnywhereSettings{
Cluster: *Cluster,
ChannelPlacementGroup: cpg,
},
OutputGroups: []OutputGroupConfiguration{
medialive.OutputGroupConfiguration_Hls(&HlsOutputGroupProps{
Name: jsii.String("hls"),
Destinations: []OutputDestination{
medialive.OutputDestination_ToBucket(bucket, jsii.String("live/stream")),
},
Outputs: []HlsOutputDefinition{
&HlsOutputDefinition{
Encodes: []EncodeConfiguration{
video,
},
OutputName: jsii.String("hls_out"),
},
},
}),
},
})
SDI Source
An SDI source represents a physical SDI input on Anywhere hardware:
ts
declare const stack: Stack;
const sdi = new medialive.SdiSource(stack, 'Sdi', {
sdiSourceName: 'camera-1',
type: medialive.SdiType.SINGLE,
});
python
# stack: Stack
sdi = medialive.SdiSource(stack, "Sdi",
sdi_source_name="camera-1",
type=medialive.SdiType.SINGLE
)
java
Stack stack;
SdiSource sdi = SdiSource.Builder.create(stack, "Sdi")
.sdiSourceName("camera-1")
.type(SdiType.SINGLE)
.build();
csharp
Stack stack;
var sdi = new SdiSource(stack, "Sdi", new SdiSourceProps {
SdiSourceName = "camera-1",
Type = SdiType.SINGLE
});
go
var stack Stack
sdi := medialive.NewSdiSource(stack, jsii.String("Sdi"), &SdiSourceProps{
SdiSourceName: jsii.String("camera-1"),
Type: medialive.SdiType_SINGLE(),
})
On-premises input networking
For inputs that live in an on-premises network, set inputNetworkLocation to InputNetworkLocation.ON_PREMISES. On-premises inputs do not use input security groups. Push inputs (RTMP/RTP/UDP) can pin their destination to a Network, declare the networkRoutes to reach it on the local network, and request a staticIpAddress:
ts
declare const stack: Stack;
const network = new medialive.Network(stack, 'Network', {
networkName: 'on-prem-network',
ipPools: ['192.168.1.0/24'],
});
new medialive.Input(stack, 'OnPremInput', {
inputName: 'on-prem-rtp',
inputNetworkLocation: medialive.InputNetworkLocation.ON_PREMISES,
input: medialive.InputConfiguration.rtpPush({
destinations: [{
network,
networkRoutes: [{ cidr: '10.0.0.0/24', gateway: '10.0.0.1' }],
staticIpAddress: '192.168.1.50',
}],
}),
});
python
# stack: Stack
network = medialive.Network(stack, "Network",
network_name="on-prem-network",
ip_pools=["192.168.1.0/24"]
)
medialive.Input(stack, "OnPremInput",
input_name="on-prem-rtp",
input_network_location=medialive.InputNetworkLocation.ON_PREMISES,
input=medialive.InputConfiguration.rtp_push(
destinations=[medialive.PushInputDestination(
network=network,
network_routes=[medialive.NetworkRoute(cidr="10.0.0.0/24", gateway="10.0.0.1")],
static_ip_address="192.168.1.50"
)]
)
)
java
Stack stack;
Network network = Network.Builder.create(stack, "Network")
.networkName("on-prem-network")
.ipPools(List.of("192.168.1.0/24"))
.build();
Input.Builder.create(stack, "OnPremInput")
.inputName("on-prem-rtp")
.inputNetworkLocation(InputNetworkLocation.ON_PREMISES)
.input(InputConfiguration.rtpPush(PushInputProps.builder()
.destinations(List.of(PushInputDestination.builder()
.network(network)
.networkRoutes(List.of(NetworkRoute.builder().cidr("10.0.0.0/24").gateway("10.0.0.1").build()))
.staticIpAddress("192.168.1.50")
.build()))
.build()))
.build();
csharp
Stack stack;
var network = new Network(stack, "Network", new NetworkProps {
NetworkName = "on-prem-network",
IpPools = new [] { "192.168.1.0/24" }
});
new Input(stack, "OnPremInput", new InputProps {
InputName = "on-prem-rtp",
InputNetworkLocation = InputNetworkLocation.ON_PREMISES,
Input = InputConfiguration.RtpPush(new PushInputProps {
Destinations = new [] { new PushInputDestination {
Network = network,
NetworkRoutes = new [] { new NetworkRoute { Cidr = "10.0.0.0/24", Gateway = "10.0.0.1" } },
StaticIpAddress = "192.168.1.50"
} }
})
});
go
var stack Stack
network := medialive.NewNetwork(stack, jsii.String("Network"), &NetworkProps{
NetworkName: jsii.String("on-prem-network"),
IpPools: []*string{
jsii.String("192.168.1.0/24"),
},
})
medialive.NewInput(stack, jsii.String("OnPremInput"), &InputProps{
InputName: jsii.String("on-prem-rtp"),
InputNetworkLocation: medialive.InputNetworkLocation_ON_PREMISES(),
Input: medialive.InputConfiguration_RtpPush(&PushInputProps{
Destinations: []PushInputDestination{
&PushInputDestination{
Network: *Network,
NetworkRoutes: []NetworkRoute{
&NetworkRoute{
Cidr: jsii.String("10.0.0.0/24"),
Gateway: jsii.String("10.0.0.1"),
},
},
StaticIpAddress: jsii.String("192.168.1.50"),
},
},
}),
})
SRT listener inputs accept a streamId that the upstream system uses when connecting:
ts
declare const stack: Stack;
declare const sg: medialive.IInputSecurityGroup;
new medialive.Input(stack, 'SrtListener', {
inputName: 'srt-listener',
input: medialive.InputConfiguration.srtListener({
inputSecurityGroups: [sg],
streamId: 'my-stream-id',
}),
});
python
# stack: Stack
# sg: medialive.IInputSecurityGroup
medialive.Input(stack, "SrtListener",
input_name="srt-listener",
input=medialive.InputConfiguration.srt_listener(
input_security_groups=[sg],
stream_id="my-stream-id"
)
)
java
Stack stack;
IInputSecurityGroup sg;
Input.Builder.create(stack, "SrtListener")
.inputName("srt-listener")
.input(InputConfiguration.srtListener(SrtListenerInputProps.builder()
.inputSecurityGroups(List.of(sg))
.streamId("my-stream-id")
.build()))
.build();
csharp
Stack stack;
IInputSecurityGroup sg;
new Input(stack, "SrtListener", new InputProps {
InputName = "srt-listener",
Input = InputConfiguration.SrtListener(new SrtListenerInputProps {
InputSecurityGroups = new [] { sg },
StreamId = "my-stream-id"
})
});
go
var stack Stack
var sg IInputSecurityGroup
medialive.NewInput(stack, jsii.String("SrtListener"), &InputProps{
InputName: jsii.String("srt-listener"),
Input: medialive.InputConfiguration_SrtListener(&SrtListenerInputProps{
InputSecurityGroups: []IInputSecurityGroupRef{
sg,
},
StreamId: jsii.String("my-stream-id"),
}),
})
Types
| Name | Kind | Summary |
|---|---|---|
Channel | Construct (L2) | Defines an AWS Elemental MediaLive Channel. |
ChannelPlacementGroup | Construct (L2) | Defines an AWS Elemental MediaLive Channel Placement Group. |
Cluster | Construct (L2) | Defines an AWS Elemental MediaLive Cluster. |
Input | Construct (L2) | Defines an AWS Elemental MediaLive Input. |
InputSecurityGroup | Construct (L2) | Defines an AWS Elemental MediaLive Input Security Group. |
Network | Construct (L2) | Defines an AWS Elemental MediaLive Network. |
SdiSource | Construct (L2) | Defines an AWS Elemental MediaLive SDI Source. |
AacCodingMode | Class | AAC coding mode. |
AacInputType | Class | AAC input type. |
AacProfile | Class | AAC profile. |
AacRateControlMode | Class | AAC rate control mode. |
AacRawFormat | Class | AAC raw format. |
AacSettingsProps | Struct | Properties for AAC codec settings. |
AacSpec | Class | AAC specification. |
AacVbrQuality | Class | AAC VBR quality level. |
Ac3AttenuationControl | Class | AC3 attenuation control. |
Ac3BitstreamMode | Class | AC3 bitstream mode. |
Ac3CodingMode | Class | AC3 coding mode. |
Ac3DrcProfile | Class | AC3 DRC profile. |
Ac3LfeFilter | Class | AC3 LFE filter. |
Ac3MetadataControl | Class | AC3 metadata control. |
Ac3SettingsProps | Struct | Properties for AC3 codec settings. |
AfdSignaling | Class | AFD signaling mode. |
AncillaryCaptionSourceOptions | Struct | Options for an ancillary caption source. |
AnywhereSettings | Struct | Anywhere settings for running the channel on AWS Elemental Anywhere. |
ArchiveContainer | Class | The container (transport stream) for an Archive output. |
ArchiveOutputDefinition | Struct | Output definition for an Archive output group. |
ArchiveOutputGroupProps | Struct | Properties for an Archive (S3) output group. |
AudioBitDepth | Class | Audio bit depth for WAV codec. |
AudioChannelMapping | Struct | A mapping from input channels to an output channel. |
AudioCodecSettings | Class | Audio codec settings. |
AudioDashRole | Class | A DASH role to assign to an audio output (used when the output carries DVB DASH accessibility signaling). |
AudioEncodeProps | Struct | Properties for an audio encode configuration. |
AudioLanguageCodeControl | Class | Determines how the audio language code is signaled in the output. |
AudioLanguageSelectionPolicy | Class | Policy for how MediaLive identifies the audio stream when selecting by language, on a transport-stream PMT update. |
AudioNormalizationAlgorithm | Class | Audio normalization algorithm. |
AudioNormalizationAlgorithmControl | Class | Audio normalization algorithm control. |
AudioNormalizationPeakCalculation | Class | Peak calculation method for audio normalization. |
AudioNormalizationSettings | Struct | Audio normalization settings. |
AudioOnlyHlsSettingsProps | Struct | Properties for audio-only HLS settings. |
AudioPidConfig | Struct | Configuration for a single audio PID in a PID-based selector. |
AudioPreMixerSettings | Class | Audio pre-mixer settings for normalizing audio before interleaving. |
AudioPreMixerSettingsProps | Struct | Properties for audio pre-mixer settings. |
AudioSampleRate | Class | Audio sample rate for AAC, MP2, and WAV codecs. |
AudioSelector | Class | An audio selector that identifies which audio to extract from the input. |
AudioSilenceFailoverProps | Struct | Properties for an audio-silence failover condition. |
AudioTrackConfig | Struct | Configuration for a single audio track in a track-based selector. |
AudioType | Class | The audio type, as defined in ISO/IEC 13818-1. |
AudioTypeControl | Class | Determines how the audio type is signaled in the output. |
AudioWatermarkSettings | Struct | Audio watermarking settings. |
AutomaticInputFailover | Struct | Automatic input failover configuration for an input attachment. |
Av1BitDepth | Class | AV1 bit depth. |
Av1ColorSpaceSettings | Class | Color space settings for AV1 video. |
Av1Level | Class | AV1 level. |
Av1RateControl | Class | AV1 rate control. |
Av1SceneChangeDetect | Class | AV1 scene change detection. |
Av1SettingsProps | Struct | Properties for AV1 codec settings. |
Av1SpatialAq | Class | AV1 spatial adaptive quantization. |
Av1TemporalAq | Class | AV1 temporal adaptive quantization. |
Av1TimecodeInsertion | Class | AV1 timecode insertion. |
AvailBlanking | Struct | Settings for blanking video, audio, and captions during ad avails. |
AvailBlankingState | Class | Avail blanking state. |
AvailSettings | Class | Avail settings — how SCTE-35 ad avail markers are handled. |
BandwidthReductionFilterProps | Struct | Properties for a bandwidth reduction filter. |
BandwidthReductionPostFilterSharpening | Class | Post-filter sharpening for bandwidth reduction filter. |
BandwidthReductionStrength | Class | Bandwidth reduction filter strength. |
BlackoutSlate | Struct | Blackout slate configuration for the channel. |
BlackoutSlateState | Class | Blackout slate state. |
BurnInDestinationProps | Struct | Properties for burn-in captions. |
CaptionAccessibility | Class | Whether a caption track implements accessibility features (written descriptions of dialog, music, and sounds). |
CaptionAlignment | Class | Caption alignment for burn-in and DVB-Sub outputs. |
CaptionBackgroundColor | Class | Background color for burn-in and DVB-Sub captions. |
CaptionDashRole | Class | A DASH role to assign to a captions output (used when the output carries DVB DASH accessibility signaling). |
CaptionDestination | Class | The output caption format for a caption encode. |
CaptionEncodeProps | Struct | Properties for a caption encode configuration. |
CaptionFontColor | Class | Font color for burn-in and DVB-Sub captions. |
CaptionFontSize | Class | Font size for burn-in and DVB-Sub captions. |
CaptionFontStyleProps | Struct | Font and positioning settings for a rendered caption output (burn-in or DVB-Sub). |
CaptionLanguageMapping | Struct | Maps a captions channel to an ISO 693-2 language code. |
CaptionOutlineColor | Class | Font outline color for burn-in and DVB-Sub captions. |
CaptionRectangle | Struct | A display rectangle, expressed as percentages of the underlying video frame, for captions converted to EBU-TT-D or TTML. |
CaptionSelector | Class | A caption selector that identifies which captions to extract from the input. |
CaptionShadowColor | Class | Shadow color for burn-in and DVB-Sub captions. |
CaptionSynchronizationMode | Class | Controls whether MediaLive delays video to synchronize captions with audio and video output. |
CaptionTeletextGridControl | Class | Controls whether a fixed grid is used to generate the subtitle bitmap (Teletext input). |
CbrRateControlProps | Struct | Properties for CBR rate control. |
CdiInputProps | Struct | Properties for a CDI (uncompressed) input. |
CdiInputResolution | Class | Maximum CDI input resolution. |
CdiInputSpecificationProps | Struct | Properties for a CDI input specification. |
ChannelClass | Class | The class of the channel. |
ChannelGrants | Facade | Collection of grant methods for a IChannelRef. |
ChannelPlacementGroupAttributes | Struct | Attributes for importing an existing Channel Placement Group. |
ChannelPlacementGroupProps | Struct | Properties for creating a MediaLive Channel Placement Group. |
ChannelProps | Struct | Properties for creating a MediaLive Channel. |
ClusterNetworkSettings | Struct | Network settings for a MediaLive Cluster. |
ClusterProps | Struct | Properties for creating a MediaLive Cluster. |
ClusterType | Class | The hardware type for the cluster. |
CmafCaptionLanguageMapping | Struct | Maps a captions channel to an ISO 639-2 language code for a CMAF Ingest output group. |
CmafIngestOutputDefinition | Struct | Output definition for a CMAF Ingest output group. |
CmafIngestOutputGroupProps | Struct | Properties for a CMAF Ingest output group. |
ColorCorrection | Struct | A color space correction rule. |
ColorMetadata | Class | Color metadata inclusion. |
ColorSpace | Class | A color space supported for 3D-LUT color conversion in a color-correction rule. |
Convert608To708 | Class | Whether to upconvert 608 captions to 708. |
DolbyEProgramSelection | Class | Which Dolby E program to decode from a selected audio track. |
DvbDashAccessibility | Class | DVB DASH accessibility signaling for an audio output. |
DvbNitSettings | Struct | Settings for inserting a DVB Network Information Table (NIT). |
DvbSdtOutputMode | Class | How DVB Service Description Table (SDT) information is inserted. |
DvbSdtSettings | Struct | Settings for inserting a DVB Service Description Table (SDT). |
DvbSubCaptionSourceOptions | Struct | Options for a DVB-Sub caption source. |
DvbSubDestinationProps | Struct | Properties for DVB-Sub captions. |
DvbTdtSettings | Struct | Settings for inserting a DVB Time and Date Table (TDT). |
Eac3AtmosCodingMode | Class | EAC3 Atmos coding mode. |
Eac3AtmosDrcLine | Class | EAC3 Atmos DRC line mode profile. |
Eac3AtmosDrcRf | Class | EAC3 Atmos DRC RF mode profile. |
Eac3AtmosSettingsProps | Struct | Properties for EAC3 Atmos codec settings. |
Eac3AttenuationControl | Class | EAC3 attenuation control. |
Eac3BitstreamMode | Class | EAC3 bitstream mode. |
Eac3CodingMode | Class | EAC3 coding mode. |
Eac3DcFilter | Class | EAC3 DC filter. |
Eac3DrcLine | Class | EAC3 DRC line mode profile. |
Eac3DrcRf | Class | EAC3 DRC RF mode profile. |
Eac3LfeControl | Class | EAC3 LFE control. |
Eac3LfeFilter | Class | EAC3 LFE filter. |
Eac3MetadataControl | Class | EAC3 metadata control. |
Eac3PassthroughControl | Class | EAC3 passthrough control. |
Eac3PhaseControl | Class | EAC3 phase control. |
Eac3SettingsProps | Struct | Properties for EAC3 codec settings. |
Eac3StereoDownmix | Class | EAC3 stereo downmix preference. |
Eac3SurroundExMode | Class | EAC3 surround ex mode. |
Eac3SurroundMode | Class | EAC3 surround mode. |
EbuTtDDestinationProps | Struct | Properties for EBU-TT-D caption output. |
EbuTtDFillLineGap | Class | Whether EBU-TT-D fills the gap between multi-line captions. |
EbuTtDStyleControl | Class | Whether EBU-TT-D includes source style information. |
EmbeddedCaptionSourceOptions | Struct | Options for an embedded (CEA-608/708) caption source. |
EncodeConfiguration | Class | Base interface for an encode configuration (video, audio, or caption). |
EpochOutputLockingProps | Struct | Properties for epoch output locking. |
EsamSettings | Struct | Settings for ESAM (Event Signaling and Management) ad avail handling. |
FailoverCondition | Class | A condition that, when met on the active input, triggers automatic input failover to the secondary input. |
FeatureActivations | Struct | Feature activations for the channel. |
FeatureActivationState | Class | Feature activation state. |
FecMode | Class | Enables column-only or column-and-row FEC for a UDP output. |
FecOutputSettings | Struct | Forward Error Correction (FEC) settings for a UDP output (SMPTE 2022-1). |
FileLocation | Class | A reference to a file MediaLive reads at runtime — for example an input-loss slate image, an avail-blanking image, a burn-in caption font, or a color-correction LUT. |
FileLocationOptions | Struct | Options for a URL-based file location (FileLocation.url). |
FlickerAq | Class | Flicker adaptive quantization. |
Fmp4HlsSettingsProps | Struct | Properties for fMP4 HLS settings. |
FrameCaptureOutputDefinition | Struct | Output definition for a Frame Capture output group. |
FrameCaptureOutputGroupProps | Struct | Properties for a Frame Capture output group. |
FrameCaptureSettingsProps | Struct | Properties for frame capture codec settings. |
Framerate | Class | A video frame rate expressed as a rational number (numerator/denominator). |
GlobalConfiguration | Struct | Global configuration settings that apply to the entire channel. |
GopBReference | Class | GOP B-frame reference. |
GopSize | Class | GOP size (keyframe interval). Use the static factory methods to specify in frames or seconds. |
H264AdaptiveQuantization | Class | H.264 adaptive quantization strength. |
H264ColorSpaceSettings | Class | Color space settings for H.264 video. |
H264EntropyEncoding | Class | H.264 entropy encoding mode. |
H264FilterSettings | Class | Filter settings for H.264 video. Supports temporal filter and bandwidth reduction filter. |
H264ForceFieldPictures | Class | H.264 force field pictures. |
H264Level | Class | H.264 level. |
H264Profile | Class | H.264 profile. |
H264QualityLevel | Class | H.264 quality level. |
H264RateControl | Class | H.264 rate control. Use the static factory methods to create. |
H264SceneChangeDetect | Class | H.264 scene change detection. |
H264SettingsProps | Struct | Properties for H.264 codec settings. |
H264SpatialAq | Class | H.264 spatial adaptive quantization. |
H264Syntax | Class | H.264 syntax mode. |
H264TemporalAq | Class | H.264 temporal adaptive quantization. |
H265AdaptiveQuantization | Class | H.265 adaptive quantization. |
H265AlternativeTransferFunction | Class | H.265 alternative transfer function. |
H265ColorSpaceSettings | Class | Color space settings for H.265 video. |
H265Deblocking | Class | H.265 deblocking filter. |
H265FilterSettings | Class | Filter settings for H.265 video. Supports temporal filter and bandwidth reduction filter. |
H265Level | Class | H.265 level. |
H265MvOverPictureBoundaries | Class | H.265 motion vector over picture boundaries. |
H265MvTemporalPredictor | Class | H.265 motion vector temporal predictor. |
H265PackagingType | Class | H.265 packaging type for HLS/MS Smooth outputs. |
H265Profile | Class | H.265 profile. |
H265RateControl | Class | H.265 rate control. Use the static factory methods to create. |
H265SceneChangeDetect | Class | H.265 scene change detection. |
H265SettingsProps | Struct | Properties for H.265 codec settings. |
H265Tier | Class | H.265 tier. |
H265TilePadding | Class | H.265 tile padding. |
H265TreeblockSize | Class | H.265 treeblock size. |
Hdr10Settings | Struct | HDR10 color space metadata for the input video. |
Hdr10SettingsProps | Struct | Properties for HDR10 color space settings. |
HlsAdMarkers | Class | Ad marker type for an HLS output group. |
HlsAkamaiCdnProps | Struct | Properties for HLS Akamai CDN settings. |
HlsAudioOnlySegmentType | Class | The segment container type for an audio-only HLS output. |
HlsAudioTrackType | Class | The audio track type for an audio-only HLS output. |
HlsBasicPutCdnProps | Struct | Properties for HLS Basic PUT CDN settings. |
HlsCaptionLanguageSetting | Class | HLS caption language setting. |
HlsCdnSettings | Class | CDN settings for HLS output groups. |
HlsClientCache | Class | HLS client cache control. |
HlsCodecSpecification | Class | HLS codec specification. |
HlsDirectoryStructure | Class | HLS directory structure. |
HlsDiscontinuityTags | Class | HLS discontinuity tags. |
HlsEncryptionType | Class | HLS encryption type. |
HlsId3SegmentTaggingState | Class | HLS ID3 segment tagging state. |
HlsIFrameOnlyPlaylists | Class | HLS I-frame only playlists. |
HlsIncompleteSegmentBehavior | Class | HLS incomplete segment behavior. |
HlsInputLossAction | Class | HLS input loss action. |
HlsInputSettings | Struct | HLS input settings for URL pull inputs. |
HlsIvInManifest | Class | HLS IV in manifest. |
HlsIvSource | Class | HLS IV source. |
HlsKeyProviderSettings | Class | Key provider settings for HLS encryption. |
HlsManifestCompression | Class | HLS manifest compression. |
HlsManifestDurationFormat | Class | HLS manifest duration format. |
HlsMode | Class | HLS output mode. |
HlsOutputDefinition | Struct | Output definition for an HLS output group. |
HlsOutputGroupProps | Struct | Properties for an HLS output group. |
HlsOutputSelection | Class | HLS output selection. |
HlsProgramDateTime | Class | HLS program date time. |
HlsProgramDateTimeClock | Class | HLS program date time clock. |
HlsRedundantManifest | Class | HLS redundant manifest. |
HlsRenditionSelectionOptions | Struct | Options for selecting an HLS audio rendition. |
HlsS3CdnProps | Struct | Properties for HLS S3 CDN settings. |
HlsScte35Source | Class | The source MediaLive ingests SCTE-35 messages from for an HLS input. |
HlsSegmentationMode | Class | HLS segmentation mode. |
HlsSettings | Class | Per-output HLS settings. |
HlsStaticKeyProps | Struct | Properties for HLS static key encryption. |
HlsStreamInfResolution | Class | HLS stream inf resolution. |
HlsTimedMetadataId3Frame | Class | HLS timed metadata ID3 frame. |
HlsTsFileMode | Class | HLS TS file mode. |
HlsWebdavCdnProps | Struct | Properties for HLS WebDAV CDN settings. |
HttpTransferMode | Class | Whether to use chunked transfer encoding for an HLS CDN connection (Akamai, WebDAV). |
IChannel | Interface | Represents a MediaLive Channel. |
IChannelPlacementGroup | Interface | Represents a MediaLive Channel Placement Group. |
ICluster | Interface | Represents a MediaLive Cluster. |
Id3Behavior | Class | ID3 metadata insertion behavior (CMAF Ingest and MediaPackage V2 output groups). |
IInput | Interface | Represents a MediaLive Input. |
IInputSecurityGroup | Interface | Represents a MediaLive Input Security Group. |
INetwork | Interface | Represents a MediaLive Network. |
InputAttachment | Struct | An input attachment definition for a channel. |
InputChannelLevel | Struct | An input channel level for audio remixing. |
InputCodec | Class | The codec for the input specification. |
InputConfiguration | Class | Defines the input configuration for a MediaLive Input. |
InputDeviceInputProps | Struct | Properties for an Elemental Link input device input. |
InputEndAction | Class | Action to take when the current input completes. |
InputFilter | Class | Input filter mode. |
InputLossBehavior | Struct | Behavior on input loss: substitute black, optionally repeat the last frame, then show a solid color or a slate image. |
InputLossFailoverProps | Struct | Properties for an input-loss failover condition. |
InputLossImageType | Class | The image MediaLive substitutes into the output on input loss. |
InputMaximumBitrate | Class | The maximum input bitrate for the input specification. |
InputNetworkLocation | Class | The network location of a MediaLive input — the AWS cloud, or an on-premises network for MediaLive Anywhere. |
InputPreference | Class | Input preference when deciding which input to make active after a previously failed input has recovered. |
InputProps | Struct | Properties for creating a MediaLive Input. |
InputResolution | Class | The resolution for the input specification. |
InputSecurityGroupProps | Struct | Properties for creating a MediaLive Input Security Group. |
InputSource | Class | A source for a pull-type input. |
InputSourceOptions | Struct | Options for a URL-based input source. |
InputSpecification | Class | The input specification for a channel. |
InterfaceMapping | Struct | A mapping between a logical interface name and a network ID. |
ISdiSource | Interface | Represents a MediaLive SDI Source. |
KlvBehavior | Class | CMAF Ingest KLV behavior. |
LinkedChannelSettings | Class | Linked channel settings for primary/follower channel configurations. |
LogLevel | Class | The log level for the channel. |
LookAheadRateControl | Class | Lookahead rate control. |
Lut | Class | The S3 location of a 3D LUT (look-up table) file used by a color-correction rule. |
M2tsAbsentInputAudioBehavior | Class | Behavior when the selected input audio stream is removed from the input. |
M2tsArib | Class | ARIB-compliant field muxing. |
M2tsAribCaptionsPidControl | Class | How the ARIB Captions PID is selected. |
M2tsAudioBufferModel | Class | The buffer model used for Dolby Digital audio. |
M2tsAudioStreamType | Class | The stream type used for audio elementary streams. |
M2tsBufferModel | Class | The buffer model used for the transport stream. |
M2tsCcDescriptor | Class | Whether to generate the captionServiceDescriptor in the PMT. |
M2tsEbif | Class | EBIF data passthrough behavior. |
M2tsEbpAudioInterval | Class | Controls placement of audio Encoder Boundary Point (EBP) markers. |
M2tsEbpPlacement | Class | Controls placement of EBP markers on audio PIDs. |
M2tsEsRateInPes | Class | Whether to include the ES Rate field in the PES header. |
M2tsKlv | Class | KLV data passthrough behavior. |
M2tsNielsenId3Behavior | Class | Nielsen ID3 passthrough behavior. |
M2tsPcrControl | Class | Controls insertion of the Program Clock Reference (PCR). |
M2tsRateMode | Class | The output bitrate mode of the transport stream. |
M2tsScte35Control | Class | SCTE-35 passthrough behavior. |
M2tsSegmentationMarkers | Class | The type of segmentation markers to insert. |
M2tsSegmentationStyle | Class | How segmentation markers respond to avails truncating a segment. |
M2tsSettings | Class | MPEG-2 transport stream (M2TS) container settings for an MPEG-TS output. |
M2tsSettingsProps | Struct | Properties for MPEG-2 transport stream (M2TS) container settings. |
M2tsTimedMetadataBehavior | Class | Timed metadata passthrough behavior. |
M3u8KlvBehavior | Class | KLV data passthrough behavior for an M3U8 container. |
M3u8NielsenId3Behavior | Class | Nielsen ID3 passthrough behavior for an M3U8 container. |
M3u8PcrControl | Class | Controls insertion of the Program Clock Reference (PCR) in an M3U8 container. |
M3u8Scte35Behavior | Class | SCTE-35 passthrough behavior for an M3U8 container. |
M3u8Settings | Class | M3U8 container settings for a standard HLS output. |
M3u8SettingsProps | Struct | Properties for M3U8 container settings. |
M3u8TimedMetadataBehavior | Class | Timed-metadata passthrough behavior for an M3U8 container. |
MaintenanceDay | Class | Day of the week for maintenance. |
MaintenanceSettings | Struct | Maintenance window settings for the channel. |
MediaConnectInputProps | Struct | Properties for a MediaConnect input. |
MediaConnectRouterInputProps | Struct | Properties for a MediaConnect router input. |
MediaConnectRouterOutputDefinition | Struct | Output definition for a MediaConnect Router output group. |
MediaConnectRouterOutputGroupProps | Struct | Properties for a MediaConnect Router output group. |
MediaConnectRouterPerPipelineSettings | Struct | Per-pipeline settings for MediaConnectRouterSettings.perPipeline(). |
MediaConnectRouterPipelineConfig | Struct | Per-pipeline settings for a MediaConnect Router output destination. |
MediaConnectRouterSettings | Class | Transit-encryption settings for a MediaConnect Router output group, applied per channel pipeline. |
MediaPackageV2Destination | Class | A MediaPackage V2 destination for a MediaLive output group. |
MediaPackageV2EndpointId | Class | The pipeline endpoint for a MediaPackage V2 destination. |
MediaPackageV2HlsSetting | Class | Whether MediaPackage sets a MediaPackage V2 audio rendition as default / auto-select in the HLS manifest. |
MediaPackageV2OutputDefinition | Struct | Output definition for a MediaPackage V2 output group. |
MediaPackageV2OutputGroupBaseProps | Struct | Common properties shared by the MediaPackage V2 output group variants. |
MediaPackageV2OutputGroupProps | Struct | Properties for a MediaPackage V2 output group. |
MediaPackageV2PerPipelineOutputGroupProps | Struct | Properties for a MediaPackage V2 output group with explicit per-pipeline destinations. |
MotionGraphicsConfiguration | Struct | Motion graphics overlay configuration. |
MotionGraphicsInsertion | Class | Motion graphics insertion state. |
Mp2CodingMode | Class | MP2 coding mode. |
Mp2SettingsProps | Struct | Properties for MP2 codec settings. |
MsSmoothAudioOnlyTimecodeControl | Class | MS Smooth audio-only timecode control. |
MsSmoothCertificateMode | Class | MS Smooth certificate mode. |
MsSmoothEventIdMode | Class | MS Smooth event ID mode. |
MsSmoothEventStopBehavior | Class | MS Smooth event stop behavior. |
MsSmoothInputLossAction | Class | MS Smooth input loss action. |
MsSmoothOutputDefinition | Struct | Output definition for an MS Smooth output group. |
MsSmoothOutputGroupProps | Struct | Properties for an MS Smooth output group. |
MsSmoothSegmentationMode | Class | MS Smooth segmentation mode. |
MsSmoothSparseTrackType | Class | MS Smooth sparse track type. |
MsSmoothStreamManifestBehavior | Class | MS Smooth stream manifest behavior. |
MsSmoothTimestampOffsetMode | Class | MS Smooth timestamp offset mode. |
MulticastInputProps | Struct | Properties for a multicast input. |
MulticastInputSource | Struct | A source for a multicast input. |
MulticastProtocol | Class | The transport protocol for a multicast source. |
NetworkAttributes | Struct | Attributes for importing an existing Network. |
NetworkEndBlackout | Class | Network end blackout state. |
NetworkInputSettings | Struct | Network input settings for URL pull inputs. |
NetworkProps | Struct | Properties for creating a MediaLive Network. |
NetworkRoute | Struct | A route for a MediaLive Network. |
NielsenCbetSettings | Struct | Nielsen CBET watermark settings. |
NielsenCbetStepaside | Class | CBET insertion behavior when prior encoding is detected on the same layer. |
NielsenConfiguration | Struct | Nielsen watermark configuration. |
NielsenDistributionType | Class | Nielsen watermark distribution type. |
NielsenId3Behavior | Class | CMAF Ingest Nielsen ID3 behavior. |
NielsenNaesIiNwSettings | Struct | Nielsen NAES II/NW watermark settings. |
NielsenPcmToId3TaggingState | Class | Whether Nielsen PCM to ID3 tagging is enabled. |
NielsenWatermarksSettings | Struct | Nielsen watermark settings for audio. |
NielsenWatermarkTimezone | Class | Timezone applied to the timestamps in a Nielsen NAES II/NW watermark. |
OcrLanguage | Class | The OCR language to use when converting an image-based caption source to text. |
Output | Class | Represents an output within an output group. |
OutputDefinition | Struct | Base output definition — shared by all output group types. |
OutputDestination | Class | A general URL-based output destination — an S3 bucket or an HTTP(S) endpoint. |
OutputDestinationOptions | Struct | Options for a URL-based output destination. |
OutputGroupConfiguration | Class | Configuration for an output group. |
OutputLocking | Class | Output locking synchronises the frames emitted by a channel's two pipelines. Use the static factory methods to select a strategy:. |
OutputTimingSource | Class | Source of output timing. |
Pipeline | Class | MediaLive pipeline (channel pipeline 0 or 1). |
PipelineLockingMethod | Class | The method MediaLive uses to synchronise pipelines for pipeline output locking. |
PipelineOutputLockingProps | Struct | Properties for pipeline output locking. |
PixelAspectRatio | Class | The pixel aspect ratio (PAR) of the video. |
PoisEndpoint | Struct | Connection details for an ESAM POIS (Placement Opportunity Information System) endpoint. |
PushInputDestination | Struct | A destination for a push-type input. |
PushInputProps | Struct | Properties for push-type inputs (RTMP_PUSH, RTP_PUSH, UDP_PUSH). |
QvbrRateControlProps | Struct | Properties for QVBR rate control. |
RemixSettings | Struct | Audio remix settings for channel remapping. |
RespondToAfd | Class | How to respond to AFD values in the input stream. |
RtmpAdMarkers | Class | Ad marker type for an RTMP output group. |
RtmpAuthenticationScheme | Class | RTMP authentication scheme. |
RtmpCacheFullBehavior | Class | RTMP cache full behavior. |
RtmpCaptionData | Class | RTMP caption data. |
RtmpCertificateMode | Class | RTMP TLS certificate verification mode. |
RtmpDestination | Class | A destination for an RTMP output group. |
RtmpIncludeFillerNalUnits | Class | RTMP include filler NAL units. |
RtmpInputLossAction | Class | RTMP input loss action. |
RtmpOutputDefinition | Struct | Output definition for an RTMP output group. |
RtmpOutputGroupProps | Struct | Properties for an RTMP output group. |
S3CannedAcl | Class | S3 canned ACL for output destinations. |
S3OutputDestination | Class | A destination for an Archive or Frame Capture output group — always an S3 bucket. |
ScalingBehavior | Class | Video scaling behavior. |
ScanType | Class | Scan type for the output video. |
Scte20CaptionSourceOptions | Struct | Options for an SCTE-20 caption source. |
Scte20Detection | Class | SCTE-20 detection mode for an embedded caption source. |
Scte27CaptionSourceOptions | Struct | Options for an SCTE-27 caption source. |
Scte35FlagBehavior | Class | How to handle SCTE-35 regional blackout and web delivery flags. |
Scte35SegmentationScope | Class | Controls which output groups receive SCTE-35 segmentation cues. |
Scte35SpliceInsertSettings | Struct | SCTE-35 splice insert avail settings. |
Scte35TimeSignalAposSettings | Struct | SCTE-35 time signal APOS avail settings. |
Scte35Type | Class | CMAF Ingest SCTE-35 type. |
SdiMode | Class | Mode when quad SDI input is selected. |
SdiSourceAttributes | Struct | Attributes for importing an existing SDI Source. |
SdiSourceProps | Struct | Properties for creating an SDI Source. |
SdiType | Class | The type of SDI input. |
Segment | Class | The length of a media segment for an output group. |
ServerValidation | Class | Server validation mode for HTTPS inputs. |
SmartSubtitleSourceOptions | Struct | Options for a smart subtitle caption source (AI-generated subtitles via Elemental Inference). |
Smpte2038DataPreference | Class | SMPTE-2038 data preference. |
Smpte2110InputProps | Struct | Properties for a SMPTE 2110 receiver group input. Requires anywhereSettings on the channel. |
Smpte2110SdpLocation | Struct | A reference to an SDP file that describes a SMPTE 2110 stream to ingest. |
SourceEndBehavior | Class | The source end behavior for file-based inputs. |
SrtCallerDestinationProps | Struct | SRT caller destination properties. |
SrtCallerSourceProps | Struct | Properties for an SRT caller input. |
SrtCallerUrlOptions | Struct | Options for a URL-based SRT caller destination (SrtDestination.callerUrl). |
SrtDecryptionAlgorithm | Class | The encryption algorithm for SRT decryption. |
SrtDecryptionProps | Struct | Properties for SRT decryption. |
SrtDestination | Class | A destination for an SRT output group. |
SrtEncryptionType | Class | SRT output encryption type. |
SrtInputLossAction | Class | Behavior of last resort when input video is lost and no more backup inputs are available, for an SRT output group. |
SrtListenerDestinationProps | Struct | SRT listener destination properties. |
SrtListenerInputProps | Struct | Properties for an SRT listener input. |
SrtOutputDefinition | Struct | Output definition for an SRT output group. |
SrtOutputGroupProps | Struct | Properties for an SRT output group. |
StandardHlsSettingsProps | Struct | Properties for standard (video) HLS settings. |
StandardInputSpecificationProps | Struct | Properties shared by all input specifications. |
SubgopLength | Class | Sub-GOP length mode. |
TeletextCaptionSourceOptions | Struct | Options for a Teletext caption source. |
TemporalFilterPostFilterSharpening | Class | Post-filter sharpening for temporal filter. |
TemporalFilterProps | Struct | Properties for a temporal filter. |
TemporalFilterStrength | Class | Temporal filter strength. |
ThumbnailConfiguration | Struct | Thumbnail configuration for the channel. |
ThumbnailState | Class | Thumbnail state. |
TimecodeBurninFontSize | Class | Font size for timecode burn-in. |
TimecodeBurninPosition | Class | Position for timecode burn-in overlay. |
TimecodeBurninSettings | Struct | Settings for burning a timecode overlay into the video output. |
TimecodeConfig | Struct | Timecode configuration for the channel. |
TimecodeInsertion | Class | Timecode insertion mode. |
TimecodeSource | Class | The source of timecode for the channel outputs. |
TimedMetadataId3Frame | Class | CMAF Ingest timed metadata ID3 frame. |
TimedMetadataPassthrough | Class | CMAF Ingest timed metadata passthrough. |
TransportOutputDestinationProps | Struct | A destination address (IP or host) and port for a transport-stream output. |
TtmlDestinationProps | Struct | Properties for TTML caption output. |
TtmlStyleControl | Class | Whether TTML passes through source style/position. |
UdpInputLossAction | Class | UDP input loss action. |
UdpOutputDefinition | Struct | Output definition for a UDP output group. |
UdpOutputDestination | Class | A destination for a UDP output group — a UDP or RTP transport endpoint. |
UdpOutputGroupProps | Struct | Properties for a UDP output group. |
UdpTimedMetadataId3Frame | Class | UDP timed metadata ID3 frame. |
VbrRateControlProps | Struct | Properties for VBR rate control. |
VideoBlackFailoverProps | Struct | Properties for a video-black failover condition. |
VideoCodecSettings | Class | Video codec settings. |
VideoColorSpace | Class | Video color space. |
VideoColorSpaceUsage | Class | Controls how the colorSpace value is used when it is not FOLLOW. |
VideoEncodeProps | Struct | Properties for a video encode configuration. |
VideoSelection | Class | Selects the specific video to extract from the input — by PID or by program. |
VideoSelectorSettings | Struct | Video selector settings for an input. |
VpcOutputSettings | Struct | VPC output settings for the channel. |
WavCodingMode | Class | WAV coding mode. |
WavSettingsProps | Struct | Properties for WAV codec settings. |
WebvttDestinationProps | Struct | Properties for WebVTT caption output. |
WebvttStyleControl | Class | Whether WebVTT passes through source style/position. |