Format options

CineonFormatOptions ¶

Cineon/DPX format-specific render options.

These settings correspond to the Cineon Settings dialog in After Effects, accessible when the output format is set to Cineon Sequence or DPX Sequence.

Example

from py_aep import CineonFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, CineonFormatOptions):
    print(om.format_options.file_format)

Attributes¶

bit_depth ¶

bit_depth = ChunkField[int](
    "_body",
    "bit_depth",
    validate=validate_one_of([8, 10, 12, 16]),
)

The bit depth per channel (8, 10, 12, or 16). Read / Write.

converted_black_point ¶

converted_black_point = ChunkField[float](
    "_body", "converted_black_point"
)

The converted black point value, normalized to the 0.0-1.0 range. This is the linear-light equivalent of the 10-bit black point. Read / Write.

converted_white_point ¶

converted_white_point = ChunkField[float](
    "_body", "converted_white_point"
)

The converted white point value, normalized to the 0.0-1.0 range. This is the linear-light equivalent of the 10-bit white point. Read / Write.

current_gamma ¶

current_gamma = ChunkField[float]('_body', 'current_gamma')

The gamma value applied during the Cineon/DPX conversion. Read / Write.

file_format ¶

file_format = enum(CineonFileFormat, "_body", "file_format")

The file format for the Cineon output. See CineonFileFormat for possible values. Read / Write.

highlight_expansion ¶

highlight_expansion = ChunkField[int](
    "_body", "highlight_expansion"
)

The highlight expansion value. Read / Write.

logarithmic_conversion ¶

logarithmic_conversion = bool(
    "_body", "logarithmic_conversion"
)

Whether logarithmic conversion is enabled. Read / Write.

ten_bit_black_point ¶

ten_bit_black_point = ChunkField[int](
    "_body",
    "ten_bit_black_point",
    validate=validate_number(min=0, max=1023, integer=True),
)

The 10-bit black point value (0-1023). Defines the code value that maps to the black point on a logarithmic scale. Read / Write.

ten_bit_white_point ¶

ten_bit_white_point = ChunkField[int](
    "_body",
    "ten_bit_white_point",
    validate=validate_number(min=0, max=1023, integer=True),
)

The 10-bit white point value (0-1023). Defines the code value that maps to the white point on a logarithmic scale. Read / Write.

JpegFormatOptions ¶

JPEG format-specific render options.

These settings correspond to the JPEG Options dialog in After Effects, accessible when the output format is set to JPEG Sequence.

Example

from py_aep import JpegFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, JpegFormatOptions):
    print(om.format_options.quality)

Attributes¶

format_type ¶

format_type = ChunkField[JpegFormatType](
    "_body",
    "format_type",
    transform=JpegFormatType,
    reverse_seq_field=int,
)

JPEG format option type: Baseline (Standard), Baseline Optimized, or Progressive. Read / Write.

quality ¶

quality = ChunkField[int](
    "_body",
    "quality",
    validate=validate_number(min=0, max=10, integer=True),
)

JPEG quality level, from 0 (Smaller File) to 10 (Bigger File). Read / Write.

scans ¶

scans = ChunkField[int](
    "_body",
    "scans",
    transform=lambda x: x + 2,
    reverse_seq_field=lambda x: x - 2,
    validate=validate_one_of([3, 4, 5]),
)

Number of progressive scans (3, 4, or 5). Only relevant when format_type is JpegFormatType.PROGRESSIVE. Read / Write.

OpenExrFormatOptions ¶

OpenEXR format-specific render options.

These settings correspond to the OpenEXR Options dialog in After Effects, accessible when the output format is set to OpenEXR or OpenEXR Sequence.

Example

from py_aep import OpenExrFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, OpenExrFormatOptions):
    print(om.format_options.compression)

Attributes¶

compression ¶

compression = enum(
    OpenExrCompression, "_body", "compression"
)

The compression method. Corresponds to the Compression dropdown in the OpenEXR Options dialog. Read / Write.

dwa_compression_level ¶

dwa_compression_level: float | None

The DWA compression level. Only meaningful when compression is OpenExrCompression.DWAA or OpenExrCompression.DWAB. Stored as a little-endian f4 in the Ropt body. Defaults to 45.0 in After Effects. Read / Write.

luminance_chroma ¶

luminance_chroma = bool('_body', 'luminance_chroma')

Whether Luminance/Chroma encoding is enabled. Corresponds to the Luminance/Chroma checkbox in the OpenEXR Options dialog. Not applicable when compression is DWAA or DWAB. Read / Write.

thirty_two_bit_float ¶

thirty_two_bit_float = bool("_body", "thirty_two_bit_float")

Whether 32-bit float output is used instead of the default 16-bit half float. Corresponds to the 32-bit float (not recommended) checkbox in the OpenEXR Options dialog. Read / Write.

PngFormatOptions ¶

PNG format-specific render options.

These settings correspond to the PNG Options dialog in After Effects, accessible when the output format is set to PNG Sequence.

The Ropt body for PNG contains a fixed-size binary block (typically 318 bytes) with width, height, and bit depth at known offsets. HDR10 metadata is stored separately in a JSON Utf8 chunk alongside the Ropt chunk.

Example

from py_aep import PngFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, PngFormatOptions):
    print(om.format_options.compression)

Attributes¶

bit_depth ¶

bit_depth = ChunkField[int](
    "_body",
    "bit_depth",
    validate=validate_one_of([8, 16, 32]),
)

The output bit depth per channel. Common values are 8 and 16. Read / Write.

color_primaries ¶

color_primaries: Hdr10ColorPrimaries

The color primaries used for HDR10 metadata. Corresponds to the Color Primaries dropdown in the PNG Options dialog. Only meaningful when include_hdr10_metadata is True. Read / Write.

compression ¶

compression = ChunkField[PngCompression](
    "_body",
    "compression",
    transform=PngCompression,
    reverse_seq_field=int,
)

The PNG compression / interlace mode. Corresponds to the Compression dropdown in the PNG Options dialog. Read / Write.

content_light_average ¶

content_light_average: float | None

The maximum frame average light level in nits for HDR10 metadata, or None if not explicitly set. Corresponds to the Content Light Average field in the PNG Options dialog. Read / Write.

content_light_max ¶

content_light_max: float | None

The maximum content light level in nits for HDR10 metadata, or None if not explicitly set. Corresponds to the Content Light Maximum field in the PNG Options dialog. Read / Write.

height ¶

height = ChunkField[int]('_body', 'height', read_only=True)

The output height in pixels. Read-only.

include_hdr10_metadata ¶

include_hdr10_metadata: bool

Whether HDR10 metadata is embedded in the PNG output. Corresponds to the Include HDR10 Metadata checkbox in the PNG Options dialog. Only available for 16-bit output. Read / Write.

luminance_max ¶

luminance_max: float | None

The maximum display luminance in nits for HDR10 metadata, or None if not explicitly set. Corresponds to the Luminance Maximum field in the PNG Options dialog. Read / Write.

luminance_min ¶

luminance_min: float | None

The minimum display luminance in nits for HDR10 metadata, or None if not explicitly set. Corresponds to the Luminance Minimum field in the PNG Options dialog. Read / Write.

width ¶

width = ChunkField[int]('_body', 'width', read_only=True)

The output width in pixels. Read-only.

TargaFormatOptions ¶

Targa (TGA) format-specific render options.

These settings correspond to the Targa Options dialog in After Effects, accessible when the output format is set to Targa Sequence.

Example

from py_aep import TargaFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, TargaFormatOptions):
    print(om.format_options.bits_per_pixel)

Attributes¶

bits_per_pixel ¶

bits_per_pixel = ChunkField[int](
    "_body",
    "bits_per_pixel",
    validate=validate_one_of([24, 32]),
)

Color depth in bits per pixel (24 or 32). Read / Write.

rle_compression ¶

rle_compression = bool('_body', 'rle_compression')

Whether RLE compression is enabled. Read / Write.

TiffFormatOptions ¶

TIFF format-specific render options.

These settings correspond to the TIFF Options dialog in After Effects, accessible when the output format is set to TIFF Sequence.

Example

from py_aep import TiffFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, TiffFormatOptions):
    print(om.format_options.lzw_compression)

Attributes¶

ibm_pc_byte_order ¶

ibm_pc_byte_order = bool('_body', 'ibm_pc_byte_order')

Whether IBM PC byte order (little-endian) is used. Read / Write.

lzw_compression ¶

lzw_compression = bool('_body', 'lzw_compression')

Whether LZW compression is enabled. Read / Write.

XmlFormatOptions ¶

XML-based format-specific render options.

Shared by output formats that store their settings as a binary header followed by a PremiereData XML block containing ExporterParam elements. Applicable formats include AVI (.AVI), H.264 (H264), MP3 (Mp3), QuickTime (MooV), and WAV (wao_).

Individual parameters are stored in the params dictionary, keyed by their Adobe parameter identifier (e.g. "ADBEVideoCodec").

Example

from py_aep import XmlFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, XmlFormatOptions):
    print(om.format_options.video_codec)

Attributes¶

audio_codec ¶

audio_codec: AudioCodec | int | None

The audio codec as an AudioCodec integer value extracted from the ADBEAudioCodec parameter, or None when the parameter is absent. Falls back to a plain int when the codec is not in the AudioCodec enum. Read / Write.

format_code ¶

format_code = ChunkField[str](
    "_ropt_body", "format_code", read_only=True
)

The 4-character format identifier from the Ropt chunk header (e.g. ".AVI", "H264", "Mp3 ", "MooV", "wao_"). Read-only.

frame_rate ¶

frame_rate: float | None

The output frame rate in frames per second, derived from the ADBEVideoFPS parameter. Adobe stores this as ticks per frame using a time base of 254,016,000,000 ticks/second, so frame_rate = 254016000000 / ADBEVideoFPS. None for audio-only formats (MP3, WAV). Read / Write.

mpeg_audio_format ¶

mpeg_audio_format: MPEGAudioFormat | int | None

The MPEG audio format as an MPEGAudioFormat FourCC integer value extracted from the ADBEMPEGAudioFormat parameter, or None when the parameter is absent. Falls back to a plain int when the value is not in the MPEGAudioFormat enum. Read / Write.

mpeg_multiplexer ¶

mpeg_multiplexer: MPEGMultiplexer | int | None

The MPEG multiplexer as an MPEGMultiplexer FourCC integer value extracted from the ADBEMPEGMultiplexer parameter, or None when the parameter is absent. Falls back to a plain int when the value is not in the MPEGMultiplexer enum. Read / Write.

mpeg_mux_stream_compatibility ¶

mpeg_mux_stream_compatibility: (
    MPEGMuxStreamCompatibility | int | None
)

The MPEG mux stream compatibility as an MPEGMuxStreamCompatibility FourCC integer value extracted from the ADBEMPEGMuxStreamCompatibility parameter, or None when the parameter is absent. Falls back to a plain int when the value is not in the MPEGMuxStreamCompatibility enum. Read / Write.

params ¶

params: ParamsDict = ParamsDict()

All ExporterParam key-value pairs extracted from the embedded XML PremiereData block. Keys are Adobe parameter identifiers such as "ADBEVideoCodec", "ADBEVideoQuality", "ADBEAudioInterleave", etc. Values are the raw string representations from the XML. Read / Write.

video_codec ¶

video_codec: VideoCodec | int | None

The video codec as a VideoCodec FourCC integer value extracted from the ADBEVideoCodec parameter, or None for audio-only formats (MP3, WAV). Falls back to a plain int when the codec is not in the VideoCodec enum. Read / Write.