@woosh/meep-engine 3.28.0 → 3.30.0

package/src/format/image/avif/av1/filter/loop_restoration.js

@@ -1,451 +1,461 @@
-import { clamp } from "../../../../../core/math/clamp.js";
-import {
-    FILTER_BITS,
-    MI_SIZE,
-    RESTORE_NONE,
-    RESTORE_SGRPROJ,
-    RESTORE_WIENER,
-    SGRPROJ_MTABLE_BITS,
-    SGRPROJ_PRJ_BITS,
-    SGRPROJ_RECIP_BITS,
-    SGRPROJ_RST_BITS,
-    SGRPROJ_SGR_BITS
-} from "../tables/av1_symbols.js";
-import { SGR_PARAMS } from "../tables/filter_tables.js";
-import { round2 } from "../util/round2.js";
-
-/**
- * `A` and `B` from the box filter, valid over one extra sample in each direction.
- * @type {number}
- */
-const BOX_STRIDE = MI_SIZE + 2;
-
-/** @type {Int32Array} */
-const BOX_A = new Int32Array(BOX_STRIDE * BOX_STRIDE);
-
-/** @type {Int32Array} */
-const BOX_B = new Int32Array(BOX_STRIDE * BOX_STRIDE);
-
-/** @type {Int32Array} the two self-guided passes' outputs */
-const FLT0 = new Int32Array(MI_SIZE * MI_SIZE);
-
-/** @type {Int32Array} */
-const FLT1 = new Int32Array(MI_SIZE * MI_SIZE);
-
-/** @type {Int32Array} the Wiener filter's horizontal pass */
-const WIENER_INTERMEDIATE = new Int32Array((MI_SIZE + 6) * MI_SIZE);
-
-/** @type {Int32Array} the seven symmetric taps expanded from the three coded ones */
-const WIENER_VERTICAL = new Int32Array(7);
-
-/** @type {Int32Array} */
-const WIENER_HORIZONTAL = new Int32Array(7);
-
-/**
- * State the source-sample fetch needs, kept here rather than threaded through every call.
- *
- * The fetch decides between the deringed frame and the merely deblocked one based on which stripe
- * the sample falls in, and that boundary changes per block. Hoisting it into a small module-level
- * record keeps the innermost loops free of parameters they would otherwise carry six deep.
- */
-const SOURCE = {
-    ctx: null,
-    plane: 0,
-    stripe_start_y: 0,
-    stripe_end_y: 0,
-    plane_end_x: 0,
-    plane_end_y: 0,
-    stride: 0,
-    cdef: null,
-    current: null
-};
-
-/**
- * Apply loop restoration.
- *
- * Reads the deringed frame and the pre-CDEF frame, and writes the restored result. The two inputs
- * are not interchangeable: within a stripe the filter reads deringed samples, and outside it reads
- * deblocked ones, which is what lets a hardware decoder run restoration a stripe behind CDEF
- * without an extra line buffer.
- *
- * @param {Av1FrameContext} ctx
- * @param {Uint16Array[]} current the deblocked frame, upscaled if superres is in use
- * @param {Uint16Array[]} cdef the deringed frame, upscaled if superres is in use
- * @param {Uint16Array[]} output
- * @param {Int32Array} stride
- * @see AV1 spec 7.17 "Loop restoration process"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function apply_loop_restoration(ctx, current, cdef, output, stride) {
-    const frame = ctx.frame;
-
-    for (let plane = 0; plane < ctx.num_planes; plane++) {
-        // the buffers are reused across frames, so the source may be longer than this frame
-        const samples = stride[plane] * ctx.plane_rows[plane];
-
-        output[plane].set(cdef[plane].subarray(0, samples));
-    }
-
-    if (frame.uses_lr === 0) {
-        return;
-    }
-
-    for (let y = 0; y < frame.frame_height; y += MI_SIZE) {
-        for (let x = 0; x < frame.upscaled_width; x += MI_SIZE) {
-            for (let plane = 0; plane < ctx.num_planes; plane++) {
-                if (frame.frame_restoration_type[plane] === RESTORE_NONE) {
-                    continue;
-                }
-
-                restore_block(ctx, current, cdef, output, stride, plane, y >> 2, x >> 2);
-            }
-        }
-    }
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {Uint16Array[]} current
- * @param {Uint16Array[]} cdef
- * @param {Uint16Array[]} output
- * @param {Int32Array} stride
- * @param {number} plane
- * @param {number} row
- * @param {number} col
- * @see AV1 spec 7.17.1 "Loop restore block process"
- */
-function restore_block(ctx, current, cdef, output, stride, plane, row, col) {
-    const frame = ctx.frame;
-
-    const luma_y = row * MI_SIZE;
-
-    // stripes are offset up by eight luma samples so a pipelined decoder can restore a stripe as
-    // soon as the superblock row above it is deblocked
-    const stripe = Math.floor((luma_y + 8) / 64);
-
-    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
-    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
-
-    SOURCE.ctx = ctx;
-    SOURCE.plane = plane;
-    SOURCE.stripe_start_y = (-8 + stripe * 64) >> sub_y;
-    SOURCE.stripe_end_y = SOURCE.stripe_start_y + (64 >> sub_y) - 1;
-    SOURCE.plane_end_x = round2(frame.upscaled_width, sub_x) - 1;
-    SOURCE.plane_end_y = round2(frame.frame_height, sub_y) - 1;
-    SOURCE.stride = stride[plane];
-    SOURCE.cdef = cdef[plane];
-    SOURCE.current = current[plane];
-
-    const x = (col * MI_SIZE) >> sub_x;
-    const y = (row * MI_SIZE) >> sub_y;
-
-    const w = Math.min(MI_SIZE >> sub_x, SOURCE.plane_end_x - x + 1);
-    const h = Math.min(MI_SIZE >> sub_y, SOURCE.plane_end_y - y + 1);
-
-    if (w <= 0 || h <= 0) {
-        return;
-    }
-
-    const unit_index = restoration_unit_of(ctx, plane, row, col);
-
-    const type = ctx.lr_type[unit_index];
-
-    if (type === RESTORE_WIENER) {
-        wiener_filter(ctx, output, stride, plane, unit_index, x, y, w, h);
-    } else if (type === RESTORE_SGRPROJ) {
-        self_guided_filter(ctx, output, stride, plane, unit_index, x, y, w, h);
-    }
-}
-
-/**
- * `count_units_in_frame`: how many restoration units of one size a frame is divided into.
- *
- * @param {number} unit_size
- * @param {number} frame_size
- * @returns {number}
- */
-export function count_units_in_frame(unit_size, frame_size) {
-    return Math.max(Math.floor((frame_size + (unit_size >> 1)) / unit_size), 1);
-}
-
-/**
- * Which restoration unit a 4x4 block is filtered by.
- *
- * The vertical mapping is offset by eight luma samples, because restoration works in stripes that
- * are offset by that much. Exported because the encoder has to attribute a block's error to the
- * same unit this attributes its filtering to, and the two agreeing is the whole point.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} plane
- * @param {number} row 4x4 block row
- * @param {number} col 4x4 block column
- * @returns {number} index into the per-unit arrays
- */
-export function restoration_unit_of(ctx, plane, row, col) {
-    const frame = ctx.frame;
-
-    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
-    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
-
-    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));
-
-    const unit_row = Math.min(unit_rows - 1, Math.floor(((row * MI_SIZE + 8) >> sub_y) / unit_size));
-    const unit_col = Math.min(unit_cols - 1, Math.floor(((col * MI_SIZE) >> sub_x) / unit_size));
-
-    return ctx.lr_unit_index(plane, unit_row, unit_col);
-}
-
-/**
- * `get_source_sample`: deringed inside the current stripe, merely deblocked outside it.
- *
- * @param {number} x
- * @param {number} y
- * @returns {number}
- * @see AV1 spec 7.17.6 "Get source sample process"
- */
-function source_sample(x, y) {
-    const clamped_x = clamp(x, 0, SOURCE.plane_end_x);
-
-    let clamped_y = clamp(y, 0, SOURCE.plane_end_y);
-
-    if (clamped_y < SOURCE.stripe_start_y) {
-        clamped_y = Math.max(SOURCE.stripe_start_y - 2, clamped_y);
-
-        return SOURCE.current[clamped_y * SOURCE.stride + clamped_x];
-    }
-
-    if (clamped_y > SOURCE.stripe_end_y) {
-        clamped_y = Math.min(SOURCE.stripe_end_y + 2, clamped_y);
-
-        return SOURCE.current[clamped_y * SOURCE.stride + clamped_x];
-    }
-
-    return SOURCE.cdef[clamped_y * SOURCE.stride + clamped_x];
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {Uint16Array[]} output
- * @param {Int32Array} stride
- * @param {number} plane
- * @param {number} unit_index
- * @param {number} x
- * @param {number} y
- * @param {number} w
- * @param {number} h
- * @see AV1 spec 7.17.4 "Wiener filter process"
- */
-function wiener_filter(ctx, output, stride, plane, unit_index, x, y, w, h) {
-    const bit_depth = ctx.bit_depth;
-
-    // the rounding the specification derives for a non-compound inter prediction, reused here
-    const round0 = bit_depth === 12 ? 5 : 3;
-    const round1 = bit_depth === 12 ? 9 : 11;
-
-    expand_wiener(ctx.lr_wiener, unit_index * 6, WIENER_VERTICAL);
-    expand_wiener(ctx.lr_wiener, unit_index * 6 + 3, WIENER_HORIZONTAL);
-
-    const offset = 1 << (bit_depth + FILTER_BITS - round0 - 1);
-    const limit = (1 << (bit_depth + 1 + FILTER_BITS - round0)) - 1;
-
-    for (let r = 0; r < h + 6; r++) {
-        for (let c = 0; c < w; c++) {
-            let s = 0;
-
-            for (let t = 0; t < 7; t++) {
-                s += WIENER_HORIZONTAL[t] * source_sample(x + c + t - 3, y + r - 3);
-            }
-
-            WIENER_INTERMEDIATE[r * MI_SIZE + c] = clamp(round2(s, round0), -offset, limit - offset);
-        }
-    }
-
-    const max_value = (1 << bit_depth) - 1;
-
-    const plane_output = output[plane];
-    const plane_stride = stride[plane];
-
-    for (let r = 0; r < h; r++) {
-        for (let c = 0; c < w; c++) {
-            let s = 0;
-
-            for (let t = 0; t < 7; t++) {
-                s += WIENER_VERTICAL[t] * WIENER_INTERMEDIATE[(r + t) * MI_SIZE + c];
-            }
-
-            plane_output[(y + r) * plane_stride + x + c] = clamp(round2(s, round1), 0, max_value);
-        }
-    }
-}
-
-/**
- * Expand three coded taps into the seven of a symmetric unit-gain filter.
- *
- * @param {Int8Array} coefficients
- * @param {number} offset
- * @param {Int32Array} filter
- * @see AV1 spec 7.17.5 "Wiener coefficient process"
- */
-function expand_wiener(coefficients, offset, filter) {
-    filter[3] = 128;
-
-    for (let i = 0; i < 3; i++) {
-        const c = coefficients[offset + i];
-
-        filter[i] = c;
-        filter[6 - i] = c;
-        filter[3] -= 2 * c;
-    }
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {Uint16Array[]} output
- * @param {Int32Array} stride
- * @param {number} plane
- * @param {number} unit_index
- * @param {number} x
- * @param {number} y
- * @param {number} w
- * @param {number} h
- * @see AV1 spec 7.17.2 "Self guided filter process"
- */
-function self_guided_filter(ctx, output, stride, plane, unit_index, x, y, w, h) {
-    const set = ctx.lr_sgr_set[unit_index];
-
-    box_filter(ctx, x, y, w, h, set, 0, FLT0);
-    box_filter(ctx, x, y, w, h, set, 1, FLT1);
-
-    const w0 = ctx.lr_sgr_xqd[unit_index * 2];
-    const w1 = ctx.lr_sgr_xqd[unit_index * 2 + 1];
-    const w2 = (1 << SGRPROJ_PRJ_BITS) - w0 - w1;
-
-    const r0 = SGR_PARAMS[set * 4];
-    const r1 = SGR_PARAMS[set * 4 + 2];
-
-    const max_value = (1 << ctx.bit_depth) - 1;
-
-    const plane_output = output[plane];
-    const plane_stride = stride[plane];
-
-    for (let i = 0; i < h; i++) {
-        for (let j = 0; j < w; j++) {
-            const u = SOURCE.cdef[(y + i) * SOURCE.stride + x + j] << SGRPROJ_RST_BITS;
-
-            let v = w1 * u;
-
-            v += r0 !== 0 ? w0 * FLT0[i * MI_SIZE + j] : w0 * u;
-            v += r1 !== 0 ? w2 * FLT1[i * MI_SIZE + j] : w2 * u;
-
-            plane_output[(y + i) * plane_stride + x + j] = clamp(
-                round2(v, SGRPROJ_RST_BITS + SGRPROJ_PRJ_BITS),
-                0,
-                max_value
-            );
-        }
-    }
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} x
- * @param {number} y
- * @param {number} w
- * @param {number} h
- * @param {number} set
- * @param {number} pass
- * @param {Int32Array} out
- * @see AV1 spec 7.17.3 "Box filter process"
- */
-function box_filter(ctx, x, y, w, h, set, pass, out) {
-    const r = SGR_PARAMS[set * 4 + pass * 2];
-
-    if (r === 0) {
-        return;
-    }
-
-    const eps = SGR_PARAMS[set * 4 + pass * 2 + 1];
-
-    const bit_depth = ctx.bit_depth;
-
-    const n = (2 * r + 1) * (2 * r + 1);
-    const n2e = n * n * eps;
-    const s = Math.floor(((1 << SGRPROJ_MTABLE_BITS) + Math.floor(n2e / 2)) / n2e);
-
-    const one_over_n = Math.floor(((1 << SGRPROJ_RECIP_BITS) + Math.floor(n / 2)) / n);
-
-    for (let i = -1; i < h + 1; i++) {
-        for (let j = -1; j < w + 1; j++) {
-            let a = 0;
-            let b = 0;
-
-            for (let dy = -r; dy <= r; dy++) {
-                for (let dx = -r; dx <= r; dx++) {
-                    const c = source_sample(x + j + dx, y + i + dy);
-
-                    a += c * c;
-                    b += c;
-                }
-            }
-
-            a = round2(a, 2 * (bit_depth - 8));
-
-            const d = round2(b, bit_depth - 8);
-
-            const p = Math.max(0, a * n - d * d);
-            const z = round2(p * s, SGRPROJ_MTABLE_BITS);
-
-            let a2;
-
-            if (z >= 255) {
-                a2 = 256;
-            } else if (z === 0) {
-                a2 = 1;
-            } else {
-                a2 = Math.floor(((z << SGRPROJ_SGR_BITS) + Math.floor(z / 2)) / (z + 1));
-            }
-
-            const b2 = ((1 << SGRPROJ_SGR_BITS) - a2) * b * one_over_n;
-
-            const index = (i + 1) * BOX_STRIDE + j + 1;
-
-            BOX_A[index] = a2;
-            BOX_B[index] = round2(b2, SGRPROJ_RECIP_BITS);
-        }
-    }
-
-    for (let i = 0; i < h; i++) {
-        const shift = pass === 0 && (i & 1) !== 0 ? 4 : 5;
-
-        for (let j = 0; j < w; j++) {
-            let a = 0;
-            let b = 0;
-
-            for (let dy = -1; dy <= 1; dy++) {
-                for (let dx = -1; dx <= 1; dx++) {
-                    let weight;
-
-                    if (pass === 0) {
-                        weight = ((i + dy) & 1) !== 0 ? (dx === 0 ? 6 : 5) : 0;
-                    } else {
-                        weight = dx === 0 || dy === 0 ? 4 : 3;
-                    }
-
-                    const index = (i + dy + 1) * BOX_STRIDE + j + dx + 1;
-
-                    a += weight * BOX_A[index];
-                    b += weight * BOX_B[index];
-                }
-            }
-
-            const v = a * SOURCE.cdef[(y + i) * SOURCE.stride + x + j] + b;
-
-            out[i * MI_SIZE + j] = round2(v, SGRPROJ_SGR_BITS + shift - SGRPROJ_RST_BITS);
-        }
-    }
-}
+import { clamp } from "../../../../../core/math/clamp.js";
+import {
+    FILTER_BITS,
+    MI_SIZE,
+    RESTORE_NONE,
+    RESTORE_SGRPROJ,
+    RESTORE_WIENER,
+    SGRPROJ_MTABLE_BITS,
+    SGRPROJ_PRJ_BITS,
+    SGRPROJ_RECIP_BITS,
+    SGRPROJ_RST_BITS,
+    SGRPROJ_SGR_BITS
+} from "../tables/av1_symbols.js";
+import { SGR_PARAMS } from "../tables/filter_tables.js";
+import { round2, round2_wide } from "../util/round2.js";
+
+/**
+ * `A` and `B` from the box filter, valid over one extra sample in each direction.
+ * @type {number}
+ */
+const BOX_STRIDE = MI_SIZE + 2;
+
+/** @type {Int32Array} */
+const BOX_A = new Int32Array(BOX_STRIDE * BOX_STRIDE);
+
+/** @type {Int32Array} */
+const BOX_B = new Int32Array(BOX_STRIDE * BOX_STRIDE);
+
+/** @type {Int32Array} the two self-guided passes' outputs */
+const FLT0 = new Int32Array(MI_SIZE * MI_SIZE);
+
+/** @type {Int32Array} */
+const FLT1 = new Int32Array(MI_SIZE * MI_SIZE);
+
+/** @type {Int32Array} the Wiener filter's horizontal pass */
+const WIENER_INTERMEDIATE = new Int32Array((MI_SIZE + 6) * MI_SIZE);
+
+/** @type {Int32Array} the seven symmetric taps expanded from the three coded ones */
+const WIENER_VERTICAL = new Int32Array(7);
+
+/** @type {Int32Array} */
+const WIENER_HORIZONTAL = new Int32Array(7);
+
+/**
+ * State the source-sample fetch needs, kept here rather than threaded through every call.
+ *
+ * The fetch decides between the deringed frame and the merely deblocked one based on which stripe
+ * the sample falls in, and that boundary changes per block. Hoisting it into a small module-level
+ * record keeps the innermost loops free of parameters they would otherwise carry six deep.
+ */
+const SOURCE = {
+    ctx: null,
+    plane: 0,
+    stripe_start_y: 0,
+    stripe_end_y: 0,
+    plane_end_x: 0,
+    plane_end_y: 0,
+    stride: 0,
+    cdef: null,
+    current: null
+};
+
+/**
+ * Apply loop restoration.
+ *
+ * Reads the deringed frame and the pre-CDEF frame, and writes the restored result. The two inputs
+ * are not interchangeable: within a stripe the filter reads deringed samples, and outside it reads
+ * deblocked ones, which is what lets a hardware decoder run restoration a stripe behind CDEF
+ * without an extra line buffer.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {Uint16Array[]} current the deblocked frame, upscaled if superres is in use
+ * @param {Uint16Array[]} cdef the deringed frame, upscaled if superres is in use
+ * @param {Uint16Array[]} output
+ * @param {Int32Array} stride
+ * @see AV1 spec 7.17 "Loop restoration process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function apply_loop_restoration(ctx, current, cdef, output, stride) {
+    const frame = ctx.frame;
+
+    for (let plane = 0; plane < ctx.num_planes; plane++) {
+        // the buffers are reused across frames, so the source may be longer than this frame
+        const samples = stride[plane] * ctx.plane_rows[plane];
+
+        output[plane].set(cdef[plane].subarray(0, samples));
+    }
+
+    if (frame.uses_lr === 0) {
+        return;
+    }
+
+    for (let y = 0; y < frame.frame_height; y += MI_SIZE) {
+        for (let x = 0; x < frame.upscaled_width; x += MI_SIZE) {
+            for (let plane = 0; plane < ctx.num_planes; plane++) {
+                if (frame.frame_restoration_type[plane] === RESTORE_NONE) {
+                    continue;
+                }
+
+                restore_block(ctx, current, cdef, output, stride, plane, y >> 2, x >> 2);
+            }
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {Uint16Array[]} current
+ * @param {Uint16Array[]} cdef
+ * @param {Uint16Array[]} output
+ * @param {Int32Array} stride
+ * @param {number} plane
+ * @param {number} row
+ * @param {number} col
+ * @see AV1 spec 7.17.1 "Loop restore block process"
+ */
+function restore_block(ctx, current, cdef, output, stride, plane, row, col) {
+    const frame = ctx.frame;
+
+    const luma_y = row * MI_SIZE;
+
+    // stripes are offset up by eight luma samples so a pipelined decoder can restore a stripe as
+    // soon as the superblock row above it is deblocked
+    const stripe = Math.floor((luma_y + 8) / 64);
+
+    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
+    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
+
+    SOURCE.ctx = ctx;
+    SOURCE.plane = plane;
+    SOURCE.stripe_start_y = (-8 + stripe * 64) >> sub_y;
+    SOURCE.stripe_end_y = SOURCE.stripe_start_y + (64 >> sub_y) - 1;
+    SOURCE.plane_end_x = round2(frame.upscaled_width, sub_x) - 1;
+    SOURCE.plane_end_y = round2(frame.frame_height, sub_y) - 1;
+    SOURCE.stride = stride[plane];
+    SOURCE.cdef = cdef[plane];
+    SOURCE.current = current[plane];
+
+    const x = (col * MI_SIZE) >> sub_x;
+    const y = (row * MI_SIZE) >> sub_y;
+
+    const w = Math.min(MI_SIZE >> sub_x, SOURCE.plane_end_x - x + 1);
+    const h = Math.min(MI_SIZE >> sub_y, SOURCE.plane_end_y - y + 1);
+
+    if (w <= 0 || h <= 0) {
+        return;
+    }
+
+    const unit_index = restoration_unit_of(ctx, plane, row, col);
+
+    const type = ctx.lr_type[unit_index];
+
+    if (type === RESTORE_WIENER) {
+        wiener_filter(ctx, output, stride, plane, unit_index, x, y, w, h);
+    } else if (type === RESTORE_SGRPROJ) {
+        self_guided_filter(ctx, output, stride, plane, unit_index, x, y, w, h);
+    }
+}
+
+/**
+ * `count_units_in_frame`: how many restoration units of one size a frame is divided into.
+ *
+ * @param {number} unit_size
+ * @param {number} frame_size
+ * @returns {number}
+ */
+export function count_units_in_frame(unit_size, frame_size) {
+    return Math.max(Math.floor((frame_size + (unit_size >> 1)) / unit_size), 1);
+}
+
+/**
+ * Which restoration unit a 4x4 block is filtered by.
+ *
+ * The vertical mapping is offset by eight luma samples, because restoration works in stripes that
+ * are offset by that much. Exported because the encoder has to attribute a block's error to the
+ * same unit this attributes its filtering to, and the two agreeing is the whole point.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} row 4x4 block row
+ * @param {number} col 4x4 block column
+ * @returns {number} index into the per-unit arrays
+ */
+export function restoration_unit_of(ctx, plane, row, col) {
+    const frame = ctx.frame;
+
+    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
+    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
+
+    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));
+
+    const unit_row = Math.min(unit_rows - 1, Math.floor(((row * MI_SIZE + 8) >> sub_y) / unit_size));
+    const unit_col = Math.min(unit_cols - 1, Math.floor(((col * MI_SIZE) >> sub_x) / unit_size));
+
+    return ctx.lr_unit_index(plane, unit_row, unit_col);
+}
+
+/**
+ * `get_source_sample`: deringed inside the current stripe, merely deblocked outside it.
+ *
+ * @param {number} x
+ * @param {number} y
+ * @returns {number}
+ * @see AV1 spec 7.17.6 "Get source sample process"
+ */
+function source_sample(x, y) {
+    const clamped_x = clamp(x, 0, SOURCE.plane_end_x);
+
+    let clamped_y = clamp(y, 0, SOURCE.plane_end_y);
+
+    if (clamped_y < SOURCE.stripe_start_y) {
+        clamped_y = Math.max(SOURCE.stripe_start_y - 2, clamped_y);
+
+        return SOURCE.current[clamped_y * SOURCE.stride + clamped_x];
+    }
+
+    if (clamped_y > SOURCE.stripe_end_y) {
+        clamped_y = Math.min(SOURCE.stripe_end_y + 2, clamped_y);
+
+        return SOURCE.current[clamped_y * SOURCE.stride + clamped_x];
+    }
+
+    return SOURCE.cdef[clamped_y * SOURCE.stride + clamped_x];
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {Uint16Array[]} output
+ * @param {Int32Array} stride
+ * @param {number} plane
+ * @param {number} unit_index
+ * @param {number} x
+ * @param {number} y
+ * @param {number} w
+ * @param {number} h
+ * @see AV1 spec 7.17.4 "Wiener filter process"
+ */
+function wiener_filter(ctx, output, stride, plane, unit_index, x, y, w, h) {
+    const bit_depth = ctx.bit_depth;
+
+    // the rounding the specification derives for a non-compound inter prediction, reused here
+    const round0 = bit_depth === 12 ? 5 : 3;
+    const round1 = bit_depth === 12 ? 9 : 11;
+
+    expand_wiener(ctx.lr_wiener, unit_index * 6, WIENER_VERTICAL);
+    expand_wiener(ctx.lr_wiener, unit_index * 6 + 3, WIENER_HORIZONTAL);
+
+    const offset = 1 << (bit_depth + FILTER_BITS - round0 - 1);
+    const limit = (1 << (bit_depth + 1 + FILTER_BITS - round0)) - 1;
+
+    for (let r = 0; r < h + 6; r++) {
+        for (let c = 0; c < w; c++) {
+            let s = 0;
+
+            for (let t = 0; t < 7; t++) {
+                s += WIENER_HORIZONTAL[t] * source_sample(x + c + t - 3, y + r - 3);
+            }
+
+            WIENER_INTERMEDIATE[r * MI_SIZE + c] = clamp(round2(s, round0), -offset, limit - offset);
+        }
+    }
+
+    const max_value = (1 << bit_depth) - 1;
+
+    const plane_output = output[plane];
+    const plane_stride = stride[plane];
+
+    for (let r = 0; r < h; r++) {
+        for (let c = 0; c < w; c++) {
+            let s = 0;
+
+            for (let t = 0; t < 7; t++) {
+                s += WIENER_VERTICAL[t] * WIENER_INTERMEDIATE[(r + t) * MI_SIZE + c];
+            }
+
+            plane_output[(y + r) * plane_stride + x + c] = clamp(round2(s, round1), 0, max_value);
+        }
+    }
+}
+
+/**
+ * Expand three coded taps into the seven of a symmetric unit-gain filter.
+ *
+ * @param {Int8Array} coefficients
+ * @param {number} offset
+ * @param {Int32Array} filter
+ * @see AV1 spec 7.17.5 "Wiener coefficient process"
+ */
+function expand_wiener(coefficients, offset, filter) {
+    filter[3] = 128;
+
+    for (let i = 0; i < 3; i++) {
+        const c = coefficients[offset + i];
+
+        filter[i] = c;
+        filter[6 - i] = c;
+        filter[3] -= 2 * c;
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {Uint16Array[]} output
+ * @param {Int32Array} stride
+ * @param {number} plane
+ * @param {number} unit_index
+ * @param {number} x
+ * @param {number} y
+ * @param {number} w
+ * @param {number} h
+ * @see AV1 spec 7.17.2 "Self guided filter process"
+ */
+function self_guided_filter(ctx, output, stride, plane, unit_index, x, y, w, h) {
+    const set = ctx.lr_sgr_set[unit_index];
+
+    box_filter(ctx, x, y, w, h, set, 0, FLT0);
+    box_filter(ctx, x, y, w, h, set, 1, FLT1);
+
+    const w0 = ctx.lr_sgr_xqd[unit_index * 2];
+    const w1 = ctx.lr_sgr_xqd[unit_index * 2 + 1];
+    const w2 = (1 << SGRPROJ_PRJ_BITS) - w0 - w1;
+
+    const r0 = SGR_PARAMS[set * 4];
+    const r1 = SGR_PARAMS[set * 4 + 2];
+
+    const max_value = (1 << ctx.bit_depth) - 1;
+
+    const plane_output = output[plane];
+    const plane_stride = stride[plane];
+
+    for (let i = 0; i < h; i++) {
+        for (let j = 0; j < w; j++) {
+            const u = SOURCE.cdef[(y + i) * SOURCE.stride + x + j] << SGRPROJ_RST_BITS;
+
+            let v = w1 * u;
+
+            v += r0 !== 0 ? w0 * FLT0[i * MI_SIZE + j] : w0 * u;
+            v += r1 !== 0 ? w2 * FLT1[i * MI_SIZE + j] : w2 * u;
+
+            plane_output[(y + i) * plane_stride + x + j] = clamp(
+                round2(v, SGRPROJ_RST_BITS + SGRPROJ_PRJ_BITS),
+                0,
+                max_value
+            );
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} x
+ * @param {number} y
+ * @param {number} w
+ * @param {number} h
+ * @param {number} set
+ * @param {number} pass
+ * @param {Int32Array} out
+ * @see AV1 spec 7.17.3 "Box filter process"
+ */
+function box_filter(ctx, x, y, w, h, set, pass, out) {
+    const r = SGR_PARAMS[set * 4 + pass * 2];
+
+    if (r === 0) {
+        return;
+    }
+
+    const eps = SGR_PARAMS[set * 4 + pass * 2 + 1];
+
+    const bit_depth = ctx.bit_depth;
+
+    const n = (2 * r + 1) * (2 * r + 1);
+    const n2e = n * n * eps;
+    const s = Math.floor(((1 << SGRPROJ_MTABLE_BITS) + Math.floor(n2e / 2)) / n2e);
+
+    const one_over_n = Math.floor(((1 << SGRPROJ_RECIP_BITS) + Math.floor(n / 2)) / n);
+
+    for (let i = -1; i < h + 1; i++) {
+        for (let j = -1; j < w + 1; j++) {
+            let a = 0;
+            let b = 0;
+
+            for (let dy = -r; dy <= r; dy++) {
+                for (let dx = -r; dx <= r; dx++) {
+                    const c = source_sample(x + j + dx, y + i + dy);
+
+                    a += c * c;
+                    b += c;
+                }
+            }
+
+            a = round2(a, 2 * (bit_depth - 8));
+
+            const d = round2(b, bit_depth - 8);
+
+            const p = Math.max(0, a * n - d * d);
+
+            /**
+             * `round2_wide`, not `round2`: `p` reaches n^2 times the window variance and `s` is up to
+             * 3236, so `p * s` runs past 2^31 on ordinary content — a 3x3 window across a hard
+             * black/white edge at 8 bit gives 3,787,576,200, where the shifted form returns -484
+             * against an exact 3612. `a2` then comes out at 257 instead of the saturated 256 and the
+             * pixel is filtered with an inverted correction, exactly where restoration is meant to
+             * help. A `z` of -1 would divide by zero and black the pixel out outright.
+             */
+            const z = round2_wide(p * s, SGRPROJ_MTABLE_BITS);
+
+            let a2;
+
+            if (z >= 255) {
+                a2 = 256;
+            } else if (z === 0) {
+                a2 = 1;
+            } else {
+                a2 = Math.floor(((z << SGRPROJ_SGR_BITS) + Math.floor(z / 2)) / (z + 1));
+            }
+
+            const b2 = ((1 << SGRPROJ_SGR_BITS) - a2) * b * one_over_n;
+
+            const index = (i + 1) * BOX_STRIDE + j + 1;
+
+            BOX_A[index] = a2;
+            //same overflow as `z` above: at 12 bit a flat near-white region gives b2 = 4,281,322,500
+            BOX_B[index] = round2_wide(b2, SGRPROJ_RECIP_BITS);
+        }
+    }
+
+    for (let i = 0; i < h; i++) {
+        const shift = pass === 0 && (i & 1) !== 0 ? 4 : 5;
+
+        for (let j = 0; j < w; j++) {
+            let a = 0;
+            let b = 0;
+
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    let weight;
+
+                    if (pass === 0) {
+                        weight = ((i + dy) & 1) !== 0 ? (dx === 0 ? 6 : 5) : 0;
+                    } else {
+                        weight = dx === 0 || dy === 0 ? 4 : 3;
+                    }
+
+                    const index = (i + dy + 1) * BOX_STRIDE + j + dx + 1;
+
+                    a += weight * BOX_A[index];
+                    b += weight * BOX_B[index];
+                }
+            }
+
+            const v = a * SOURCE.cdef[(y + i) * SOURCE.stride + x + j] + b;
+
+            out[i * MI_SIZE + j] = round2(v, SGRPROJ_SGR_BITS + shift - SGRPROJ_RST_BITS);
+        }
+    }
+}