@woosh/meep-engine 3.9.0 → 3.11.0

package/src/avif/native/av1/decode/get_scan.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The scan order a transform block's coefficients are coded in.
+ *
+ * Transforms larger than 32 in either direction reuse a smaller scan: only the top-left 32x32
+ * carries coefficients, so there is nothing for a larger scan to visit.
+ *
+ * @param {number} tx_size
+ * @param {number} plane_tx_type
+ * @returns {Uint16Array}
+ * @see AV1 spec 5.11.41 "Get scan function"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function get_scan(tx_size: number, plane_tx_type: number): Uint16Array;
+//# sourceMappingURL=get_scan.d.ts.map

package/src/avif/native/av1/decode/get_scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_scan.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/get_scan.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;GAaG;AACH,kCARW,MAAM,iBACN,MAAM,GACJ,WAAW,CAoCvB"}

package/src/avif/native/av1/decode/get_scan.js

@@ -0,0 +1,138 @@
+import {
+    H_ADST,
+    H_DCT,
+    H_FLIPADST,
+    IDTX,
+    TX_16X4,
+    TX_16X16,
+    TX_16X32,
+    TX_16X64,
+    TX_16X8,
+    TX_32X16,
+    TX_32X8,
+    TX_4X16,
+    TX_4X4,
+    TX_4X8,
+    TX_64X16,
+    TX_64X64,
+    TX_8X16,
+    TX_8X32,
+    TX_8X4,
+    TX_8X8,
+    V_ADST,
+    V_DCT,
+    V_FLIPADST
+} from "../tables/av1_symbols.js";
+import { TX_SIZE_SQR_UP } from "../tables/block_tables.js";
+import * as scans from "../tables/scan_tables.js";
+
+/**
+ * Default (diagonal) scans, indexed by transform size. Sizes with no default scan of their own
+ * borrow one, per `get_default_scan`.
+ * @type {Uint16Array[]}
+ */
+const DEFAULT_SCAN = build_scan_table("DEFAULT");
+
+/**
+ * Row-major scans, used when the transform is vertical-only.
+ * @type {Uint16Array[]}
+ */
+const MROW_SCAN = build_scan_table("MROW");
+
+/**
+ * Column-major scans, used when the transform is horizontal-only.
+ * @type {Uint16Array[]}
+ */
+const MCOL_SCAN = build_scan_table("MCOL");
+
+/**
+ * @param {string} prefix
+ * @returns {Uint16Array[]}
+ */
+function build_scan_table(prefix) {
+    const table = new Array(19).fill(null);
+
+    /**
+     * @param {number} tx_size
+     * @param {string} name
+     */
+    function set(tx_size, name) {
+        table[tx_size] = scans[`${prefix}_SCAN_${name}`] ?? null;
+    }
+
+    set(TX_4X4, "4X4");
+    set(TX_4X8, "4X8");
+    set(TX_8X4, "8X4");
+    set(TX_8X8, "8X8");
+    set(TX_8X16, "8X16");
+    set(TX_16X8, "16X8");
+    set(TX_16X16, "16X16");
+    set(TX_4X16, "4X16");
+    set(TX_16X4, "16X4");
+
+    if (prefix === "DEFAULT") {
+        set(TX_16X32, "16X32");
+        set(TX_32X16, "32X16");
+        set(TX_8X32, "8X32");
+        set(TX_32X8, "32X8");
+    }
+
+    return table;
+}
+
+/**
+ * `get_default_scan( txSz )`, including its fall-through to the 32x32 scan.
+ * @param {number} tx_size
+ * @returns {Uint16Array}
+ */
+function get_default_scan(tx_size) {
+    const scan = DEFAULT_SCAN[tx_size];
+
+    return scan !== null && scan !== undefined ? scan : scans.DEFAULT_SCAN_32X32;
+}
+
+/**
+ * The scan order a transform block's coefficients are coded in.
+ *
+ * Transforms larger than 32 in either direction reuse a smaller scan: only the top-left 32x32
+ * carries coefficients, so there is nothing for a larger scan to visit.
+ *
+ * @param {number} tx_size
+ * @param {number} plane_tx_type
+ * @returns {Uint16Array}
+ * @see AV1 spec 5.11.41 "Get scan function"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function get_scan(tx_size, plane_tx_type) {
+    if (tx_size === TX_16X64) {
+        return scans.DEFAULT_SCAN_16X32;
+    }
+
+    if (tx_size === TX_64X16) {
+        return scans.DEFAULT_SCAN_32X16;
+    }
+
+    if (TX_SIZE_SQR_UP[tx_size] === TX_64X64) {
+        return scans.DEFAULT_SCAN_32X32;
+    }
+
+    if (plane_tx_type === IDTX) {
+        return get_default_scan(tx_size);
+    }
+
+    if (plane_tx_type === V_DCT || plane_tx_type === V_ADST || plane_tx_type === V_FLIPADST) {
+        const scan = MROW_SCAN[tx_size];
+
+        return scan !== null && scan !== undefined ? scan : scans.MROW_SCAN_16X4;
+    }
+
+    if (plane_tx_type === H_DCT || plane_tx_type === H_ADST || plane_tx_type === H_FLIPADST) {
+        const scan = MCOL_SCAN[tx_size];
+
+        return scan !== null && scan !== undefined ? scan : scans.MCOL_SCAN_16X4;
+    }
+
+    return get_default_scan(tx_size);
+}

package/src/avif/native/av1/decode/read_lr.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Read the loop restoration units a superblock covers.
+ *
+ * Restoration units are not superblock-aligned: their size is signalled independently, so a
+ * superblock may cover several units or part of one. The coefficients are coded as differences from
+ * the previous unit's, which is why the reference values live on the context and persist across
+ * superblocks within a tile.
+ *
+ * @param {Av1FrameContext} ctx
+ * @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"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function read_lr(ctx: Av1FrameContext, r: number, c: number, b_size: number): void;
+/**
+ * Which restoration units a superblock is responsible for coding.
+ *
+ * Units are not superblock-aligned — their size is signalled independently of the superblock size —
+ * so this is where the two grids are reconciled, once, for the reader and the encoder's writer
+ * both. A superblock codes the units whose top left corner falls inside it.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} r superblock row in 4x4 units
+ * @param {number} c superblock column in 4x4 units
+ * @param {number} b_size the superblock size
+ * @param {number} plane
+ * @param {Int32Array} range filled with the first and last unit row, then column
+ * @see AV1 spec 5.11.57
+ */
+export function loop_restoration_unit_range(ctx: Av1FrameContext, r: number, c: number, b_size: number, plane: number, range: Int32Array): void;
+//# sourceMappingURL=read_lr.d.ts.map

package/src/avif/native/av1/decode/read_lr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_lr.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/read_lr.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;GAgBG;AACH,iDARW,MAAM,KACN,MAAM,UACN,MAAM,QA0BhB;AAKD;;;;;;;;;;;;;;GAcG;AACH,qEAPW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,SACN,UAAU,QAgCpB"}

package/src/avif/native/av1/decode/read_lr.js

@@ -0,0 +1,277 @@
+import { clamp } from "../../../../core/math/clamp.js";
+import {
+    MI_SIZE,
+    RESTORE_NONE,
+    RESTORE_SGRPROJ,
+    RESTORE_WIENER,
+    SGRPROJ_PARAMS_BITS,
+    SGRPROJ_PRJ_BITS,
+    SGRPROJ_PRJ_SUBEXP_K,
+    SUPERRES_NUM
+} from "../tables/av1_symbols.js";
+import {
+    SGRPROJ_XQD_MAX,
+    SGRPROJ_XQD_MIN,
+    SGR_PARAMS,
+    WIENER_TAPS_K,
+    WIENER_TAPS_MAX,
+    WIENER_TAPS_MIN
+} from "../tables/filter_tables.js";
+import { NUM_4X4_BLOCKS_HIGH, NUM_4X4_BLOCKS_WIDE } from "../tables/block_tables.js";
+import { count_units_in_frame } from "../filter/loop_restoration.js";
+import { round2 } from "../util/round2.js";
+
+/**
+ * Read the loop restoration units a superblock covers.
+ *
+ * Restoration units are not superblock-aligned: their size is signalled independently, so a
+ * superblock may cover several units or part of one. The coefficients are coded as differences from
+ * the previous unit's, which is why the reference values live on the context and persist across
+ * superblocks within a tile.
+ *
+ * @param {Av1FrameContext} ctx
+ * @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"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function read_lr(ctx, r, c, b_size) {
+    const frame = ctx.frame;
+
+    if (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++) {
+                read_lr_unit(ctx, plane, unit_row, unit_col);
+            }
+        }
+    }
+}
+
+/** @type {Int32Array} first and last row, then first and last column */
+const UNIT_RANGE = new Int32Array(4);
+
+/**
+ * Which restoration units a superblock is responsible for coding.
+ *
+ * Units are not superblock-aligned — their size is signalled independently of the superblock size —
+ * so this is where the two grids are reconciled, once, for the reader and the encoder's writer
+ * both. A superblock codes the units whose top left corner falls inside it.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} r superblock row in 4x4 units
+ * @param {number} c superblock column in 4x4 units
+ * @param {number} b_size the superblock size
+ * @param {number} plane
+ * @param {Int32Array} range filled with the first and last unit row, then column
+ * @see AV1 spec 5.11.57
+ */
+export function loop_restoration_unit_range(ctx, r, c, b_size, plane, range) {
+    const frame = ctx.frame;
+
+    const w = NUM_4X4_BLOCKS_WIDE[b_size];
+    const h = NUM_4X4_BLOCKS_HIGH[b_size];
+
+    const sub_x = plane === 0 ? 0 : ctx.subsampling_x;
+    const sub_y = plane === 0 ? 0 : ctx.subsampling_y;
+
+    const unit_size = frame.loop_restoration_size[plane];
+
+    const unit_rows = count_units_in_frame(unit_size, round2(frame.frame_height, sub_y));
+    const unit_cols = count_units_in_frame(unit_size, round2(frame.upscaled_width, sub_x));
+
+    let numerator;
+    let denominator;
+
+    if (frame.use_superres === 1) {
+        numerator = (MI_SIZE >> sub_x) * frame.superres_denom;
+        denominator = unit_size * SUPERRES_NUM;
+    } else {
+        numerator = MI_SIZE >> sub_x;
+        denominator = unit_size;
+    }
+
+    range[0] = Math.floor((r * (MI_SIZE >> sub_y) + unit_size - 1) / unit_size);
+    range[1] = Math.min(unit_rows, Math.floor(((r + h) * (MI_SIZE >> sub_y) + unit_size - 1) / unit_size));
+    range[2] = Math.floor((c * numerator + denominator - 1) / denominator);
+    range[3] = Math.min(unit_cols, Math.floor(((c + w) * numerator + denominator - 1) / denominator));
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} unit_row
+ * @param {number} unit_col
+ * @see AV1 spec 5.11.58 "Read loop restoration unit syntax"
+ */
+function read_lr_unit(ctx, plane, unit_row, unit_col) {
+    const reader = ctx.reader;
+    const cdf = ctx.cdf;
+
+    const frame_type = ctx.frame.frame_restoration_type[plane];
+
+    let restoration_type;
+
+    if (frame_type === RESTORE_WIENER) {
+        restoration_type = reader.read_symbol(cdf.use_wiener, 0, 2) === 1 ? RESTORE_WIENER : RESTORE_NONE;
+    } else if (frame_type === RESTORE_SGRPROJ) {
+        restoration_type = reader.read_symbol(cdf.use_sgrproj, 0, 2) === 1 ? RESTORE_SGRPROJ : RESTORE_NONE;
+    } else {
+        restoration_type = reader.read_symbol(cdf.restoration_type, 0, 3);
+    }
+
+    const index = ctx.lr_unit_index(plane, unit_row, unit_col);
+
+    ctx.lr_type[index] = restoration_type;
+
+    if (restoration_type === RESTORE_WIENER) {
+        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;
+
+            if (plane !== 0) {
+                ctx.lr_wiener[index * 6 + pass * 3] = 0;
+            }
+
+            for (let j = first; j < 3; j++) {
+                const minimum = WIENER_TAPS_MIN[j];
+                const maximum = WIENER_TAPS_MAX[j];
+                const k = WIENER_TAPS_K[j];
+
+                const reference = ctx.ref_lr_wiener[(plane * 2 + pass) * 3 + j];
+
+                const value = decode_signed_subexp_with_ref(ctx, minimum, maximum + 1, k, reference);
+
+                ctx.lr_wiener[index * 6 + pass * 3 + j] = value;
+                ctx.ref_lr_wiener[(plane * 2 + pass) * 3 + j] = value;
+            }
+        }
+
+        return;
+    }
+
+    if (restoration_type !== RESTORE_SGRPROJ) {
+        return;
+    }
+
+    const set = reader.read_literal(SGRPROJ_PARAMS_BITS);
+
+    ctx.lr_sgr_set[index] = set;
+
+    for (let i = 0; i < 2; i++) {
+        const radius = SGR_PARAMS[set * 4 + i * 2];
+
+        const minimum = SGRPROJ_XQD_MIN[i];
+        const maximum = SGRPROJ_XQD_MAX[i];
+
+        let value;
+
+        if (radius !== 0) {
+            value = decode_signed_subexp_with_ref(
+                ctx,
+                minimum,
+                maximum + 1,
+                SGRPROJ_PRJ_SUBEXP_K,
+                ctx.ref_sgr_xqd[plane * 2 + i]
+            );
+        } else {
+            // a zero radius means that pass contributes nothing, so its weight is not coded; the
+            // second one is derived so the three weights still sum to unity
+            value = i === 1
+                ? clamp((1 << SGRPROJ_PRJ_BITS) - ctx.ref_sgr_xqd[plane * 2], minimum, maximum)
+                : 0;
+        }
+
+        ctx.lr_sgr_xqd[index * 2 + i] = value;
+        ctx.ref_sgr_xqd[plane * 2 + i] = value;
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} low
+ * @param {number} high
+ * @param {number} k
+ * @param {number} reference
+ * @returns {number}
+ * @see AV1 spec 5.11.58, `decode_signed_subexp_with_ref_bool`
+ */
+function decode_signed_subexp_with_ref(ctx, low, high, k, reference) {
+    return decode_unsigned_subexp_with_ref(ctx, high - low, k, reference - low) + low;
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} mx
+ * @param {number} k
+ * @param {number} r
+ * @returns {number}
+ */
+function decode_unsigned_subexp_with_ref(ctx, mx, k, r) {
+    const v = decode_subexp(ctx, mx, k);
+
+    if ((r << 1) <= mx) {
+        return inverse_recenter(r, v);
+    }
+
+    return mx - 1 - inverse_recenter(mx - 1 - r, v);
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} num_symbols
+ * @param {number} k
+ * @returns {number}
+ */
+function decode_subexp(ctx, num_symbols, k) {
+    const reader = ctx.reader;
+
+    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) {
+            return reader.read_ns(num_symbols - mk) + mk;
+        }
+
+        if (reader.read_literal(1) === 1) {
+            i++;
+            mk += a;
+        } else {
+            return reader.read_literal(b2) + mk;
+        }
+    }
+}
+
+/**
+ * @param {number} r
+ * @param {number} v
+ * @returns {number}
+ * @see AV1 spec 5.9.28 "Inverse recenter function"
+ */
+function inverse_recenter(r, v) {
+    if (v > 2 * r) {
+        return v;
+    }
+
+    if ((v & 1) !== 0) {
+        return r - ((v + 1) >> 1);
+    }
+
+    return r + (v >> 1);
+}

package/src/avif/native/av1/decode/read_transform_type.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Read the transform type for a luma transform block and record it across the 4x4 positions it
+ * covers.
+ *
+ * A type is only coded when the transform size allows more than a plain DCT *and* the block is
+ * actually quantised — at quantizer index zero the residual is exact and the choice would be
+ * meaningless, so the format spends no bits on it.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} x4 luma 4x4 column
+ * @param {number} y4 luma 4x4 row
+ * @param {number} tx_size
+ * @see AV1 spec 5.11.47 "Transform type syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function read_transform_type(ctx: Av1FrameContext, x4: number, y4: number, tx_size: number): void;
+//# sourceMappingURL=read_transform_type.d.ts.map

package/src/avif/native/av1/decode/read_transform_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_transform_type.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/read_transform_type.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AACH,8DARW,MAAM,MACN,MAAM,WACN,MAAM,QAmDhB"}

package/src/avif/native/av1/decode/read_transform_type.js

@@ -0,0 +1,92 @@
+import {
+    DCT_DCT,
+    SEG_LVL_ALT_Q,
+    SEG_LVL_MAX,
+    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 { FILTER_INTRA_MODE_TO_INTRA_DIR } from "../tables/prediction_tables.js";
+import { clamp } from "../../../../core/math/clamp.js";
+import { get_tx_set } from "./transform_type.js";
+
+/**
+ * Read the transform type for a luma transform block and record it across the 4x4 positions it
+ * covers.
+ *
+ * A type is only coded when the transform size allows more than a plain DCT *and* the block is
+ * actually quantised — at quantizer index zero the residual is exact and the choice would be
+ * meaningless, so the format spends no bits on it.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} x4 luma 4x4 column
+ * @param {number} y4 luma 4x4 row
+ * @param {number} tx_size
+ * @see AV1 spec 5.11.47 "Transform type syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function read_transform_type(ctx, x4, y4, tx_size) {
+    const frame = ctx.frame;
+
+    const set = get_tx_set(tx_size, 0, frame.reduced_tx_set);
+
+    let tx_type = DCT_DCT;
+
+    const qindex = frame.segmentation_enabled === 1
+        ? segment_qindex(frame, ctx.segment_id)
+        : frame.base_q_idx;
+
+    if (set > 0 && qindex > 0) {
+        const intra_direction = ctx.use_filter_intra === 1
+            ? FILTER_INTRA_MODE_TO_INTRA_DIR[ctx.filter_intra_mode]
+            : ctx.y_mode;
+
+        const square = TX_SIZE_SQR[tx_size];
+
+        if (set === TX_SET_INTRA_1) {
+            const symbol = ctx.reader.read_symbol(
+                ctx.cdf.intra_tx_type_set1,
+                (square * 13 + intra_direction) * 8,
+                7
+            );
+
+            tx_type = TX_TYPE_INTRA_INV_SET1[symbol];
+        } else {
+            const symbol = ctx.reader.read_symbol(
+                ctx.cdf.intra_tx_type_set2,
+                (square * 13 + intra_direction) * 6,
+                5
+            );
+
+            tx_type = TX_TYPE_INTRA_INV_SET2[symbol];
+        }
+    }
+
+    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;
+        }
+    }
+}
+
+/**
+ * `get_qindex( 1, segmentId )`.
+ * @param {FrameHeader} frame
+ * @param {number} segment_id
+ * @returns {number}
+ */
+function segment_qindex(frame, segment_id) {
+    if (frame.feature_enabled[segment_id * SEG_LVL_MAX + SEG_LVL_ALT_Q] !== 0) {
+        return clamp(frame.base_q_idx + frame.feature_data[segment_id * SEG_LVL_MAX + SEG_LVL_ALT_Q], 0, 255);
+    }
+
+    return frame.base_q_idx;
+}

package/src/avif/native/av1/decode/reconstruct.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `dc_q( b )`. Exported because an encoder has to quantise with exactly what this dequantises with.
+ * @param {number} bit_depth
+ * @param {number} b
+ * @returns {number}
+ */
+export function dc_quant(bit_depth: number, b: number): number;
+/**
+ * `ac_q( b )`.
+ * @param {number} bit_depth
+ * @param {number} b
+ * @returns {number}
+ */
+export function ac_quant(bit_depth: number, b: number): number;
+/**
+ * `get_qindex( 0, segment_id )`: the block's quantizer index, honouring any per-block delta.
+ * @param {Av1FrameContext} ctx
+ * @returns {number}
+ * @see AV1 spec 7.12.2 "Dequantization functions"
+ */
+export function get_qindex(ctx: Av1FrameContext): number;
+/**
+ * Dequantise, inverse transform and add the residual into the plane.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} x left edge of the transform block in plane samples
+ * @param {number} y top edge of the transform block in plane samples
+ * @param {number} tx_size
+ * @see AV1 spec 7.12.3 "Reconstruct process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function reconstruct(ctx: Av1FrameContext, plane: number, x: number, y: number, tx_size: number): void;
+//# sourceMappingURL=reconstruct.d.ts.map

package/src/avif/native/av1/decode/reconstruct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconstruct.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/reconstruct.js"],"names":[],"mappings":"AAkCA;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,kDAHa,MAAM,CAsBlB;AA0BD;;;;;;;;;;;;GAYG;AACH,yDATW,MAAM,KACN,MAAM,KACN,MAAM,WACN,MAAM,QAsGhB"}