@woosh/meep-engine 3.9.0 → 3.11.0

package/src/avif/native/av1/encode/write_lr.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Write the loop restoration units a superblock is responsible for.
+ *
+ * The mirror of `read_lr`, and the one piece of syntax this encoder emits that it cannot decide
+ * while it is coding: a restoration filter is fitted to the *finished* picture, after deblocking
+ * and the directional filter have been through it, and the format codes it here — inside the tile,
+ * ahead of the superblock's own partition tree. That is why the tile is written twice.
+ *
+ * Only the Wiener filter is offered. The self-guided one is a different shape of answer — it fits
+ * noise rather than ringing — and choosing between them per unit costs a three-way symbol on every
+ * unit whether or not either wins.
+ *
+ * @param {Av1EncodeContext} ec
+ * @param {SymbolWriter} writer
+ * @param {number} r superblock row in 4x4 units
+ * @param {number} c superblock column in 4x4 units
+ * @param {number} b_size the superblock size
+ * @see AV1 spec 5.11.57 "Read loop restoration syntax", of which this is the mirror
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function write_lr(ec: Av1EncodeContext, writer: SymbolWriter, r: number, c: number, b_size: number): void;
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {SymbolWriter} writer
+ * @param {number} plane
+ * @param {number} unit_row
+ * @param {number} unit_col
+ * @see AV1 spec 5.11.58 "Read loop restoration unit syntax"
+ */
+export function write_lr_unit(ctx: Av1FrameContext, writer: SymbolWriter, plane: number, unit_row: number, unit_col: number): void;
+//# sourceMappingURL=write_lr.d.ts.map

package/src/avif/native/av1/encode/write_lr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_lr.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/write_lr.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wEARW,MAAM,KACN,MAAM,UACN,MAAM,QA2BhB;AAED;;;;;;;GAOG;AACH,iFALW,MAAM,YACN,MAAM,YACN,MAAM,QA4BhB"}

package/src/avif/native/av1/encode/write_lr.js

@@ -0,0 +1,174 @@
+import { RESTORE_NONE, RESTORE_WIENER } from "../tables/av1_symbols.js";
+import { WIENER_TAPS_K, WIENER_TAPS_MAX, WIENER_TAPS_MIN } from "../tables/filter_tables.js";
+import { loop_restoration_unit_range } from "../decode/read_lr.js";
+
+/** @type {Int32Array} first and last unit row, then column */
+const UNIT_RANGE = new Int32Array(4);
+
+/**
+ * Write the loop restoration units a superblock is responsible for.
+ *
+ * The mirror of `read_lr`, and the one piece of syntax this encoder emits that it cannot decide
+ * while it is coding: a restoration filter is fitted to the *finished* picture, after deblocking
+ * and the directional filter have been through it, and the format codes it here — inside the tile,
+ * ahead of the superblock's own partition tree. That is why the tile is written twice.
+ *
+ * Only the Wiener filter is offered. The self-guided one is a different shape of answer — it fits
+ * noise rather than ringing — and choosing between them per unit costs a three-way symbol on every
+ * unit whether or not either wins.
+ *
+ * @param {Av1EncodeContext} ec
+ * @param {SymbolWriter} writer
+ * @param {number} r superblock row in 4x4 units
+ * @param {number} c superblock column in 4x4 units
+ * @param {number} b_size the superblock size
+ * @see AV1 spec 5.11.57 "Read loop restoration syntax", of which this is the mirror
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function write_lr(ec, writer, r, c, b_size) {
+    const ctx = ec.frame_context;
+    const frame = ec.frame;
+
+    if (frame.uses_lr === 0 || frame.allow_intrabc === 1) {
+        return;
+    }
+
+    for (let plane = 0; plane < ctx.num_planes; plane++) {
+        if (frame.frame_restoration_type[plane] === RESTORE_NONE) {
+            continue;
+        }
+
+        loop_restoration_unit_range(ctx, r, c, b_size, plane, UNIT_RANGE);
+
+        for (let unit_row = UNIT_RANGE[0]; unit_row < UNIT_RANGE[1]; unit_row++) {
+            for (let unit_col = UNIT_RANGE[2]; unit_col < UNIT_RANGE[3]; unit_col++) {
+                write_lr_unit(ctx, writer, plane, unit_row, unit_col);
+            }
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {SymbolWriter} writer
+ * @param {number} plane
+ * @param {number} unit_row
+ * @param {number} unit_col
+ * @see AV1 spec 5.11.58 "Read loop restoration unit syntax"
+ */
+export function write_lr_unit(ctx, writer, plane, unit_row, unit_col) {
+    const index = ctx.lr_unit_index(plane, unit_row, unit_col);
+
+    const restoration_type = ctx.lr_type[index];
+
+    writer.write_symbol(restoration_type === RESTORE_WIENER ? 1 : 0, ctx.cdf.use_wiener, 0, 2);
+
+    if (restoration_type !== RESTORE_WIENER) {
+        return;
+    }
+
+    for (let pass = 0; pass < 2; pass++) {
+        // chroma's outermost tap is always zero, which is what makes it a five tap filter
+        const first = plane !== 0 ? 1 : 0;
+
+        for (let j = first; j < 3; j++) {
+            const reference = ctx.ref_lr_wiener[(plane * 2 + pass) * 3 + j];
+
+            const value = ctx.lr_wiener[index * 6 + pass * 3 + j];
+
+            write_signed_subexp_with_ref(writer, WIENER_TAPS_MIN[j], WIENER_TAPS_MAX[j] + 1, WIENER_TAPS_K[j], reference, value);
+
+            ctx.ref_lr_wiener[(plane * 2 + pass) * 3 + j] = value;
+        }
+    }
+}
+
+/**
+ * @param {SymbolWriter} writer
+ * @param {number} low
+ * @param {number} high
+ * @param {number} k
+ * @param {number} reference
+ * @param {number} value
+ */
+function write_signed_subexp_with_ref(writer, low, high, k, reference, value) {
+    write_unsigned_subexp_with_ref(writer, high - low, k, reference - low, value - low);
+}
+
+/**
+ * @param {SymbolWriter} writer
+ * @param {number} mx
+ * @param {number} k
+ * @param {number} r
+ * @param {number} v
+ */
+function write_unsigned_subexp_with_ref(writer, mx, k, r, v) {
+    if ((r << 1) <= mx) {
+        write_subexp(writer, mx, k, recenter(r, v));
+
+        return;
+    }
+
+    write_subexp(writer, mx, k, recenter(mx - 1 - r, mx - 1 - v));
+}
+
+/**
+ * Write one value in the exponential-with-a-flat-tail code the restoration parameters use.
+ *
+ * @param {SymbolWriter} writer
+ * @param {number} num_symbols
+ * @param {number} k
+ * @param {number} value
+ * @see AV1 spec 5.9.27 "Decode subexp", of which this is the mirror
+ */
+function write_subexp(writer, num_symbols, k, value) {
+    let i = 0;
+    let mk = 0;
+
+    for (;;) {
+        const b2 = i !== 0 ? k + i - 1 : k;
+        const a = 1 << b2;
+
+        if (num_symbols <= mk + 3 * a) {
+            writer.write_ns(value - mk, num_symbols - mk);
+
+            return;
+        }
+
+        if (value >= mk + a) {
+            writer.write_literal(1, 1);
+
+            i++;
+            mk += a;
+
+            continue;
+        }
+
+        writer.write_literal(0, 1);
+        writer.write_literal(value - mk, b2);
+
+        return;
+    }
+}
+
+/**
+ * The inverse of `inverse_recenter`: which coded value produces `v` when read against `r`.
+ *
+ * @param {number} r
+ * @param {number} v
+ * @returns {number}
+ * @see AV1 spec 5.9.28 "Inverse recenter function"
+ */
+function recenter(r, v) {
+    if (v > 2 * r) {
+        return v;
+    }
+
+    if (v >= r) {
+        return (v - r) << 1;
+    }
+
+    return ((r - v) << 1) - 1;
+}

package/src/avif/native/av1/encode/write_transform_type.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Write the transform type for a luma transform block, and record it where the decoder will.
+ *
+ * A type is only coded when the transform size allows more than a plain DCT *and* the block is
+ * quantised at all — the same two conditions the reader applies, because a symbol written where the
+ * reader expects none is a desynchronised bitstream.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {SymbolWriter} writer where the symbol goes, or what prices it
+ * @param {number} record `1` to record the type where the decoder will look for it, `0` for a trial
+ * @param {number} x4 luma 4x4 column
+ * @param {number} y4 luma 4x4 row
+ * @param {number} tx_size
+ * @param {number} tx_type the type the coefficients were produced with
+ * @see AV1 spec 5.11.47 "Transform type syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function write_transform_type(ctx: Av1FrameContext, writer: SymbolWriter, record: number, x4: number, y4: number, tx_size: number, tx_type: number): void;
+//# sourceMappingURL=write_transform_type.d.ts.map

package/src/avif/native/av1/encode/write_transform_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_transform_type.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/write_transform_type.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yFAVW,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,QAmDhB"}

package/src/avif/native/av1/encode/write_transform_type.js

@@ -0,0 +1,70 @@
+import { DCT_DCT, TX_SET_INTRA_1 } from "../tables/av1_symbols.js";
+import { TX_HEIGHT, TX_SIZE_SQR, TX_WIDTH } from "../tables/block_tables.js";
+import { TX_TYPE_INTRA_INV_SET1, TX_TYPE_INTRA_INV_SET2 } from "../tables/transform_tables.js";
+import { get_tx_set } from "../decode/transform_type.js";
+
+/**
+ * Write the transform type for a luma transform block, and record it where the decoder will.
+ *
+ * A type is only coded when the transform size allows more than a plain DCT *and* the block is
+ * quantised at all — the same two conditions the reader applies, because a symbol written where the
+ * reader expects none is a desynchronised bitstream.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {SymbolWriter} writer where the symbol goes, or what prices it
+ * @param {number} record `1` to record the type where the decoder will look for it, `0` for a trial
+ * @param {number} x4 luma 4x4 column
+ * @param {number} y4 luma 4x4 row
+ * @param {number} tx_size
+ * @param {number} tx_type the type the coefficients were produced with
+ * @see AV1 spec 5.11.47 "Transform type syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function write_transform_type(ctx, writer, record, x4, y4, tx_size, tx_type) {
+    const frame = ctx.frame;
+
+    const set = get_tx_set(tx_size, 0, frame.reduced_tx_set);
+
+    if (set > 0 && frame.base_q_idx > 0) {
+        const square = TX_SIZE_SQR[tx_size];
+
+        const table = set === TX_SET_INTRA_1 ? TX_TYPE_INTRA_INV_SET1 : TX_TYPE_INTRA_INV_SET2;
+
+        let symbol = -1;
+
+        for (let i = 0; i < table.length; i++) {
+            if (table[i] === tx_type) {
+                symbol = i;
+
+                break;
+            }
+        }
+
+        if (symbol < 0) {
+            throw new Error(`transform type ${tx_type} is not in the set this size allows`);
+        }
+
+        if (set === TX_SET_INTRA_1) {
+            writer.write_symbol(symbol, ctx.cdf.intra_tx_type_set1, (square * 13 + ctx.y_mode) * 8, 7);
+        } else {
+            writer.write_symbol(symbol, ctx.cdf.intra_tx_type_set2, (square * 13 + ctx.y_mode) * 6, 5);
+        }
+    } else if (tx_type !== DCT_DCT) {
+        throw new Error("a transform type that is not coded has to be the plain DCT");
+    }
+
+    if (record === 0) {
+        return;
+    }
+
+    const width4 = TX_WIDTH[tx_size] >> 2;
+    const height4 = TX_HEIGHT[tx_size] >> 2;
+
+    for (let i = 0; i < width4; i++) {
+        for (let j = 0; j < height4; j++) {
+            ctx.tx_types[(y4 + j) * ctx.mi_stride + x4 + i] = tx_type;
+        }
+    }
+}

package/src/avif/native/av1/entropy/CdfContext.d.ts

@@ -0,0 +1,167 @@
+/**
+ * The quantizer band whose coefficient CDFs a frame uses.
+ *
+ * @param {number} base_q_idx
+ * @returns {number} `0 .. 3`
+ * @see AV1 spec 6.8.2, `init_coeff_cdfs`
+ */
+export function coefficient_cdf_band(base_q_idx: number): number;
+/**
+ * Re-seed a context from the default CDFs, as `init_non_coeff_cdfs` and `init_coeff_cdfs` do.
+ *
+ * @param {CdfContext} cdf
+ * @param {number} base_q_idx selects the coefficient CDF band
+ * @see AV1 spec 6.8.2 "Uncompressed header semantics"
+ */
+export function cdf_context_init(cdf: CdfContext, base_q_idx: number): void;
+/**
+ * The adaptive CDF state a tile decodes against.
+ *
+ * ### What is here and what is not
+ *
+ * Only the CDFs an intra key frame can reach. The inter-only families — reference frame selection,
+ * compound modes, motion mode, interpolation filter, wedge masks — are unreachable from a still
+ * image, so carrying them would be memory and copying for state nothing reads.
+ *
+ * The motion vector CDFs *are* here: intra block copy codes a displacement with the same syntax,
+ * with `MV_INTRABC_CONTEXT` selecting the second of the two contexts.
+ *
+ * ### Why the coefficient CDFs are one slice, not four
+ *
+ * The specification's coefficient tables carry four sets indexed by a quantizer band, and
+ * `init_coeff_cdfs` selects one from `base_q_idx`. Storing only the selected slice makes the
+ * working set a quarter of the size and removes the band from every index computation downstream.
+ *
+ * ### Lifetime
+ *
+ * One context is allocated per decode and reused. {@link cdf_context_init} re-seeds it from the
+ * defaults, which is what every tile does at its start: a still image never carries CDFs forward
+ * to another frame, so the tile-end save the specification describes has no consumer and is not
+ * performed.
+ *
+ * @see AV1 spec 8.4 "Cdf selection process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class CdfContext {
+    /** @type {Uint16Array} `[5][5][14]` */
+    intra_frame_y_mode: Uint16Array;
+    /** @type {Uint16Array} `[13][14]` */
+    uv_mode_cfl_not_allowed: Uint16Array;
+    /** @type {Uint16Array} `[13][15]` */
+    uv_mode_cfl_allowed: Uint16Array;
+    /** @type {Uint16Array} `[8][8]` */
+    angle_delta: Uint16Array;
+    /** @type {Uint16Array} `[3]` */
+    intrabc: Uint16Array;
+    /** @type {Uint16Array} `[4][5]` */
+    partition_w8: Uint16Array;
+    /** @type {Uint16Array} `[4][11]` */
+    partition_w16: Uint16Array;
+    /** @type {Uint16Array} `[4][11]` */
+    partition_w32: Uint16Array;
+    /** @type {Uint16Array} `[4][11]` */
+    partition_w64: Uint16Array;
+    /** @type {Uint16Array} `[4][9]` */
+    partition_w128: Uint16Array;
+    /** @type {Uint16Array} `[3][3]` */
+    tx_8x8: Uint16Array;
+    /** @type {Uint16Array} `[3][4]` */
+    tx_16x16: Uint16Array;
+    /** @type {Uint16Array} `[3][4]` */
+    tx_32x32: Uint16Array;
+    /** @type {Uint16Array} `[3][4]` */
+    tx_64x64: Uint16Array;
+    /** @type {Uint16Array} `[6]` */
+    filter_intra_mode: Uint16Array;
+    /** @type {Uint16Array} `[22][3]` */
+    filter_intra: Uint16Array;
+    /** @type {Uint16Array} `[3][9]` */
+    segment_id: Uint16Array;
+    /** @type {Uint16Array} `[3][3]` */
+    skip: Uint16Array;
+    /** @type {Uint16Array} `[5]` */
+    delta_q: Uint16Array;
+    /** @type {Uint16Array} `[5]` */
+    delta_lf: Uint16Array;
+    /** @type {Uint16Array} `[4][5]`, one per plane-and-more flavour of delta_lf_multi */
+    delta_lf_multi: Uint16Array;
+    /** @type {Uint16Array} `[2][13][8]` */
+    intra_tx_type_set1: Uint16Array;
+    /** @type {Uint16Array} `[3][13][6]` */
+    intra_tx_type_set2: Uint16Array;
+    /** @type {Uint16Array} `[9]` */
+    cfl_sign: Uint16Array;
+    /** @type {Uint16Array} `[6][17]` */
+    cfl_alpha: Uint16Array;
+    /** @type {Uint16Array} `[3]` */
+    use_wiener: Uint16Array;
+    /** @type {Uint16Array} `[3]` */
+    use_sgrproj: Uint16Array;
+    /** @type {Uint16Array} `[4]` */
+    restoration_type: Uint16Array;
+    /** @type {Uint16Array} `[7][8]` */
+    palette_y_size: Uint16Array;
+    /** @type {Uint16Array} `[7][8]` */
+    palette_uv_size: Uint16Array;
+    /** @type {Uint16Array} `[7][3][3]` */
+    palette_y_mode: Uint16Array;
+    /** @type {Uint16Array} `[2][3]` */
+    palette_uv_mode: Uint16Array;
+    /**
+     * Palette colour CDFs for sizes two through eight, luma then chroma.
+     *
+     * Kept as an array of arrays because the alphabets differ in size — three through nine — so a
+     * single flat buffer would need a stride table to index it and would be no faster.
+     * @type {Uint16Array[]}
+     */
+    palette_y_color: Uint16Array[];
+    /** @type {Uint16Array[]} */
+    palette_uv_color: Uint16Array[];
+    /** @type {Uint16Array} `[5]` */
+    mv_joint: Uint16Array;
+    /** @type {Uint16Array} `[2][3]` — one per component */
+    mv_sign: Uint16Array;
+    /** @type {Uint16Array} `[2][12]` */
+    mv_class: Uint16Array;
+    /** @type {Uint16Array} `[2][3]` */
+    mv_class0_bit: Uint16Array;
+    /** @type {Uint16Array} `[2][10][3]` */
+    mv_bit: Uint16Array;
+    /** @type {Uint16Array} `[2][2][5]` */
+    mv_class0_fr: Uint16Array;
+    /** @type {Uint16Array} `[2][5]` */
+    mv_fr: Uint16Array;
+    /** @type {Uint16Array} `[2][3]` */
+    mv_class0_hp: Uint16Array;
+    /** @type {Uint16Array} `[2][3]` */
+    mv_hp: Uint16Array;
+    /** @type {Uint16Array} `[5][13][3]` */
+    txb_skip: Uint16Array;
+    /** @type {Uint16Array} `[2][2][6]` */
+    eob_pt_16: Uint16Array;
+    /** @type {Uint16Array} `[2][2][7]` */
+    eob_pt_32: Uint16Array;
+    /** @type {Uint16Array} `[2][2][8]` */
+    eob_pt_64: Uint16Array;
+    /** @type {Uint16Array} `[2][2][9]` */
+    eob_pt_128: Uint16Array;
+    /** @type {Uint16Array} `[2][2][10]` */
+    eob_pt_256: Uint16Array;
+    /** @type {Uint16Array} `[2][11]` */
+    eob_pt_512: Uint16Array;
+    /** @type {Uint16Array} `[2][12]` */
+    eob_pt_1024: Uint16Array;
+    /** @type {Uint16Array} `[5][2][9][3]` */
+    eob_extra: Uint16Array;
+    /** @type {Uint16Array} `[2][3][3]` */
+    dc_sign: Uint16Array;
+    /** @type {Uint16Array} `[5][2][4][4]` */
+    coeff_base_eob: Uint16Array;
+    /** @type {Uint16Array} `[5][2][42][5]` */
+    coeff_base: Uint16Array;
+    /** @type {Uint16Array} `[5][2][21][5]` */
+    coeff_br: Uint16Array;
+}
+//# sourceMappingURL=CdfContext.d.ts.map

package/src/avif/native/av1/entropy/CdfContext.d.ts.map

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