@woosh/meep-engine 3.14.2 → 3.14.3

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

@@ -1,377 +0,0 @@
-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/avif/native/av1/filter/loop_restoration.d.ts.map

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