@swf2es/player 0.0.0-stage → 0.1.1

package/src/bitmap/images.ts

@@ -0,0 +1,304 @@
+// 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 {
+  type BitmapCharacter,
+  type BitmapPixels,
+  INVALID_PIXELS,
+  type Library,
+} from "../display/timeline.js";
+
+/** A decoded image: straight (not premultiplied) RGBA, row by row. */
+export interface DecodedImage {
+  width: number;
+  height: number;
+  rgba: Uint8Array;
+}
+
+/** Decodes a JPEG, PNG or GIF; null for one it cannot. */
+export type ImageDecode = (
+  data: Uint8Array,
+  format: "jpeg" | "png" | "gif",
+) => Promise<DecodedImage | null>;
+
+/**
+ * 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: Uint8Array,
+  format: "jpeg" | "png" | "gif",
+): Promise<DecodedImage | null> {
+  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 as Uint8Array<ArrayBuffer>], { 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: Uint8Array, type: string): Promise<DecodedImage | null> {
+  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: Library): boolean {
+  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: Library, decode: ImageDecode | null): Promise<void> {
+  const pending: Promise<void>[] = [];
+  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<
+  ImageDecode,
+  WeakMap<BitmapCharacter["definition"], Promise<BitmapPixels>>
+>();
+
+async function decodeOne(character: BitmapCharacter, decode: ImageDecode | null): Promise<void> {
+  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: Uint8Array): "jpeg" | "png" | "gif" | null {
+  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: Uint8Array,
+  format: "jpeg" | "png" | "gif",
+  decode: ImageDecode | null,
+): Promise<BitmapPixels | null> {
+  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: Uint8Array, format: "png" | "gif"): boolean {
+  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: Extract<BitmapCharacter["definition"], { type: "image" }>,
+  image: DecodedImage,
+): BitmapPixels {
+  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/src/bitmap/kernel.ts

@@ -0,0 +1,77 @@
+// 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 "@swf2es/native/render";
+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: BitmapKernel | false | null = null;
+
+/** The realm's kernel, made as it is first needed; null where the realm refused the module. */
+export function bitmapKernel(): BitmapKernel | null {
+  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: DrawKernel | false | null = null;
+
+/** The realm's kernel for draws of a bitmap, made as first needed; null where the realm refused the module. */
+export function drawKernel(): DrawKernel | null {
+  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(): void {
+  players++;
+}
+
+/** A player ended: the last one lets the draw kernel's instance go, and its memory with it. */
+export function drawKernelLetGo(): void {
+  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(): void {
+  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;
+  }
+}