Preset class

Provides an Elastic Transcoder preset resource.

> Warning: This resource is deprecated. Use AWS Elemental MediaConvert instead. AWS will discontinue support for Amazon Elastic Transcoder, effective November 13, 2025.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const bar = new aws.elastictranscoder.Preset("bar", {
    audio: {
        audioPackingMode: "SingleTrack",
        bitRate: "96",
        channels: "2",
        codec: "AAC",
        sampleRate: "44100",
    },
    audioCodecOptions: {
        profile: "AAC-LC",
    },
    video: {
        bitRate: "1600",
        codec: "H.264",
        displayAspectRatio: "16:9",
        fixedGop: "false",
        frameRate: "auto",
        maxFrameRate: "60",
        keyframesMaxDist: "240",
        maxHeight: "auto",
        maxWidth: "auto",
        paddingPolicy: "Pad",
        sizingPolicy: "Fit",
    },
    thumbnails: {
        format: "png",
        interval: "120",
        maxWidth: "auto",
        maxHeight: "auto",
        paddingPolicy: "Pad",
        sizingPolicy: "Fit",
    },
    videoWatermarks: [{
        id: "Test",
        maxWidth: "20%",
        maxHeight: "20%",
        sizingPolicy: "ShrinkToFit",
        horizontalAlign: "Right",
        horizontalOffset: "10px",
        verticalAlign: "Bottom",
        verticalOffset: "10px",
        opacity: "55.5",
        target: "Content",
    }],
    container: "mp4",
    description: "Sample Preset",
    name: "sample_preset",
    videoCodecOptions: {
        Profile: "main",
        Level: "2.2",
        MaxReferenceFrames: "3",
        InterlacedMode: "Progressive",
        ColorSpaceConversionMode: "None",
    },
});

import pulumi
import pulumi_aws as aws

bar = aws.elastictranscoder.Preset("bar",
    audio={
        "audio_packing_mode": "SingleTrack",
        "bit_rate": "96",
        "channels": "2",
        "codec": "AAC",
        "sample_rate": "44100",
    },
    audio_codec_options={
        "profile": "AAC-LC",
    },
    video={
        "bit_rate": "1600",
        "codec": "H.264",
        "display_aspect_ratio": "16:9",
        "fixed_gop": "false",
        "frame_rate": "auto",
        "max_frame_rate": "60",
        "keyframes_max_dist": "240",
        "max_height": "auto",
        "max_width": "auto",
        "padding_policy": "Pad",
        "sizing_policy": "Fit",
    },
    thumbnails={
        "format": "png",
        "interval": "120",
        "max_width": "auto",
        "max_height": "auto",
        "padding_policy": "Pad",
        "sizing_policy": "Fit",
    },
    video_watermarks=[{
        "id": "Test",
        "max_width": "20%",
        "max_height": "20%",
        "sizing_policy": "ShrinkToFit",
        "horizontal_align": "Right",
        "horizontal_offset": "10px",
        "vertical_align": "Bottom",
        "vertical_offset": "10px",
        "opacity": "55.5",
        "target": "Content",
    }],
    container="mp4",
    description="Sample Preset",
    name="sample_preset",
    video_codec_options={
        "Profile": "main",
        "Level": "2.2",
        "MaxReferenceFrames": "3",
        "InterlacedMode": "Progressive",
        "ColorSpaceConversionMode": "None",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var bar = new Aws.ElasticTranscoder.Preset("bar", new()
    {
        Audio = new Aws.ElasticTranscoder.Inputs.PresetAudioArgs
        {
            AudioPackingMode = "SingleTrack",
            BitRate = "96",
            Channels = "2",
            Codec = "AAC",
            SampleRate = "44100",
        },
        AudioCodecOptions = new Aws.ElasticTranscoder.Inputs.PresetAudioCodecOptionsArgs
        {
            Profile = "AAC-LC",
        },
        Video = new Aws.ElasticTranscoder.Inputs.PresetVideoArgs
        {
            BitRate = "1600",
            Codec = "H.264",
            DisplayAspectRatio = "16:9",
            FixedGop = "false",
            FrameRate = "auto",
            MaxFrameRate = "60",
            KeyframesMaxDist = "240",
            MaxHeight = "auto",
            MaxWidth = "auto",
            PaddingPolicy = "Pad",
            SizingPolicy = "Fit",
        },
        Thumbnails = new Aws.ElasticTranscoder.Inputs.PresetThumbnailsArgs
        {
            Format = "png",
            Interval = "120",
            MaxWidth = "auto",
            MaxHeight = "auto",
            PaddingPolicy = "Pad",
            SizingPolicy = "Fit",
        },
        VideoWatermarks = new[]
        {
            new Aws.ElasticTranscoder.Inputs.PresetVideoWatermarkArgs
            {
                Id = "Test",
                MaxWidth = "20%",
                MaxHeight = "20%",
                SizingPolicy = "ShrinkToFit",
                HorizontalAlign = "Right",
                HorizontalOffset = "10px",
                VerticalAlign = "Bottom",
                VerticalOffset = "10px",
                Opacity = "55.5",
                Target = "Content",
            },
        },
        Container = "mp4",
        Description = "Sample Preset",
        Name = "sample_preset",
        VideoCodecOptions =
        {
            { "Profile", "main" },
            { "Level", "2.2" },
            { "MaxReferenceFrames", "3" },
            { "InterlacedMode", "Progressive" },
            { "ColorSpaceConversionMode", "None" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/elastictranscoder"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := elastictranscoder.NewPreset(ctx, "bar", &elastictranscoder.PresetArgs{
			Audio: &elastictranscoder.PresetAudioArgs{
				AudioPackingMode: pulumi.String("SingleTrack"),
				BitRate:          pulumi.String("96"),
				Channels:         pulumi.String("2"),
				Codec:            pulumi.String("AAC"),
				SampleRate:       pulumi.String("44100"),
			},
			AudioCodecOptions: &elastictranscoder.PresetAudioCodecOptionsArgs{
				Profile: pulumi.String("AAC-LC"),
			},
			Video: &elastictranscoder.PresetVideoArgs{
				BitRate:            pulumi.String("1600"),
				Codec:              pulumi.String("H.264"),
				DisplayAspectRatio: pulumi.String("16:9"),
				FixedGop:           pulumi.String("false"),
				FrameRate:          pulumi.String("auto"),
				MaxFrameRate:       pulumi.String("60"),
				KeyframesMaxDist:   pulumi.String("240"),
				MaxHeight:          pulumi.String("auto"),
				MaxWidth:           pulumi.String("auto"),
				PaddingPolicy:      pulumi.String("Pad"),
				SizingPolicy:       pulumi.String("Fit"),
			},
			Thumbnails: &elastictranscoder.PresetThumbnailsArgs{
				Format:        pulumi.String("png"),
				Interval:      pulumi.String("120"),
				MaxWidth:      pulumi.String("auto"),
				MaxHeight:     pulumi.String("auto"),
				PaddingPolicy: pulumi.String("Pad"),
				SizingPolicy:  pulumi.String("Fit"),
			},
			VideoWatermarks: elastictranscoder.PresetVideoWatermarkArray{
				&elastictranscoder.PresetVideoWatermarkArgs{
					Id:               pulumi.String("Test"),
					MaxWidth:         pulumi.String("20%"),
					MaxHeight:        pulumi.String("20%"),
					SizingPolicy:     pulumi.String("ShrinkToFit"),
					HorizontalAlign:  pulumi.String("Right"),
					HorizontalOffset: pulumi.String("10px"),
					VerticalAlign:    pulumi.String("Bottom"),
					VerticalOffset:   pulumi.String("10px"),
					Opacity:          pulumi.String("55.5"),
					Target:           pulumi.String("Content"),
				},
			},
			Container:   pulumi.String("mp4"),
			Description: pulumi.String("Sample Preset"),
			Name:        pulumi.String("sample_preset"),
			VideoCodecOptions: pulumi.StringMap{
				"Profile":                  pulumi.String("main"),
				"Level":                    pulumi.String("2.2"),
				"MaxReferenceFrames":       pulumi.String("3"),
				"InterlacedMode":           pulumi.String("Progressive"),
				"ColorSpaceConversionMode": pulumi.String("None"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_elastictranscoder_preset" "bar" {
  audio = {
    audio_packing_mode = "SingleTrack"
    bit_rate           = 96
    channels           = 2
    codec              = "AAC"
    sample_rate        = 44100
  }
  audio_codec_options = {
    profile = "AAC-LC"
  }
  video = {
    bit_rate             = "1600"
    codec                = "H.264"
    display_aspect_ratio = "16:9"
    fixed_gop            = "false"
    frame_rate           = "auto"
    max_frame_rate       = "60"
    keyframes_max_dist   = 240
    max_height           = "auto"
    max_width            = "auto"
    padding_policy       = "Pad"
    sizing_policy        = "Fit"
  }
  thumbnails = {
    format         = "png"
    interval       = 120
    max_width      = "auto"
    max_height     = "auto"
    padding_policy = "Pad"
    sizing_policy  = "Fit"
  }
  video_watermarks {
    id                = "Test"
    max_width         = "20%"
    max_height        = "20%"
    sizing_policy     = "ShrinkToFit"
    horizontal_align  = "Right"
    horizontal_offset = "10px"
    vertical_align    = "Bottom"
    vertical_offset   = "10px"
    opacity           = "55.5"
    target            = "Content"
  }
  container   = "mp4"
  description = "Sample Preset"
  name        = "sample_preset"
  video_codec_options = {
    "Profile"                  = "main"
    "Level"                    = "2.2"
    "MaxReferenceFrames"       = 3
    "InterlacedMode"           = "Progressive"
    "ColorSpaceConversionMode" = "None"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.elastictranscoder.Preset;
import com.pulumi.aws.elastictranscoder.PresetArgs;
import com.pulumi.aws.elastictranscoder.inputs.PresetAudioArgs;
import com.pulumi.aws.elastictranscoder.inputs.PresetAudioCodecOptionsArgs;
import com.pulumi.aws.elastictranscoder.inputs.PresetVideoArgs;
import com.pulumi.aws.elastictranscoder.inputs.PresetThumbnailsArgs;
import com.pulumi.aws.elastictranscoder.inputs.PresetVideoWatermarkArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var bar = new Preset("bar", PresetArgs.builder()
            .audio(PresetAudioArgs.builder()
                .audioPackingMode("SingleTrack")
                .bitRate("96")
                .channels("2")
                .codec("AAC")
                .sampleRate("44100")
                .build())
            .audioCodecOptions(PresetAudioCodecOptionsArgs.builder()
                .profile("AAC-LC")
                .build())
            .video(PresetVideoArgs.builder()
                .bitRate("1600")
                .codec("H.264")
                .displayAspectRatio("16:9")
                .fixedGop("false")
                .frameRate("auto")
                .maxFrameRate("60")
                .keyframesMaxDist("240")
                .maxHeight("auto")
                .maxWidth("auto")
                .paddingPolicy("Pad")
                .sizingPolicy("Fit")
                .build())
            .thumbnails(PresetThumbnailsArgs.builder()
                .format("png")
                .interval("120")
                .maxWidth("auto")
                .maxHeight("auto")
                .paddingPolicy("Pad")
                .sizingPolicy("Fit")
                .build())
            .videoWatermarks(PresetVideoWatermarkArgs.builder()
                .id("Test")
                .maxWidth("20%")
                .maxHeight("20%")
                .sizingPolicy("ShrinkToFit")
                .horizontalAlign("Right")
                .horizontalOffset("10px")
                .verticalAlign("Bottom")
                .verticalOffset("10px")
                .opacity("55.5")
                .target("Content")
                .build())
            .container("mp4")
            .description("Sample Preset")
            .name("sample_preset")
            .videoCodecOptions(Map.ofEntries(
                Map.entry("Profile", "main"),
                Map.entry("Level", "2.2"),
                Map.entry("MaxReferenceFrames", "3"),
                Map.entry("InterlacedMode", "Progressive"),
                Map.entry("ColorSpaceConversionMode", "None")
            ))
            .build());

    }
}

resources:
  bar:
    type: aws:elastictranscoder:Preset
    properties:
      audio:
        audioPackingMode: SingleTrack
        bitRate: 96
        channels: 2
        codec: AAC
        sampleRate: 44100
      audioCodecOptions:
        profile: AAC-LC
      video:
        bitRate: '1600'
        codec: H.264
        displayAspectRatio: 16:9
        fixedGop: 'false'
        frameRate: auto
        maxFrameRate: '60'
        keyframesMaxDist: 240
        maxHeight: auto
        maxWidth: auto
        paddingPolicy: Pad
        sizingPolicy: Fit
      thumbnails:
        format: png
        interval: 120
        maxWidth: auto
        maxHeight: auto
        paddingPolicy: Pad
        sizingPolicy: Fit
      videoWatermarks:
        - id: Test
          maxWidth: 20%
          maxHeight: 20%
          sizingPolicy: ShrinkToFit
          horizontalAlign: Right
          horizontalOffset: 10px
          verticalAlign: Bottom
          verticalOffset: 10px
          opacity: '55.5'
          target: Content
      container: mp4
      description: Sample Preset
      name: sample_preset
      videoCodecOptions:
        Profile: main
        Level: '2.2'
        MaxReferenceFrames: 3
        InterlacedMode: Progressive
        ColorSpaceConversionMode: None

Import

Using pulumi import, import Elastic Transcoder presets using the id. For example:

$ pulumi import aws:elastictranscoder/preset:Preset basic_preset 1407981661351-cttk8b

Constructors

Preset(String name, {PresetArgs? args, CustomResourceOptions? options}): Creates a new Preset. name The Pulumi resource name. args Arguments used to configure this Preset. The set of arguments for Preset. options Resource options controlling this resource's behavior.
Preset.reference(String urn): Creates a typed reference to an existing Preset resource.

Properties

arn ↔ Output<String>: ARN of the Elastic Transcoder Preset.
latefinal
audio ↔ Output<PresetAudio?>: Audio parameters object (documented below).
latefinal
audioCodecOptions ↔ Output<PresetAudioCodecOptions>: Codec options for the audio parameters (documented below)
latefinal
childResources → Set<Resource>: finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>: latefinalinherited
container ↔ Output<String>: The container type for the output file. Valid values are flac, flv, fmp4, gif, mp3, mp4, mpg, mxf, oga, ogg, ts, and webm.
latefinal
description ↔ Output<String?>: A description of the preset (maximum 255 characters)
latefinal
hashCode → int: The hash code for this object.
no setterinherited
id ↔ Output<String>: getter/setter pairinherited
isCustom → bool: Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool: Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool: Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool: Whether this instance represents a resource value returned over RPC.
finalinherited
name ↔ Output<String>: The name of the preset. (maximum 40 characters)
latefinal
region ↔ Output<String>: Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>: Inherited/explicit async transforms.
no setterinherited
runtimeType → Type: A representation of the runtime type of the object.
no setterinherited
thumbnails ↔ Output<PresetThumbnails?>: Thumbnail parameters object (documented below)
latefinal
transformations → List<ResourceTransformation>: Inherited/explicit legacy transformations.
no setterinherited
type ↔ Output<String>: latefinal
urn ↔ Output<String>: latefinalinherited
video ↔ Output<PresetVideo?>: Video parameters object (documented below)
latefinal
videoCodecOptions ↔ Output<Map<String, String>?>: Codec options for the video parameters
latefinal
videoWatermarks ↔ Output<List<PresetVideoWatermark>?>: Watermark parameters for the video parameters (documented below)
latefinal

Methods

failId(Object error) → void: Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void: Completes all output properties with error.
inherited
failUrn(Object error) → void: Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?: Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String: Returns this resource's logical name.
inherited
getResourceType() → String: Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic: Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>: Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void: Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void: Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void: Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>: Serializes resource properties for RPC transmission.
inherited
toString() → String: A string representation of this object.
inherited

Operators

operator ==(Object other) → bool: The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {PresetState? state, CustomResourceOptions? options}) → Preset: Gets an existing Preset resource's state with the given name and id.