@woosh/meep-engine 3.9.0 → 3.11.0

package/src/avif/native/av1/obu/write_sequence_header.js

@@ -0,0 +1,189 @@
+import { CP_BT_709, MC_IDENTITY, TC_SRGB } from "../tables/av1_symbols.js";
+
+/**
+ * Emit a sequence header OBU payload from `header`.
+ *
+ * Exactly mirrors {@link parse_sequence_header}: a header that was parsed and is re-emitted is
+ * bit-identical, which is what makes the round-trip spec a meaningful check on both directions.
+ * Fields the syntax derives rather than codes — `bit_depth`, `num_planes`, `order_hint_bits` — are
+ * ignored here and recomputed by the reader.
+ *
+ * @param {BitWriter} writer
+ * @param {SequenceHeader} header
+ * @see AV1 spec 5.5.1 "General sequence header OBU syntax"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function write_sequence_header(writer, header) {
+    writer.f(3, header.seq_profile);
+    writer.f(1, header.still_picture);
+    writer.f(1, header.reduced_still_picture_header);
+
+    if (header.reduced_still_picture_header === 1) {
+        writer.f(5, header.seq_level_idx[0]);
+    } else {
+        writer.f(1, header.timing_info_present_flag);
+
+        if (header.timing_info_present_flag === 1) {
+            writer.f(32, header.num_units_in_display_tick);
+            writer.f(32, header.time_scale);
+            writer.f(1, header.equal_picture_interval);
+
+            if (header.equal_picture_interval === 1) {
+                writer.uvlc(header.num_ticks_per_picture_minus_1);
+            }
+
+            writer.f(1, header.decoder_model_info_present_flag);
+
+            if (header.decoder_model_info_present_flag === 1) {
+                writer.f(5, header.buffer_delay_length_minus_1);
+                writer.f(32, header.num_units_in_decoding_tick);
+                writer.f(5, header.buffer_removal_time_length_minus_1);
+                writer.f(5, header.frame_presentation_time_length_minus_1);
+            }
+        }
+
+        writer.f(1, header.initial_display_delay_present_flag);
+        writer.f(5, header.operating_points_cnt_minus_1);
+
+        for (let i = 0; i <= header.operating_points_cnt_minus_1; i++) {
+            writer.f(12, header.operating_point_idc[i]);
+            writer.f(5, header.seq_level_idx[i]);
+
+            if (header.seq_level_idx[i] > 7) {
+                writer.f(1, header.seq_tier[i]);
+            }
+
+            if (header.decoder_model_info_present_flag === 1) {
+                writer.f(1, header.decoder_model_present_for_this_op[i]);
+
+                if (header.decoder_model_present_for_this_op[i] === 1) {
+                    const n = header.buffer_delay_length_minus_1 + 1;
+
+                    writer.f(n, header.decoder_buffer_delay[i]);
+                    writer.f(n, header.encoder_buffer_delay[i]);
+                    writer.f(1, header.low_delay_mode_flag[i]);
+                }
+            }
+
+            if (header.initial_display_delay_present_flag === 1) {
+                writer.f(1, header.initial_display_delay_present_for_this_op[i]);
+
+                if (header.initial_display_delay_present_for_this_op[i] === 1) {
+                    writer.f(4, header.initial_display_delay_minus_1[i]);
+                }
+            }
+        }
+    }
+
+    writer.f(4, header.frame_width_bits_minus_1);
+    writer.f(4, header.frame_height_bits_minus_1);
+    writer.f(header.frame_width_bits_minus_1 + 1, header.max_frame_width_minus_1);
+    writer.f(header.frame_height_bits_minus_1 + 1, header.max_frame_height_minus_1);
+
+    if (header.reduced_still_picture_header === 0) {
+        writer.f(1, header.frame_id_numbers_present_flag);
+    }
+
+    if (header.frame_id_numbers_present_flag === 1) {
+        writer.f(4, header.delta_frame_id_length_minus_2);
+        writer.f(3, header.additional_frame_id_length_minus_1);
+    }
+
+    writer.f(1, header.use_128x128_superblock);
+    writer.f(1, header.enable_filter_intra);
+    writer.f(1, header.enable_intra_edge_filter);
+
+    if (header.reduced_still_picture_header === 0) {
+        writer.f(1, header.enable_interintra_compound);
+        writer.f(1, header.enable_masked_compound);
+        writer.f(1, header.enable_warped_motion);
+        writer.f(1, header.enable_dual_filter);
+        writer.f(1, header.enable_order_hint);
+
+        if (header.enable_order_hint === 1) {
+            writer.f(1, header.enable_jnt_comp);
+            writer.f(1, header.enable_ref_frame_mvs);
+        }
+
+        writer.f(1, header.seq_choose_screen_content_tools);
+
+        if (header.seq_choose_screen_content_tools === 0) {
+            writer.f(1, header.seq_force_screen_content_tools);
+        }
+
+        if (header.seq_force_screen_content_tools > 0) {
+            writer.f(1, header.seq_choose_integer_mv);
+
+            if (header.seq_choose_integer_mv === 0) {
+                writer.f(1, header.seq_force_integer_mv);
+            }
+        }
+
+        if (header.enable_order_hint === 1) {
+            writer.f(3, header.order_hint_bits_minus_1);
+        }
+    }
+
+    writer.f(1, header.enable_superres);
+    writer.f(1, header.enable_cdef);
+    writer.f(1, header.enable_restoration);
+
+    write_color_config(writer, header);
+
+    writer.f(1, header.film_grain_params_present);
+}
+
+/**
+ * @param {BitWriter} writer
+ * @param {SequenceHeader} header
+ * @see AV1 spec 5.5.2 "Color config syntax"
+ */
+function write_color_config(writer, header) {
+    writer.f(1, header.high_bitdepth);
+
+    if (header.seq_profile === 2 && header.high_bitdepth === 1) {
+        writer.f(1, header.twelve_bit);
+    }
+
+    if (header.seq_profile !== 1) {
+        writer.f(1, header.mono_chrome);
+    }
+
+    writer.f(1, header.color_description_present_flag);
+
+    if (header.color_description_present_flag === 1) {
+        writer.f(8, header.color_primaries);
+        writer.f(8, header.transfer_characteristics);
+        writer.f(8, header.matrix_coefficients);
+    }
+
+    if (header.mono_chrome === 1) {
+        writer.f(1, header.color_range);
+
+        return;
+    }
+
+    if (header.color_primaries === CP_BT_709
+        && header.transfer_characteristics === TC_SRGB
+        && header.matrix_coefficients === MC_IDENTITY) {
+        // this combination codes neither range nor subsampling
+    } else {
+        writer.f(1, header.color_range);
+
+        if (header.seq_profile === 2 && header.bit_depth === 12) {
+            writer.f(1, header.subsampling_x);
+
+            if (header.subsampling_x === 1) {
+                writer.f(1, header.subsampling_y);
+            }
+        }
+
+        if (header.subsampling_x === 1 && header.subsampling_y === 1) {
+            writer.f(2, header.chroma_sample_position);
+        }
+    }
+
+    writer.f(1, header.separate_uv_delta_q);
+}

package/src/avif/native/av1/predict/IntraPredictionState.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Where index `0` of an edge buffer sits.
+ *
+ * The specification indexes `AboveRow` and `LeftCol` from `-2`: `-1` is the corner sample, and the
+ * upsample process writes one further back still. Shifting every access by a constant is cheaper
+ * and clearer than carrying two arrays.
+ * @type {number}
+ */
+export const EDGE_ORIGIN: number;
+/**
+ * Entries an edge buffer must hold.
+ *
+ * `AboveRow` runs to `w + h - 1`, at most 127. Upsampling doubles that reach to `2 * numPx - 2`,
+ * with `numPx` at most 128, so index 254 is addressable. Plus the two negative entries and one for
+ * the interpolation's `base + 1` read at the far end.
+ * @type {number}
+ */
+export const EDGE_CAPACITY: number;
+/**
+ * Everything the intra prediction process needs beyond the pixels themselves.
+ *
+ * Allocated once per decode and refilled per block, so prediction allocates nothing. Keeping it a
+ * struct rather than a reference to the tile decoder is what lets `predict/` stay independent of
+ * the decoder's state, as the module contract requires.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class IntraPredictionState {
+    /** @type {Int32Array} `AboveRow`, offset by {@link EDGE_ORIGIN} */
+    above: Int32Array;
+    /** @type {Int32Array} `LeftCol`, offset by {@link EDGE_ORIGIN} */
+    left: Int32Array;
+    /** @type {Int32Array} scratch for the upsample process */
+    upsample_scratch: Int32Array;
+    /** @type {number} */
+    bit_depth: number;
+    /** @type {number} from the sequence header */
+    enable_intra_edge_filter: number;
+    /** @type {number} `AngleDeltaY` or `AngleDeltaUV`, per the plane being predicted */
+    angle_delta: number;
+    /** @type {number} `1` when the block uses recursive filter intra prediction */
+    use_filter_intra: number;
+    /** @type {number} */
+    filter_intra_mode: number;
+    /** @type {number} `1` when a neighbouring block used a smooth mode */
+    filter_type: number;
+}
+//# sourceMappingURL=IntraPredictionState.d.ts.map

package/src/avif/native/av1/predict/IntraPredictionState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntraPredictionState.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/predict/IntraPredictionState.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,0BAFU,MAAM,CAEa;AAE7B;;;;;;;GAOG;AACH,4BAFU,MAAM,CAE+B;AAE/C;;;;;;;;;GASG;AACH;IACI,mEAAmE;IACnE,OADW,UAAU,CACiB;IAEtC,kEAAkE;IAClE,MADW,UAAU,CACgB;IAErC,0DAA0D;IAC1D,kBADW,UAAU,CACgC;IAErD,qBAAqB;IACrB,WADW,MAAM,CACH;IAEd,8CAA8C;IAC9C,0BADW,MAAM,CACY;IAE7B,oFAAoF;IACpF,aADW,MAAM,CACD;IAEhB,+EAA+E;IAC/E,kBADW,MAAM,CACI;IAErB,qBAAqB;IACrB,mBADW,MAAM,CACK;IAEtB,sEAAsE;IACtE,aADW,MAAM,CACD;CACnB"}

package/src/avif/native/av1/predict/IntraPredictionState.js

@@ -0,0 +1,58 @@
+/**
+ * Where index `0` of an edge buffer sits.
+ *
+ * The specification indexes `AboveRow` and `LeftCol` from `-2`: `-1` is the corner sample, and the
+ * upsample process writes one further back still. Shifting every access by a constant is cheaper
+ * and clearer than carrying two arrays.
+ * @type {number}
+ */
+export const EDGE_ORIGIN = 2;
+
+/**
+ * Entries an edge buffer must hold.
+ *
+ * `AboveRow` runs to `w + h - 1`, at most 127. Upsampling doubles that reach to `2 * numPx - 2`,
+ * with `numPx` at most 128, so index 254 is addressable. Plus the two negative entries and one for
+ * the interpolation's `base + 1` read at the far end.
+ * @type {number}
+ */
+export const EDGE_CAPACITY = EDGE_ORIGIN + 256;
+
+/**
+ * Everything the intra prediction process needs beyond the pixels themselves.
+ *
+ * Allocated once per decode and refilled per block, so prediction allocates nothing. Keeping it a
+ * struct rather than a reference to the tile decoder is what lets `predict/` stay independent of
+ * the decoder's state, as the module contract requires.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class IntraPredictionState {
+    /** @type {Int32Array} `AboveRow`, offset by {@link EDGE_ORIGIN} */
+    above = new Int32Array(EDGE_CAPACITY);
+
+    /** @type {Int32Array} `LeftCol`, offset by {@link EDGE_ORIGIN} */
+    left = new Int32Array(EDGE_CAPACITY);
+
+    /** @type {Int32Array} scratch for the upsample process */
+    upsample_scratch = new Int32Array(EDGE_CAPACITY + 4);
+
+    /** @type {number} */
+    bit_depth = 8;
+
+    /** @type {number} from the sequence header */
+    enable_intra_edge_filter = 1;
+
+    /** @type {number} `AngleDeltaY` or `AngleDeltaUV`, per the plane being predicted */
+    angle_delta = 0;
+
+    /** @type {number} `1` when the block uses recursive filter intra prediction */
+    use_filter_intra = 0;
+
+    /** @type {number} */
+    filter_intra_mode = 0;
+
+    /** @type {number} `1` when a neighbouring block used a smooth mode */
+    filter_type = 0;
+}

package/src/avif/native/av1/predict/intra_filter_type.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Whether a block's intra edge should be filtered smoothly.
+ *
+ * Shared between the decoder and the encoder: the encoder predicts with exactly the same edge the
+ * decoder will, or its residual would be a residual against a different picture.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @returns {number}
+ * @see AV1 spec 7.11.2.8 "Intra filter type process"
+ */
+export function get_filter_type(ctx: Av1FrameContext, plane: number): number;
+//# sourceMappingURL=intra_filter_type.d.ts.map

package/src/avif/native/av1/predict/intra_filter_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intra_filter_type.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/predict/intra_filter_type.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,6DAJW,MAAM,GACJ,MAAM,CA4ClB"}

package/src/avif/native/av1/predict/intra_filter_type.js

@@ -0,0 +1,79 @@
+import { is_smooth_mode } from "./predict_intra.js";
+
+/**
+ * Whether a block's intra edge should be filtered smoothly.
+ *
+ * Shared between the decoder and the encoder: the encoder predicts with exactly the same edge the
+ * decoder will, or its residual would be a residual against a different picture.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} plane
+ * @returns {number}
+ * @see AV1 spec 7.11.2.8 "Intra filter type process"
+ */
+export function get_filter_type(ctx, plane) {
+    const stride = ctx.mi_stride;
+
+    let above_smooth = 0;
+    let left_smooth = 0;
+
+    if ((plane === 0 ? ctx.avail_u : ctx.avail_u_chroma) === 1) {
+        let r = ctx.mi_row - 1;
+        let c = ctx.mi_col;
+
+        if (plane > 0) {
+            if (ctx.subsampling_x === 1 && (ctx.mi_col & 1) === 0) {
+                c++;
+            }
+
+            if (ctx.subsampling_y === 1 && (ctx.mi_row & 1) === 1) {
+                r--;
+            }
+        }
+
+        above_smooth = is_smooth_at(ctx, r, c, plane) ? 1 : 0;
+    }
+
+    if ((plane === 0 ? ctx.avail_l : ctx.avail_l_chroma) === 1) {
+        let r = ctx.mi_row;
+        let c = ctx.mi_col - 1;
+
+        if (plane > 0) {
+            if (ctx.subsampling_x === 1 && (ctx.mi_col & 1) === 1) {
+                c--;
+            }
+
+            if (ctx.subsampling_y === 1 && (ctx.mi_row & 1) === 0) {
+                r++;
+            }
+        }
+
+        left_smooth = is_smooth_at(ctx, r, c, plane) ? 1 : 0;
+    }
+
+    return above_smooth !== 0 || left_smooth !== 0 ? 1 : 0;
+}
+
+/**
+ * @param {Av1FrameContext} ctx
+ * @param {number} row
+ * @param {number} col
+ * @param {number} plane
+ * @returns {boolean}
+ */
+function is_smooth_at(ctx, row, col, plane) {
+    if (row < 0 || col < 0 || row >= ctx.mi_rows || col >= ctx.mi_cols) {
+        return false;
+    }
+
+    const index = row * ctx.mi_stride + col;
+
+    const mode = plane === 0 ? ctx.y_modes[index] : ctx.uv_modes[index];
+
+    return is_smooth_mode(mode);
+}

package/src/avif/native/av1/predict/predict_chroma_from_luma.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Reduce the reconstructed luma under a chroma transform block to what chroma is predicted from.
+ *
+ * Subsampled the way the chroma plane is, carried at three fractional bits, and with its own average
+ * removed — so what is left is the shape of the luma and not its level, which is what a chroma
+ * block wants to borrow. The block's own DC prediction supplies the level.
+ *
+ * Shared with the encoder, which fits the scaling factor against exactly these numbers. Fitting
+ * against anything else would be fitting to a prediction the decoder does not make.
+ *
+ * @param {Uint16Array} luma
+ * @param {number} luma_stride
+ * @param {number} start_x left edge of the chroma transform block
+ * @param {number} start_y
+ * @param {number} tx_size
+ * @param {number} subsampling_x
+ * @param {number} subsampling_y
+ * @param {number} max_luma_w largest luma width available for this block
+ * @param {number} max_luma_h
+ * @returns {Int32Array} `w * h` of it, valid until the next call
+ * @see AV1 spec 7.11.5, the part before the scaling
+ */
+export function chroma_from_luma_ac(luma: Uint16Array, luma_stride: number, start_x: number, start_y: number, tx_size: number, subsampling_x: number, subsampling_y: number, max_luma_w: number, max_luma_h: number): Int32Array;
+/**
+ * Add the high frequencies of the reconstructed luma to an already DC-predicted chroma block.
+ *
+ * The chroma block must already hold its DC prediction: this process reads it back, adds a scaled
+ * copy of the luma's deviation from its own average, and writes the sum. That is why it is a
+ * separate step rather than another mode inside `predict_intra`.
+ *
+ * @param {Uint16Array} chroma the plane being predicted
+ * @param {number} chroma_stride
+ * @param {Uint16Array} luma
+ * @param {number} luma_stride
+ * @param {number} start_x left edge of the chroma transform block
+ * @param {number} start_y top edge of the chroma transform block
+ * @param {number} tx_size
+ * @param {number} alpha `CflAlphaU` or `CflAlphaV`
+ * @param {number} subsampling_x
+ * @param {number} subsampling_y
+ * @param {number} max_luma_w largest luma width available for this block
+ * @param {number} max_luma_h largest luma height available for this block
+ * @param {number} bit_depth
+ * @see AV1 spec 7.11.5 "Predict chroma from luma process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function predict_chroma_from_luma(chroma: Uint16Array, chroma_stride: number, luma: Uint16Array, luma_stride: number, start_x: number, start_y: number, tx_size: number, alpha: number, subsampling_x: number, subsampling_y: number, max_luma_w: number, max_luma_h: number, bit_depth: number): void;
+//# sourceMappingURL=predict_chroma_from_luma.d.ts.map

package/src/avif/native/av1/predict/predict_chroma_from_luma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predict_chroma_from_luma.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/predict/predict_chroma_from_luma.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,0CAZW,WAAW,eACX,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,iBACN,MAAM,iBACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,UAAU,CAoDtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,iDAlBW,WAAW,iBACX,MAAM,QACN,WAAW,eACX,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,SACN,MAAM,iBACN,MAAM,iBACN,MAAM,cACN,MAAM,cACN,MAAM,aACN,MAAM,QA+ChB"}

package/src/avif/native/av1/predict/predict_chroma_from_luma.js

@@ -0,0 +1,153 @@
+import { clamp } from "../../../../core/math/clamp.js";
+import { TX_HEIGHT, TX_HEIGHT_LOG2, TX_WIDTH, TX_WIDTH_LOG2 } from "../tables/block_tables.js";
+import { round2 } from "../util/round2.js";
+import { round2_signed } from "../util/round2_signed.js";
+
+/**
+ * Subsampled luma, with three fractional bits and its own average taken out, for one chroma
+ * transform block. Sized for the largest chroma transform, and module-level so prediction allocates
+ * nothing.
+ * @type {Int32Array}
+ */
+const LUMA_SCRATCH = new Int32Array(32 * 32);
+
+/**
+ * Reduce the reconstructed luma under a chroma transform block to what chroma is predicted from.
+ *
+ * Subsampled the way the chroma plane is, carried at three fractional bits, and with its own average
+ * removed — so what is left is the shape of the luma and not its level, which is what a chroma
+ * block wants to borrow. The block's own DC prediction supplies the level.
+ *
+ * Shared with the encoder, which fits the scaling factor against exactly these numbers. Fitting
+ * against anything else would be fitting to a prediction the decoder does not make.
+ *
+ * @param {Uint16Array} luma
+ * @param {number} luma_stride
+ * @param {number} start_x left edge of the chroma transform block
+ * @param {number} start_y
+ * @param {number} tx_size
+ * @param {number} subsampling_x
+ * @param {number} subsampling_y
+ * @param {number} max_luma_w largest luma width available for this block
+ * @param {number} max_luma_h
+ * @returns {Int32Array} `w * h` of it, valid until the next call
+ * @see AV1 spec 7.11.5, the part before the scaling
+ */
+export function chroma_from_luma_ac(
+    luma,
+    luma_stride,
+    start_x,
+    start_y,
+    tx_size,
+    subsampling_x,
+    subsampling_y,
+    max_luma_w,
+    max_luma_h
+) {
+    const w = TX_WIDTH[tx_size];
+    const h = TX_HEIGHT[tx_size];
+
+    let luma_average = 0;
+
+    for (let i = 0; i < h; i++) {
+        let luma_y = (start_y + i) << subsampling_y;
+
+        luma_y = Math.min(luma_y, max_luma_h - (1 << subsampling_y));
+
+        for (let j = 0; j < w; j++) {
+            let luma_x = (start_x + j) << subsampling_x;
+
+            luma_x = Math.min(luma_x, max_luma_w - (1 << subsampling_x));
+
+            let t = 0;
+
+            for (let dy = 0; dy <= subsampling_y; dy++) {
+                for (let dx = 0; dx <= subsampling_x; dx++) {
+                    t += luma[(luma_y + dy) * luma_stride + luma_x + dx];
+                }
+            }
+
+            // three fractional bits, less however many the subsampling sum already contributed
+            const v = t << (3 - subsampling_x - subsampling_y);
+
+            LUMA_SCRATCH[i * w + j] = v;
+            luma_average += v;
+        }
+    }
+
+    luma_average = round2(luma_average, TX_WIDTH_LOG2[tx_size] + TX_HEIGHT_LOG2[tx_size]);
+
+    for (let i = 0; i < w * h; i++) {
+        LUMA_SCRATCH[i] -= luma_average;
+    }
+
+    return LUMA_SCRATCH;
+}
+
+/**
+ * Add the high frequencies of the reconstructed luma to an already DC-predicted chroma block.
+ *
+ * The chroma block must already hold its DC prediction: this process reads it back, adds a scaled
+ * copy of the luma's deviation from its own average, and writes the sum. That is why it is a
+ * separate step rather than another mode inside `predict_intra`.
+ *
+ * @param {Uint16Array} chroma the plane being predicted
+ * @param {number} chroma_stride
+ * @param {Uint16Array} luma
+ * @param {number} luma_stride
+ * @param {number} start_x left edge of the chroma transform block
+ * @param {number} start_y top edge of the chroma transform block
+ * @param {number} tx_size
+ * @param {number} alpha `CflAlphaU` or `CflAlphaV`
+ * @param {number} subsampling_x
+ * @param {number} subsampling_y
+ * @param {number} max_luma_w largest luma width available for this block
+ * @param {number} max_luma_h largest luma height available for this block
+ * @param {number} bit_depth
+ * @see AV1 spec 7.11.5 "Predict chroma from luma process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function predict_chroma_from_luma(
+    chroma,
+    chroma_stride,
+    luma,
+    luma_stride,
+    start_x,
+    start_y,
+    tx_size,
+    alpha,
+    subsampling_x,
+    subsampling_y,
+    max_luma_w,
+    max_luma_h,
+    bit_depth
+) {
+    const w = TX_WIDTH[tx_size];
+    const h = TX_HEIGHT[tx_size];
+
+    const max_value = (1 << bit_depth) - 1;
+
+    const ac = chroma_from_luma_ac(
+        luma,
+        luma_stride,
+        start_x,
+        start_y,
+        tx_size,
+        subsampling_x,
+        subsampling_y,
+        max_luma_w,
+        max_luma_h
+    );
+
+    for (let i = 0; i < h; i++) {
+        const row = (start_y + i) * chroma_stride + start_x;
+
+        for (let j = 0; j < w; j++) {
+            const scaled = round2_signed(alpha * ac[i * w + j], 6);
+
+            chroma[row + j] = clamp(chroma[row + j] + scaled, 0, max_value);
+        }
+    }
+}

package/src/avif/native/av1/predict/predict_intra.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Whether `mode` predicts along an angle.
+ * @param {number} mode
+ * @returns {boolean}
+ * @see AV1 spec 7.11.2 "Intra prediction process"
+ */
+export function is_directional_mode(mode: number): boolean;
+/**
+ * Whether `mode` is one of the smooth modes, which is what `get_filter_type` tests for.
+ * @param {number} mode
+ * @returns {boolean}
+ */
+export function is_smooth_mode(mode: number): boolean;
+/**
+ * Intra-predict a transform block, writing the prediction straight into the plane.
+ *
+ * The specification builds a `pred` array and copies it into `CurrFrame` afterwards. Writing
+ * directly is equivalent and saves the copy: the only process that reads back what it has already
+ * predicted is the recursive filter, and the samples it reads are exactly the ones just written.
+ *
+ * @param {IntraPredictionState} state
+ * @param {Uint16Array} plane samples of the plane being predicted
+ * @param {number} stride
+ * @param {number} plane_index `0` luma, `1` U, `2` V
+ * @param {number} x left edge of the transform block, in samples
+ * @param {number} y top edge of the transform block, in samples
+ * @param {number} max_x largest valid x coordinate in this plane
+ * @param {number} max_y largest valid y coordinate in this plane
+ * @param {number} have_left
+ * @param {number} have_above
+ * @param {number} have_above_right
+ * @param {number} have_below_left
+ * @param {number} mode
+ * @param {number} log2_w
+ * @param {number} log2_h
+ * @see AV1 spec 7.11.2 "Intra prediction process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function predict_intra(state: IntraPredictionState, plane: Uint16Array, stride: number, plane_index: number, x: number, y: number, max_x: number, max_y: number, have_left: number, have_above: number, have_above_right: number, have_below_left: number, mode: number, log2_w: number, log2_h: number): void;
+//# sourceMappingURL=predict_intra.d.ts.map

package/src/avif/native/av1/predict/predict_intra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predict_intra.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/predict/predict_intra.js"],"names":[],"mappings":"AAyCA;;;;;GAKG;AACH,0CAJW,MAAM,GACJ,OAAO,CAKnB;AAED;;;;GAIG;AACH,qCAHW,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,kEAnBW,WAAW,UACX,MAAM,eACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,SACN,MAAM,aACN,MAAM,cACN,MAAM,oBACN,MAAM,mBACN,MAAM,QACN,MAAM,UACN,MAAM,UACN,MAAM,QA0DhB"}