Format Options

CineonFormatOptions ¶

CineonFormatOptions(
    ten_bit_black_point: int,
    ten_bit_white_point: int,
    converted_black_point: float,
    converted_white_point: float,
    current_gamma: float,
    highlight_expansion: int,
    logarithmic_conversion: bool,
    file_format: CineonFileFormat,
    bit_depth: int,
)

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 aep_parser 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: int

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

converted_black_point ¶

converted_black_point: float

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.

converted_white_point ¶

converted_white_point: float

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.

current_gamma ¶

current_gamma: float

The gamma value applied during the Cineon/DPX conversion.

file_format ¶

file_format: CineonFileFormat

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

highlight_expansion ¶

highlight_expansion: int

The highlight expansion value.

logarithmic_conversion ¶

logarithmic_conversion: bool

Whether logarithmic conversion is enabled.

ten_bit_black_point ¶

ten_bit_black_point: int

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

ten_bit_white_point ¶

ten_bit_white_point: int

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

JpegFormatOptions ¶

JpegFormatOptions(
    quality: int, format_type: JpegFormatType, scans: int
)

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 aep_parser 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: JpegFormatType

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

quality ¶

quality: int

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

scans ¶

scans: int

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

OpenExrFormatOptions ¶

OpenExrFormatOptions(
    compression: OpenExrCompression,
    luminance_chroma: bool,
    thirty_two_bit_float: bool,
    dwa_compression_level: float | None,
)

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 aep_parser 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: OpenExrCompression

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

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.

luminance_chroma ¶

luminance_chroma: bool

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.

thirty_two_bit_float ¶

thirty_two_bit_float: bool

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.

PngFormatOptions ¶

PngFormatOptions(
    width: int,
    height: int,
    bit_depth: int,
    compression: PngCompression,
    include_hdr10_metadata: bool,
    color_primaries: Hdr10ColorPrimaries,
    luminance_min: float | None,
    luminance_max: float | None,
    content_light_max: float | None,
    content_light_average: float | None,
)

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 aep_parser 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: int

The output bit depth per channel (big-endian u2 at offset 24). Common values are 8 and 16.

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.

compression ¶

compression: PngCompression

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

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.

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.

height ¶

height: int

The output height in pixels (big-endian u4 at offset 18).

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.

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.

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.

width ¶

width: int

The output width in pixels (big-endian u4 at offset 14).

TargaFormatOptions ¶

TargaFormatOptions(
    bits_per_pixel: int, rle_compression: bool
)

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 aep_parser 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: int

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

rle_compression ¶

rle_compression: bool

Whether RLE compression is enabled.

TiffFormatOptions ¶

TiffFormatOptions(
    lzw_compression: bool, ibm_pc_byte_order: bool
)

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 aep_parser 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

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

lzw_compression ¶

lzw_compression: bool

Whether LZW compression is enabled.

XmlFormatOptions ¶

XmlFormatOptions(
    format_code: str,
    video_codec: VideoCodec | int | None,
    audio_codec: AudioCodec | int | None,
    frame_rate: float | None,
    mpeg_audio_format: MPEGAudioFormat | int | None = None,
    mpeg_multiplexer: MPEGMultiplexer | int | None = None,
    mpeg_mux_stream_compatibility: MPEGMuxStreamCompatibility
    | int
    | None = None,
    params: dict[str, str] = dict(),
)

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 aep_parser 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.

format_code ¶

format_code: str

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

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).

mpeg_audio_format ¶

mpeg_audio_format: MPEGAudioFormat | int | None = 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.

mpeg_multiplexer ¶

mpeg_multiplexer: MPEGMultiplexer | int | None = 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.

mpeg_mux_stream_compatibility ¶

mpeg_mux_stream_compatibility: (
    MPEGMuxStreamCompatibility | int | None
) = 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.

params ¶

params: dict[str, str] = field(default_factory=dict)

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.

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.