@woosh/meep-engine 3.14.1 → 3.14.3

package/src/format/image/avif/api/convert_to_rgba.js

@@ -0,0 +1,204 @@
+import { clamp01 } from "../../../../core/math/clamp01.js";
+import { clamp_sample } from "../color/clamp_sample.js";
+import { colour_transform_init } from "../color/ColourTransform.js";
+import { LINEAR_REFERENCE_NITS } from "../color/transfer_to_linear.js";
+import { MC_BT_601 } from "../av1/tables/av1_symbols.js";
+import { to_half_float_uint16 } from "../../../../core/binary/to_half_float_uint16.js";
+import { transfer_row_to_linear } from "../color/transfer_to_linear.js";
+import { UPSAMPLE_BILINEAR, UPSAMPLE_NEAREST, upsample_chroma_row } from "../color/upsample_chroma_row.js";
+import { ycbcr_row_to_rgb } from "../color/ycbcr_row_to_rgb.js";
+
+/**
+ * Hand back the samples as they were coded, gamma and all.
+ * @type {number}
+ */
+export const COLOUR_SPACE_SIGNAL = 0;
+
+/**
+ * Undo the transfer function, so that the output is linear light with `1.0` at
+ * {@link LINEAR_REFERENCE_NITS}, or at whatever `linear_reference_nits` names instead. Only useful
+ * with a float output: HDR content goes well above one.
+ * @type {number}
+ */
+export const COLOUR_SPACE_LINEAR = 1;
+
+/**
+ * Let the decoder pick, which means interpolating whenever chroma is subsampled.
+ * @type {number}
+ */
+export const CHROMA_UPSAMPLING_AUTOMATIC = 0;
+
+/** @type {number} nearest neighbour */
+export const CHROMA_UPSAMPLING_FASTEST = 1;
+
+/** @type {number} bilinear */
+export const CHROMA_UPSAMPLING_BEST = 2;
+
+/**
+ * Convert a decoded image to interleaved RGBA.
+ *
+ * Works a row at a time through buffers on the decoder, so the only allocation is the output
+ * itself — which the caller owns and this cannot reuse.
+ *
+ * @param {AvifDecoder} decoder
+ * @param {YuvImage} image
+ * @param {object} [options]
+ * @param {number} [options.bit_depth] `8`, `10` or `12`; ignored when the output is float
+ * @param {boolean} [options.output_float16] half floats rather than integers
+ * @param {number} [options.output_colour_space] one of the `COLOUR_SPACE_*` constants
+ * @param {number} [options.linear_reference_nits] luminance a linear `1.0` in the *output* stands
+ *   for, in nits; defaults to {@link LINEAR_REFERENCE_NITS}. Only read for `COLOUR_SPACE_LINEAR`,
+ *   and the exact counterpart of {@link encode_avif}'s option of the same name
+ * @param {number} [options.chroma_upsampling] one of the `CHROMA_UPSAMPLING_*` constants
+ * @returns {{data: (Uint8ClampedArray|Uint16Array), width: number, height: number}}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function convert_to_rgba(decoder, image, options = {}) {
+    const width = image.width;
+    const height = image.height;
+
+    const output_bit_depth = options.bit_depth ?? 8;
+    const output_float16 = options.output_float16 === true;
+    const colour_space = options.output_colour_space ?? COLOUR_SPACE_SIGNAL;
+
+    // the colour module decodes to LINEAR_REFERENCE_NITS to the unit; a caller that counts in some
+    // other white asks for it here, and pays one multiply a sample for it
+    const linear_scale = LINEAR_REFERENCE_NITS / (options.linear_reference_nits ?? LINEAR_REFERENCE_NITS);
+
+    if (output_bit_depth !== 8 && output_bit_depth !== 10 && output_bit_depth !== 12) {
+        throw new Error(`unsupported output bit depth ${output_bit_depth}`);
+    }
+
+    const upsampling = choose_upsampling(options.chroma_upsampling ?? CHROMA_UPSAMPLING_AUTOMATIC);
+
+    decoder.resize_rows(width);
+
+    const transform = decoder.transform;
+
+    // a monochrome image has no matrix to speak of: neutral chroma through any of them is grey,
+    // and going through one keeps the range handling in a single place
+    colour_transform_init(
+        transform,
+        image.num_planes === 1 ? MC_BT_601 : image.matrix_coefficients,
+        image.color_primaries,
+        image.color_range,
+        image.bit_depth
+    );
+
+    const cb_row = decoder.cb_row;
+    const cr_row = decoder.cr_row;
+    const rgb_row = decoder.rgb_row;
+
+    if (image.num_planes === 1) {
+        cb_row.fill(transform.c_offset, 0, width);
+        cr_row.fill(transform.c_offset, 0, width);
+    }
+
+    const samples = width * height * 4;
+
+    const data = output_float16 || output_bit_depth > 8
+        ? new Uint16Array(samples)
+        : new Uint8ClampedArray(samples);
+
+    const maximum = (1 << output_bit_depth) - 1;
+
+    const alpha_scale = alpha_normalisation(image);
+    const alpha_offset = image.alpha_range === 1 ? 0 : 16 << (image.alpha_bit_depth - 8);
+
+    const chroma_width = (image.width + image.subsampling_x) >> image.subsampling_x;
+    const chroma_height = (image.height + image.subsampling_y) >> image.subsampling_y;
+
+    for (let y = 0; y < height; y++) {
+        if (image.num_planes > 1) {
+            upsample_chroma_row(
+                image.planes[1], image.stride[1], chroma_width, chroma_height,
+                image.subsampling_x, image.subsampling_y, y, width, upsampling, cb_row
+            );
+
+            upsample_chroma_row(
+                image.planes[2], image.stride[2], chroma_width, chroma_height,
+                image.subsampling_x, image.subsampling_y, y, width, upsampling, cr_row
+            );
+        }
+
+        ycbcr_row_to_rgb(transform, image.planes[0], y * image.stride[0], cb_row, cr_row, width, rgb_row);
+
+        if (colour_space === COLOUR_SPACE_LINEAR) {
+            transfer_row_to_linear(image.transfer_characteristics, rgb_row, width);
+
+            if (linear_scale !== 1) {
+                for (let i = 0, count = width * 3; i < count; i++) {
+                    rgb_row[i] *= linear_scale;
+                }
+            }
+        }
+
+        const alpha_row = image.alpha === null ? 0 : y * image.alpha_stride;
+
+        let out = y * width * 4;
+
+        for (let x = 0; x < width; x++) {
+            const i = x * 3;
+
+            const alpha = image.alpha === null
+                ? 1
+                : clamp01((image.alpha[alpha_row + x] - alpha_offset) * alpha_scale);
+
+            if (output_float16) {
+                data[out] = to_half_float_uint16(rgb_row[i]);
+                data[out + 1] = to_half_float_uint16(rgb_row[i + 1]);
+                data[out + 2] = to_half_float_uint16(rgb_row[i + 2]);
+                data[out + 3] = to_half_float_uint16(alpha);
+            } else {
+                data[out] = quantise(rgb_row[i], maximum);
+                data[out + 1] = quantise(rgb_row[i + 1], maximum);
+                data[out + 2] = quantise(rgb_row[i + 2], maximum);
+                data[out + 3] = quantise(alpha, maximum);
+            }
+
+            out += 4;
+        }
+    }
+
+    return { data, width, height };
+}
+
+/**
+ * @param {number} requested
+ * @returns {number} one of the `UPSAMPLE_*` constants
+ */
+function choose_upsampling(requested) {
+    if (requested === CHROMA_UPSAMPLING_FASTEST) {
+        return UPSAMPLE_NEAREST;
+    }
+
+    return UPSAMPLE_BILINEAR;
+}
+
+/**
+ * @param {YuvImage} image
+ * @returns {number}
+ */
+function alpha_normalisation(image) {
+    if (image.alpha === null) {
+        return 1;
+    }
+
+    if (image.alpha_range === 1) {
+        return 1 / ((1 << image.alpha_bit_depth) - 1);
+    }
+
+    return 1 / (219 << (image.alpha_bit_depth - 8));
+}
+
+/**
+ * A normalised `0 .. 1` value as a coded sample of the output depth.
+ * @param {number} value
+ * @param {number} maximum
+ * @returns {number}
+ */
+function quantise(value, maximum) {
+    return clamp_sample(value * maximum, maximum);
+}

package/src/format/image/avif/api/decode_avif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_avif.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/avif/api/decode_avif.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;GAgBG;AACH,oCAVW,WAAW,GAAC,UAAU,YACtB,MAAM,YAGN,WAAW,GACT;IAAC,IAAI,EAAE,CAAC,iBAAiB,GAAC,WAAW,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAmClF;4BA/D2B,kBAAkB"}

package/src/format/image/avif/api/decode_image_item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_image_item.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/avif/api/decode_image_item.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;GAeG;AACH,kIAuGC"}

package/src/format/image/avif/api/encode_avif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode_avif.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/avif/api/encode_avif.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA7BwE,IAAI,EAAjE,UAAU,GAAC,iBAAiB,GAAC,WAAW,GAAC,YAAY;IACvC,KAAK,EAAnB,MAAM;IACQ,MAAM,EAApB,MAAM;;IAEW,OAAO,GAAxB,MAAM;IACW,MAAM,GAAvB,MAAM;IAGW,aAAa,GAA9B,MAAM;IAGW,SAAS,GAA1B,MAAM;IACW,eAAe,GAAhC,MAAM;IACW,WAAW,GAA5B,MAAM;IACY,KAAK,GAAvB,OAAO;IACU,eAAe,GAAhC,MAAM;IACW,wBAAwB,GAAzC,MAAM;IACW,mBAAmB,GAApC,MAAM;IACY,eAAe,GAAjC,OAAO;IAEU,qBAAqB,GAAtC,MAAM;aAGN,gBAAgB,GACd,UAAU,CAwGtB;AAxKD;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;iCAnCA,mCAAmC"}

package/src/format/image/avif/av1/decode/Av1FrameContext.d.ts.map

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

package/src/format/image/avif/av1/decode/block_decoded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_decoded.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/decode/block_decoded.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,mEALW,MAAM,KACN,MAAM,YACN,MAAM,QA6BhB;AAED;;;;;;GAMG;AACH,mDALW,MAAM,KACN,MAAM,GACJ,OAAO,CAKnB"}

package/src/format/image/avif/av1/decode/decode_av1_still.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_av1_still.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/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/format/image/avif/av1/decode/decode_coefficients.d.ts.map

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

package/src/format/image/avif/av1/decode/decode_palette.d.ts.map

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

package/src/format/image/avif/av1/decode/decode_palette.js

@@ -0,0 +1,442 @@
+import { clamp } from "../../../../../core/math/clamp.js";
+import {
+    DC_PRED,
+    MI_SIZE,
+    PALETTE_COLORS,
+    PALETTE_NUM_NEIGHBORS
+} from "../tables/av1_symbols.js";
+import { MI_HEIGHT_LOG2, MI_WIDTH_LOG2 } from "../tables/block_tables.js";
+import { BLOCK_HEIGHT, BLOCK_WIDTH } from "../tables/derived_block_tables.js";
+import { PALETTE_COLOR_CONTEXT, PALETTE_COLOR_HASH_MULTIPLIERS } from "../tables/prediction_tables.js";
+import { ceil_log2 } from "../util/ceil_log2.js";
+import { MAX_PALETTE_SIZE } from "./Av1FrameContext.js";
+
+/**
+ * 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) {
+    const reader = ctx.reader;
+    const cdf = ctx.cdf;
+
+    const bit_depth = ctx.bit_depth;
+    const max_value = (1 << bit_depth) - 1;
+
+    const bsize_ctx = MI_WIDTH_LOG2[ctx.mi_size] + MI_HEIGHT_LOG2[ctx.mi_size] - 2;
+
+    if (ctx.y_mode === DC_PRED) {
+        let ctx_y = 0;
+
+        if (ctx.avail_u === 1 && ctx.palette_sizes[0 * ctx.mi_stride * ctx.mi_rows + (ctx.mi_row - 1) * ctx.mi_stride + ctx.mi_col] > 0) {
+            ctx_y += 1;
+        }
+
+        if (ctx.avail_l === 1 && ctx.palette_sizes[0 * ctx.mi_stride * ctx.mi_rows + ctx.mi_row * ctx.mi_stride + ctx.mi_col - 1] > 0) {
+            ctx_y += 1;
+        }
+
+        const has_palette_y = reader.read_symbol(cdf.palette_y_mode, (bsize_ctx * 3 + ctx_y) * 3, 2);
+
+        if (has_palette_y === 1) {
+            ctx.palette_size_y = reader.read_symbol(cdf.palette_y_size, bsize_ctx * 8, 7) + 2;
+
+            const cache_count = build_palette_cache(ctx, 0);
+
+            let idx = 0;
+
+            for (let i = 0; i < cache_count && idx < ctx.palette_size_y; i++) {
+                if (reader.read_bool() === 1) {
+                    ctx.palette_colors_y[idx] = ctx.palette_cache[i];
+                    idx++;
+                }
+            }
+
+            if (idx < ctx.palette_size_y) {
+                ctx.palette_colors_y[idx] = reader.read_literal(bit_depth);
+                idx++;
+            }
+
+            let palette_bits = 0;
+
+            if (idx < ctx.palette_size_y) {
+                palette_bits = (bit_depth - 3) + reader.read_literal(2);
+            }
+
+            while (idx < ctx.palette_size_y) {
+                const delta = reader.read_literal(palette_bits) + 1;
+
+                ctx.palette_colors_y[idx] = clamp(ctx.palette_colors_y[idx - 1] + delta, 0, max_value);
+
+                const range = (1 << bit_depth) - ctx.palette_colors_y[idx] - 1;
+
+                palette_bits = Math.min(palette_bits, ceil_log2(range));
+
+                idx++;
+            }
+
+            sort_palette(ctx.palette_colors_y, ctx.palette_size_y);
+        }
+    }
+
+    if (ctx.has_chroma === 1 && ctx.uv_mode === DC_PRED) {
+        const has_palette_uv = reader.read_symbol(cdf.palette_uv_mode, (ctx.palette_size_y > 0 ? 1 : 0) * 3, 2);
+
+        if (has_palette_uv === 1) {
+            ctx.palette_size_uv = reader.read_symbol(cdf.palette_uv_size, bsize_ctx * 8, 7) + 2;
+
+            const cache_count = build_palette_cache(ctx, 1);
+
+            let idx = 0;
+
+            for (let i = 0; i < cache_count && idx < ctx.palette_size_uv; i++) {
+                if (reader.read_bool() === 1) {
+                    ctx.palette_colors_u[idx] = ctx.palette_cache[i];
+                    idx++;
+                }
+            }
+
+            if (idx < ctx.palette_size_uv) {
+                ctx.palette_colors_u[idx] = reader.read_literal(bit_depth);
+                idx++;
+            }
+
+            let palette_bits = 0;
+
+            if (idx < ctx.palette_size_uv) {
+                palette_bits = (bit_depth - 3) + reader.read_literal(2);
+            }
+
+            while (idx < ctx.palette_size_uv) {
+                const delta = reader.read_literal(palette_bits);
+
+                ctx.palette_colors_u[idx] = clamp(ctx.palette_colors_u[idx - 1] + delta, 0, max_value);
+
+                const range = (1 << bit_depth) - ctx.palette_colors_u[idx];
+
+                palette_bits = Math.min(palette_bits, ceil_log2(range));
+
+                idx++;
+            }
+
+            sort_palette(ctx.palette_colors_u, ctx.palette_size_uv);
+
+            if (reader.read_bool() === 1) {
+                const max_val = 1 << bit_depth;
+
+                const bits = (bit_depth - 4) + reader.read_literal(2);
+
+                ctx.palette_colors_v[0] = reader.read_literal(bit_depth);
+
+                for (let i = 1; i < ctx.palette_size_uv; i++) {
+                    let delta = reader.read_literal(bits);
+
+                    if (delta !== 0 && reader.read_bool() === 1) {
+                        delta = -delta;
+                    }
+
+                    let value = ctx.palette_colors_v[i - 1] + delta;
+
+                    if (value < 0) {
+                        value += max_val;
+                    }
+
+                    if (value >= max_val) {
+                        value -= max_val;
+                    }
+
+                    ctx.palette_colors_v[i] = clamp(value, 0, max_value);
+                }
+            } else {
+                for (let i = 0; i < ctx.palette_size_uv; i++) {
+                    ctx.palette_colors_v[i] = reader.read_literal(bit_depth);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Merge the palettes of the blocks above and to the left into `ctx.palette_cache`.
+ *
+ * Both are already in ascending order, so this is a merge rather than a sort, and duplicates are
+ * dropped as they appear.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane `0` luma, `1` chroma
+ * @returns {number} the number of cached colours
+ * @see AV1 spec 5.11.46, `get_palette_cache`
+ */
+function build_palette_cache(ctx, plane) {
+    const mi_count = ctx.mi_stride * ctx.mi_rows;
+    const size_base = plane * mi_count;
+    const colour_base = plane * mi_count * MAX_PALETTE_SIZE;
+
+    // the above palette is only visible within the same 64-sample row of superblocks
+    const above_available = (ctx.mi_row * MI_SIZE) % 64 !== 0;
+
+    const above_index = (ctx.mi_row - 1) * ctx.mi_stride + ctx.mi_col;
+    const left_index = ctx.mi_row * ctx.mi_stride + ctx.mi_col - 1;
+
+    const above_count = above_available ? ctx.palette_sizes[size_base + above_index] : 0;
+    const left_count = ctx.avail_l === 1 ? ctx.palette_sizes[size_base + left_index] : 0;
+
+    const cache = ctx.palette_cache;
+    const colours = ctx.palette_colors;
+
+    let above_idx = 0;
+    let left_idx = 0;
+    let n = 0;
+
+    while (above_idx < above_count && left_idx < left_count) {
+        const above_colour = colours[colour_base + above_index * MAX_PALETTE_SIZE + above_idx];
+        const left_colour = colours[colour_base + left_index * MAX_PALETTE_SIZE + left_idx];
+
+        if (left_colour < above_colour) {
+            if (n === 0 || left_colour !== cache[n - 1]) {
+                cache[n++] = left_colour;
+            }
+
+            left_idx++;
+        } else {
+            if (n === 0 || above_colour !== cache[n - 1]) {
+                cache[n++] = above_colour;
+            }
+
+            above_idx++;
+
+            if (left_colour === above_colour) {
+                left_idx++;
+            }
+        }
+    }
+
+    while (above_idx < above_count) {
+        const value = colours[colour_base + above_index * MAX_PALETTE_SIZE + above_idx];
+
+        above_idx++;
+
+        if (n === 0 || value !== cache[n - 1]) {
+            cache[n++] = value;
+        }
+    }
+
+    while (left_idx < left_count) {
+        const value = colours[colour_base + left_index * MAX_PALETTE_SIZE + left_idx];
+
+        left_idx++;
+
+        if (n === 0 || value !== cache[n - 1]) {
+            cache[n++] = value;
+        }
+    }
+
+    return n;
+}
+
+/**
+ * @param {Uint16Array} palette
+ * @param {number} count
+ */
+function sort_palette(palette, count) {
+    // insertion sort: the array is at most eight entries and usually already ordered
+    for (let i = 1; i < count; i++) {
+        const value = palette[i];
+
+        let j = i - 1;
+
+        while (j >= 0 && palette[j] > value) {
+            palette[j + 1] = palette[j];
+            j--;
+        }
+
+        palette[j + 1] = value;
+    }
+}
+
+/**
+ * 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) {
+    const reader = ctx.reader;
+
+    let block_height = BLOCK_HEIGHT[ctx.mi_size];
+    let block_width = BLOCK_WIDTH[ctx.mi_size];
+
+    let onscreen_height = Math.min(block_height, (ctx.mi_rows - ctx.mi_row) * MI_SIZE);
+    let onscreen_width = Math.min(block_width, (ctx.mi_cols - ctx.mi_col) * MI_SIZE);
+
+    const stride = ctx.color_map_stride;
+
+    if (ctx.palette_size_y > 0) {
+        const map = ctx.color_map_y;
+
+        map[0] = reader.read_ns(ctx.palette_size_y);
+
+        read_colour_map(ctx, map, stride, onscreen_width, onscreen_height, ctx.palette_size_y, ctx.cdf.palette_y_color);
+
+        extend_colour_map(map, stride, block_width, block_height, onscreen_width, onscreen_height);
+    }
+
+    if (ctx.palette_size_uv > 0) {
+        const map = ctx.color_map_uv;
+
+        map[0] = reader.read_ns(ctx.palette_size_uv);
+
+        block_height = block_height >> ctx.subsampling_y;
+        block_width = block_width >> ctx.subsampling_x;
+        onscreen_height = onscreen_height >> ctx.subsampling_y;
+        onscreen_width = onscreen_width >> ctx.subsampling_x;
+
+        // a 4x4 luma block subsamples to 2x2 chroma, which is smaller than the smallest transform;
+        // the map is grown to 4 so the prediction has something to read
+        if (block_width < 4) {
+            block_width += 2;
+            onscreen_width += 2;
+        }
+
+        if (block_height < 4) {
+            block_height += 2;
+            onscreen_height += 2;
+        }
+
+        read_colour_map(ctx, map, stride, onscreen_width, onscreen_height, ctx.palette_size_uv, ctx.cdf.palette_uv_color);
+
+        extend_colour_map(map, stride, block_width, block_height, onscreen_width, onscreen_height);
+    }
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {Uint8Array} map
+ * @param {number} stride
+ * @param {number} width
+ * @param {number} height
+ * @param {number} palette_size
+ * @param {Uint16Array[]} colour_cdfs
+ */
+function read_colour_map(ctx, map, stride, width, height, palette_size, colour_cdfs) {
+    const reader = ctx.reader;
+
+    const cdf = colour_cdfs[palette_size - 2];
+    const stride_symbols = palette_size + 1;
+
+    for (let i = 1; i < height + width - 1; i++) {
+        for (let j = Math.min(i, width - 1); j >= Math.max(0, i - height + 1); j--) {
+            const r = i - j;
+
+            const hash = compute_colour_context(ctx, map, stride, r, j, palette_size);
+            const context = PALETTE_COLOR_CONTEXT[hash];
+
+            const symbol = reader.read_symbol(cdf, context * stride_symbols, palette_size);
+
+            map[r * stride + j] = ctx.color_order[symbol];
+        }
+    }
+}
+
+/**
+ * @param {Uint8Array} map
+ * @param {number} stride
+ * @param {number} block_width
+ * @param {number} block_height
+ * @param {number} onscreen_width
+ * @param {number} onscreen_height
+ */
+function extend_colour_map(map, stride, block_width, block_height, onscreen_width, onscreen_height) {
+    for (let i = 0; i < onscreen_height; i++) {
+        for (let j = onscreen_width; j < block_width; j++) {
+            map[i * stride + j] = map[i * stride + onscreen_width - 1];
+        }
+    }
+
+    for (let i = onscreen_height; i < block_height; i++) {
+        for (let j = 0; j < block_width; j++) {
+            map[i * stride + j] = map[(onscreen_height - 1) * stride + j];
+        }
+    }
+}
+
+/**
+ * Rank the palette colours by how strongly the decoded neighbours vote for them, and return the
+ * hash that selects the context.
+ *
+ * @param {Av1FrameContext} ctx
+ * @param {Uint8Array} map
+ * @param {number} stride
+ * @param {number} r
+ * @param {number} c
+ * @param {number} n palette size
+ * @returns {number} the colour context hash
+ * @see AV1 spec 5.11.50 "Palette color context function"
+ */
+function compute_colour_context(ctx, map, stride, r, c, n) {
+    const scores = ctx.color_scores;
+    const order = ctx.color_order;
+
+    for (let i = 0; i < PALETTE_COLORS; i++) {
+        scores[i] = 0;
+        order[i] = i;
+    }
+
+    if (c > 0) {
+        scores[map[r * stride + c - 1]] += 2;
+    }
+
+    if (r > 0 && c > 0) {
+        scores[map[(r - 1) * stride + c - 1]] += 1;
+    }
+
+    if (r > 0) {
+        scores[map[(r - 1) * stride + c]] += 2;
+    }
+
+    for (let i = 0; i < PALETTE_NUM_NEIGHBORS; i++) {
+        let max_score = scores[i];
+        let max_idx = i;
+
+        for (let j = i + 1; j < n; j++) {
+            if (scores[j] > max_score) {
+                max_score = scores[j];
+                max_idx = j;
+            }
+        }
+
+        if (max_idx !== i) {
+            const max_order = order[max_idx];
+
+            for (let k = max_idx; k > i; k--) {
+                scores[k] = scores[k - 1];
+                order[k] = order[k - 1];
+            }
+
+            scores[i] = max_score;
+            order[i] = max_order;
+        }
+    }
+
+    let hash = 0;
+
+    for (let i = 0; i < PALETTE_NUM_NEIGHBORS; i++) {
+        hash += scores[i] * PALETTE_COLOR_HASH_MULTIPLIERS[i];
+    }
+
+    return hash;
+}

package/src/format/image/avif/av1/decode/decode_tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_tile.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/decode/decode_tile.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;GAWG;AACH,wDAmCC"}