@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/bitmap/images.js

@@ -0,0 +1,240 @@
+// The images in a SWF's JPEG tags, decoded when the SWF is linked, before
+// its scripts run, so that a bitmap class's constructor finds its pixels
+// at hand as Flash's does. The host may give a decoder; the browser's
+// serves otherwise, and without either an image is one Flash cannot read.
+import { INVALID_PIXELS, } from "../display/timeline.js";
+/**
+ * The browser's decoder. A PNG's or GIF's frame comes from WebCodecs'
+ * ImageDecoder as it is, straight alpha (asking `copyTo` for RGBA goes
+ * through premultiplied values and loses low alphas' colours); a JPEG,
+ * opaque, and anything ImageDecoder will not take, through
+ * createImageBitmap and a canvas.
+ */
+export async function decodeInBrowser(data, format) {
+    const type = `image/${format}`;
+    try {
+        if (format !== "jpeg" && typeof ImageDecoder !== "undefined") {
+            // What WebCodecs refuses, the canvas below may still read.
+            const decoded = await decodeFrame(data, type).catch(() => null);
+            if (decoded) {
+                return decoded;
+            }
+        }
+        if (typeof createImageBitmap === "undefined" || typeof OffscreenCanvas === "undefined") {
+            return null;
+        }
+        const bitmap = await createImageBitmap(new Blob([data], { type }), {
+            premultiplyAlpha: "none",
+            colorSpaceConversion: "none",
+        });
+        const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+        const context = canvas.getContext("2d");
+        if (!context) {
+            return null;
+        }
+        context.drawImage(bitmap, 0, 0);
+        bitmap.close();
+        const pixels = context.getImageData(0, 0, canvas.width, canvas.height).data;
+        return { width: canvas.width, height: canvas.height, rgba: new Uint8Array(pixels.buffer) };
+    }
+    catch {
+        return null;
+    }
+}
+/** The first frame's pixels as ImageDecoder gives them, in a format of four bytes a pixel; null for another. */
+async function decodeFrame(data, type) {
+    const decoder = new ImageDecoder({ data, type, colorSpaceConversion: "none" });
+    try {
+        const { image } = await decoder.decode();
+        try {
+            const order = image.format?.startsWith("BGR") ? 2 : 0;
+            const opaque = image.format?.endsWith("X");
+            if (!image.format || !/^(RGB|BGR)[AX]$/.test(image.format)) {
+                return null;
+            }
+            const raw = new Uint8Array(image.allocationSize());
+            const [plane] = await image.copyTo(raw);
+            const width = image.displayWidth;
+            const height = image.displayHeight;
+            const rgba = new Uint8Array(width * height * 4);
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const from = plane.offset + y * plane.stride + x * 4;
+                    const to = (y * width + x) * 4;
+                    rgba[to] = raw[from + order];
+                    rgba[to + 1] = raw[from + 1];
+                    rgba[to + 2] = raw[from + 2 - order];
+                    rgba[to + 3] = opaque ? 255 : raw[from + 3];
+                }
+            }
+            return { width, height, rgba };
+        }
+        finally {
+            image.close();
+        }
+    }
+    finally {
+        decoder.close();
+    }
+}
+/** Whether `library` has an image decodeImages has still to decode. */
+export function hasUndecoded(library) {
+    for (const character of library.characters.values()) {
+        if (character.type === "bitmap" && !character.pixels) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Decode every image of `library` not yet decoded, all at once. */
+export async function decodeImages(library, decode) {
+    const pending = [];
+    for (const character of library.characters.values()) {
+        if (character.type === "bitmap" && !character.pixels) {
+            pending.push(decodeOne(character, decode));
+        }
+    }
+    await Promise.all(pending);
+}
+/**
+ * Each image's pixels, decoding or decoded, by the decoder and its
+ * definition, which the SWFs that define it alike share (timeline.ts'
+ * sharedBitmaps): decoded once for them all, and held as long as the
+ * definition is. A host's own decoder decodes for itself.
+ */
+const decoded = new WeakMap();
+async function decodeOne(character, decode) {
+    const definition = character.definition;
+    if (definition.type !== "image" || !decode) {
+        character.pixels = INVALID_PIXELS;
+        return;
+    }
+    let byDefinition = decoded.get(decode);
+    if (!byDefinition) {
+        byDefinition = new WeakMap();
+        decoded.set(decode, byDefinition);
+    }
+    let pixels = byDefinition.get(definition);
+    if (!pixels) {
+        const cache = byDefinition;
+        pixels = decode(definition.data, definition.format).then((image) => image && image.width > 0 && image.height > 0 ? pixelsOf(definition, image) : INVALID_PIXELS, 
+        // A decoder that failed is asked again by the next load, as before it was shared.
+        (error) => {
+            cache.delete(definition);
+            throw error;
+        });
+        byDefinition.set(definition, pixels);
+    }
+    character.pixels = await pixels;
+}
+/** An image file's format by its signature, as Flash sniffs a load's: null for none it shows. */
+export function imageFormat(data) {
+    if (data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff) {
+        return "jpeg";
+    }
+    if (data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47) {
+        return "png";
+    }
+    return data[0] === 0x47 && data[1] === 0x49 && data[2] === 0x46 && data[3] === 0x38
+        ? "gif"
+        : null;
+}
+/**
+ * The pixels of an image file a load brought, a JPEG opaque and a PNG's or
+ * GIF's alpha its own; null where the decoder cannot read it, or there is
+ * none.
+ */
+export async function decodeImageFile(data, format, decode) {
+    const image = decode === null ? null : await decode(data, format).catch(() => null);
+    if (image === null || image.width === 0 || image.height === 0) {
+        return null;
+    }
+    return pixelsOf({ id: 0, type: "image", format, data, alpha: null, opaque: false }, image);
+}
+/** Alpha capability comes from the file, even when every decoded pixel is opaque. */
+function hasAlpha(data, format) {
+    if (format === "png") {
+        if (data.length < 26 || (data[25] & 4) !== 0) {
+            return true;
+        }
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        for (let at = 8; at + 12 <= data.length;) {
+            const length = view.getUint32(at);
+            if (length > data.length - at - 12) {
+                break;
+            }
+            switch (view.getUint32(at + 4)) {
+                case 0x74524e53: // tRNS
+                    return true;
+                case 0x49444154: // IDAT: transparency, if any, precedes the pixels.
+                    return false;
+            }
+            at += length + 12;
+        }
+    }
+    else if (data.length >= 13) {
+        let at = 13 + ((data[10] & 0x80) !== 0 ? 3 * (2 << (data[10] & 7)) : 0);
+        while (at < data.length) {
+            switch (data[at]) {
+                case 0x2c: // The first image uses the preceding graphic control extension.
+                case 0x3b:
+                    return false;
+                case 0x21:
+                    if (at + 7 < data.length &&
+                        data[at + 1] === 0xf9 &&
+                        data[at + 2] === 4 &&
+                        (data[at + 3] & 1) !== 0) {
+                        return true;
+                    }
+                    at += 2;
+                    while (at < data.length && data[at] !== 0) {
+                        at += data[at] + 1;
+                    }
+                    at++;
+                    break;
+                default:
+                    return true;
+            }
+        }
+    }
+    // A custom decoder may accept bytes with no recognizable header; keep their alpha.
+    return true;
+}
+/** The pixels Flash makes of a decoded image, as adl shows them. */
+function pixelsOf(definition, image) {
+    const { width, height, rgba } = image;
+    const count = width * height;
+    const pixels = new Uint32Array(count);
+    if (definition.format !== "jpeg") {
+        // Flash uses an 8-bit shift for partial alpha, and preserves opaque channels.
+        for (let i = 0; i < count; i++) {
+            const p = i * 4;
+            const a = rgba[p + 3];
+            pixels[i] =
+                a === 255
+                    ? (0xff000000 | (rgba[p] << 16) | (rgba[p + 1] << 8) | rgba[p + 2]) >>> 0
+                    : ((a << 24) |
+                        (((rgba[p] * a) >> 8) << 16) |
+                        (((rgba[p + 1] * a) >> 8) << 8) |
+                        ((rgba[p + 2] * a) >> 8)) >>>
+                        0;
+        }
+        return { width, height, transparent: hasAlpha(definition.data, definition.format), pixels };
+    }
+    // DefineBitsJPEG3's colours are taken as premultiplied by its alpha
+    // already, not premultiplied again; a colour above its alpha reads back
+    // as 255, as it does from a colour clamped to the alpha, which keeps the
+    // store a valid premultiplied one. Alpha of the wrong size is none.
+    const alpha = definition.alpha && definition.alpha.length >= count ? definition.alpha : null;
+    for (let i = 0; i < count; i++) {
+        const p = i * 4;
+        const a = alpha ? alpha[i] : 255;
+        pixels[i] =
+            ((a << 24) |
+                (Math.min(rgba[p], a) << 16) |
+                (Math.min(rgba[p + 1], a) << 8) |
+                Math.min(rgba[p + 2], a)) >>>
+                0;
+    }
+    return { width, height, transparent: alpha !== null || definition.opaque, pixels };
+}

package/dist/thread/player/bitmap/kernel.js

@@ -0,0 +1,65 @@
+// The realm's BitmapData kernels: @swf2es/native's (bitmap-kernel.ts), which
+// the filters and the pixel operations compute by, in Wasm, and its draw
+// kernel (draw-kernel.ts), which draws a bitmap in the normal blend mode.
+import { BitmapKernel, DrawKernel } from "../../native/render/index.js";
+import { releaseDxtEncoder } from "./dxt.js";
+/**
+ * The realm's kernel, made at the first filter or operation that needs it:
+ * @swf2es/native's, in Wasm. False where the realm refused the module, as
+ * a worker served with a CSP without 'wasm-unsafe-eval' may.
+ */
+let kernel = null;
+/** The realm's kernel, made as it is first needed; null where the realm refused the module. */
+export function bitmapKernel() {
+    if (kernel === null) {
+        try {
+            kernel = new BitmapKernel();
+        }
+        catch {
+            kernel = false;
+        }
+    }
+    return kernel || null;
+}
+/** The realm's draw kernel, as `kernel` is made; false where the realm refused the module. */
+let draws = null;
+/** The realm's kernel for draws of a bitmap, made as first needed; null where the realm refused the module. */
+export function drawKernel() {
+    if (draws === null) {
+        // The module compiles once for both: refused for one, it is refused for the other.
+        draws = bitmapKernel() ? new DrawKernel() : false;
+    }
+    return draws || null;
+}
+/** How many frames the draw kernel keeps its instance without drawing. */
+const DRAW_IDLE_FRAMES = 120;
+/** The players that may draw with the draw kernel, and the frames since it last drew. */
+let players = 0;
+let idleFrames = 0;
+/** A player began, which may draw with the draw kernel. */
+export function drawKernelUsed() {
+    players++;
+}
+/** A player ended: the last one lets the draw kernel's instance go, and its memory with it. */
+export function drawKernelLetGo() {
+    players = Math.max(0, players - 1);
+    if (players === 0) {
+        if (draws) {
+            draws.release();
+        }
+        releaseDxtEncoder();
+    }
+}
+/** A player's frame played: the draw kernel, idle for DRAW_IDLE_FRAMES of them, lets its instance go. */
+export function drawKernelFrame() {
+    const kernel = draws || null;
+    if (!kernel?.held) {
+        idleFrames = 0;
+        return;
+    }
+    idleFrames = kernel.idle() ? idleFrames + 1 : 0;
+    if (idleFrames > DRAW_IDLE_FRAMES) {
+        kernel.release();
+        idleFrames = 0;
+    }
+}