@woosh/meep-engine 3.9.0 → 3.10.0

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

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