@woosh/meep-engine 3.14.2 → 3.14.4

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

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