@woosh/meep-engine 3.14.1 → 3.14.3

package/src/format/image/avif/av1/decode/decode_tile.js

@@ -0,0 +1,1213 @@
+import { clamp } from "../../../../../core/math/clamp.js";
+import {
+    BLOCK_128X128,
+    BLOCK_4X4,
+    BLOCK_64X64,
+    BLOCK_8X8,
+    DC_PRED,
+    DELTA_LF_SMALL,
+    DELTA_Q_SMALL,
+    FRAME_LF_COUNT,
+    MAX_ANGLE_DELTA,
+    MAX_LOOP_FILTER,
+    MI_SIZE,
+    PARTITION_HORZ,
+    PARTITION_HORZ_4,
+    PARTITION_HORZ_A,
+    PARTITION_HORZ_B,
+    PARTITION_NONE,
+    PARTITION_SPLIT,
+    PARTITION_VERT,
+    PARTITION_VERT_4,
+    PARTITION_VERT_A,
+    PARTITION_VERT_B,
+    SEG_LVL_MAX,
+    SEG_LVL_SKIP,
+    TX_4X4,
+    TX_16X32,
+    TX_32X16,
+    TX_32X32,
+    TX_MODE_SELECT,
+    UV_CFL_PRED,
+    V_PRED
+} from "../tables/av1_symbols.js";
+import {
+    MAX_TX_SIZE_RECT,
+    NUM_4X4_BLOCKS_HIGH,
+    NUM_4X4_BLOCKS_WIDE,
+    PARTITION_SUBSIZE,
+    SPLIT_TX_SIZE,
+    SUBSAMPLED_SIZE,
+    TX_HEIGHT,
+    TX_HEIGHT_LOG2,
+    TX_WIDTH,
+    TX_WIDTH_LOG2
+} from "../tables/block_tables.js";
+import { MAX_TX_DEPTH as MAX_TX_DEPTH_TABLE } from "../tables/block_tables.js";
+import { BLOCK_HEIGHT, BLOCK_WIDTH } from "../tables/derived_block_tables.js";
+import { INTRA_MODE_CONTEXT } from "../tables/prediction_tables.js";
+import { partition_cdf, partition_context, probability_of } from "../entropy/partition_cdf.js";
+import { reset_block_context } from "../entropy/coefficient_context.js";
+import { clear_block_decoded_flags, is_inside } from "./block_decoded.js";
+import { SGRPROJ_XQD_MID, WIENER_TAPS_MID } from "../tables/filter_tables.js";
+import { predict_chroma_from_luma } from "../predict/predict_chroma_from_luma.js";
+import { predict_intra, is_directional_mode } from "../predict/predict_intra.js";
+import { get_filter_type } from "../predict/intra_filter_type.js";
+import { predict_palette } from "../predict/predict_palette.js";
+import { BLOCK_DECODED_ORIGIN, BLOCK_DECODED_STRIDE, MAX_PALETTE_SIZE } from "./Av1FrameContext.js";
+import { decode_coefficients } from "./decode_coefficients.js";
+import { read_palette_mode_info, read_palette_tokens } from "./decode_palette.js";
+import { read_lr } from "./read_lr.js";
+import { reconstruct } from "./reconstruct.js";
+
+/**
+ * Decode one tile's worth of superblocks.
+ *
+ * The symbol reader must already be initialised over the tile's payload, and the tile bounds must
+ * be set on the context.
+ *
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.2 "Decode tile syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function decode_tile(ctx) {
+    clear_above_context(ctx);
+
+    ctx.delta_lf.fill(0);
+
+    // loop restoration coefficients are coded as differences from the previous unit's, and the
+    // chain restarts at each tile
+    for (let plane = 0; plane < ctx.num_planes; plane++) {
+        for (let pass = 0; pass < 2; pass++) {
+            ctx.ref_sgr_xqd[plane * 2 + pass] = SGRPROJ_XQD_MID[pass];
+
+            for (let i = 0; i < 3; i++) {
+                ctx.ref_lr_wiener[(plane * 2 + pass) * 3 + i] = WIENER_TAPS_MID[i];
+            }
+        }
+    }
+
+    const use_128 = ctx.sequence.use_128x128_superblock === 1;
+    const sb_size = use_128 ? BLOCK_128X128 : BLOCK_64X64;
+    const sb_size4 = NUM_4X4_BLOCKS_WIDE[sb_size];
+
+    for (let r = ctx.mi_row_start; r < ctx.mi_row_end; r += sb_size4) {
+        clear_left_context(ctx);
+
+        for (let c = ctx.mi_col_start; c < ctx.mi_col_end; c += sb_size4) {
+            ctx.read_deltas = ctx.frame.delta_q_present;
+
+            clear_cdef(ctx, r, c, sb_size4);
+            clear_block_decoded_flags(ctx, r, c, sb_size4);
+
+            read_lr(ctx, r, c, sb_size);
+
+            decode_partition(ctx, r, c, sb_size);
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ */
+function clear_above_context(ctx) {
+    for (let plane = 0; plane < ctx.num_planes; plane++) {
+        ctx.above_level_context[plane].fill(0);
+        ctx.above_dc_context[plane].fill(0);
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ */
+function clear_left_context(ctx) {
+    for (let plane = 0; plane < ctx.num_planes; plane++) {
+        ctx.left_level_context[plane].fill(0);
+        ctx.left_dc_context[plane].fill(0);
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} sb_size4
+ */
+function clear_cdef(ctx, r, c, sb_size4) {
+    const stride = ctx.mi_stride;
+
+    ctx.cdef_idx[r * stride + c] = -1;
+
+    if (sb_size4 === 32) {
+        const half = NUM_4X4_BLOCKS_WIDE[BLOCK_64X64];
+
+        if (c + half < ctx.mi_cols) {
+            ctx.cdef_idx[r * stride + c + half] = -1;
+        }
+
+        if (r + half < ctx.mi_rows) {
+            ctx.cdef_idx[(r + half) * stride + c] = -1;
+
+            if (c + half < ctx.mi_cols) {
+                ctx.cdef_idx[(r + half) * stride + c + half] = -1;
+            }
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} b_size
+ * @see AV1 spec 5.11.4 "Decode partition syntax"
+ */
+function decode_partition(ctx, r, c, b_size) {
+    if (r >= ctx.mi_rows || c >= ctx.mi_cols) {
+        return;
+    }
+
+    const avail_u = is_inside(ctx, r - 1, c) ? 1 : 0;
+    const avail_l = is_inside(ctx, r, c - 1) ? 1 : 0;
+
+    const num4x4 = NUM_4X4_BLOCKS_WIDE[b_size];
+    const half4x4 = num4x4 >> 1;
+    const quarter4x4 = half4x4 >> 1;
+
+    const has_rows = r + half4x4 < ctx.mi_rows;
+    const has_cols = c + half4x4 < ctx.mi_cols;
+
+    let partition;
+
+    if (b_size < BLOCK_8X8) {
+        partition = PARTITION_NONE;
+    } else if (has_rows && has_cols) {
+        partition = read_partition(ctx, r, c, b_size, avail_u, avail_l);
+    } else if (has_cols) {
+        partition = read_split_or_horz(ctx, r, c, b_size, avail_u, avail_l) === 1 ? PARTITION_SPLIT : PARTITION_HORZ;
+    } else if (has_rows) {
+        partition = read_split_or_vert(ctx, r, c, b_size, avail_u, avail_l) === 1 ? PARTITION_SPLIT : PARTITION_VERT;
+    } else {
+        partition = PARTITION_SPLIT;
+    }
+
+    const sub_size = PARTITION_SUBSIZE[partition * 22 + b_size];
+    const split_size = PARTITION_SUBSIZE[PARTITION_SPLIT * 22 + b_size];
+
+    if (partition === PARTITION_NONE) {
+        decode_block(ctx, r, c, sub_size);
+    } else if (partition === PARTITION_HORZ) {
+        decode_block(ctx, r, c, sub_size);
+
+        if (has_rows) {
+            decode_block(ctx, r + half4x4, c, sub_size);
+        }
+    } else if (partition === PARTITION_VERT) {
+        decode_block(ctx, r, c, sub_size);
+
+        if (has_cols) {
+            decode_block(ctx, r, c + half4x4, sub_size);
+        }
+    } else if (partition === PARTITION_SPLIT) {
+        decode_partition(ctx, r, c, sub_size);
+        decode_partition(ctx, r, c + half4x4, sub_size);
+        decode_partition(ctx, r + half4x4, c, sub_size);
+        decode_partition(ctx, r + half4x4, c + half4x4, sub_size);
+    } else if (partition === PARTITION_HORZ_A) {
+        decode_block(ctx, r, c, split_size);
+        decode_block(ctx, r, c + half4x4, split_size);
+        decode_block(ctx, r + half4x4, c, sub_size);
+    } else if (partition === PARTITION_HORZ_B) {
+        decode_block(ctx, r, c, sub_size);
+        decode_block(ctx, r + half4x4, c, split_size);
+        decode_block(ctx, r + half4x4, c + half4x4, split_size);
+    } else if (partition === PARTITION_VERT_A) {
+        decode_block(ctx, r, c, split_size);
+        decode_block(ctx, r + half4x4, c, split_size);
+        decode_block(ctx, r, c + half4x4, sub_size);
+    } else if (partition === PARTITION_VERT_B) {
+        decode_block(ctx, r, c, sub_size);
+        decode_block(ctx, r, c + half4x4, split_size);
+        decode_block(ctx, r + half4x4, c + half4x4, split_size);
+    } else if (partition === PARTITION_HORZ_4) {
+        decode_block(ctx, r, c, sub_size);
+        decode_block(ctx, r + quarter4x4, c, sub_size);
+        decode_block(ctx, r + quarter4x4 * 2, c, sub_size);
+
+        if (r + quarter4x4 * 3 < ctx.mi_rows) {
+            decode_block(ctx, r + quarter4x4 * 3, c, sub_size);
+        }
+    } else {
+        decode_block(ctx, r, c, sub_size);
+        decode_block(ctx, r, c + quarter4x4, sub_size);
+        decode_block(ctx, r, c + quarter4x4 * 2, sub_size);
+
+        if (c + quarter4x4 * 3 < ctx.mi_cols) {
+            decode_block(ctx, r, c + quarter4x4 * 3, sub_size);
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} b_size
+ * @param {number} avail_u
+ * @param {number} avail_l
+ * @returns {number}
+ */
+function read_partition(ctx, r, c, b_size, avail_u, avail_l) {
+    const context = partition_context(ctx, r, c, b_size, avail_u, avail_l);
+    const selected = partition_cdf(ctx, b_size, context);
+
+    return ctx.reader.read_symbol(selected.cdf, selected.offset, selected.symbols);
+}
+
+/**
+ * The two-symbol CDF used when only one of the two split directions is available.
+ * @type {Uint16Array}
+ */
+const BINARY_PARTITION_CDF = new Uint16Array(3);
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} b_size
+ * @param {number} avail_u
+ * @param {number} avail_l
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `split_or_horz`
+ */
+function read_split_or_horz(ctx, r, c, b_size, avail_u, avail_l) {
+    const context = partition_context(ctx, r, c, b_size, avail_u, avail_l);
+    const selected = partition_cdf(ctx, b_size, context);
+
+    const cdf = selected.cdf;
+    const base = selected.offset;
+
+    let psum = probability_of(cdf, base, PARTITION_VERT)
+        + probability_of(cdf, base, PARTITION_SPLIT)
+        + probability_of(cdf, base, PARTITION_HORZ_A)
+        + probability_of(cdf, base, PARTITION_VERT_A)
+        + probability_of(cdf, base, PARTITION_VERT_B);
+
+    if (b_size !== BLOCK_128X128) {
+        psum += probability_of(cdf, base, PARTITION_VERT_4);
+    }
+
+    BINARY_PARTITION_CDF[0] = (1 << 15) - psum;
+    BINARY_PARTITION_CDF[1] = 1 << 15;
+    BINARY_PARTITION_CDF[2] = 0;
+
+    // adaptation is deliberately skipped: the specification builds this CDF fresh from the
+    // partition CDF at every use, so any update would be discarded
+    const saved = ctx.reader.disable_cdf_update;
+
+    ctx.reader.disable_cdf_update = 1;
+
+    const symbol = ctx.reader.read_symbol(BINARY_PARTITION_CDF, 0, 2);
+
+    ctx.reader.disable_cdf_update = saved;
+
+    return symbol;
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} b_size
+ * @param {number} avail_u
+ * @param {number} avail_l
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `split_or_vert`
+ */
+function read_split_or_vert(ctx, r, c, b_size, avail_u, avail_l) {
+    const context = partition_context(ctx, r, c, b_size, avail_u, avail_l);
+    const selected = partition_cdf(ctx, b_size, context);
+
+    const cdf = selected.cdf;
+    const base = selected.offset;
+
+    let psum = probability_of(cdf, base, PARTITION_HORZ)
+        + probability_of(cdf, base, PARTITION_SPLIT)
+        + probability_of(cdf, base, PARTITION_HORZ_A)
+        + probability_of(cdf, base, PARTITION_HORZ_B)
+        + probability_of(cdf, base, PARTITION_VERT_A);
+
+    if (b_size !== BLOCK_128X128) {
+        psum += probability_of(cdf, base, PARTITION_HORZ_4);
+    }
+
+    BINARY_PARTITION_CDF[0] = (1 << 15) - psum;
+    BINARY_PARTITION_CDF[1] = 1 << 15;
+    BINARY_PARTITION_CDF[2] = 0;
+
+    const saved = ctx.reader.disable_cdf_update;
+
+    ctx.reader.disable_cdf_update = 1;
+
+    const symbol = ctx.reader.read_symbol(BINARY_PARTITION_CDF, 0, 2);
+
+    ctx.reader.disable_cdf_update = saved;
+
+    return symbol;
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} r
+ * @param {number} c
+ * @param {number} sub_size
+ * @see AV1 spec 5.11.5 "Decode block syntax"
+ */
+function decode_block(ctx, r, c, sub_size) {
+    ctx.mi_row = r;
+    ctx.mi_col = c;
+    ctx.mi_size = sub_size;
+
+    const bw4 = NUM_4X4_BLOCKS_WIDE[sub_size];
+    const bh4 = NUM_4X4_BLOCKS_HIGH[sub_size];
+
+    if (bh4 === 1 && ctx.subsampling_y === 1 && (r & 1) === 0) {
+        ctx.has_chroma = 0;
+    } else if (bw4 === 1 && ctx.subsampling_x === 1 && (c & 1) === 0) {
+        ctx.has_chroma = 0;
+    } else {
+        ctx.has_chroma = ctx.num_planes > 1 ? 1 : 0;
+    }
+
+    ctx.avail_u = is_inside(ctx, r - 1, c) ? 1 : 0;
+    ctx.avail_l = is_inside(ctx, r, c - 1) ? 1 : 0;
+    ctx.avail_u_chroma = ctx.avail_u;
+    ctx.avail_l_chroma = ctx.avail_l;
+
+    if (ctx.has_chroma === 1) {
+        if (ctx.subsampling_y === 1 && bh4 === 1) {
+            ctx.avail_u_chroma = is_inside(ctx, r - 2, c) ? 1 : 0;
+        }
+
+        if (ctx.subsampling_x === 1 && bw4 === 1) {
+            ctx.avail_l_chroma = is_inside(ctx, r, c - 2) ? 1 : 0;
+        }
+    } else {
+        ctx.avail_u_chroma = 0;
+        ctx.avail_l_chroma = 0;
+    }
+
+    read_intra_frame_mode_info(ctx);
+
+    read_palette_tokens(ctx);
+
+    read_block_tx_size(ctx, bw4, bh4);
+
+    if (ctx.skip === 1) {
+        reset_block_context(ctx, bw4, bh4);
+    }
+
+    const stride = ctx.mi_stride;
+    const mi_count = stride * ctx.mi_rows;
+
+    for (let y = 0; y < bh4; y++) {
+        if (r + y >= ctx.mi_rows) {
+            break;
+        }
+
+        for (let x = 0; x < bw4; x++) {
+            if (c + x >= ctx.mi_cols) {
+                break;
+            }
+
+            const index = (r + y) * stride + c + x;
+
+            ctx.y_modes[index] = ctx.y_mode;
+
+            if (ctx.has_chroma === 1) {
+                ctx.uv_modes[index] = ctx.uv_mode;
+            }
+        }
+    }
+
+    residual(ctx);
+
+    for (let y = 0; y < bh4; y++) {
+        if (r + y >= ctx.mi_rows) {
+            break;
+        }
+
+        for (let x = 0; x < bw4; x++) {
+            if (c + x >= ctx.mi_cols) {
+                break;
+            }
+
+            const index = (r + y) * stride + c + x;
+
+            ctx.is_inters[index] = 0;
+            ctx.skips[index] = ctx.skip;
+            ctx.tx_sizes[index] = ctx.tx_size;
+            ctx.mi_sizes[index] = ctx.mi_size;
+            ctx.segment_ids[index] = ctx.segment_id;
+            ctx.palette_sizes[index] = ctx.palette_size_y;
+            ctx.palette_sizes[mi_count + index] = ctx.palette_size_uv;
+
+            for (let i = 0; i < ctx.palette_size_y; i++) {
+                ctx.palette_colors[index * MAX_PALETTE_SIZE + i] = ctx.palette_colors_y[i];
+            }
+
+            for (let i = 0; i < ctx.palette_size_uv; i++) {
+                ctx.palette_colors[(mi_count + index) * MAX_PALETTE_SIZE + i] = ctx.palette_colors_u[i];
+            }
+
+            for (let i = 0; i < FRAME_LF_COUNT; i++) {
+                ctx.delta_lfs[index * FRAME_LF_COUNT + i] = ctx.delta_lf[i];
+            }
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} feature
+ * @returns {boolean}
+ */
+function seg_feature_active(ctx, feature) {
+    return ctx.frame.segmentation_enabled === 1
+        && ctx.frame.feature_enabled[ctx.segment_id * SEG_LVL_MAX + feature] !== 0;
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.7 "Intra frame mode info syntax"
+ */
+function read_intra_frame_mode_info(ctx) {
+    const reader = ctx.reader;
+    const cdf = ctx.cdf;
+    const frame = ctx.frame;
+
+    ctx.skip = 0;
+
+    if (frame.seg_id_pre_skip === 1) {
+        read_intra_segment_id(ctx);
+    }
+
+    read_skip(ctx);
+
+    if (frame.seg_id_pre_skip === 0) {
+        read_intra_segment_id(ctx);
+    }
+
+    read_cdef(ctx);
+    read_delta_qindex(ctx);
+    read_delta_lf(ctx);
+
+    ctx.read_deltas = 0;
+
+    if (frame.allow_intrabc === 1) {
+        const use_intrabc = reader.read_symbol(cdf.intrabc, 0, 2);
+
+        if (use_intrabc === 1) {
+            throw new Error("intra block copy is not supported by this decoder");
+        }
+    }
+
+    const stride = ctx.mi_stride;
+
+    const above_mode = INTRA_MODE_CONTEXT[ctx.avail_u === 1 ? ctx.y_modes[(ctx.mi_row - 1) * stride + ctx.mi_col] : DC_PRED];
+    const left_mode = INTRA_MODE_CONTEXT[ctx.avail_l === 1 ? ctx.y_modes[ctx.mi_row * stride + ctx.mi_col - 1] : DC_PRED];
+
+    ctx.y_mode = reader.read_symbol(cdf.intra_frame_y_mode, ((above_mode * 5) + left_mode) * 14, 13);
+
+    ctx.angle_delta_y = 0;
+
+    if (ctx.mi_size >= BLOCK_8X8 && is_directional_mode(ctx.y_mode)) {
+        ctx.angle_delta_y = reader.read_symbol(cdf.angle_delta, (ctx.y_mode - V_PRED) * 8, 7) - MAX_ANGLE_DELTA;
+    }
+
+    ctx.uv_mode = DC_PRED;
+    ctx.angle_delta_uv = 0;
+    ctx.cfl_alpha_u = 0;
+    ctx.cfl_alpha_v = 0;
+
+    if (ctx.has_chroma === 1) {
+        const cfl_allowed = ctx.lossless === 1
+            ? plane_residual_size(ctx, ctx.mi_size, 1) === BLOCK_4X4
+            : Math.max(BLOCK_WIDTH[ctx.mi_size], BLOCK_HEIGHT[ctx.mi_size]) <= 32;
+
+        ctx.uv_mode = cfl_allowed
+            ? reader.read_symbol(cdf.uv_mode_cfl_allowed, ctx.y_mode * 15, 14)
+            : reader.read_symbol(cdf.uv_mode_cfl_not_allowed, ctx.y_mode * 14, 13);
+
+        if (ctx.uv_mode === UV_CFL_PRED) {
+            read_cfl_alphas(ctx);
+        }
+
+        if (ctx.mi_size >= BLOCK_8X8 && is_directional_mode(ctx.uv_mode)) {
+            ctx.angle_delta_uv = reader.read_symbol(cdf.angle_delta, (ctx.uv_mode - V_PRED) * 8, 7) - MAX_ANGLE_DELTA;
+        }
+    }
+
+    ctx.palette_size_y = 0;
+    ctx.palette_size_uv = 0;
+
+    if (ctx.mi_size >= BLOCK_8X8
+        && BLOCK_WIDTH[ctx.mi_size] <= 64
+        && BLOCK_HEIGHT[ctx.mi_size] <= 64
+        && frame.allow_screen_content_tools !== 0) {
+        read_palette_mode_info(ctx);
+    }
+
+    read_filter_intra_mode_info(ctx);
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} size
+ * @param {number} plane
+ * @returns {number}
+ */
+function plane_residual_size(ctx, size, plane) {
+    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
+    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
+
+    return SUBSAMPLED_SIZE[(size * 2 + sub_x) * 2 + sub_y];
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.8 "Intra segment ID syntax"
+ */
+function read_intra_segment_id(ctx) {
+    if (ctx.frame.segmentation_enabled === 1) {
+        read_segment_id(ctx);
+    } else {
+        ctx.segment_id = 0;
+    }
+
+    ctx.lossless = ctx.frame.lossless_array[ctx.segment_id];
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.9 "Read segment ID syntax"
+ */
+function read_segment_id(ctx) {
+    const stride = ctx.mi_stride;
+    const row = ctx.mi_row;
+    const col = ctx.mi_col;
+
+    const prev_ul = ctx.avail_u === 1 && ctx.avail_l === 1 ? ctx.segment_ids[(row - 1) * stride + col - 1] : -1;
+    const prev_u = ctx.avail_u === 1 ? ctx.segment_ids[(row - 1) * stride + col] : -1;
+    const prev_l = ctx.avail_l === 1 ? ctx.segment_ids[row * stride + col - 1] : -1;
+
+    let pred;
+
+    if (prev_u === -1) {
+        pred = prev_l === -1 ? 0 : prev_l;
+    } else if (prev_l === -1) {
+        pred = prev_u;
+    } else {
+        pred = prev_ul === prev_u ? prev_u : prev_l;
+    }
+
+    if (ctx.skip === 1) {
+        ctx.segment_id = pred;
+
+        return;
+    }
+
+    let context;
+
+    if (prev_ul < 0) {
+        context = 0;
+    } else if (prev_ul === prev_u && prev_ul === prev_l) {
+        context = 2;
+    } else if (prev_ul === prev_u || prev_ul === prev_l || prev_u === prev_l) {
+        context = 1;
+    } else {
+        context = 0;
+    }
+
+    const diff = ctx.reader.read_symbol(ctx.cdf.segment_id, context * 9, 8);
+
+    ctx.segment_id = neg_deinterleave(diff, pred, ctx.frame.last_active_seg_id + 1);
+}
+
+/**
+ * @param {number} diff
+ * @param {number} ref
+ * @param {number} max
+ * @returns {number}
+ * @see AV1 spec 5.11.9, `neg_deinterleave`
+ */
+function neg_deinterleave(diff, ref, max) {
+    if (ref === 0) {
+        return diff;
+    }
+
+    if (ref >= max - 1) {
+        return max - diff - 1;
+    }
+
+    if (2 * ref < max) {
+        if (diff <= 2 * ref) {
+            return (diff & 1) !== 0 ? ref + ((diff + 1) >> 1) : ref - (diff >> 1);
+        }
+
+        return diff;
+    }
+
+    if (diff <= 2 * (max - ref - 1)) {
+        return (diff & 1) !== 0 ? ref + ((diff + 1) >> 1) : ref - (diff >> 1);
+    }
+
+    return max - (diff + 1);
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.11 "Skip syntax"
+ */
+function read_skip(ctx) {
+    if (ctx.frame.seg_id_pre_skip === 1 && seg_feature_active(ctx, SEG_LVL_SKIP)) {
+        ctx.skip = 1;
+
+        return;
+    }
+
+    const stride = ctx.mi_stride;
+
+    let context = 0;
+
+    if (ctx.avail_u === 1) {
+        context += ctx.skips[(ctx.mi_row - 1) * stride + ctx.mi_col];
+    }
+
+    if (ctx.avail_l === 1) {
+        context += ctx.skips[ctx.mi_row * stride + ctx.mi_col - 1];
+    }
+
+    ctx.skip = ctx.reader.read_symbol(ctx.cdf.skip, context * 3, 2);
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.56 "Read CDEF syntax"
+ */
+function read_cdef(ctx) {
+    const frame = ctx.frame;
+
+    if (ctx.skip === 1 || frame.coded_lossless === 1 || ctx.sequence.enable_cdef === 0 || frame.allow_intrabc === 1) {
+        return;
+    }
+
+    const cdef_size4 = NUM_4X4_BLOCKS_WIDE[BLOCK_64X64];
+    const mask = ~(cdef_size4 - 1);
+
+    const r = ctx.mi_row & mask;
+    const c = ctx.mi_col & mask;
+
+    const stride = ctx.mi_stride;
+
+    if (ctx.cdef_idx[r * stride + c] !== -1) {
+        return;
+    }
+
+    const value = ctx.reader.read_literal(frame.cdef_bits);
+
+    ctx.cdef_idx[r * stride + c] = value;
+
+    const w4 = NUM_4X4_BLOCKS_WIDE[ctx.mi_size];
+    const h4 = NUM_4X4_BLOCKS_HIGH[ctx.mi_size];
+
+    for (let i = r; i < r + h4 && i < ctx.mi_rows; i += cdef_size4) {
+        for (let j = c; j < c + w4 && j < ctx.mi_cols; j += cdef_size4) {
+            ctx.cdef_idx[i * stride + j] = value;
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.12 "Quantizer index delta syntax"
+ */
+function read_delta_qindex(ctx) {
+    const sb_size = ctx.sequence.use_128x128_superblock === 1 ? BLOCK_128X128 : BLOCK_64X64;
+
+    if (ctx.mi_size === sb_size && ctx.skip === 1) {
+        return;
+    }
+
+    if (ctx.read_deltas !== 1) {
+        return;
+    }
+
+    const reader = ctx.reader;
+
+    let delta_q_abs = reader.read_symbol(ctx.cdf.delta_q, 0, 4);
+
+    if (delta_q_abs === DELTA_Q_SMALL) {
+        const rem_bits = reader.read_literal(3) + 1;
+        const abs_bits = reader.read_literal(rem_bits);
+
+        delta_q_abs = abs_bits + (1 << rem_bits) + 1;
+    }
+
+    if (delta_q_abs !== 0) {
+        const sign = reader.read_literal(1);
+        const reduced = sign !== 0 ? -delta_q_abs : delta_q_abs;
+
+        ctx.current_q_index = clamp(ctx.current_q_index + (reduced << ctx.frame.delta_q_res), 1, 255);
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.13 "Loop filter delta syntax"
+ */
+function read_delta_lf(ctx) {
+    const sb_size = ctx.sequence.use_128x128_superblock === 1 ? BLOCK_128X128 : BLOCK_64X64;
+
+    if (ctx.mi_size === sb_size && ctx.skip === 1) {
+        return;
+    }
+
+    if (ctx.read_deltas !== 1 || ctx.frame.delta_lf_present !== 1) {
+        return;
+    }
+
+    const reader = ctx.reader;
+
+    let count = 1;
+
+    if (ctx.frame.delta_lf_multi === 1) {
+        count = ctx.num_planes > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;
+    }
+
+    for (let i = 0; i < count; i++) {
+        const cdf = ctx.frame.delta_lf_multi === 1 ? ctx.cdf.delta_lf_multi : ctx.cdf.delta_lf;
+        const offset = ctx.frame.delta_lf_multi === 1 ? i * 5 : 0;
+
+        let abs_value = reader.read_symbol(cdf, offset, 4);
+
+        if (abs_value === DELTA_LF_SMALL) {
+            const rem_bits = reader.read_literal(3) + 1;
+            const abs_bits = reader.read_literal(rem_bits);
+
+            abs_value = abs_bits + (1 << rem_bits) + 1;
+        }
+
+        if (abs_value !== 0) {
+            const sign = reader.read_literal(1);
+            const reduced = sign !== 0 ? -abs_value : abs_value;
+
+            ctx.delta_lf[i] = clamp(
+                ctx.delta_lf[i] + (reduced << ctx.frame.delta_lf_res),
+                -MAX_LOOP_FILTER,
+                MAX_LOOP_FILTER
+            );
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.45 "Read CFL alphas syntax"
+ */
+function read_cfl_alphas(ctx) {
+    const reader = ctx.reader;
+    const cdf = ctx.cdf;
+
+    const signs = reader.read_symbol(cdf.cfl_sign, 0, 8);
+
+    const sign_u = Math.floor((signs + 1) / 3);
+    const sign_v = (signs + 1) % 3;
+
+    if (sign_u !== 0) {
+        const context = (sign_u - 1) * 3 + sign_v;
+
+        ctx.cfl_alpha_u = 1 + reader.read_symbol(cdf.cfl_alpha, context * 17, 16);
+
+        if (sign_u === 1) {
+            ctx.cfl_alpha_u = -ctx.cfl_alpha_u;
+        }
+    } else {
+        ctx.cfl_alpha_u = 0;
+    }
+
+    if (sign_v !== 0) {
+        const context = (sign_v - 1) * 3 + sign_u;
+
+        ctx.cfl_alpha_v = 1 + reader.read_symbol(cdf.cfl_alpha, context * 17, 16);
+
+        if (sign_v === 1) {
+            ctx.cfl_alpha_v = -ctx.cfl_alpha_v;
+        }
+    } else {
+        ctx.cfl_alpha_v = 0;
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.20 "Filter intra mode info syntax"
+ */
+function read_filter_intra_mode_info(ctx) {
+    ctx.use_filter_intra = 0;
+
+    if (ctx.sequence.enable_filter_intra === 1
+        && ctx.y_mode === DC_PRED
+        && ctx.palette_size_y === 0
+        && Math.max(BLOCK_WIDTH[ctx.mi_size], BLOCK_HEIGHT[ctx.mi_size]) <= 32) {
+        ctx.use_filter_intra = ctx.reader.read_symbol(ctx.cdf.filter_intra, ctx.mi_size * 3, 2);
+
+        if (ctx.use_filter_intra === 1) {
+            ctx.filter_intra_mode = ctx.reader.read_symbol(ctx.cdf.filter_intra_mode, 0, 5);
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} bw4
+ * @param {number} bh4
+ * @see AV1 spec 5.11.15 "Block TX size syntax"
+ */
+function read_block_tx_size(ctx, bw4, bh4) {
+    // the specification's condition is `!skip || !is_inter`; every block here is intra, so the
+    // second term is always true and a skipped block still codes its transform size
+    read_tx_size(ctx, true);
+
+    const stride = ctx.mi_stride;
+
+    for (let row = ctx.mi_row; row < ctx.mi_row + bh4 && row < ctx.mi_rows; row++) {
+        for (let col = ctx.mi_col; col < ctx.mi_col + bw4 && col < ctx.mi_cols; col++) {
+            ctx.inter_tx_sizes[row * stride + col] = ctx.tx_size;
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {boolean} allow_select
+ * @see AV1 spec 5.11.14 "TX size syntax"
+ */
+function read_tx_size(ctx, allow_select) {
+    if (ctx.lossless === 1) {
+        ctx.tx_size = TX_4X4;
+
+        return;
+    }
+
+    const max_rect = MAX_TX_SIZE_RECT[ctx.mi_size];
+    const max_depth = MAX_TX_DEPTH_TABLE[ctx.mi_size];
+
+    ctx.tx_size = max_rect;
+
+    if (ctx.mi_size > BLOCK_4X4 && allow_select && ctx.frame.tx_mode === TX_MODE_SELECT) {
+        const depth = read_tx_depth(ctx, max_rect, max_depth);
+
+        for (let i = 0; i < depth; i++) {
+            ctx.tx_size = SPLIT_TX_SIZE[ctx.tx_size];
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} max_rect
+ * @param {number} max_depth
+ * @returns {number}
+ * @see AV1 spec 8.3.2, `tx_depth`
+ */
+function read_tx_depth(ctx, max_rect, max_depth) {
+    const stride = ctx.mi_stride;
+    const row = ctx.mi_row;
+    const col = ctx.mi_col;
+
+    const max_tx_width = TX_WIDTH[max_rect];
+    const max_tx_height = TX_HEIGHT[max_rect];
+
+    // this decoder has no inter blocks, so the `IsInters` branches of the specification's
+    // derivation are unreachable and the neighbour's own transform size always applies
+    const above_w = ctx.avail_u === 1 ? TX_WIDTH[ctx.inter_tx_sizes[(row - 1) * stride + col]] : 0;
+    const left_h = ctx.avail_l === 1 ? TX_HEIGHT[ctx.inter_tx_sizes[row * stride + col - 1]] : 0;
+
+    const context = (above_w >= max_tx_width ? 1 : 0) + (left_h >= max_tx_height ? 1 : 0);
+
+    if (max_depth === 4) {
+        return ctx.reader.read_symbol(ctx.cdf.tx_64x64, context * 4, 3);
+    }
+
+    if (max_depth === 3) {
+        return ctx.reader.read_symbol(ctx.cdf.tx_32x32, context * 4, 3);
+    }
+
+    if (max_depth === 2) {
+        return ctx.reader.read_symbol(ctx.cdf.tx_16x16, context * 4, 3);
+    }
+
+    return ctx.reader.read_symbol(ctx.cdf.tx_8x8, context * 3, 2);
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} tx_size
+ * @returns {number}
+ * @see AV1 spec 5.11.38 "Get TX size function"
+ */
+function get_tx_size(ctx, plane, tx_size) {
+    if (plane === 0) {
+        return tx_size;
+    }
+
+    const uv_tx = MAX_TX_SIZE_RECT[plane_residual_size(ctx, ctx.mi_size, plane)];
+
+    if (TX_WIDTH[uv_tx] === 64 || TX_HEIGHT[uv_tx] === 64) {
+        if (TX_WIDTH[uv_tx] === 16) {
+            return TX_16X32;
+        }
+
+        if (TX_HEIGHT[uv_tx] === 16) {
+            return TX_32X16;
+        }
+
+        return TX_32X32;
+    }
+
+    return uv_tx;
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.34 "Residual syntax"
+ */
+function residual(ctx) {
+    const width_chunks = Math.max(1, BLOCK_WIDTH[ctx.mi_size] >> 6);
+    const height_chunks = Math.max(1, BLOCK_HEIGHT[ctx.mi_size] >> 6);
+
+    const mi_size_chunk = width_chunks > 1 || height_chunks > 1 ? BLOCK_64X64 : ctx.mi_size;
+
+    for (let chunk_y = 0; chunk_y < height_chunks; chunk_y++) {
+        for (let chunk_x = 0; chunk_x < width_chunks; chunk_x++) {
+            const mi_row_chunk = ctx.mi_row + (chunk_y << 4);
+            const mi_col_chunk = ctx.mi_col + (chunk_x << 4);
+
+            const planes = 1 + ctx.has_chroma * 2;
+
+            for (let plane = 0; plane < planes; plane++) {
+                const tx_size = ctx.lossless === 1 ? TX_4X4 : get_tx_size(ctx, plane, ctx.tx_size);
+
+                const step_x = TX_WIDTH[tx_size] >> 2;
+                const step_y = TX_HEIGHT[tx_size] >> 2;
+
+                const plane_size = plane_residual_size(ctx, mi_size_chunk, plane);
+
+                const num4x4_w = NUM_4X4_BLOCKS_WIDE[plane_size];
+                const num4x4_h = NUM_4X4_BLOCKS_HIGH[plane_size];
+
+                const sub_x = plane > 0 ? ctx.subsampling_x : 0;
+                const sub_y = plane > 0 ? ctx.subsampling_y : 0;
+
+                const base_x_block = (ctx.mi_col >> sub_x) * MI_SIZE;
+                const base_y_block = (ctx.mi_row >> sub_y) * MI_SIZE;
+
+                for (let y = 0; y < num4x4_h; y += step_y) {
+                    for (let x = 0; x < num4x4_w; x += step_x) {
+                        transform_block(
+                            ctx,
+                            plane,
+                            base_x_block,
+                            base_y_block,
+                            tx_size,
+                            x + ((chunk_x << 4) >> sub_x),
+                            y + ((chunk_y << 4) >> sub_y)
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} base_x
+ * @param {number} base_y
+ * @param {number} tx_size
+ * @param {number} x offset within the block, in 4 sample units
+ * @param {number} y offset within the block, in 4 sample units
+ * @see AV1 spec 5.11.35 "Transform block syntax"
+ */
+function transform_block(ctx, plane, base_x, base_y, tx_size, x, y) {
+    const start_x = base_x + 4 * x;
+    const start_y = base_y + 4 * y;
+
+    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
+    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
+
+    const row = (start_y << sub_y) >> 2;
+    const col = (start_x << sub_x) >> 2;
+
+    const sb_mask = ctx.sequence.use_128x128_superblock === 1 ? 31 : 15;
+
+    const sub_block_mi_row = row & sb_mask;
+    const sub_block_mi_col = col & sb_mask;
+
+    const step_x = TX_WIDTH[tx_size] >> 2;
+    const step_y = TX_HEIGHT[tx_size] >> 2;
+
+    const max_x = (ctx.mi_cols * MI_SIZE) >> sub_x;
+    const max_y = (ctx.mi_rows * MI_SIZE) >> sub_y;
+
+    if (start_x >= max_x || start_y >= max_y) {
+        return;
+    }
+
+    const flags = ctx.block_decoded[plane];
+
+    const plane_data = ctx.planes[plane];
+    const stride = ctx.plane_stride[plane];
+
+    if ((plane === 0 && ctx.palette_size_y > 0) || (plane !== 0 && ctx.palette_size_uv > 0)) {
+        predict_palette(
+            plane_data,
+            stride,
+            start_x,
+            start_y,
+            x,
+            y,
+            tx_size,
+            plane === 0 ? ctx.palette_colors_y : (plane === 1 ? ctx.palette_colors_u : ctx.palette_colors_v),
+            plane === 0 ? ctx.color_map_y : ctx.color_map_uv,
+            ctx.color_map_stride
+        );
+    } else {
+        const is_cfl = plane > 0 && ctx.uv_mode === UV_CFL_PRED;
+
+        const mode = plane === 0 ? ctx.y_mode : (is_cfl ? DC_PRED : ctx.uv_mode);
+
+        const intra = ctx.intra;
+
+        intra.bit_depth = ctx.bit_depth;
+        intra.enable_intra_edge_filter = ctx.sequence.enable_intra_edge_filter;
+        intra.angle_delta = plane === 0 ? ctx.angle_delta_y : ctx.angle_delta_uv;
+        intra.use_filter_intra = ctx.use_filter_intra;
+        intra.filter_intra_mode = ctx.filter_intra_mode;
+        intra.filter_type = get_filter_type(ctx, plane);
+
+        const have_left = ((plane === 0 ? ctx.avail_l : ctx.avail_l_chroma) === 1 || x > 0) ? 1 : 0;
+        const have_above = ((plane === 0 ? ctx.avail_u : ctx.avail_u_chroma) === 1 || y > 0) ? 1 : 0;
+
+        const above_right = flags[
+            (((sub_block_mi_row >> sub_y) - 1) + BLOCK_DECODED_ORIGIN) * BLOCK_DECODED_STRIDE
+            + ((sub_block_mi_col >> sub_x) + step_x) + BLOCK_DECODED_ORIGIN
+        ];
+
+        const below_left = flags[
+            (((sub_block_mi_row >> sub_y) + step_y) + BLOCK_DECODED_ORIGIN) * BLOCK_DECODED_STRIDE
+            + ((sub_block_mi_col >> sub_x) - 1) + BLOCK_DECODED_ORIGIN
+        ];
+
+        predict_intra(
+            intra,
+            plane_data,
+            stride,
+            plane,
+            start_x,
+            start_y,
+            max_x - 1,
+            max_y - 1,
+            have_left,
+            have_above,
+            above_right,
+            below_left,
+            mode,
+            TX_WIDTH_LOG2[tx_size],
+            TX_HEIGHT_LOG2[tx_size]
+        );
+
+        if (is_cfl) {
+            predict_chroma_from_luma(
+                plane_data,
+                stride,
+                ctx.planes[0],
+                ctx.plane_stride[0],
+                start_x,
+                start_y,
+                tx_size,
+                plane === 1 ? ctx.cfl_alpha_u : ctx.cfl_alpha_v,
+                ctx.subsampling_x,
+                ctx.subsampling_y,
+                ctx.max_luma_w,
+                ctx.max_luma_h,
+                ctx.bit_depth
+            );
+        }
+    }
+
+    if (plane === 0) {
+        ctx.max_luma_w = start_x + step_x * 4;
+        ctx.max_luma_h = start_y + step_y * 4;
+    }
+
+    let eob = 0;
+
+    if (ctx.skip !== 1) {
+        eob = decode_coefficients(ctx, plane, start_x, start_y, tx_size);
+
+        if (eob > 0) {
+            reconstruct(ctx, plane, start_x, start_y, tx_size);
+        }
+    }
+
+    if (ctx.trace !== null) {
+        // recorded here rather than inside the coefficient decode so that skipped blocks — which
+        // code no coefficients at all — still appear; their absence once made a whole class of
+        // block invisible to the trace
+        ctx.trace.push({
+            plane,
+            x: start_x,
+            y: start_y,
+            tx_size,
+            tx_type: ctx.plane_tx_type,
+            mi_row: ctx.mi_row,
+            mi_col: ctx.mi_col,
+            mi_size: ctx.mi_size,
+            y_mode: ctx.y_mode,
+            uv_mode: ctx.uv_mode,
+            use_filter_intra: ctx.use_filter_intra,
+            filter_intra_mode: ctx.filter_intra_mode,
+            angle_delta_y: ctx.angle_delta_y,
+            palette_size_y: ctx.palette_size_y,
+            skip: ctx.skip,
+            eob
+        });
+    }
+
+    const tx_size_plane = ctx.loop_filter_tx_sizes[plane];
+    const tx_stride = ctx.plane_stride[plane] >> 2;
+
+    for (let i = 0; i < step_y; i++) {
+        for (let j = 0; j < step_x; j++) {
+            const flag_index = (((sub_block_mi_row >> sub_y) + i) + BLOCK_DECODED_ORIGIN) * BLOCK_DECODED_STRIDE
+                + (((sub_block_mi_col >> sub_x) + j) + BLOCK_DECODED_ORIGIN);
+
+            flags[flag_index] = 1;
+
+            const tx_row = (row >> sub_y) + i;
+            const tx_col = (col >> sub_x) + j;
+
+            const tx_index = tx_row * tx_stride + tx_col;
+
+            if (tx_index < tx_size_plane.length) {
+                tx_size_plane[tx_index] = tx_size;
+            }
+        }
+    }
+}