@remotion/media-parser 4.0.193 → 4.0.195

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

package/dist/boxes/webm/bitstream/av1/matrix-coefficients.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matrixCoefficients = void 0;
+exports.matrixCoefficients = {
+    MC_IDENTITY: 0,
+    MC_BT_709: 1,
+    MC_UNSPECIFIED: 2,
+    MC_RESERVED_3: 3,
+    MC_FCC: 4,
+    MC_BT_470_B_G: 5,
+    MC_BT_601: 6,
+    MC_SMPTE_240: 7,
+    MC_SMPTE_YCGCO: 8,
+    MC_BT_2020_NCL: 9,
+    MC_BT_2020_CL: 10,
+    MC_SMPTE_2085: 11,
+    MC_CHROMAT_NCL: 12,
+    MC_CHROMAT_CL: 13,
+    MC_ICTCP: 14,
+};

package/dist/boxes/webm/bitstream/av1/operating-parameters-info.d.ts

@@ -0,0 +1,10 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export type OperatingParametersInfo = {
+    decoder_buffer_delay: number;
+    encoder_buffer_delay: number;
+    low_delay_mode_flag: boolean;
+};
+export declare const parseOperatingParametersInfo: ({ stream, buffer_delay_length_minus_1, }: {
+    stream: BufferIterator;
+    buffer_delay_length_minus_1: number;
+}) => OperatingParametersInfo;

package/dist/boxes/webm/bitstream/av1/operating-parameters-info.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOperatingParametersInfo = void 0;
+const parseOperatingParametersInfo = ({ stream, buffer_delay_length_minus_1, }) => {
+    const n = buffer_delay_length_minus_1 + 1;
+    const decoder_buffer_delay = stream.getBits(n);
+    const encoder_buffer_delay = stream.getBits(n);
+    const low_delay_mode_flag = Boolean(stream.getBits(1));
+    return {
+        decoder_buffer_delay,
+        encoder_buffer_delay,
+        low_delay_mode_flag,
+    };
+};
+exports.parseOperatingParametersInfo = parseOperatingParametersInfo;

package/dist/boxes/webm/bitstream/av1/temporal-point-info.d.ts

@@ -0,0 +1,5 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export declare const getTemporalPointInfo: ({ stream, frame_presentation_time_length_minus_1, }: {
+    stream: BufferIterator;
+    frame_presentation_time_length_minus_1: number;
+}) => number;

package/dist/boxes/webm/bitstream/av1/temporal-point-info.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemporalPointInfo = void 0;
+const getTemporalPointInfo = ({ stream, frame_presentation_time_length_minus_1, }) => {
+    const n = frame_presentation_time_length_minus_1 + 1;
+    return stream.getBits(n);
+};
+exports.getTemporalPointInfo = getTemporalPointInfo;

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

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export type TimingInfo = {
+    num_units_in_display_tick: number;
+    time_scale: number;
+    equal_picture_interval: boolean;
+    num_ticks_per_picture_minus_1: number;
+};
+export declare const getTimingInfo: (stream: BufferIterator) => TimingInfo;

package/dist/boxes/webm/bitstream/av1/timing-info.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimingInfo = void 0;
+const uvlc_1 = require("./uvlc");
+const getTimingInfo = (stream) => {
+    const num_units_in_display_tick = stream.getBits(32);
+    const time_scale = stream.getBits(32);
+    const equal_picture_interval = Boolean(stream.getBits(1));
+    let num_ticks_per_picture_minus_1 = 0;
+    if (equal_picture_interval) {
+        num_ticks_per_picture_minus_1 = (0, uvlc_1.uvlc)(stream);
+    }
+    return {
+        num_units_in_display_tick,
+        time_scale,
+        equal_picture_interval,
+        num_ticks_per_picture_minus_1,
+    };
+};
+exports.getTimingInfo = getTimingInfo;

package/dist/boxes/webm/bitstream/av1/transfer-characteristics.d.ts

@@ -0,0 +1,21 @@
+export declare const transferCharacteristics: {
+    TC_RESERVED_0: number;
+    TC_BT_709: number;
+    TC_UNSPECIFIED: number;
+    TC_RESERVED_3: number;
+    TC_BT_470_M: number;
+    TC_BT_470_B_G: number;
+    TC_BT_601: number;
+    TC_SMPTE_240: number;
+    TC_LINEAR: number;
+    TC_LOG_100: number;
+    TC_LOG_100_SQRT10: number;
+    TC_IEC_61966: number;
+    TC_BT_1361: number;
+    TC_SRGB: number;
+    TC_BT_2020_10_BIT: number;
+    TC_BT_2020_12_BIT: number;
+    TC_SMPTE_2084: number;
+    TC_SMPTE_428: number;
+    TC_HLG: number;
+};

package/dist/boxes/webm/bitstream/av1/transfer-characteristics.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferCharacteristics = void 0;
+exports.transferCharacteristics = {
+    TC_RESERVED_0: 0,
+    TC_BT_709: 1,
+    TC_UNSPECIFIED: 2,
+    TC_RESERVED_3: 3,
+    TC_BT_470_M: 4,
+    TC_BT_470_B_G: 5,
+    TC_BT_601: 6,
+    TC_SMPTE_240: 7,
+    TC_LINEAR: 8,
+    TC_LOG_100: 9,
+    TC_LOG_100_SQRT10: 10,
+    TC_IEC_61966: 11,
+    TC_BT_1361: 12,
+    TC_SRGB: 13,
+    TC_BT_2020_10_BIT: 14,
+    TC_BT_2020_12_BIT: 15,
+    TC_SMPTE_2084: 16,
+    TC_SMPTE_428: 17,
+    TC_HLG: 18,
+};

package/dist/boxes/webm/bitstream/av1/uvlc.d.ts

@@ -0,0 +1,2 @@
+import type { BufferIterator } from '../../../../buffer-iterator';
+export declare const uvlc: (stream: BufferIterator) => number;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uvlc = void 0;
+const uvlc = (stream) => {
+    let leadingZeroBits = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const done = stream.getBits(1);
+        if (done) {
+            break;
+        }
+        leadingZeroBits++;
+    }
+    if (leadingZeroBits >= 32) {
+        return (1 << 32) - 1;
+    }
+    const value = stream.getBits(leadingZeroBits);
+    return value + (1 << leadingZeroBits) - 1;
+};
+exports.uvlc = uvlc;

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

@@ -0,0 +1,20 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
+import type { VideoSample } from '../../../webcodec-sample-types';
+import { type Av1BitstreamHeaderSegment } from './av1/header-segment';
+type Av1BitstreamUimplementedSegment = {
+    type: 'av1-bitstream-unimplemented';
+};
+export type Av1BitstreamSegment = Av1BitstreamHeaderSegment | Av1BitstreamUimplementedSegment;
+export declare const av1Bitstream: ({ stream, length, onVideoSample, trackNumber, context, timecode, }: {
+    stream: BufferIterator;
+    length: number;
+    onVideoSample: (trackId: number, sample: VideoSample) => void;
+    trackNumber: number;
+    context: ParserContext;
+    timecode: number;
+}) => {
+    discarded: boolean;
+    segment: Av1BitstreamSegment;
+};
+export {};

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.av1Bitstream = void 0;
+const combine_uint8array_1 = require("../../../combine-uint8array");
+const bitstream_frame_1 = require("./av1/bitstream-frame");
+const header_segment_1 = require("./av1/header-segment");
+const av1Bitstream = ({ stream, length, onVideoSample, trackNumber, context, timecode, }) => {
+    var _a, _b;
+    const address = stream.counter.getOffset();
+    stream.startReadingBits();
+    // log this to understand:
+    // (firstByte.toString(2).padStart(8, '0'));
+    // get bit 0
+    const obuForbiddenBit = stream.getBits(1);
+    if (obuForbiddenBit) {
+        throw new Error('obuForbiddenBit is not 0');
+    }
+    // get bits 1-3
+    const obuType = stream.getBits(4);
+    // get bit 4
+    const obuExtensionFlag = stream.getBits(1);
+    // get bit 5
+    const obuHasSizeField = stream.getBits(1);
+    // reserved bit
+    stream.getBits(1);
+    let size = null;
+    if (obuExtensionFlag) {
+        // extension
+        stream.getBits(6);
+    }
+    if (obuHasSizeField) {
+        // size
+        size = stream.leb128();
+    }
+    /*
+    console.log(
+        address.toString(16),
+        firstByte.toString(2).padStart(8, '0'),
+        obuForbiddenBit,
+        obuType,
+        obuExtensionFlag,
+        obuHasSizeField,
+        reservedBit,
+        size,
+    );
+    */
+    const bytesReadSoFar = stream.counter.getOffset() - address;
+    const segment = obuType === 1
+        ? (0, header_segment_1.parseAv1BitstreamHeaderSegment)(stream)
+        : {
+            type: 'av1-bitstream-unimplemented',
+        };
+    if (obuType === 6) {
+        const head = context.parserState.getAv1BitstreamHeaderSegment();
+        if (!head) {
+            throw new Error('Expected header segment');
+        }
+        const header = (0, bitstream_frame_1.parseAv1Frame)({
+            stream,
+            headerSegment: head.segment,
+        });
+        const bytesAdvanced = stream.counter.getOffset() - address;
+        stream.counter.decrement(bytesAdvanced);
+        if (size === null) {
+            throw new Error('Expected size in OBU');
+        }
+        const clusterTimestamp = context.parserState.getClusterTimestamp();
+        if (clusterTimestamp === null) {
+            throw new Error('Expected cluster timestamp');
+        }
+        const toSlice = size + bytesReadSoFar;
+        const frame = stream.getSlice(toSlice);
+        let extraBytes = null;
+        if (!context.parserState.getIsFirstAv1FrameRead()) {
+            context.parserState.setIsFirstAv1FrameRead();
+            extraBytes =
+                (_b = (_a = context.parserState.getAv1BitstreamHeaderSegment()) === null || _a === void 0 ? void 0 : _a.header) !== null && _b !== void 0 ? _b : null;
+            if (!extraBytes) {
+                throw new Error('Expected extra bytes');
+            }
+        }
+        onVideoSample(trackNumber, {
+            data: (0, combine_uint8array_1.combineUint8Arrays)(extraBytes, frame),
+            timestamp: timecode + clusterTimestamp,
+            duration: undefined,
+            trackId: trackNumber,
+            cts: null,
+            dts: null,
+            type: header.header.frameType === 'key' ? 'key' : 'delta',
+        });
+        stream.stopReadingBits();
+        return {
+            discarded: true,
+            segment,
+        };
+    }
+    stream.stopReadingBits();
+    if (size === null) {
+        return {
+            discarded: false,
+            segment,
+        };
+    }
+    const end = stream.counter.getOffset();
+    const remaining = (size === null ? length : size + bytesReadSoFar) - (end - address);
+    if (remaining > 0) {
+        stream.discard(remaining);
+    }
+    const remainingNow = length - (stream.counter.getOffset() - address);
+    if (remainingNow > 0 && remainingNow <= 2) {
+        throw new Error('remainingNow > 0 && remainingNow <= 2');
+    }
+    return {
+        discarded: Boolean(size),
+        segment,
+    };
+};
+exports.av1Bitstream = av1Bitstream;

package/dist/boxes/webm/bitstream/h264/get-h264-descriptor.js

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

package/dist/boxes/webm/description.d.ts

@@ -0,0 +1,2 @@
+import type { TrackEntrySegment } from './segments/track-entry';
+export declare const getAudioDescription: (track: TrackEntrySegment) => undefined | Uint8Array;

package/dist/boxes/webm/description.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioDescription = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const traversal_1 = require("../../traversal");
+const getAudioDescription = (track) => {
+    const codec = (0, traversal_1.getCodecSegment)(track);
+    if (!codec || codec.codec !== 'A_VORBIS') {
+        return undefined;
+    }
+    // how to parse vorbis private
+    // https://github.com/google/ExoPlayer/blob/dd430f7053a1a3958deea3ead6a0565150c06bfc/library/extractor/src/main/java/com/google/android/exoplayer2/extractor/mkv/MatroskaExtractor.java#L2466
+    const privateData = (0, traversal_1.getPrivateData)(track);
+    if (!privateData) {
+        return undefined;
+    }
+    if (privateData[0] !== 2) {
+        throw new Error('Expected vorbis private data version 2');
+    }
+    let offset = 1;
+    let vorbisInfoLength = 0;
+    let vorbisSkipLength = 0;
+    while ((privateData[offset] & 0xff) === 0xff) {
+        vorbisInfoLength += 0xff;
+        offset++;
+    }
+    vorbisInfoLength += privateData[offset++] & 0xff;
+    while ((privateData[offset] & 0xff) === 0xff) {
+        vorbisSkipLength += 0xff;
+        offset++;
+    }
+    vorbisSkipLength += privateData[offset++] & 0xff;
+    if (privateData[offset] !== 0x01) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisInfo = privateData.slice(offset, offset + vorbisInfoLength);
+    offset += vorbisInfoLength;
+    if (privateData[offset] !== 0x03) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisComments = privateData.slice(offset, offset + vorbisSkipLength);
+    offset += vorbisSkipLength;
+    if (privateData[offset] !== 0x05) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisBooks = privateData.slice(offset);
+    const bufferIterator = (0, buffer_iterator_1.getArrayBufferIterator)(vorbisInfo.slice(0));
+    // type
+    bufferIterator.getUint8();
+    // vorbis
+    const vorbis = bufferIterator.getByteString(6);
+    if (vorbis !== 'vorbis') {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisVersion = bufferIterator.getUint32Le();
+    if (vorbisVersion !== 0) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisDescription = new Uint8Array([
+        // constructing the vorbis description
+        // This format consists in the page_segments field
+        /**
+         * The number of segment entries to appear in the segment table.
+         * The maximum number of 255 segments (255 bytes each) sets the maximum possible physical page size at 65307 bytes or just under 64kB (thus we know that a header corrupted so as destroy sizing/alignment information will not cause a runaway bitstream.
+         * We'll read in the page according to the corrupted size information that's guaranteed to be a reasonable size regardless, notice the checksum mismatch, drop sync and then look for recapture).
+         */
+        2,
+        // followed by the segment_table field
+        // offset of the comments table
+        vorbisInfo.length,
+        // offset of the codebooks table
+        vorbisComments.length,
+        // followed by the three Vorbis header packets,
+        // respectively the identification header,
+        ...vorbisInfo,
+        // the comments header,
+        ...vorbisComments,
+        // and the setup header, in this order, as described in section 4.2 of [VORBIS].
+        ...vorbisBooks,
+    ]);
+    return vorbisDescription;
+};
+exports.getAudioDescription = getAudioDescription;

package/dist/boxes/webm/get-ready-tracks.d.ts

@@ -0,0 +1,3 @@
+import type { Track } from '../../get-tracks';
+import type { MainSegment } from './segments/main';
+export declare const getTracksFromMatroska: (segment: MainSegment, timescale: number) => Track[];

package/dist/boxes/webm/get-ready-tracks.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTracksFromMatroska = void 0;
+const traversal_1 = require("../../traversal");
+const get_track_1 = require("./get-track");
+const getTracksFromMatroska = (segment, timescale) => {
+    const tracksSegment = (0, traversal_1.getTracksSegment)(segment);
+    if (!tracksSegment) {
+        throw new Error('No tracks segment');
+    }
+    const tracks = [];
+    for (const trackEntrySegment of tracksSegment.children) {
+        if (trackEntrySegment.type === 'crc32-segment') {
+            continue;
+        }
+        if (trackEntrySegment.type !== 'track-entry-segment') {
+            throw new Error('Expected track entry segment');
+        }
+        const track = (0, get_track_1.getTrack)({
+            track: trackEntrySegment,
+            timescale,
+        });
+        if (track) {
+            tracks.push(track);
+        }
+    }
+    return tracks;
+};
+exports.getTracksFromMatroska = getTracksFromMatroska;

package/dist/boxes/webm/get-track.d.ts

@@ -0,0 +1,6 @@
+import type { AudioTrack, VideoTrack } from '../../get-tracks';
+import type { TrackEntrySegment } from './segments/track-entry';
+export declare const getTrack: ({ timescale, track, }: {
+    timescale: number;
+    track: TrackEntrySegment;
+}) => VideoTrack | AudioTrack | null;