@woosh/meep-engine 3.14.1 → 3.14.3

package/src/avif/native/av1/transform/inverse_transform_2d.js

@@ -1,180 +0,0 @@
-import { clamp } from "../../../../core/math/clamp.js";
-import {
-    ADST_ADST,
-    ADST_DCT,
-    ADST_FLIPADST,
-    DCT_ADST,
-    DCT_DCT,
-    DCT_FLIPADST,
-    FLIPADST_ADST,
-    FLIPADST_DCT,
-    FLIPADST_FLIPADST,
-    H_ADST,
-    H_DCT,
-    H_FLIPADST,
-    V_ADST,
-    V_DCT,
-    V_FLIPADST
-} from "../tables/av1_symbols.js";
-import { TRANSFORM_ROW_SHIFT } from "../tables/transform_tables.js";
-import { TX_HEIGHT_LOG2, TX_WIDTH_LOG2 } from "../tables/block_tables.js";
-import { round2 } from "../util/round2.js";
-import { inverse_adst, inverse_dct, inverse_identity, inverse_wht, round2_12 } from "./inverse_transform_1d.js";
-
-/**
- * Whether the row (horizontal) transform for `tx_type` is a DCT. Exported because the encoder's
- * forward transform has to be the inverse of whichever pair this picks.
- * @param {number} tx_type
- * @returns {boolean}
- */
-export function row_is_dct(tx_type) {
-    return tx_type === DCT_DCT || tx_type === ADST_DCT || tx_type === FLIPADST_DCT || tx_type === H_DCT;
-}
-
-/**
- * Whether the row (horizontal) transform for `tx_type` is an ADST.
- * @param {number} tx_type
- * @returns {boolean}
- */
-export function row_is_adst(tx_type) {
-    return tx_type === DCT_ADST
-        || tx_type === ADST_ADST
-        || tx_type === DCT_FLIPADST
-        || tx_type === FLIPADST_FLIPADST
-        || tx_type === ADST_FLIPADST
-        || tx_type === FLIPADST_ADST
-        || tx_type === H_ADST
-        || tx_type === H_FLIPADST;
-}
-
-/**
- * Whether the column (vertical) transform for `tx_type` is a DCT.
- * @param {number} tx_type
- * @returns {boolean}
- */
-export function column_is_dct(tx_type) {
-    return tx_type === DCT_DCT || tx_type === DCT_ADST || tx_type === DCT_FLIPADST || tx_type === V_DCT;
-}
-
-/**
- * Whether the column (vertical) transform for `tx_type` is an ADST.
- * @param {number} tx_type
- * @returns {boolean}
- */
-export function column_is_adst(tx_type) {
-    return tx_type === ADST_DCT
-        || tx_type === ADST_ADST
-        || tx_type === FLIPADST_DCT
-        || tx_type === FLIPADST_FLIPADST
-        || tx_type === ADST_FLIPADST
-        || tx_type === FLIPADST_ADST
-        || tx_type === V_ADST
-        || tx_type === V_FLIPADST;
-}
-
-/**
- * 2D inverse transform, in place.
- *
- * `residual` holds the dequantised coefficients on entry, row-major with stride `1 << log2W`, and
- * the spatial residual on exit. Coefficients only ever occupy the top-left 32x32 of a block, and
- * the caller is responsible for having zeroed the rest — the specification reads those positions as
- * zero rather than as whatever was left there.
- *
- * @param {Int32Array} residual
- * @param {number} tx_size
- * @param {number} tx_type
- * @param {number} lossless `1` to use the Walsh-Hadamard transform
- * @param {number} bit_depth
- * @param {Int32Array} t scratch of at least 64 entries
- * @see AV1 spec 7.13.3 "2D inverse transform process"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function inverse_transform_2d(residual, tx_size, tx_type, lossless, bit_depth, t) {
-    const log2_w = TX_WIDTH_LOG2[tx_size];
-    const log2_h = TX_HEIGHT_LOG2[tx_size];
-
-    const w = 1 << log2_w;
-    const h = 1 << log2_h;
-
-    const row_shift = lossless === 1 ? 0 : TRANSFORM_ROW_SHIFT[tx_size];
-    const column_shift = lossless === 1 ? 0 : 4;
-
-    const row_clamp_range = bit_depth + 8;
-    const column_clamp_range = Math.max(bit_depth + 6, 16);
-
-    // a transform whose sides differ by a factor of two carries an extra 1/sqrt(2) so that the
-    // basis stays orthonormal; it is folded into the row pass
-    const rectangular = Math.abs(log2_w - log2_h) === 1;
-
-    for (let i = 0; i < h; i++) {
-        const row = i * w;
-
-        let occupied = 0;
-
-        for (let j = 0; j < w; j++) {
-            const coefficient = i < 32 && j < 32 ? residual[row + j] : 0;
-
-            t[j] = coefficient;
-            occupied |= coefficient;
-        }
-
-        // every step of every one of these transforms is a multiply and a rounded shift of its
-        // inputs, and none of them adds a constant, so a row of zeros comes out of all of them as a
-        // row of zeros. Past the end of a block a quantiser emptied that is most of the rows, and
-        // finding out costs one comparison per coefficient against the whole transform it skips
-        if (occupied === 0) {
-            residual.fill(0, row, row + w);
-
-            continue;
-        }
-
-        if (rectangular) {
-            for (let j = 0; j < w; j++) {
-                t[j] = round2_12(t[j] * 2896);
-            }
-        }
-
-        if (lossless === 1) {
-            inverse_wht(t, 2);
-        } else if (row_is_dct(tx_type)) {
-            inverse_dct(t, log2_w, row_clamp_range);
-        } else if (row_is_adst(tx_type)) {
-            inverse_adst(t, log2_w, row_clamp_range);
-        } else {
-            inverse_identity(t, log2_w);
-        }
-
-        for (let j = 0; j < w; j++) {
-            residual[row + j] = round2(t[j], row_shift);
-        }
-    }
-
-    const column_low = -(1 << (column_clamp_range - 1));
-    const column_high = (1 << (column_clamp_range - 1)) - 1;
-
-    for (let i = 0; i < h * w; i++) {
-        residual[i] = clamp(residual[i], column_low, column_high);
-    }
-
-    for (let j = 0; j < w; j++) {
-        for (let i = 0; i < h; i++) {
-            t[i] = residual[i * w + j];
-        }
-
-        if (lossless === 1) {
-            inverse_wht(t, 0);
-        } else if (column_is_dct(tx_type)) {
-            inverse_dct(t, log2_h, column_clamp_range);
-        } else if (column_is_adst(tx_type)) {
-            inverse_adst(t, log2_h, column_clamp_range);
-        } else {
-            inverse_identity(t, log2_h);
-        }
-
-        for (let i = 0; i < h; i++) {
-            residual[i * w + j] = round2(t[i], column_shift);
-        }
-    }
-}

package/src/avif/native/av1/util/ceil_log2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ceil_log2.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/ceil_log2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,6BAPW,MAAM,GACJ,MAAM,CAYlB"}

package/src/avif/native/av1/util/floor_log2.d.ts

@@ -1,20 +0,0 @@
-/**
- * `FloorLog2( x )` from the AV1 specification: the position of the most significant set bit.
- *
- * The specification guarantees `x >= 1` at every call site. `x === 0` returns `-1` here rather than
- * throwing, matching what the specification's own shift-loop definition would produce, so a caller
- * that reaches it with zero fails on the resulting index rather than being masked by a clamp.
- *
- * The core primitive under its own name: `msb_32` is the same operation, and the alias exists so
- * that code transliterated from the specification can be read against it.
- *
- * @param {number} x 32-bit unsigned integer
- * @returns {number}
- * @see AV1 spec 4.7 "Mathematical functions"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export const floor_log2: typeof msb_32;
-import { msb_32 } from "../../../../core/binary/msb_32.js";
-//# sourceMappingURL=floor_log2.d.ts.map

package/src/avif/native/av1/util/floor_log2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"floor_log2.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/floor_log2.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAAiC;uBAnBV,mCAAmC"}

package/src/avif/native/av1/util/floor_log2.js

@@ -1,20 +0,0 @@
-import { msb_32 } from "../../../../core/binary/msb_32.js";
-
-/**
- * `FloorLog2( x )` from the AV1 specification: the position of the most significant set bit.
- *
- * The specification guarantees `x >= 1` at every call site. `x === 0` returns `-1` here rather than
- * throwing, matching what the specification's own shift-loop definition would produce, so a caller
- * that reaches it with zero fails on the resulting index rather than being masked by a clamp.
- *
- * The core primitive under its own name: `msb_32` is the same operation, and the alias exists so
- * that code transliterated from the specification can be read against it.
- *
- * @param {number} x 32-bit unsigned integer
- * @returns {number}
- * @see AV1 spec 4.7 "Mathematical functions"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export const floor_log2 = msb_32;

package/src/avif/native/av1/util/round2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"round2.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/round2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0BARW,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB"}

package/src/avif/native/av1/util/round2_signed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"round2_signed.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/round2_signed.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,iCARW,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB"}

package/src/avif/native/av1/util/tile_log2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tile_log2.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/tile_log2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,sCARW,MAAM,UACN,MAAM,GACJ,MAAM,CAclB"}

package/src/avif/native/bitstream/BitReader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BitReader.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/bitstream/BitReader.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACI;;;OAGG;IACH,MAFU,UAAU,CAER;IAEZ;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,KAFU,MAAM,CAER;IAER;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;;OAQG;IACH,WALW,UAAU,gBACV,MAAM,gBACN,MAAM,GACJ,SAAS,CAerB;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,YAFa,MAAM,CAiBlB;IAED;;;;;;;;;;OAUG;IACH,KAJW,MAAM,GACJ,MAAM,CA6ClB;IAED;;;;;;OAMG;IACH,MAJW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;OAOG;IACH,MAJW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;;;;;OASG;IACH,QAHa,MAAM,CAkBlB;IAED;;;;;;OAMG;IACH,MAJW,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;;;;;;;OAUG;IACH,UAHa,MAAM,CAqClB;IAED;;;;;OAKG;IACH,uBAMC;IAED;;;;OAIG;IACH,sBAUC;IAED;;;;;;;;OAQG;IACH,8BAIC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAYhB;CACJ"}

package/src/avif/native/bitstream/BitWriter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BitWriter.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/bitstream/BitWriter.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH;IACI;;;OAGG;IACH,MAFU,UAAU,CAEoB;IAExC;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,SAFa,SAAS,CAQrB;IAED;;;OAGG;IACH,+BAEC;IAED;;OAEG;IACH,+BAEC;IAwBD;;;OAGG;IACH,eAFW,MAAM,QAmBhB;IAED;;;;;;;;OAQG;IACH,KAHW,MAAM,SACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,MAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,MAHW,MAAM,SACN,MAAM,QAoBhB;IAED;;;OAGG;IACH,YAFW,MAAM,QAuBhB;IAED;;;;OAIG;IACH,MAHW,MAAM,SACN,MAAM,QAkBhB;IAED;;;;;;;;;OASG;IACH,cAHW,MAAM,eACN,MAAM,QAiChB;IAED;;;OAGG;IACH,uBAIC;IAED;;;OAGG;IACH,sBAIC;IAED;;;;;OAKG;IACH,mBAJW,UAAU,WACV,MAAM,WACN,MAAM,QAahB;IAED;;;;;;;;OAQG;IACH,YAFa,UAAU,CAMtB;;CACJ"}

package/src/avif/native/color/ColourTransform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ColourTransform.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/ColourTransform.js"],"names":[],"mappings":"AAiFA;;;;;;;;;;;;;;;GAeG;AACH,iDAPW,eAAe,uBACf,MAAM,mBACN,MAAM,eACN,MAAM,aACN,MAAM,QA8FhB;AA1KD;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AASlC;;;;;;;;GAQG;AACH;IACI,yDAAyD;IACzD,MADW,MAAM,CACQ;IAEzB,mDAAmD;IACnD,UADW,MAAM,CACJ;IAEb,kGAAkG;IAClG,SADW,MAAM,CACL;IAEZ,kEAAkE;IAClE,UADW,MAAM,CACJ;IAEb,0EAA0E;IAC1E,SADW,MAAM,CACL;IAEZ,qBAAqB;IACrB,SADW,MAAM,CACL;IAEZ,qBAAqB;IACrB,SADW,MAAM,CACL;IAEZ,qBAAqB;IACrB,SADW,MAAM,CACL;IAEZ,qBAAqB;IACrB,SADW,MAAM,CACL;CACf"}

package/src/avif/native/color/YuvImage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"YuvImage.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/YuvImage.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH;IACI,mFAAmF;IACnF,QADW,WAAW,EAAE,CACI;IAE5B,yEAAyE;IACzE,QADW,UAAU,CACM;IAE3B,qBAAqB;IACrB,OADW,MAAM,CACP;IAEV,qBAAqB;IACrB,QADW,MAAM,CACN;IAEX,uCAAuC;IACvC,WADW,MAAM,CACH;IAEd,qBAAqB;IACrB,eADW,MAAM,CACC;IAElB,qBAAqB;IACrB,eADW,MAAM,CACC;IAElB,wCAAwC;IACxC,YADW,MAAM,CACF;IAEf,mCAAmC;IACnC,iBADW,MAAM,CACG;IAEpB,mCAAmC;IACnC,0BADW,MAAM,CACY;IAE7B,oCAAoC;IACpC,qBADW,MAAM,CACO;IAExB,8EAA8E;IAC9E,aADW,MAAM,CACD;IAEhB,gGAAgG;IAChG,OADW,WAAW,GAAC,IAAI,CACd;IAEb,qBAAqB;IACrB,cADW,MAAM,CACA;IAEjB,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB,qBAAqB;IACrB,aADW,MAAM,CACD;IAEhB;;;OAGG;IACH,qBAHU,MAAM,CAGQ;CAC3B"}

package/src/avif/native/color/clamp_sample.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clamp_sample.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/clamp_sample.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,oCAPW,MAAM,WACN,MAAM,GACJ,MAAM,CAalB"}

package/src/avif/native/color/linear_to_transfer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"linear_to_transfer.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/linear_to_transfer.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;GAaG;AACH,6DARW,MAAM,SACN,MAAM,GACJ,MAAM,CA4ClB;AAED;;;;;;GAMG;AACH,mEAJW,MAAM,OACN,YAAY,SACZ,MAAM,QA0BhB"}

package/src/avif/native/color/linear_to_transfer.js

@@ -1,126 +0,0 @@
-import { HLG_PEAK_NITS, LINEAR_REFERENCE_NITS } from "./transfer_to_linear.js";
-import { PQ_MAX_NITS } from "../../../core/color/PQ/PQ_constants.js";
-import {
-    TC_BT_470_B_G,
-    TC_BT_470_M,
-    TC_HLG,
-    TC_IEC_61966,
-    TC_LINEAR,
-    TC_SMPTE_2084,
-    TC_SMPTE_240,
-    TC_SMPTE_428,
-    TC_SRGB
-} from "../av1/tables/av1_symbols.js";
-import { convert_channel_linear_to_sRGB } from "../../../core/color/sRGB/linear_to_sRGB.js";
-import { linear_to_PQ } from "../../../core/color/PQ/linear_to_PQ.js";
-
-/** @type {number} */
-const HLG_A = 0.17883277;
-
-/** @type {number} */
-const HLG_B = 1 - 4 * HLG_A;
-
-/** @type {number} */
-const HLG_C = 0.5 - HLG_A * Math.log(4 * HLG_A);
-
-/**
- * Encode linear light as a signal value.
- *
- * The inverse of {@link transfer_to_linear}, in the same normalisation: `1.0` of linear light is
- * {@link LINEAR_REFERENCE_NITS}.
- *
- * @param {number} transfer_characteristics a `TC_*` code
- * @param {number} value linear light
- * @returns {number} signal, `0 .. 1`
- * @see ITU-T H.273 table 3 "Transfer characteristics"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function linear_to_transfer(transfer_characteristics, value) {
-    const light = value < 0 ? 0 : value;
-
-    switch (transfer_characteristics) {
-        case TC_SMPTE_2084:
-            return linear_to_PQ(Math.min(light * (LINEAR_REFERENCE_NITS / PQ_MAX_NITS), 1));
-
-        case TC_HLG:
-            return scene_linear_to_hlg(Math.min(light * (LINEAR_REFERENCE_NITS / HLG_PEAK_NITS), 1));
-
-        case TC_LINEAR:
-            return Math.min(light, 1);
-
-        case TC_SRGB:
-        case TC_IEC_61966:
-            return convert_channel_linear_to_sRGB(Math.min(light, 1));
-
-        case TC_BT_470_M:
-            return Math.pow(Math.min(light, 1), 1 / 2.2);
-
-        case TC_BT_470_B_G:
-            return Math.pow(Math.min(light, 1), 1 / 2.8);
-
-        case TC_SMPTE_428:
-            return Math.pow(Math.min(light * (48.0 / 52.37), 1), 1 / 2.6);
-
-        case TC_SMPTE_240: {
-            const clipped = Math.min(light, 1);
-
-            return clipped < 0.0228 ? clipped * 4.0 : 1.1115 * Math.pow(clipped, 0.45) - 0.1115;
-        }
-
-        default: {
-            const clipped = Math.min(light, 1);
-
-            return clipped < 0.018 ? clipped * 4.5 : 1.099 * Math.pow(clipped, 0.45) - 0.099;
-        }
-    }
-}
-
-/**
- * Encode a row of interleaved linear RGB as signal values, in place.
- *
- * @param {number} transfer_characteristics
- * @param {Float32Array} row interleaved, `width * 3` long
- * @param {number} width
- */
-export function transfer_row_from_linear(transfer_characteristics, row, width) {
-    const count = width * 3;
-
-    if (transfer_characteristics === TC_HLG) {
-        // undo the opto-optical transfer function before the per channel curve, since it is what
-        // took the picture from scene to display referred in the first place
-        const scale = LINEAR_REFERENCE_NITS / HLG_PEAK_NITS;
-
-        for (let i = 0; i < count; i += 3) {
-            const luminance = (0.2627 * row[i] + 0.6780 * row[i + 1] + 0.0593 * row[i + 2]) * scale;
-
-            const gain = luminance <= 0 ? 0 : Math.pow(luminance, -0.2 / 1.2);
-
-            for (let c = 0; c < 3; c++) {
-                row[i + c] = scene_linear_to_hlg(Math.min(Math.max(row[i + c] * scale * gain, 0), 1));
-            }
-        }
-
-        return;
-    }
-
-    for (let i = 0; i < count; i++) {
-        row[i] = linear_to_transfer(transfer_characteristics, row[i]);
-    }
-}
-
-/**
- * Hybrid log-gamma's opto-electronic transfer function.
- *
- * @param {number} scene scene linear, `0 .. 1`
- * @returns {number}
- * @see ITU-R BT.2100 table 5
- */
-function scene_linear_to_hlg(scene) {
-    if (scene <= 1 / 12) {
-        return Math.sqrt(3 * scene);
-    }
-
-    return HLG_A * Math.log(12 * scene - HLG_B) + HLG_C;
-}

package/src/avif/native/color/primaries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"primaries.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/primaries.js"],"names":[],"mappings":"AAwCA;;;;;GAKG;AACH,wDAHW,MAAM,GACJ,MAAM,EAAE,CAUpB;AAED;;;;;;;;;;GAUG;AACH,0DAJW,MAAM,OACN,YAAY,QA6BtB"}

package/src/avif/native/color/rgb_row_to_ycbcr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rgb_row_to_ycbcr.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/rgb_row_to_ycbcr.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,kEAVW,YAAY,SACZ,MAAM,QACN,WAAW,eACX,MAAM,MACN,YAAY,MACZ,YAAY,QA8DtB"}

package/src/avif/native/color/transfer_to_linear.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transfer_to_linear.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/transfer_to_linear.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;;;;;GAcG;AACH,6DARW,MAAM,SACN,MAAM,GACJ,MAAM,CAmDlB;AAED;;;;;;GAMG;AACH,iEAJW,MAAM,OACN,YAAY,SACZ,MAAM,QA+BhB;AArID;;;;;;;;;;;;;;;;GAgBG;AACH,oCAFU,MAAM,CAEyB;AAEzC;;;;GAIG;AACH,4BAFU,MAAM,CAEkB"}

package/src/avif/native/color/transfer_to_linear.js

@@ -1,171 +0,0 @@
-import { PQ_MAX_NITS } from "../../../core/color/PQ/PQ_constants.js";
-import { PQ_to_linear } from "../../../core/color/PQ/PQ_to_linear.js";
-import {
-    TC_BT_1361,
-    TC_BT_2020_10_BIT,
-    TC_BT_2020_12_BIT,
-    TC_BT_470_B_G,
-    TC_BT_470_M,
-    TC_BT_601,
-    TC_BT_709,
-    TC_HLG,
-    TC_IEC_61966,
-    TC_LINEAR,
-    TC_LOG_100,
-    TC_LOG_100_SQRT10,
-    TC_SMPTE_2084,
-    TC_SMPTE_240,
-    TC_SMPTE_428,
-    TC_SRGB
-} from "../av1/tables/av1_symbols.js";
-import { convert_channel_sRGB_to_linear } from "../../../core/color/sRGB/sRGB_to_linear.js";
-
-/**
- * Luminance that a linear value of `1.0` stands for, in nits.
- *
- * Every transfer function here decodes to this normalisation, so that SDR content lands at `1.0`
- * whatever curve carried it and HDR content simply goes above it.
- *
- * A hundred rather than the engine's 203 deliberately, and it is not a renderer setting. The SDR
- * curves in H.273 table 3 — BT.709, sRGB, gamma 2.2, gamma 2.8 — are defined against a hundred nit
- * reference display, so signal `1.0` decoding to linear `1.0` is their own fixed point rather than
- * a convention this file picks. Setting it to `SDR_WHITE_NITS` would land sRGB white at 0.4926 and
- * make this module a statement about meep instead of a statement about the standard.
- *
- * 203 nits is a rendering convention (BT.2408 graphics white on an HDR display), so it lives on the
- * renderer's side of the boundary: `sampler2d_to_avif` and `avif_to_sampler2d` each name their
- * white to the codec through `linear_reference_nits`, and that is where the two meet.
- * @type {number}
- */
-export const LINEAR_REFERENCE_NITS = 100;
-
-/**
- * Peak luminance an HLG signal is decoded against, in nits. The curve carries no absolute luminance
- * of its own, and this is the reference display ITU-R BT.2100 defines its system gamma on.
- * @type {number}
- */
-export const HLG_PEAK_NITS = 1000;
-
-/** @type {number} */
-const HLG_A = 0.17883277;
-
-/** @type {number} */
-const HLG_B = 1 - 4 * HLG_A;
-
-/** @type {number} */
-const HLG_C = 0.5 - HLG_A * Math.log(4 * HLG_A);
-
-/**
- * Decode one signal value to linear light.
- *
- * HLG is the exception: what comes back is *scene* linear, because its opto-optical transfer
- * function is a function of the picture's luminance rather than of one channel. Completing it is
- * {@link transfer_row_to_linear}'s job, which is why nothing should call this directly for HLG.
- *
- * @param {number} transfer_characteristics a `TC_*` code
- * @param {number} value signal, `0 .. 1`
- * @returns {number} linear light, `1.0` being {@link LINEAR_REFERENCE_NITS}
- * @see ITU-T H.273 table 3 "Transfer characteristics"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function transfer_to_linear(transfer_characteristics, value) {
-    switch (transfer_characteristics) {
-        case TC_SMPTE_2084:
-            return PQ_to_linear(value) * (PQ_MAX_NITS / LINEAR_REFERENCE_NITS);
-
-        case TC_HLG:
-            return hlg_to_scene_linear(value);
-
-        case TC_LINEAR:
-            return value;
-
-        case TC_SRGB:
-        case TC_IEC_61966:
-            return convert_channel_sRGB_to_linear(value);
-
-        case TC_BT_470_M:
-            return value <= 0 ? 0 : Math.pow(value, 2.2);
-
-        case TC_BT_470_B_G:
-            return value <= 0 ? 0 : Math.pow(value, 2.8);
-
-        case TC_SMPTE_428:
-            // defined as 48 nits out of a 52.37 nit projector, and that ratio is part of the
-            // standard rather than a rounding artefact
-            return Math.pow(value, 2.6) * (52.37 / 48.0);
-
-        case TC_LOG_100:
-            return value <= 0 ? 0 : Math.pow(10, (value - 1) * 2);
-
-        case TC_LOG_100_SQRT10:
-            return value <= 0 ? 0 : Math.pow(10, (value - 1) * 2.5);
-
-        case TC_SMPTE_240:
-            return value < 0.0913 ? value / 4.0 : Math.pow((value + 0.1115) / 1.1115, 1 / 0.45);
-
-        // BT.709 and everything sharing its curve, which is also what an unspecified or reserved
-        // code is taken to mean
-        case TC_BT_709:
-        case TC_BT_601:
-        case TC_BT_2020_10_BIT:
-        case TC_BT_2020_12_BIT:
-        case TC_BT_1361:
-        default:
-            return value < 0.081 ? value / 4.5 : Math.pow((value + 0.099) / 1.099, 1 / 0.45);
-    }
-}
-
-/**
- * Decode a row of interleaved RGB to linear light, in place.
- *
- * @param {number} transfer_characteristics a `TC_*` code
- * @param {Float32Array} row interleaved, `width * 3` long
- * @param {number} width
- */
-export function transfer_row_to_linear(transfer_characteristics, row, width) {
-    const count = width * 3;
-
-    if (transfer_characteristics === TC_LINEAR) {
-        return;
-    }
-
-    for (let i = 0; i < count; i++) {
-        row[i] = transfer_to_linear(transfer_characteristics, row[i]);
-    }
-
-    if (transfer_characteristics !== TC_HLG) {
-        return;
-    }
-
-    // the opto-optical transfer function, which takes HLG from scene to display referred. It scales
-    // all three channels by a power of the *scene luminance*, so it cannot be folded into the
-    // per-channel curve above
-    const scale = HLG_PEAK_NITS / LINEAR_REFERENCE_NITS;
-
-    for (let i = 0; i < count; i += 3) {
-        const luminance = 0.2627 * row[i] + 0.6780 * row[i + 1] + 0.0593 * row[i + 2];
-
-        const gain = luminance <= 0 ? 0 : Math.pow(luminance, 0.2) * scale;
-
-        row[i] *= gain;
-        row[i + 1] *= gain;
-        row[i + 2] *= gain;
-    }
-}
-
-/**
- * Hybrid log-gamma's inverse opto-electronic transfer function.
- *
- * @param {number} value
- * @returns {number} scene linear, `0 .. 1`
- * @see ITU-R BT.2100 table 5
- */
-function hlg_to_scene_linear(value) {
-    if (value <= 0.5) {
-        return (value * value) / 3;
-    }
-
-    return (Math.exp((value - HLG_C) / HLG_A) + HLG_B) / 12;
-}

package/src/avif/native/color/upsample_chroma_row.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"upsample_chroma_row.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/upsample_chroma_row.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAdW,WAAW,UACX,MAAM,eACN,MAAM,gBACN,MAAM,SACN,MAAM,SACN,MAAM,OACN,MAAM,SACN,MAAM,QACN,MAAM,eACN,YAAY,QAwDtB;AAtFD;;;;GAIG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;;;;GAQG;AACH,gCAFU,MAAM,CAEmB"}

package/src/avif/native/color/upsample_chroma_row.js

@@ -1,89 +0,0 @@
-import { clamp_index } from "../../../core/math/clamp_index.js";
-
-/**
- * Repeat the nearest chroma sample. What every fast decoder does, and what the reference decoder was
- * driven with when the fixtures were minted.
- * @type {number}
- */
-export const UPSAMPLE_NEAREST = 0;
-
-/**
- * Interpolate between chroma samples, treating each as centred on the luma samples it covers.
- *
- * The bitstream can signal where the chroma samples actually sit, but only for 4:2:0 and only as
- * "left" or "top left"; in practice it is almost always left unknown. Centred is the choice that
- * neither shifts the image nor favours one edge, which matters more here than matching any
- * particular other decoder — nothing in the format makes one interpolation normative.
- * @type {number}
- */
-export const UPSAMPLE_BILINEAR = 1;
-
-/**
- * Expand one row of a subsampled chroma plane to full width.
- *
- * @param {Uint16Array} plane
- * @param {number} stride
- * @param {number} plane_width in chroma samples
- * @param {number} plane_height in chroma samples
- * @param {number} sub_x
- * @param {number} sub_y
- * @param {number} row the *luma* row wanted
- * @param {number} width full width, in luma samples
- * @param {number} mode one of the `UPSAMPLE_*` constants
- * @param {Float32Array} destination at least `width` long
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function upsample_chroma_row(plane, stride, plane_width, plane_height, sub_x, sub_y, row, width, mode, destination) {
-    if (sub_x === 0 && sub_y === 0) {
-        const offset = row * stride;
-
-        for (let x = 0; x < width; x++) {
-            destination[x] = plane[offset + x];
-        }
-
-        return;
-    }
-
-    if (mode === UPSAMPLE_NEAREST) {
-        const offset = (row >> sub_y) * stride;
-
-        for (let x = 0; x < width; x++) {
-            const sample_x = x >> sub_x;
-
-            destination[x] = plane[offset + (sample_x < plane_width ? sample_x : plane_width - 1)];
-        }
-
-        return;
-    }
-
-    // vertical position of this luma row within the chroma grid, as a sample index plus a fraction
-    const source_y = sub_y === 0 ? row : (row - 0.5) * 0.5;
-
-    const top = Math.floor(source_y);
-    const weight_y = source_y - top;
-
-    const row_top = clamp_index(top, plane_height) * stride;
-    const row_bottom = clamp_index(top + 1, plane_height) * stride;
-
-    for (let x = 0; x < width; x++) {
-        const source_x = sub_x === 0 ? x : (x - 0.5) * 0.5;
-
-        const left = Math.floor(source_x);
-        const weight_x = source_x - left;
-
-        const column_left = clamp_index(left, plane_width);
-        const column_right = clamp_index(left + 1, plane_width);
-
-        const top_left = plane[row_top + column_left];
-        const top_right = plane[row_top + column_right];
-        const bottom_left = plane[row_bottom + column_left];
-        const bottom_right = plane[row_bottom + column_right];
-
-        const above = top_left + (top_right - top_left) * weight_x;
-        const below = bottom_left + (bottom_right - bottom_left) * weight_x;
-
-        destination[x] = above + (below - above) * weight_y;
-    }
-}

package/src/avif/native/color/ycbcr_row_to_rgb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ycbcr_row_to_rgb.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/color/ycbcr_row_to_rgb.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,mEAVW,WAAW,eACX,MAAM,MACN,YAAY,MACZ,YAAY,SACZ,MAAM,eACN,YAAY,QA0DtB"}