Skip to content
v2.277.0

Experimental

@aws-cdk/aws-mediaconnect-alpha is an experimental (alpha) package: its API may change in any release, without a major version bump.

MediaStreamVideo Struct ​

A media stream represents one component of your content, such as video, audio, or ancillary data.

After you add a media stream to your flow, you can associate it with sources and outputs that use the ST 2110 JPEG XS or CDI protocol.

Example ​

ts
declare const stack: Stack;
declare const role: iam.IRole;
declare const securityGroup: ec2.ISecurityGroup;
declare const subnet: ec2.ISubnet;

const efaInterface = VpcInterface.define({
  vpcInterfaceName: 'efa-interface',
  role: role,
  securityGroups: [securityGroup],
  subnet: subnet,
  networkInterfaceType: NetworkInterface.EFA,  // Required for CDI
});

const videoStream = MediaStream.video({
  mediaStreamId: 1,
  mediaStreamName: 'video',
  videoFormat: MediaVideoFormat.HD_1080P,
  fmtp: {
    exactFramerate: Framerate.FPS_29_97,
    par: PixelAspectRatio.SQUARE,
  },
});

const flow = new Flow(stack, 'MyCdiFlow', {
  flowSize: FlowSize.LARGE_4X,  // Required for CDI and JPEG XS
  vpcInterfaces: [efaInterface],
  mediaStreams: [videoStream],
  source: SourceConfiguration.cdi({
    flowSourceName: 'cdi-source',
    vpcInterface: efaInterface,
    port: 5000,
    maxSyncBuffer: 100,
    mediaStreamSourceConfigurations: [{
      encoding: Encoding.RAW,
      mediaStream: videoStream,
    }],
  }),
});
python
from aws_cdk.aws_mediaconnect_alpha import FmtpVideo, MediaStreamSourceConfigurationCdi
# stack: Stack
# role: iam.IRole
# security_group: ec2.ISecurityGroup
# subnet: ec2.ISubnet


efa_interface = VpcInterface.define(
    vpc_interface_name="efa-interface",
    role=role,
    security_groups=[security_group],
    subnet=subnet,
    network_interface_type=NetworkInterface.EFA
)

video_stream = MediaStream.video(
    media_stream_id=1,
    media_stream_name="video",
    video_format=MediaVideoFormat.HD_1080P,
    fmtp=FmtpVideo(
        exact_framerate=Framerate.FPS_29_97,
        par=PixelAspectRatio.SQUARE
    )
)

flow = Flow(stack, "MyCdiFlow",
    flow_size=FlowSize.LARGE_4X,  # Required for CDI and JPEG XS
    vpc_interfaces=[efa_interface],
    media_streams=[video_stream],
    source=SourceConfiguration.cdi(
        flow_source_name="cdi-source",
        vpc_interface=efa_interface,
        port=5000,
        max_sync_buffer=100,
        media_stream_source_configurations=[MediaStreamSourceConfigurationCdi(
            encoding=Encoding.RAW,
            media_stream=video_stream
        )]
    )
)
java
Stack stack;
IRole role;
ISecurityGroup securityGroup;
ISubnet subnet;


VpcInterfaceConfig efaInterface = VpcInterface.define(VpcInterfaceDefineProps.builder()
        .vpcInterfaceName("efa-interface")
        .role(role)
        .securityGroups(List.of(securityGroup))
        .subnet(subnet)
        .networkInterfaceType(NetworkInterface.EFA)
        .build());

MediaStream videoStream = MediaStream.video(MediaStreamVideo.builder()
        .mediaStreamId(1)
        .mediaStreamName("video")
        .videoFormat(MediaVideoFormat.HD_1080P)
        .fmtp(FmtpVideo.builder()
                .exactFramerate(Framerate.FPS_29_97)
                .par(PixelAspectRatio.SQUARE)
                .build())
        .build());

Flow flow = Flow.Builder.create(stack, "MyCdiFlow")
        .flowSize(FlowSize.LARGE_4X) // Required for CDI and JPEG XS
        .vpcInterfaces(List.of(efaInterface))
        .mediaStreams(List.of(videoStream))
        .source(SourceConfiguration.cdi(SourceCdi.builder()
                .flowSourceName("cdi-source")
                .vpcInterface(efaInterface)
                .port(5000)
                .maxSyncBuffer(100)
                .mediaStreamSourceConfigurations(List.of(MediaStreamSourceConfigurationCdi.builder()
                        .encoding(Encoding.RAW)
                        .mediaStream(videoStream)
                        .build()))
                .build()))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.AWS.MediaConnect.Alpha
Stack stack;
IRole role;
ISecurityGroup securityGroup;
ISubnet subnet;


var efaInterface = VpcInterface.Define(new VpcInterfaceDefineProps {
    VpcInterfaceName = "efa-interface",
    Role = role,
    SecurityGroups = new [] { securityGroup },
    Subnet = subnet,
    NetworkInterfaceType = NetworkInterface.EFA
});

var videoStream = MediaStream.Video(new MediaStreamVideo {
    MediaStreamId = 1,
    MediaStreamName = "video",
    VideoFormat = MediaVideoFormat.HD_1080P,
    Fmtp = new FmtpVideo {
        ExactFramerate = Framerate.FPS_29_97,
        Par = PixelAspectRatio.SQUARE
    }
});

var flow = new Flow(stack, "MyCdiFlow", new FlowProps {
    FlowSize = FlowSize.LARGE_4X,  // Required for CDI and JPEG XS
    VpcInterfaces = new [] { efaInterface },
    MediaStreams = new [] { videoStream },
    Source = SourceConfiguration.Cdi(new SourceCdi {
        FlowSourceName = "cdi-source",
        VpcInterface = efaInterface,
        Port = 5000,
        MaxSyncBuffer = 100,
        MediaStreamSourceConfigurations = new [] { new MediaStreamSourceConfigurationCdi {
            Encoding = Encoding.RAW,
            MediaStream = videoStream
        } }
    })
});
go
// Install: go get github.com/aws/aws-cdk-go/awsmediaconnectalpha/v2
var stack Stack
var role IRole
var securityGroup ISecurityGroup
var subnet ISubnet


efaInterface := awsmediaconnectalpha.VpcInterface_Define(&VpcInterfaceDefineProps{
	VpcInterfaceName: jsii.String("efa-interface"),
	Role: role,
	SecurityGroups: []ISecurityGroup{
		securityGroup,
	},
	Subnet: subnet,
	NetworkInterfaceType: awsmediaconnectalpha.NetworkInterface_EFA(),
})

videoStream := awsmediaconnectalpha.MediaStream_Video(&MediaStreamVideo{
	MediaStreamId: jsii.Number(1),
	MediaStreamName: jsii.String("video"),
	VideoFormat: awsmediaconnectalpha.MediaVideoFormat_HD_1080P(),
	Fmtp: &FmtpVideo{
		ExactFramerate: awsmediaconnectalpha.Framerate_FPS_29_97(),
		Par: awsmediaconnectalpha.PixelAspectRatio_SQUARE(),
	},
})

flow := awsmediaconnectalpha.NewFlow(stack, jsii.String("MyCdiFlow"), &FlowProps{
	FlowSize: awsmediaconnectalpha.FlowSize_LARGE_4X(),
	 // Required for CDI and JPEG XS
	VpcInterfaces: []VpcInterfaceConfig{
		efaInterface,
	},
	MediaStreams: []MediaStream{
		videoStream,
	},
	Source: awsmediaconnectalpha.SourceConfiguration_Cdi(&SourceCdi{
		FlowSourceName: jsii.String("cdi-source"),
		VpcInterface: efaInterface,
		Port: jsii.Number(5000),
		MaxSyncBuffer: jsii.Number(100),
		MediaStreamSourceConfigurations: []MediaStreamSourceConfigurationCdi{
			&MediaStreamSourceConfigurationCdi{
				Encoding: awsmediaconnectalpha.Encoding_RAW(),
				MediaStream: videoStream,
			},
		},
	}),
})

Properties ​

clockRateoptionalnumberclock_rateoptionalint | floatclockRateoptionalNumberClockRateoptionaldoubleClockRateoptional*float64 #
The sample rate for the stream.

Default: default clock rate for the media stream type

This value is measured in Hz.

descriptionoptionalstringdescriptionoptionalstrdescriptionoptionalStringDescriptionoptionalstringDescriptionoptional*string #
A description that can help you quickly identify what your media stream is used for.

Default: no description

fmtoptionalnumberfmtoptionalint | floatfmtoptionalNumberFmtoptionaldoubleFmtoptional*float64 #
The format type number (sometimes referred to as RTP payload type) of the media stream.

Default: assigned by MediaConnect

MediaConnect assigns this value to the media stream. For ST 2110 JPEG XS outputs, you need to provide this value to the receiver.

Attributes that are related to the media stream.
mediaStreamIdnumbermedia_stream_idint | floatmediaStreamIdNumberMediaStreamIddoubleMediaStreamId*float64 required #
A unique identifier for the media stream.
mediaStreamNamestringmedia_stream_namestrmediaStreamNameStringMediaStreamNamestringMediaStreamName*string required #
A name that helps you distinguish one media stream from another.
videoFormatMediaVideoFormatvideo_formatMediaVideoFormatvideoFormatMediaVideoFormatVideoFormatMediaVideoFormatVideoFormatMediaVideoFormat required #
The resolution of the video.