@woosh/meep-engine 3.14.1 → 3.14.3

package/src/format/image/avif/av1/predict/predict_intra.js

@@ -0,0 +1,803 @@
+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];
+    }
+}