@woosh/meep-engine 3.14.2 → 3.14.4

package/src/avif/native/av1/predict/predict_intra.js

@@ -1,803 +0,0 @@
-import { clamp } from "../../../../core/math/clamp.js";
-import {
-    ANGLE_STEP,
-    D67_PRED,
-    DC_PRED,
-    INTRA_EDGE_TAPS,
-    INTRA_FILTER_SCALE_BITS,
-    SMOOTH_H_PRED,
-    SMOOTH_PRED,
-    SMOOTH_V_PRED,
-    V_PRED
-} from "../tables/av1_symbols.js";
-import {
-    DR_INTRA_DERIVATIVE,
-    INTRA_EDGE_KERNEL,
-    INTRA_FILTER_TAPS,
-    MODE_TO_ANGLE,
-    SM_WEIGHTS_TX_16X16,
-    SM_WEIGHTS_TX_32X32,
-    SM_WEIGHTS_TX_4X4,
-    SM_WEIGHTS_TX_64X64,
-    SM_WEIGHTS_TX_8X8
-} from "../tables/prediction_tables.js";
-import { round2 } from "../util/round2.js";
-import { round2_signed } from "../util/round2_signed.js";
-import { EDGE_ORIGIN } from "./IntraPredictionState.js";
-
-/**
- * Smooth-prediction weights, indexed by the base 2 logarithm of the dimension.
- * @type {Uint8Array[]}
- */
-const SM_WEIGHTS = [
-    null,
-    null,
-    SM_WEIGHTS_TX_4X4,
-    SM_WEIGHTS_TX_8X8,
-    SM_WEIGHTS_TX_16X16,
-    SM_WEIGHTS_TX_32X32,
-    SM_WEIGHTS_TX_64X64
-];
-
-/**
- * Whether `mode` predicts along an angle.
- * @param {number} mode
- * @returns {boolean}
- * @see AV1 spec 7.11.2 "Intra prediction process"
- */
-export function is_directional_mode(mode) {
-    return mode >= V_PRED && mode <= D67_PRED;
-}
-
-/**
- * Whether `mode` is one of the smooth modes, which is what `get_filter_type` tests for.
- * @param {number} mode
- * @returns {boolean}
- */
-export function is_smooth_mode(mode) {
-    return mode === SMOOTH_PRED || mode === SMOOTH_V_PRED || mode === SMOOTH_H_PRED;
-}
-
-/**
- * Intra-predict a transform block, writing the prediction straight into the plane.
- *
- * The specification builds a `pred` array and copies it into `CurrFrame` afterwards. Writing
- * directly is equivalent and saves the copy: the only process that reads back what it has already
- * predicted is the recursive filter, and the samples it reads are exactly the ones just written.
- *
- * @param {IntraPredictionState} state
- * @param {Uint16Array} plane samples of the plane being predicted
- * @param {number} stride
- * @param {number} plane_index `0` luma, `1` U, `2` V
- * @param {number} x left edge of the transform block, in samples
- * @param {number} y top edge of the transform block, in samples
- * @param {number} max_x largest valid x coordinate in this plane
- * @param {number} max_y largest valid y coordinate in this plane
- * @param {number} have_left
- * @param {number} have_above
- * @param {number} have_above_right
- * @param {number} have_below_left
- * @param {number} mode
- * @param {number} log2_w
- * @param {number} log2_h
- * @see AV1 spec 7.11.2 "Intra prediction process"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function predict_intra(
-    state,
-    plane,
-    stride,
-    plane_index,
-    x,
-    y,
-    max_x,
-    max_y,
-    have_left,
-    have_above,
-    have_above_right,
-    have_below_left,
-    mode,
-    log2_w,
-    log2_h
-) {
-    const w = 1 << log2_w;
-    const h = 1 << log2_h;
-
-    const bit_depth = state.bit_depth;
-
-    const above = state.above;
-    const left = state.left;
-
-    build_edges(state, plane, stride, x, y, max_x, max_y, have_left, have_above, have_above_right, have_below_left, w, h);
-
-    if (plane_index === 0 && state.use_filter_intra === 1) {
-        predict_recursive(state, plane, stride, x, y, w, h);
-
-        return;
-    }
-
-    if (is_directional_mode(mode)) {
-        predict_directional(state, plane, stride, x, y, max_x, max_y, have_left, have_above, mode, w, h);
-
-        return;
-    }
-
-    if (mode === SMOOTH_PRED || mode === SMOOTH_V_PRED || mode === SMOOTH_H_PRED) {
-        predict_smooth(above, left, plane, stride, x, y, mode, log2_w, log2_h, w, h);
-
-        return;
-    }
-
-    if (mode === DC_PRED) {
-        predict_dc(above, left, plane, stride, x, y, have_left, have_above, log2_w, log2_h, w, h, bit_depth);
-
-        return;
-    }
-
-    predict_paeth(above, left, plane, stride, x, y, w, h);
-}
-
-/**
- * Fill `AboveRow` and `LeftCol` from the reconstructed neighbours.
- *
- * The two "missing neighbour" defaults differ by two — `(1 << (BitDepth - 1)) - 1` above and
- * `+ 1` to the left — which is not a typo in the specification. It guarantees the two edges are
- * never equal when both are absent, which keeps Paeth prediction from having to break a tie.
- *
- * @param {IntraPredictionState} state
- * @param {Uint16Array} plane
- * @param {number} stride
- * @param {number} x
- * @param {number} y
- * @param {number} max_x
- * @param {number} max_y
- * @param {number} have_left
- * @param {number} have_above
- * @param {number} have_above_right
- * @param {number} have_below_left
- * @param {number} w
- * @param {number} h
- */
-function build_edges(state, plane, stride, x, y, max_x, max_y, have_left, have_above, have_above_right, have_below_left, w, h) {
-    const above = state.above;
-    const left = state.left;
-
-    const count = w + h;
-    const mid = 1 << (state.bit_depth - 1);
-
-    if (have_above === 0 && have_left === 1) {
-        const value = plane[y * stride + x - 1];
-
-        for (let i = 0; i < count; i++) {
-            above[EDGE_ORIGIN + i] = value;
-        }
-    } else if (have_above === 0) {
-        for (let i = 0; i < count; i++) {
-            above[EDGE_ORIGIN + i] = mid - 1;
-        }
-    } else {
-        const limit = Math.min(max_x, x + (have_above_right === 1 ? 2 * w : w) - 1);
-        const row = (y - 1) * stride;
-
-        for (let i = 0; i < count; i++) {
-            above[EDGE_ORIGIN + i] = plane[row + Math.min(limit, x + i)];
-        }
-    }
-
-    if (have_left === 0 && have_above === 1) {
-        const value = plane[(y - 1) * stride + x];
-
-        for (let i = 0; i < count; i++) {
-            left[EDGE_ORIGIN + i] = value;
-        }
-    } else if (have_left === 0) {
-        for (let i = 0; i < count; i++) {
-            left[EDGE_ORIGIN + i] = mid + 1;
-        }
-    } else {
-        const limit = Math.min(max_y, y + (have_below_left === 1 ? 2 * h : h) - 1);
-
-        for (let i = 0; i < count; i++) {
-            left[EDGE_ORIGIN + i] = plane[Math.min(limit, y + i) * stride + x - 1];
-        }
-    }
-
-    let corner;
-
-    if (have_above === 1 && have_left === 1) {
-        corner = plane[(y - 1) * stride + x - 1];
-    } else if (have_above === 1) {
-        corner = plane[(y - 1) * stride + x];
-    } else if (have_left === 1) {
-        corner = plane[y * stride + x - 1];
-    } else {
-        corner = mid;
-    }
-
-    above[EDGE_ORIGIN - 1] = corner;
-    left[EDGE_ORIGIN - 1] = corner;
-}
-
-/**
- * @param {Int32Array} above
- * @param {Int32Array} left
- * @param {Uint16Array} plane
- * @param {number} stride
- * @param {number} x
- * @param {number} y
- * @param {number} w
- * @param {number} h
- * @see AV1 spec 7.11.2.2 "Basic intra prediction process"
- */
-function predict_paeth(above, left, plane, stride, x, y, w, h) {
-    const corner = above[EDGE_ORIGIN - 1];
-
-    for (let i = 0; i < h; i++) {
-        const left_value = left[EDGE_ORIGIN + i];
-        const row = (y + i) * stride + x;
-
-        for (let j = 0; j < w; j++) {
-            const above_value = above[EDGE_ORIGIN + j];
-
-            const base = above_value + left_value - corner;
-
-            const p_left = Math.abs(base - left_value);
-            const p_top = Math.abs(base - above_value);
-            const p_corner = Math.abs(base - corner);
-
-            if (p_left <= p_top && p_left <= p_corner) {
-                plane[row + j] = left_value;
-            } else if (p_top <= p_corner) {
-                plane[row + j] = above_value;
-            } else {
-                plane[row + j] = corner;
-            }
-        }
-    }
-}
-
-/**
- * @param {Int32Array} above
- * @param {Int32Array} left
- * @param {Uint16Array} plane
- * @param {number} stride
- * @param {number} x
- * @param {number} y
- * @param {number} have_left
- * @param {number} have_above
- * @param {number} log2_w
- * @param {number} log2_h
- * @param {number} w
- * @param {number} h
- * @param {number} bit_depth
- * @see AV1 spec 7.11.2.5 "DC intra prediction process"
- */
-function predict_dc(above, left, plane, stride, x, y, have_left, have_above, log2_w, log2_h, w, h, bit_depth) {
-    const max_value = (1 << bit_depth) - 1;
-
-    let value;
-
-    if (have_left === 1 && have_above === 1) {
-        let sum = 0;
-
-        for (let k = 0; k < h; k++) {
-            sum += left[EDGE_ORIGIN + k];
-        }
-
-        for (let k = 0; k < w; k++) {
-            sum += above[EDGE_ORIGIN + k];
-        }
-
-        value = Math.floor((sum + ((w + h) >> 1)) / (w + h));
-    } else if (have_left === 1) {
-        let sum = 0;
-
-        for (let k = 0; k < h; k++) {
-            sum += left[EDGE_ORIGIN + k];
-        }
-
-        value = clamp((sum + (h >> 1)) >> log2_h, 0, max_value);
-    } else if (have_above === 1) {
-        let sum = 0;
-
-        for (let k = 0; k < w; k++) {
-            sum += above[EDGE_ORIGIN + k];
-        }
-
-        value = clamp((sum + (w >> 1)) >> log2_w, 0, max_value);
-    } else {
-        value = 1 << (bit_depth - 1);
-    }
-
-    for (let i = 0; i < h; i++) {
-        const row = (y + i) * stride + x;
-
-        for (let j = 0; j < w; j++) {
-            plane[row + j] = value;
-        }
-    }
-}
-
-/**
- * @param {Int32Array} above
- * @param {Int32Array} left
- * @param {Uint16Array} plane
- * @param {number} stride
- * @param {number} x
- * @param {number} y
- * @param {number} mode
- * @param {number} log2_w
- * @param {number} log2_h
- * @param {number} w
- * @param {number} h
- * @see AV1 spec 7.11.2.6 "Smooth intra prediction process"
- */
-function predict_smooth(above, left, plane, stride, x, y, mode, log2_w, log2_h, w, h) {
-    const weights_x = SM_WEIGHTS[log2_w];
-    const weights_y = SM_WEIGHTS[log2_h];
-
-    const bottom = left[EDGE_ORIGIN + h - 1];
-    const right = above[EDGE_ORIGIN + w - 1];
-
-    if (mode === SMOOTH_PRED) {
-        for (let i = 0; i < h; i++) {
-            const wy = weights_y[i];
-            const left_value = left[EDGE_ORIGIN + i];
-            const row = (y + i) * stride + x;
-
-            for (let j = 0; j < w; j++) {
-                const wx = weights_x[j];
-
-                const sum = wy * above[EDGE_ORIGIN + j]
-                    + (256 - wy) * bottom
-                    + wx * left_value
-                    + (256 - wx) * right;
-
-                plane[row + j] = round2(sum, 9);
-            }
-        }
-
-        return;
-    }
-
-    if (mode === SMOOTH_V_PRED) {
-        for (let i = 0; i < h; i++) {
-            const wy = weights_y[i];
-            const row = (y + i) * stride + x;
-
-            for (let j = 0; j < w; j++) {
-                plane[row + j] = round2(wy * above[EDGE_ORIGIN + j] + (256 - wy) * bottom, 8);
-            }
-        }
-
-        return;
-    }
-
-    for (let i = 0; i < h; i++) {
-        const left_value = left[EDGE_ORIGIN + i];
-        const row = (y + i) * stride + x;
-
-        for (let j = 0; j < w; j++) {
-            const wx = weights_x[j];
-
-            plane[row + j] = round2(wx * left_value + (256 - wx) * right, 8);
-        }
-    }
-}
-
-/**
- * The seven neighbours the recursive filter reads for each 4x2 sub-block. Module-level so a block
- * of any size predicts without allocating.
- * @type {Int32Array}
- */
-const RECURSIVE_NEIGHBOURS = new Int32Array(7);
-
-/**
- * @param {IntraPredictionState} state
- * @param {Uint16Array} plane
- * @param {number} stride
- * @param {number} x
- * @param {number} y
- * @param {number} w
- * @param {number} h
- * @see AV1 spec 7.11.2.3 "Recursive intra prediction process"
- */
-function predict_recursive(state, plane, stride, x, y, w, h) {
-    const above = state.above;
-    const left = state.left;
-
-    const max_value = (1 << state.bit_depth) - 1;
-    const taps_base = state.filter_intra_mode * 8 * 7;
-
-    const w4 = w >> 2;
-    const h2 = h >> 1;
-
-    const p = RECURSIVE_NEIGHBOURS;
-
-    for (let i2 = 0; i2 < h2; i2++) {
-        for (let j4 = 0; j4 < w4; j4++) {
-            for (let i = 0; i < 5; i++) {
-                if (i2 === 0) {
-                    p[i] = above[EDGE_ORIGIN + (j4 << 2) + i - 1];
-                } else if (j4 === 0 && i === 0) {
-                    p[i] = left[EDGE_ORIGIN + (i2 << 1) - 1];
-                } else {
-                    p[i] = plane[(y + (i2 << 1) - 1) * stride + x + (j4 << 2) + i - 1];
-                }
-            }
-
-            for (let i = 5; i < 7; i++) {
-                if (j4 === 0) {
-                    p[i] = left[EDGE_ORIGIN + (i2 << 1) + i - 5];
-                } else {
-                    p[i] = plane[(y + (i2 << 1) + i - 5) * stride + x + (j4 << 2) - 1];
-                }
-            }
-
-            for (let i1 = 0; i1 < 2; i1++) {
-                for (let j1 = 0; j1 < 4; j1++) {
-                    const tap = taps_base + ((i1 << 2) + j1) * 7;
-
-                    let pr = 0;
-
-                    for (let i = 0; i < 7; i++) {
-                        pr += INTRA_FILTER_TAPS[tap + i] * p[i];
-                    }
-
-                    plane[(y + (i2 << 1) + i1) * stride + x + (j4 << 2) + j1] = clamp(
-                        round2_signed(pr, INTRA_FILTER_SCALE_BITS),
-                        0,
-                        max_value
-                    );
-                }
-            }
-        }
-    }
-}
-
-/**
- * @param {IntraPredictionState} state
- * @param {Uint16Array} plane
- * @param {number} stride
- * @param {number} x
- * @param {number} y
- * @param {number} max_x
- * @param {number} max_y
- * @param {number} have_left
- * @param {number} have_above
- * @param {number} mode
- * @param {number} w
- * @param {number} h
- * @see AV1 spec 7.11.2.4 "Directional intra prediction process"
- */
-function predict_directional(state, plane, stride, x, y, max_x, max_y, have_left, have_above, mode, w, h) {
-    const above = state.above;
-    const left = state.left;
-
-    const p_angle = MODE_TO_ANGLE[mode] + state.angle_delta * ANGLE_STEP;
-
-    let upsample_above = 0;
-    let upsample_left = 0;
-
-    if (state.enable_intra_edge_filter === 1) {
-        if (p_angle !== 90 && p_angle !== 180) {
-            if (p_angle > 90 && p_angle < 180 && (w + h) >= 24) {
-                const s = left[EDGE_ORIGIN + 0] * 5 + above[EDGE_ORIGIN - 1] * 6 + above[EDGE_ORIGIN + 0] * 5;
-                const filtered = round2(s, 4);
-
-                left[EDGE_ORIGIN - 1] = filtered;
-                above[EDGE_ORIGIN - 1] = filtered;
-            }
-
-            if (have_above === 1) {
-                const strength = edge_filter_strength(w, h, state.filter_type, p_angle - 90);
-                const num_px = Math.min(w, max_x - x + 1) + (p_angle < 90 ? h : 0) + 1;
-
-                filter_edge(above, num_px, strength);
-            }
-
-            if (have_left === 1) {
-                const strength = edge_filter_strength(w, h, state.filter_type, p_angle - 180);
-                const num_px = Math.min(h, max_y - y + 1) + (p_angle > 180 ? w : 0) + 1;
-
-                filter_edge(left, num_px, strength);
-            }
-        }
-
-        upsample_above = edge_upsample_selection(w, h, state.filter_type, p_angle - 90);
-
-        if (upsample_above === 1) {
-            upsample_edge(above, w + (p_angle < 90 ? h : 0), state.upsample_scratch, state.bit_depth);
-        }
-
-        upsample_left = edge_upsample_selection(w, h, state.filter_type, p_angle - 180);
-
-        if (upsample_left === 1) {
-            upsample_edge(left, h + (p_angle > 180 ? w : 0), state.upsample_scratch, state.bit_depth);
-        }
-    }
-
-    if (p_angle === 90) {
-        for (let i = 0; i < h; i++) {
-            const row = (y + i) * stride + x;
-
-            for (let j = 0; j < w; j++) {
-                plane[row + j] = above[EDGE_ORIGIN + j];
-            }
-        }
-
-        return;
-    }
-
-    if (p_angle === 180) {
-        for (let i = 0; i < h; i++) {
-            const row = (y + i) * stride + x;
-            const value = left[EDGE_ORIGIN + i];
-
-            for (let j = 0; j < w; j++) {
-                plane[row + j] = value;
-            }
-        }
-
-        return;
-    }
-
-    if (p_angle < 90) {
-        const dx = DR_INTRA_DERIVATIVE[p_angle];
-        const max_base_x = (w + h - 1) << upsample_above;
-
-        for (let i = 0; i < h; i++) {
-            const idx = (i + 1) * dx;
-            const shift = ((idx << upsample_above) >> 1) & 0x1f;
-            const base_row = idx >> (6 - upsample_above);
-            const row = (y + i) * stride + x;
-
-            for (let j = 0; j < w; j++) {
-                const base = base_row + (j << upsample_above);
-
-                if (base < max_base_x) {
-                    plane[row + j] = round2(
-                        above[EDGE_ORIGIN + base] * (32 - shift) + above[EDGE_ORIGIN + base + 1] * shift,
-                        5
-                    );
-                } else {
-                    plane[row + j] = above[EDGE_ORIGIN + max_base_x];
-                }
-            }
-        }
-
-        return;
-    }
-
-    if (p_angle > 180) {
-        const dy = DR_INTRA_DERIVATIVE[270 - p_angle];
-
-        for (let i = 0; i < h; i++) {
-            const row = (y + i) * stride + x;
-
-            for (let j = 0; j < w; j++) {
-                const idx = (j + 1) * dy;
-                const base = (idx >> (6 - upsample_left)) + (i << upsample_left);
-                const shift = ((idx << upsample_left) >> 1) & 0x1f;
-
-                plane[row + j] = round2(
-                    left[EDGE_ORIGIN + base] * (32 - shift) + left[EDGE_ORIGIN + base + 1] * shift,
-                    5
-                );
-            }
-        }
-
-        return;
-    }
-
-    // 90 < pAngle < 180: the prediction walks off the above edge onto the left one partway across
-    const dx = DR_INTRA_DERIVATIVE[180 - p_angle];
-    const dy = DR_INTRA_DERIVATIVE[p_angle - 90];
-
-    for (let i = 0; i < h; i++) {
-        const row = (y + i) * stride + x;
-
-        for (let j = 0; j < w; j++) {
-            let idx = (j << 6) - (i + 1) * dx;
-            let base = idx >> (6 - upsample_above);
-
-            if (base >= -(1 << upsample_above)) {
-                const shift = ((idx << upsample_above) >> 1) & 0x1f;
-
-                plane[row + j] = round2(
-                    above[EDGE_ORIGIN + base] * (32 - shift) + above[EDGE_ORIGIN + base + 1] * shift,
-                    5
-                );
-            } else {
-                idx = (i << 6) - (j + 1) * dy;
-                base = idx >> (6 - upsample_left);
-
-                const shift = ((idx << upsample_left) >> 1) & 0x1f;
-
-                plane[row + j] = round2(
-                    left[EDGE_ORIGIN + base] * (32 - shift) + left[EDGE_ORIGIN + base + 1] * shift,
-                    5
-                );
-            }
-        }
-    }
-}
-
-/**
- * @param {number} w
- * @param {number} h
- * @param {number} filter_type
- * @param {number} delta
- * @returns {number} `0 .. 3`
- * @see AV1 spec 7.11.2.9 "Intra edge filter strength selection process"
- */
-function edge_filter_strength(w, h, filter_type, delta) {
-    const d = Math.abs(delta);
-    const blk_wh = w + h;
-
-    let strength = 0;
-
-    if (filter_type === 0) {
-        if (blk_wh <= 8) {
-            if (d >= 56) {
-                strength = 1;
-            }
-        } else if (blk_wh <= 12) {
-            if (d >= 40) {
-                strength = 1;
-            }
-        } else if (blk_wh <= 16) {
-            if (d >= 40) {
-                strength = 1;
-            }
-        } else if (blk_wh <= 24) {
-            if (d >= 8) {
-                strength = 1;
-            }
-
-            if (d >= 16) {
-                strength = 2;
-            }
-
-            if (d >= 32) {
-                strength = 3;
-            }
-        } else if (blk_wh <= 32) {
-            strength = 1;
-
-            if (d >= 4) {
-                strength = 2;
-            }
-
-            if (d >= 32) {
-                strength = 3;
-            }
-        } else {
-            strength = 3;
-        }
-    } else if (blk_wh <= 8) {
-        if (d >= 40) {
-            strength = 1;
-        }
-
-        if (d >= 64) {
-            strength = 2;
-        }
-    } else if (blk_wh <= 16) {
-        if (d >= 20) {
-            strength = 1;
-        }
-
-        if (d >= 48) {
-            strength = 2;
-        }
-    } else if (blk_wh <= 24) {
-        if (d >= 4) {
-            strength = 3;
-        }
-    } else {
-        strength = 3;
-    }
-
-    return strength;
-}
-
-/**
- * @param {number} w
- * @param {number} h
- * @param {number} filter_type
- * @param {number} delta
- * @returns {number} `0` or `1`
- * @see AV1 spec 7.11.2.10 "Intra edge upsample selection process"
- */
-function edge_upsample_selection(w, h, filter_type, delta) {
-    const d = Math.abs(delta);
-    const blk_wh = w + h;
-
-    if (d <= 0 || d >= 40) {
-        return 0;
-    }
-
-    if (filter_type === 0) {
-        return blk_wh <= 16 ? 1 : 0;
-    }
-
-    return blk_wh <= 8 ? 1 : 0;
-}
-
-/**
- * Smooth an edge in place with a five tap kernel.
- *
- * The specification copies the edge out before filtering, and that copy is load-bearing: each
- * output reads two samples ahead, so filtering in place would feed already-filtered values back
- * into later taps.
- *
- * @param {Int32Array} edge offset by {@link EDGE_ORIGIN}
- * @param {number} size
- * @param {number} strength `0 .. 3`
- * @see AV1 spec 7.11.2.12 "Intra edge filter process"
- */
-function filter_edge(edge, size, strength) {
-    if (strength === 0) {
-        return;
-    }
-
-    const copy = EDGE_FILTER_SCRATCH;
-
-    for (let i = 0; i < size; i++) {
-        copy[i] = edge[EDGE_ORIGIN + i - 1];
-    }
-
-    const kernel_base = (strength - 1) * INTRA_EDGE_TAPS;
-
-    for (let i = 1; i < size; i++) {
-        let s = 0;
-
-        for (let j = 0; j < INTRA_EDGE_TAPS; j++) {
-            const k = clamp(i - 2 + j, 0, size - 1);
-
-            s += INTRA_EDGE_KERNEL[kernel_base + j] * copy[k];
-        }
-
-        edge[EDGE_ORIGIN + i - 1] = (s + 8) >> 4;
-    }
-}
-
-/**
- * Scratch for {@link filter_edge}. Module-level because the filter is called twice per directional
- * block and neither call is reentrant.
- * @type {Int32Array}
- */
-const EDGE_FILTER_SCRATCH = new Int32Array(160);
-
-/**
- * Double an edge's resolution in place with a four tap interpolator.
- *
- * @param {Int32Array} edge offset by {@link EDGE_ORIGIN}
- * @param {number} num_px
- * @param {Int32Array} dup scratch of at least `num_px + 3` entries
- * @param {number} bit_depth
- * @see AV1 spec 7.11.2.11 "Intra edge upsample process"
- */
-function upsample_edge(edge, num_px, dup, bit_depth) {
-    const max_value = (1 << bit_depth) - 1;
-
-    dup[0] = edge[EDGE_ORIGIN - 1];
-
-    for (let i = -1; i < num_px; i++) {
-        dup[i + 2] = edge[EDGE_ORIGIN + i];
-    }
-
-    dup[num_px + 2] = edge[EDGE_ORIGIN + num_px - 1];
-
-    edge[EDGE_ORIGIN - 2] = dup[0];
-
-    for (let i = 0; i < num_px; i++) {
-        const s = -dup[i] + 9 * dup[i + 1] + 9 * dup[i + 2] - dup[i + 3];
-
-        edge[EDGE_ORIGIN + 2 * i - 1] = clamp(round2(s, 4), 0, max_value);
-        edge[EDGE_ORIGIN + 2 * i] = dup[i + 2];
-    }
-}