@woosh/meep-engine 3.9.0 → 3.11.0

package/src/avif/native/av1/decode/Av1FrameContext.js

@@ -0,0 +1,622 @@
+import { CdfContext } from "../entropy/CdfContext.js";
+import { FilmGrainState } from "../grain/FilmGrainState.js";
+import { IntraPredictionState } from "../predict/IntraPredictionState.js";
+import { PartitionCdf } from "../entropy/partition_cdf.js";
+import { SymbolReader } from "../entropy/SymbolReader.js";
+import { SymbolWriter } from "../entropy/SymbolWriter.js";
+
+/**
+ * Widest superblock, in 4x4 units.
+ * @type {number}
+ */
+const MAX_SB4 = 32;
+
+/**
+ * Stride of the block-decoded flag planes. One entry either side of the superblock, since the
+ * specification indexes them from `-1`.
+ * @type {number}
+ */
+export const BLOCK_DECODED_STRIDE = MAX_SB4 + 3;
+
+/**
+ * Where index `0` sits in a block-decoded plane.
+ * @type {number}
+ */
+export const BLOCK_DECODED_ORIGIN = 1;
+
+/**
+ * Largest palette a block may carry.
+ * @type {number}
+ */
+export const MAX_PALETTE_SIZE = 8;
+
+/**
+ * Everything a frame decode needs, allocated once and reused.
+ *
+ * The layout follows the protocol's flat-storage rule: per-4x4 state is one typed array per field,
+ * indexed `mi_row * mi_stride + mi_col`. The neighbour lookups those feed are the hottest reads in
+ * the tile decoder, and an array of per-block objects would make every one of them a pointer chase.
+ *
+ * {@link resize} is idempotent for a given frame geometry, so decoding many images of the same size
+ * allocates only on the first.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Av1FrameContext {
+    /** @type {SequenceHeader|null} */
+    sequence = null;
+
+    /** @type {FrameHeader|null} */
+    frame = null;
+
+    /** @type {CdfContext} */
+    cdf = new CdfContext();
+
+    /** @type {SymbolReader} */
+    reader = new SymbolReader();
+
+    /**
+     * @type {SymbolWriter} the same state serves an encode; only the direction of the arithmetic
+     * coder differs, and everything else — planes, contexts, CDFs — is shared
+     */
+    writer = new SymbolWriter();
+
+    /** @type {IntraPredictionState} */
+    intra = new IntraPredictionState();
+
+    /** @type {PartitionCdf} refilled by every partition decision rather than allocated by one */
+    partition_selection = new PartitionCdf();
+
+    /** @type {FilmGrainState} */
+    grain = new FilmGrainState();
+
+    // ---- geometry ------------------------------------------------------------------------------
+
+    /** @type {number} */
+    mi_cols = 0;
+
+    /** @type {number} */
+    mi_rows = 0;
+
+    /** @type {number} */
+    mi_stride = 0;
+
+    /** @type {number} */
+    num_planes = 1;
+
+    /** @type {number} */
+    subsampling_x = 0;
+
+    /** @type {number} */
+    subsampling_y = 0;
+
+    /** @type {number} */
+    bit_depth = 8;
+
+    // ---- sample planes -------------------------------------------------------------------------
+
+    /** @type {Uint16Array[]} one per plane, allocated at the mode-info-aligned size */
+    planes = [null, null, null];
+
+    /**
+     * Distance between rows of a plane, in samples.
+     *
+     * Wider than {@link plane_width}: a block whose superblock overhangs the right edge of the
+     * frame is still predicted and reconstructed in full, so the plane is padded out to a whole
+     * superblock. Without that padding those writes wrap into the next row's leading samples and
+     * corrupt a strip down the left of the image — which is exactly what they did.
+     * @type {Int32Array}
+     */
+    plane_stride = new Int32Array(3);
+
+    /** @type {Int32Array} the visible extent, and the largest coordinate prediction may read */
+    plane_width = new Int32Array(3);
+
+    /** @type {Int32Array} */
+    plane_height = new Int32Array(3);
+
+    /** @type {Int32Array} rows a plane's buffer holds, padded to a whole superblock like the stride */
+    plane_rows = new Int32Array(3);
+
+    /** @type {number} stride of the post-superres buffers, in luma samples */
+    upscaled_stride = 0;
+
+    /** @type {Int32Array} per-plane form of {@link upscaled_stride} */
+    upscaled_plane_stride = new Int32Array(3);
+
+    // ---- per 4x4 mode info ---------------------------------------------------------------------
+
+    /** @type {Uint8Array} */
+    y_modes = null;
+
+    /** @type {Uint8Array} */
+    uv_modes = null;
+
+    /** @type {Uint8Array} */
+    mi_sizes = null;
+
+    /** @type {Uint8Array} */
+    tx_sizes = null;
+
+    /** @type {Uint8Array} */
+    inter_tx_sizes = null;
+
+    /** @type {Uint8Array} */
+    skips = null;
+
+    /** @type {Uint8Array} */
+    is_inters = null;
+
+    /** @type {Uint8Array} */
+    segment_ids = null;
+
+    /** @type {Uint8Array} `[plane][mi]`, two planes */
+    palette_sizes = null;
+
+    /** @type {Uint16Array} `[plane][mi][colour]`, two planes of eight colours */
+    palette_colors = null;
+
+    /** @type {Int8Array} `[mi][filter]`, four loop filter deltas */
+    delta_lfs = null;
+
+    /** @type {Int8Array} one per superblock-aligned position, `-1` when unset */
+    cdef_idx = null;
+
+    /** @type {Uint8Array} transform type per luma 4x4 */
+    tx_types = null;
+
+    /** @type {Uint8Array[]} transform size per plane 4x4, for the loop filter */
+    loop_filter_tx_sizes = [null, null, null];
+
+    // ---- entropy contexts ----------------------------------------------------------------------
+
+    /** @type {Uint8Array[]} */
+    above_level_context = [null, null, null];
+
+    /** @type {Uint8Array[]} */
+    above_dc_context = [null, null, null];
+
+    /** @type {Uint8Array[]} */
+    left_level_context = [null, null, null];
+
+    /** @type {Uint8Array[]} */
+    left_dc_context = [null, null, null];
+
+    /** @type {Uint8Array[]} `[-1 .. sbSize4]` in both axes, offset by {@link BLOCK_DECODED_ORIGIN} */
+    block_decoded = [null, null, null];
+
+    // ---- post-processing planes ------------------------------------------------------------------
+
+    /** @type {Uint16Array[]} the deringed frame, allocated only when CDEF or restoration is in use */
+    cdef_planes = [null, null, null];
+
+    /** @type {Uint16Array[]} the deblocked frame after superres, allocated only when it is in use */
+    upscaled_planes = [null, null, null];
+
+    /** @type {Uint16Array[]} the deringed frame after superres */
+    upscaled_cdef_planes = [null, null, null];
+
+    /** @type {Uint16Array[]} the restored frame, allocated only when loop restoration is in use */
+    lr_planes = [null, null, null];
+
+    /**
+     * The planes a consumer should read, and their stride.
+     *
+     * Post-processing is a chain of whole-frame passes, and which buffer holds the final result
+     * depends on which of them ran. Rather than make every consumer work that out, the decode
+     * points these at the answer.
+     * @type {Uint16Array[]}
+     */
+    output_planes = [null, null, null];
+
+    /** @type {Int32Array} */
+    output_stride = new Int32Array(3);
+
+    /** @type {number} width of {@link output_planes}, after any superres upscaling */
+    output_width = 0;
+
+    /** @type {number} */
+    output_height = 0;
+
+    // ---- loop restoration units ------------------------------------------------------------------
+
+    /** @type {number} */
+    lr_unit_stride = 0;
+
+    /** @type {number} */
+    lr_unit_rows = 0;
+
+    /** @type {Uint8Array} one `RESTORE_*` per unit, per plane */
+    lr_type = null;
+
+    /** @type {Int8Array} two passes of three taps per unit, per plane */
+    lr_wiener = null;
+
+    /** @type {Uint8Array} */
+    lr_sgr_set = null;
+
+    /** @type {Int8Array} two weights per unit, per plane */
+    lr_sgr_xqd = null;
+
+    /** @type {Int8Array} the running reference the subexp coding is relative to */
+    ref_lr_wiener = new Int8Array(3 * 2 * 3);
+
+    /** @type {Int8Array} */
+    ref_sgr_xqd = new Int8Array(3 * 2);
+
+    // ---- coefficient scratch -------------------------------------------------------------------
+
+    /** @type {Int32Array} the current transform block's quantised levels, by raster position */
+    quant = new Int32Array(1024);
+
+    /** @type {Int32Array} dequantised coefficients, then the spatial residual */
+    residual = new Int32Array(64 * 64);
+
+    /** @type {Int32Array} scratch for the 1D transforms */
+    transform_scratch = new Int32Array(64);
+
+    // ---- current block registers ---------------------------------------------------------------
+
+    /** @type {number} */
+    mi_row = 0;
+
+    /** @type {number} */
+    mi_col = 0;
+
+    /** @type {number} */
+    mi_size = 0;
+
+    /** @type {number} */
+    y_mode = 0;
+
+    /** @type {number} */
+    uv_mode = 0;
+
+    /** @type {number} */
+    angle_delta_y = 0;
+
+    /** @type {number} */
+    angle_delta_uv = 0;
+
+    /** @type {number} */
+    use_filter_intra = 0;
+
+    /** @type {number} */
+    filter_intra_mode = 0;
+
+    /** @type {number} */
+    cfl_alpha_u = 0;
+
+    /** @type {number} */
+    cfl_alpha_v = 0;
+
+    /** @type {number} */
+    skip = 0;
+
+    /** @type {number} */
+    segment_id = 0;
+
+    /** @type {number} */
+    lossless = 0;
+
+    /** @type {number} */
+    tx_size = 0;
+
+    /** @type {number} */
+    has_chroma = 0;
+
+    /** @type {number} */
+    avail_u = 0;
+
+    /** @type {number} */
+    avail_l = 0;
+
+    /** @type {number} */
+    avail_u_chroma = 0;
+
+    /** @type {number} */
+    avail_l_chroma = 0;
+
+    /** @type {number} */
+    read_deltas = 0;
+
+    /** @type {number} */
+    current_q_index = 0;
+
+    /** @type {Int32Array} */
+    delta_lf = new Int32Array(4);
+
+    /** @type {number} */
+    max_luma_w = 0;
+
+    /** @type {number} */
+    max_luma_h = 0;
+
+    /** @type {number} the transform type in force for the transform block being reconstructed */
+    plane_tx_type = 0;
+
+    /**
+     * Diagnostic sink. When set to an array, every transform block appends a record of what it
+     * decoded — position, size, type, end-of-block and its first levels.
+     *
+     * Here rather than added when something breaks, because the failure mode it exists for is an
+     * entropy desync: the encoder and the decoder walk their two traces together until they
+     * disagree, and the first record that differs is the symbol that went wrong. By the time the
+     * picture looks wrong, it is thousands of symbols too late to ask. Left null it costs one
+     * comparison per transform block.
+     * @type {Array|null}
+     */
+    trace = null;
+
+    // ---- palette ---------------------------------------------------------------------------------
+
+    /** @type {number} */
+    palette_size_y = 0;
+
+    /** @type {number} */
+    palette_size_uv = 0;
+
+    /** @type {Uint16Array} */
+    palette_colors_y = new Uint16Array(MAX_PALETTE_SIZE);
+
+    /** @type {Uint16Array} */
+    palette_colors_u = new Uint16Array(MAX_PALETTE_SIZE);
+
+    /** @type {Uint16Array} */
+    palette_colors_v = new Uint16Array(MAX_PALETTE_SIZE);
+
+    /** @type {Uint16Array} merged neighbour palettes */
+    palette_cache = new Uint16Array(2 * MAX_PALETTE_SIZE);
+
+    /** @type {Uint8Array} colour map for luma, one entry per sample of the block */
+    color_map_y = new Uint8Array(128 * 128);
+
+    /** @type {Uint8Array} colour map for chroma */
+    color_map_uv = new Uint8Array(128 * 128);
+
+    /** @type {number} */
+    color_map_stride = 128;
+
+    /** @type {Uint8Array} palette indices sorted by neighbour score */
+    color_order = new Uint8Array(MAX_PALETTE_SIZE);
+
+    /** @type {Int32Array} */
+    color_scores = new Int32Array(MAX_PALETTE_SIZE);
+
+    // ---- tile bounds -----------------------------------------------------------------------------
+
+    /** @type {number} */
+    mi_row_start = 0;
+
+    /** @type {number} */
+    mi_row_end = 0;
+
+    /** @type {number} */
+    mi_col_start = 0;
+
+    /** @type {number} */
+    mi_col_end = 0;
+
+    /**
+     * Size the context for a frame, allocating only what has grown.
+     *
+     * @param {SequenceHeader} sequence
+     * @param {FrameHeader} frame
+     */
+    resize(sequence, frame) {
+        this.sequence = sequence;
+        this.frame = frame;
+
+        this.mi_cols = frame.mi_cols;
+        this.mi_rows = frame.mi_rows;
+        this.mi_stride = frame.mi_cols;
+        this.num_planes = sequence.num_planes;
+        this.subsampling_x = sequence.subsampling_x;
+        this.subsampling_y = sequence.subsampling_y;
+        this.bit_depth = sequence.bit_depth;
+
+        const mi_count = this.mi_stride * this.mi_rows;
+
+        // a block never crosses a superblock boundary, so padding each plane out to a whole
+        // superblock is exactly enough room for any block that overhangs the frame
+        const superblock = sequence.use_128x128_superblock === 1 ? 128 : 64;
+
+        const padded_width = Math.ceil((this.mi_cols * 4) / superblock) * superblock;
+        const padded_height = Math.ceil((this.mi_rows * 4) / superblock) * superblock;
+
+        for (let plane = 0; plane < 3; plane++) {
+            const sub_x = plane > 0 ? this.subsampling_x : 0;
+            const sub_y = plane > 0 ? this.subsampling_y : 0;
+
+            const width = (this.mi_cols * 4) >> sub_x;
+            const height = (this.mi_rows * 4) >> sub_y;
+
+            const stride = padded_width >> sub_x;
+            const rows = padded_height >> sub_y;
+
+            this.plane_width[plane] = width;
+            this.plane_height[plane] = height;
+            this.plane_stride[plane] = stride;
+            this.plane_rows[plane] = rows;
+
+            if (plane < this.num_planes) {
+                this.planes[plane] = allocate_uint16(this.planes[plane], stride * rows);
+                this.loop_filter_tx_sizes[plane] = allocate_uint8(this.loop_filter_tx_sizes[plane], (stride >> 2) * (rows >> 2));
+
+                this.above_level_context[plane] = allocate_uint8(this.above_level_context[plane], (stride >> 2) + 32);
+                this.above_dc_context[plane] = allocate_uint8(this.above_dc_context[plane], (stride >> 2) + 32);
+                this.left_level_context[plane] = allocate_uint8(this.left_level_context[plane], (rows >> 2) + 32);
+                this.left_dc_context[plane] = allocate_uint8(this.left_dc_context[plane], (rows >> 2) + 32);
+
+                this.block_decoded[plane] = allocate_uint8(this.block_decoded[plane], BLOCK_DECODED_STRIDE * BLOCK_DECODED_STRIDE);
+            }
+        }
+
+        this.y_modes = allocate_uint8(this.y_modes, mi_count);
+        this.uv_modes = allocate_uint8(this.uv_modes, mi_count);
+        this.mi_sizes = allocate_uint8(this.mi_sizes, mi_count);
+        this.tx_sizes = allocate_uint8(this.tx_sizes, mi_count);
+        this.inter_tx_sizes = allocate_uint8(this.inter_tx_sizes, mi_count);
+        this.skips = allocate_uint8(this.skips, mi_count);
+        this.is_inters = allocate_uint8(this.is_inters, mi_count);
+        this.segment_ids = allocate_uint8(this.segment_ids, mi_count);
+        this.palette_sizes = allocate_uint8(this.palette_sizes, mi_count * 2);
+        this.palette_colors = allocate_uint16(this.palette_colors, mi_count * 2 * MAX_PALETTE_SIZE);
+        this.cdef_idx = allocate_int8(this.cdef_idx, mi_count);
+        this.tx_types = allocate_uint8(this.tx_types, mi_count);
+
+        this.delta_lfs = allocate_int8(this.delta_lfs, mi_count * 4);
+
+        this.#resize_post_processing(sequence, frame, padded_width, padded_height);
+    }
+
+    /**
+     * Allocate the buffers each post-processing pass needs, and only those.
+     *
+     * A frame that uses none of them keeps one plane set; one that uses all of them needs four, and
+     * at twelve bits that is not a trivial amount of memory to hold for nothing.
+     *
+     * @param {SequenceHeader} sequence
+     * @param {FrameHeader} frame
+     * @param {number} padded_width
+     * @param {number} padded_height
+     * @private
+     */
+    #resize_post_processing(sequence, frame, padded_width, padded_height) {
+        const uses_cdef = frame.coded_lossless === 0
+            && frame.allow_intrabc === 0
+            && sequence.enable_cdef === 1;
+
+        const uses_superres = frame.use_superres === 1;
+        const uses_lr = frame.uses_lr === 1;
+
+        // superres widens the frame, so everything after it is sized from the upscaled width
+        const upscaled_padded_width = Math.max(padded_width, Math.ceil(frame.upscaled_width / 64) * 64);
+
+        this.upscaled_stride = upscaled_padded_width;
+
+        for (let plane = 0; plane < this.num_planes; plane++) {
+            const sub_x = plane > 0 ? this.subsampling_x : 0;
+            const sub_y = plane > 0 ? this.subsampling_y : 0;
+
+            const stride = padded_width >> sub_x;
+            const rows = padded_height >> sub_y;
+
+            const upscaled_stride = upscaled_padded_width >> sub_x;
+
+            this.upscaled_plane_stride[plane] = upscaled_stride;
+
+            this.cdef_planes[plane] = uses_cdef || uses_lr
+                ? allocate_uint16(this.cdef_planes[plane], stride * rows)
+                : null;
+
+            this.upscaled_planes[plane] = uses_superres
+                ? allocate_uint16(this.upscaled_planes[plane], upscaled_stride * rows)
+                : null;
+
+            this.upscaled_cdef_planes[plane] = uses_superres
+                ? allocate_uint16(this.upscaled_cdef_planes[plane], upscaled_stride * rows)
+                : null;
+
+            this.lr_planes[plane] = uses_lr
+                ? allocate_uint16(this.lr_planes[plane], upscaled_stride * rows)
+                : null;
+        }
+
+        if (!uses_lr) {
+            this.lr_unit_stride = 0;
+            this.lr_unit_rows = 0;
+
+            return;
+        }
+
+        let columns = 1;
+        let unit_rows = 1;
+
+        for (let plane = 0; plane < this.num_planes; plane++) {
+            const sub_x = plane > 0 ? this.subsampling_x : 0;
+            const sub_y = plane > 0 ? this.subsampling_y : 0;
+
+            const unit_size = frame.loop_restoration_size[plane];
+
+            columns = Math.max(columns, count_units(unit_size, (frame.upscaled_width + sub_x) >> sub_x));
+            unit_rows = Math.max(unit_rows, count_units(unit_size, (frame.frame_height + sub_y) >> sub_y));
+        }
+
+        this.lr_unit_stride = columns;
+        this.lr_unit_rows = unit_rows;
+
+        const units = 3 * unit_rows * columns;
+
+        this.lr_type = allocate_uint8(this.lr_type, units);
+        this.lr_sgr_set = allocate_uint8(this.lr_sgr_set, units);
+        this.lr_wiener = allocate_int8(this.lr_wiener, units * 6);
+        this.lr_sgr_xqd = allocate_int8(this.lr_sgr_xqd, units * 2);
+    }
+
+    /**
+     * Index of one loop restoration unit within the per-unit arrays.
+     * @param {number} plane
+     * @param {number} unit_row
+     * @param {number} unit_col
+     * @returns {number}
+     */
+    lr_unit_index(plane, unit_row, unit_col) {
+        return (plane * this.lr_unit_rows + unit_row) * this.lr_unit_stride + unit_col;
+    }
+}
+
+/**
+ * @param {number} unit_size
+ * @param {number} frame_size
+ * @returns {number}
+ */
+function count_units(unit_size, frame_size) {
+    return Math.max(Math.floor((frame_size + (unit_size >> 1)) / unit_size), 1);
+}
+
+/**
+ * @param {Uint8Array|null} existing
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+function allocate_uint8(existing, length) {
+    if (existing !== null && existing.length >= length) {
+        existing.fill(0);
+
+        return existing;
+    }
+
+    return new Uint8Array(length);
+}
+
+/**
+ * @param {Int8Array|null} existing
+ * @param {number} length
+ * @returns {Int8Array}
+ */
+function allocate_int8(existing, length) {
+    if (existing !== null && existing.length >= length) {
+        existing.fill(0);
+
+        return existing;
+    }
+
+    return new Int8Array(length);
+}
+
+/**
+ * @param {Uint16Array|null} existing
+ * @param {number} length
+ * @returns {Uint16Array}
+ */
+function allocate_uint16(existing, length) {
+    if (existing !== null && existing.length >= length) {
+        existing.fill(0);
+
+        return existing;
+    }
+
+    return new Uint16Array(length);
+}

package/src/avif/native/av1/decode/block_decoded.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Where a superblock's neighbours are, as far as intra prediction is concerned.
+ *
+ * Shared with the encoder: prediction reads these to decide whether the samples above right and
+ * below left have been coded yet, and an encoder that disagreed would predict from something the
+ * decoder cannot.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} sb_size4
+ * @see AV1 spec 5.11.3 "Clear block decoded flags function"
+ */
+export function clear_block_decoded_flags(ctx: Av1FrameContext, r: number, c: number, sb_size4: number): void;
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @returns {boolean}
+ * @see AV1 spec 5.11.51 "Is inside function"
+ */
+export function is_inside(ctx: Av1FrameContext, r: number, c: number): boolean;
+//# sourceMappingURL=block_decoded.d.ts.map

package/src/avif/native/av1/decode/block_decoded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_decoded.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/block_decoded.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,mEALW,MAAM,KACN,MAAM,YACN,MAAM,QA6BhB;AAED;;;;;;GAMG;AACH,mDALW,MAAM,KACN,MAAM,GACJ,OAAO,CAKnB"}

package/src/avif/native/av1/decode/block_decoded.js

@@ -0,0 +1,59 @@
+import { BLOCK_DECODED_ORIGIN, BLOCK_DECODED_STRIDE } from "./Av1FrameContext.js";
+
+/**
+ * Where a superblock's neighbours are, as far as intra prediction is concerned.
+ *
+ * Shared with the encoder: prediction reads these to decide whether the samples above right and
+ * below left have been coded yet, and an encoder that disagreed would predict from something the
+ * decoder cannot.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} sb_size4
+ * @see AV1 spec 5.11.3 "Clear block decoded flags function"
+ */
+export function clear_block_decoded_flags(ctx, r, c, sb_size4) {
+    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 sb_width4 = (ctx.mi_col_end - c) >> sub_x;
+        const sb_height4 = (ctx.mi_row_end - r) >> sub_y;
+
+        const flags = ctx.block_decoded[plane];
+
+        for (let y = -1; y <= (sb_size4 >> sub_y); y++) {
+            for (let x = -1; x <= (sb_size4 >> sub_x); x++) {
+                const index = (y + BLOCK_DECODED_ORIGIN) * BLOCK_DECODED_STRIDE + x + BLOCK_DECODED_ORIGIN;
+
+                if (y < 0 && x < sb_width4) {
+                    flags[index] = 1;
+                } else if (x < 0 && y < sb_height4) {
+                    flags[index] = 1;
+                } else {
+                    flags[index] = 0;
+                }
+            }
+        }
+
+        flags[((sb_size4 >> sub_y) + BLOCK_DECODED_ORIGIN) * BLOCK_DECODED_STRIDE + BLOCK_DECODED_ORIGIN - 1] = 0;
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @returns {boolean}
+ * @see AV1 spec 5.11.51 "Is inside function"
+ */
+export function is_inside(ctx, r, c) {
+    return c >= ctx.mi_col_start && c < ctx.mi_col_end && r >= ctx.mi_row_start && r < ctx.mi_row_end;
+}
+