@woosh/meep-engine 3.9.0 → 3.10.0

package/src/avif/native/av1/entropy/coefficient_context.js

@@ -0,0 +1,325 @@
+import {
+    COEFF_BASE_RANGE,
+    NUM_BASE_LEVELS,
+    SIG_COEF_CONTEXTS,
+    SIG_REF_DIFF_OFFSET_NUM,
+    TX_CLASS_2D,
+    TX_CLASS_VERT
+} from "../tables/av1_symbols.js";
+import { SUBSAMPLED_SIZE, TX_HEIGHT, TX_WIDTH } from "../tables/block_tables.js";
+import { BLOCK_HEIGHT, BLOCK_WIDTH } from "../tables/derived_block_tables.js";
+import {
+    COEFF_BASE_CTX_OFFSET,
+    COEFF_BASE_POS_CTX_OFFSET,
+    MAG_REF_OFFSET_WITH_TX_CLASS,
+    SIG_REF_DIFF_OFFSET
+} from "../tables/coefficient_tables.js";
+
+/**
+ * The contexts coefficient coding conditions its probabilities on.
+ *
+ * Shared rather than duplicated: an encoder has to derive every one of these identically to the
+ * decoder, and a context that drifted by one would desynchronise the arithmetic coder several
+ * blocks later, somewhere that looks nothing like the mistake.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} x4
+ * @param {number} y4
+ * @param {number} w4
+ * @param {number} h4
+ * @param {number} tx_size
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `all_zero`
+ */
+export function get_all_zero_ctx(ctx, plane, x4, y4, w4, h4, tx_size) {
+    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
+    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
+
+    const max_x4 = ctx.mi_cols >> sub_x;
+    const max_y4 = ctx.mi_rows >> sub_y;
+
+    const w = TX_WIDTH[tx_size];
+    const h = TX_HEIGHT[tx_size];
+
+    const plane_size = SUBSAMPLED_SIZE[(ctx.mi_size * 2 + sub_x) * 2 + sub_y];
+    const bw = BLOCK_WIDTH[plane_size];
+    const bh = BLOCK_HEIGHT[plane_size];
+
+    const above_level = ctx.above_level_context[plane];
+    const above_dc = ctx.above_dc_context[plane];
+    const left_level = ctx.left_level_context[plane];
+    const left_dc = ctx.left_dc_context[plane];
+
+    if (plane === 0) {
+        let top = 0;
+        let left = 0;
+
+        for (let k = 0; k < w4; k++) {
+            if (x4 + k < max_x4) {
+                top = Math.max(top, above_level[x4 + k]);
+            }
+        }
+
+        for (let k = 0; k < h4; k++) {
+            if (y4 + k < max_y4) {
+                left = Math.max(left, left_level[y4 + k]);
+            }
+        }
+
+        top = Math.min(top, 255);
+        left = Math.min(left, 255);
+
+        if (bw === w && bh === h) {
+            return 0;
+        }
+
+        if (top === 0 && left === 0) {
+            return 1;
+        }
+
+        if (top === 0 || left === 0) {
+            return 2 + (Math.max(top, left) > 3 ? 1 : 0);
+        }
+
+        if (Math.max(top, left) <= 3) {
+            return 4;
+        }
+
+        if (Math.min(top, left) <= 3) {
+            return 5;
+        }
+
+        return 6;
+    }
+
+    let above = 0;
+    let left = 0;
+
+    for (let i = 0; i < w4; i++) {
+        if (x4 + i < max_x4) {
+            above |= above_level[x4 + i];
+            above |= above_dc[x4 + i];
+        }
+    }
+
+    for (let i = 0; i < h4; i++) {
+        if (y4 + i < max_y4) {
+            left |= left_level[y4 + i];
+            left |= left_dc[y4 + i];
+        }
+    }
+
+    let result = (above !== 0 ? 1 : 0) + (left !== 0 ? 1 : 0) + 7;
+
+    if (bw * bh > w * h) {
+        result += 3;
+    }
+
+    return result;
+}
+
+/**
+ * @param {Int32Array} quant
+ * @param {number} tx_class
+ * @param {number} bwl
+ * @param {number} width
+ * @param {number} height
+ * @param {number} pos
+ * @param {number} c
+ * @param {number} is_eob
+ * @param {number} tx_size
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `get_coeff_base_ctx`
+ */
+export function get_coeff_base_ctx(quant, tx_class, bwl, width, height, pos, c, is_eob, tx_size) {
+    if (is_eob === 1) {
+        if (c === 0) {
+            return SIG_COEF_CONTEXTS - 4;
+        }
+
+        if (c <= (height << bwl) / 8) {
+            return SIG_COEF_CONTEXTS - 3;
+        }
+
+        if (c <= (height << bwl) / 4) {
+            return SIG_COEF_CONTEXTS - 2;
+        }
+
+        return SIG_COEF_CONTEXTS - 1;
+    }
+
+    const row = pos >> bwl;
+    const col = pos - (row << bwl);
+
+    let mag = 0;
+
+    const offset_base = tx_class * SIG_REF_DIFF_OFFSET_NUM * 2;
+
+    for (let idx = 0; idx < SIG_REF_DIFF_OFFSET_NUM; idx++) {
+        const ref_row = row + SIG_REF_DIFF_OFFSET[offset_base + idx * 2];
+        const ref_col = col + SIG_REF_DIFF_OFFSET[offset_base + idx * 2 + 1];
+
+        if (ref_row >= 0 && ref_col >= 0 && ref_row < height && ref_col < width) {
+            mag += Math.min(Math.abs(quant[(ref_row << bwl) + ref_col]), 3);
+        }
+    }
+
+    const base = Math.min((mag + 1) >> 1, 4);
+
+    if (tx_class === TX_CLASS_2D) {
+        if (row === 0 && col === 0) {
+            return 0;
+        }
+
+        return base + COEFF_BASE_CTX_OFFSET[(tx_size * 5 + Math.min(row, 4)) * 5 + Math.min(col, 4)];
+    }
+
+    const idx = tx_class === TX_CLASS_VERT ? row : col;
+
+    return base + COEFF_BASE_POS_CTX_OFFSET[Math.min(idx, 2)];
+}
+
+/**
+ * @param {Int32Array} quant
+ * @param {number} tx_class
+ * @param {number} bwl
+ * @param {number} width
+ * @param {number} height
+ * @param {number} pos
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `coeff_br`
+ */
+export function get_coeff_br_ctx(quant, tx_class, bwl, width, height, pos) {
+    const row = pos >> bwl;
+    const col = pos - (row << bwl);
+
+    let mag = 0;
+
+    const offset_base = tx_class * 3 * 2;
+
+    for (let idx = 0; idx < 3; idx++) {
+        const ref_row = row + MAG_REF_OFFSET_WITH_TX_CLASS[offset_base + idx * 2];
+        const ref_col = col + MAG_REF_OFFSET_WITH_TX_CLASS[offset_base + idx * 2 + 1];
+
+        if (ref_row >= 0 && ref_col >= 0 && ref_row < height && ref_col < width) {
+            // the specification indexes Quant by `refRow * txw + refCol` here and by
+            // `(refRow << bwl) + refCol` in get_coeff_base_ctx; `txw` is the adjusted transform's
+            // width, which is `1 << bwl`, so the two agree
+            mag += Math.min(quant[ref_row * width + ref_col], COEFF_BASE_RANGE + NUM_BASE_LEVELS + 1);
+        }
+    }
+
+    mag = Math.min((mag + 1) >> 1, 6);
+
+    if (pos === 0) {
+        return mag;
+    }
+
+    if (tx_class === TX_CLASS_2D) {
+        return row < 2 && col < 2 ? mag + 7 : mag + 14;
+    }
+
+    if (tx_class === 1) {
+        return col === 0 ? mag + 7 : mag + 14;
+    }
+
+    return row === 0 ? mag + 7 : mag + 14;
+}
+
+/**
+ * Clear the coefficient contexts a block covers, which is what a skipped block leaves behind.
+ *
+ * A block coded with `skip` writes no coefficients at all, so both sides have to agree that it
+ * contributed nothing — not that it contributed whatever the block before it did.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} bw4 block width in 4x4 units
+ * @param {number} bh4
+ * @see AV1 spec 5.11.6, `reset_block_context`
+ */
+export function reset_block_context(ctx, bw4, bh4) {
+    const planes = 1 + 2 * ctx.has_chroma;
+
+    for (let plane = 0; plane < planes; plane++) {
+        const sub_x = plane > 0 ? ctx.subsampling_x : 0;
+        const sub_y = plane > 0 ? ctx.subsampling_y : 0;
+
+        const above_level = ctx.above_level_context[plane];
+        const above_dc = ctx.above_dc_context[plane];
+        const left_level = ctx.left_level_context[plane];
+        const left_dc = ctx.left_dc_context[plane];
+
+        for (let i = ctx.mi_col >> sub_x; i < (ctx.mi_col + bw4) >> sub_x; i++) {
+            above_level[i] = 0;
+            above_dc[i] = 0;
+        }
+
+        for (let i = ctx.mi_row >> sub_y; i < (ctx.mi_row + bh4) >> sub_y; i++) {
+            left_level[i] = 0;
+            left_dc[i] = 0;
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} x4
+ * @param {number} y4
+ * @param {number} w4
+ * @param {number} h4
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `dc_sign`
+ */
+export function get_dc_sign_ctx(ctx, plane, x4, y4, w4, h4) {
+    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
+    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
+
+    const max_x4 = ctx.mi_cols >> sub_x;
+    const max_y4 = ctx.mi_rows >> sub_y;
+
+    const above_dc = ctx.above_dc_context[plane];
+    const left_dc = ctx.left_dc_context[plane];
+
+    let dc_sign = 0;
+
+    for (let k = 0; k < w4; k++) {
+        if (x4 + k < max_x4) {
+            const sign = above_dc[x4 + k];
+
+            if (sign === 1) {
+                dc_sign--;
+            } else if (sign === 2) {
+                dc_sign++;
+            }
+        }
+    }
+
+    for (let k = 0; k < h4; k++) {
+        if (y4 + k < max_y4) {
+            const sign = left_dc[y4 + k];
+
+            if (sign === 1) {
+                dc_sign--;
+            } else if (sign === 2) {
+                dc_sign++;
+            }
+        }
+    }
+
+    if (dc_sign < 0) {
+        return 1;
+    }
+
+    if (dc_sign > 0) {
+        return 2;
+    }
+
+    return 0;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Choosing the probabilities a partition decision is coded with.
+ *
+ * Shared with the encoder, which has to select exactly the same CDF and derive exactly the same
+ * context, or the two sides disagree about what a symbol meant.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} b_size
+ * @param {number} avail_u
+ * @param {number} avail_l
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `partition`
+ */
+export function partition_context(ctx: Av1FrameContext, r: number, c: number, b_size: number, avail_u: number, avail_l: number): number;
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} b_size
+ * @param {number} context
+ * @returns {PartitionCdf} the context's own, refilled — valid until the next call
+ */
+export function partition_cdf(ctx: Av1FrameContext, b_size: number, context: number): PartitionCdf;
+/**
+ * The probability mass a CDF assigns to one symbol.
+ * @param {Uint16Array} cdf
+ * @param {number} base
+ * @param {number} symbol
+ * @returns {number}
+ */
+export function probability_of(cdf: Uint16Array, base: number, symbol: number): number;
+/**
+ * Which probabilities a partition decision is coded against, and where in them.
+ *
+ * A struct rather than a returned object literal: the encoder's partition search asks this question
+ * ten times per node and a hundred thousand times per picture, and an object literal is an
+ * allocation each time. One per frame context, refilled and handed back.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PartitionCdf {
+    /** @type {Uint16Array|null} */
+    cdf: Uint16Array | null;
+    /** @type {number} */
+    offset: number;
+    /** @type {number} */
+    symbols: number;
+}
+//# sourceMappingURL=partition_cdf.d.ts.map

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

@@ -0,0 +1 @@
+{"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/partition_cdf.js

@@ -0,0 +1,98 @@
+import { MI_HEIGHT_LOG2, MI_WIDTH_LOG2 } from "../tables/block_tables.js";
+
+/**
+ * Choosing the probabilities a partition decision is coded with.
+ *
+ * Shared with the encoder, which has to select exactly the same CDF and derive exactly the same
+ * context, or the two sides disagree about what a symbol meant.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} b_size
+ * @param {number} avail_u
+ * @param {number} avail_l
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `partition`
+ */
+export function partition_context(ctx, r, c, b_size, avail_u, avail_l) {
+    const bsl = MI_WIDTH_LOG2[b_size];
+
+    const above = avail_u === 1 && MI_WIDTH_LOG2[ctx.mi_sizes[(r - 1) * ctx.mi_stride + c]] < bsl ? 1 : 0;
+    const left = avail_l === 1 && MI_HEIGHT_LOG2[ctx.mi_sizes[r * ctx.mi_stride + c - 1]] < bsl ? 1 : 0;
+
+    return left * 2 + above;
+}
+
+/**
+ * Which probabilities a partition decision is coded against, and where in them.
+ *
+ * A struct rather than a returned object literal: the encoder's partition search asks this question
+ * ten times per node and a hundred thousand times per picture, and an object literal is an
+ * allocation each time. One per frame context, refilled and handed back.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PartitionCdf {
+    /** @type {Uint16Array|null} */
+    cdf = null;
+
+    /** @type {number} */
+    offset = 0;
+
+    /** @type {number} */
+    symbols = 0;
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} b_size
+ * @param {number} context
+ * @returns {PartitionCdf} the context's own, refilled — valid until the next call
+ */
+export function partition_cdf(ctx, b_size, context) {
+    const bsl = MI_WIDTH_LOG2[b_size];
+
+    const selected = ctx.partition_selection;
+
+    if (bsl === 1) {
+        selected.cdf = ctx.cdf.partition_w8;
+        selected.offset = context * 5;
+        selected.symbols = 4;
+    } else if (bsl === 2) {
+        selected.cdf = ctx.cdf.partition_w16;
+        selected.offset = context * 11;
+        selected.symbols = 10;
+    } else if (bsl === 3) {
+        selected.cdf = ctx.cdf.partition_w32;
+        selected.offset = context * 11;
+        selected.symbols = 10;
+    } else if (bsl === 4) {
+        selected.cdf = ctx.cdf.partition_w64;
+        selected.offset = context * 11;
+        selected.symbols = 10;
+    } else {
+        selected.cdf = ctx.cdf.partition_w128;
+        selected.offset = context * 9;
+        selected.symbols = 8;
+    }
+
+    return selected;
+}
+
+/**
+ * The probability mass a CDF assigns to one symbol.
+ * @param {Uint16Array} cdf
+ * @param {number} base
+ * @param {number} symbol
+ * @returns {number}
+ */
+export function probability_of(cdf, base, symbol) {
+    return cdf[base + symbol] - cdf[base + symbol - 1];
+}

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

@@ -0,0 +1,37 @@
+/**
+ * What one symbol would cost to write, without writing it.
+ *
+ * The interval the arithmetic coder gives a symbol is not `cdf[s] - cdf[s-1]`: it is that
+ * probability pushed through the same shifts {@link SymbolWriter.write_symbol} applies, plus the
+ * floor of {@link EC_MIN_PROB} every symbol gets so that none is ever impossible. Measuring the
+ * partition rather than the CDF is what keeps the estimate honest for the rare symbols — which are
+ * the expensive ones, and therefore the ones a decision turns on.
+ *
+ * Evaluated at a range of `1 << 15`, which is the range renormalisation keeps the coder near and
+ * makes the answer independent of where in the stream the symbol lands.
+ *
+ * @param {Uint16Array} cdf in specification form
+ * @param {number} offset
+ * @param {number} symbol `0 .. n - 1`
+ * @param {number} n number of symbols
+ * @returns {number} cost in {@link COST_ONE_BIT} units
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function symbol_cost(cdf: Uint16Array, offset: number, symbol: number, n: number): number;
+/**
+ * Fixed-point unit the costs here are counted in: a bit is this many.
+ *
+ * A tenth of a percent of a bit. Fine enough that ten thousand near-certain symbols — which cost a
+ * hundredth of a bit each and are where a coarse table goes wrong — still add up to within a bit of
+ * the truth, and coarse enough that the whole table is sixteen bit.
+ * @type {number}
+ */
+export const COST_ONE_BIT: number;
+/**
+ * What one even-odds bit costs. Slightly more than a bit, because of the same floor.
+ * @type {number}
+ */
+export const BOOL_COST: number;
+//# sourceMappingURL=symbol_cost.d.ts.map

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

@@ -0,0 +1 @@
+{"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/entropy/symbol_cost.js

@@ -0,0 +1,76 @@
+import { EC_MIN_PROB, EC_PROB_SHIFT } from "../tables/av1_symbols.js";
+
+/**
+ * Fixed-point unit the costs here are counted in: a bit is this many.
+ *
+ * A tenth of a percent of a bit. Fine enough that ten thousand near-certain symbols — which cost a
+ * hundredth of a bit each and are where a coarse table goes wrong — still add up to within a bit of
+ * the truth, and coarse enough that the whole table is sixteen bit.
+ * @type {number}
+ */
+export const COST_ONE_BIT = 1024;
+
+/**
+ * `-log2(p)` for every probability the symbol coder can hold, in {@link COST_ONE_BIT} units.
+ *
+ * Indexed by the probability in fifteen-bit units. The rarest representable symbol costs fifteen
+ * bits, so the largest entry is `15 * COST_ONE_BIT`, which is well inside sixteen bits.
+ * @type {Uint16Array}
+ */
+const COST_OF_PROBABILITY = build_cost_table();
+
+/**
+ * @returns {Uint16Array}
+ */
+function build_cost_table() {
+    const table = new Uint16Array(32769);
+
+    for (let p = 1; p <= 32768; p++) {
+        table[p] = Math.round(-Math.log2(p / 32768) * COST_ONE_BIT);
+    }
+
+    // a probability of zero cannot occur — the coder floors every symbol at EC_MIN_PROB — but an
+    // index of zero must still return a number rather than a hole
+    table[0] = table[1];
+
+    return table;
+}
+
+/**
+ * What one symbol would cost to write, without writing it.
+ *
+ * The interval the arithmetic coder gives a symbol is not `cdf[s] - cdf[s-1]`: it is that
+ * probability pushed through the same shifts {@link SymbolWriter.write_symbol} applies, plus the
+ * floor of {@link EC_MIN_PROB} every symbol gets so that none is ever impossible. Measuring the
+ * partition rather than the CDF is what keeps the estimate honest for the rare symbols — which are
+ * the expensive ones, and therefore the ones a decision turns on.
+ *
+ * Evaluated at a range of `1 << 15`, which is the range renormalisation keeps the coder near and
+ * makes the answer independent of where in the stream the symbol lands.
+ *
+ * @param {Uint16Array} cdf in specification form
+ * @param {number} offset
+ * @param {number} symbol `0 .. n - 1`
+ * @param {number} n number of symbols
+ * @returns {number} cost in {@link COST_ONE_BIT} units
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function symbol_cost(cdf, offset, symbol, n) {
+    const high = (((128 * (((1 << 15) - cdf[offset + symbol]) >> EC_PROB_SHIFT)) >> (7 - EC_PROB_SHIFT)) + EC_MIN_PROB * (n - symbol - 1)) | 0;
+
+    const low = symbol > 0
+        ? (((128 * (((1 << 15) - cdf[offset + symbol - 1]) >> EC_PROB_SHIFT)) >> (7 - EC_PROB_SHIFT)) + EC_MIN_PROB * (n - symbol)) | 0
+        : 1 << 15;
+
+    return COST_OF_PROBABILITY[low - high];
+}
+
+/**
+ * What one even-odds bit costs. Slightly more than a bit, because of the same floor.
+ * @type {number}
+ */
+export const BOOL_COST = COST_OF_PROBABILITY[
+    (1 << 15) - ((((128 * ((1 << 14) >> EC_PROB_SHIFT)) >> (7 - EC_PROB_SHIFT)) + EC_MIN_PROB) | 0)
+];

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

@@ -0,0 +1,15 @@
+/**
+ * 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: Av1FrameContext): void;
+//# sourceMappingURL=cdef.d.ts.map

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

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