@woosh/meep-engine 3.14.2 → 3.14.4

package/src/avif/native/av1/encode/encode_tile.js

@@ -1,2331 +0,0 @@
-import {
-    ADST_ADST,
-    ADST_DCT,
-    BLOCK_128X128,
-    BLOCK_INVALID,
-    BLOCK_16X16,
-    BLOCK_32X32,
-    BLOCK_4X4,
-    BLOCK_64X64,
-    BLOCK_8X8,
-    D113_PRED,
-    D135_PRED,
-    D157_PRED,
-    D203_PRED,
-    D45_PRED,
-    D67_PRED,
-    DC_PRED,
-    DCT_ADST,
-    DCT_DCT,
-    H_PRED,
-    MAX_ANGLE_DELTA,
-    MI_SIZE,
-    PAETH_PRED,
-    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,
-    SMOOTH_H_PRED,
-    SMOOTH_PRED,
-    SMOOTH_V_PRED,
-    TX_4X4,
-    UV_CFL_PRED,
-    TX_SET_DCTONLY,
-    V_PRED
-} from "../tables/av1_symbols.js";
-import {
-    MAX_TX_DEPTH,
-    MAX_TX_SIZE_RECT,
-    NUM_4X4_BLOCKS_HIGH,
-    NUM_4X4_BLOCKS_WIDE,
-    PARTITION_SUBSIZE,
-    PARTITION_SUBSIZE_SHAPE,
-    SPLIT_TX_SIZE,
-    SUBSAMPLED_SIZE,
-    TX_HEIGHT,
-    TX_HEIGHT_LOG2,
-    TX_WIDTH,
-    TX_WIDTH_LOG2
-} from "../tables/block_tables.js";
-import { BLOCK_DECODED_ORIGIN, BLOCK_DECODED_STRIDE } from "../decode/Av1FrameContext.js";
-import { assert } from "../../../../core/assert.js";
-import { capture_block, restore_block } from "./Av1BlockSnapshot.js";
-import {
-    DECISION_SKIP,
-    DECISION_TX_SIZE,
-    DECISION_TX_TYPE,
-    DECISION_UV_MODE,
-    DECISION_Y_MODE
-} from "./Av1EncodeContext.js";
-import { SGRPROJ_XQD_MID, WIENER_TAPS_MID } from "../tables/filter_tables.js";
-import { clear_block_decoded_flags, is_inside } from "../decode/block_decoded.js";
-import { write_lr } from "./write_lr.js";
-import { FORWARD_ADST, FORWARD_DCT, forward_transform_2d, forward_transform_bound, forward_wht_4x4 } from "../transform/forward_transform_2d.js";
-import { INTRA_MODE_CONTEXT } from "../tables/prediction_tables.js";
-import { column_is_dct, row_is_dct } from "../transform/inverse_transform_2d.js";
-import { compute_tx_type, get_tx_set } from "../decode/transform_type.js";
-import { get_filter_type } from "../predict/intra_filter_type.js";
-import { partition_cdf, partition_context, probability_of } from "../entropy/partition_cdf.js";
-import { reset_block_context } from "../entropy/coefficient_context.js";
-import { COST_ONE_BIT, symbol_cost } from "../entropy/symbol_cost.js";
-import { choose_chroma_alpha } from "./choose_chroma_alpha.js";
-import { is_directional_mode, predict_intra } from "../predict/predict_intra.js";
-import { predict_chroma_from_luma } from "../predict/predict_chroma_from_luma.js";
-import { get_scan } from "../decode/get_scan.js";
-import { quantise_transform_block, quantiser_zero_threshold } from "./quantise.js";
-import { reconstruct } from "../decode/reconstruct.js";
-import { write_coefficients } from "./write_coefficients.js";
-
-/**
- * The intra modes the luma decision chooses between: all thirteen the format has.
- *
- * They are affordable now because they are not all priced. Every one is predicted and ranked, which
- * costs a prediction each, and only the best few are transformed and costed — so widening the set
- * buys the oriented edges photographs are full of without paying thirteen full trials for them.
- * @type {number[]}
- */
-const LUMA_CANDIDATES = [
-    DC_PRED,
-    V_PRED,
-    H_PRED,
-    D45_PRED,
-    D135_PRED,
-    D113_PRED,
-    D157_PRED,
-    D203_PRED,
-    D67_PRED,
-    SMOOTH_PRED,
-    SMOOTH_V_PRED,
-    SMOOTH_H_PRED,
-    PAETH_PRED
-];
-
-/**
- * The modes the chroma decision chooses between.
- *
- * Narrower than luma's on purpose: subsampled chroma is smooth, its transform blocks are a quarter
- * the area, and the directional modes almost never win there — while every candidate costs two
- * predictions, one per chroma plane.
- * @type {number[]}
- */
-const CHROMA_CANDIDATES = [DC_PRED, V_PRED, H_PRED, SMOOTH_PRED, PAETH_PRED, UV_CFL_PRED];
-
-/**
- * The smallest block this encoder partitions down to.
- *
- * Four by four, which is the smallest the format has. A block this size does not own its chroma —
- * the format gives one chroma block to each 8x8 of luma, and `begin_block` works out which of the
- * four owns it — and codes no partition symbol, because there is nothing left to divide.
- * @type {number}
- */
-const MIN_BLOCK = BLOCK_4X4;
-
-/**
- * The largest.
- *
- * Not the superblock: a 64x64 block's transform codes only its top left 32x32 coefficients and
- * discards the rest, which is a low pass filter rather than a coding decision.
- * @type {number}
- */
-const MAX_BLOCK = BLOCK_32X32;
-
-/**
- * Row stride of {@link PARTITION_SUBSIZE}, which is indexed by partition and then by block size.
- * @type {number}
- */
-const PARTITION_SUBSIZE_STRIDE = PARTITION_SUBSIZE_SHAPE[1];
-
-/**
- * Squared error in the coefficient domain, per unit of squared error in samples.
- *
- * The specification's inverse transform is orthonormal up to a scale, and the scale is the same
- * sixty-fourth for every size and every type this encoder emits — the sizes whose dequantiser
- * divides by two or four included, because that division happens before the transform. Measured
- * rather than derived, and it is what lets a trial price what a candidate loses without running an
- * inverse transform to find out.
- * @type {number}
- */
-const COEFFICIENT_ENERGY_PER_SAMPLE = 64;
-
-/**
- * Encode one tile — which, for a still image, is the whole picture.
- *
- * Each superblock is coded twice. The first pass searches: it prices both answers to every
- * partition decision by *making* each of them — predicting, quantising, reconstructing, advancing
- * the contexts — against a writer that emits nothing, and puts the state back between them. The
- * second pass writes the tree the first settled on.
- *
- * It has to be that way round. A partition symbol comes before everything under it in the stream,
- * and choosing which one to write means knowing what the whole subtree would cost. What makes the
- * two passes agree is that the second starts from exactly the state the first did, and replays the
- * decisions the first recorded, so it reproduces the winning path sample for sample.
- *
- * Searching a superblock at a time rather than the whole tile keeps the probabilities honest: the
- * CDFs a search prices against are the ones the previous superblock left behind, which is within a
- * superblock of the ones its own symbols will meet.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} replay `0` to search and write, `1` to write again from what the search recorded
- * @see AV1 spec 5.11.2 "Decode tile syntax", of which this is the mirror
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function encode_tile(ec, replay) {
-    const ctx = ec.frame_context;
-
-    clear_above_context(ctx);
-    clear_restoration_reference(ctx);
-
-    ctx.delta_lf.fill(0);
-
-    const sb_size = 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 = 0;
-
-            clear_block_decoded_flags(ctx, r, c, sb_size4);
-
-            ctx.cdef_idx[r * ctx.mi_stride + c] = -1;
-
-            if (replay === 0) {
-                capture_block(ctx, ec.snapshots[0], r, c, sb_size);
-
-                search_partition(ec, r, c, sb_size, 0);
-
-                record_decisions(ec, r, c, sb_size);
-                restore_block(ctx, ec.snapshots[0], r, c, sb_size);
-            } else {
-                // only the second pass has anything to say here: the filter these carry was fitted
-                // to the picture the first pass produced
-                write_lr(ec, ctx.writer, r, c, sb_size);
-            }
-
-            write_partition_tree(ec, r, c, sb_size, 0);
-        }
-    }
-}
-
-/**
- * Restoration parameters are coded as differences from the unit before, and a tile starts from the
- * middle of each parameter's range rather than from whatever the tile before it left.
- *
- * @param {Av1FrameContext} ctx
- */
-function clear_restoration_reference(ctx) {
-    for (let plane = 0; plane < 3; 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];
-            }
-        }
-    }
-}
-
-/**
- * Copy what the search settled on out of the frame context, before the search is undone.
- *
- * Five fields per 4x4 position: the two prediction modes, the skip flag, and the transform's type
- * and size. Everything else the writing pass needs it works out again from these.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- */
-function record_decisions(ec, r, c, b_size) {
-    const ctx = ec.frame_context;
-
-    const stride = ctx.mi_stride;
-
-    const rows = Math.min(NUM_4X4_BLOCKS_HIGH[b_size], ctx.mi_rows - r);
-    const columns = Math.min(NUM_4X4_BLOCKS_WIDE[b_size], ctx.mi_cols - c);
-
-    const decisions = ec.decisions;
-    const field = ec.decision_stride;
-
-    for (let y = 0; y < rows; y++) {
-        const row = (r + y) * stride + c;
-
-        for (let x = 0; x < columns; x++) {
-            const at = row + x;
-
-            decisions[DECISION_Y_MODE * field + at] = ctx.y_modes[at];
-            decisions[DECISION_UV_MODE * field + at] = ctx.uv_modes[at];
-            decisions[DECISION_SKIP * field + at] = ctx.skips[at];
-            decisions[DECISION_TX_TYPE * field + at] = ctx.tx_types[at];
-            decisions[DECISION_TX_SIZE * field + at] = ctx.inter_tx_sizes[at];
-        }
-    }
-}
-
-/**
- * @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);
-    }
-}
-
-/**
- * Search a partition: price coding the block whole against coding it as four, and leave the state
- * the winner produced.
- *
- * Only two of the ten partitions are considered — none, and a split into four. The rest exist to
- * fit rectangular detail, and each one added is another whole subtree to price.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @param {number} depth how deep below the superblock this node is, which picks its snapshots
- * @returns {number} squared error plus lambda times rate, for this node and everything under it
- */
-function search_partition(ec, r, c, b_size, depth) {
-    const ctx = ec.frame_context;
-
-    if (r >= ctx.mi_rows || c >= ctx.mi_cols) {
-        return 0;
-    }
-
-    const num4x4 = NUM_4X4_BLOCKS_WIDE[b_size];
-    const half4x4 = num4x4 >> 1;
-
-    const has_rows = r + half4x4 < ctx.mi_rows;
-    const has_cols = c + half4x4 < ctx.mi_cols;
-
-    // a superblock is always split: its transform would be 64x64, which codes only a quarter of
-    // its coefficients and throws the rest away. So is a block hanging off the edge of the picture,
-    // because the format codes no partition there that would keep it whole
-    const must_split = b_size > MAX_BLOCK || !has_rows || !has_cols;
-
-    const recorded = depth * ec.decision_stride + r * ctx.mi_stride + c;
-
-    if (b_size <= MIN_BLOCK) {
-        ec.partitions[recorded] = PARTITION_NONE;
-
-        return partition_rate(ec, r, c, b_size, PARTITION_NONE, has_rows, has_cols)
-            + search_block(ec, r, c, b_size);
-    }
-
-    if (must_split) {
-        ec.partitions[recorded] = PARTITION_SPLIT;
-
-        return partition_rate(ec, r, c, b_size, PARTITION_SPLIT, has_rows, has_cols)
-            + search_children(ec, r, c, b_size, depth, Infinity);
-    }
-
-    const before = ec.snapshots[depth * 2 - 1];
-    const winner = ec.snapshots[depth * 2];
-
-    capture_block(ctx, before, r, c, b_size);
-
-    let best = partition_rate(ec, r, c, b_size, PARTITION_NONE, has_rows, has_cols)
-        + search_block(ec, r, c, b_size);
-
-    let chosen = PARTITION_NONE;
-
-    // four quarters cost a partition symbol and four sets of mode info before they code anything,
-    // so a block already costing less than that cannot be improved by splitting it — and the whole
-    // subtree underneath goes unsearched
-    if (best <= ec.lambda * COST_ONE_BIT * ec.split_floor) {
-        ec.partitions[recorded] = PARTITION_NONE;
-
-        return best;
-    }
-
-    // keeping what an answer produced is cheaper than making it again if it turns out to have won
-    capture_block(ctx, winner, r, c, b_size);
-    restore_block(ctx, before, r, c, b_size);
-
-    const split_overhead = partition_rate(ec, r, c, b_size, PARTITION_SPLIT, has_rows, has_cols);
-
-    const split = split_overhead + search_children(ec, r, c, b_size, depth, best - split_overhead);
-
-    if (split < best) {
-        best = split;
-        chosen = PARTITION_SPLIT;
-
-        capture_block(ctx, winner, r, c, b_size);
-    }
-
-    // An uneven cut is the answer between a whole and a quarter, so it is worth asking about exactly
-    // when those two are close. When one of them wins outright the picture has already said whether
-    // the detail here is worth another partition symbol, and more subtrees will not change its mind
-    // — while each of them costs as much again as the unsplit answer did, or half as much more.
-    const uneven = Math.min(ec.uneven_partitions, UNEVEN_PARTITIONS.length);
-
-    if (Math.max(split, best) < Math.min(split, best) * ec.rectangle_margin) {
-        for (let i = 0; i < uneven; i++) {
-            const partition = UNEVEN_PARTITIONS[i];
-
-            // only the two halves have a symbol at 8x8
-            if (i >= 2 && b_size < RECTANGLE_MIN_BLOCK) {
-                break;
-            }
-
-            if (!partition_is_available(ctx, b_size, partition)) {
-                continue;
-            }
-
-            restore_block(ctx, before, r, c, b_size);
-
-            const overhead = partition_rate(ec, r, c, b_size, partition, has_rows, has_cols);
-
-            const cost = overhead + search_layout(ec, r, c, b_size, partition, best - overhead);
-
-            if (cost < best) {
-                best = cost;
-                chosen = partition;
-
-                capture_block(ctx, winner, r, c, b_size);
-            }
-        }
-    }
-
-    restore_block(ctx, winner, r, c, b_size);
-
-    ec.partitions[recorded] = chosen;
-
-    return best;
-}
-
-/**
- * Where the blocks of each partition go, and which of the two sizes each is.
- *
- * Three numbers per block: how far down and how far right its corner sits, as quarters of the
- * node's side — multiplied by the side and shifted, never divided, because a quarter of an 8x8 is
- * half a mode-info unit and an integer quarter would be none of one — and whether it takes the
- * partition's own sub-size or the size a plain split would have given. The specification lays these out as ten branches of one switch; a table is the same
- * thing with the arithmetic factored out, and it means the encoder walks a partition the same way
- * whichever one it is.
- *
- * `PARTITION_SPLIT` is absent because it is not a leaf: it recurses.
- * @type {Int32Array[]}
- */
-const PARTITION_LAYOUT = build_partition_layouts();
-
-/**
- * @returns {Int32Array[]}
- */
-function build_partition_layouts() {
-    const layouts = new Array(10).fill(null);
-
-    layouts[PARTITION_NONE] = new Int32Array([0, 0, 0]);
-    layouts[PARTITION_HORZ] = new Int32Array([0, 0, 0, 2, 0, 0]);
-    layouts[PARTITION_VERT] = new Int32Array([0, 0, 0, 0, 2, 0]);
-
-    layouts[PARTITION_HORZ_A] = new Int32Array([0, 0, 1, 0, 2, 1, 2, 0, 0]);
-    layouts[PARTITION_HORZ_B] = new Int32Array([0, 0, 0, 2, 0, 1, 2, 2, 1]);
-    layouts[PARTITION_VERT_A] = new Int32Array([0, 0, 1, 2, 0, 1, 0, 2, 0]);
-    layouts[PARTITION_VERT_B] = new Int32Array([0, 0, 0, 0, 2, 1, 2, 2, 1]);
-
-    layouts[PARTITION_HORZ_4] = new Int32Array([0, 0, 0, 1, 0, 0, 2, 0, 0, 3, 0, 0]);
-    layouts[PARTITION_VERT_4] = new Int32Array([0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 3, 0]);
-
-    return layouts;
-}
-
-/**
- * The partitions that cut a block unevenly, in the order they are worth asking about.
- *
- * The two halves first, because they are where most of the gain is and each is two blocks rather
- * than three. Then the four T-shapes, which fit a block with detail in one corner. Then the two
- * quarterings, which fit a band.
- * @type {number[]}
- */
-const UNEVEN_PARTITIONS = [
-    PARTITION_HORZ,
-    PARTITION_VERT,
-    PARTITION_HORZ_A,
-    PARTITION_HORZ_B,
-    PARTITION_VERT_A,
-    PARTITION_VERT_B,
-    PARTITION_HORZ_4,
-    PARTITION_VERT_4
-];
-
-/**
- * The smallest block the T-shapes and the quarterings are offered for.
- *
- * The format codes only four partitions at 8x8 — none, the two halves, and the quartering — so
- * there is no symbol for the rest of them there. The halves are available all the way down.
- * @type {number}
- */
-const RECTANGLE_MIN_BLOCK = BLOCK_16X16;
-
-/**
- * Whether every block a partition lays down is one this encoder can code.
- *
- * What stops it is a size the format has no chroma block for at all: an 8x16 block at 4:2:2 would
- * want a 4x16 chroma block, and the specification's table of subsampled sizes says there is no such
- * thing — so a vertical halving is out at that subsampling, and asking for one produces a stream no
- * decoder can read.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} b_size
- * @param {number} partition
- * @returns {boolean}
- * @see AV1 spec, `Subsampled_Size`
- */
-function partition_is_available(ctx, b_size, partition) {
-    const sub_size = PARTITION_SUBSIZE[partition * PARTITION_SUBSIZE_STRIDE + b_size];
-
-    if (sub_size === BLOCK_INVALID || !owns_chroma(ctx, sub_size)) {
-        return false;
-    }
-
-    const layout = PARTITION_LAYOUT[partition];
-
-    const split_size = PARTITION_SUBSIZE[PARTITION_SPLIT * PARTITION_SUBSIZE_STRIDE + b_size];
-
-    for (let i = 0; i < layout.length; i += 3) {
-        if (layout[i + 2] === 1 && (split_size === BLOCK_INVALID || !owns_chroma(ctx, split_size))) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} b_size
- * @returns {boolean}
- */
-function owns_chroma(ctx, b_size) {
-    if (ctx.num_planes === 1) {
-        return true;
-    }
-
-    return SUBSAMPLED_SIZE[(b_size * 2 + ctx.subsampling_x) * 2 + ctx.subsampling_y] !== BLOCK_INVALID;
-}
-
-/**
- * Search one uneven partition's blocks, giving up as soon as they cost more than the best so far.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @param {number} partition
- * @param {number} budget cost above which this partition has already lost
- * @returns {number}
- */
-function search_layout(ec, r, c, b_size, partition, budget) {
-    const ctx = ec.frame_context;
-
-    const num4x4 = NUM_4X4_BLOCKS_WIDE[b_size];
-
-    const sub_size = PARTITION_SUBSIZE[partition * PARTITION_SUBSIZE_STRIDE + b_size];
-    const split_size = PARTITION_SUBSIZE[PARTITION_SPLIT * PARTITION_SUBSIZE_STRIDE + b_size];
-
-    const layout = PARTITION_LAYOUT[partition];
-
-    let total = 0;
-
-    for (let i = 0; i < layout.length; i += 3) {
-        const row = r + ((layout[i] * num4x4) >> 2);
-        const column = c + ((layout[i + 1] * num4x4) >> 2);
-
-        if (row >= ctx.mi_rows || column >= ctx.mi_cols) {
-            continue;
-        }
-
-        total += search_block(ec, row, column, layout[i + 2] === 1 ? split_size : sub_size);
-
-        if (total >= budget) {
-            return Infinity;
-        }
-    }
-
-    return total;
-}
-
-/**
- * Search the four quarters of a block, giving up as soon as they cost more than the whole did.
- *
- * The quarters' costs only ever add up, so once the running total passes what keeping the block
- * whole cost, no amount of searching the rest can bring it back under. Abandoning there is not an
- * approximation — the answer is the same one, reached without paying for it — and on flat content
- * it stops after the first quarter.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @param {number} depth
- * @param {number} budget cost above which the split has already lost
- * @returns {number} the split's cost, or infinity if it passed the budget on the way
- */
-function search_children(ec, r, c, b_size, depth, budget) {
-    const half4x4 = NUM_4X4_BLOCKS_WIDE[b_size] >> 1;
-    const sub_size = SPLIT_SIZE[b_size];
-
-    let total = search_partition(ec, r, c, sub_size, depth + 1);
-
-    if (total >= budget) {
-        return Infinity;
-    }
-
-    total += search_partition(ec, r, c + half4x4, sub_size, depth + 1);
-
-    if (total >= budget) {
-        return Infinity;
-    }
-
-    total += search_partition(ec, r + half4x4, c, sub_size, depth + 1);
-
-    if (total >= budget) {
-        return Infinity;
-    }
-
-    return total + search_partition(ec, r + half4x4, c + half4x4, sub_size, depth + 1);
-}
-
-/**
- * Write the partition tree the search settled on, and the blocks under it.
- *
- * The tree is read back out of what the search recorded, one partition per node. Deriving it from
- * the block sizes it left behind would very nearly work and would be wrong in one case: a node cut
- * into a T and a node quartered whose first quarter was then left whole put the same size in the
- * same corner, and the two are different partitions.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @param {number} depth how deep below the superblock this node is, which is how the search
- *   recorded what it chose
- */
-function write_partition_tree(ec, r, c, b_size, depth) {
-    const ctx = ec.frame_context;
-
-    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 has_rows = r + half4x4 < ctx.mi_rows;
-    const has_cols = c + half4x4 < ctx.mi_cols;
-
-    const partition = ec.partitions[depth * ec.decision_stride + r * ctx.mi_stride + c];
-
-    if (b_size < BLOCK_8X8) {
-        write_block(ec, r, c, b_size);
-
-        return;
-    }
-
-    if (has_rows && has_cols) {
-        write_partition(ec, ctx.writer, r, c, b_size, partition, avail_u, avail_l);
-    } else if (has_cols) {
-        write_split_or_horz(ec, ctx.writer, r, c, b_size, avail_u, avail_l);
-    } else if (has_rows) {
-        write_split_or_vert(ec, ctx.writer, r, c, b_size, avail_u, avail_l);
-    }
-
-    if (partition === PARTITION_SPLIT) {
-        const sub_size = SPLIT_SIZE[b_size];
-
-        write_partition_tree(ec, r, c, sub_size, depth + 1);
-        write_partition_tree(ec, r, c + half4x4, sub_size, depth + 1);
-        write_partition_tree(ec, r + half4x4, c, sub_size, depth + 1);
-        write_partition_tree(ec, r + half4x4, c + half4x4, sub_size, depth + 1);
-
-        return;
-    }
-
-    const sub_size = PARTITION_SUBSIZE[partition * PARTITION_SUBSIZE_STRIDE + b_size];
-    const split_size = PARTITION_SUBSIZE[PARTITION_SPLIT * PARTITION_SUBSIZE_STRIDE + b_size];
-
-    const layout = PARTITION_LAYOUT[partition];
-
-    for (let i = 0; i < layout.length; i += 3) {
-        const row = r + ((layout[i] * num4x4) >> 2);
-        const column = c + ((layout[i + 1] * num4x4) >> 2);
-
-        if (row >= ctx.mi_rows || column >= ctx.mi_cols) {
-            continue;
-        }
-
-        write_block(ec, row, column, layout[i + 2] === 1 ? split_size : sub_size);
-    }
-}
-
-/**
- * What the partition symbol at a node would cost, priced against the CDFs it will be written with.
- *
- * Routed through the same three cases the writer takes, with the cost writer standing in for it, so
- * that a decision cannot be priced against a symbol the writer would not emit.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @param {number} partition
- * @param {boolean} has_rows
- * @param {boolean} has_cols
- * @returns {number} lambda times the rate, so that it adds to a squared error
- */
-function partition_rate(ec, r, c, b_size, partition, has_rows, has_cols) {
-    const ctx = ec.frame_context;
-
-    // a block below 8x8 is already the smallest the format divides into, so nothing is coded to say
-    // it was not divided further
-    if (b_size < BLOCK_8X8) {
-        return 0;
-    }
-
-    const avail_u = is_inside(ctx, r - 1, c) ? 1 : 0;
-    const avail_l = is_inside(ctx, r, c - 1) ? 1 : 0;
-
-    const writer = ec.partition_cost_writer;
-
-    writer.reset_costing();
-
-    if (has_rows && has_cols) {
-        write_partition(ec, writer, r, c, b_size, partition, avail_u, avail_l);
-    } else if (has_cols) {
-        write_split_or_horz(ec, writer, r, c, b_size, avail_u, avail_l);
-    } else if (has_rows) {
-        write_split_or_vert(ec, writer, r, c, b_size, avail_u, avail_l);
-    }
-
-    return ec.lambda * writer.cost;
-}
-
-/**
- * The square block half the size, by block size. Only the sizes this encoder produces are filled
- * in; anything else is a bug rather than a case to handle.
- * @type {Int32Array}
- */
-const SPLIT_SIZE = build_split_sizes();
-
-/**
- * @returns {Int32Array}
- */
-function build_split_sizes() {
-    const table = new Int32Array(BLOCK_128X128 + 1).fill(-1);
-
-    table[BLOCK_64X64] = BLOCK_32X32;
-    table[BLOCK_32X32] = BLOCK_16X16;
-    table[BLOCK_16X16] = BLOCK_8X8;
-    table[BLOCK_8X8] = BLOCK_4X4;
-
-    return table;
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @param {number} partition
- * @param {number} avail_u
- * @param {number} avail_l
- */
-function write_partition(ec, writer, r, c, b_size, partition, avail_u, avail_l) {
-    const ctx = ec.frame_context;
-
-    const context = partition_context(ctx, r, c, b_size, avail_u, avail_l);
-    const selected = partition_cdf(ctx, b_size, context);
-
-    writer.write_symbol(partition, selected.cdf, selected.offset, selected.symbols);
-}
-
-/**
- * Write the one-bit decision the decoder reads when the block runs off the bottom of the picture.
- *
- * The CDF is built from the partition CDF at every use and never adapts, which the writer has to
- * respect too — an update here would be an update the decoder does not make.
- *
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @param {number} avail_u
- * @param {number} avail_l
- */
-function write_split_or_horz(ec, writer, r, c, b_size, avail_u, avail_l) {
-    const ctx = ec.frame_context;
-
-    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);
-    }
-
-    write_binary(writer, psum);
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @param {number} avail_u
- * @param {number} avail_l
- */
-function write_split_or_vert(ec, writer, r, c, b_size, avail_u, avail_l) {
-    const ctx = ec.frame_context;
-
-    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);
-    }
-
-    write_binary(writer, psum);
-}
-
-/**
- * The two-entry CDF the edge decisions are coded with.
- * @type {Uint16Array}
- */
-const BINARY_PARTITION_CDF = new Uint16Array(3);
-
-/**
- * @param {SymbolWriter} writer
- * @param {number} psum probability mass of the partitions that count as a split
- */
-function write_binary(writer, psum) {
-    BINARY_PARTITION_CDF[0] = (1 << 15) - psum;
-    BINARY_PARTITION_CDF[1] = 1 << 15;
-    BINARY_PARTITION_CDF[2] = 0;
-
-    const saved = writer.disable_cdf_update;
-
-    writer.disable_cdf_update = 1;
-
-    writer.write_symbol(1, BINARY_PARTITION_CDF, 0, 2);
-
-    writer.disable_cdf_update = saved;
-}
-
-/**
- * Choose everything about one block and code it against the cost writer, so that the partition
- * decision above it has a price to compare.
- *
- * The block really is coded: the contexts advance, the reconstruction lands in the plane, the mode
- * info is recorded. That is what the block after it has to predict and derive contexts from, and
- * pricing a decision against a state that will not exist is pricing the wrong decision. Undoing it
- * is the snapshot's job.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- * @returns {number} squared error plus lambda times rate
- */
-function search_block(ec, r, c, b_size) {
-    const ctx = ec.frame_context;
-
-    begin_block(ec, r, c, b_size);
-
-    ctx.y_mode = choose_luma_mode(ec);
-
-    choose_transform_depth(ec);
-
-    choose_luma_transform(ec);
-
-    if (ctx.has_chroma === 1) {
-        materialise_plane(ec, 0);
-
-        ctx.uv_mode = choose_chroma_mode(ec);
-    } else {
-        ctx.uv_mode = DC_PRED;
-    }
-
-    // nothing was coded, so nothing has to be: coding the block as skipped saves the per-plane
-    // "this transform block is empty" symbols, and says the same thing
-    ctx.skip = block_is_empty(ec) ? 1 : 0;
-
-    const writer = ec.block_cost_writer;
-
-    writer.reset_costing();
-
-    code_block(ec, writer, STAGE_CODE);
-
-    return ec.block_distortion + ec.lambda * writer.cost;
-}
-
-/**
- * Code one block for real, from the decisions the search recorded.
- *
- * The levels are worked out again rather than kept: the state here is the state the search was in
- * when it made them, so the same prediction, the same transform and the same quantiser produce the
- * same numbers, and a superblock's worth of levels does not have to be carried between the passes.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- */
-function write_block(ec, r, c, b_size) {
-    const ctx = ec.frame_context;
-
-    begin_block(ec, r, c, b_size);
-
-    const decisions = ec.decisions;
-
-    const field = ec.decision_stride;
-    const decided = r * ctx.mi_stride + c;
-
-    ctx.y_mode = decisions[DECISION_Y_MODE * field + decided];
-    ctx.uv_mode = ctx.has_chroma === 1 ? decisions[DECISION_UV_MODE * field + decided] : DC_PRED;
-    ctx.skip = decisions[DECISION_SKIP * field + decided];
-
-    ec.luma_tx_type = decisions[DECISION_TX_TYPE * field + decided];
-
-    ctx.tx_size = ctx.lossless === 1 ? TX_4X4 : decisions[DECISION_TX_SIZE * field + decided];
-
-    // the scalings go in the bitstream before the luma residual they are fitted to, so the luma has
-    // to be made before the block is written, and fitted against again. It is the same fit: the
-    // state it reads is the state the search read
-    if (ctx.uv_mode === UV_CFL_PRED) {
-        materialise_plane(ec, 0);
-
-        prepare_chroma_from_luma(
-            ec,
-            (ctx.mi_col >> ctx.subsampling_x) * MI_SIZE,
-            (ctx.mi_row >> ctx.subsampling_y) * MI_SIZE,
-            transform_size(ctx, 1)
-        );
-    }
-
-    code_block(ec, ctx.writer, STAGE_CODE);
-}
-
-/**
- * Emit a block's mode info and residual, and record what it leaves behind.
- *
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer
- * @param {number} stage always {@link STAGE_CODE}; the writer says whether this is the search
- */
-function code_block(ec, writer, stage) {
-    const ctx = ec.frame_context;
-
-    const r = ctx.mi_row;
-    const c = ctx.mi_col;
-
-    const bw4 = NUM_4X4_BLOCKS_WIDE[ctx.mi_size];
-    const bh4 = NUM_4X4_BLOCKS_HIGH[ctx.mi_size];
-
-    write_block_mode_info(ec, writer);
-
-    mark_cdef(ec, writer);
-
-    write_transform_size(ec, writer);
-
-    if (ctx.skip === 1) {
-        reset_block_context(ctx, bw4, bh4);
-    }
-
-    const stride = ctx.mi_stride;
-
-    for (let y = 0; y < bh4 && r + y < ctx.mi_rows; y++) {
-        for (let x = 0; x < bw4 && c + x < ctx.mi_cols; x++) {
-            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;
-            }
-        }
-    }
-
-    const planes = 1 + ctx.has_chroma * 2;
-
-    ec.block_distortion = 0;
-
-    for (let plane = 0; plane < planes; plane++) {
-        ec.block_distortion += code_plane(ec, plane, writer, stage);
-    }
-
-    for (let y = 0; y < bh4 && r + y < ctx.mi_rows; y++) {
-        for (let x = 0; x < bw4 && c + x < ctx.mi_cols; x++) {
-            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.inter_tx_sizes[index] = ctx.tx_size;
-            ctx.mi_sizes[index] = ctx.mi_size;
-            ctx.segment_ids[index] = 0;
-            ctx.palette_sizes[index] = 0;
-
-            // the transform the search chose, kept where the write pass can find it.
-            // `write_coefficients` records the same thing when the block codes any coefficients,
-            // and records a plain DCT when it codes none — which is what the decoder does, and
-            // would lose the choice for a block whose luma quantised to nothing while its chroma
-            // did not. Nothing in this encoder reads the plane back for coding
-            if (ctx.skip !== 1) {
-                ctx.tx_types[index] = ec.luma_tx_type;
-            }
-        }
-    }
-}
-
-/**
- * Record that a superblock is one the directional filter will visit.
- *
- * The decoder reads an index here — zero bits wide, because there is one strength for the frame —
- * and only for a block that is not skipped, so a superblock every one of whose blocks was skipped
- * is left alone by the filter. `choose_filters` measures strengths against the frame the filter
- * would actually produce, so the encoder has to reach the same conclusion about which superblocks
- * those are.
- *
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer, which says whether this is the writing pass
- * @see AV1 spec 5.11.56 "Read CDEF syntax", of which this is the mirror
- */
-function mark_cdef(ec, writer) {
-    const ctx = ec.frame_context;
-
-    if (writer !== ctx.writer || ctx.skip === 1 || ec.sequence.enable_cdef === 0) {
-        return;
-    }
-
-    const cdef_size4 = NUM_4X4_BLOCKS_WIDE[BLOCK_64X64];
-    const mask = ~(cdef_size4 - 1);
-
-    ctx.cdef_idx[(ctx.mi_row & mask) * ctx.mi_stride + (ctx.mi_col & mask)] = 0;
-}
-
-/**
- * Point the context's per-block registers at a block, ahead of any decision about it.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} r
- * @param {number} c
- * @param {number} b_size
- */
-function begin_block(ec, r, c, b_size) {
-    const ctx = ec.frame_context;
-
-    ctx.mi_row = r;
-    ctx.mi_col = c;
-    ctx.mi_size = b_size;
-
-    const bw4 = NUM_4X4_BLOCKS_WIDE[b_size];
-    const bh4 = NUM_4X4_BLOCKS_HIGH[b_size];
-
-    // a block four samples high or wide in a subsampled direction does not carry chroma of its own:
-    // the format gives one chroma block to each pair, and the second of the pair codes it for both
-    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) {
-        // and where it does carry chroma for a pair, the chroma above and to the left of *that* is
-        // a block further away than the one above and to the left of this
-        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;
-    }
-
-    ctx.skip = 0;
-    ctx.segment_id = 0;
-    ctx.palette_size_y = 0;
-    ctx.palette_size_uv = 0;
-    ctx.use_filter_intra = 0;
-    ctx.filter_intra_mode = 0;
-    ctx.angle_delta_y = 0;
-    ctx.angle_delta_uv = 0;
-    ctx.cfl_alpha_u = 0;
-    ctx.cfl_alpha_v = 0;
-
-    ctx.tx_size = ctx.lossless === 1 ? TX_4X4 : MAX_TX_SIZE_RECT[b_size];
-
-    // the mode search runs before the transform search and has to run against something; a plain
-    // DCT is the one type every transform size allows
-    ec.luma_tx_type = DCT_DCT;
-}
-
-/**
- * Whether every plane of the block quantised to nothing.
- *
- * @param {Av1EncodeContext} ec
- * @returns {boolean}
- */
-function block_is_empty(ec) {
-    const ctx = ec.frame_context;
-
-    const planes = 1 + ctx.has_chroma * 2;
-
-    for (let plane = 0; plane < planes; plane++) {
-        if (ec.chosen_empty[plane] === 0) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Write the block's skip flag and prediction modes, in the order the decoder reads them.
- *
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer
- */
-function write_block_mode_info(ec, writer) {
-    const ctx = ec.frame_context;
-
-    const cdf = ctx.cdf;
-
-    write_skip(ec, writer);
-
-    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];
-
-    writer.write_symbol(ctx.y_mode, cdf.intra_frame_y_mode, ((above_mode * 5) + left_mode) * 14, 13);
-
-    // a directional mode carries a fine angle adjustment; this encoder always chooses the nominal
-    // angle, but the symbol is not optional — the decoder reads it either way
-    if (ctx.mi_size >= BLOCK_8X8 && is_directional_mode(ctx.y_mode)) {
-        writer.write_symbol(MAX_ANGLE_DELTA, cdf.angle_delta, (ctx.y_mode - V_PRED) * 8, 7);
-    }
-
-    if (ctx.has_chroma === 1) {
-        if (cfl_is_allowed(ctx)) {
-            writer.write_symbol(ctx.uv_mode, cdf.uv_mode_cfl_allowed, ctx.y_mode * 15, 14);
-        } else {
-            writer.write_symbol(ctx.uv_mode, cdf.uv_mode_cfl_not_allowed, ctx.y_mode * 14, 13);
-        }
-
-        if (ctx.uv_mode === UV_CFL_PRED) {
-            write_chroma_alphas(ec, writer);
-        }
-
-        if (ctx.mi_size >= BLOCK_8X8 && is_directional_mode(ctx.uv_mode)) {
-            writer.write_symbol(MAX_ANGLE_DELTA, cdf.angle_delta, (ctx.uv_mode - V_PRED) * 8, 7);
-        }
-    }
-}
-
-/**
- * Write the two chroma-from-luma scalings, as a joint sign and then a magnitude each.
- *
- * The joint symbol has eight values and not nine: both scalings zero is not codable, because a
- * chroma-from-luma block that borrows nothing from the luma is a flat block, which the format
- * already has a mode for. `choose_chroma_mode` never offers one.
- *
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer
- * @see AV1 spec 5.11.45 "Read CFL alphas syntax", of which this is the mirror
- */
-function write_chroma_alphas(ec, writer) {
-    const ctx = ec.frame_context;
-
-    const sign_u = sign_of(ctx.cfl_alpha_u);
-    const sign_v = sign_of(ctx.cfl_alpha_v);
-
-    writer.write_symbol(sign_u * 3 + sign_v - 1, ctx.cdf.cfl_sign, 0, 8);
-
-    if (sign_u !== 0) {
-        const context = (sign_u - 1) * 3 + sign_v;
-
-        writer.write_symbol(Math.abs(ctx.cfl_alpha_u) - 1, ctx.cdf.cfl_alpha, context * 17, 16);
-    }
-
-    if (sign_v !== 0) {
-        const context = (sign_v - 1) * 3 + sign_u;
-
-        writer.write_symbol(Math.abs(ctx.cfl_alpha_v) - 1, ctx.cdf.cfl_alpha, context * 17, 16);
-    }
-}
-
-/**
- * @param {number} alpha
- * @returns {number} `0` for none, `1` for negative, `2` for positive, as the joint symbol counts them
- */
-function sign_of(alpha) {
-    if (alpha === 0) {
-        return 0;
-    }
-
-    return alpha < 0 ? 1 : 2;
-}
-
-/**
- * Write the block's transform size, as the number of times the largest one is halved.
- *
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer
- * @see AV1 spec 5.11.15 "Block tx size syntax", of which this is the mirror
- */
-function write_transform_size(ec, writer) {
-    const ctx = ec.frame_context;
-
-    const stride = ctx.mi_stride;
-
-    if (ctx.lossless !== 1 && ctx.mi_size > BLOCK_4X4) {
-        const max_rect = MAX_TX_SIZE_RECT[ctx.mi_size];
-
-        let depth = 0;
-
-        for (let size = max_rect; size !== ctx.tx_size; size = SPLIT_TX_SIZE[size]) {
-            depth++;
-        }
-
-        writer.write_symbol(depth, depth_cdf(ec), depth_offset(ec), depth_symbols(ec));
-    }
-
-    for (let row = ctx.mi_row; row < ctx.mi_row + NUM_4X4_BLOCKS_HIGH[ctx.mi_size] && row < ctx.mi_rows; row++) {
-        for (let col = ctx.mi_col; col < ctx.mi_col + NUM_4X4_BLOCKS_WIDE[ctx.mi_size] && col < ctx.mi_cols; col++) {
-            ctx.inter_tx_sizes[row * stride + col] = ctx.tx_size;
-        }
-    }
-}
-
-/**
- * The context a transform depth is coded against: whether the neighbours' transforms are at least
- * as large as the largest this block could use.
- *
- * @param {Av1EncodeContext} ec
- * @returns {number}
- * @see AV1 spec 8.3.2, `tx_depth`
- */
-function depth_context(ec) {
-    const ctx = ec.frame_context;
-
-    const stride = ctx.mi_stride;
-
-    const max_rect = MAX_TX_SIZE_RECT[ctx.mi_size];
-
-    const above_w = ctx.avail_u === 1 ? TX_WIDTH[ctx.inter_tx_sizes[(ctx.mi_row - 1) * stride + ctx.mi_col]] : 0;
-    const left_h = ctx.avail_l === 1 ? TX_HEIGHT[ctx.inter_tx_sizes[ctx.mi_row * stride + ctx.mi_col - 1]] : 0;
-
-    return (above_w >= TX_WIDTH[max_rect] ? 1 : 0) + (left_h >= TX_HEIGHT[max_rect] ? 1 : 0);
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @returns {Uint16Array}
- */
-function depth_cdf(ec) {
-    const cdf = ec.frame_context.cdf;
-
-    const depth = MAX_TX_DEPTH[ec.frame_context.mi_size];
-
-    if (depth === 4) {
-        return cdf.tx_64x64;
-    }
-
-    if (depth === 3) {
-        return cdf.tx_32x32;
-    }
-
-    return depth === 2 ? cdf.tx_16x16 : cdf.tx_8x8;
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @returns {number}
- */
-function depth_offset(ec) {
-    const depth = MAX_TX_DEPTH[ec.frame_context.mi_size];
-
-    return depth_context(ec) * (depth === 1 ? 3 : 4);
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @returns {number}
- */
-function depth_symbols(ec) {
-    return MAX_TX_DEPTH[ec.frame_context.mi_size] === 1 ? 2 : 3;
-}
-
-/**
- * What the block's transform depth symbol would cost.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} depth
- * @returns {number} cost in `COST_ONE_BIT` units
- */
-function transform_depth_cost(ec, depth) {
-    if (ec.frame_context.lossless === 1 || ec.frame_context.mi_size <= BLOCK_4X4) {
-        return 0;
-    }
-
-    return symbol_cost(depth_cdf(ec), depth_offset(ec), depth, depth_symbols(ec));
-}
-
-/**
- * Choose how finely the block's luma is cut into transforms.
- *
- * A transform spanning detail it cannot fit spends coefficients describing the mismatch; four
- * transforms that each fit spend fewer, and cost one symbol saying so. Only luma is asked — chroma's
- * transform follows from the block's subsampled size and is not coded.
- *
- * Searched after the mode and before the transform type, on the same argument as the type: the mode
- * that predicts best at the largest transform is the mode that predicts best at any of them.
- *
- * @param {Av1EncodeContext} ec
- */
-function choose_transform_depth(ec) {
-    const ctx = ec.frame_context;
-
-    const max_rect = MAX_TX_SIZE_RECT[ctx.mi_size];
-
-    ctx.tx_size = max_rect;
-
-    if (ctx.lossless === 1 || ctx.mi_size <= BLOCK_4X4) {
-        return;
-    }
-
-    const depths = Math.min(ec.transform_depths, MAX_TX_DEPTH[ctx.mi_size] + 1);
-
-    let best = max_rect;
-    let best_cost = ec.chosen_plane_cost + ec.lambda * transform_depth_cost(ec, 0);
-
-    let size = max_rect;
-
-    for (let depth = 1; depth < depths; depth++) {
-        size = SPLIT_TX_SIZE[size];
-
-        ctx.tx_size = size;
-
-        const cost = trial_plane(ec, 0) + ec.lambda * transform_depth_cost(ec, depth);
-
-        if (cost < best_cost) {
-            best_cost = cost;
-            best = size;
-
-            ec.chosen_empty[0] = ec.trial_empty;
-        }
-    }
-
-    ctx.tx_size = best;
-
-    // the transform search picks up from here, and it starts from what the winning depth cost
-    ec.chosen_plane_cost = best_cost - ec.lambda * transform_depth_cost(ec, depth_of(ctx, best));
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @param {number} tx_size
- * @returns {number} how many halvings from the largest transform the block allows
- */
-function depth_of(ctx, tx_size) {
-    let depth = 0;
-
-    for (let size = MAX_TX_SIZE_RECT[ctx.mi_size]; size !== tx_size; size = SPLIT_TX_SIZE[size]) {
-        depth++;
-    }
-
-    return depth;
-}
-
-/**
- * What the block's luma mode symbols would cost, which is part of what choosing one costs.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} mode
- * @returns {number} cost in `COST_ONE_BIT` units
- */
-function luma_mode_cost(ec, mode) {
-    const ctx = ec.frame_context;
-
-    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];
-
-    let cost = symbol_cost(ctx.cdf.intra_frame_y_mode, ((above_mode * 5) + left_mode) * 14, mode, 13);
-
-    if (ctx.mi_size >= BLOCK_8X8 && is_directional_mode(mode)) {
-        cost += symbol_cost(ctx.cdf.angle_delta, (mode - V_PRED) * 8, MAX_ANGLE_DELTA, 7);
-    }
-
-    return cost;
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @param {number} mode
- * @returns {number} cost in `COST_ONE_BIT` units
- */
-function chroma_mode_cost(ec, mode) {
-    const ctx = ec.frame_context;
-
-    let cost = cfl_is_allowed(ctx)
-        ? symbol_cost(ctx.cdf.uv_mode_cfl_allowed, ctx.y_mode * 15, mode, 14)
-        : symbol_cost(ctx.cdf.uv_mode_cfl_not_allowed, ctx.y_mode * 14, mode, 13);
-
-    if (mode === UV_CFL_PRED) {
-        const sign_u = sign_of(ctx.cfl_alpha_u);
-        const sign_v = sign_of(ctx.cfl_alpha_v);
-
-        cost += symbol_cost(ctx.cdf.cfl_sign, 0, sign_u * 3 + sign_v - 1, 8);
-
-        if (sign_u !== 0) {
-            cost += symbol_cost(ctx.cdf.cfl_alpha, ((sign_u - 1) * 3 + sign_v) * 17, Math.abs(ctx.cfl_alpha_u) - 1, 16);
-        }
-
-        if (sign_v !== 0) {
-            cost += symbol_cost(ctx.cdf.cfl_alpha, ((sign_v - 1) * 3 + sign_u) * 17, Math.abs(ctx.cfl_alpha_v) - 1, 16);
-        }
-    }
-
-    if (ctx.mi_size >= BLOCK_8X8 && is_directional_mode(mode)) {
-        cost += symbol_cost(ctx.cdf.angle_delta, (mode - V_PRED) * 8, MAX_ANGLE_DELTA, 7);
-    }
-
-    return cost;
-}
-
-/**
- * Choose the block's luma mode by what it costs and what it loses.
- *
- * Every candidate is predicted and ranked by how far its prediction lands from the source, and only
- * the best few are then transformed, quantised and priced. The ranking is one prediction each; the
- * pricing is a transform, a quantisation, a run through the coefficient syntax and an inverse
- * transform, and the mode that wins on rate and distortion is almost always among the two or three
- * that predicted best.
- *
- * @param {Av1EncodeContext} ec
- * @returns {number}
- */
-function choose_luma_mode(ec) {
-    const ctx = ec.frame_context;
-
-    const count = rank_modes(ec, 0, LUMA_CANDIDATES);
-
-    const trials = Math.min(Math.max(ec.mode_trials, 1), count);
-
-    let best = ec.mode_order[0];
-    let best_cost = Infinity;
-
-    for (let i = 0; i < trials; i++) {
-        const mode = ec.mode_order[i];
-
-        ctx.y_mode = mode;
-
-        const plane_cost = trial_plane(ec, 0);
-
-        const cost = plane_cost + ec.lambda * luma_mode_cost(ec, mode);
-
-        if (cost < best_cost) {
-            best_cost = cost;
-            best = mode;
-
-            // the transform search picks up from here, and the mode symbol is the same price
-            // whatever transform follows it, so what it needs is the plane on its own
-            ec.chosen_plane_cost = plane_cost;
-
-            ec.chosen_empty[0] = ec.trial_empty;
-        }
-    }
-
-    return best;
-}
-
-/**
- * Choose the block's chroma mode, which both chroma planes share and so is priced across both.
- *
- * @param {Av1EncodeContext} ec
- * @returns {number}
- */
-function choose_chroma_mode(ec) {
-    const ctx = ec.frame_context;
-
-    const tx_size = transform_size(ctx, 1);
-
-    const start_x = (ctx.mi_col >> ctx.subsampling_x) * MI_SIZE;
-    const start_y = (ctx.mi_row >> ctx.subsampling_y) * MI_SIZE;
-
-    const count = rank_modes(ec, 1, CHROMA_CANDIDATES);
-
-    const trials = Math.min(Math.max(ec.mode_trials, 1), count);
-
-    let best = ec.mode_order[0];
-    let best_cost = Infinity;
-
-    for (let i = 0; i < trials; i++) {
-        const mode = ec.mode_order[i];
-
-        ctx.uv_mode = mode;
-
-        if (mode === UV_CFL_PRED) {
-            prepare_chroma_from_luma(ec, start_x, start_y, tx_size);
-        }
-
-        const cost = trial_plane(ec, 1) + trial_plane(ec, 2) + ec.lambda * chroma_mode_cost(ec, mode);
-
-        if (cost < best_cost) {
-            best_cost = cost;
-            best = mode;
-
-            ec.chosen_empty[1] = ec.trial_empty_u;
-            ec.chosen_empty[2] = ec.trial_empty;
-        }
-    }
-
-    ctx.uv_mode = best;
-
-    // the winner may not have been the last thing tried, and the scalings the block is written with
-    // have to be the ones it was chosen with
-    if (best === UV_CFL_PRED) {
-        prepare_chroma_from_luma(ec, start_x, start_y, tx_size);
-    }
-
-    return best;
-}
-
-/**
- * Fit both chroma planes' scalings against the luma reconstruction under them.
- *
- * The fit needs the flat prediction to measure against, so the planes are predicted with a scaling
- * of nothing first — which is what a flat prediction is — and then fitted. Deterministic given the
- * block's state, so the search and the writing pass reach the same two numbers without one having
- * to tell the other.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} start_x left edge of the chroma transform block
- * @param {number} start_y
- * @param {number} tx_size
- * @returns {boolean} whether the format can express what was fitted
- */
-function prepare_chroma_from_luma(ec, start_x, start_y, tx_size) {
-    const ctx = ec.frame_context;
-
-    ctx.cfl_alpha_u = 0;
-    ctx.cfl_alpha_v = 0;
-
-    predict_transform_block(ec, 1, start_x, start_y, tx_size, 0, 0);
-    predict_transform_block(ec, 2, start_x, start_y, tx_size, 0, 0);
-
-    ctx.cfl_alpha_u = choose_chroma_alpha(ec, 1, start_x, start_y, tx_size);
-    ctx.cfl_alpha_v = choose_chroma_alpha(ec, 2, start_x, start_y, tx_size);
-
-    return ctx.cfl_alpha_u !== 0 || ctx.cfl_alpha_v !== 0;
-}
-
-/**
- * Code a plane without writing anything, so that what comes after it can see its reconstruction.
- *
- * Chroma-from-luma needs the luma the decoder will have, and the format puts the scalings in the
- * bitstream *before* the luma residual that produces it — so the encoder has to make the luma first
- * and write it second. This is the making.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} plane
- */
-function materialise_plane(ec, plane) {
-    ec.materialising = 1;
-
-    code_plane(ec, plane, ec.cost_writer.reset_costing(), STAGE_TRIAL);
-
-    ec.materialising = 0;
-}
-
-/**
- * Predict a plane with every candidate mode and order them by how close the prediction landed.
- *
- * Ranked on the first transform block only, which for every block this encoder emits outside the
- * lossless path is the whole plane.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} plane the plane to rank on; `1` ranks both chroma planes together
- * @param {number[]} candidates
- * @returns {number} how many entries of `ec.mode_order` were filled
- */
-function rank_modes(ec, plane, candidates) {
-    const ctx = ec.frame_context;
-
-    const order = ec.mode_order;
-    const errors = ec.mode_error;
-
-    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
-    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
-
-    const tx_size = transform_size(ctx, plane);
-
-    // the mode info position is subsampled and *then* scaled, never the other way round: a block at
-    // an odd mode-info column shares its chroma with the block beside it, and the pair's chroma
-    // starts at the even one. Scaling first puts it half a chroma block to the right, off the end
-    // of the row and into the start of the next
-    const start_x = (ctx.mi_col >> sub_x) * MI_SIZE;
-    const start_y = (ctx.mi_row >> sub_y) * MI_SIZE;
-
-    let filled = 0;
-
-    for (let i = 0; i < candidates.length; i++) {
-        const mode = candidates[i];
-
-        if (mode === UV_CFL_PRED && !cfl_is_allowed(ctx)) {
-            continue;
-        }
-
-        if (plane === 0) {
-            ctx.y_mode = mode;
-        } else {
-            ctx.uv_mode = mode;
-        }
-
-        if (mode === UV_CFL_PRED && !prepare_chroma_from_luma(ec, start_x, start_y, tx_size)) {
-            // nothing of the luma's shape is worth borrowing, and the format cannot say so: a
-            // chroma-from-luma block scaling the luma by nothing is a flat block, which has its own
-            // mode already
-            continue;
-        }
-
-        predict_transform_block(ec, plane, start_x, start_y, tx_size, 0, 0);
-
-        let error = transform_block_error(ec, plane, start_x, start_y, tx_size);
-
-        if (plane === 1) {
-            predict_transform_block(ec, 2, start_x, start_y, tx_size, 0, 0);
-
-            error += transform_block_error(ec, 2, start_x, start_y, tx_size);
-        }
-
-        let at = filled;
-
-        while (at > 0 && errors[at - 1] > error) {
-            errors[at] = errors[at - 1];
-            order[at] = order[at - 1];
-            at--;
-        }
-
-        errors[at] = error;
-        order[at] = mode;
-
-        filled++;
-    }
-
-    return filled;
-}
-
-/**
- * A candidate being priced: nothing is recorded, nothing is written, and every mark the trial makes
- * is taken back.
- * @type {number}
- */
-const STAGE_TRIAL = 0;
-
-/**
- * The block being made: the contexts, the reconstruction and the mode info all advance, because the
- * block after this one has to see them, and the symbols go wherever the writer sends them — to the
- * bitstream on the writing pass, and to a running total on the searching one.
- * @type {number}
- */
-const STAGE_CODE = 1;
-
-/**
- * Code one plane of the current block, either to price it or to make it.
- *
- * One function rather than two near-copies, because they differ only in what they leave behind —
- * and a copy that drifted from the other would be an encoder whose decisions were made about a
- * block it did not then write.
- *
- * ### Why a trial does not reconstruct
- *
- * What a trial needs from a candidate is what it costs and what it loses. The cost comes from the
- * coefficient syntax; the loss the quantiser caused is a number the quantiser already had, in the
- * coefficient domain, and the specification's inverse transform carries a fixed sixty-fourth of
- * that energy into samples. So the trial reads the loss off the quantiser instead of running an
- * inverse transform and subtracting a thousand samples to find it again — which was, before this,
- * a fifth of the encoder's running time.
- *
- * It reconstructs anyway when a plane holds more than one transform block, because then each of
- * them predicts from the one before and a prediction from an unreconstructed block is not the
- * prediction the decoder will make.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} plane
- * @param {SymbolWriter} writer
- * @param {number} stage {@link STAGE_TRIAL} or {@link STAGE_CODE}
- * @returns {number} squared error in samples, which is zero at the writing pass because nothing
- *   downstream of it reads one
- */
-function code_plane(ec, plane, writer, stage) {
-    const ctx = ec.frame_context;
-
-    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
-    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
-
-    const tx_size = transform_size(ctx, plane);
-
-    const step_x = TX_WIDTH[tx_size] >> 2;
-    const step_y = TX_HEIGHT[tx_size] >> 2;
-
-    const size = SUBSAMPLED_SIZE[(ctx.mi_size * 2 + sub_x) * 2 + sub_y];
-
-    const num4x4_w = NUM_4X4_BLOCKS_WIDE[size];
-    const num4x4_h = NUM_4X4_BLOCKS_HIGH[size];
-
-    const base_x = (ctx.mi_col >> sub_x) * MI_SIZE;
-    const base_y = (ctx.mi_row >> sub_y) * MI_SIZE;
-
-    const max_x = (ctx.mi_cols * MI_SIZE) >> sub_x;
-    const max_y = (ctx.mi_rows * MI_SIZE) >> sub_y;
-
-    const trial = stage === STAGE_TRIAL ? 1 : 0;
-
-    // a trial has not decided the skip flag yet, and the block it is pricing is by definition one
-    // that codes its coefficients
-    const skip = trial === 0 && ctx.skip === 1;
-
-    // the writing pass is downstream of every decision, so what it costs in error is a number
-    // nothing will read. Everything else — a candidate being priced, and a block being made so that
-    // the partition above it has a price — is measured
-    const measure = writer !== ctx.writer ? 1 : 0;
-
-    const one_block = step_x >= num4x4_w && step_y >= num4x4_h;
-
-    const levels = ec.levels[plane];
-
-    const levels_step = TX_WIDTH[tx_size] * TX_HEIGHT[tx_size];
-
-    let distortion = 0;
-    let offset = 0;
-    let empty = 1;
-
-    for (let y = 0; y < num4x4_h; y += step_y) {
-        for (let x = 0; x < num4x4_w; x += step_x) {
-            const start_x = base_x + 4 * x;
-            const start_y = base_y + 4 * y;
-
-            if (start_x >= max_x || start_y >= max_y) {
-                continue;
-            }
-
-            predict_transform_block(ec, plane, start_x, start_y, tx_size, x, y);
-
-            let eob = 0;
-            let tx_type = DCT_DCT;
-
-            if (skip) {
-                if (measure === 1) {
-                    distortion += transform_block_error(ec, plane, start_x, start_y, tx_size);
-                }
-            } else {
-                tx_type = transform_type_of(ec, plane, tx_size);
-
-                const energy = take_residual(ec, plane, start_x, start_y, tx_size);
-
-                const scan = get_scan(tx_size, tx_type);
-
-                // no coefficient of this residual can reach the quantiser's first step, so every
-                // one of them is going to be zero and the transform that would have proved it one
-                // multiply at a time is not run. The error is then the whole residual, which is
-                // what its energy already says
-                if (survives_quantiser(ec, plane, tx_size, tx_type, energy)) {
-                    forward_transform(ec, tx_size, tx_type);
-
-                    eob = quantise_transform_block(ec, plane, tx_size, tx_type, ec.residual, levels, offset, scan);
-                } else {
-                    levels.fill(0, offset, offset + levels_step);
-
-                    ec.quantised_error = energy * COEFFICIENT_ENERGY_PER_SAMPLE;
-                }
-
-                // a candidate is priced on what the quantiser says it lost, which costs nothing;
-                // a block being *made* is priced on what it actually left, which costs a subtraction
-                // over a reconstruction it had to build anyway. The two are within half a percent of
-                // each other on a mode decision and eight per cent apart on a partition one, which
-                // is what decides where each is used
-                const cheap = trial === 1 && ec.exact_trial_distortion === 0 && ec.materialising === 0;
-
-                if (measure === 1 && cheap) {
-                    distortion += ec.quantised_error / COEFFICIENT_ENERGY_PER_SAMPLE;
-                }
-
-                write_coefficients(ctx, writer, 1 - trial, plane, start_x, start_y, tx_size, tx_type, levels, offset, eob);
-
-                if (eob > 0) {
-                    empty = 0;
-                }
-
-                if (eob > 0 && (!cheap || !one_block)) {
-                    reconstruct(ctx, plane, start_x, start_y, tx_size);
-                }
-
-                if (measure === 1 && !cheap) {
-                    distortion += transform_block_error(ec, plane, start_x, start_y, tx_size);
-                }
-            }
-
-            if (plane === 0) {
-                ctx.max_luma_w = start_x + TX_WIDTH[tx_size];
-                ctx.max_luma_h = start_y + TX_HEIGHT[tx_size];
-            }
-
-            if (writer === ctx.writer && ctx.trace !== null) {
-                // the same record the decoder writes, so that a desync can be found by walking the
-                // two traces together until they disagree — which is the only practical way to
-                // debug an arithmetic coder that has already gone wrong
-                ctx.trace.push({
-                    plane,
-                    x: start_x,
-                    y: start_y,
-                    tx_size,
-                    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: 0,
-                    filter_intra_mode: 0,
-                    angle_delta_y: 0,
-                    palette_size_y: 0,
-                    skip: ctx.skip,
-                    eob
-                });
-            }
-
-            mark_decoded(ctx, plane, start_x, start_y, tx_size, 1);
-
-            offset += levels_step;
-        }
-    }
-
-    if (trial === 1) {
-        // the marks a trial made are taken back, so that the next candidate starts where this one
-        // did. They had to be made: within a block, each transform block predicts from the last
-        for (let y = 0; y < num4x4_h; y += step_y) {
-            for (let x = 0; x < num4x4_w; x += step_x) {
-                const start_x = base_x + 4 * x;
-                const start_y = base_y + 4 * y;
-
-                if (start_x >= max_x || start_y >= max_y) {
-                    continue;
-                }
-
-                mark_decoded(ctx, plane, start_x, start_y, tx_size, 0);
-            }
-        }
-
-        // chroma is priced two planes at a time and the second call would overwrite the first's
-        // answer, so the U plane parks its result where the chroma decision can still find it
-        if (plane === 1) {
-            ec.trial_empty_u = empty;
-        }
-
-        ec.trial_empty = empty;
-    }
-
-    return distortion;
-}
-
-/**
- * Price one candidate for one plane, leaving nothing behind.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} plane
- * @returns {number} the Lagrangian cost of the plane: squared error plus lambda times rate
- */
-function trial_plane(ec, plane) {
-    const writer = ec.cost_writer;
-
-    writer.reset_costing();
-
-    const distortion = code_plane(ec, plane, writer, STAGE_TRIAL);
-
-    return distortion + ec.lambda * writer.cost;
-}
-
-/**
- * Whether any coefficient of the residual now in `ec.residual` can survive the quantiser.
- *
- * The bound is Cauchy-Schwarz on the transform matrix and is therefore a fact rather than a guess:
- * a `false` here is a block that would have quantised to nothing, and skipping the transform for it
- * changes what the encoder does by not one bit.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} plane
- * @param {number} tx_size
- * @param {number} tx_type
- * @param {number} energy sum of the residual's squares
- * @returns {boolean}
- */
-function survives_quantiser(ec, plane, tx_size, tx_type, energy) {
-    if (ec.frame_context.lossless === 1) {
-        return true;
-    }
-
-    const bound = forward_transform_bound(
-        tx_size,
-        row_is_dct(tx_type) ? FORWARD_DCT : FORWARD_ADST,
-        column_is_dct(tx_type) ? FORWARD_DCT : FORWARD_ADST
-    );
-
-    return bound * Math.sqrt(energy) >= quantiser_zero_threshold(ec, plane, tx_size);
-}
-
-/**
- * Fill `ec.residual` with the difference between the source and the prediction now in the plane.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} plane
- * @param {number} start_x
- * @param {number} start_y
- * @param {number} tx_size
- * @returns {number} the sum of the residual's squares, which is both what the block would cost if
- *   nothing of it were coded and what decides whether anything can be
- */
-function take_residual(ec, plane, start_x, start_y, tx_size) {
-    const ctx = ec.frame_context;
-
-    const width = TX_WIDTH[tx_size];
-    const height = TX_HEIGHT[tx_size];
-
-    const residual = ec.residual;
-
-    const reconstruction = ctx.planes[plane];
-    const reconstruction_stride = ctx.plane_stride[plane];
-
-    const source = ec.source[plane];
-    const source_stride = ec.source_stride[plane];
-
-    let energy = 0;
-
-    for (let i = 0; i < height; i++) {
-        const a = (start_y + i) * reconstruction_stride + start_x;
-        const b = (start_y + i) * source_stride + start_x;
-
-        for (let j = 0; j < width; j++) {
-            const difference = source[b + j] - reconstruction[a + j];
-
-            residual[i * width + j] = difference;
-
-            energy += difference * difference;
-        }
-    }
-
-    return energy;
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @param {number} tx_size
- * @param {number} tx_type
- */
-function forward_transform(ec, tx_size, tx_type) {
-    if (ec.frame_context.lossless === 1) {
-        forward_wht_4x4(ec.residual, ec.scratch);
-
-        return;
-    }
-
-    forward_transform_2d(
-        ec.residual,
-        tx_size,
-        row_is_dct(tx_type) ? FORWARD_DCT : FORWARD_ADST,
-        column_is_dct(tx_type) ? FORWARD_DCT : FORWARD_ADST
-    );
-}
-
-/**
- * The transform type a plane's transform block is coded with.
- *
- * Luma writes whichever type the search settled on. Chroma codes no type at all — it inherits one
- * from the chroma prediction mode, and the decoder derives exactly this.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} plane
- * @param {number} tx_size
- * @returns {number}
- */
-function transform_type_of(ec, plane, tx_size) {
-    if (plane === 0) {
-        return ec.luma_tx_type;
-    }
-
-    return compute_tx_type(ec.frame_context, 1, tx_size, 0, 0);
-}
-
-/**
- * The types the intra sets hold that are a transform in each direction, less the plain DCT the mode
- * search has already priced.
- *
- * Both sets also hold the identity — coding a residual untransformed, which suits the hard edges of
- * a screenshot and almost never a photograph — and set one holds two more that are an identity in
- * one direction. `forward_transform_2d` builds its matrices by inverting the specification's
- * inverse transform, and there is no matrix to invert for an identity, so those three are out of
- * reach and are not searched. Everything here is in both sets.
- * @type {number[]}
- */
-const TRANSFORM_CANDIDATES = [ADST_DCT, DCT_ADST, ADST_ADST];
-
-/**
- * Choose the transform the block's luma residual is coded with.
- *
- * Searched after the prediction mode rather than alongside it: the two interact, but pricing every
- * pairing is four times the work for a fraction of the gain, and the mode that wins under a plain
- * DCT is very nearly always the mode that wins under the best transform for it.
- *
- * A residual left by intra prediction is not stationary — it grows with distance from the edge the
- * prediction came from — and that is exactly the shape an ADST fits and a DCT does not. Which
- * direction it grows in depends on which edge, so all four pairings are worth asking about.
- *
- * @param {Av1EncodeContext} ec
- */
-function choose_luma_transform(ec) {
-    const ctx = ec.frame_context;
-
-    ec.luma_tx_type = DCT_DCT;
-
-    const tx_size = transform_size(ctx, 0);
-
-    // at a large transform the format codes no type, and at quantizer index zero the block is
-    // lossless and the transform is the Walsh-Hadamard pair whatever this said
-    if (ctx.frame.base_q_idx === 0 || get_tx_set(tx_size, 0, ctx.frame.reduced_tx_set) === TX_SET_DCTONLY) {
-        return;
-    }
-
-    // nothing survived the quantiser, so there is no residual to fit a transform to and no symbol
-    // naming one. Another transform could bring a coefficient back, but the mode search has already
-    // been over the prediction space that would make one worth having
-    if (ec.chosen_empty[0] === 1) {
-        return;
-    }
-
-    let best = DCT_DCT;
-    let best_cost = ec.chosen_plane_cost;
-
-    const trials = Math.min(ec.transform_trials, TRANSFORM_CANDIDATES.length);
-
-    for (let i = 0; i < trials; i++) {
-        ec.luma_tx_type = TRANSFORM_CANDIDATES[i];
-
-        const cost = trial_plane(ec, 0);
-
-        if (cost < best_cost) {
-            best_cost = cost;
-            best = ec.luma_tx_type;
-
-            ec.chosen_empty[0] = ec.trial_empty;
-        }
-    }
-
-    ec.luma_tx_type = best;
-}
-
-/**
- * @param {Av1FrameContext} ctx
- * @returns {boolean}
- */
-function cfl_is_allowed(ctx) {
-    if (ctx.lossless === 1) {
-        const size = SUBSAMPLED_SIZE[(ctx.mi_size * 2 + ctx.subsampling_x) * 2 + ctx.subsampling_y];
-
-        return size === 0;
-    }
-
-    return NUM_4X4_BLOCKS_WIDE[ctx.mi_size] * MI_SIZE <= 32 && NUM_4X4_BLOCKS_HIGH[ctx.mi_size] * MI_SIZE <= 32;
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @param {SymbolWriter} writer
- */
-function write_skip(ec, writer) {
-    const ctx = ec.frame_context;
-
-    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];
-    }
-
-    writer.write_symbol(ctx.skip, ctx.cdf.skip, context * 3, 2);
-}
-
-/**
- * Sum of squared differences between the reconstruction plane, which currently holds a trial
- * prediction, and the source.
- *
- * @param {Av1EncodeContext} ec
- * @param {number} plane
- * @param {number} start_x
- * @param {number} start_y
- * @param {number} tx_size
- * @returns {number}
- */
-function transform_block_error(ec, plane, start_x, start_y, tx_size) {
-    const ctx = ec.frame_context;
-
-    const x0 = start_x;
-    const y0 = start_y;
-
-    const x1 = Math.min(x0 + TX_WIDTH[tx_size], ctx.plane_width[plane]);
-    const y1 = Math.min(y0 + TX_HEIGHT[tx_size], ctx.plane_height[plane]);
-
-    const reconstruction = ctx.planes[plane];
-    const reconstruction_stride = ctx.plane_stride[plane];
-
-    const source = ec.source[plane];
-    const source_stride = ec.source_stride[plane];
-
-    let error = 0;
-
-    for (let y = y0; y < y1; y++) {
-        const a = y * reconstruction_stride;
-        const b = y * source_stride;
-
-        for (let x = x0; x < x1; x++) {
-            const difference = reconstruction[a + x] - source[b + x];
-
-            error += difference * difference;
-        }
-    }
-
-    return error;
-}
-
-/**
- * The transform size a plane of the current block uses.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} plane
- * @returns {number}
- */
-function transform_size(ctx, plane) {
-    if (ctx.lossless === 1) {
-        return TX_4X4;
-    }
-
-    if (plane === 0) {
-        return ctx.tx_size;
-    }
-
-    const sub_x = ctx.subsampling_x;
-    const sub_y = ctx.subsampling_y;
-
-    return MAX_TX_SIZE_RECT[SUBSAMPLED_SIZE[(ctx.mi_size * 2 + sub_x) * 2 + sub_y]];
-}
-
-/**
- * @param {Av1EncodeContext} ec
- * @param {number} plane
- * @param {number} start_x
- * @param {number} start_y
- * @param {number} tx_size
- * @param {number} x
- * @param {number} y
- */
-function predict_transform_block(ec, plane, start_x, start_y, tx_size, x, y) {
-    const ctx = ec.frame_context;
-
-    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
-    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
-
-    const max_x = (ctx.mi_cols * MI_SIZE) >> sub_x;
-    const max_y = (ctx.mi_rows * MI_SIZE) >> sub_y;
-
-    const intra = ctx.intra;
-
-    intra.bit_depth = ctx.bit_depth;
-    intra.enable_intra_edge_filter = ctx.sequence.enable_intra_edge_filter;
-    intra.angle_delta = 0;
-    intra.use_filter_intra = 0;
-    intra.filter_intra_mode = 0;
-    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 step_x = TX_WIDTH[tx_size] >> 2;
-    const step_y = TX_HEIGHT[tx_size] >> 2;
-
-    const row = (start_y << sub_y) >> 2;
-    const col = (start_x << sub_x) >> 2;
-
-    const sub_block_mi_row = row & 15;
-    const sub_block_mi_col = col & 15;
-
-    const flags = ctx.block_decoded[plane];
-
-    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
-    ];
-
-    // prediction writes the whole transform block whether or not the picture reaches that far, so
-    // the plane is padded out to a whole superblock to receive it. Running past *that* wraps into
-    // the next row and corrupts a strip of a block coded long ago, which is a very quiet way to be
-    // wrong — so it is checked here rather than found later
-    if (start_x + TX_WIDTH[tx_size] > ctx.plane_stride[plane] || start_y + TX_HEIGHT[tx_size] > ctx.plane_rows[plane]) {
-        assert.ok(false, `a ${TX_WIDTH[tx_size]}x${TX_HEIGHT[tx_size]} transform at ${start_x},${start_y} runs off plane ${plane}`);
-    }
-
-    const cfl = plane > 0 && ctx.uv_mode === UV_CFL_PRED;
-
-    predict_intra(
-        intra,
-        ctx.planes[plane],
-        ctx.plane_stride[plane],
-        plane,
-        start_x,
-        start_y,
-        max_x - 1,
-        max_y - 1,
-        have_left,
-        have_above,
-        above_right,
-        below_left,
-        plane === 0 ? ctx.y_mode : (cfl ? DC_PRED : ctx.uv_mode),
-        TX_WIDTH_LOG2[tx_size],
-        TX_HEIGHT_LOG2[tx_size]
-    );
-
-    if (cfl) {
-        predict_chroma_from_luma(
-            ctx.planes[plane],
-            ctx.plane_stride[plane],
-            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
-        );
-    }
-}
-
-/**
- * Record that a transform block has been coded, which is what tells the transform block below and
- * to the right of it that there are samples there to predict from.
- *
- * A trial marks its transform blocks too and clears them again afterwards, with `decoded` of zero:
- * a block cut into several transform blocks predicts each from the last, so a trial that did not
- * mark would price a prediction the real pass would never make.
- *
- * @param {Av1FrameContext} ctx
- * @param {number} plane
- * @param {number} start_x
- * @param {number} start_y
- * @param {number} tx_size
- * @param {number} decoded `1` when coding, `0` to undo a trial's marks
- */
-function mark_decoded(ctx, plane, start_x, start_y, tx_size, decoded) {
-    const sub_x = plane > 0 ? ctx.subsampling_x : 0;
-    const sub_y = plane > 0 ? ctx.subsampling_y : 0;
-
-    const step_x = TX_WIDTH[tx_size] >> 2;
-    const step_y = TX_HEIGHT[tx_size] >> 2;
-
-    const row = (start_y << sub_y) >> 2;
-    const col = (start_x << sub_x) >> 2;
-
-    const sub_block_mi_row = row & 15;
-    const sub_block_mi_col = col & 15;
-
-    const flags = ctx.block_decoded[plane];
-
-    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++) {
-            flags[
-                (((sub_block_mi_row >> sub_y) + i) + BLOCK_DECODED_ORIGIN) * BLOCK_DECODED_STRIDE
-                + (((sub_block_mi_col >> sub_x) + j) + BLOCK_DECODED_ORIGIN)
-            ] = decoded;
-
-            if (decoded === 0) {
-                continue;
-            }
-
-            const index = ((row >> sub_y) + i) * tx_stride + (col >> sub_x) + j;
-
-            if (index < tx_size_plane.length) {
-                tx_size_plane[index] = tx_size;
-            }
-        }
-    }
-}