@remotion/media-parser 4.0.194 → 4.0.196

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

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

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAv1BitstreamHeaderSegment = void 0;
+const color_config_1 = require("./color-config");
+const decoder_model_info_1 = require("./decoder-model-info");
+const operating_parameters_info_1 = require("./operating-parameters-info");
+const timing_info_1 = require("./timing-info");
+const makeSeqLevelIdx = () => {
+    return {
+        operating_point_idc: 0,
+        seq_level_idx: 0,
+        seq_tier: 0,
+    };
+};
+const SELECT_SCREEN_CONTENT_TOOLS = 2;
+const SELECT_INTEGER_MV = 2;
+const parseAv1BitstreamHeaderSegment = (stream) => {
+    // https://aomediacodec.github.io/av1-spec/av1-spec.pdf
+    // Page 41
+    const seq_profile = stream.getBits(3);
+    const still_picture = Boolean(stream.getBits(1));
+    const reduced_still_picture_header = Boolean(stream.getBits(1));
+    let timing_info_present_flag = false;
+    let decoder_model_info_present_flag = false;
+    let initial_display_delay_present_flag = false;
+    let operating_points_cnt_minus_1 = 1;
+    const seq_level = [];
+    let timing_info = null;
+    let decoder_model_info = null;
+    const operating_parameters_info = [];
+    const initial_display_delay_minus_1 = [];
+    if (reduced_still_picture_header) {
+        timing_info_present_flag = false;
+        decoder_model_info_present_flag = false;
+        initial_display_delay_present_flag = false;
+        operating_points_cnt_minus_1 = 0;
+        seq_level[0] = makeSeqLevelIdx();
+        seq_level[0].seq_level_idx = stream.getBits(5);
+    }
+    else {
+        timing_info_present_flag = Boolean(stream.getBits(1));
+        if (timing_info_present_flag) {
+            timing_info = (0, timing_info_1.getTimingInfo)(stream);
+            decoder_model_info_present_flag = Boolean(stream.getBits(1));
+            if (decoder_model_info_present_flag) {
+                decoder_model_info = (0, decoder_model_info_1.parseDecoderModelInfo)(stream);
+            }
+        }
+        initial_display_delay_present_flag = Boolean(stream.getBits(1));
+        operating_points_cnt_minus_1 = stream.getBits(5);
+        for (let i = 0; i <= operating_points_cnt_minus_1; i++) {
+            seq_level[i] = makeSeqLevelIdx();
+            seq_level[i].operating_point_idc = stream.getBits(12);
+            seq_level[i].seq_level_idx = stream.getBits(5);
+            if (seq_level[i].seq_level_idx > 7) {
+                seq_level[i].seq_tier = stream.getBits(1);
+            }
+            else {
+                seq_level[i].seq_tier = 0;
+            }
+            if (decoder_model_info) {
+                const decoder_model_present_for_this_op = Boolean(stream.getBits(1));
+                if (decoder_model_present_for_this_op) {
+                    operating_parameters_info.push((0, operating_parameters_info_1.parseOperatingParametersInfo)({
+                        stream,
+                        buffer_delay_length_minus_1: decoder_model_info.buffer_delay_length_minus_1,
+                    }));
+                }
+            }
+            if (initial_display_delay_present_flag) {
+                const initial_display_delay_present_for_this_op = Boolean(stream.getBits(1));
+                if (initial_display_delay_present_for_this_op) {
+                    initial_display_delay_minus_1.push(stream.getBits(4));
+                }
+            }
+        }
+    }
+    const frame_width_bits_minus_1 = stream.getBits(4);
+    const frame_height_bits_minus_1 = stream.getBits(4);
+    const n = frame_width_bits_minus_1 + 1;
+    const max_frame_width_minus_1 = stream.getBits(n);
+    const m = frame_height_bits_minus_1 + 1;
+    const max_frame_height_minus_1 = stream.getBits(m);
+    let frame_id_numbers_present_flag = false;
+    if (!reduced_still_picture_header) {
+        frame_id_numbers_present_flag = Boolean(stream.getBits(1));
+    }
+    let delta_frame_id_length_minus_2 = null;
+    let additional_frame_id_length_minus_1 = null;
+    if (frame_id_numbers_present_flag) {
+        delta_frame_id_length_minus_2 = stream.getBits(4);
+        additional_frame_id_length_minus_1 = stream.getBits(3);
+    }
+    const use_128x128_superblock = Boolean(stream.getBits(1));
+    const enable_filter_intra = Boolean(stream.getBits(1));
+    const enable_intra_edge_filter = Boolean(stream.getBits(1));
+    let enable_interintra_compound = 0;
+    let enable_masked_compound = 0;
+    let enable_warped_motion = 0;
+    let enable_dual_filter = 0;
+    let enable_order_hint = 0;
+    let enable_jnt_comp = false;
+    let enable_ref_frame_mvs = false;
+    let seq_force_screen_content_tools = SELECT_SCREEN_CONTENT_TOOLS;
+    let seq_force_integer_mv = SELECT_INTEGER_MV;
+    let orderHintBits = 0;
+    if (!reduced_still_picture_header) {
+        enable_interintra_compound = stream.getBits(1);
+        enable_masked_compound = stream.getBits(1);
+        enable_warped_motion = stream.getBits(1);
+        enable_dual_filter = stream.getBits(1);
+        enable_order_hint = stream.getBits(1);
+        enable_jnt_comp = enable_order_hint ? Boolean(stream.getBits(1)) : false;
+        enable_ref_frame_mvs = enable_order_hint
+            ? Boolean(stream.getBits(1))
+            : false;
+        const seq_choose_screen_content_tools = stream.getBits(1);
+        seq_force_screen_content_tools = seq_choose_screen_content_tools
+            ? SELECT_SCREEN_CONTENT_TOOLS
+            : stream.getBits(1);
+        if (seq_choose_screen_content_tools > 0) {
+            const seq_choose_integer_mv = stream.getBits(1);
+            seq_force_integer_mv = seq_choose_integer_mv
+                ? SELECT_INTEGER_MV
+                : stream.getBits(1);
+        }
+        else {
+            seq_force_integer_mv = SELECT_INTEGER_MV;
+        }
+        if (enable_order_hint) {
+            const order_hint_bits_minus_1 = stream.getBits(3);
+            orderHintBits = order_hint_bits_minus_1 + 1;
+        }
+        else {
+            orderHintBits = 0;
+        }
+    }
+    const enable_superres = Boolean(stream.getBits(1));
+    const enable_cdef = Boolean(stream.getBits(1));
+    const enable_restoration = Boolean(stream.getBits(1));
+    const color_config = (0, color_config_1.getColorConfig)(stream, seq_profile);
+    const film_grain_params_present = Boolean(stream.getBits(1));
+    return {
+        type: 'av1-bitstream-header',
+        seq_profile,
+        still_picture,
+        reduced_still_picture_header,
+        timing_info_present_flag,
+        decoder_model_info_present_flag,
+        initial_display_delay_present_flag,
+        operating_points_cnt_minus_1,
+        seq_level,
+        timing_info,
+        decoder_model_info,
+        operating_parameters_info,
+        initial_display_delay_minus_1,
+        frame_width_bits_minus_1,
+        frame_height_bits_minus_1,
+        max_frame_width_minus_1,
+        max_frame_height_minus_1,
+        delta_frame_id_length_minus_2,
+        additional_frame_id_length_minus_1,
+        use_128x128_superblock,
+        enable_filter_intra,
+        enable_intra_edge_filter,
+        color_config,
+        film_grain_params_present,
+        enable_interintra_compound,
+        enable_masked_compound,
+        enable_warped_motion,
+        enable_order_hint,
+        enable_dual_filter,
+        enable_jnt_comp,
+        enable_ref_frame_mvs,
+        seq_force_screen_content_tools,
+        seq_force_integer_mv,
+        enable_superres,
+        enable_cdef,
+        enable_restoration,
+        orderHintBits,
+    };
+};
+exports.parseAv1BitstreamHeaderSegment = parseAv1BitstreamHeaderSegment;

package/dist/boxes/webm/bitstream/av1/matrix-coefficients.d.ts

@@ -0,0 +1,17 @@
+export declare const matrixCoefficients: {
+    MC_IDENTITY: number;
+    MC_BT_709: number;
+    MC_UNSPECIFIED: number;
+    MC_RESERVED_3: number;
+    MC_FCC: number;
+    MC_BT_470_B_G: number;
+    MC_BT_601: number;
+    MC_SMPTE_240: number;
+    MC_SMPTE_YCGCO: number;
+    MC_BT_2020_NCL: number;
+    MC_BT_2020_CL: number;
+    MC_SMPTE_2085: number;
+    MC_CHROMAT_NCL: number;
+    MC_CHROMAT_CL: number;
+    MC_ICTCP: number;
+};