@woosh/meep-engine 3.9.0 → 3.11.0

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

@@ -0,0 +1,286 @@
+/**
+ * Stride of the block-decoded flag planes. One entry either side of the superblock, since the
+ * specification indexes them from `-1`.
+ * @type {number}
+ */
+export const BLOCK_DECODED_STRIDE: number;
+/**
+ * Where index `0` sits in a block-decoded plane.
+ * @type {number}
+ */
+export const BLOCK_DECODED_ORIGIN: number;
+/**
+ * Largest palette a block may carry.
+ * @type {number}
+ */
+export const MAX_PALETTE_SIZE: number;
+/**
+ * Everything a frame decode needs, allocated once and reused.
+ *
+ * The layout follows the protocol's flat-storage rule: per-4x4 state is one typed array per field,
+ * indexed `mi_row * mi_stride + mi_col`. The neighbour lookups those feed are the hottest reads in
+ * the tile decoder, and an array of per-block objects would make every one of them a pointer chase.
+ *
+ * {@link resize} is idempotent for a given frame geometry, so decoding many images of the same size
+ * allocates only on the first.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Av1FrameContext {
+    /** @type {SequenceHeader|null} */
+    sequence: SequenceHeader | null;
+    /** @type {FrameHeader|null} */
+    frame: FrameHeader | null;
+    /** @type {CdfContext} */
+    cdf: CdfContext;
+    /** @type {SymbolReader} */
+    reader: SymbolReader;
+    /**
+     * @type {SymbolWriter} the same state serves an encode; only the direction of the arithmetic
+     * coder differs, and everything else — planes, contexts, CDFs — is shared
+     */
+    writer: SymbolWriter;
+    /** @type {IntraPredictionState} */
+    intra: IntraPredictionState;
+    /** @type {PartitionCdf} refilled by every partition decision rather than allocated by one */
+    partition_selection: PartitionCdf;
+    /** @type {FilmGrainState} */
+    grain: FilmGrainState;
+    /** @type {number} */
+    mi_cols: number;
+    /** @type {number} */
+    mi_rows: number;
+    /** @type {number} */
+    mi_stride: number;
+    /** @type {number} */
+    num_planes: number;
+    /** @type {number} */
+    subsampling_x: number;
+    /** @type {number} */
+    subsampling_y: number;
+    /** @type {number} */
+    bit_depth: number;
+    /** @type {Uint16Array[]} one per plane, allocated at the mode-info-aligned size */
+    planes: Uint16Array[];
+    /**
+     * Distance between rows of a plane, in samples.
+     *
+     * Wider than {@link plane_width}: a block whose superblock overhangs the right edge of the
+     * frame is still predicted and reconstructed in full, so the plane is padded out to a whole
+     * superblock. Without that padding those writes wrap into the next row's leading samples and
+     * corrupt a strip down the left of the image — which is exactly what they did.
+     * @type {Int32Array}
+     */
+    plane_stride: Int32Array;
+    /** @type {Int32Array} the visible extent, and the largest coordinate prediction may read */
+    plane_width: Int32Array;
+    /** @type {Int32Array} */
+    plane_height: Int32Array;
+    /** @type {Int32Array} rows a plane's buffer holds, padded to a whole superblock like the stride */
+    plane_rows: Int32Array;
+    /** @type {number} stride of the post-superres buffers, in luma samples */
+    upscaled_stride: number;
+    /** @type {Int32Array} per-plane form of {@link upscaled_stride} */
+    upscaled_plane_stride: Int32Array;
+    /** @type {Uint8Array} */
+    y_modes: Uint8Array;
+    /** @type {Uint8Array} */
+    uv_modes: Uint8Array;
+    /** @type {Uint8Array} */
+    mi_sizes: Uint8Array;
+    /** @type {Uint8Array} */
+    tx_sizes: Uint8Array;
+    /** @type {Uint8Array} */
+    inter_tx_sizes: Uint8Array;
+    /** @type {Uint8Array} */
+    skips: Uint8Array;
+    /** @type {Uint8Array} */
+    is_inters: Uint8Array;
+    /** @type {Uint8Array} */
+    segment_ids: Uint8Array;
+    /** @type {Uint8Array} `[plane][mi]`, two planes */
+    palette_sizes: Uint8Array;
+    /** @type {Uint16Array} `[plane][mi][colour]`, two planes of eight colours */
+    palette_colors: Uint16Array;
+    /** @type {Int8Array} `[mi][filter]`, four loop filter deltas */
+    delta_lfs: Int8Array;
+    /** @type {Int8Array} one per superblock-aligned position, `-1` when unset */
+    cdef_idx: Int8Array;
+    /** @type {Uint8Array} transform type per luma 4x4 */
+    tx_types: Uint8Array;
+    /** @type {Uint8Array[]} transform size per plane 4x4, for the loop filter */
+    loop_filter_tx_sizes: Uint8Array[];
+    /** @type {Uint8Array[]} */
+    above_level_context: Uint8Array[];
+    /** @type {Uint8Array[]} */
+    above_dc_context: Uint8Array[];
+    /** @type {Uint8Array[]} */
+    left_level_context: Uint8Array[];
+    /** @type {Uint8Array[]} */
+    left_dc_context: Uint8Array[];
+    /** @type {Uint8Array[]} `[-1 .. sbSize4]` in both axes, offset by {@link BLOCK_DECODED_ORIGIN} */
+    block_decoded: Uint8Array[];
+    /** @type {Uint16Array[]} the deringed frame, allocated only when CDEF or restoration is in use */
+    cdef_planes: Uint16Array[];
+    /** @type {Uint16Array[]} the deblocked frame after superres, allocated only when it is in use */
+    upscaled_planes: Uint16Array[];
+    /** @type {Uint16Array[]} the deringed frame after superres */
+    upscaled_cdef_planes: Uint16Array[];
+    /** @type {Uint16Array[]} the restored frame, allocated only when loop restoration is in use */
+    lr_planes: Uint16Array[];
+    /**
+     * The planes a consumer should read, and their stride.
+     *
+     * Post-processing is a chain of whole-frame passes, and which buffer holds the final result
+     * depends on which of them ran. Rather than make every consumer work that out, the decode
+     * points these at the answer.
+     * @type {Uint16Array[]}
+     */
+    output_planes: Uint16Array[];
+    /** @type {Int32Array} */
+    output_stride: Int32Array;
+    /** @type {number} width of {@link output_planes}, after any superres upscaling */
+    output_width: number;
+    /** @type {number} */
+    output_height: number;
+    /** @type {number} */
+    lr_unit_stride: number;
+    /** @type {number} */
+    lr_unit_rows: number;
+    /** @type {Uint8Array} one `RESTORE_*` per unit, per plane */
+    lr_type: Uint8Array;
+    /** @type {Int8Array} two passes of three taps per unit, per plane */
+    lr_wiener: Int8Array;
+    /** @type {Uint8Array} */
+    lr_sgr_set: Uint8Array;
+    /** @type {Int8Array} two weights per unit, per plane */
+    lr_sgr_xqd: Int8Array;
+    /** @type {Int8Array} the running reference the subexp coding is relative to */
+    ref_lr_wiener: Int8Array;
+    /** @type {Int8Array} */
+    ref_sgr_xqd: Int8Array;
+    /** @type {Int32Array} the current transform block's quantised levels, by raster position */
+    quant: Int32Array;
+    /** @type {Int32Array} dequantised coefficients, then the spatial residual */
+    residual: Int32Array;
+    /** @type {Int32Array} scratch for the 1D transforms */
+    transform_scratch: Int32Array;
+    /** @type {number} */
+    mi_row: number;
+    /** @type {number} */
+    mi_col: number;
+    /** @type {number} */
+    mi_size: number;
+    /** @type {number} */
+    y_mode: number;
+    /** @type {number} */
+    uv_mode: number;
+    /** @type {number} */
+    angle_delta_y: number;
+    /** @type {number} */
+    angle_delta_uv: number;
+    /** @type {number} */
+    use_filter_intra: number;
+    /** @type {number} */
+    filter_intra_mode: number;
+    /** @type {number} */
+    cfl_alpha_u: number;
+    /** @type {number} */
+    cfl_alpha_v: number;
+    /** @type {number} */
+    skip: number;
+    /** @type {number} */
+    segment_id: number;
+    /** @type {number} */
+    lossless: number;
+    /** @type {number} */
+    tx_size: number;
+    /** @type {number} */
+    has_chroma: number;
+    /** @type {number} */
+    avail_u: number;
+    /** @type {number} */
+    avail_l: number;
+    /** @type {number} */
+    avail_u_chroma: number;
+    /** @type {number} */
+    avail_l_chroma: number;
+    /** @type {number} */
+    read_deltas: number;
+    /** @type {number} */
+    current_q_index: number;
+    /** @type {Int32Array} */
+    delta_lf: Int32Array;
+    /** @type {number} */
+    max_luma_w: number;
+    /** @type {number} */
+    max_luma_h: number;
+    /** @type {number} the transform type in force for the transform block being reconstructed */
+    plane_tx_type: number;
+    /**
+     * Diagnostic sink. When set to an array, every transform block appends a record of what it
+     * decoded — position, size, type, end-of-block and its first levels.
+     *
+     * Here rather than added when something breaks, because the failure mode it exists for is an
+     * entropy desync: the encoder and the decoder walk their two traces together until they
+     * disagree, and the first record that differs is the symbol that went wrong. By the time the
+     * picture looks wrong, it is thousands of symbols too late to ask. Left null it costs one
+     * comparison per transform block.
+     * @type {Array|null}
+     */
+    trace: any[] | null;
+    /** @type {number} */
+    palette_size_y: number;
+    /** @type {number} */
+    palette_size_uv: number;
+    /** @type {Uint16Array} */
+    palette_colors_y: Uint16Array;
+    /** @type {Uint16Array} */
+    palette_colors_u: Uint16Array;
+    /** @type {Uint16Array} */
+    palette_colors_v: Uint16Array;
+    /** @type {Uint16Array} merged neighbour palettes */
+    palette_cache: Uint16Array;
+    /** @type {Uint8Array} colour map for luma, one entry per sample of the block */
+    color_map_y: Uint8Array;
+    /** @type {Uint8Array} colour map for chroma */
+    color_map_uv: Uint8Array;
+    /** @type {number} */
+    color_map_stride: number;
+    /** @type {Uint8Array} palette indices sorted by neighbour score */
+    color_order: Uint8Array;
+    /** @type {Int32Array} */
+    color_scores: Int32Array;
+    /** @type {number} */
+    mi_row_start: number;
+    /** @type {number} */
+    mi_row_end: number;
+    /** @type {number} */
+    mi_col_start: number;
+    /** @type {number} */
+    mi_col_end: number;
+    /**
+     * Size the context for a frame, allocating only what has grown.
+     *
+     * @param {SequenceHeader} sequence
+     * @param {FrameHeader} frame
+     */
+    resize(sequence: SequenceHeader, frame: FrameHeader): void;
+    /**
+     * Index of one loop restoration unit within the per-unit arrays.
+     * @param {number} plane
+     * @param {number} unit_row
+     * @param {number} unit_col
+     * @returns {number}
+     */
+    lr_unit_index(plane: number, unit_row: number, unit_col: number): number;
+    #private;
+}
+import { CdfContext } from "../entropy/CdfContext.js";
+import { SymbolReader } from "../entropy/SymbolReader.js";
+import { SymbolWriter } from "../entropy/SymbolWriter.js";
+import { IntraPredictionState } from "../predict/IntraPredictionState.js";
+import { PartitionCdf } from "../entropy/partition_cdf.js";
+import { FilmGrainState } from "../grain/FilmGrainState.js";
+//# sourceMappingURL=Av1FrameContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Av1FrameContext.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/decode/Av1FrameContext.js"],"names":[],"mappings":"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"}