@woosh/meep-engine 3.14.1 → 3.14.3

package/src/format/image/avif/av1/decode/get_scan.d.ts.map

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

package/src/format/image/avif/av1/decode/read_lr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_lr.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/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/format/image/avif/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/format/image/avif/av1/decode/read_transform_type.d.ts.map

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

package/src/format/image/avif/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/format/image/avif/av1/decode/reconstruct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconstruct.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/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"}

package/src/format/image/avif/av1/decode/reconstruct.js

@@ -0,0 +1,241 @@
+import { clamp } from "../../../../../core/math/clamp.js";
+import {
+    ADST_FLIPADST,
+    DCT_FLIPADST,
+    FLIPADST_ADST,
+    FLIPADST_DCT,
+    FLIPADST_FLIPADST,
+    H_FLIPADST,
+    IDTX,
+    MAX_SEGMENTS,
+    SEG_LVL_ALT_Q,
+    SEG_LVL_MAX,
+    TX_16X32,
+    TX_16X64,
+    TX_32X16,
+    TX_32X32,
+    TX_32X64,
+    TX_64X16,
+    TX_64X32,
+    TX_64X64,
+    V_FLIPADST
+} from "../tables/av1_symbols.js";
+import { QM_OFFSET, QUANTIZER_MATRIX } from "../tables/quantizer_matrix_tables.js";
+import { AC_QLOOKUP, DC_QLOOKUP } from "../tables/quantizer_tables.js";
+import { TX_HEIGHT, TX_WIDTH } from "../tables/block_tables.js";
+import { inverse_transform_2d } from "../transform/inverse_transform_2d.js";
+import { round2 } from "../util/round2.js";
+
+/**
+ * `Quantizer_Matrix` covers one level and plane type in this many entries.
+ * @type {number}
+ */
+const QM_TOTAL_SIZE = 3344;
+
+/**
+ * `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, b) {
+    return DC_QLOOKUP[((bit_depth - 8) >> 1) * 256 + clamp(b, 0, 255)];
+}
+
+/**
+ * `ac_q( b )`.
+ * @param {number} bit_depth
+ * @param {number} b
+ * @returns {number}
+ */
+export function ac_quant(bit_depth, b) {
+    return AC_QLOOKUP[((bit_depth - 8) >> 1) * 256 + clamp(b, 0, 255)];
+}
+
+/**
+ * `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) {
+    const frame = ctx.frame;
+    const segment = ctx.segment_id;
+
+    if (frame.segmentation_enabled === 1 && frame.feature_enabled[segment * SEG_LVL_MAX + SEG_LVL_ALT_Q] !== 0) {
+        const data = frame.feature_data[segment * SEG_LVL_MAX + SEG_LVL_ALT_Q];
+
+        const qindex = frame.delta_q_present === 1
+            ? ctx.current_q_index + data
+            : frame.base_q_idx + data;
+
+        return clamp(qindex, 0, 255);
+    }
+
+    if (frame.delta_q_present === 1) {
+        return ctx.current_q_index;
+    }
+
+    return frame.base_q_idx;
+}
+
+/**
+ * Whether the transform type flips its output vertically.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+function flips_vertically(tx_type) {
+    return tx_type === FLIPADST_DCT
+        || tx_type === FLIPADST_ADST
+        || tx_type === V_FLIPADST
+        || tx_type === FLIPADST_FLIPADST;
+}
+
+/**
+ * Whether the transform type flips its output horizontally.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+function flips_horizontally(tx_type) {
+    return tx_type === DCT_FLIPADST
+        || tx_type === ADST_FLIPADST
+        || tx_type === H_FLIPADST
+        || tx_type === FLIPADST_FLIPADST;
+}
+
+/**
+ * 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, plane, x, y, tx_size) {
+    const frame = ctx.frame;
+    const bit_depth = ctx.bit_depth;
+
+    let dq_denom = 1;
+
+    if (tx_size === TX_32X32 || tx_size === TX_16X32 || tx_size === TX_32X16 || tx_size === TX_16X64 || tx_size === TX_64X16) {
+        dq_denom = 2;
+    } else if (tx_size === TX_64X64 || tx_size === TX_32X64 || tx_size === TX_64X32) {
+        dq_denom = 4;
+    }
+
+    const w = TX_WIDTH[tx_size];
+    const h = TX_HEIGHT[tx_size];
+
+    const tw = Math.min(32, w);
+    const th = Math.min(32, h);
+
+    const tx_type = ctx.plane_tx_type;
+
+    const flip_up_down = flips_vertically(tx_type);
+    const flip_left_right = flips_horizontally(tx_type);
+
+    const qindex = get_qindex(ctx);
+
+    const dc_q = dc_quant(bit_depth, qindex + dc_delta(frame, plane));
+    const ac_q = ac_quant(bit_depth, qindex + ac_delta(frame, plane));
+
+    const residual = ctx.residual;
+    const quant = ctx.quant;
+
+    residual.fill(0, 0, w * h);
+
+    const qm_level = frame.using_qmatrix === 1 ? frame.seg_qm_level[plane * MAX_SEGMENTS + ctx.segment_id] : 15;
+    const use_qm = frame.using_qmatrix === 1 && tx_type < IDTX && qm_level < 15;
+
+    const qm_base = use_qm
+        ? (qm_level * 2 + (plane > 0 ? 1 : 0)) * QM_TOTAL_SIZE + QM_OFFSET[tx_size]
+        : 0;
+
+    const limit = 1 << (7 + bit_depth);
+
+    for (let i = 0; i < th; i++) {
+        for (let j = 0; j < tw; j++) {
+            const level = quant[i * tw + j];
+
+            // a coefficient the quantiser zeroed dequantises to zero, and the residual is already
+            // zero there. Most of a block is this
+            if (level === 0) {
+                continue;
+            }
+
+            const q = i === 0 && j === 0 ? dc_q : ac_q;
+
+            const q2 = use_qm ? round2(q * QUANTIZER_MATRIX[qm_base + i * tw + j], 5) : q;
+
+            const dq = level * q2;
+
+            const sign = dq < 0 ? -1 : 1;
+
+            // the mask is not a clamp: the specification truncates the magnitude to 24 bits and
+            // only then divides, so a value above it wraps rather than saturating
+            const dq2 = sign * Math.floor((Math.abs(dq) & 0xffffff) / dq_denom);
+
+            residual[i * w + j] = clamp(dq2, -limit, limit - 1);
+        }
+    }
+
+    inverse_transform_2d(residual, tx_size, tx_type, ctx.lossless, bit_depth, ctx.transform_scratch);
+
+    const plane_data = ctx.planes[plane];
+    const stride = ctx.plane_stride[plane];
+    const plane_width = ctx.plane_width[plane];
+    const plane_height = ctx.plane_height[plane];
+
+    const max_value = (1 << bit_depth) - 1;
+
+    for (let i = 0; i < h; i++) {
+        const yy = flip_up_down ? h - i - 1 : i;
+
+        if (y + yy >= plane_height) {
+            continue;
+        }
+
+        const row = (y + yy) * stride;
+
+        for (let j = 0; j < w; j++) {
+            const xx = flip_left_right ? w - j - 1 : j;
+
+            if (x + xx >= plane_width) {
+                continue;
+            }
+
+            plane_data[row + x + xx] = clamp(plane_data[row + x + xx] + residual[i * w + j], 0, max_value);
+        }
+    }
+}
+
+/**
+ * @param {FrameHeader} frame
+ * @param {number} plane
+ * @returns {number}
+ */
+function dc_delta(frame, plane) {
+    if (plane === 0) {
+        return frame.delta_q_y_dc;
+    }
+
+    return plane === 1 ? frame.delta_q_u_dc : frame.delta_q_v_dc;
+}
+
+/**
+ * @param {FrameHeader} frame
+ * @param {number} plane
+ * @returns {number}
+ */
+function ac_delta(frame, plane) {
+    if (plane === 0) {
+        return 0;
+    }
+
+    return plane === 1 ? frame.delta_q_u_ac : frame.delta_q_v_ac;
+}

package/src/format/image/avif/av1/decode/transform_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform_type.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/decode/transform_type.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;GAeG;AACH,oCATW,MAAM,YACN,MAAM,kBACN,MAAM,GACJ,MAAM,CAmClB;AAED;;;;;GAKG;AACH,0CALW,MAAM,WACN,MAAM,YACN,MAAM,GACJ,OAAO,CAMnB;AAED;;;;;;;;;;;;;;GAcG;AACH,6DAPW,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,MAAM,CAqBlB;AAED;;;;;;GAMG;AACH,sCAJW,MAAM,GACJ,MAAM,CAalB"}

package/src/format/image/avif/av1/encode/Av1BlockSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Av1BlockSnapshot.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/encode/Av1BlockSnapshot.js"],"names":[],"mappings":"AA6IA;;;;;;;;GAQG;AACH,8DALW,gBAAgB,KAChB,MAAM,KACN,MAAM,UACN,MAAM,QAIhB;AAED;;;;;;;;GAQG;AACH,8DALW,gBAAgB,KAChB,MAAM,KACN,MAAM,UACN,MAAM,QAIhB;AA5JD;;;GAGG;AACH,8BAFU,MAAM,CAE4B;AAmB5C;;GAEG;AACH,mCAFU,MAAM,CAEsC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAWQ,oFAAoF;IACpF,QADW,WAAW,EAAE,CACR;IAQhB,2BAA2B;IAC3B,aADW,UAAU,EAAE,CACF;IAErB,2BAA2B;IAC3B,UADW,UAAU,EAAE,CACL;IAElB,2BAA2B;IAC3B,YADW,UAAU,EAAE,CACH;IAEpB,2BAA2B;IAC3B,SADW,UAAU,EAAE,CACN;IAUjB,qFAAqF;IACrF,eADW,UAAU,EAAE,CACA;IAQvB,yBAAyB;IACzB,SADW,UAAU,CACuC;IAI5D,yBAAyB;IACzB,UADW,UAAU,CACwC;IAI7D,yBAAyB;IACzB,UADW,UAAU,CACwC;IAI7D,yBAAyB;IACzB,OADW,UAAU,CACqC;IAI1D,yBAAyB;IACzB,UADW,UAAU,CACwC;IAI7D,yBAAyB;IACzB,UADW,UAAU,CACwC;CAEpE"}

package/src/format/image/avif/av1/encode/Av1EncodeContext.d.ts.map

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

package/src/format/image/avif/av1/encode/build_headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_headers.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/encode/build_headers.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAf2B,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACW,eAAe,GAAhC,MAAM;IACW,wBAAwB,GAAzC,MAAM;IACW,mBAAmB,GAApC,MAAM;IACW,WAAW,GAA5B,MAAM;SAqFhB;AA6BD;;;;;;;;;GASG;AACH;IAJ2B,UAAU,EAA1B,MAAM;IACU,sBAAsB,EAAtC,MAAM;SA6HhB"}

package/src/format/image/avif/av1/encode/choose_chroma_alpha.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"choose_chroma_alpha.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/encode/choose_chroma_alpha.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iEATW,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,MAAM,CAuDlB"}

package/src/format/image/avif/av1/encode/choose_filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"choose_filters.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/encode/choose_filters.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;GAkBG;AACH,2DA6CC"}

package/src/format/image/avif/av1/encode/choose_restoration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"choose_restoration.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/encode/choose_restoration.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,+DA+CC"}