@woosh/meep-engine 3.9.0 → 3.11.0

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

@@ -0,0 +1,590 @@
+import { clamp } from "../../../../core/math/clamp.js";
+import { COS128_LOOKUP } from "../tables/transform_tables.js";
+
+/** @type {number} */
+const SINPI_1_9 = 1321;
+
+/** @type {number} */
+const SINPI_2_9 = 2482;
+
+/** @type {number} */
+const SINPI_3_9 = 3344;
+
+/** @type {number} */
+const SINPI_4_9 = 3803;
+
+/**
+ * `Round2( x, 12 )` for values that do not fit in a signed 32-bit integer.
+ *
+ * The butterfly's intermediates are a coefficient of up to 20 bits times a basis value of up to 12,
+ * summed in pairs — as much as 33 bits, which `>>` would wrap. Every JavaScript number is already a
+ * double, so the product is exact and only the shift needs replacing with a floor division; nothing
+ * is converted and nothing is lost.
+ *
+ * @param {number} x
+ * @returns {number}
+ */
+export function round2_12(x) {
+    return Math.floor((x + 2048) / 4096);
+}
+
+/**
+ * `cos128( angle )`: `4096 * cos( angle * pi / 128 )`, rounded.
+ *
+ * @param {number} angle
+ * @returns {number}
+ * @see AV1 spec 7.13.2.1 "Butterfly functions"
+ */
+export function cos128(angle) {
+    const angle2 = angle & 255;
+
+    if (angle2 <= 64) {
+        return COS128_LOOKUP[angle2];
+    }
+
+    if (angle2 <= 128) {
+        return -COS128_LOOKUP[128 - angle2];
+    }
+
+    if (angle2 <= 192) {
+        return -COS128_LOOKUP[angle2 - 128];
+    }
+
+    return COS128_LOOKUP[256 - angle2];
+}
+
+/**
+ * `sin128( angle )`.
+ * @param {number} angle
+ * @returns {number}
+ */
+export function sin128(angle) {
+    return cos128(angle - 64);
+}
+
+/**
+ * `brev( numBits, x )`: reverse the low `numBits` of `x`.
+ * @param {number} num_bits
+ * @param {number} x
+ * @returns {number}
+ */
+function brev(num_bits, x) {
+    let t = 0;
+
+    for (let i = 0; i < num_bits; i++) {
+        t += ((x >> i) & 1) << (num_bits - 1 - i);
+    }
+
+    return t;
+}
+
+/**
+ * `B( a, b, angle, flip, r )`: a butterfly rotation, optionally exchanging the two outputs.
+ *
+ * @param {Int32Array} t
+ * @param {number} a
+ * @param {number} b
+ * @param {number} angle
+ * @param {number} flip
+ * @see AV1 spec 7.13.2.1 "Butterfly functions"
+ */
+function butterfly(t, a, b, angle, flip) {
+    const c = cos128(angle);
+    const s = sin128(angle);
+
+    const ta = t[a];
+    const tb = t[b];
+
+    const x = round2_12(ta * c - tb * s);
+    const y = round2_12(ta * s + tb * c);
+
+    if (flip !== 0) {
+        t[a] = y;
+        t[b] = x;
+    } else {
+        t[a] = x;
+        t[b] = y;
+    }
+}
+
+/**
+ * `H( a, b, flip, r )`: a Hadamard rotation, clamped to `r` bits.
+ *
+ * @param {Int32Array} t
+ * @param {number} a
+ * @param {number} b
+ * @param {number} flip
+ * @param {number} r
+ * @see AV1 spec 7.13.2.1 "Butterfly functions"
+ */
+function hadamard(t, a, b, flip, r) {
+    if (flip !== 0) {
+        const swap = a;
+
+        a = b;
+        b = swap;
+    }
+
+    const x = t[a];
+    const y = t[b];
+
+    const low = -(1 << (r - 1));
+    const high = (1 << (r - 1)) - 1;
+
+    t[a] = clamp(x + y, low, high);
+    t[b] = clamp(x - y, low, high);
+}
+
+/**
+ * Scratch for the permutation steps. Reused across calls: the transforms are the hottest thing in
+ * the decoder after the symbol reader, and a per-block allocation here would dominate.
+ * @type {Int32Array}
+ */
+const PERMUTATION_SCRATCH = new Int32Array(64);
+
+/**
+ * In-place inverse DCT of the first `1 << n` entries of `t`.
+ *
+ * A direct transliteration of the specification's thirty-one ordered steps. It is long, and it
+ * stays long: every step is a different butterfly pattern, and rewriting it as anything more
+ * compact would be a second, unverifiable description of the same thing.
+ *
+ * @param {Int32Array} t
+ * @param {number} n base 2 logarithm of the length, `2 .. 6`
+ * @param {number} r intermediate clamping range in bits
+ * @see AV1 spec 7.13.2.3 "Inverse DCT process"
+ */
+export function inverse_dct(t, n, r) {
+    const size = 1 << n;
+    const copy = PERMUTATION_SCRATCH;
+
+    for (let i = 0; i < size; i++) {
+        copy[i] = t[i];
+    }
+
+    for (let i = 0; i < size; i++) {
+        t[i] = copy[brev(n, i)];
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 15; i++) {
+            butterfly(t, 32 + i, 63 - i, 63 - 4 * brev(4, i), 0);
+        }
+    }
+
+    if (n >= 5) {
+        for (let i = 0; i <= 7; i++) {
+            butterfly(t, 16 + i, 31 - i, 6 + (brev(3, 7 - i) << 3), 0);
+        }
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 15; i++) {
+            hadamard(t, 32 + i * 2, 33 + i * 2, i & 1, r);
+        }
+    }
+
+    if (n >= 4) {
+        for (let i = 0; i <= 3; i++) {
+            butterfly(t, 8 + i, 15 - i, 12 + (brev(2, 3 - i) << 4), 0);
+        }
+    }
+
+    if (n >= 5) {
+        for (let i = 0; i <= 7; i++) {
+            hadamard(t, 16 + 2 * i, 17 + 2 * i, i & 1, r);
+        }
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 3; i++) {
+            for (let j = 0; j <= 1; j++) {
+                butterfly(t, 62 - i * 4 - j, 33 + i * 4 + j, 60 - 16 * brev(2, i) + 64 * j, 1);
+            }
+        }
+    }
+
+    if (n >= 3) {
+        for (let i = 0; i <= 1; i++) {
+            butterfly(t, 4 + i, 7 - i, 56 - 32 * i, 0);
+        }
+    }
+
+    if (n >= 4) {
+        for (let i = 0; i <= 3; i++) {
+            hadamard(t, 8 + 2 * i, 9 + 2 * i, i & 1, r);
+        }
+    }
+
+    if (n >= 5) {
+        for (let i = 0; i <= 1; i++) {
+            for (let j = 0; j <= 1; j++) {
+                butterfly(t, 30 - 4 * i - j, 17 + 4 * i + j, 24 + (j << 6) + ((1 - i) << 5), 1);
+            }
+        }
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 7; i++) {
+            for (let j = 0; j <= 1; j++) {
+                hadamard(t, 32 + i * 4 + j, 35 + i * 4 - j, i & 1, r);
+            }
+        }
+    }
+
+    for (let i = 0; i <= 1; i++) {
+        butterfly(t, 2 * i, 2 * i + 1, 32 + 16 * i, 1 - i);
+    }
+
+    if (n >= 3) {
+        for (let i = 0; i <= 1; i++) {
+            hadamard(t, 4 + 2 * i, 5 + 2 * i, i, r);
+        }
+    }
+
+    if (n >= 4) {
+        for (let i = 0; i <= 1; i++) {
+            butterfly(t, 14 - i, 9 + i, 48 + 64 * i, 1);
+        }
+    }
+
+    if (n >= 5) {
+        for (let i = 0; i <= 3; i++) {
+            for (let j = 0; j <= 1; j++) {
+                hadamard(t, 16 + 4 * i + j, 19 + 4 * i - j, i & 1, r);
+            }
+        }
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 1; i++) {
+            for (let j = 0; j <= 3; j++) {
+                butterfly(t, 61 - i * 8 - j, 34 + i * 8 + j, 56 - i * 32 + (j >> 1) * 64, 1);
+            }
+        }
+    }
+
+    for (let i = 0; i <= 1; i++) {
+        hadamard(t, i, 3 - i, 0, r);
+    }
+
+    if (n >= 3) {
+        butterfly(t, 6, 5, 32, 1);
+    }
+
+    if (n >= 4) {
+        for (let i = 0; i <= 1; i++) {
+            for (let j = 0; j <= 1; j++) {
+                hadamard(t, 8 + 4 * i + j, 11 + 4 * i - j, i, r);
+            }
+        }
+    }
+
+    if (n >= 5) {
+        for (let i = 0; i <= 3; i++) {
+            butterfly(t, 29 - i, 18 + i, 48 + (i >> 1) * 64, 1);
+        }
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 3; i++) {
+            for (let j = 0; j <= 3; j++) {
+                hadamard(t, 32 + 8 * i + j, 39 + 8 * i - j, i & 1, r);
+            }
+        }
+    }
+
+    if (n >= 3) {
+        for (let i = 0; i <= 3; i++) {
+            hadamard(t, i, 7 - i, 0, r);
+        }
+    }
+
+    if (n >= 4) {
+        for (let i = 0; i <= 1; i++) {
+            butterfly(t, 13 - i, 10 + i, 32, 1);
+        }
+    }
+
+    if (n >= 5) {
+        for (let i = 0; i <= 1; i++) {
+            for (let j = 0; j <= 3; j++) {
+                hadamard(t, 16 + i * 8 + j, 23 + i * 8 - j, i, r);
+            }
+        }
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 7; i++) {
+            butterfly(t, 59 - i, 36 + i, i < 4 ? 48 : 112, 1);
+        }
+    }
+
+    if (n >= 4) {
+        for (let i = 0; i <= 7; i++) {
+            hadamard(t, i, 15 - i, 0, r);
+        }
+    }
+
+    if (n >= 5) {
+        for (let i = 0; i <= 3; i++) {
+            butterfly(t, 27 - i, 20 + i, 32, 1);
+        }
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 7; i++) {
+            hadamard(t, 32 + i, 47 - i, 0, r);
+            hadamard(t, 48 + i, 63 - i, 1, r);
+        }
+    }
+
+    if (n >= 5) {
+        for (let i = 0; i <= 15; i++) {
+            hadamard(t, i, 31 - i, 0, r);
+        }
+    }
+
+    if (n === 6) {
+        for (let i = 0; i <= 7; i++) {
+            butterfly(t, 55 - i, 40 + i, 32, 1);
+        }
+
+        for (let i = 0; i <= 31; i++) {
+            hadamard(t, i, 63 - i, 0, r);
+        }
+    }
+}
+
+/**
+ * @param {Int32Array} t
+ * @param {number} n `3` or `4`
+ * @see AV1 spec 7.13.2.4 "Inverse ADST input array permutation process"
+ */
+function adst_input_permutation(t, n) {
+    const size = 1 << n;
+    const copy = PERMUTATION_SCRATCH;
+
+    for (let i = 0; i < size; i++) {
+        copy[i] = t[i];
+    }
+
+    for (let i = 0; i < size; i++) {
+        t[i] = copy[(i & 1) !== 0 ? i - 1 : size - i - 1];
+    }
+}
+
+/**
+ * @param {Int32Array} t
+ * @param {number} n `3` or `4`
+ * @see AV1 spec 7.13.2.5 "Inverse ADST output array permutation process"
+ */
+function adst_output_permutation(t, n) {
+    const size = 1 << n;
+    const copy = PERMUTATION_SCRATCH;
+
+    for (let i = 0; i < size; i++) {
+        copy[i] = t[i];
+    }
+
+    for (let i = 0; i < size; i++) {
+        const a = (i >> 3) & 1;
+        const b = ((i >> 2) & 1) ^ ((i >> 3) & 1);
+        const c = ((i >> 1) & 1) ^ ((i >> 2) & 1);
+        const d = (i & 1) ^ ((i >> 1) & 1);
+
+        const idx = ((d << 3) | (c << 2) | (b << 1) | a) >> (4 - n);
+
+        t[i] = (i & 1) !== 0 ? -copy[idx] : copy[idx];
+    }
+}
+
+/**
+ * @param {Int32Array} t
+ * @see AV1 spec 7.13.2.6 "Inverse ADST4 process"
+ */
+export function inverse_adst4(t) {
+    const t0 = t[0];
+    const t1 = t[1];
+    const t2 = t[2];
+    const t3 = t[3];
+
+    let s0 = SINPI_1_9 * t0;
+    let s1 = SINPI_2_9 * t0;
+    const s2_in = SINPI_3_9 * t1;
+    const s3_in = SINPI_4_9 * t2;
+    const s4 = SINPI_1_9 * t2;
+    const s5 = SINPI_2_9 * t3;
+    const s6 = SINPI_4_9 * t3;
+
+    const a7 = t0 - t2;
+    const b7 = a7 + t3;
+
+    s0 = s0 + s3_in;
+    s1 = s1 - s4;
+
+    const s3 = s2_in;
+    const s2 = SINPI_3_9 * b7;
+
+    s0 = s0 + s5;
+    s1 = s1 - s6;
+
+    const x0 = s0 + s3;
+    const x1 = s1 + s3;
+    const x2 = s2;
+    const x3 = s0 + s1 - s3;
+
+    t[0] = round2_12(x0);
+    t[1] = round2_12(x1);
+    t[2] = round2_12(x2);
+    t[3] = round2_12(x3);
+}
+
+/**
+ * @param {Int32Array} t
+ * @param {number} r
+ * @see AV1 spec 7.13.2.7 "Inverse ADST8 process"
+ */
+export function inverse_adst8(t, r) {
+    adst_input_permutation(t, 3);
+
+    for (let i = 0; i <= 3; i++) {
+        butterfly(t, 2 * i, 2 * i + 1, 60 - 16 * i, 1);
+    }
+
+    for (let i = 0; i <= 3; i++) {
+        hadamard(t, i, 4 + i, 0, r);
+    }
+
+    for (let i = 0; i <= 1; i++) {
+        butterfly(t, 4 + 3 * i, 5 + i, 48 - 32 * i, 1);
+    }
+
+    for (let j = 0; j <= 1; j++) {
+        for (let i = 0; i <= 1; i++) {
+            hadamard(t, 4 * j + i, 2 + 4 * j + i, 0, r);
+        }
+    }
+
+    for (let i = 0; i <= 1; i++) {
+        butterfly(t, 2 + 4 * i, 3 + 4 * i, 32, 1);
+    }
+
+    adst_output_permutation(t, 3);
+}
+
+/**
+ * @param {Int32Array} t
+ * @param {number} r
+ * @see AV1 spec 7.13.2.8 "Inverse ADST16 process"
+ */
+export function inverse_adst16(t, r) {
+    adst_input_permutation(t, 4);
+
+    for (let i = 0; i <= 7; i++) {
+        butterfly(t, 2 * i, 2 * i + 1, 62 - 8 * i, 1);
+    }
+
+    for (let i = 0; i <= 7; i++) {
+        hadamard(t, i, 8 + i, 0, r);
+    }
+
+    for (let i = 0; i <= 1; i++) {
+        butterfly(t, 8 + 2 * i, 9 + 2 * i, 56 - 32 * i, 1);
+        butterfly(t, 13 + 2 * i, 12 + 2 * i, 8 + 32 * i, 1);
+    }
+
+    for (let j = 0; j <= 1; j++) {
+        for (let i = 0; i <= 3; i++) {
+            hadamard(t, 8 * j + i, 4 + 8 * j + i, 0, r);
+        }
+    }
+
+    for (let j = 0; j <= 1; j++) {
+        for (let i = 0; i <= 1; i++) {
+            butterfly(t, 4 + 8 * j + 3 * i, 5 + 8 * j + i, 48 - 32 * i, 1);
+        }
+    }
+
+    for (let j = 0; j <= 3; j++) {
+        for (let i = 0; i <= 1; i++) {
+            hadamard(t, 4 * j + i, 2 + 4 * j + i, 0, r);
+        }
+    }
+
+    for (let i = 0; i <= 3; i++) {
+        butterfly(t, 2 + 4 * i, 3 + 4 * i, 32, 1);
+    }
+
+    adst_output_permutation(t, 4);
+}
+
+/**
+ * @param {Int32Array} t
+ * @param {number} n `2 .. 4`
+ * @param {number} r
+ * @see AV1 spec 7.13.2.9 "Inverse ADST process"
+ */
+export function inverse_adst(t, n, r) {
+    if (n === 2) {
+        inverse_adst4(t);
+    } else if (n === 3) {
+        inverse_adst8(t, r);
+    } else {
+        inverse_adst16(t, r);
+    }
+}
+
+/**
+ * @param {Int32Array} t
+ * @param {number} shift
+ * @see AV1 spec 7.13.2.10 "Inverse Walsh-Hadamard transform process"
+ */
+export function inverse_wht(t, shift) {
+    let a = t[0] >> shift;
+    let c = t[1] >> shift;
+    let d = t[2] >> shift;
+    let b = t[3] >> shift;
+
+    a += c;
+    d -= b;
+
+    const e = (a - d) >> 1;
+
+    b = e - b;
+    c = e - c;
+
+    a -= b;
+    d += c;
+
+    t[0] = a;
+    t[1] = b;
+    t[2] = c;
+    t[3] = d;
+}
+
+/**
+ * @param {Int32Array} t
+ * @param {number} n `2 .. 5`
+ * @see AV1 spec 7.13.2.15 "Inverse identity transform process"
+ */
+export function inverse_identity(t, n) {
+    if (n === 2) {
+        for (let i = 0; i < 4; i++) {
+            t[i] = round2_12(t[i] * 5793);
+        }
+    } else if (n === 3) {
+        for (let i = 0; i < 8; i++) {
+            t[i] = t[i] * 2;
+        }
+    } else if (n === 4) {
+        for (let i = 0; i < 16; i++) {
+            t[i] = round2_12(t[i] * 11586);
+        }
+    } else {
+        for (let i = 0; i < 32; i++) {
+            t[i] = t[i] * 4;
+        }
+    }
+}
+

package/src/avif/native/av1/transform/inverse_transform_2d.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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: number): boolean;
+/**
+ * Whether the row (horizontal) transform for `tx_type` is an ADST.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+export function row_is_adst(tx_type: number): boolean;
+/**
+ * Whether the column (vertical) transform for `tx_type` is a DCT.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+export function column_is_dct(tx_type: number): boolean;
+/**
+ * Whether the column (vertical) transform for `tx_type` is an ADST.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+export function column_is_adst(tx_type: number): boolean;
+/**
+ * 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: Int32Array, tx_size: number, tx_type: number, lossless: number, bit_depth: number, t: Int32Array): void;
+//# sourceMappingURL=inverse_transform_2d.d.ts.map

package/src/avif/native/av1/transform/inverse_transform_2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inverse_transform_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/transform/inverse_transform_2d.js"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,oCAHW,MAAM,GACJ,OAAO,CAInB;AAED;;;;GAIG;AACH,qCAHW,MAAM,GACJ,OAAO,CAWnB;AAED;;;;GAIG;AACH,uCAHW,MAAM,GACJ,OAAO,CAInB;AAED;;;;GAIG;AACH,wCAHW,MAAM,GACJ,OAAO,CAWnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,+CAXW,UAAU,WACV,MAAM,WACN,MAAM,YACN,MAAM,aACN,MAAM,KACN,UAAU,QA4FpB"}