@woosh/meep-engine 3.14.2 → 3.14.4

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

@@ -1 +0,0 @@
-{"version":3,"file":"quantise.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/quantise.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,sEAfW,MAAM,WACN,MAAM,WACN,MAAM,gBACN,UAAU,UACV,UAAU,iBACV,MAAM,QAEN,WAAW,GACT,MAAM,CA2FlB;AAED;;;;;;;;;;;GAWG;AACH,sEAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAclB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"write_coefficients.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/write_coefficients.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAnBW,MAAM,SAEN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,UACN,UAAU,iBACV,MAAM,OACN,MAAM,GAIJ,MAAM,CAoKlB"}

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

@@ -1 +0,0 @@
-{"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_transform_type.d.ts.map

@@ -1 +0,0 @@
-{"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/entropy/CdfContext.d.ts.map

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"SymbolReader.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/entropy/SymbolReader.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACI,yBAAyB;IACzB,MADW,UAAU,CACT;IAEZ,4DAA4D;IAC5D,eADW,MAAM,CACC;IAElB,4FAA4F;IAC5F,cADW,MAAM,CACA;IAEjB,2DAA2D;IAC3D,KADW,MAAM,CACT;IAER,mCAAmC;IACnC,cADW,MAAM,CACA;IAEjB,mCAAmC;IACnC,cADW,MAAM,CACA;IAEjB,kFAAkF;IAClF,iBADW,MAAM,CACG;IAEpB;;;;OAIG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;;;;;OASG;IACH,WAPW,UAAU,eACV,MAAM,QACN,MAAM,uBACN,MAAM,GACJ,YAAY,CAuBxB;IA2CD;;;;;;;;OAQG;IACH,iBANW,WAAW,UACX,MAAM,KACN,MAAM,GACJ,MAAM,CA0ElB;IAED;;;;;;;;;OASG;IACH,aAHa,MAAM,CA6ClB;IAED;;;;;;OAMG;IACH,gBAJW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;OAMG;IACH,WAJW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;;;;;OASG;IACH,aAOC;;CACJ"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"SymbolWriter.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/entropy/SymbolWriter.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IACI,gFAAgF;IAChF,UADW,WAAW,CACuB;IAE7C,8DAA8D;IAC9D,iBADW,MAAM,CACG;IAEpB,uFAAuF;IACvF,KADW,MAAM,CACT;IAER,2FAA2F;IAC3F,OADW,MAAM,CACH;IAEd,0EAA0E;IAC1E,OADW,MAAM,CACN;IAEX;;OAEG;IACH,oBAFU,MAAM,CAEO;IAEvB,mEAAmE;IACnE,SADW,MAAM,CACL;IAEZ,mGAAmG;IACnG,MADW,MAAM,CACR;IAET;;;;OAIG;IACH,2BAHW,MAAM,GACJ,YAAY,CAYxB;IAED;;;;;OAKG;IACH,iBAFa,YAAY,CAQxB;IAiED;;;;;;;;OAQG;IACH,qBALW,MAAM,OACN,WAAW,UACX,MAAM,KACN,MAAM,QAuDhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAoBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,KACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,UAFa,UAAU,CA8CtB;;CACJ"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"coefficient_context.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/entropy/coefficient_context.js"],"names":[],"mappings":"AAiBA;;;;;;;;;GASG;AAEH;;;;;;;;;;GAUG;AACH,8DATW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,GACJ,MAAM,CAwFlB;AAED;;;;;;;;;;;;GAYG;AACH,0CAZW,UAAU,YACV,MAAM,OACN,MAAM,SACN,MAAM,UACN,MAAM,OACN,MAAM,KACN,MAAM,UACN,MAAM,WACN,MAAM,GACJ,MAAM,CAiDlB;AAED;;;;;;;;;GASG;AACH,wCATW,UAAU,YACV,MAAM,OACN,MAAM,SACN,MAAM,UACN,MAAM,OACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;;;;;;GAUG;AACH,+DAJW,MAAM,OACN,MAAM,QAyBhB;AAED;;;;;;;;;GASG;AACH,6DARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgDlB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"partition_cdf.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/entropy/partition_cdf.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH;;;;;;;;;GASG;AACH,2DARW,MAAM,KACN,MAAM,UACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,MAAM,CAUlB;AAuBD;;;;;GAKG;AACH,4DAJW,MAAM,WACN,MAAM,GACJ,YAAY,CA8BxB;AAED;;;;;;GAMG;AACH,oCALW,WAAW,QACX,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAlED;;;;;;;;;GASG;AACH;IACI,+BAA+B;IAC/B,KADW,WAAW,GAAC,IAAI,CAChB;IAEX,qBAAqB;IACrB,QADW,MAAM,CACN;IAEX,qBAAqB;IACrB,SADW,MAAM,CACL;CACf"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"symbol_cost.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/entropy/symbol_cost.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iCATW,WAAW,UACX,MAAM,UACN,MAAM,KACN,MAAM,GACJ,MAAM,CAalB;AAjED;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEiB;AA2DjC;;;GAGG;AACH,wBAFU,MAAM,CAId"}

package/src/avif/native/av1/filter/cdef.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cdef.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/filter/cdef.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,uDAWC"}

package/src/avif/native/av1/filter/cdef.js

@@ -1,313 +0,0 @@
-import { clamp } from "../../../../core/math/clamp.js";
-import { MI_SIZE } from "../tables/av1_symbols.js";
-import { CDEF_DIRECTIONS, CDEF_PRI_TAPS, CDEF_SEC_TAPS, CDEF_UV_DIR, DIV_TABLE } from "../tables/filter_tables.js";
-import { floor_log2 } from "../util/floor_log2.js";
-
-/**
- * Accumulators for the direction search. Module-level: the search runs once per 8x8 block and
- * allocating these per block would dominate its cost.
- * @type {Int32Array}
- */
-const PARTIAL = new Int32Array(8 * 15);
-
-/** @type {Float64Array} costs reach ~2^40, past what an Int32Array can hold */
-const COST = new Float64Array(8);
-
-/**
- * Apply constrained directional enhancement to a decoded frame.
- *
- * Reads from `ctx.planes` and writes to `ctx.cdef_planes`, which the caller must have sized to
- * match. The two cannot be the same buffer: the filter reads its neighbourhood from the *unfiltered*
- * frame, so filtering in place would feed already-filtered samples back into later blocks.
- *
- * @param {Av1FrameContext} ctx
- * @see AV1 spec 7.15 "CDEF process"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function apply_cdef(ctx) {
-    const cdef_size4 = 16;
-    const mask4 = ~(cdef_size4 - 1);
-
-    for (let r = 0; r < ctx.mi_rows; r += 2) {
-        for (let c = 0; c < ctx.mi_cols; c += 2) {
-            const idx = ctx.cdef_idx[(r & mask4) * ctx.mi_stride + (c & mask4)];
-
-            cdef_block(ctx, r, c, idx);
-        }
-    }
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} r
- * @param {number} c
- * @param {number} idx `-1` when the block is not filtered
- * @see AV1 spec 7.15.1 "CDEF block process"
- */
-function cdef_block(ctx, r, c, idx) {
-    copy_block(ctx, r, c);
-
-    if (idx === -1) {
-        return;
-    }
-
-    const stride = ctx.mi_stride;
-
-    const skip = ctx.skips[r * stride + c] === 1
-        && ctx.skips[Math.min(r + 1, ctx.mi_rows - 1) * stride + c] === 1
-        && ctx.skips[r * stride + Math.min(c + 1, ctx.mi_cols - 1)] === 1
-        && ctx.skips[Math.min(r + 1, ctx.mi_rows - 1) * stride + Math.min(c + 1, ctx.mi_cols - 1)] === 1;
-
-    if (skip) {
-        return;
-    }
-
-    const frame = ctx.frame;
-
-    const coefficient_shift = ctx.bit_depth - 8;
-
-    const direction = cdef_direction(ctx, r, c);
-
-    const y_dir = direction & 0xff;
-    const variance = direction >> 8;
-
-    let primary = frame.cdef_y_pri_strength[idx] << coefficient_shift;
-    const secondary = frame.cdef_y_sec_strength[idx] << coefficient_shift;
-
-    const dir = primary === 0 ? 0 : y_dir;
-
-    const variance_strength = (variance >> 6) !== 0 ? Math.min(floor_log2(variance >> 6), 12) : 0;
-
-    primary = variance !== 0 ? (primary * (4 + variance_strength) + 8) >> 4 : 0;
-
-    cdef_filter(ctx, 0, r, c, primary, secondary, frame.cdef_damping + coefficient_shift, dir);
-
-    if (ctx.num_planes === 1) {
-        return;
-    }
-
-    const uv_primary = frame.cdef_uv_pri_strength[idx] << coefficient_shift;
-    const uv_secondary = frame.cdef_uv_sec_strength[idx] << coefficient_shift;
-
-    const uv_dir = uv_primary === 0
-        ? 0
-        : CDEF_UV_DIR[(ctx.subsampling_x * 2 + ctx.subsampling_y) * 8 + y_dir];
-
-    const uv_damping = frame.cdef_damping + coefficient_shift - 1;
-
-    cdef_filter(ctx, 1, r, c, uv_primary, uv_secondary, uv_damping, uv_dir);
-    cdef_filter(ctx, 2, r, c, uv_primary, uv_secondary, uv_damping, uv_dir);
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} r
- * @param {number} c
- */
-function copy_block(ctx, r, c) {
-    for (let plane = 0; plane < ctx.num_planes; plane++) {
-        const sub_x = plane > 0 ? ctx.subsampling_x : 0;
-        const sub_y = plane > 0 ? ctx.subsampling_y : 0;
-
-        const start_y = (r * MI_SIZE) >> sub_y;
-        const start_x = (c * MI_SIZE) >> sub_x;
-
-        const end_y = start_y + (MI_SIZE * 2 >> sub_y);
-        const end_x = start_x + (MI_SIZE * 2 >> sub_x);
-
-        const source = ctx.planes[plane];
-        const destination = ctx.cdef_planes[plane];
-        const stride = ctx.plane_stride[plane];
-
-        for (let y = start_y; y < end_y; y++) {
-            const row = y * stride;
-
-            for (let x = start_x; x < end_x; x++) {
-                destination[row + x] = source[row + x];
-            }
-        }
-    }
-}
-
-/**
- * Find the dominant direction of an 8x8 luma block and how strongly it dominates.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} r
- * @param {number} c
- * @returns {number} the direction in the low byte, the variance above it
- * @see AV1 spec 7.15.2 "CDEF direction process"
- */
-function cdef_direction(ctx, r, c) {
-    PARTIAL.fill(0);
-    COST.fill(0);
-
-    const samples = ctx.planes[0];
-    const stride = ctx.plane_stride[0];
-
-    const x0 = c << 2;
-    const y0 = r << 2;
-
-    const shift = ctx.bit_depth - 8;
-
-    for (let i = 0; i < 8; i++) {
-        const row = (y0 + i) * stride + x0;
-
-        for (let j = 0; j < 8; j++) {
-            const x = (samples[row + j] >> shift) - 128;
-
-            PARTIAL[0 * 15 + i + j] += x;
-            PARTIAL[1 * 15 + i + (j >> 1)] += x;
-            PARTIAL[2 * 15 + i] += x;
-            PARTIAL[3 * 15 + 3 + i - (j >> 1)] += x;
-            PARTIAL[4 * 15 + 7 + i - j] += x;
-            PARTIAL[5 * 15 + 3 - (i >> 1) + j] += x;
-            PARTIAL[6 * 15 + j] += x;
-            PARTIAL[7 * 15 + (i >> 1) + j] += x;
-        }
-    }
-
-    for (let i = 0; i < 8; i++) {
-        COST[2] += PARTIAL[2 * 15 + i] * PARTIAL[2 * 15 + i];
-        COST[6] += PARTIAL[6 * 15 + i] * PARTIAL[6 * 15 + i];
-    }
-
-    COST[2] *= DIV_TABLE[8];
-    COST[6] *= DIV_TABLE[8];
-
-    for (let i = 0; i < 7; i++) {
-        COST[0] += (PARTIAL[0 * 15 + i] * PARTIAL[0 * 15 + i]
-            + PARTIAL[0 * 15 + 14 - i] * PARTIAL[0 * 15 + 14 - i]) * DIV_TABLE[i + 1];
-
-        COST[4] += (PARTIAL[4 * 15 + i] * PARTIAL[4 * 15 + i]
-            + PARTIAL[4 * 15 + 14 - i] * PARTIAL[4 * 15 + 14 - i]) * DIV_TABLE[i + 1];
-    }
-
-    COST[0] += PARTIAL[0 * 15 + 7] * PARTIAL[0 * 15 + 7] * DIV_TABLE[8];
-    COST[4] += PARTIAL[4 * 15 + 7] * PARTIAL[4 * 15 + 7] * DIV_TABLE[8];
-
-    for (let i = 1; i < 8; i += 2) {
-        for (let j = 0; j < 5; j++) {
-            COST[i] += PARTIAL[i * 15 + 3 + j] * PARTIAL[i * 15 + 3 + j];
-        }
-
-        COST[i] *= DIV_TABLE[8];
-
-        for (let j = 0; j < 3; j++) {
-            COST[i] += (PARTIAL[i * 15 + j] * PARTIAL[i * 15 + j]
-                + PARTIAL[i * 15 + 10 - j] * PARTIAL[i * 15 + 10 - j]) * DIV_TABLE[2 * j + 2];
-        }
-    }
-
-    let best_cost = 0;
-    let y_dir = 0;
-
-    for (let i = 0; i < 8; i++) {
-        if (COST[i] > best_cost) {
-            best_cost = COST[i];
-            y_dir = i;
-        }
-    }
-
-    const variance = Math.floor((best_cost - COST[(y_dir + 4) & 7]) / 1024);
-
-    return (variance << 8) | y_dir;
-}
-
-/**
- * @param {number} difference
- * @param {number} threshold
- * @param {number} damping
- * @returns {number}
- * @see AV1 spec 7.15.3, `constrain`
- */
-function constrain(difference, threshold, damping) {
-    if (threshold === 0) {
-        return 0;
-    }
-
-    const damping_adjusted = Math.max(0, damping - floor_log2(threshold));
-
-    const sign = difference < 0 ? -1 : 1;
-    const magnitude = Math.abs(difference);
-
-    return sign * clamp(threshold - (magnitude >> damping_adjusted), 0, magnitude);
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} plane
- * @param {number} r
- * @param {number} c
- * @param {number} primary
- * @param {number} secondary
- * @param {number} damping
- * @param {number} dir
- * @see AV1 spec 7.15.3 "CDEF filter process"
- */
-function cdef_filter(ctx, plane, r, c, primary, secondary, damping, dir) {
-    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
-    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
-
-    const x0 = (c * MI_SIZE) >> sub_x;
-    const y0 = (r * MI_SIZE) >> sub_y;
-
-    const w = 8 >> sub_x;
-    const h = 8 >> sub_y;
-
-    const source = ctx.planes[plane];
-    const destination = ctx.cdef_planes[plane];
-    const stride = ctx.plane_stride[plane];
-
-    const coefficient_shift = ctx.bit_depth - 8;
-    const tap_index = (primary >> coefficient_shift) & 1;
-
-    const plane_width = ctx.plane_width[plane];
-    const plane_height = ctx.plane_height[plane];
-
-    for (let i = 0; i < h; i++) {
-        for (let j = 0; j < w; j++) {
-            const x = source[(y0 + i) * stride + x0 + j];
-
-            let sum = 0;
-            let max = x;
-            let min = x;
-
-            for (let k = 0; k < 2; k++) {
-                for (let sign = -1; sign <= 1; sign += 2) {
-                    const primary_y = y0 + i + sign * CDEF_DIRECTIONS[(dir * 2 + k) * 2];
-                    const primary_x = x0 + j + sign * CDEF_DIRECTIONS[(dir * 2 + k) * 2 + 1];
-
-                    if (primary_x >= 0 && primary_x < plane_width && primary_y >= 0 && primary_y < plane_height) {
-                        const p = source[primary_y * stride + primary_x];
-
-                        sum += CDEF_PRI_TAPS[tap_index * 2 + k] * constrain(p - x, primary, damping);
-
-                        max = Math.max(p, max);
-                        min = Math.min(p, min);
-                    }
-
-                    for (let offset = -2; offset <= 2; offset += 4) {
-                        const secondary_dir = (dir + offset) & 7;
-
-                        const secondary_y = y0 + i + sign * CDEF_DIRECTIONS[(secondary_dir * 2 + k) * 2];
-                        const secondary_x = x0 + j + sign * CDEF_DIRECTIONS[(secondary_dir * 2 + k) * 2 + 1];
-
-                        if (secondary_x >= 0 && secondary_x < plane_width && secondary_y >= 0 && secondary_y < plane_height) {
-                            const s = source[secondary_y * stride + secondary_x];
-
-                            sum += CDEF_SEC_TAPS[tap_index * 2 + k] * constrain(s - x, secondary, damping);
-
-                            max = Math.max(s, max);
-                            min = Math.min(s, min);
-                        }
-                    }
-                }
-            }
-
-            destination[(y0 + i) * stride + x0 + j] = clamp(x + ((8 + sum - (sum < 0 ? 1 : 0)) >> 4), min, max);
-        }
-    }
-}

package/src/avif/native/av1/filter/loop_filter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loop_filter.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/filter/loop_filter.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH,8DAuBC"}