imagescript 1.3.1 → 3.1.0

package/dist/codecs/webp.d.ts

@@ -0,0 +1,67 @@
+export interface WebPFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** milliseconds */
+    duration: number;
+    /** whether the frame is alpha blended onto the canvas (false: it replaces the covered area) */
+    blend: boolean;
+    /** whether the frame's area is cleared to transparent after it was shown */
+    dispose: boolean;
+    /** RGBA */
+    pixels: Uint8Array;
+}
+export interface WebPAnimation {
+    width: number;
+    height: number;
+    /** 0 = forever */
+    loopCount: number;
+    /** ARGB background color hint (decoders, like browsers, are free to ignore it) */
+    background: number;
+    frames: WebPFrame[];
+}
+/** Whether the WebP is animated */
+export declare function isAnimated(data: Uint8Array): boolean;
+/**
+ * Decodes a still WebP into RGBA pixels. Animated WebPs decode to their first frame composited on the canvas
+ */
+export declare function decode(data: Uint8Array): {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+    orientation: number;
+};
+/**
+ * Decodes an animated WebP into its frames (not composited); still WebPs become a single frame
+ */
+export declare function decodeAnimation(data: Uint8Array, onlyFirstFrame?: boolean): WebPAnimation;
+/**
+ * Composites animation frames onto the canvas like browsers do (transparent background, the background color hint
+ * is ignored as the spec allows)
+ */
+export declare function composite({ width, height, frames }: WebPAnimation): Array<{
+    pixels: Uint8Array;
+    duration: number;
+}>;
+/**
+ * Encodes RGBA pixels into a lossless WebP
+ */
+export declare function encode(rgba: Uint8Array, width: number, height: number): Uint8Array;
+export interface WebPEncodeFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** milliseconds */
+    duration: number;
+    /** whether the frame's area is cleared after it was shown */
+    dispose: boolean;
+    /** RGBA, alpha blended onto the canvas */
+    pixels: Uint8Array;
+}
+/**
+ * Encodes frames into a lossless animated WebP. Frame offsets have to be even (the format stores them halved)
+ * @param plays How often to play the animation, 0 = forever
+ */
+export declare function encodeAnimation(frames: WebPEncodeFrame[], width: number, height: number, plays: number): Uint8Array;

package/dist/codecs/webp.js

@@ -0,0 +1,280 @@
+/*!
+ * WebP container. Animation frames are blended with libwebp's integer arithmetic (Copyright (c) 2010 Google Inc., BSD
+ * license, see THIRD_PARTY_NOTICES.md)
+ */
+import * as vp8l from "./vp8l.js";
+import * as vp8 from "./vp8.js";
+import { orientation as exifOrientation } from "./exif.js";
+const fourCC = (s) => s.charCodeAt(0) | s.charCodeAt(1) << 8 | s.charCodeAt(2) << 16 | s.charCodeAt(3) << 24;
+const RIFF = fourCC('RIFF'), WEBP = fourCC('WEBP');
+const VP8 = fourCC('VP8 '), VP8L = fourCC('VP8L'), VP8X = fourCC('VP8X');
+const ALPH = fourCC('ALPH'), ANIM = fourCC('ANIM'), ANMF = fourCC('ANMF'), EXIF = fourCC('EXIF');
+function chunks(data, start, end) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const out = [];
+    let offset = start;
+    while (offset + 8 <= end) {
+        const type = view.getUint32(offset, true);
+        const size = view.getUint32(offset + 4, true);
+        const dataStart = offset + 8;
+        out.push({ type, data: data.subarray(dataStart, Math.min(end, dataStart + size)) });
+        offset = dataStart + size + (size & 1);
+    }
+    return out;
+}
+function container(data) {
+    if (data.length < 12)
+        throw new Error('WebP: invalid header');
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (view.getUint32(0, true) !== RIFF || view.getUint32(8, true) !== WEBP)
+        throw new Error('WebP: invalid header');
+    const size = view.getUint32(4, true);
+    return chunks(data, 12, Math.min(data.length, 8 + size));
+}
+const u24 = (d, o) => d[o] | d[o + 1] << 8 | d[o + 2] << 16;
+function decodeBitstream(list) {
+    let alpha = null;
+    for (const chunk of list) {
+        if (chunk.type === ALPH)
+            alpha ??= chunk;
+        else if (chunk.type === VP8L) {
+            const { width, height, argb } = vp8l.decode(chunk.data);
+            const pixels = new Uint8Array(width * height * 4);
+            const out = new DataView(pixels.buffer);
+            for (let i = 0; i < argb.length; i++) {
+                const p = argb[i];
+                out.setUint32(i * 4, (p << 8 | p >>> 24) >>> 0);
+            }
+            return { width, height, pixels };
+        }
+        else if (chunk.type === VP8) {
+            const image = vp8.decode(chunk.data);
+            if (alpha)
+                applyAlpha(image.pixels, image.width, image.height, alpha.data);
+            return image;
+        }
+    }
+    throw new Error('WebP: no image data');
+}
+function applyAlpha(rgba, width, height, chunk) {
+    if (!chunk.length)
+        return;
+    const header = chunk[0];
+    const compression = header & 3, filter = header >> 2 & 3;
+    const total = width * height;
+    let alpha;
+    if (compression === 0) {
+        alpha = new Uint8Array(total);
+        alpha.set(chunk.subarray(1, 1 + total));
+    }
+    else if (compression === 1) {
+        const argb = vp8l.decodeStream(new vp8l.BitReader(chunk, 1), width, height);
+        alpha = new Uint8Array(total);
+        for (let i = 0; i < total; i++)
+            alpha[i] = argb[i] >> 8 & 255;
+    }
+    else
+        throw new Error('WebP: invalid alpha compression');
+    if (filter)
+        unfilterAlpha(alpha, width, height, filter);
+    for (let i = 0; i < total; i++)
+        rgba[i * 4 + 3] = alpha[i];
+}
+function unfilterAlpha(a, width, height, filter) {
+    for (let y = 0; y < height; y++) {
+        const row = y * width;
+        for (let x = 0; x < width; x++) {
+            const i = row + x;
+            let prediction;
+            if (x === 0 && y === 0)
+                prediction = 0;
+            else if (y === 0)
+                prediction = a[i - 1];
+            else if (x === 0)
+                prediction = a[i - width];
+            else if (filter === 1)
+                prediction = a[i - 1];
+            else if (filter === 2)
+                prediction = a[i - width];
+            else {
+                const g = a[i - 1] + a[i - width] - a[i - width - 1];
+                prediction = g < 0 ? 0 : g > 255 ? 255 : g;
+            }
+            a[i] = a[i] + prediction & 255;
+        }
+    }
+}
+export function isAnimated(data) {
+    const list = container(data);
+    const header = list[0];
+    return header && header.type === VP8X && header.data.length >= 10 && (header.data[0] & 2) !== 0 && list.some(c => c.type === ANMF);
+}
+export function decode(data) {
+    const list = container(data);
+    if (!list.length)
+        throw new Error('WebP: no image data');
+    let orientation = 1;
+    const exif = list.find(c => c.type === EXIF);
+    if (exif)
+        orientation = exifOrientation(exif.data);
+    if (list.some(c => c.type === ANMF)) {
+        const animation = decodeAnimation(data, true);
+        const frame = composite(animation)[0];
+        return { width: animation.width, height: animation.height, pixels: frame.pixels, orientation };
+    }
+    const image = decodeBitstream(list);
+    if (list[0].type === VP8X && list[0].data.length >= 10) {
+        const width = u24(list[0].data, 4) + 1, height = u24(list[0].data, 7) + 1;
+        if (width !== image.width || height !== image.height)
+            throw new Error('WebP: canvas and image sizes differ');
+    }
+    return { ...image, orientation };
+}
+export function decodeAnimation(data, onlyFirstFrame = false) {
+    const list = container(data);
+    const header = list[0];
+    if (!header || header.type !== VP8X || !list.some(c => c.type === ANMF)) {
+        const { width, height, pixels } = decodeBitstream(list);
+        return { width, height, loopCount: 0, background: 0, frames: [{ x: 0, y: 0, width, height, duration: 0, blend: false, dispose: false, pixels }] };
+    }
+    if (header.data.length < 10)
+        throw new Error('WebP: invalid VP8X chunk');
+    const width = u24(header.data, 4) + 1, height = u24(header.data, 7) + 1;
+    let loopCount = 0, background = 0;
+    const frames = [];
+    for (const chunk of list) {
+        if (chunk.type === ANIM && chunk.data.length >= 6) {
+            const d = chunk.data;
+            background = (d[3] << 24 | d[2] << 16 | d[1] << 8 | d[0]) >>> 0;
+            loopCount = d[4] | d[5] << 8;
+        }
+        else if (chunk.type === ANMF) {
+            const d = chunk.data;
+            if (d.length < 16)
+                throw new Error('WebP: invalid ANMF chunk');
+            const frame = decodeBitstream(chunks(d, 16, d.length));
+            frames.push({
+                x: u24(d, 0) * 2,
+                y: u24(d, 3) * 2,
+                width: frame.width,
+                height: frame.height,
+                duration: u24(d, 12),
+                blend: (d[15] & 2) === 0,
+                dispose: (d[15] & 1) === 1,
+                pixels: frame.pixels
+            });
+            if (onlyFirstFrame)
+                break;
+        }
+    }
+    if (!frames.length)
+        throw new Error('WebP: animation without frames');
+    return { width, height, loopCount, background, frames };
+}
+export function composite({ width, height, frames }) {
+    const canvas = new Uint8Array(width * height * 4);
+    const output = [];
+    for (const frame of frames) {
+        const x0 = Math.min(frame.x, width), x1 = Math.min(frame.x + frame.width, width);
+        const y0 = Math.min(frame.y, height), y1 = Math.min(frame.y + frame.height, height);
+        for (let y = y0; y < y1; y++)
+            for (let x = x0; x < x1; x++) {
+                const s = ((y - frame.y) * frame.width + x - frame.x) * 4, d = (y * width + x) * 4;
+                const sa = frame.pixels[s + 3];
+                if (!frame.blend || sa === 255 || canvas[d + 3] === 0) {
+                    canvas[d] = frame.pixels[s];
+                    canvas[d + 1] = frame.pixels[s + 1];
+                    canvas[d + 2] = frame.pixels[s + 2];
+                    canvas[d + 3] = sa;
+                }
+                else if (sa !== 0)
+                    blendOver(frame.pixels, s, canvas, d);
+            }
+        output.push({ pixels: canvas.slice(), duration: frame.duration });
+        if (frame.dispose)
+            for (let y = y0; y < y1; y++)
+                canvas.fill(0, (y * width + x0) * 4, (y * width + x1) * 4);
+    }
+    return output;
+}
+function blendOver(src, s, dst, d) {
+    const sa = src[s + 3], da = dst[d + 3];
+    const dstFactor = da * (256 - sa) >> 8;
+    const alpha = sa + dstFactor;
+    const scale = alpha ? Math.floor((1 << 24) / alpha) : 0;
+    for (let c = 0; c < 3; c++) {
+        const blended = src[s + c] * sa + dst[d + c] * dstFactor;
+        dst[d + c] = blended * scale >>> 24;
+    }
+    dst[d + 3] = alpha;
+}
+function riffChunk(type, body) {
+    const out = new Uint8Array(8 + body.length + (body.length & 1));
+    const view = new DataView(out.buffer);
+    view.setUint32(0, fourCC(type), true);
+    view.setUint32(4, body.length, true);
+    out.set(body, 8);
+    return out;
+}
+function riff(chunks) {
+    let size = 4;
+    for (const c of chunks)
+        size += c.length;
+    const out = new Uint8Array(8 + size);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, RIFF, true);
+    view.setUint32(4, size, true);
+    view.setUint32(8, WEBP, true);
+    let offset = 12;
+    for (const c of chunks) {
+        out.set(c, offset);
+        offset += c.length;
+    }
+    return out;
+}
+function toARGB(rgba, count) {
+    const argb = new Uint32Array(count);
+    for (let i = 0, o = 0; i < count; i++, o += 4)
+        argb[i] = (rgba[o + 3] << 24 | rgba[o] << 16 | rgba[o + 1] << 8 | rgba[o + 2]) >>> 0;
+    return argb;
+}
+const set24 = (d, o, v) => { d[o] = v & 255; d[o + 1] = v >> 8 & 255; d[o + 2] = v >> 16 & 255; };
+export function encode(rgba, width, height) {
+    return riff([riffChunk('VP8L', vp8l.encode(toARGB(rgba, width * height), width, height))]);
+}
+export function encodeAnimation(frames, width, height, plays) {
+    if (!frames.length)
+        throw new Error('WebP: an animation needs at least one frame');
+    if (width > 1 << 24 || height > 1 << 24)
+        throw new RangeError('WebP: canvas too large');
+    let alpha = false;
+    for (const f of frames)
+        for (let i = 3; i < f.pixels.length && !alpha; i += 4)
+            if (f.pixels[i] !== 255)
+                alpha = true;
+    const vp8x = new Uint8Array(10);
+    vp8x[0] = 2 | (alpha ? 16 : 0);
+    set24(vp8x, 4, width - 1);
+    set24(vp8x, 7, height - 1);
+    const anim = new Uint8Array(6);
+    anim[4] = plays & 255;
+    anim[5] = plays >> 8 & 255;
+    const chunks = [riffChunk('VP8X', vp8x), riffChunk('ANIM', anim)];
+    for (const f of frames) {
+        if (f.x & 1 || f.y & 1)
+            throw new RangeError('WebP: frame offsets have to be even');
+        const bitstream = riffChunk('VP8L', vp8l.encode(toARGB(f.pixels, f.width * f.height), f.width, f.height));
+        const header = new Uint8Array(16);
+        set24(header, 0, f.x >> 1);
+        set24(header, 3, f.y >> 1);
+        set24(header, 6, f.width - 1);
+        set24(header, 9, f.height - 1);
+        set24(header, 12, Math.min(0xffffff, Math.max(0, Math.round(f.duration))));
+        header[15] = f.dispose ? 1 : 0;
+        const body = new Uint8Array(16 + bitstream.length);
+        body.set(header);
+        body.set(bitstream, 16);
+        chunks.push(riffChunk('ANMF', body));
+    }
+    return riff(chunks);
+}

package/dist/codecs/zlib.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * zlib deflate/inflate, derived from fflate (https://github.com/101arrowz/fflate)
+ * Copyright (c) 2020 Arjun Barrett, MIT License (see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Compresses data into a zlib stream
+ * @param level compression level 0-9
+ */
+export declare function compress(data: Uint8Array, level: number): Uint8Array;
+/**
+ * Decompresses a zlib stream into at most limit bytes
+ */
+export declare function decompress(data: Uint8Array, limit: number): Uint8Array;
+/**
+ * Compresses data into a zlib stream, with the runtime's native zlib when available
+ * @param level compression level 0-9
+ */
+export declare function compressAsync(data: Uint8Array, level: number): Promise<Uint8Array>;
+/**
+ * Decompresses a zlib stream into at most limit bytes, using the runtime's native zlib when available
+ */
+export declare function decompressAsync(data: Uint8Array, limit: number): Promise<Uint8Array>;