@woosh/meep-engine 3.9.0 → 3.11.0

package/src/avif/native/av1/obu/ObuHeader.js

@@ -0,0 +1,62 @@
+/**
+ * A parsed OBU header, plus where its payload sits in the buffer.
+ *
+ * Reused across a whole bitstream walk rather than allocated per OBU.
+ *
+ * @see AV1 spec 5.3.2 "OBU header syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ObuHeader {
+    /**
+     * @type {number} one of the `OBU_*` constants
+     */
+    obu_type = 0;
+
+    /**
+     * @type {number}
+     */
+    obu_extension_flag = 0;
+
+    /**
+     * @type {number}
+     */
+    obu_has_size_field = 0;
+
+    /**
+     * @type {number} valid when {@link obu_extension_flag} is set
+     */
+    temporal_id = 0;
+
+    /**
+     * @type {number} valid when {@link obu_extension_flag} is set
+     */
+    spatial_id = 0;
+
+    /**
+     * Absolute byte offset of the first byte of the OBU, its header included.
+     * @type {number}
+     */
+    offset = 0;
+
+    /**
+     * Absolute byte offset of the first payload byte.
+     * @type {number}
+     */
+    payload_offset = 0;
+
+    /**
+     * Payload length in bytes, `obu_size`.
+     * @type {number}
+     */
+    payload_size = 0;
+
+    /**
+     * Absolute byte offset one past the last byte of the OBU.
+     * @returns {number}
+     */
+    get end() {
+        return this.payload_offset + this.payload_size;
+    }
+}

package/src/avif/native/av1/obu/SequenceHeader.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Maximum number of operating points a sequence header can declare.
+ * @type {number}
+ */
+export const MAX_OPERATING_POINTS: number;
+/**
+ * The AV1 sequence header, as a struct.
+ *
+ * Every field the syntax can set is present, including the ones only reachable from the full
+ * (non-still-picture) form, because the parser has to read them to find the fields after them and
+ * because a writer needs somewhere to take them from when re-emitting a header it parsed.
+ *
+ * The decoder-model fields are parsed and kept but never acted on: they describe buffering
+ * behaviour that has no meaning for a still image.
+ *
+ * @see AV1 spec 5.5.1 "General sequence header OBU syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class SequenceHeader {
+    /** @type {number} `0` main, `1` high, `2` professional */
+    seq_profile: number;
+    /** @type {number} */
+    still_picture: number;
+    /** @type {number} */
+    reduced_still_picture_header: number;
+    /** @type {number} */
+    timing_info_present_flag: number;
+    /** @type {number} */
+    num_units_in_display_tick: number;
+    /** @type {number} */
+    time_scale: number;
+    /** @type {number} */
+    equal_picture_interval: number;
+    /** @type {number} */
+    num_ticks_per_picture_minus_1: number;
+    /** @type {number} */
+    decoder_model_info_present_flag: number;
+    /** @type {number} */
+    buffer_delay_length_minus_1: number;
+    /** @type {number} */
+    num_units_in_decoding_tick: number;
+    /** @type {number} */
+    buffer_removal_time_length_minus_1: number;
+    /** @type {number} */
+    frame_presentation_time_length_minus_1: number;
+    /** @type {number} */
+    initial_display_delay_present_flag: number;
+    /** @type {number} */
+    operating_points_cnt_minus_1: number;
+    /** @type {Uint16Array} */
+    operating_point_idc: Uint16Array;
+    /** @type {Uint8Array} */
+    seq_level_idx: Uint8Array;
+    /** @type {Uint8Array} */
+    seq_tier: Uint8Array;
+    /** @type {Uint8Array} */
+    decoder_model_present_for_this_op: Uint8Array;
+    /** @type {Uint32Array} */
+    decoder_buffer_delay: Uint32Array;
+    /** @type {Uint32Array} */
+    encoder_buffer_delay: Uint32Array;
+    /** @type {Uint8Array} */
+    low_delay_mode_flag: Uint8Array;
+    /** @type {Uint8Array} */
+    initial_display_delay_present_for_this_op: Uint8Array;
+    /** @type {Uint8Array} */
+    initial_display_delay_minus_1: Uint8Array;
+    /** @type {number} the operating point this decode is targeting */
+    operating_point: number;
+    /** @type {number} `operating_point_idc[operating_point]` */
+    operating_point_idc_selected: number;
+    /** @type {number} */
+    frame_width_bits_minus_1: number;
+    /** @type {number} */
+    frame_height_bits_minus_1: number;
+    /** @type {number} */
+    max_frame_width_minus_1: number;
+    /** @type {number} */
+    max_frame_height_minus_1: number;
+    /** @type {number} */
+    frame_id_numbers_present_flag: number;
+    /** @type {number} */
+    delta_frame_id_length_minus_2: number;
+    /** @type {number} */
+    additional_frame_id_length_minus_1: number;
+    /** @type {number} */
+    use_128x128_superblock: number;
+    /** @type {number} */
+    enable_filter_intra: number;
+    /** @type {number} */
+    enable_intra_edge_filter: number;
+    /** @type {number} */
+    enable_interintra_compound: number;
+    /** @type {number} */
+    enable_masked_compound: number;
+    /** @type {number} */
+    enable_warped_motion: number;
+    /** @type {number} */
+    enable_dual_filter: number;
+    /** @type {number} */
+    enable_order_hint: number;
+    /** @type {number} */
+    enable_jnt_comp: number;
+    /** @type {number} */
+    enable_ref_frame_mvs: number;
+    /** @type {number} */
+    seq_choose_screen_content_tools: number;
+    /** @type {number} */
+    seq_force_screen_content_tools: number;
+    /** @type {number} */
+    seq_choose_integer_mv: number;
+    /** @type {number} */
+    seq_force_integer_mv: number;
+    /** @type {number} */
+    order_hint_bits_minus_1: number;
+    /** @type {number} */
+    order_hint_bits: number;
+    /** @type {number} */
+    enable_superres: number;
+    /** @type {number} */
+    enable_cdef: number;
+    /** @type {number} */
+    enable_restoration: number;
+    /** @type {number} */
+    film_grain_params_present: number;
+    /** @type {number} */
+    high_bitdepth: number;
+    /** @type {number} */
+    twelve_bit: number;
+    /** @type {number} `8`, `10` or `12` */
+    bit_depth: number;
+    /** @type {number} */
+    mono_chrome: number;
+    /** @type {number} `1` when monochrome, otherwise `3` */
+    num_planes: number;
+    /** @type {number} */
+    color_description_present_flag: number;
+    /** @type {number} CICP colour primaries */
+    color_primaries: number;
+    /** @type {number} CICP transfer characteristics */
+    transfer_characteristics: number;
+    /** @type {number} CICP matrix coefficients */
+    matrix_coefficients: number;
+    /** @type {number} `0` limited (studio) range, `1` full range */
+    color_range: number;
+    /** @type {number} */
+    subsampling_x: number;
+    /** @type {number} */
+    subsampling_y: number;
+    /** @type {number} */
+    chroma_sample_position: number;
+    /** @type {number} */
+    separate_uv_delta_q: number;
+}
+//# sourceMappingURL=SequenceHeader.d.ts.map

package/src/avif/native/av1/obu/SequenceHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SequenceHeader.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/obu/SequenceHeader.js"],"names":[],"mappings":"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"}

package/src/avif/native/av1/obu/SequenceHeader.js

@@ -0,0 +1,225 @@
+/**
+ * Maximum number of operating points a sequence header can declare.
+ * @type {number}
+ */
+export const MAX_OPERATING_POINTS = 32;
+
+/**
+ * The AV1 sequence header, as a struct.
+ *
+ * Every field the syntax can set is present, including the ones only reachable from the full
+ * (non-still-picture) form, because the parser has to read them to find the fields after them and
+ * because a writer needs somewhere to take them from when re-emitting a header it parsed.
+ *
+ * The decoder-model fields are parsed and kept but never acted on: they describe buffering
+ * behaviour that has no meaning for a still image.
+ *
+ * @see AV1 spec 5.5.1 "General sequence header OBU syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class SequenceHeader {
+    /** @type {number} `0` main, `1` high, `2` professional */
+    seq_profile = 0;
+
+    /** @type {number} */
+    still_picture = 0;
+
+    /** @type {number} */
+    reduced_still_picture_header = 0;
+
+    /** @type {number} */
+    timing_info_present_flag = 0;
+
+    /** @type {number} */
+    num_units_in_display_tick = 0;
+
+    /** @type {number} */
+    time_scale = 0;
+
+    /** @type {number} */
+    equal_picture_interval = 0;
+
+    /** @type {number} */
+    num_ticks_per_picture_minus_1 = 0;
+
+    /** @type {number} */
+    decoder_model_info_present_flag = 0;
+
+    /** @type {number} */
+    buffer_delay_length_minus_1 = 0;
+
+    /** @type {number} */
+    num_units_in_decoding_tick = 0;
+
+    /** @type {number} */
+    buffer_removal_time_length_minus_1 = 0;
+
+    /** @type {number} */
+    frame_presentation_time_length_minus_1 = 0;
+
+    /** @type {number} */
+    initial_display_delay_present_flag = 0;
+
+    /** @type {number} */
+    operating_points_cnt_minus_1 = 0;
+
+    /** @type {Uint16Array} */
+    operating_point_idc = new Uint16Array(MAX_OPERATING_POINTS);
+
+    /** @type {Uint8Array} */
+    seq_level_idx = new Uint8Array(MAX_OPERATING_POINTS);
+
+    /** @type {Uint8Array} */
+    seq_tier = new Uint8Array(MAX_OPERATING_POINTS);
+
+    /** @type {Uint8Array} */
+    decoder_model_present_for_this_op = new Uint8Array(MAX_OPERATING_POINTS);
+
+    /** @type {Uint32Array} */
+    decoder_buffer_delay = new Uint32Array(MAX_OPERATING_POINTS);
+
+    /** @type {Uint32Array} */
+    encoder_buffer_delay = new Uint32Array(MAX_OPERATING_POINTS);
+
+    /** @type {Uint8Array} */
+    low_delay_mode_flag = new Uint8Array(MAX_OPERATING_POINTS);
+
+    /** @type {Uint8Array} */
+    initial_display_delay_present_for_this_op = new Uint8Array(MAX_OPERATING_POINTS);
+
+    /** @type {Uint8Array} */
+    initial_display_delay_minus_1 = new Uint8Array(MAX_OPERATING_POINTS);
+
+    /** @type {number} the operating point this decode is targeting */
+    operating_point = 0;
+
+    /** @type {number} `operating_point_idc[operating_point]` */
+    operating_point_idc_selected = 0;
+
+    /** @type {number} */
+    frame_width_bits_minus_1 = 0;
+
+    /** @type {number} */
+    frame_height_bits_minus_1 = 0;
+
+    /** @type {number} */
+    max_frame_width_minus_1 = 0;
+
+    /** @type {number} */
+    max_frame_height_minus_1 = 0;
+
+    /** @type {number} */
+    frame_id_numbers_present_flag = 0;
+
+    /** @type {number} */
+    delta_frame_id_length_minus_2 = 0;
+
+    /** @type {number} */
+    additional_frame_id_length_minus_1 = 0;
+
+    /** @type {number} */
+    use_128x128_superblock = 0;
+
+    /** @type {number} */
+    enable_filter_intra = 0;
+
+    /** @type {number} */
+    enable_intra_edge_filter = 0;
+
+    /** @type {number} */
+    enable_interintra_compound = 0;
+
+    /** @type {number} */
+    enable_masked_compound = 0;
+
+    /** @type {number} */
+    enable_warped_motion = 0;
+
+    /** @type {number} */
+    enable_dual_filter = 0;
+
+    /** @type {number} */
+    enable_order_hint = 0;
+
+    /** @type {number} */
+    enable_jnt_comp = 0;
+
+    /** @type {number} */
+    enable_ref_frame_mvs = 0;
+
+    /** @type {number} */
+    seq_choose_screen_content_tools = 0;
+
+    /** @type {number} */
+    seq_force_screen_content_tools = 0;
+
+    /** @type {number} */
+    seq_choose_integer_mv = 0;
+
+    /** @type {number} */
+    seq_force_integer_mv = 0;
+
+    /** @type {number} */
+    order_hint_bits_minus_1 = 0;
+
+    /** @type {number} */
+    order_hint_bits = 0;
+
+    /** @type {number} */
+    enable_superres = 0;
+
+    /** @type {number} */
+    enable_cdef = 0;
+
+    /** @type {number} */
+    enable_restoration = 0;
+
+    /** @type {number} */
+    film_grain_params_present = 0;
+
+    // ---- colour configuration -----------------------------------------------------------------
+
+    /** @type {number} */
+    high_bitdepth = 0;
+
+    /** @type {number} */
+    twelve_bit = 0;
+
+    /** @type {number} `8`, `10` or `12` */
+    bit_depth = 8;
+
+    /** @type {number} */
+    mono_chrome = 0;
+
+    /** @type {number} `1` when monochrome, otherwise `3` */
+    num_planes = 3;
+
+    /** @type {number} */
+    color_description_present_flag = 0;
+
+    /** @type {number} CICP colour primaries */
+    color_primaries = 2;
+
+    /** @type {number} CICP transfer characteristics */
+    transfer_characteristics = 2;
+
+    /** @type {number} CICP matrix coefficients */
+    matrix_coefficients = 2;
+
+    /** @type {number} `0` limited (studio) range, `1` full range */
+    color_range = 0;
+
+    /** @type {number} */
+    subsampling_x = 1;
+
+    /** @type {number} */
+    subsampling_y = 1;
+
+    /** @type {number} */
+    chroma_sample_position = 0;
+
+    /** @type {number} */
+    separate_uv_delta_q = 0;
+}

package/src/avif/native/av1/obu/for_each_obu.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Walk the OBUs in a low-overhead bitstream, calling `visit` for each.
+ *
+ * The header handed to `visit` is one reused instance, and the reader is a second, so a whole walk
+ * allocates exactly two objects regardless of how many OBUs there are. A visitor that needs a
+ * header beyond its call must copy the fields it wants.
+ *
+ * An OBU without a size field can only be the last one in the stream — there is no way to find the
+ * next — so the walk ends after it.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @param {number} length
+ * @param {function(ObuHeader, BitReader): (boolean|void)} visit returning `false` stops the walk;
+ *   the reader it receives is positioned at the payload
+ * @see AV1 spec 5.2 "Low overhead bitstream format"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function for_each_obu(bytes: Uint8Array, offset: number, length: number, visit: (arg0: ObuHeader, arg1: BitReader) => (boolean | void)): void;
+import { ObuHeader } from "./ObuHeader.js";
+import { BitReader } from "../../bitstream/BitReader.js";
+//# sourceMappingURL=for_each_obu.d.ts.map

package/src/avif/native/av1/obu/for_each_obu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"for_each_obu.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/obu/for_each_obu.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,oCAVW,UAAU,UACV,MAAM,UACN,MAAM,gBACG,SAAS,QAAE,SAAS,KAAG,CAAC,OAAO,GAAC,IAAI,CAAC,QAgCxD;0BAhDyB,gBAAgB;0BADhB,8BAA8B"}

package/src/avif/native/av1/obu/for_each_obu.js

@@ -0,0 +1,50 @@
+import { BitReader } from "../../bitstream/BitReader.js";
+import { ObuHeader } from "./ObuHeader.js";
+import { parse_obu_header } from "./parse_obu_header.js";
+
+/**
+ * Walk the OBUs in a low-overhead bitstream, calling `visit` for each.
+ *
+ * The header handed to `visit` is one reused instance, and the reader is a second, so a whole walk
+ * allocates exactly two objects regardless of how many OBUs there are. A visitor that needs a
+ * header beyond its call must copy the fields it wants.
+ *
+ * An OBU without a size field can only be the last one in the stream — there is no way to find the
+ * next — so the walk ends after it.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @param {number} length
+ * @param {function(ObuHeader, BitReader): (boolean|void)} visit returning `false` stops the walk;
+ *   the reader it receives is positioned at the payload
+ * @see AV1 spec 5.2 "Low overhead bitstream format"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function for_each_obu(bytes, offset, length, visit) {
+    const header = new ObuHeader();
+    const header_reader = new BitReader();
+    const payload_reader = new BitReader();
+
+    let position = offset;
+    const end = offset + length;
+
+    while (position < end) {
+        parse_obu_header(bytes, position, end - position, header, header_reader);
+
+        payload_reader.init(bytes, header.payload_offset, header.payload_size);
+
+        const carry_on = visit(header, payload_reader);
+
+        if (carry_on === false) {
+            return;
+        }
+
+        if (header.obu_has_size_field === 0) {
+            return;
+        }
+
+        position = header.end;
+    }
+}

package/src/avif/native/av1/obu/parse_frame_header.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Parse an uncompressed frame header.
+ *
+ * Only key frames are accepted. An inter frame is rejected as soon as its type is known rather than
+ * parsed into a header that nothing downstream could act on: this decoder has no reference frames,
+ * so an inter frame is not a degraded case but an impossible one.
+ *
+ * @param {BitReader} reader positioned at the start of the frame header payload
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} header filled in place
+ * @returns {FrameHeader} `header`
+ * @see AV1 spec 5.9.2 "Uncompressed header syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function parse_frame_header(reader: BitReader, sequence: SequenceHeader, header: FrameHeader): FrameHeader;
+//# sourceMappingURL=parse_frame_header.d.ts.map

package/src/avif/native/av1/obu/parse_frame_header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_frame_header.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/obu/parse_frame_header.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;GAeG;AACH,kHAmIC"}