@woosh/meep-engine 3.8.0 → 3.10.0

package/src/avif/native/av1/decode/decode_av1_still.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Decode an AV1 still picture into planar samples.
+ *
+ * `ctx` is reused across calls: it holds every buffer the decode needs, so decoding a series of
+ * images of the same size allocates only on the first.
+ *
+ * `configuration_obus` is the `av1C` property's payload, which may carry the sequence header when
+ * the item's own payload does not repeat it.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {Uint8Array} payload the AV1 item's data
+ * @param {Uint8Array|null} [configuration_obus]
+ * @param {number} [operating_point]
+ * @returns {Av1FrameContext} `ctx`
+ * @see AV1 spec 5.1 "General OBU syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function decode_av1_still(ctx: Av1FrameContext, payload: Uint8Array, configuration_obus?: Uint8Array | null, operating_point?: number): Av1FrameContext;
+import { Av1FrameContext } from "./Av1FrameContext.js";
+//# sourceMappingURL=decode_av1_still.d.ts.map

package/src/avif/native/av1/decode/decode_av1_still.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_av1_still.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/decode_av1_still.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sCAVW,eAAe,WACf,UAAU,uBACV,UAAU,GAAC,IAAI,oBACf,MAAM,GACJ,eAAe,CAsG3B;gCA3H+B,sBAAsB"}

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

@@ -0,0 +1,309 @@
+import { BitReader } from "../../bitstream/BitReader.js";
+import { cdf_context_init } from "../entropy/CdfContext.js";
+import {
+    OBU_FRAME,
+    OBU_FRAME_HEADER,
+    OBU_METADATA,
+    OBU_PADDING,
+    OBU_SEQUENCE_HEADER,
+    OBU_TEMPORAL_DELIMITER,
+    OBU_TILE_GROUP
+} from "../tables/av1_symbols.js";
+import { FrameHeader } from "../obu/FrameHeader.js";
+import { ObuHeader } from "../obu/ObuHeader.js";
+import { SequenceHeader } from "../obu/SequenceHeader.js";
+import { parse_frame_header } from "../obu/parse_frame_header.js";
+import { parse_obu_header } from "../obu/parse_obu_header.js";
+import { parse_sequence_header } from "../obu/parse_sequence_header.js";
+import { Av1FrameContext } from "./Av1FrameContext.js";
+import { apply_cdef } from "../filter/cdef.js";
+import { apply_film_grain } from "../grain/film_grain.js";
+import { apply_loop_filter } from "../filter/loop_filter.js";
+import { apply_loop_restoration } from "../filter/loop_restoration.js";
+import { apply_superres } from "../filter/superres.js";
+import { decode_tile } from "./decode_tile.js";
+
+/**
+ * Decode an AV1 still picture into planar samples.
+ *
+ * `ctx` is reused across calls: it holds every buffer the decode needs, so decoding a series of
+ * images of the same size allocates only on the first.
+ *
+ * `configuration_obus` is the `av1C` property's payload, which may carry the sequence header when
+ * the item's own payload does not repeat it.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {Uint8Array} payload the AV1 item's data
+ * @param {Uint8Array|null} [configuration_obus]
+ * @param {number} [operating_point]
+ * @returns {Av1FrameContext} `ctx`
+ * @see AV1 spec 5.1 "General OBU syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function decode_av1_still(ctx, payload, configuration_obus = null, operating_point = 0) {
+    const sequence = new SequenceHeader();
+    const frame = new FrameHeader();
+
+    const header = new ObuHeader();
+    const header_reader = new BitReader();
+    const reader = new BitReader();
+
+    let have_sequence = false;
+    let have_frame = false;
+    let decoded = false;
+
+    /**
+     * @param {Uint8Array} bytes
+     */
+    function walk(bytes) {
+        let position = 0;
+
+        while (position < bytes.length) {
+            parse_obu_header(bytes, position, bytes.length - position, header, header_reader);
+
+            const type = header.obu_type;
+
+            if (type === OBU_SEQUENCE_HEADER) {
+                reader.init(bytes, header.payload_offset, header.payload_size);
+
+                parse_sequence_header(reader, sequence, operating_point);
+
+                have_sequence = true;
+            } else if (type === OBU_FRAME_HEADER || type === OBU_FRAME) {
+                if (!have_sequence) {
+                    throw new Error("a frame header appeared before any sequence header");
+                }
+
+                reader.init(bytes, header.payload_offset, header.payload_size);
+
+                parse_frame_header(reader, sequence, frame);
+
+                have_frame = true;
+
+                if (type === OBU_FRAME) {
+                    // deliberately not the validating byte_alignment: see the note on
+                    // BitReader.skip_to_byte_boundary for why real encoders leave these bits dirty
+                    reader.skip_to_byte_boundary();
+
+                    const consumed = reader.position_in_bits / 8;
+
+                    decode_tile_group(
+                        ctx,
+                        sequence,
+                        frame,
+                        bytes,
+                        header.payload_offset + consumed,
+                        header.payload_size - consumed,
+                        decoded
+                    );
+
+                    decoded = true;
+                }
+            } else if (type === OBU_TILE_GROUP) {
+                if (!have_frame) {
+                    throw new Error("a tile group appeared before any frame header");
+                }
+
+                decode_tile_group(ctx, sequence, frame, bytes, header.payload_offset, header.payload_size, decoded);
+
+                decoded = true;
+            } else if (type !== OBU_TEMPORAL_DELIMITER && type !== OBU_METADATA && type !== OBU_PADDING) {
+                // reserved types carry no defined syntax and are skipped by their size
+            }
+
+            if (header.obu_has_size_field === 0) {
+                return;
+            }
+
+            position = header.end;
+        }
+    }
+
+    if (configuration_obus !== null && configuration_obus.length > 0) {
+        walk(configuration_obus);
+    }
+
+    walk(payload);
+
+    if (!have_sequence) {
+        throw new Error("the AV1 payload carried no sequence header");
+    }
+
+    if (!decoded) {
+        throw new Error("the AV1 payload carried no tile data");
+    }
+
+    apply_post_processing(ctx, sequence, frame);
+
+    return ctx;
+}
+
+/**
+ * Run the frame-level filters, in the order the specification fixes: deblock, dering, upscale,
+ * restore.
+ *
+ * Each pass reads a whole frame and writes another, so the buffer holding the final result depends
+ * on which passes ran. That is what `output_planes` records, and why nothing downstream has to
+ * reason about it.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} frame
+ * @see AV1 spec 7.4 "Decode frame wrapup process"
+ */
+function apply_post_processing(ctx, sequence, frame) {
+    apply_loop_filter(ctx);
+
+    let current = ctx.planes;
+    let deringed = ctx.planes;
+    let stride = ctx.plane_stride;
+
+    const uses_cdef = frame.coded_lossless === 0
+        && frame.allow_intrabc === 0
+        && sequence.enable_cdef === 1;
+
+    if (uses_cdef || frame.uses_lr === 1) {
+        // loop restoration needs a deringed frame even when no CDEF strength is signalled, because
+        // it reads one inside the current stripe and the deblocked frame outside it
+        if (uses_cdef) {
+            apply_cdef(ctx);
+        } else {
+            for (let plane = 0; plane < ctx.num_planes; plane++) {
+                const samples = ctx.plane_stride[plane] * ctx.plane_rows[plane];
+
+                // the buffers are reused across frames, so either may be longer than this frame
+                ctx.cdef_planes[plane].set(ctx.planes[plane].subarray(0, samples));
+            }
+        }
+
+        deringed = ctx.cdef_planes;
+    }
+
+    ctx.output_width = frame.upscaled_width;
+    ctx.output_height = frame.frame_height;
+
+    if (frame.use_superres === 1) {
+        apply_superres(ctx, deringed, ctx.upscaled_cdef_planes, ctx.upscaled_plane_stride);
+        apply_superres(ctx, current, ctx.upscaled_planes, ctx.upscaled_plane_stride);
+
+        current = ctx.upscaled_planes;
+        deringed = ctx.upscaled_cdef_planes;
+        stride = ctx.upscaled_plane_stride;
+    }
+
+    if (frame.uses_lr === 1) {
+        apply_loop_restoration(ctx, current, deringed, ctx.lr_planes, stride);
+
+        deringed = ctx.lr_planes;
+    }
+
+    for (let plane = 0; plane < ctx.num_planes; plane++) {
+        ctx.output_planes[plane] = deringed[plane];
+        ctx.output_stride[plane] = stride[plane];
+    }
+
+    apply_film_grain(ctx);
+}
+
+/**
+ * Decode one tile group OBU.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} frame
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @param {number} size
+ * @param {boolean} already_started whether an earlier tile group of this frame has been decoded
+ * @see AV1 spec 5.11.1 "General tile group OBU syntax"
+ */
+function decode_tile_group(ctx, sequence, frame, bytes, offset, size, already_started) {
+    reject_unsupported(sequence, frame);
+
+    if (!already_started) {
+        ctx.resize(sequence, frame);
+    }
+
+    const reader = new BitReader().init(bytes, offset, size);
+
+    const tile_count = frame.tile_cols * frame.tile_rows;
+
+    let tile_start = 0;
+    let tile_end = tile_count - 1;
+
+    if (tile_count > 1) {
+        const present = reader.f(1);
+
+        if (present === 1) {
+            const bits = frame.tile_cols_log2 + frame.tile_rows_log2;
+
+            tile_start = reader.f(bits);
+            tile_end = reader.f(bits);
+        }
+    }
+
+    reader.byte_alignment();
+
+    let position = offset + reader.position_in_bits / 8;
+    let remaining = size - reader.position_in_bits / 8;
+
+    for (let tile_number = tile_start; tile_number <= tile_end; tile_number++) {
+        const tile_row = Math.floor(tile_number / frame.tile_cols);
+        const tile_col = tile_number % frame.tile_cols;
+
+        const is_last = tile_number === tile_end;
+
+        let tile_size;
+
+        if (is_last) {
+            tile_size = remaining;
+        } else {
+            const size_reader = new BitReader().init(bytes, position, frame.tile_size_bytes);
+
+            tile_size = size_reader.le(frame.tile_size_bytes) + 1;
+
+            position += frame.tile_size_bytes;
+            remaining -= frame.tile_size_bytes + tile_size;
+        }
+
+        if (tile_size < 0 || position + tile_size > offset + size) {
+            throw new Error(`tile ${tile_number} declares ${tile_size} bytes, past the end of the tile group`);
+        }
+
+        ctx.mi_row_start = frame.mi_row_starts[tile_row];
+        ctx.mi_row_end = frame.mi_row_starts[tile_row + 1];
+        ctx.mi_col_start = frame.mi_col_starts[tile_col];
+        ctx.mi_col_end = frame.mi_col_starts[tile_col + 1];
+
+        ctx.current_q_index = frame.base_q_idx;
+
+        // every tile starts from the frame's initial CDFs. The specification also saves the final
+        // CDFs of one nominated tile for a later frame to load; a still image has no later frame,
+        // so that save has no consumer and is not performed.
+        cdf_context_init(ctx.cdf, frame.base_q_idx);
+
+        ctx.reader.init(bytes, position, tile_size, frame.disable_cdf_update);
+
+        decode_tile(ctx);
+
+        ctx.reader.exit();
+
+        position += tile_size;
+    }
+}
+
+/**
+ * Refuse streams that use tools this decoder does not implement, before any of their state has been
+ * half-applied.
+ *
+ * @param {SequenceHeader} sequence
+ * @param {FrameHeader} frame
+ */
+function reject_unsupported(sequence, frame) {
+    if (frame.allow_intrabc === 1) {
+        throw new Error("intra block copy is not supported");
+    }
+
+}

package/src/avif/native/av1/decode/decode_coefficients.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Decode the coefficients of one transform block.
+ *
+ * Fills `ctx.quant` with the quantised levels by raster position within the block and returns the
+ * end-of-block position, which is zero when the block is empty. Also updates the level and DC-sign
+ * contexts that the next block's `all_zero` and `dc_sign` decisions read.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} start_x left edge of the transform block in plane samples
+ * @param {number} start_y top edge of the transform block in plane samples
+ * @param {number} tx_size
+ * @returns {number} the end-of-block position
+ * @see AV1 spec 5.11.39 "Coefficients syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function decode_coefficients(ctx: Av1FrameContext, plane: number, start_x: number, start_y: number, tx_size: number): number;
+//# sourceMappingURL=decode_coefficients.d.ts.map

package/src/avif/native/av1/decode/decode_coefficients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_coefficients.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/decode_coefficients.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;GAiBG;AACH,iEAVW,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,MAAM,CAuNlB"}

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

@@ -0,0 +1,259 @@
+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 "./get_scan.js";
+import { compute_tx_type, get_tx_class } from "./transform_type.js";
+import { read_transform_type } from "./read_transform_type.js";
+
+/**
+ * Decode the coefficients of one transform block.
+ *
+ * Fills `ctx.quant` with the quantised levels by raster position within the block and returns the
+ * end-of-block position, which is zero when the block is empty. Also updates the level and DC-sign
+ * contexts that the next block's `all_zero` and `dc_sign` decisions read.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @param {number} start_x left edge of the transform block in plane samples
+ * @param {number} start_y top edge of the transform block in plane samples
+ * @param {number} tx_size
+ * @returns {number} the end-of-block position
+ * @see AV1 spec 5.11.39 "Coefficients syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function decode_coefficients(ctx, plane, start_x, start_y, tx_size) {
+    const reader = ctx.reader;
+    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 quant = ctx.quant;
+
+    quant.fill(0, 0, seg_eob);
+
+    let eob = 0;
+    let cul_level = 0;
+    let dc_category = 0;
+
+    const all_zero_ctx = get_all_zero_ctx(ctx, plane, x4, y4, w4, h4, tx_size);
+
+    const all_zero = reader.read_symbol(cdf.txb_skip, (tx_size_ctx * 13 + all_zero_ctx) * 3, 2);
+
+    if (all_zero === 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;
+                }
+            }
+        }
+    } else {
+        if (plane === 0) {
+            read_transform_type(ctx, x4, y4, tx_size);
+        }
+
+        const tx_type = compute_tx_type(ctx, plane, tx_size, x4, y4);
+
+        ctx.plane_tx_type = tx_type;
+
+        const tx_class = get_tx_class(tx_type);
+        const scan = get_scan(tx_size, tx_type);
+
+        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;
+
+        let eob_pt;
+
+        if (eob_multisize === 0) {
+            eob_pt = reader.read_symbol(cdf.eob_pt_16, ((plane_type * 2) + eob_class_ctx) * 6, 5) + 1;
+        } else if (eob_multisize === 1) {
+            eob_pt = reader.read_symbol(cdf.eob_pt_32, ((plane_type * 2) + eob_class_ctx) * 7, 6) + 1;
+        } else if (eob_multisize === 2) {
+            eob_pt = reader.read_symbol(cdf.eob_pt_64, ((plane_type * 2) + eob_class_ctx) * 8, 7) + 1;
+        } else if (eob_multisize === 3) {
+            eob_pt = reader.read_symbol(cdf.eob_pt_128, ((plane_type * 2) + eob_class_ctx) * 9, 8) + 1;
+        } else if (eob_multisize === 4) {
+            eob_pt = reader.read_symbol(cdf.eob_pt_256, ((plane_type * 2) + eob_class_ctx) * 10, 9) + 1;
+        } else if (eob_multisize === 5) {
+            eob_pt = reader.read_symbol(cdf.eob_pt_512, plane_type * 11, 10) + 1;
+        } else {
+            eob_pt = reader.read_symbol(cdf.eob_pt_1024, plane_type * 12, 11) + 1;
+        }
+
+        eob = eob_pt < 2 ? eob_pt : (1 << (eob_pt - 2)) + 1;
+
+        let eob_shift = Math.max(-1, eob_pt - 3);
+
+        if (eob_shift >= 0) {
+            const extra = reader.read_symbol(
+                cdf.eob_extra,
+                ((tx_size_ctx * 2 + plane_type) * 9 + (eob_pt - 3)) * 3,
+                2
+            );
+
+            if (extra === 1) {
+                eob += 1 << eob_shift;
+            }
+
+            for (let i = 1; i < Math.max(0, eob_pt - 2); i++) {
+                eob_shift = Math.max(0, eob_pt - 2) - 1 - i;
+
+                if (reader.read_bool() === 1) {
+                    eob += 1 << eob_shift;
+                }
+            }
+        }
+
+        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);
+
+        for (let c = eob - 1; c >= 0; c--) {
+            const pos = scan[c];
+
+            let level;
+
+            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;
+
+                level = reader.read_symbol(
+                    cdf.coeff_base_eob,
+                    ((tx_size_ctx * 2 + plane_type) * SIG_COEF_CONTEXTS_EOB + eob_ctx) * 4,
+                    3
+                ) + 1;
+            } else {
+                const base_ctx = get_coeff_base_ctx(quant, tx_class, bwl, adjusted_width, adjusted_height, pos, c, 0, tx_size);
+
+                level = reader.read_symbol(
+                    cdf.coeff_base,
+                    ((tx_size_ctx * 2 + plane_type) * SIG_COEF_CONTEXTS + base_ctx) * 5,
+                    4
+                );
+            }
+
+            if (level > NUM_BASE_LEVELS) {
+                const br_ctx = get_coeff_br_ctx(quant, tx_class, bwl, adjusted_width, adjusted_height, pos);
+
+                for (let idx = 0; idx < COEFF_BASE_RANGE / (BR_CDF_SIZE - 1); idx++) {
+                    const coeff_br = reader.read_symbol(
+                        cdf.coeff_br,
+                        ((br_cdf_size_ctx * 2 + plane_type) * 21 + br_ctx) * 5,
+                        4
+                    );
+
+                    level += coeff_br;
+
+                    if (coeff_br < BR_CDF_SIZE - 1) {
+                        break;
+                    }
+                }
+            }
+
+            quant[pos] = level;
+        }
+
+        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];
+
+            let sign = 0;
+
+            if (quant[pos] !== 0) {
+                if (c === 0) {
+                    sign = reader.read_symbol(cdf.dc_sign, (plane_type * 3 + dc_sign_ctx) * 3, 2);
+                } else {
+                    sign = reader.read_bool();
+                }
+            }
+
+            if (quant[pos] > NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
+                let length = 0;
+
+                do {
+                    length++;
+                } while (reader.read_bool() === 0);
+
+                let x = 1;
+
+                for (let i = length - 2; i >= 0; i--) {
+                    x = (x << 1) | reader.read_bool();
+                }
+
+                quant[pos] = x + COEFF_BASE_RANGE + NUM_BASE_LEVELS;
+            }
+
+            if (pos === 0 && quant[pos] > 0) {
+                dc_category = sign !== 0 ? 1 : 2;
+            }
+
+            quant[pos] = quant[pos] & 0xfffff;
+
+            cul_level += quant[pos];
+
+            if (sign !== 0) {
+                quant[pos] = -quant[pos];
+            }
+        }
+
+        cul_level = Math.min(63, cul_level);
+    }
+
+    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;
+    }
+
+    return eob;
+}

package/src/avif/native/av1/decode/decode_palette.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Read a block's palettes.
+ *
+ * Colours are coded as a mixture of cache hits — colours reused from the blocks above and to the
+ * left — a literal, and then deltas whose width shrinks as the colours climb towards the top of the
+ * range. The V plane is the odd one out: its colours may be delta-coded with a sign and wrap around
+ * the range, because chroma has no reason to be monotonic.
+ *
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.46 "Palette mode info syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function read_palette_mode_info(ctx: Av1FrameContext): void;
+/**
+ * Read the colour index maps for a palette block.
+ *
+ * The map is coded along anti-diagonals so that every sample has its left, above and above-left
+ * neighbours already decoded. Samples beyond the visible edge of the frame are not coded at all;
+ * they are filled by extending the last coded column and row, which keeps prediction well defined
+ * without spending bits on samples nobody sees.
+ *
+ * @param {Av1FrameContext} ctx
+ * @see AV1 spec 5.11.49 "Palette tokens syntax"
+ */
+export function read_palette_tokens(ctx: Av1FrameContext): void;
+//# sourceMappingURL=decode_palette.d.ts.map

package/src/avif/native/av1/decode/decode_palette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_palette.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/decode_palette.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;GAaG;AACH,mEA0IC;AAoGD;;;;;;;;;;GAUG;AACH,gEA+CC"}