@remotion/media-parser 4.0.206 → 4.0.208

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

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/make-header.d.ts

@@ -1,4 +1,8 @@
-import type { PossibleEbmlOrUint8Array } from './segments/all-segments';
+import type { BytesAndOffset, PossibleEbmlOrUint8Array } from './segments/all-segments';
+import { matroskaElements } from './segments/all-segments';
 export declare const webmPattern: Uint8Array;
-export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => Uint8Array;
+export declare const matroskaToHex: (matrId: (typeof matroskaElements)[keyof typeof matroskaElements]) => Uint8Array;
+export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => BytesAndOffset;
+export declare const padMatroskaBytes: (fields: PossibleEbmlOrUint8Array, totalLength: number) => BytesAndOffset[];
 export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;
+export declare function serializeUint16(value: number): Uint8Array;