@woosh/meep-engine 3.9.0 → 3.11.0

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * Deblock a decoded frame in place.
+ *
+ * Every vertical boundary in a plane is filtered before any horizontal one, which is what makes the
+ * result independent of the order the edges are visited in.
+ *
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 7.14 "Loop filter process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function apply_loop_filter(ctx: Av1FrameContext): void;
+//# sourceMappingURL=loop_filter.d.ts.map

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

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

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

@@ -0,0 +1,377 @@
+import { clamp } from "../../../../core/math/clamp.js";
+import {
+    INTRA_FRAME,
+    MAX_LOOP_FILTER,
+    MI_SIZE,
+    SEG_LVL_ALT_LF_Y_V,
+    SEG_LVL_MAX
+} 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 { round2 } from "../util/round2.js";
+
+/**
+ * Scratch for the wide filter's outputs, which must all be computed before any are written.
+ * @type {Int32Array}
+ */
+const WIDE_FILTER_OUTPUT = new Int32Array(16);
+
+/**
+ * Deblock a decoded frame in place.
+ *
+ * Every vertical boundary in a plane is filtered before any horizontal one, which is what makes the
+ * result independent of the order the edges are visited in.
+ *
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 7.14 "Loop filter process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function apply_loop_filter(ctx) {
+    const frame = ctx.frame;
+
+    if (frame.loop_filter_level[0] === 0 && frame.loop_filter_level[1] === 0) {
+        return;
+    }
+
+    for (let plane = 0; plane < ctx.num_planes; plane++) {
+        if (plane > 0 && frame.loop_filter_level[1 + plane] === 0) {
+            continue;
+        }
+
+        for (let pass = 0; pass < 2; pass++) {
+            const row_step = plane === 0 ? 1 : 1 << ctx.subsampling_y;
+            const col_step = plane === 0 ? 1 : 1 << ctx.subsampling_x;
+
+            for (let row = 0; row < ctx.mi_rows; row += row_step) {
+                for (let col = 0; col < ctx.mi_cols; col += col_step) {
+                    filter_edge(ctx, plane, pass, row, col);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} pass
+ * @param {number} row
+ * @param {number} col
+ * @see AV1 spec 7.14.2 "Edge loop filter process"
+ */
+function filter_edge(ctx, plane, pass, row, col) {
+    const frame = ctx.frame;
+
+    const sub_x = plane === 0 ? 0 : ctx.subsampling_x;
+    const sub_y = plane === 0 ? 0 : ctx.subsampling_y;
+
+    const dx = pass === 0 ? 1 : 0;
+    const dy = pass === 0 ? 0 : 1;
+
+    const x = col * MI_SIZE;
+    const y = row * MI_SIZE;
+
+    // a chroma edge is decided by the mode info of the block that owns the chroma sample, which for
+    // subsampled planes is the odd-indexed one of the pair
+    const mi_row = row | sub_y;
+    const mi_col = col | sub_x;
+
+    if (x >= frame.frame_width || y >= frame.frame_height) {
+        return;
+    }
+
+    if (pass === 0 && x === 0) {
+        return;
+    }
+
+    if (pass === 1 && y === 0) {
+        return;
+    }
+
+    const xp = x >> sub_x;
+    const yp = y >> sub_y;
+
+    const previous_row = mi_row - (dy << sub_y);
+    const previous_col = mi_col - (dx << sub_x);
+
+    const stride = ctx.mi_stride;
+    const index = mi_row * stride + mi_col;
+
+    const mi_size = ctx.mi_sizes[index];
+    const skip = ctx.skips[index];
+
+    const tx_stride = ctx.plane_stride[plane] >> 2;
+
+    const tx_size = ctx.loop_filter_tx_sizes[plane][(mi_row >> sub_y) * tx_stride + (mi_col >> sub_x)];
+    const previous_tx_size = ctx.loop_filter_tx_sizes[plane][(previous_row >> sub_y) * tx_stride + (previous_col >> sub_x)];
+
+    const plane_size = SUBSAMPLED_SIZE[(mi_size * 2 + sub_x) * 2 + sub_y];
+
+    const is_block_edge = pass === 0
+        ? xp % BLOCK_WIDTH[plane_size] === 0
+        : yp % BLOCK_HEIGHT[plane_size] === 0;
+
+    const is_tx_edge = pass === 0
+        ? xp % TX_WIDTH[tx_size] === 0
+        : yp % TX_HEIGHT[tx_size] === 0;
+
+    // every block here is intra, so the specification's `isIntra` term is always true and any
+    // transform edge is filtered regardless of the skip flag
+    const apply = is_tx_edge && (is_block_edge || skip === 0 || true);
+
+    if (!apply) {
+        return;
+    }
+
+    const base_size = pass === 0
+        ? Math.min(TX_WIDTH[previous_tx_size], TX_WIDTH[tx_size])
+        : Math.min(TX_HEIGHT[previous_tx_size], TX_HEIGHT[tx_size]);
+
+    const filter_size = plane === 0 ? Math.min(16, base_size) : Math.min(8, base_size);
+
+    let level = filter_strength(ctx, mi_row, mi_col, plane, pass);
+
+    if (level === 0) {
+        level = filter_strength(ctx, previous_row, previous_col, plane, pass);
+    }
+
+    if (level === 0) {
+        return;
+    }
+
+    const sharpness = frame.loop_filter_sharpness;
+
+    const shift = sharpness > 4 ? 2 : (sharpness > 0 ? 1 : 0);
+
+    const limit = sharpness > 0
+        ? clamp(level >> shift, 1, 9 - sharpness)
+        : Math.max(1, level >> shift);
+
+    const blimit = 2 * (level + 2) + limit;
+    const thresh = level >> 4;
+
+    for (let i = 0; i < MI_SIZE; i++) {
+        filter_samples(ctx, plane, xp + dy * i, yp + dx * i, limit, blimit, thresh, dx, dy, filter_size);
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} row
+ * @param {number} col
+ * @param {number} plane
+ * @param {number} pass
+ * @returns {number}
+ * @see AV1 spec 7.14.4 "Adaptive filter strength process"
+ */
+function filter_strength(ctx, row, col, plane, pass) {
+    if (row < 0 || col < 0 || row >= ctx.mi_rows || col >= ctx.mi_cols) {
+        return 0;
+    }
+
+    const frame = ctx.frame;
+
+    const index = row * ctx.mi_stride + col;
+
+    const segment = ctx.segment_ids[index];
+
+    const i = plane === 0 ? pass : plane + 1;
+
+    const delta_lf = frame.delta_lf_multi === 0
+        ? ctx.delta_lfs[index * 4]
+        : ctx.delta_lfs[index * 4 + i];
+
+    let level = clamp(delta_lf + frame.loop_filter_level[i], 0, MAX_LOOP_FILTER);
+
+    const feature = SEG_LVL_ALT_LF_Y_V + i;
+
+    if (frame.segmentation_enabled === 1 && frame.feature_enabled[segment * SEG_LVL_MAX + feature] !== 0) {
+        level = clamp(frame.feature_data[segment * SEG_LVL_MAX + feature] + level, 0, MAX_LOOP_FILTER);
+    }
+
+    if (frame.loop_filter_delta_enabled === 1) {
+        // every block here is intra, so only the INTRA_FRAME reference delta can apply and the
+        // mode delta never does
+        const n_shift = level >> 5;
+
+        level = clamp(level + (frame.loop_filter_ref_deltas[INTRA_FRAME] << n_shift), 0, MAX_LOOP_FILTER);
+    }
+
+    return level;
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} x
+ * @param {number} y
+ * @param {number} limit
+ * @param {number} blimit
+ * @param {number} thresh
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} filter_size
+ * @see AV1 spec 7.14.6 "Sample filtering process"
+ */
+function filter_samples(ctx, plane, x, y, limit, blimit, thresh, dx, dy, filter_size) {
+    const samples = ctx.planes[plane];
+    const stride = ctx.plane_stride[plane];
+    const bit_depth = ctx.bit_depth;
+
+    const step = dy * stride + dx;
+    const centre = y * stride + x;
+
+    const q0 = samples[centre];
+    const q1 = samples[centre + step];
+    const q2 = samples[centre + step * 2];
+    const q3 = samples[centre + step * 3];
+
+    const p0 = samples[centre - step];
+    const p1 = samples[centre - step * 2];
+    const p2 = samples[centre - step * 3];
+    const p3 = samples[centre - step * 4];
+
+    const scale = bit_depth - 8;
+
+    const thresh_bd = thresh << scale;
+
+    const hev_mask = Math.abs(p1 - p0) > thresh_bd || Math.abs(q1 - q0) > thresh_bd;
+
+    const filter_len = filter_size === 4 ? 4 : (plane !== 0 ? 6 : (filter_size === 8 ? 8 : 16));
+
+    const limit_bd = limit << scale;
+    const blimit_bd = blimit << scale;
+
+    let mask = Math.abs(p1 - p0) > limit_bd
+        || Math.abs(q1 - q0) > limit_bd
+        || Math.abs(p0 - q0) * 2 + Math.floor(Math.abs(p1 - q1) / 2) > blimit_bd;
+
+    if (!mask && filter_len >= 6) {
+        mask = Math.abs(p2 - p1) > limit_bd || Math.abs(q2 - q1) > limit_bd;
+    }
+
+    if (!mask && filter_len >= 8) {
+        mask = Math.abs(p3 - p2) > limit_bd || Math.abs(q3 - q2) > limit_bd;
+    }
+
+    if (mask) {
+        return;
+    }
+
+    const threshold_bd = 1 << scale;
+
+    let flat_mask = false;
+
+    if (filter_size >= 8) {
+        let flat = Math.abs(p1 - p0) > threshold_bd
+            || Math.abs(q1 - q0) > threshold_bd
+            || Math.abs(p2 - p0) > threshold_bd
+            || Math.abs(q2 - q0) > threshold_bd;
+
+        if (!flat && filter_len >= 8) {
+            flat = Math.abs(p3 - p0) > threshold_bd || Math.abs(q3 - q0) > threshold_bd;
+        }
+
+        flat_mask = !flat;
+    }
+
+    if (filter_size === 4 || !flat_mask) {
+        narrow_filter(samples, centre, step, hev_mask, bit_depth);
+
+        return;
+    }
+
+    if (filter_size >= 16) {
+        const q4 = samples[centre + step * 4];
+        const q5 = samples[centre + step * 5];
+        const q6 = samples[centre + step * 6];
+
+        const p4 = samples[centre - step * 5];
+        const p5 = samples[centre - step * 6];
+        const p6 = samples[centre - step * 7];
+
+        const flat2 = Math.abs(p6 - p0) > threshold_bd
+            || Math.abs(q6 - q0) > threshold_bd
+            || Math.abs(p5 - p0) > threshold_bd
+            || Math.abs(q5 - q0) > threshold_bd
+            || Math.abs(p4 - p0) > threshold_bd
+            || Math.abs(q4 - q0) > threshold_bd;
+
+        if (!flat2) {
+            wide_filter(samples, centre, step, plane, 4);
+
+            return;
+        }
+    }
+
+    wide_filter(samples, centre, step, plane, 3);
+}
+
+/**
+ * @param {Uint16Array} samples
+ * @param {number} centre
+ * @param {number} step
+ * @param {boolean} hev_mask
+ * @param {number} bit_depth
+ * @see AV1 spec 7.14.6.3 "Narrow filter process"
+ */
+function narrow_filter(samples, centre, step, hev_mask, bit_depth) {
+    const offset = 0x80 << (bit_depth - 8);
+
+    const low = -(1 << (bit_depth - 1));
+    const high = (1 << (bit_depth - 1)) - 1;
+
+    const ps1 = samples[centre - step * 2] - offset;
+    const ps0 = samples[centre - step] - offset;
+    const qs0 = samples[centre] - offset;
+    const qs1 = samples[centre + step] - offset;
+
+    let filter = hev_mask ? clamp(ps1 - qs1, low, high) : 0;
+
+    filter = clamp(filter + 3 * (qs0 - ps0), low, high);
+
+    const filter1 = clamp(filter + 4, low, high) >> 3;
+    const filter2 = clamp(filter + 3, low, high) >> 3;
+
+    samples[centre] = clamp(qs0 - filter1, low, high) + offset;
+    samples[centre - step] = clamp(ps0 + filter2, low, high) + offset;
+
+    if (!hev_mask) {
+        const adjust = round2(filter1, 1);
+
+        samples[centre + step] = clamp(qs1 - adjust, low, high) + offset;
+        samples[centre - step * 2] = clamp(ps1 + adjust, low, high) + offset;
+    }
+}
+
+/**
+ * @param {Uint16Array} samples
+ * @param {number} centre
+ * @param {number} step
+ * @param {number} plane
+ * @param {number} log2_size
+ * @see AV1 spec 7.14.6.4 "Wide filter process"
+ */
+function wide_filter(samples, centre, step, plane, log2_size) {
+    const n = log2_size === 4 ? 6 : (plane === 0 ? 3 : 2);
+    const n2 = log2_size === 3 && plane === 0 ? 0 : 1;
+
+    for (let i = -n; i < n; i++) {
+        let t = 0;
+
+        for (let j = -n; j <= n; j++) {
+            const p = clamp(i + j, -(n + 1), n);
+            const tap = Math.abs(j) <= n2 ? 2 : 1;
+
+            t += samples[centre + p * step] * tap;
+        }
+
+        WIDE_FILTER_OUTPUT[i + n] = round2(t, log2_size);
+    }
+
+    for (let i = -n; i < n; i++) {
+        samples[centre + i * step] = WIDE_FILTER_OUTPUT[i + n];
+    }
+}