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.

Tcs Class ​

Options for Tcs.

Example ​

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

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

const enaInterface = VpcInterface.define({
  vpcInterfaceName: 'ena-interface',
  role: role,
  securityGroups: [sg2],
  subnet: subnet,
  networkInterfaceType: NetworkInterface.ENA,
});

const videoStream = MediaStream.video({
  mediaStreamId: 1,
  mediaStreamName: 'video',
  videoFormat: MediaVideoFormat.UHD_2160P,
  fmtp: {
    exactFramerate: Framerate.FPS_59_94,
    par: PixelAspectRatio.SQUARE,
    colorimetry: Colorimetry.BT2020,
    videoRange: VideoRange.FULL,
    scanMode: ScanMode.PROGRESSIVE,
    tcs: Tcs.PQ,
  },
});

const flow = new Flow(stack, 'MyJpegXsFlow', {
  flowSize: FlowSize.LARGE_4X,  // Required for JPEG XS
  vpcInterfaces: [efaInterface, enaInterface],
  mediaStreams: [videoStream],
  source: SourceConfiguration.jpegXs({
    flowSourceName: 'jpegxs-source',
    maxSyncBuffer: 100,
    mediaStreamSourceConfigurations: [{
      encoding: Encoding.JXSV,
      port: 5000,
      inputInterface: [efaInterface, enaInterface],  // 2 interfaces for redundancy
      mediaStream: videoStream,
    }],
  }),
});
python
from aws_cdk.aws_mediaconnect_alpha import FmtpVideo, MediaStreamSourceConfigurationJpegXs
# stack: Stack
# role: iam.IRole
# sg1: ec2.ISecurityGroup
# sg2: ec2.ISecurityGroup
# subnet: ec2.ISubnet


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

ena_interface = VpcInterface.define(
    vpc_interface_name="ena-interface",
    role=role,
    security_groups=[sg2],
    subnet=subnet,
    network_interface_type=NetworkInterface.ENA
)

video_stream = MediaStream.video(
    media_stream_id=1,
    media_stream_name="video",
    video_format=MediaVideoFormat.UHD_2160P,
    fmtp=FmtpVideo(
        exact_framerate=Framerate.FPS_59_94,
        par=PixelAspectRatio.SQUARE,
        colorimetry=Colorimetry.BT2020,
        video_range=VideoRange.FULL,
        scan_mode=ScanMode.PROGRESSIVE,
        tcs=Tcs.PQ
    )
)

flow = Flow(stack, "MyJpegXsFlow",
    flow_size=FlowSize.LARGE_4X,  # Required for JPEG XS
    vpc_interfaces=[efa_interface, ena_interface],
    media_streams=[video_stream],
    source=SourceConfiguration.jpeg_xs(
        flow_source_name="jpegxs-source",
        max_sync_buffer=100,
        media_stream_source_configurations=[MediaStreamSourceConfigurationJpegXs(
            encoding=Encoding.JXSV,
            port=5000,
            input_interface=[efa_interface, ena_interface],  # 2 interfaces for redundancy
            media_stream=video_stream
        )]
    )
)
java
Stack stack;
IRole role;
ISecurityGroup sg1;
ISecurityGroup sg2;
ISubnet subnet;


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

VpcInterfaceConfig enaInterface = VpcInterface.define(VpcInterfaceDefineProps.builder()
        .vpcInterfaceName("ena-interface")
        .role(role)
        .securityGroups(List.of(sg2))
        .subnet(subnet)
        .networkInterfaceType(NetworkInterface.ENA)
        .build());

MediaStream videoStream = MediaStream.video(MediaStreamVideo.builder()
        .mediaStreamId(1)
        .mediaStreamName("video")
        .videoFormat(MediaVideoFormat.UHD_2160P)
        .fmtp(FmtpVideo.builder()
                .exactFramerate(Framerate.FPS_59_94)
                .par(PixelAspectRatio.SQUARE)
                .colorimetry(Colorimetry.BT2020)
                .videoRange(VideoRange.FULL)
                .scanMode(ScanMode.PROGRESSIVE)
                .tcs(Tcs.PQ)
                .build())
        .build());

Flow flow = Flow.Builder.create(stack, "MyJpegXsFlow")
        .flowSize(FlowSize.LARGE_4X) // Required for JPEG XS
        .vpcInterfaces(List.of(efaInterface, enaInterface))
        .mediaStreams(List.of(videoStream))
        .source(SourceConfiguration.jpegXs(SourceJpegXs.builder()
                .flowSourceName("jpegxs-source")
                .maxSyncBuffer(100)
                .mediaStreamSourceConfigurations(List.of(MediaStreamSourceConfigurationJpegXs.builder()
                        .encoding(Encoding.JXSV)
                        .port(5000)
                        .inputInterface(List.of(efaInterface, enaInterface)) // 2 interfaces for redundancy
                        .mediaStream(videoStream)
                        .build()))
                .build()))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.AWS.MediaConnect.Alpha
Stack stack;
IRole role;
ISecurityGroup sg1;
ISecurityGroup sg2;
ISubnet subnet;


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

var enaInterface = VpcInterface.Define(new VpcInterfaceDefineProps {
    VpcInterfaceName = "ena-interface",
    Role = role,
    SecurityGroups = new [] { sg2 },
    Subnet = subnet,
    NetworkInterfaceType = NetworkInterface.ENA
});

var videoStream = MediaStream.Video(new MediaStreamVideo {
    MediaStreamId = 1,
    MediaStreamName = "video",
    VideoFormat = MediaVideoFormat.UHD_2160P,
    Fmtp = new FmtpVideo {
        ExactFramerate = Framerate.FPS_59_94,
        Par = PixelAspectRatio.SQUARE,
        Colorimetry = Colorimetry.BT2020,
        VideoRange = VideoRange.FULL,
        ScanMode = ScanMode.PROGRESSIVE,
        Tcs = Tcs.PQ
    }
});

var flow = new Flow(stack, "MyJpegXsFlow", new FlowProps {
    FlowSize = FlowSize.LARGE_4X,  // Required for JPEG XS
    VpcInterfaces = new [] { efaInterface, enaInterface },
    MediaStreams = new [] { videoStream },
    Source = SourceConfiguration.JpegXs(new SourceJpegXs {
        FlowSourceName = "jpegxs-source",
        MaxSyncBuffer = 100,
        MediaStreamSourceConfigurations = new [] { new MediaStreamSourceConfigurationJpegXs {
            Encoding = Encoding.JXSV,
            Port = 5000,
            InputInterface = new [] { efaInterface, enaInterface },  // 2 interfaces for redundancy
            MediaStream = videoStream
        } }
    })
});
go
// Install: go get github.com/aws/aws-cdk-go/awsmediaconnectalpha/v2
var stack Stack
var role IRole
var sg1 ISecurityGroup
var sg2 ISecurityGroup
var subnet ISubnet


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

enaInterface := awsmediaconnectalpha.VpcInterface_Define(&VpcInterfaceDefineProps{
	VpcInterfaceName: jsii.String("ena-interface"),
	Role: role,
	SecurityGroups: []ISecurityGroup{
		sg2,
	},
	Subnet: subnet,
	NetworkInterfaceType: awsmediaconnectalpha.NetworkInterface_ENA(),
})

videoStream := awsmediaconnectalpha.MediaStream_Video(&MediaStreamVideo{
	MediaStreamId: jsii.Number(1),
	MediaStreamName: jsii.String("video"),
	VideoFormat: awsmediaconnectalpha.MediaVideoFormat_UHD_2160P(),
	Fmtp: &FmtpVideo{
		ExactFramerate: awsmediaconnectalpha.Framerate_FPS_59_94(),
		Par: awsmediaconnectalpha.PixelAspectRatio_SQUARE(),
		Colorimetry: awsmediaconnectalpha.Colorimetry_BT2020(),
		VideoRange: awsmediaconnectalpha.VideoRange_FULL(),
		ScanMode: awsmediaconnectalpha.ScanMode_PROGRESSIVE(),
		Tcs: awsmediaconnectalpha.Tcs_PQ(),
	},
})

flow := awsmediaconnectalpha.NewFlow(stack, jsii.String("MyJpegXsFlow"), &FlowProps{
	FlowSize: awsmediaconnectalpha.FlowSize_LARGE_4X(),
	 // Required for JPEG XS
	VpcInterfaces: []VpcInterfaceConfig{
		efaInterface,
		enaInterface,
	},
	MediaStreams: []MediaStream{
		videoStream,
	},
	Source: awsmediaconnectalpha.SourceConfiguration_JpegXs(&SourceJpegXs{
		FlowSourceName: jsii.String("jpegxs-source"),
		MaxSyncBuffer: jsii.Number(100),
		MediaStreamSourceConfigurations: []MediaStreamSourceConfigurationJpegXs{
			&MediaStreamSourceConfigurationJpegXs{
				Encoding: awsmediaconnectalpha.Encoding_JXSV(),
				Port: jsii.Number(5000),
				InputInterface: []VpcInterfaceConfig{
					efaInterface,
					enaInterface,
				},
				 // 2 interfaces for redundancy
				MediaStream: videoStream,
			},
		},
	}),
})

Properties ​

BT2100LINHLGTcsbt2100_linhlgTcsBT2100LINHLGTcsBT2100LINHLGTcsBT2100LINHLGTcsstatic#
Option for BT2100LINHLG.
BT2100LINPQTcsbt2100_linpqTcsBT2100LINPQTcsBT2100LINPQTcsBT2100LINPQTcsstatic#
Option for BT2100LINPQ.
DENSITYTcsdensityTcsDENSITYTcsDENSITYTcsDENSITYTcsstatic#
Option for Density.
HLGTcshlgTcsHLGTcsHLGTcsHLGTcsstatic#
Option for HLG.
LINEARTcslinearTcsLINEARTcsLINEARTcsLINEARTcsstatic#
Option for Linear.
PQTcspqTcsPQTcsPQTcsPQTcsstatic#
Option for PQ.
SDRTcssdrTcsSDRTcsSDRTcsSDRTcsstatic#
Option for SDR.
ST2065_1Tcsst2065_1TcsST2065_1TcsST2065_1TcsST2065_1Tcsstatic#
Option for ST2065-1.
ST428_1Tcsst428_1TcsST428_1TcsST428_1TcsST428_1Tcsstatic#
Option for ST428-1.
valuestringvaluestrvalueStringValuestringValue*string#
The TCS string value.

Methods ​

of(value: string): Tcs // chainable@staticmethod def of(value: str) -> Tcspublic static Tcs of(String value)public static Tcs Of(string value)func Of(Value *string) Tcsstatic#
Use a custom TCS value.
toString(): stringdef to_string(self, ) -> strpublic String toString()public string ToString()func ToString() *string#
Returns the string value.