@remotion/media-parser 4.0.207 → 4.0.208

package/dist/av1-codec-string.d.ts

@@ -0,0 +1,3 @@
+import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
+import type { Av1BitstreamHeaderSegment } from './boxes/webm/bitstream/av1/header-segment';
+export declare const constructAv1CodecString: (av1BitstreamHeader: Av1BitstreamHeaderSegment, colrAtom: ColorParameterBox | null) => string;

package/dist/av1-codec-string.js

@@ -0,0 +1,91 @@
+"use strict";
+// https://aomediacodec.github.io/av1-isobmff/#codecsparam
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructAv1CodecString = void 0;
+const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
+    let str = 'av01.';
+    // Profile
+    str += av1BitstreamHeader.seq_profile;
+    str += '.';
+    // Level
+    // The level parameter value SHALL equal the first level value indicated by seq_level_idx in the Sequence Header OBU
+    str += av1BitstreamHeader.seq_level[0].seq_level_idx
+        .toString()
+        .padStart(2, '0');
+    // Tier
+    // The tier parameter value SHALL be equal to M when the first seq_tier value in the Sequence Header OBU is equal to 0, and H when it is equal to 1
+    str += av1BitstreamHeader.seq_level[0].seq_tier ? '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
+    str += av1BitstreamHeader.color_config.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
+    str += av1BitstreamHeader.color_config.mono_chrome ? '1' : '0';
+    str += '.';
+    // The chromaSubsampling parameter value, represented by a three-digit decimal,
+    // SHALL have its first digit equal to subsampling_x
+    str += av1BitstreamHeader.color_config.subsampling_x ? '1' : '0';
+    // and its second digit equal to subsampling_y.
+    str += av1BitstreamHeader.color_config.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
+    str +=
+        av1BitstreamHeader.color_config.subsampling_x &&
+            av1BitstreamHeader.color_config.subsampling_y
+            ? av1BitstreamHeader.color_config.chroma_sample_position === 1
+                ? '1'
+                : '0'
+            : '0';
+    str += '.';
+    // The colorPrimaries, transferCharacteristics, matrixCoefficients, and videoFullRangeFlag parameter values are set as follows:
+    // If a colr box with colour_type set to nclx is present, the colorPrimaries, transferCharacteristics, matrixCoefficients, and videoFullRangeFlag parameter values SHALL equal the values of matching fields in the colr box.
+    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';
+    }
+    // Otherwise, a colr box with colour_type set to nclx is absent.
+    // If the color_description_present_flag is set to 1 in the Sequence Header OBU, the colorPrimaries, transferCharacteristics, and matrixCoefficients parameter values SHALL equal the values of matching fields in the Sequence Header OBU.
+    else if (av1BitstreamHeader.color_config.color_description_present_flag) {
+        str += av1BitstreamHeader.color_config.color_primaries
+            .toString()
+            .padStart(2, '0');
+        str += '.';
+        str += av1BitstreamHeader.color_config.transfer_characteristics
+            .toString()
+            .padStart(2, '0');
+        str += '.';
+        str += av1BitstreamHeader.color_config.matrix_coefficients
+            .toString()
+            .padStart(2, '0');
+        str += '.';
+        //		The videoFullRangeFlag parameter value SHALL equal the color_range flag in the Sequence Header OBU.
+        str += av1BitstreamHeader.color_config.color_range ? '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);
+    }
+    return str;
+};
+exports.constructAv1CodecString = constructAv1CodecString;

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

@@ -0,0 +1,9 @@
+import type { BaseBox } from './base-type';
+export interface FtypBox extends BaseBox {
+    type: 'ftyp-box';
+    majorBrand: string;
+    minorVersion: number;
+    compatibleBrands: string[];
+}
+export declare const fourByteToNumber: (data: ArrayBuffer, from: number) => number;
+export declare const parseFtyp: (data: ArrayBuffer, offset: number) => FtypBox;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFtyp = exports.fourByteToNumber = void 0;
+const fourByteToNumber = (data, from) => {
+    const view = new DataView(data);
+    return ((view.getUint8(from + 0) << 24) |
+        (view.getUint8(from + 1) << 16) |
+        (view.getUint8(from + 2) << 8) |
+        view.getUint8(from + 3));
+};
+exports.fourByteToNumber = fourByteToNumber;
+const parseFtyp = (data, offset) => {
+    const majorBrand = new TextDecoder().decode(data.slice(8, 12)).trim();
+    const minorVersion = (0, exports.fourByteToNumber)(data, 12);
+    const rest = data.slice(16);
+    const types = rest.byteLength / 4;
+    const compatibleBrands = [];
+    for (let i = 0; i < types; i++) {
+        const fourBytes = rest.slice(i * 4, i * 4 + 4);
+        compatibleBrands.push(new TextDecoder().decode(fourBytes).trim());
+    }
+    return {
+        type: 'ftyp-box',
+        majorBrand,
+        minorVersion,
+        compatibleBrands,
+        offset,
+        boxSize: data.byteLength,
+    };
+};
+exports.parseFtyp = parseFtyp;

package/dist/boxes/iso-base-media/stsd/avcc-hvcc.d.ts

@@ -0,0 +1,20 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface AvccBox {
+    type: 'avcc-box';
+    data: Uint8Array;
+    configurationString: string;
+}
+export declare const parseAvcc: ({ data, size, }: {
+    data: BufferIterator;
+    size: number;
+}) => AvccBox;
+export interface HvccBox {
+    type: 'hvcc-box';
+    data: Uint8Array;
+    configurationString: string;
+}
+export declare const parseHvcc: ({ data, size, offset, }: {
+    data: BufferIterator;
+    size: number;
+    offset: number;
+}) => HvccBox;

package/dist/boxes/iso-base-media/stsd/avcc-hvcc.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHvcc = exports.parseAvcc = void 0;
+const parseAvcc = ({ data, size, }) => {
+    const confVersion = data.getUint8();
+    if (confVersion !== 1) {
+        throw new Error(`Unsupported AVCC version ${confVersion}`);
+    }
+    const profile = data.getUint8();
+    const profileCompatibility = data.getUint8();
+    const level = data.getUint8();
+    const str = `${profile.toString(16).padStart(2, '0')}${profileCompatibility.toString(16).padStart(2, '0')}${level.toString(16).padStart(2, '0')}`;
+    data.counter.decrement(4);
+    return {
+        type: 'avcc-box',
+        data: data.getSlice(size - 8),
+        configurationString: str,
+    };
+};
+exports.parseAvcc = parseAvcc;
+const parseHvcc = ({ data, size, offset, }) => {
+    const raw = data.getSlice(size - 8);
+    data.counter.decrement(size - 8);
+    const configurationVersion = data.getUint8();
+    if (configurationVersion !== 1) {
+        throw new Error(`Unsupported HVCC version ${configurationVersion}`);
+    }
+    const generalProfileSpaceTierFlagAndIdc = data.getUint8();
+    let generalProfileCompatibility = data.getUint32();
+    //  unsigned int(2) general_profile_space;
+    // 	unsigned int(1) general_tier_flag;
+    //	unsigned int(5) general_profile_idc;
+    const generalProfileSpace = generalProfileSpaceTierFlagAndIdc >> 6;
+    const generalTierFlag = generalProfileSpaceTierFlagAndIdc >> 5;
+    const generalProfileIdc = generalProfileSpaceTierFlagAndIdc >> 0;
+    // general_constraint_indicator_flags(48)
+    const generalConstraintIndicator = data.getSlice(6);
+    const generalLevelIdc = data.getUint8();
+    let reversedGeneralProfileSpace = 0;
+    for (let i = 0; i < 32; i++) {
+        reversedGeneralProfileSpace |= generalProfileCompatibility & 1;
+        if (i === 31)
+            break;
+        reversedGeneralProfileSpace <<= 1;
+        generalProfileCompatibility >>= 1;
+    }
+    const profileSpaceChar = generalProfileSpace === 0
+        ? ''
+        : generalProfileSpace === 1
+            ? 'A'
+            : generalProfileSpace === 2
+                ? 'B'
+                : 'C';
+    const generalTierChar = generalTierFlag === 0 ? 'L' : 'H';
+    let hasByte = false;
+    let generalConstraintString = '';
+    for (let i = 5; i >= 0; i--) {
+        if (generalConstraintIndicator[i] || hasByte) {
+            generalConstraintString =
+                generalConstraintIndicator[i].toString(16) + generalConstraintString;
+            hasByte = true;
+        }
+    }
+    const constraintString = `${profileSpaceChar}${generalProfileIdc.toString(16)}.${reversedGeneralProfileSpace.toString(16)}.${generalTierChar}${generalLevelIdc}.${generalConstraintString}`;
+    const remaining = size - (data.counter.getOffset() - offset);
+    data.discard(remaining);
+    return {
+        type: 'hvcc-box',
+        data: raw,
+        configurationString: constraintString,
+    };
+};
+exports.parseHvcc = parseHvcc;

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

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface SttsBox {
+    type: 'stts-box';
+    sampleDistribution: SampleDistribution[];
+}
+type SampleDistribution = {
+    sampleCount: number;
+    sampleDelta: number;
+};
+export declare const parseStts: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+}) => SttsBox;
+export {};

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStts = void 0;
+const parseStts = ({ data, size, fileOffset, }) => {
+    const initialOffset = data.counter.getOffset();
+    const initialCounter = initialOffset - fileOffset;
+    const version = data.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STTS version ${version}`);
+    }
+    // flags, we discard them
+    data.discard(3);
+    // entry count
+    const entryCount = data.getUint32();
+    const sampleDistributions = [];
+    // entries
+    for (let i = 0; i < entryCount; i++) {
+        const sampleCount = data.getUint32();
+        const sampleDelta = data.getUint32();
+        const sampleDistribution = {
+            sampleCount,
+            sampleDelta,
+        };
+        sampleDistributions.push(sampleDistribution);
+    }
+    const bytesUsed = data.counter.getOffset() - initialOffset + initialCounter;
+    if (bytesUsed !== size) {
+        throw new Error(`Expected stts box to be ${size} bytes, but was ${bytesUsed} bytes`);
+    }
+    return {
+        type: 'stts-box',
+        sampleDistribution: sampleDistributions,
+    };
+};
+exports.parseStts = parseStts;

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 {};