@woosh/meep-engine 3.9.0 → 3.11.0

package/src/avif/native/av1/encode/quantise.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Quantise one transform block's coefficients.
+ *
+ * The step is exactly the one `reconstruct` will divide back out, taken from the same tables, so
+ * that the only error is the rounding this chooses to make.
+ *
+ * At quantizer index zero the step is four rather than one — the lossless transform is scaled to
+ * match, and the division here is exact — so the lossless path needs no special case.
+ *
+ * That rounding is deliberately biased towards zero. A coefficient that quantises to zero costs
+ * almost nothing to code, and one that quantises to one costs a symbol and a sign; giving up the
+ * last fraction of a step buys a great many bits back on the kind of content still images are made
+ * of.
+ *
+ * The pass runs in scan order and carries two answers out with it that the caller would otherwise
+ * pay for separately: the end-of-block position, which the coefficient writer used to find by
+ * walking a thousand positions backwards, and the squared error the quantiser cost in the
+ * coefficient domain, which is what saves the rate-distortion search an inverse transform per
+ * candidate. Both are free here and neither is anywhere else.
+ *
+ * @param {Av1EncodeContext} ec
+ * @param {number} plane
+ * @param {number} tx_size
+ * @param {number} tx_type
+ * @param {Int32Array} coefficients
+ * @param {Int32Array} levels filled with the signed quantised levels
+ * @param {number} levels_offset where in `levels` this transform block's start, so that a block's
+ *   transform blocks can share one buffer
+ * @param {Uint16Array} scan the order the coefficients will be coded in
+ * @returns {number} the end-of-block position: one past the last coefficient in scan order that
+ *   survived, and zero for a block that did not
+ * @see AV1 spec 7.12.2 "Dequantization functions", which this is the inverse of
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quantise_transform_block(ec: Av1EncodeContext, plane: number, tx_size: number, tx_type: number, coefficients: Int32Array, levels: Int32Array, levels_offset: number, scan: Uint16Array): number;
+/**
+ * The coefficient magnitude below which the quantiser produces nothing at all.
+ *
+ * A coefficient quantises to zero when `|c| * denominator / step + rounding` stays under one, and
+ * the DC step is the smaller of the two, so a magnitude under this survives at no position. A block
+ * whose largest possible coefficient is under it is a block the transform need not be run on.
+ *
+ * @param {Av1EncodeContext} ec
+ * @param {number} plane
+ * @param {number} tx_size
+ * @returns {number}
+ */
+export function quantiser_zero_threshold(ec: Av1EncodeContext, plane: number, tx_size: number): number;
+//# sourceMappingURL=quantise.d.ts.map

package/src/avif/native/av1/encode/quantise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantise.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/quantise.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,sEAfW,MAAM,WACN,MAAM,WACN,MAAM,gBACN,UAAU,UACV,UAAU,iBACV,MAAM,QAEN,WAAW,GACT,MAAM,CA2FlB;AAED;;;;;;;;;;;GAWG;AACH,sEAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAclB"}

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

@@ -0,0 +1,212 @@
+import {
+    TX_16X32,
+    TX_16X64,
+    TX_32X16,
+    TX_32X32,
+    TX_32X64,
+    TX_64X16,
+    TX_64X32,
+    TX_64X64
+} from "../tables/av1_symbols.js";
+import { TX_HEIGHT, TX_WIDTH } from "../tables/block_tables.js";
+import { ac_quant, dc_quant, get_qindex } from "../decode/reconstruct.js";
+
+/**
+ * Largest level the format can carry. The decoder masks a coefficient to twenty bits before
+ * dequantising, so anything past this would come back as something else entirely.
+ * @type {number}
+ */
+const MAX_LEVEL = 0xfffff;
+
+/**
+ * Quantise one transform block's coefficients.
+ *
+ * The step is exactly the one `reconstruct` will divide back out, taken from the same tables, so
+ * that the only error is the rounding this chooses to make.
+ *
+ * At quantizer index zero the step is four rather than one — the lossless transform is scaled to
+ * match, and the division here is exact — so the lossless path needs no special case.
+ *
+ * That rounding is deliberately biased towards zero. A coefficient that quantises to zero costs
+ * almost nothing to code, and one that quantises to one costs a symbol and a sign; giving up the
+ * last fraction of a step buys a great many bits back on the kind of content still images are made
+ * of.
+ *
+ * The pass runs in scan order and carries two answers out with it that the caller would otherwise
+ * pay for separately: the end-of-block position, which the coefficient writer used to find by
+ * walking a thousand positions backwards, and the squared error the quantiser cost in the
+ * coefficient domain, which is what saves the rate-distortion search an inverse transform per
+ * candidate. Both are free here and neither is anywhere else.
+ *
+ * @param {Av1EncodeContext} ec
+ * @param {number} plane
+ * @param {number} tx_size
+ * @param {number} tx_type
+ * @param {Int32Array} coefficients
+ * @param {Int32Array} levels filled with the signed quantised levels
+ * @param {number} levels_offset where in `levels` this transform block's start, so that a block's
+ *   transform blocks can share one buffer
+ * @param {Uint16Array} scan the order the coefficients will be coded in
+ * @returns {number} the end-of-block position: one past the last coefficient in scan order that
+ *   survived, and zero for a block that did not
+ * @see AV1 spec 7.12.2 "Dequantization functions", which this is the inverse of
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quantise_transform_block(ec, plane, tx_size, tx_type, coefficients, levels, levels_offset, scan) {
+    const ctx = ec.frame_context;
+    const frame = ec.frame;
+
+    const width = TX_WIDTH[tx_size];
+    const height = TX_HEIGHT[tx_size];
+
+    const tw = Math.min(32, width);
+    const th = Math.min(32, height);
+
+    // the scan's positions are raster indices into the coded corner, whose stride is `tw`; the
+    // coefficients the transform produced are strided by the transform's full width. This encoder
+    // emits nothing wider than the corner, so the two agree — and if that ever changes, the scan
+    // would be indexing the wrong samples silently
+    if (tw !== width) {
+        throw new Error(`a transform ${width} wide codes only its first ${tw} columns, which this does not handle`);
+    }
+
+    const denominator = dequant_denominator(tx_size);
+
+    const qindex = get_qindex(ctx);
+
+    const dc_step = dc_quant(ctx.bit_depth, qindex + dc_delta(frame, plane));
+    const ac_step = ac_quant(ctx.bit_depth, qindex + ac_delta(frame, plane));
+
+    const rounding = ec.rounding;
+
+    // what the decoder will multiply these levels back up by, left where whatever wants to reason
+    // about a level's worth can find it without deriving it a second time
+    ec.step_dc = dc_step;
+    ec.step_ac = ac_step;
+    ec.step_denominator = denominator;
+
+    // a reciprocal, because this is the innermost loop of the encoder and a division here is worth
+    // twenty multiplications. The step is an integer under two thousand and the magnitude an
+    // integer under a million, so the product is exact well past the point the rounding decides
+    const dc_scale = denominator / dc_step;
+    const ac_scale = denominator / ac_step;
+
+    // one, a half or a quarter, all of them exact in floating point, so this is the dequantiser's
+    // division without the division
+    const inverse_denominator = 1 / denominator;
+
+    const count = tw * th;
+
+    // in scan order rather than in raster order, so that the end-of-block position — which the
+    // coefficient writer would otherwise find by walking a thousand positions backwards looking for
+    // one that is not zero — falls out of the same pass
+    let eob = 0;
+    let error = 0;
+
+    for (let c = 0; c < count; c++) {
+        const pos = scan[c];
+
+        const coefficient = coefficients[pos];
+
+        const magnitude = coefficient < 0 ? -coefficient : coefficient;
+
+        const scale = pos === 0 ? dc_scale : ac_scale;
+
+        let level = (magnitude * scale + rounding) | 0;
+
+        if (level > MAX_LEVEL) {
+            level = MAX_LEVEL;
+        }
+
+        levels[levels_offset + pos] = coefficient < 0 ? -level : level;
+
+        if (level !== 0) {
+            eob = c + 1;
+        }
+
+        // what the decoder will reconstruct, and therefore what this cost in accuracy. Squared
+        // error in the coefficient domain, which the caller scales into samples
+        const step = pos === 0 ? dc_step : ac_step;
+
+        const difference = magnitude - ((level * step * inverse_denominator) | 0);
+
+        error += difference * difference;
+    }
+
+    ec.quantised_error = error;
+
+    return eob;
+}
+
+/**
+ * The coefficient magnitude below which the quantiser produces nothing at all.
+ *
+ * A coefficient quantises to zero when `|c| * denominator / step + rounding` stays under one, and
+ * the DC step is the smaller of the two, so a magnitude under this survives at no position. A block
+ * whose largest possible coefficient is under it is a block the transform need not be run on.
+ *
+ * @param {Av1EncodeContext} ec
+ * @param {number} plane
+ * @param {number} tx_size
+ * @returns {number}
+ */
+export function quantiser_zero_threshold(ec, plane, tx_size) {
+    const ctx = ec.frame_context;
+    const frame = ec.frame;
+
+    const qindex = get_qindex(ctx);
+
+    const dc_step = dc_quant(ctx.bit_depth, qindex + dc_delta(frame, plane));
+    const ac_step = ac_quant(ctx.bit_depth, qindex + ac_delta(frame, plane));
+
+    const step = dc_step < ac_step ? dc_step : ac_step;
+
+    return ((1 - ec.rounding) * step) / dequant_denominator(tx_size);
+}
+
+/**
+ * The divisor the dequantiser applies after multiplying by the step, which is how large transforms
+ * keep their coefficients in range.
+ *
+ * @param {number} tx_size
+ * @returns {number}
+ */
+function dequant_denominator(tx_size) {
+    if (tx_size === TX_32X32 || tx_size === TX_16X32 || tx_size === TX_32X16 || tx_size === TX_16X64 || tx_size === TX_64X16) {
+        return 2;
+    }
+
+    if (tx_size === TX_64X64 || tx_size === TX_32X64 || tx_size === TX_64X32) {
+        return 4;
+    }
+
+    return 1;
+}
+
+/**
+ * @param {FrameHeader} frame
+ * @param {number} plane
+ * @returns {number}
+ */
+function dc_delta(frame, plane) {
+    if (plane === 0) {
+        return frame.delta_q_y_dc;
+    }
+
+    return plane === 1 ? frame.delta_q_u_dc : frame.delta_q_v_dc;
+}
+
+/**
+ * @param {FrameHeader} frame
+ * @param {number} plane
+ * @returns {number}
+ */
+function ac_delta(frame, plane) {
+    if (plane === 0) {
+        return 0;
+    }
+
+    return plane === 1 ? frame.delta_q_u_ac : frame.delta_q_v_ac;
+}

package/src/avif/native/av1/encode/write_coefficients.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Write the coefficients of one transform block.
+ *
+ * The mirror of `decode_coefficients`, and deliberately written to look like it: every context here
+ * has to be derived from exactly the state the decoder will have when it reads the symbol back, so
+ * the two read as the same sequence of decisions with the arrows reversed.
+ *
+ * `levels` holds the signed quantised coefficients by raster position. On return `ctx.quant` holds
+ * what the decoder would have, so `reconstruct` can be called on it directly — which is what keeps
+ * the encoder's picture and the decoder's identical rather than merely close.
+ *
+ * ### Costing a block without coding it
+ *
+ * Passing a writer in its costing mode, and `record` of zero, runs the whole syntax against
+ * something that adds up what each symbol would cost and writes nothing, leaving the block's
+ * entropy contexts and recorded transform types untouched. That is how the encoder prices a decision: the rate it weighs
+ * is the rate of exactly these symbols through exactly these contexts, because it *is* this
+ * function. `ctx.quant` is filled either way, so a trial can still be reconstructed and measured.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {SymbolWriter} writer where the symbols go, or what prices them
+ * @param {number} record `1` to update the entropy contexts and transform types this block leaves
+ *   behind, `0` for a trial that must leave no trace
+ * @param {number} plane
+ * @param {number} start_x left edge of the transform block in plane samples
+ * @param {number} start_y
+ * @param {number} tx_size
+ * @param {number} tx_type the type the coefficients were produced with
+ * @param {Int32Array} levels
+ * @param {number} levels_offset where in `levels` this transform block starts
+ * @param {number} eob one past the last coefficient in scan order that survived the quantiser, as
+ *   `quantise_transform_block` returned it. Passing it rather than looking for it is worth having:
+ *   finding it here means walking the scan backwards from its end, which for a 32x32 block is a
+ *   thousand positions to reach an answer that is usually under a hundred
+ * @returns {number} the same end-of-block position
+ * @see AV1 spec 5.11.39 "Coefficients syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function write_coefficients(ctx: Av1FrameContext, writer: SymbolWriter, record: number, plane: number, start_x: number, start_y: number, tx_size: number, tx_type: number, levels: Int32Array, levels_offset: number, eob: number): number;
+//# sourceMappingURL=write_coefficients.d.ts.map

package/src/avif/native/av1/encode/write_coefficients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_coefficients.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/encode/write_coefficients.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAnBW,MAAM,SAEN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,UACN,UAAU,iBACV,MAAM,OACN,MAAM,GAIJ,MAAM,CAoKlB"}

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

@@ -0,0 +1,367 @@
+import {
+    BR_CDF_SIZE,
+    COEFF_BASE_RANGE,
+    DCT_DCT,
+    NUM_BASE_LEVELS,
+    SIG_COEF_CONTEXTS,
+    SIG_COEF_CONTEXTS_EOB,
+    TX_16X64,
+    TX_32X32,
+    TX_64X16,
+    TX_CLASS_2D
+} from "../tables/av1_symbols.js";
+import {
+    ADJUSTED_TX_SIZE,
+    TX_HEIGHT,
+    TX_HEIGHT_LOG2,
+    TX_SIZE_SQR,
+    TX_SIZE_SQR_UP,
+    TX_WIDTH,
+    TX_WIDTH_LOG2
+} from "../tables/block_tables.js";
+import {
+    get_all_zero_ctx,
+    get_coeff_base_ctx,
+    get_coeff_br_ctx,
+    get_dc_sign_ctx
+} from "../entropy/coefficient_context.js";
+import { get_scan } from "../decode/get_scan.js";
+import { get_tx_class } from "../decode/transform_type.js";
+import { write_transform_type } from "./write_transform_type.js";
+
+/**
+ * Write the coefficients of one transform block.
+ *
+ * The mirror of `decode_coefficients`, and deliberately written to look like it: every context here
+ * has to be derived from exactly the state the decoder will have when it reads the symbol back, so
+ * the two read as the same sequence of decisions with the arrows reversed.
+ *
+ * `levels` holds the signed quantised coefficients by raster position. On return `ctx.quant` holds
+ * what the decoder would have, so `reconstruct` can be called on it directly — which is what keeps
+ * the encoder's picture and the decoder's identical rather than merely close.
+ *
+ * ### Costing a block without coding it
+ *
+ * Passing a writer in its costing mode, and `record` of zero, runs the whole syntax against
+ * something that adds up what each symbol would cost and writes nothing, leaving the block's
+ * entropy contexts and recorded transform types untouched. That is how the encoder prices a decision: the rate it weighs
+ * is the rate of exactly these symbols through exactly these contexts, because it *is* this
+ * function. `ctx.quant` is filled either way, so a trial can still be reconstructed and measured.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {SymbolWriter} writer where the symbols go, or what prices them
+ * @param {number} record `1` to update the entropy contexts and transform types this block leaves
+ *   behind, `0` for a trial that must leave no trace
+ * @param {number} plane
+ * @param {number} start_x left edge of the transform block in plane samples
+ * @param {number} start_y
+ * @param {number} tx_size
+ * @param {number} tx_type the type the coefficients were produced with
+ * @param {Int32Array} levels
+ * @param {number} levels_offset where in `levels` this transform block starts
+ * @param {number} eob one past the last coefficient in scan order that survived the quantiser, as
+ *   `quantise_transform_block` returned it. Passing it rather than looking for it is worth having:
+ *   finding it here means walking the scan backwards from its end, which for a 32x32 block is a
+ *   thousand positions to reach an answer that is usually under a hundred
+ * @returns {number} the same end-of-block position
+ * @see AV1 spec 5.11.39 "Coefficients syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function write_coefficients(ctx, writer, record, plane, start_x, start_y, tx_size, tx_type, levels, levels_offset, eob) {
+    const cdf = ctx.cdf;
+
+    const x4 = start_x >> 2;
+    const y4 = start_y >> 2;
+    const w4 = TX_WIDTH[tx_size] >> 2;
+    const h4 = TX_HEIGHT[tx_size] >> 2;
+
+    const tx_size_ctx = (TX_SIZE_SQR[tx_size] + TX_SIZE_SQR_UP[tx_size] + 1) >> 1;
+    const plane_type = plane > 0 ? 1 : 0;
+
+    const seg_eob = tx_size === TX_16X64 || tx_size === TX_64X16
+        ? 512
+        : Math.min(1024, TX_WIDTH[tx_size] * TX_HEIGHT[tx_size]);
+
+    const scan = get_scan(tx_size, tx_type);
+
+    const quant = ctx.quant;
+
+    quant.fill(0, 0, seg_eob);
+
+    const all_zero_ctx = get_all_zero_ctx(ctx, plane, x4, y4, w4, h4, tx_size);
+
+    writer.write_symbol(eob === 0 ? 1 : 0, cdf.txb_skip, (tx_size_ctx * 13 + all_zero_ctx) * 3, 2);
+
+    let cul_level = 0;
+    let dc_category = 0;
+
+    if (eob === 0) {
+        if (record === 1) {
+            if (plane === 0) {
+                for (let i = 0; i < w4; i++) {
+                    for (let j = 0; j < h4; j++) {
+                        ctx.tx_types[(y4 + j) * ctx.mi_stride + x4 + i] = DCT_DCT;
+                    }
+                }
+            }
+
+            update_contexts(ctx, plane, x4, y4, w4, h4, 0, 0);
+        }
+
+        return 0;
+    }
+
+    // the type is coded here, after the block is known not to be empty, because that is where the
+    // decoder reads it
+    if (plane === 0) {
+        write_transform_type(ctx, writer, record, x4, y4, tx_size, tx_type);
+    }
+
+    ctx.plane_tx_type = tx_type;
+
+    const tx_class = get_tx_class(tx_type);
+
+    write_eob_position(ctx, writer, tx_size, tx_size_ctx, plane_type, tx_class, eob);
+
+    const adjusted = ADJUSTED_TX_SIZE[tx_size];
+    const bwl = TX_WIDTH_LOG2[adjusted];
+    const adjusted_width = 1 << bwl;
+    const adjusted_height = TX_HEIGHT[adjusted];
+
+    const br_cdf_size_ctx = Math.min(tx_size_ctx, TX_32X32);
+
+    // the magnitudes the decoder holds while it reads: capped, because anything larger is coded as
+    // a suffix in the second pass and the contexts below never see the true value
+    const cap = NUM_BASE_LEVELS + COEFF_BASE_RANGE + 1;
+
+    for (let c = eob - 1; c >= 0; c--) {
+        const pos = scan[c];
+
+        const magnitude = Math.abs(levels[levels_offset + pos]);
+        const capped = magnitude < cap ? magnitude : cap;
+
+        if (c === eob - 1) {
+            const eob_ctx = get_coeff_base_ctx(quant, tx_class, bwl, adjusted_width, adjusted_height, pos, c, 1, tx_size)
+                - SIG_COEF_CONTEXTS + SIG_COEF_CONTEXTS_EOB;
+
+            writer.write_symbol(
+                (capped < 3 ? capped : 3) - 1,
+                cdf.coeff_base_eob,
+                ((tx_size_ctx * 2 + plane_type) * SIG_COEF_CONTEXTS_EOB + eob_ctx) * 4,
+                3
+            );
+        } else {
+            const base_ctx = get_coeff_base_ctx(quant, tx_class, bwl, adjusted_width, adjusted_height, pos, c, 0, tx_size);
+
+            writer.write_symbol(
+                capped < 3 ? capped : 3,
+                cdf.coeff_base,
+                ((tx_size_ctx * 2 + plane_type) * SIG_COEF_CONTEXTS + base_ctx) * 5,
+                4
+            );
+        }
+
+        if (capped > NUM_BASE_LEVELS) {
+            const br_ctx = get_coeff_br_ctx(quant, tx_class, bwl, adjusted_width, adjusted_height, pos);
+
+            let remaining = capped - (NUM_BASE_LEVELS + 1);
+
+            for (let idx = 0; idx < COEFF_BASE_RANGE / (BR_CDF_SIZE - 1); idx++) {
+                const chunk = remaining < BR_CDF_SIZE - 1 ? remaining : BR_CDF_SIZE - 1;
+
+                writer.write_symbol(
+                    chunk,
+                    cdf.coeff_br,
+                    ((br_cdf_size_ctx * 2 + plane_type) * 21 + br_ctx) * 5,
+                    4
+                );
+
+                remaining -= chunk;
+
+                if (chunk < BR_CDF_SIZE - 1) {
+                    break;
+                }
+            }
+        }
+
+        quant[pos] = capped;
+    }
+
+    const dc_sign_ctx = get_dc_sign_ctx(ctx, plane, x4, y4, w4, h4);
+
+    for (let c = 0; c < eob; c++) {
+        const pos = scan[c];
+
+        const level = levels[levels_offset + pos];
+        const magnitude = Math.abs(level);
+
+        const sign = level < 0 ? 1 : 0;
+
+        if (magnitude !== 0) {
+            if (c === 0) {
+                writer.write_symbol(sign, cdf.dc_sign, (plane_type * 3 + dc_sign_ctx) * 3, 2);
+            } else {
+                writer.write_bool(sign);
+            }
+        }
+
+        if (quant[pos] > NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
+            write_golomb(writer, magnitude - (NUM_BASE_LEVELS + COEFF_BASE_RANGE));
+        }
+
+        if (pos === 0 && magnitude > 0) {
+            dc_category = sign !== 0 ? 1 : 2;
+        }
+
+        cul_level += magnitude;
+
+        quant[pos] = level;
+    }
+
+    cul_level = Math.min(63, cul_level);
+
+    if (record === 1) {
+        update_contexts(ctx, plane, x4, y4, w4, h4, cul_level, dc_category);
+    }
+
+    return eob;
+}
+
+/**
+ * Write the end-of-block position, which is coded as a bucket and then the offset within it.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {SymbolWriter} writer
+ * @param {number} tx_size
+ * @param {number} tx_size_ctx
+ * @param {number} plane_type
+ * @param {number} tx_class
+ * @param {number} eob
+ */
+function write_eob_position(ctx, writer, tx_size, tx_size_ctx, plane_type, tx_class, eob) {
+    const cdf = ctx.cdf;
+
+    // the bucket is the position of the top set bit, offset so that one and two get buckets of
+    // their own
+    let eob_pt = 1;
+
+    while (eob_pt < 11 && eob > bucket_base(eob_pt)) {
+        eob_pt++;
+    }
+
+    const eob_multisize = Math.min(TX_WIDTH_LOG2[tx_size], 5) + Math.min(TX_HEIGHT_LOG2[tx_size], 5) - 4;
+
+    const eob_class_ctx = tx_class === TX_CLASS_2D ? 0 : 1;
+
+    if (eob_multisize === 0) {
+        writer.write_symbol(eob_pt - 1, cdf.eob_pt_16, ((plane_type * 2) + eob_class_ctx) * 6, 5);
+    } else if (eob_multisize === 1) {
+        writer.write_symbol(eob_pt - 1, cdf.eob_pt_32, ((plane_type * 2) + eob_class_ctx) * 7, 6);
+    } else if (eob_multisize === 2) {
+        writer.write_symbol(eob_pt - 1, cdf.eob_pt_64, ((plane_type * 2) + eob_class_ctx) * 8, 7);
+    } else if (eob_multisize === 3) {
+        writer.write_symbol(eob_pt - 1, cdf.eob_pt_128, ((plane_type * 2) + eob_class_ctx) * 9, 8);
+    } else if (eob_multisize === 4) {
+        writer.write_symbol(eob_pt - 1, cdf.eob_pt_256, ((plane_type * 2) + eob_class_ctx) * 10, 9);
+    } else if (eob_multisize === 5) {
+        writer.write_symbol(eob_pt - 1, cdf.eob_pt_512, plane_type * 11, 10);
+    } else {
+        writer.write_symbol(eob_pt - 1, cdf.eob_pt_1024, plane_type * 12, 11);
+    }
+
+    const base = bucket_base(eob_pt - 1) + 1;
+
+    let remainder = eob - base;
+
+    let eob_shift = Math.max(-1, eob_pt - 3);
+
+    if (eob_shift < 0) {
+        return;
+    }
+
+    const extra = (remainder >> eob_shift) & 1;
+
+    writer.write_symbol(
+        extra,
+        cdf.eob_extra,
+        ((tx_size_ctx * 2 + plane_type) * 9 + (eob_pt - 3)) * 3,
+        2
+    );
+
+    for (let i = 1; i < Math.max(0, eob_pt - 2); i++) {
+        eob_shift = Math.max(0, eob_pt - 2) - 1 - i;
+
+        writer.write_bool((remainder >> eob_shift) & 1);
+    }
+}
+
+/**
+ * The largest end-of-block position a bucket covers.
+ *
+ * @param {number} eob_pt
+ * @returns {number}
+ */
+function bucket_base(eob_pt) {
+    if (eob_pt < 1) {
+        return 0;
+    }
+
+    if (eob_pt < 2) {
+        return eob_pt;
+    }
+
+    return (1 << (eob_pt - 1));
+}
+
+/**
+ * Write the Exp-Golomb suffix for a coefficient beyond the range the base symbols reach.
+ *
+ * @param {SymbolWriter} writer
+ * @param {number} value at least one
+ */
+function write_golomb(writer, value) {
+    let length = 0;
+
+    for (let probe = value; probe > 0; probe >>= 1) {
+        length++;
+    }
+
+    for (let i = 0; i < length - 1; i++) {
+        writer.write_bool(0);
+    }
+
+    writer.write_bool(1);
+
+    for (let i = length - 2; i >= 0; i--) {
+        writer.write_bool((value >> i) & 1);
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} x4
+ * @param {number} y4
+ * @param {number} w4
+ * @param {number} h4
+ * @param {number} cul_level
+ * @param {number} dc_category
+ */
+function update_contexts(ctx, plane, x4, y4, w4, h4, cul_level, dc_category) {
+    const above_level = ctx.above_level_context[plane];
+    const above_dc = ctx.above_dc_context[plane];
+    const left_level = ctx.left_level_context[plane];
+    const left_dc = ctx.left_dc_context[plane];
+
+    for (let i = 0; i < w4; i++) {
+        above_level[x4 + i] = cul_level;
+        above_dc[x4 + i] = dc_category;
+    }
+
+    for (let i = 0; i < h4; i++) {
+        left_level[y4 + i] = cul_level;
+        left_dc[y4 + i] = dc_category;
+    }
+}