@remotion/media-parser 4.0.193 → 4.0.195

package/dist/boxes/iso-base-media/tkhd.d.ts

@@ -14,6 +14,9 @@ export interface TkhdBox extends BaseBox {
     matrix: ThreeDMatrix;
     width: number;
     height: number;
+    unrotatedWidth: number;
+    unrotatedHeight: number;
+    rotation: number;
 }
 export declare const parseTkhd: ({ iterator, offset, size, }: {
     iterator: BufferIterator;

package/dist/boxes/iso-base-media/tkhd.js

@@ -2,6 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTkhd = void 0;
 const to_date_1 = require("./to-date");
+function getRotationAngleFromMatrix(matrix) {
+    // Extract elements from the matrix
+    const [a, b, c, d] = matrix;
+    // Check if the matrix is a valid rotation matrix
+    if (Math.round(a * a + b * b) !== 1 || Math.round(c * c + d * d) !== 1) {
+        throw new Error('The provided matrix is not a valid rotation matrix.');
+    }
+    // Calculate the angle using the atan2 function
+    const angleRadians = Math.atan2(c, a); // atan2(sin(θ), cos(θ))
+    const angleDegrees = angleRadians * (180 / Math.PI); // Convert radians to degrees
+    return angleDegrees;
+}
+const applyRotation = ({ matrix, width, height, }) => {
+    const newWidth = matrix[0] * width + matrix[1] * height; // 0*3840 + 1*2160
+    const newHeight = matrix[2] * width + matrix[3] * height; // -1*3840 + 0*2160
+    return {
+        width: Math.abs(newWidth),
+        height: Math.abs(newHeight),
+    };
+};
 const parseTkhd = ({ iterator, offset, size, }) => {
     if (size !== 92) {
         throw new Error(`Expected tkhd size of version 0 to be 92, got ${size}`);
@@ -28,21 +48,25 @@ const parseTkhd = ({ iterator, offset, size, }) => {
     // reserved 4
     iterator.discard(2);
     const matrix = [
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
     ];
-    const widthWithoutRotationApplied = iterator.getUint32() / (matrix[0] === 0 ? 1 : matrix[0]);
-    const heightWithoutRotationApplied = iterator.getUint32() / (matrix[4] === 0 ? 1 : matrix[4]);
-    // TODO: This is not correct, HEVC videos with matrix is wrong
-    const width = widthWithoutRotationApplied / (matrix[1] === 0 ? 1 : matrix[1]);
-    const height = heightWithoutRotationApplied / (matrix[1] === 0 ? 1 : matrix[1]);
+    const rotationMatrix = [matrix[0], matrix[1], matrix[3], matrix[4]];
+    const widthWithoutRotationApplied = iterator.getFixedPointUnsigned1616Number();
+    const heightWithoutRotationApplied = iterator.getFixedPointSigned1616Number();
+    const { width, height } = applyRotation({
+        matrix: rotationMatrix,
+        width: widthWithoutRotationApplied,
+        height: heightWithoutRotationApplied,
+    });
+    const rotation = getRotationAngleFromMatrix(rotationMatrix);
     return {
         offset,
         boxSize: size,
@@ -58,6 +82,9 @@ const parseTkhd = ({ iterator, offset, size, }) => {
         width,
         height,
         version,
+        rotation,
+        unrotatedWidth: widthWithoutRotationApplied,
+        unrotatedHeight: heightWithoutRotationApplied,
     };
 };
 exports.parseTkhd = parseTkhd;

package/dist/boxes/iso-base-media/trak/trak.d.ts

@@ -1,12 +1,14 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
 export interface TrakBox extends BaseBox {
     type: 'trak-box';
     children: AnySegment[];
 }
-export declare const parseTrak: ({ data, size, offsetAtStart, }: {
+export declare const parseTrak: ({ data, size, offsetAtStart, options, }: {
     data: BufferIterator;
     size: number;
     offsetAtStart: number;
-}) => TrakBox;
+    options: ParserContext;
+}) => Promise<TrakBox>;

package/dist/boxes/iso-base-media/trak/trak.js

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrak = void 0;
 const process_box_1 = require("../process-box");
-const parseTrak = ({ data, size, offsetAtStart, }) => {
-    const children = (0, process_box_1.parseBoxes)({
+const parseTrak = async ({ data, size, offsetAtStart, options, }) => {
+    const children = await (0, process_box_1.parseBoxes)({
         iterator: data,
         maxBytes: size - (data.counter.getOffset() - offsetAtStart),
         allowIncompleteBoxes: false,
         initialBoxes: [],
+        options,
+        continueMdat: false,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/iso-base-media/void-box.d.ts

@@ -0,0 +1,4 @@
+export interface VoidBox {
+    type: 'void-box';
+    boxSize: number;
+}

package/dist/boxes/iso-base-media/void-box.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/boxes/webm/allowed-partial-segments.d.ts

@@ -0,0 +1 @@
+export declare const allowedPartialSegments: string[];

package/dist/boxes/webm/allowed-partial-segments.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowedPartialSegments = void 0;
+exports.allowedPartialSegments = ['0x1f43b675', '0x18538067'];

package/dist/boxes/webm/av1-codec-private.d.ts

@@ -0,0 +1,2 @@
+import type { ColorParameterBox } from '../iso-base-media/stsd/colr';
+export declare const parseAv1PrivateData: (data: Uint8Array, colrAtom: ColorParameterBox | null) => string;

package/dist/boxes/webm/av1-codec-private.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAv1PrivateData = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const parseAv1PrivateData = (data, colrAtom) => {
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data);
+    iterator.startReadingBits();
+    if (iterator.getBits(1) !== 1) {
+        iterator.destroy();
+        throw new Error('Expected av1 private data to be version 1');
+    }
+    const version = iterator.getBits(7);
+    if (version !== 1) {
+        iterator.destroy();
+        throw new Error(`Expected av1 private data to be version 1, got ${version}`);
+    }
+    let str = 'av01.';
+    // https://aomediacodec.github.io/av1-isobmff/#codecsparam
+    const seqProfile = iterator.getBits(3);
+    // Profile
+    str += seqProfile;
+    str += '.';
+    const seq_level_idx = iterator.getBits(5);
+    const seq_tier_0 = iterator.getBits(1);
+    // Level
+    // The level parameter value SHALL equal the first level value indicated by seq_level_idx in the Sequence Header OBU
+    str += seq_level_idx.toString(16).padStart(2, '0');
+    str += seq_tier_0 ? 'H' : 'M';
+    str += '.';
+    // bitDepth
+    // The bitDepth parameter value SHALL equal the value of BitDepth variable as defined in [AV1] derived from the Sequence Header OBU
+    const high_bitdepth = iterator.getBits(1);
+    const twelve_bit = iterator.getBits(1);
+    const bitDepth = high_bitdepth && seqProfile === 2
+        ? twelve_bit
+            ? 12
+            : 10
+        : high_bitdepth
+            ? 10
+            : 8;
+    str += bitDepth.toString().padStart(2, '0');
+    str += '.';
+    // monochrome
+    // The monochrome parameter value, represented by a single digit decimal, SHALL equal the value of mono_chrome in the Sequence Header OBU
+    const mono_chrome = iterator.getBits(1);
+    str += mono_chrome ? '1' : '0';
+    str += '.';
+    // The chromaSubsampling parameter value, represented by a three-digit decimal,
+    // SHALL have its first digit equal to subsampling_x
+    const subsampling_x = iterator.getBits(1);
+    str += subsampling_x ? '1' : '0';
+    // and its second digit equal to subsampling_y.
+    const subsampling_y = iterator.getBits(1);
+    str += subsampling_y ? '1' : '0';
+    // If both subsampling_x and subsampling_y are set to 1, then the third digit SHALL be equal to chroma_sample_position, otherwise it SHALL be set to 0
+    const chroma_sample_position = iterator.getBits(2);
+    str +=
+        subsampling_x && subsampling_y
+            ? chroma_sample_position === 1
+                ? '1'
+                : '0'
+            : '0';
+    str += '.';
+    if (colrAtom) {
+        str += colrAtom.primaries.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.transfer.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.matrixIndex.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.fullRangeFlag ? '1' : '0';
+    }
+    else {
+        // Otherwise, the color_description_present_flag is set to 0 in the Sequence Header OBU. The colorPrimaries, transferCharacteristics, and matrixCoefficients parameter values SHOULD be set to the default values below.
+        // colorPrimaries 01 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // transferCharacteristics 01 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // matrixCoefficients 00 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // videoFullRangeFlag 0 (studio swing representation)
+        str += '0';
+    }
+    // If the codecs parameter string ends with ".0.110.01.01.01.0" (containing all the default values below), that trailing part of the string SHOULD be omitted.
+    const suffix = '.0.110.01.01.01.0';
+    if (str.endsWith(suffix)) {
+        str = str.slice(0, -suffix.length);
+    }
+    iterator.destroy();
+    return str;
+};
+exports.parseAv1PrivateData = parseAv1PrivateData;

package/dist/boxes/webm/bitstream/av1/bitstream-frame-header.d.ts

@@ -0,0 +1,14 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+import type { Av1BitstreamHeaderSegment } from './header-segment';
+type FrameType = 'key' | 'delta' | 'intra' | 'switch';
+export type Av1FrameHeader = {
+    type: 'av1-frame-header';
+    frameType: FrameType;
+    temporalPointInfo: number | null;
+};
+export declare const getFrameType: (frameType: number) => FrameType;
+export declare const parseAv1FrameHeader: ({ stream, headerSegment, }: {
+    stream: BufferIterator;
+    headerSegment: Av1BitstreamHeaderSegment;
+}) => Av1FrameHeader;
+export {};

package/dist/boxes/webm/bitstream/av1/bitstream-frame-header.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAv1FrameHeader = exports.getFrameType = void 0;
+const temporal_point_info_1 = require("./temporal-point-info");
+const getFrameType = (frameType) => {
+    switch (frameType) {
+        case 0:
+            return 'key';
+        case 1:
+            return 'delta';
+        case 2:
+            return 'intra';
+        case 3:
+            return 'switch';
+        default:
+            throw new Error('Unknown frame type');
+    }
+};
+exports.getFrameType = getFrameType;
+// https://aomediacodec.github.io/av1-spec/#uncompressed-header-syntax
+// Only implmementing to get the basic stuff
+const parseAv1FrameHeader = ({ stream, headerSegment, }) => {
+    var _a, _b;
+    if (headerSegment.reduced_still_picture_header) {
+        return {
+            type: 'av1-frame-header',
+            frameType: 'key',
+            temporalPointInfo: null,
+        };
+    }
+    let temporalPointInfo = null;
+    const show_existing_frame = Boolean(stream.getBits(1));
+    if (show_existing_frame) {
+        const frame_to_show_map_idx = stream.getBits(3);
+        if (headerSegment.decoder_model_info &&
+            !((_a = headerSegment.timing_info) === null || _a === void 0 ? void 0 : _a.equal_picture_interval)) {
+            temporalPointInfo = (0, temporal_point_info_1.getTemporalPointInfo)({
+                stream,
+                frame_presentation_time_length_minus_1: headerSegment.decoder_model_info
+                    .frame_presentation_time_length_minus_1,
+            });
+        }
+        // TODO: this is wrong, there should be a store
+        const frame_type = (0, exports.getFrameType)(frame_to_show_map_idx);
+        return {
+            type: 'av1-frame-header',
+            frameType: frame_type,
+            temporalPointInfo,
+        };
+    }
+    const frameType = (0, exports.getFrameType)(stream.getBits(2));
+    const showFrame = Boolean(stream.getBits(1));
+    if (showFrame &&
+        headerSegment.decoder_model_info &&
+        !((_b = headerSegment.timing_info) === null || _b === void 0 ? void 0 : _b.equal_picture_interval)) {
+        temporalPointInfo = (0, temporal_point_info_1.getTemporalPointInfo)({
+            stream,
+            frame_presentation_time_length_minus_1: headerSegment.decoder_model_info.frame_presentation_time_length_minus_1,
+        });
+    }
+    return {
+        type: 'av1-frame-header',
+        frameType,
+        temporalPointInfo,
+    };
+};
+exports.parseAv1FrameHeader = parseAv1FrameHeader;

package/dist/boxes/webm/bitstream/av1/bitstream-frame.d.ts

@@ -0,0 +1,11 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+import { type Av1FrameHeader } from './bitstream-frame-header';
+import type { Av1BitstreamHeaderSegment } from './header-segment';
+export type Av1Frame = {
+    type: 'av1-frame';
+    header: Av1FrameHeader;
+};
+export declare const parseAv1Frame: ({ stream, headerSegment, }: {
+    stream: BufferIterator;
+    headerSegment: Av1BitstreamHeaderSegment;
+}) => Av1Frame;

package/dist/boxes/webm/bitstream/av1/bitstream-frame.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAv1Frame = void 0;
+const bitstream_frame_header_1 = require("./bitstream-frame-header");
+const parseAv1Frame = ({ stream, headerSegment, }) => {
+    return {
+        type: 'av1-frame',
+        header: (0, bitstream_frame_header_1.parseAv1FrameHeader)({
+            stream,
+            headerSegment,
+        }),
+    };
+};
+exports.parseAv1Frame = parseAv1Frame;

package/dist/boxes/webm/bitstream/av1/chroma-sample-position.d.ts

@@ -0,0 +1,6 @@
+export declare const chromaSamplePositions: {
+    CSP_UNKNOWN: number;
+    CSP_VERTICAL: number;
+    CSP_COLOCATED: number;
+    CSP_RESERVED: number;
+};

package/dist/boxes/webm/bitstream/av1/chroma-sample-position.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chromaSamplePositions = void 0;
+exports.chromaSamplePositions = {
+    CSP_UNKNOWN: 0,
+    CSP_VERTICAL: 1,
+    CSP_COLOCATED: 2,
+    CSP_RESERVED: 3,
+};

package/dist/boxes/webm/bitstream/av1/color-config.d.ts

@@ -0,0 +1,16 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export type ColorConfig = {
+    bitDepth: number;
+    numPlanes: number;
+    color_primaries: number;
+    transfer_characteristics: number;
+    matrix_coefficients: number;
+    separate_uv_delta_q: number;
+    color_range: boolean;
+    subsampling_x: boolean;
+    subsampling_y: boolean;
+    chroma_sample_position: number;
+    mono_chrome: boolean;
+    color_description_present_flag: boolean;
+};
+export declare const getColorConfig: (stream: BufferIterator, seq_profile: number) => ColorConfig;

package/dist/boxes/webm/bitstream/av1/color-config.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColorConfig = void 0;
+const chroma_sample_position_1 = require("./chroma-sample-position");
+const color_primaries_1 = require("./color-primaries");
+const matrix_coefficients_1 = require("./matrix-coefficients");
+const transfer_characteristics_1 = require("./transfer-characteristics");
+const getColorConfig = (stream, seq_profile) => {
+    const high_bitdepth = Boolean(stream.getBits(1));
+    let bitDepth = 0;
+    if (seq_profile === 2 && high_bitdepth) {
+        const twelve_bit = Boolean(stream.getBits(1));
+        bitDepth = twelve_bit ? 12 : 10;
+    }
+    else if (seq_profile <= 2) {
+        bitDepth = high_bitdepth ? 10 : 8;
+    }
+    const mono_chrome = seq_profile === 1 ? true : Boolean(stream.getBits(1));
+    const numPlanes = mono_chrome ? 1 : 3;
+    const color_description_present_flag = Boolean(stream.getBits(1));
+    const color_primaries = color_description_present_flag
+        ? stream.getBits(8)
+        : color_primaries_1.colorPrimaries.CP_UNSPECIFIED;
+    const transfer_characteristics = color_description_present_flag
+        ? stream.getBits(8)
+        : transfer_characteristics_1.transferCharacteristics.TC_UNSPECIFIED;
+    const matrix_coefficients = color_description_present_flag
+        ? stream.getBits(8)
+        : matrix_coefficients_1.matrixCoefficients.MC_UNSPECIFIED;
+    let chroma_sample_position = chroma_sample_position_1.chromaSamplePositions.CSP_UNKNOWN;
+    let color_range = false;
+    let subsampling_x = false;
+    let subsampling_y = false;
+    if (mono_chrome) {
+        color_range = Boolean(stream.getBits(1));
+        subsampling_x = true;
+        subsampling_y = true;
+        return {
+            bitDepth,
+            numPlanes,
+            color_primaries,
+            transfer_characteristics,
+            matrix_coefficients,
+            separate_uv_delta_q: 0,
+            color_range,
+            subsampling_x,
+            subsampling_y,
+            chroma_sample_position,
+            mono_chrome,
+            color_description_present_flag,
+        };
+    }
+    if (color_primaries === color_primaries_1.colorPrimaries.CP_BT_709 &&
+        transfer_characteristics === transfer_characteristics_1.transferCharacteristics.TC_SRGB &&
+        matrix_coefficients === matrix_coefficients_1.matrixCoefficients.MC_IDENTITY) {
+        color_range = true;
+        subsampling_x = false;
+        subsampling_y = false;
+    }
+    else {
+        color_range = Boolean(stream.getBits(1));
+        if (seq_profile === 0) {
+            subsampling_x = true;
+            subsampling_y = true;
+        }
+        else if (seq_profile === 1) {
+            subsampling_x = false;
+            subsampling_y = false;
+        }
+        else if (bitDepth === 12) {
+            subsampling_x = Boolean(stream.getBits(1));
+            if (subsampling_x) {
+                subsampling_y = Boolean(stream.getBits(1));
+            }
+            else {
+                subsampling_y = false;
+            }
+        }
+        else {
+            subsampling_x = true;
+            subsampling_y = false;
+        }
+        if (subsampling_x && subsampling_y) {
+            chroma_sample_position = stream.getBits(2);
+        }
+    }
+    const separate_uv_delta_q = stream.getBits(1);
+    return {
+        bitDepth,
+        numPlanes,
+        color_primaries,
+        transfer_characteristics,
+        matrix_coefficients,
+        separate_uv_delta_q,
+        chroma_sample_position,
+        color_range,
+        subsampling_x,
+        subsampling_y,
+        mono_chrome,
+        color_description_present_flag,
+    };
+};
+exports.getColorConfig = getColorConfig;

package/dist/boxes/webm/bitstream/av1/color-primaries.d.ts

@@ -0,0 +1,14 @@
+export declare const colorPrimaries: {
+    CP_BT_709: number;
+    CP_UNSPECIFIED: number;
+    CP_BT_470_M: number;
+    CP_BT_470_B_G: number;
+    CP_BT_601: number;
+    CP_SMPTE_240: number;
+    CP_GENERIC_FILM: number;
+    CP_BT_2020: number;
+    CP_XYZ: number;
+    CP_SMPTE_431: number;
+    CP_SMPTE_432: number;
+    CP_EBU_3213: number;
+};

package/dist/boxes/webm/bitstream/av1/color-primaries.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorPrimaries = void 0;
+exports.colorPrimaries = {
+    CP_BT_709: 1,
+    CP_UNSPECIFIED: 2,
+    CP_BT_470_M: 4,
+    CP_BT_470_B_G: 5,
+    CP_BT_601: 6,
+    CP_SMPTE_240: 7,
+    CP_GENERIC_FILM: 8,
+    CP_BT_2020: 9,
+    CP_XYZ: 10,
+    CP_SMPTE_431: 11,
+    CP_SMPTE_432: 12,
+    CP_EBU_3213: 22,
+};

package/dist/boxes/webm/bitstream/av1/decoder-model-info.d.ts

@@ -0,0 +1,9 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export type DecoderModelInfo = {
+    type: 'decoder-model-info';
+    buffer_delay_length_minus_1: number;
+    num_units_in_decoding_tick: number;
+    buffer_removal_time_length_minus_1: number;
+    frame_presentation_time_length_minus_1: number;
+};
+export declare const parseDecoderModelInfo: (stream: BufferIterator) => DecoderModelInfo;

package/dist/boxes/webm/bitstream/av1/decoder-model-info.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDecoderModelInfo = void 0;
+const parseDecoderModelInfo = (stream) => {
+    const buffer_delay_length_minus_1 = stream.getBits(5);
+    const num_units_in_decoding_tick = stream.getBits(32);
+    const buffer_removal_time_length_minus_1 = stream.getBits(5);
+    const frame_presentation_time_length_minus_1 = stream.getBits(5);
+    return {
+        type: 'decoder-model-info',
+        buffer_delay_length_minus_1,
+        num_units_in_decoding_tick,
+        buffer_removal_time_length_minus_1,
+        frame_presentation_time_length_minus_1,
+    };
+};
+exports.parseDecoderModelInfo = parseDecoderModelInfo;

package/dist/boxes/webm/bitstream/av1/frame.js

@@ -0,0 +1 @@
+"use strict";

package/dist/boxes/webm/bitstream/av1/header-segment.d.ts

@@ -0,0 +1,51 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+import type { ColorConfig } from './color-config';
+import { type DecoderModelInfo } from './decoder-model-info';
+import { type OperatingParametersInfo } from './operating-parameters-info';
+import { type TimingInfo } from './timing-info';
+type SeqLevelIndex = {
+    operating_point_idc: number;
+    seq_level_idx: number;
+    seq_tier: number;
+};
+export type Av1BitstreamHeaderSegment = {
+    type: 'av1-bitstream-header';
+    seq_profile: number;
+    still_picture: boolean;
+    reduced_still_picture_header: boolean;
+    timing_info_present_flag: boolean;
+    decoder_model_info_present_flag: boolean;
+    initial_display_delay_present_flag: boolean;
+    operating_points_cnt_minus_1: number;
+    seq_level: SeqLevelIndex[];
+    timing_info: TimingInfo | null;
+    decoder_model_info: DecoderModelInfo | null;
+    operating_parameters_info: OperatingParametersInfo[];
+    initial_display_delay_minus_1: number[];
+    frame_width_bits_minus_1: number;
+    frame_height_bits_minus_1: number;
+    max_frame_width_minus_1: number;
+    max_frame_height_minus_1: number;
+    delta_frame_id_length_minus_2: number | null;
+    additional_frame_id_length_minus_1: number | null;
+    use_128x128_superblock: boolean;
+    enable_filter_intra: boolean;
+    enable_intra_edge_filter: boolean;
+    color_config: ColorConfig;
+    film_grain_params_present: boolean;
+    enable_interintra_compound: number;
+    enable_masked_compound: number;
+    enable_warped_motion: number;
+    enable_order_hint: number;
+    enable_dual_filter: number;
+    enable_jnt_comp: boolean;
+    enable_ref_frame_mvs: boolean;
+    seq_force_screen_content_tools: number;
+    seq_force_integer_mv: number;
+    enable_superres: boolean;
+    enable_cdef: boolean;
+    enable_restoration: boolean;
+    orderHintBits: number;
+};
+export declare const parseAv1BitstreamHeaderSegment: (stream: BufferIterator) => Av1BitstreamHeaderSegment;
+export {};