@woosh/meep-engine 3.14.2 → 3.14.4

package/src/format/image/avif/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];
+    }
+}

package/src/format/image/avif/av1/filter/loop_restoration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop_restoration.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/filter/loop_restoration.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;;;;GAiBG;AACH,sEATW,WAAW,EAAE,QACb,WAAW,EAAE,UACb,WAAW,EAAE,UACb,UAAU,QA+BpB;AAwDD;;;;;;GAMG;AACH,gDAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;GAYG;AACH,iEALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAiBlB"}