imagescript 3.3.0 → 3.4.0

package/dist/codecs/jxl/bits.js

@@ -0,0 +1,126 @@
+/*!
+ * The JPEG XL bit reader and the field types of its headers (ISO/IEC 18181-1), ported from jxl-oxide
+ * (crates/jxl-bitstream). Copyright (c) Wonwoo Choi, MIT License (see THIRD_PARTY_NOTICES.md)
+ */
+export class BitReader {
+    d;
+    start;
+    end;
+    buf = 0;
+    n = 0;
+    pos;
+    constructor(d, start = 0, end = d.length) {
+        this.d = d;
+        this.start = start;
+        this.end = end;
+        this.pos = start;
+    }
+    get bitPosition() {
+        return (this.pos - this.start) * 8 - this.n;
+    }
+    refill() {
+        while (this.n <= 24) {
+            if (this.pos >= this.end) {
+                if (this.pos >= this.end + 8)
+                    throw new Error('JPEG XL: truncated data');
+                this.pos++;
+            }
+            else
+                this.buf = (this.buf | this.d[this.pos++] << this.n) >>> 0;
+            this.n += 8;
+        }
+    }
+    peek(n) {
+        if (this.n < n)
+            this.refill();
+        return this.buf & ((1 << n) - 1);
+    }
+    skip(n) {
+        this.buf >>>= n;
+        this.n -= n;
+    }
+    bits(n) {
+        if (n > 24) {
+            const low = this.bits(16);
+            return low + this.bits(n - 16) * 65536;
+        }
+        if (this.n < n)
+            this.refill();
+        const v = this.buf & ((1 << n) - 1);
+        this.buf >>>= n;
+        this.n -= n;
+        return v;
+    }
+    bool() {
+        return this.bits(1) === 1;
+    }
+    u32(d0, d1, d2, d3) {
+        const sel = this.bits(2);
+        const d = sel === 0 ? d0 : sel === 1 ? d1 : sel === 2 ? d2 : d3;
+        return typeof d === 'number' ? d : d[0] + this.bits(d[1]);
+    }
+    u64() {
+        const sel = this.bits(2);
+        if (sel === 0)
+            return 0;
+        if (sel === 1)
+            return 1 + this.bits(4);
+        if (sel === 2)
+            return 17 + this.bits(8);
+        let value = this.bits(12), shift = 12;
+        while (this.bool()) {
+            if (shift === 60) {
+                value += this.bits(4) * 2 ** shift;
+                break;
+            }
+            value += this.bits(8) * 2 ** shift;
+            shift += 8;
+        }
+        if (value > Number.MAX_SAFE_INTEGER)
+            throw new Error('JPEG XL: value too large');
+        return value;
+    }
+    f16() {
+        const v = this.bits(16);
+        const sign = v & 0x8000 ? -1 : 1, exponent = v >> 10 & 31, mantissa = v & 1023;
+        if (exponent === 31)
+            throw new Error('JPEG XL: invalid float');
+        if (exponent === 0)
+            return sign * mantissa / 1024 / 16384;
+        return sign * (1 + mantissa / 1024) * 2 ** (exponent - 15);
+    }
+    enum() {
+        const v = this.u32(0, 1, [2, 4], [18, 6]);
+        if (v > 63)
+            throw new Error('JPEG XL: invalid enum value');
+        return v;
+    }
+    skipBits(n) {
+        while (n > 24) {
+            this.bits(24);
+            n -= 24;
+        }
+        this.bits(n);
+    }
+    zeroPadToByte() {
+        const pad = (8 - this.bitPosition % 8) % 8;
+        if (this.bits(pad) !== 0)
+            throw new Error('JPEG XL: non-zero padding');
+    }
+    get bytePosition() {
+        return this.start + Math.ceil(this.bitPosition / 8);
+    }
+    checkEnd() {
+        if (this.bitPosition > (this.end - this.start) * 8)
+            throw new Error('JPEG XL: truncated data');
+    }
+}
+export const unpackSigned = (v) => v % 2 ? -(v + 1) / 2 : v / 2;
+export function extensions(r) {
+    const bits = r.u64();
+    let lengths = 0;
+    for (let i = 0; i < 64; i++)
+        if (Math.floor(bits / 2 ** i) % 2)
+            lengths += r.u64();
+    r.skipBits(lengths);
+}

package/dist/codecs/jxl/blend.js

@@ -0,0 +1,117 @@
+import { EXTRA_ALPHA } from "./headers.js";
+export const PB_NONE = 0, PB_REPLACE = 1, PB_ADD = 2, PB_MUL = 3, PB_BLEND_ABOVE = 4, PB_BLEND_BELOW = 5, PB_ADD_ABOVE = 6, PB_ADD_BELOW = 7;
+const clamp01 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+let rows = [];
+export function performBlending(bg, bi, fg, fi, out, oi, n, numColor, color, ec, extra) {
+    const hasAlpha = extra.some(e => e.type === EXTRA_ALPHA), numEc = extra.length, nc = numColor + numEc;
+    if (rows.length < nc || rows[0].length < n)
+        rows = Array.from({ length: Math.max(nc, rows.length) }, () => new Float32Array(Math.max(n, rows[0]?.length ?? 0)));
+    for (let i = 0; i < numEc; i++) {
+        const c = numColor + i, e = ec[i], a = numColor + e.alpha, t = rows[c], B = bg[c], F = fg[c], BA = bg[a], FA = fg[a];
+        const isAlpha = c === a, premultiplied = extra[e.alpha].alphaAssociated;
+        switch (e.mode) {
+            case PB_ADD:
+                for (let k = 0; k < n; k++)
+                    t[k] = B[bi + k] + F[fi + k];
+                break;
+            case PB_BLEND_ABOVE:
+                for (let k = 0; k < n; k++)
+                    t[k] = alphaBlend1(B[bi + k], BA[bi + k], F[fi + k], FA[fi + k], isAlpha, premultiplied, e.clamp);
+                break;
+            case PB_BLEND_BELOW:
+                for (let k = 0; k < n; k++)
+                    t[k] = alphaBlend1(F[fi + k], FA[fi + k], B[bi + k], BA[bi + k], isAlpha, premultiplied, e.clamp);
+                break;
+            case PB_ADD_ABOVE:
+                for (let k = 0; k < n; k++)
+                    t[k] = isAlpha ? B[bi + k] : B[bi + k] + F[fi + k] * (e.clamp ? clamp01(FA[fi + k]) : FA[fi + k]);
+                break;
+            case PB_ADD_BELOW:
+                for (let k = 0; k < n; k++)
+                    t[k] = isAlpha ? F[fi + k] : F[fi + k] + B[bi + k] * (e.clamp ? clamp01(BA[bi + k]) : BA[bi + k]);
+                break;
+            case PB_MUL:
+                for (let k = 0; k < n; k++)
+                    t[k] = B[bi + k] * (e.clamp ? clamp01(F[fi + k]) : F[fi + k]);
+                break;
+            case PB_REPLACE:
+                t.set(F.subarray(fi, fi + n));
+                break;
+            default: t.set(B.subarray(bi, bi + n));
+        }
+    }
+    const a = numColor + color.alpha;
+    switch (color.mode) {
+        case PB_ADD:
+            for (let c = 0; c < numColor; c++) {
+                const t = rows[c], B = bg[c], F = fg[c];
+                for (let k = 0; k < n; k++)
+                    t[k] = B[bi + k] + F[fi + k];
+            }
+            break;
+        case PB_ADD_ABOVE:
+        case PB_ADD_BELOW: {
+            const [lo, li, hi, hj] = color.mode === PB_ADD_ABOVE ? [bg, bi, fg, fi] : [fg, fi, bg, bi];
+            for (let c = 0; c < numColor; c++) {
+                const t = rows[c], L = lo[c], H = hi[c];
+                if (!hasAlpha) {
+                    for (let k = 0; k < n; k++)
+                        t[k] = bg[c][bi + k] + fg[c][fi + k];
+                    continue;
+                }
+                const HA = hi[a];
+                for (let k = 0; k < n; k++)
+                    t[k] = L[li + k] + H[hj + k] * (color.clamp ? clamp01(HA[hj + k]) : HA[hj + k]);
+            }
+            break;
+        }
+        case PB_BLEND_ABOVE:
+        case PB_BLEND_BELOW: {
+            if (!hasAlpha) {
+                for (let c = 0; c < numColor; c++)
+                    rows[c].set(fg[c].subarray(fi, fi + n));
+                break;
+            }
+            const [lo, li, hi, hj] = color.mode === PB_BLEND_ABOVE ? [bg, bi, fg, fi] : [fg, fi, bg, bi];
+            const premultiplied = extra[color.alpha].alphaAssociated, HA = hi[a], LA = lo[a], ta = rows[a];
+            for (let k = 0; k < n; k++) {
+                const fa = color.clamp ? clamp01(HA[hj + k]) : HA[hj + k], ba = LA[li + k], na = 1 - (1 - fa) * (1 - ba);
+                if (premultiplied)
+                    for (let c = 0; c < numColor; c++)
+                        rows[c][k] = hi[c][hj + k] + lo[c][li + k] * (1 - fa);
+                else {
+                    const rna = na > 0 ? 1 / na : 0;
+                    for (let c = 0; c < numColor; c++)
+                        rows[c][k] = (hi[c][hj + k] * fa + lo[c][li + k] * ba * (1 - fa)) * rna;
+                }
+                ta[k] = na;
+            }
+            break;
+        }
+        case PB_MUL:
+            for (let c = 0; c < numColor; c++) {
+                const t = rows[c], B = bg[c], F = fg[c];
+                for (let k = 0; k < n; k++)
+                    t[k] = B[bi + k] * (color.clamp ? clamp01(F[fi + k]) : F[fi + k]);
+            }
+            break;
+        case PB_REPLACE:
+            for (let c = 0; c < numColor; c++)
+                rows[c].set(fg[c].subarray(fi, fi + n));
+            break;
+        default:
+            for (let c = 0; c < numColor; c++)
+                rows[c].set(bg[c].subarray(bi, bi + n));
+    }
+    for (let c = 0; c < nc; c++)
+        out[c].set(rows[c].subarray(0, n), oi);
+}
+function alphaBlend1(bg, bga, fg, fga, isAlpha, premultiplied, clamp) {
+    const fa = clamp ? fga : clamp01(fga);
+    if (isAlpha)
+        return 1 - (1 - fa) * (1 - bga);
+    if (premultiplied)
+        return fg + bg * (1 - fa);
+    const na = 1 - (1 - fa) * (1 - bga);
+    return (fg * fa + bg * bga * (1 - fa)) * (na > 0 ? 1 / na : 0);
+}

package/dist/codecs/jxl/color.js

@@ -0,0 +1,116 @@
+import { TF_PQ, TF_HLG, PRI_BT2100, PRI_P3, EXTRA_ALPHA, EXTRA_SPOT, EXTRA_BLACK } from "./headers.js";
+import { toSRGB, hdrToLinear, REFERENCE_WHITE } from "../hdr.js";
+const srgbEncode = (v) => v <= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055;
+export class ColorOutput {
+    image;
+    toneMapping;
+    linear;
+    hdrSignal;
+    scale;
+    constructor(image, toneMapping) {
+        this.image = image;
+        this.toneMapping = toneMapping;
+        const c = image.colour, hdr = !c.wantICC && (c.transfer === TF_PQ || c.transfer === TF_HLG);
+        this.linear = image.xybEncoded && (hdr || image.toneMapping.intensityTarget > 255);
+        this.hdrSignal = !image.xybEncoded && hdr;
+        this.scale = this.linear ? image.toneMapping.intensityTarget / REFERENCE_WHITE : 1;
+    }
+    transform(p, ycbcr) {
+        const image = this.image, n = p.width * p.height, ch = p.channels.slice();
+        if (ycbcr) {
+            const [cb, y, cr] = ch, r = new Float32Array(n), g = new Float32Array(n), b = new Float32Array(n);
+            for (let i = 0; i < n; i++) {
+                const Y = y[i] + 128 / 255;
+                r[i] = Y + 1.402 * cr[i];
+                g[i] = Y - 0.299 * 1.402 / 0.587 * cr[i] - 0.114 * 1.772 / 0.587 * cb[i];
+                b[i] = Y + 1.772 * cb[i];
+            }
+            ch.splice(0, 3, r, g, b);
+        }
+        else if (image.xybEncoded) {
+            const [x, y, b] = ch, m = image.opsinInverse, bias = image.opsinBias, cbrt = bias.map(Math.cbrt);
+            const k = 255 / image.toneMapping.intensityTarget * this.scale;
+            const R = new Float32Array(n), G = new Float32Array(n), B = new Float32Array(n);
+            for (let i = 0; i < n; i++) {
+                const gr = y[i] + x[i] - cbrt[0], gg = y[i] - x[i] - cbrt[1], gb = b[i] - cbrt[2];
+                const mr = gr * gr * gr + bias[0], mg = gg * gg * gg + bias[1], mb = gb * gb * gb + bias[2];
+                let r = (m[0] * mr + m[1] * mg + m[2] * mb) * k, g = (m[3] * mr + m[4] * mg + m[5] * mb) * k, bl = (m[6] * mr + m[7] * mg + m[8] * mb) * k;
+                if (!this.linear) {
+                    r = srgbEncode(r);
+                    g = srgbEncode(g);
+                    bl = srgbEncode(bl);
+                }
+                R[i] = r;
+                G[i] = g;
+                B[i] = bl;
+            }
+            ch.splice(0, 3, R, G, B);
+        }
+        return { width: p.width, height: p.height, channels: ch };
+    }
+    toRGBA(p) {
+        const n = p.width * p.height, ch = p.channels, image = this.image;
+        const numColor = ch.length - image.extraChannels.length, grey = numColor === 1;
+        let [r, g, b] = grey ? [ch[0], ch[0], ch[0]] : ch;
+        const black = image.extraChannels.findIndex(e => e.type === EXTRA_BLACK);
+        if (black >= 0) {
+            const k = ch[numColor + black];
+            if (grey)
+                r = g = b = r.slice();
+            else
+                [r, g, b] = [r.slice(), g.slice(), b.slice()];
+            for (let i = 0; i < n; i++) {
+                r[i] *= k[i];
+                if (!grey) {
+                    g[i] *= k[i];
+                    b[i] *= k[i];
+                }
+            }
+        }
+        image.extraChannels.forEach((e, i) => {
+            if (e.type !== EXTRA_SPOT || grey)
+                return;
+            const s = ch[numColor + i], [sr, sg, sb, solidity] = e.spot;
+            if (r === ch[0])
+                [r, g, b] = [r.slice(), g.slice(), b.slice()];
+            for (let k = 0; k < n; k++) {
+                const mix = solidity * s[k];
+                r[k] = mix * sr + (1 - mix) * r[k];
+                g[k] = mix * sg + (1 - mix) * g[k];
+                b[k] = mix * sb + (1 - mix) * b[k];
+            }
+        });
+        const alphaIndex = image.extraChannels.findIndex(e => e.type === EXTRA_ALPHA);
+        const alpha = alphaIndex >= 0 ? ch[ch.length - image.extraChannels.length + alphaIndex] : null;
+        const premultiplied = alphaIndex >= 0 && image.extraChannels[alphaIndex].alphaAssociated;
+        let out;
+        if (this.linear || this.hdrSignal) {
+            const rgb = new Float32Array(3 * n);
+            for (let i = 0; i < n; i++) {
+                const a = premultiplied ? Math.max(alpha[i], 2 ** -26) : 1;
+                rgb[3 * i] = r[i] / a;
+                rgb[3 * i + 1] = g[i] / a;
+                rgb[3 * i + 2] = b[i] / a;
+            }
+            const c = image.colour;
+            if (this.hdrSignal)
+                hdrToLinear(rgb, c.transfer, c.primaries === PRI_BT2100 ? 9 : c.primaries === PRI_P3 ? 12 : 1);
+            out = toSRGB(rgb, this.toneMapping);
+        }
+        else {
+            out = new Uint8Array(4 * n);
+            const byte = (v) => v <= 0 ? 0 : v >= 1 ? 255 : Math.round(v * 255);
+            for (let i = 0; i < n; i++) {
+                const a = premultiplied ? Math.max(alpha[i], 2 ** -26) : 1;
+                out[4 * i] = byte(r[i] / a);
+                out[4 * i + 1] = byte(g[i] / a);
+                out[4 * i + 2] = byte(b[i] / a);
+                out[4 * i + 3] = 255;
+            }
+        }
+        if (alpha)
+            for (let i = 0; i < n; i++)
+                out[4 * i + 3] = alpha[i] <= 0 ? 0 : alpha[i] >= 1 ? 255 : Math.round(alpha[i] * 255);
+        return out;
+    }
+}