@swf2es/native 0.0.0-stage → 0.1.1

package/src/atf/parse.ts

@@ -0,0 +1,263 @@
+// ATF, Adobe's texture container: its header and the blocks of each face
+// and level, read as AIR reads them. The layout is Adobe's "ATF file
+// format" (version 3, 2015), and the old header, which has no version,
+// as Adobe's dds2atf writes it:
+//
+//   old:  "ATF", length U24, cube UB[1] format UB[7], log2 width U8,
+//         log2 height U8, count U8; each block's length U24
+//   new:  "ATF", reserved U8[3], 0xff, version U8, length U32, then as
+//         the old; each block's length U32 (U24 at version 0)
+//
+// The length counts what follows its own field. Each face, then each level
+// of it, holds the blocks of every GPU's encoding in a fixed order; from
+// version 3 those include ETC2's.
+
+/**
+ * Why AIR refuses an ATF: `size` is Error #3669 (Bad input size), `decode`
+ * #3677 (Texture decoding failed) and `format` #3675 (Texture format
+ * mismatch).
+ */
+export type AtfFailure = "size" | "decode" | "format";
+
+export class AtfError extends Error {
+  readonly reason: AtfFailure;
+
+  constructor(reason: AtfFailure, message: string) {
+    super(message);
+    this.reason = reason;
+  }
+}
+
+/** The Context3DTextureFormat whose textures take an ATF format. */
+export type AtfKind = "bgra" | "compressed" | "compressedAlpha";
+
+export const ATF_RGB888 = 0;
+export const ATF_RGBA8888 = 1;
+export const ATF_COMPRESSED = 2;
+export const ATF_RAW_COMPRESSED = 3;
+export const ATF_COMPRESSED_ALPHA = 4;
+export const ATF_RAW_COMPRESSED_ALPHA = 5;
+export const ATF_COMPRESSED_LOSSY = 0x0c;
+export const ATF_COMPRESSED_LOSSY_ALPHA = 0x0d;
+
+/** The largest texture ATF describes, 4096 pixels a side. */
+const MAX_LOG2 = 12;
+
+export interface AtfHeader {
+  /** Whether it is the old header, which AIR reads alone for content before SWF 17. */
+  old: boolean;
+  /** 0 for the old header. */
+  version: number;
+  format: number;
+  cube: boolean;
+  log2Width: number;
+  log2Height: number;
+  width: number;
+  height: number;
+  /** Levels each face holds, the first the full size. */
+  count: number;
+  /** Where the first face's first block starts, in the data. */
+  start: number;
+  /** Where the length field says the texture ends: AIR refuses less data (#3669), and reads on past it. */
+  end: number;
+}
+
+/** A level's blocks, in the order its format lists them: views of the data. */
+export type AtfBlocks = Uint8Array[];
+
+/**
+ * The texture format that takes ATF's `format`: null for the formats 6 to
+ * 11, which AIR calls a mismatch whatever the texture (#3675), and
+ * undefined for any later one, which it calls corrupt (#3677).
+ */
+export function atfKind(format: number): AtfKind | null | undefined {
+  switch (format) {
+    case ATF_RGB888:
+    case ATF_RGBA8888:
+      return "bgra";
+    case ATF_COMPRESSED:
+    case ATF_RAW_COMPRESSED:
+    case ATF_COMPRESSED_LOSSY:
+      return "compressed";
+    case ATF_COMPRESSED_ALPHA:
+    case ATF_RAW_COMPRESSED_ALPHA:
+    case ATF_COMPRESSED_LOSSY_ALPHA:
+      return "compressedAlpha";
+    default:
+      return format <= 11 ? null : undefined;
+  }
+}
+
+/**
+ * The ATF at `offset` of `data`, checked as AIR checks it before it looks
+ * further, even for an asynchronous upload: its signature (#3677), and that
+ * the data holds the header and what its length says (#3669).
+ */
+export function readAtfHeader(data: Uint8Array, offset: number): AtfHeader {
+  // An offset past the data, or not one at all, is as short as none.
+  const available =
+    Number.isInteger(offset) && offset >= 0 && offset <= data.length ? data.length - offset : -1;
+  if (available < 3) {
+    throw new AtfError("size", "no ATF signature");
+  }
+
+  if (data[offset] !== 0x41 || data[offset + 1] !== 0x54 || data[offset + 2] !== 0x46) {
+    throw new AtfError("decode", "not an ATF");
+  }
+
+  // The new header marks itself where the old one has its format.
+  const old = available < 7 || data[offset + 6] !== 0xff;
+  if (available < (old ? 10 : 16)) {
+    throw new AtfError("size", "ATF header truncated");
+  }
+
+  const at = offset + (old ? 6 : 12);
+  const length = old
+    ? (data[offset + 3] << 16) | (data[offset + 4] << 8) | data[offset + 5]
+    : ((data[offset + 8] << 24) |
+        (data[offset + 9] << 16) |
+        (data[offset + 10] << 8) |
+        data[offset + 11]) >>>
+      0;
+  // Past this, AIR reads as far as the data goes, the length aside.
+  const end = at + length;
+  if (end > data.length) {
+    throw new AtfError("size", "ATF longer than its data");
+  }
+
+  const log2Width = data[at + 1];
+  const log2Height = data[at + 2];
+
+  return {
+    old,
+    version: old ? 0 : data[offset + 7],
+    format: data[at] & 0x7f,
+    cube: (data[at] & 0x80) !== 0,
+    log2Width,
+    log2Height,
+    width: 2 ** Math.min(log2Width, 31),
+    height: 2 ** Math.min(log2Height, 31),
+    count: data[at + 3],
+    start: at + 4,
+    end,
+  };
+}
+
+/** The lossy formats, which came with version 3 and AIR reads in no other. */
+function lossy(format: number): boolean {
+  return format === ATF_COMPRESSED_LOSSY || format === ATF_COMPRESSED_LOSSY_ALPHA;
+}
+
+/** Blocks a level holds, every GPU's encoding: ETC2's from version 3. */
+function blocksPerLevel(format: number, version: number): number {
+  const etc2 = version >= 3;
+  switch (format) {
+    case ATF_RGB888:
+    case ATF_RGBA8888:
+      return 1;
+    case ATF_COMPRESSED:
+      // DXT1 2, PVRTC 3, ETC1 3, ETC2 3.
+      return etc2 ? 11 : 8;
+    case ATF_RAW_COMPRESSED:
+    case ATF_RAW_COMPRESSED_ALPHA:
+      // DXT, PVRTC, ETC1 and ETC2 one each.
+      return etc2 ? 4 : 3;
+    case ATF_COMPRESSED_ALPHA:
+      // DXT5 4, PVRTC 3, ETC1 3, ETC2 6.
+      return etc2 ? 16 : 10;
+    case ATF_COMPRESSED_LOSSY:
+      // As compressed, with a block of ETC2's modes; version 3 alone.
+      return 12;
+    default:
+      // As compressed with alpha, with a block of ETC2's modes; version 3 alone.
+      return 17;
+  }
+}
+
+/** How many of a level's blocks the desktop reads: its BGRA image, or its DXT's. */
+function desktopBlocks(format: number): number {
+  switch (format) {
+    case ATF_COMPRESSED:
+    case ATF_COMPRESSED_LOSSY:
+      return 2;
+    case ATF_COMPRESSED_ALPHA:
+    case ATF_COMPRESSED_LOSSY_ALPHA:
+      return 4;
+    default:
+      return 1;
+  }
+}
+
+/**
+ * Each face's levels, each its blocks, as views of `data`; a format AIR
+ * knows, a size up to 4096 and a level count from 1 to the size's own, or
+ * #3677, and a format no texture takes, #3675. AIR reads the blocks as far
+ * as the data goes, whatever the length says, and streams what it finds: a
+ * level that starts where too little is left for a block's length is
+ * absent, as are those after it; one whose blocks for the desktop are whole
+ * stands though a later block of its is cut short, and the levels after it
+ * are absent; but a block the desktop reads that is cut short is corrupt
+ * (#3677).
+ */
+export function readAtfBlocks(data: Uint8Array, header: AtfHeader): (AtfBlocks | null)[][] {
+  const kind = atfKind(header.format);
+  if (kind === null) {
+    throw new AtfError("format", `ATF format ${header.format} is no texture's`);
+  }
+
+  const levels = 1 + Math.max(header.log2Width, header.log2Height);
+  if (
+    kind === undefined ||
+    header.log2Width > MAX_LOG2 ||
+    header.log2Height > MAX_LOG2 ||
+    header.count === 0 ||
+    header.count > levels ||
+    (lossy(header.format) && header.version < 3)
+  ) {
+    throw new AtfError("decode", "ATF format, size or level count out of range");
+  }
+
+  const blocks = blocksPerLevel(header.format, header.version);
+  const needed = desktopBlocks(header.format);
+  const field = header.version === 0 ? 3 : 4;
+  const faces: (AtfBlocks | null)[][] = [];
+  let at = header.start;
+  let streamed = false;
+
+  for (let face = 0; face < (header.cube ? 6 : 1); face++) {
+    const found: (AtfBlocks | null)[] = [];
+    for (let level = 0; level < header.count; level++) {
+      const read: AtfBlocks = [];
+      for (let block = 0; block < blocks && !streamed; block++) {
+        if (field > data.length - at) {
+          streamed = true;
+          break;
+        }
+
+        let length = (data[at] << 16) | (data[at + 1] << 8) | data[at + 2];
+        if (field === 4) {
+          length = length * 256 + data[at + 3];
+        }
+
+        at += field;
+        if (length > data.length - at) {
+          if (block < needed) {
+            throw new AtfError("decode", "ATF block past the data");
+          }
+
+          streamed = true;
+          break;
+        }
+
+        read.push(data.subarray(at, at + length));
+        at += length;
+      }
+
+      found.push(read.length >= needed ? read : null);
+    }
+
+    faces.push(found);
+  }
+
+  return faces;
+}

package/src/audio/index.ts

@@ -0,0 +1,93 @@
+// SWF's ADPCM and Nellymoser sound, decoded synchronously in one module
+// that imports nothing (src/audio/root.zig), kept as compress's is: each
+// call copies its input into the module's memory, decodes there in an
+// arena reset first, and copies the samples out. A Nellymoser stream's
+// state stays here between its calls, copied in and out with each.
+import { KeptInstance } from "../instance.js";
+import { binary } from "./binary.js";
+
+interface Exports {
+  memory: WebAssembly.Memory;
+  reset(): void;
+  alloc(n: number): number;
+  resultPointer(): number;
+  decodeAdpcm(input: number, length: number, channels: number): number;
+  nellymoserStateSize(): number;
+  nellymoserStart(state: number): void;
+  decodeNellymoser(input: number, length: number, state: number): number;
+}
+
+const kept = new KeptInstance<Exports>(binary);
+
+/** `data` in the module's memory, after a reset; 0 if it does not fit. */
+function input(x: Exports, data: Uint8Array): number {
+  x.reset();
+  const at = x.alloc(data.length);
+  if (at !== 0) {
+    new Uint8Array(x.memory.buffer, at, data.length).set(data);
+  }
+
+  return at;
+}
+
+/**
+ * SWF's ADPCM as 16-bit samples, channels interleaved: a code size, then
+ * packets of a header per channel (a 16-bit sample and a 6-bit step index)
+ * and 4095 codes, the header's sample the packet's first, as adl gives it
+ * (Ruffle's decoder leaves it out). It ends where the bits do; none where
+ * the module cannot have the memory.
+ */
+export function decodeAdpcm(data: Uint8Array, channels: 1 | 2): Int16Array {
+  return kept.call((x) => {
+    const at = input(x, data);
+    const n = at === 0 ? -1 : x.decodeAdpcm(at, data.length, channels);
+    return n <= 0
+      ? new Int16Array(0)
+      : new Int16Array(x.memory.buffer, x.resultPointer(), n).slice();
+  });
+}
+
+/** The samples a Nellymoser block decodes to. */
+export const NELLYMOSER_SAMPLES = 256;
+
+/** Nellymoser's blocks into samples, the overlap carried from one call to the next, as a stream's blocks need. */
+export class NellymoserDecoder {
+  /** The stream's state as the module keeps it, made at the first call. */
+  #state: Uint8Array | null = null;
+
+  /**
+   * `data`'s whole 64-byte blocks as samples from -1 to 1, 256 a block;
+   * none where the module cannot have the memory, the stream's state then
+   * as it was.
+   */
+  decode(data: Uint8Array): Float32Array {
+    return kept.call((x) => {
+      x.reset();
+      const size = x.nellymoserStateSize();
+      const state = x.alloc(size);
+      if (state === 0) {
+        return new Float32Array(0);
+      }
+
+      if (this.#state) {
+        new Uint8Array(x.memory.buffer, state, size).set(this.#state);
+      } else {
+        x.nellymoserStart(state);
+      }
+
+      const at = x.alloc(data.length);
+      if (at === 0) {
+        return new Float32Array(0);
+      }
+
+      new Uint8Array(x.memory.buffer, at, data.length).set(data);
+      const n = x.decodeNellymoser(at, data.length, state);
+      if (n < 0) {
+        return new Float32Array(0);
+      }
+
+      this.#state = new Uint8Array(x.memory.buffer, state, size).slice();
+      return new Float32Array(x.memory.buffer, x.resultPointer(), n).slice();
+    });
+  }
+}

package/src/base64.ts

@@ -0,0 +1,10 @@
+/** Base64 to bytes with a plain loop: Uint8Array.from with a callback takes some 8 times as long. */
+export function decodeBase64(text: string): Uint8Array {
+  const raw = atob(text);
+  const bytes = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) {
+    bytes[i] = raw.charCodeAt(i);
+  }
+
+  return bytes;
+}

package/src/compress/index.ts

@@ -0,0 +1,225 @@
+// zlib and LZMA, synchronously, in one module that imports nothing. Each call
+// copies its input into the module's memory, works there in an arena reset
+// first, and copies the output out. Memory never shrinks, so an instance
+// whose memory has grown past MEMORY_KEPT is dropped after its call, as is
+// one whose call threw, and the next call starts a new one from the
+// compiled module.
+import { KeptInstance } from "../instance.js";
+import { binary } from "./binary.js";
+
+interface Exports {
+  memory: WebAssembly.Memory;
+  reset(): void;
+  alloc(n: number): number;
+  resultPointer(): number;
+  resultSize(): number;
+  inputUsed(): number;
+  errorMessage(): number;
+  inflateData(input: number, length: number, windowBits: number, limit: number): number;
+  deflateData(input: number, length: number, level: number, windowBits: number): number;
+  lzmaDecode(properties: number, input: number, length: number, size: number): number;
+  lzmaEncode(input: number, length: number): number;
+}
+
+/** The stream ended. */
+export const DONE = 0;
+/** The output reached its limit before the stream ended. */
+export const FULL = 1;
+/** The data is not what it says. */
+export const CORRUPT = -1;
+/** The input ended before the stream did. */
+export const TRUNCATED = -2;
+/** The module, or the page, could not have the memory the output needed. */
+export const NO_MEMORY = -3;
+/** A zlib stream asked for a preset dictionary. */
+export const DICTIONARY = -4;
+
+/** What a decoder made of its input. */
+export interface Decoded {
+  /** DONE, FULL or one of the failures. */
+  status: number;
+  /**
+   * The output, after `offset` bytes left for the caller: on DONE and FULL,
+   * and on a failure only when `partial` asked for what decoded before it;
+   * otherwise only the `offset` bytes, so that what a bomb inflated is
+   * never copied out of the module only to be dropped.
+   */
+  bytes: Uint8Array;
+  /** How many bytes of the input it read. */
+  used: number;
+  /** zlib's account of corrupt data, if it gave one. */
+  message: string | null;
+}
+
+/** How a decoder hands its output over. */
+export interface DecodeOptions {
+  /** Bytes to leave before the output, for the caller to fill. */
+  offset?: number;
+  /** Whether a failure still gives what decoded before it. */
+  partial?: boolean;
+}
+
+export { MEMORY_KEPT } from "../instance.js";
+
+const kept = new KeptInstance<Exports>(binary);
+
+/** Run `f` on the module's kept instance. */
+function call<T>(f: (x: Exports) => T): T {
+  return kept.call(f);
+}
+
+/** `data` in the module's memory, after a reset; 0 if it does not fit. */
+function input(x: Exports, data: Uint8Array): number {
+  x.reset();
+  const at = x.alloc(data.length);
+  if (at !== 0) {
+    new Uint8Array(x.memory.buffer, at, data.length).set(data);
+  }
+
+  return at;
+}
+
+/** The result, copied out after `offset` bytes; null if the page cannot have that much. */
+function output(x: Exports, offset: number): Uint8Array | null {
+  const n = x.resultSize();
+  let bytes: Uint8Array;
+  try {
+    bytes = new Uint8Array(offset + n);
+  } catch (e) {
+    if (e instanceof RangeError) {
+      return null;
+    }
+
+    throw e;
+  }
+
+  if (n) {
+    bytes.set(new Uint8Array(x.memory.buffer, x.resultPointer(), n), offset);
+  }
+
+  return bytes;
+}
+
+/** A decoder's result: its output copied out only when it is wanted. */
+function decoded(x: Exports, status: number, options: DecodeOptions): Decoded {
+  const offset = options.offset ?? 0;
+  const used = x.inputUsed();
+  const message = status === CORRUPT ? cString(x, x.errorMessage()) : null;
+  const wanted = status === DONE || status === FULL || options.partial === true;
+  const bytes = wanted ? output(x, offset) : new Uint8Array(offset);
+  if (bytes === null) {
+    return { status: NO_MEMORY, bytes: new Uint8Array(offset), used, message: null };
+  }
+
+  return { status, bytes, used, message };
+}
+
+function cString(x: Exports, at: number): string | null {
+  if (at === 0) {
+    return null;
+  }
+
+  const memory = new Uint8Array(x.memory.buffer);
+  let end = at;
+  while (memory[end] !== 0) {
+    end++;
+  }
+
+  return String.fromCharCode(...memory.subarray(at, end));
+}
+
+/**
+ * Inflate a zlib stream, or with `raw` a raw deflate stream, to at most
+ * `limit` bytes. What follows the stream's end is not read.
+ */
+export function inflate(
+  data: Uint8Array,
+  raw: boolean,
+  limit: number,
+  options: DecodeOptions = {},
+): Decoded {
+  return call((x) => {
+    const at = input(x, data);
+    const status =
+      at === 0
+        ? NO_MEMORY
+        : x.inflateData(at, data.length, raw ? -15 : 15, Math.min(limit, 2 ** 32 - 1));
+    return decoded(x, status, options);
+  });
+}
+
+/** `data` deflated at `level` (0 to 9) with zlib's default memory and window, as a zlib stream or, `raw`, a raw one. */
+export function deflate(data: Uint8Array, level: number, raw: boolean): Uint8Array {
+  return call((x) => {
+    const at = input(x, data);
+    const bytes =
+      at === 0 || x.deflateData(at, data.length, level, raw ? -15 : 15) !== DONE
+        ? null
+        : output(x, 0);
+    if (bytes === null) {
+      throw new RangeError(`no memory to deflate ${data.length} bytes`);
+    }
+
+    return bytes;
+  });
+}
+
+/**
+ * Decode the LZMA stream at `start` of `data`, whose 5 property bytes are at
+ * `properties`, to `size` bytes, or fewer if its end marker comes first.
+ * Properties past 224 are corrupt, a dictionary is at least 4 KB, and any
+ * read past the data's end fails, as a whole stream never makes one.
+ */
+export function lzmaDecode(
+  data: Uint8Array,
+  properties: number,
+  start: number,
+  size: number,
+  options: DecodeOptions = {},
+): Decoded {
+  if (properties < 0 || properties + 5 > data.length || start < 0 || start > data.length) {
+    return {
+      status: TRUNCATED,
+      bytes: new Uint8Array(options.offset ?? 0),
+      used: 0,
+      message: null,
+    };
+  }
+
+  return call((x) => {
+    const from = Math.min(properties, start);
+    const at = input(x, data.subarray(from));
+    const status =
+      at === 0
+        ? NO_MEMORY
+        : x.lzmaDecode(
+            at + properties - from,
+            at + start - from,
+            data.length - start,
+            Math.min(size, 2 ** 32 - 1),
+          );
+    return decoded(x, status, options);
+  });
+}
+
+/**
+ * `data` as LZMA, as avmplus' ByteArray writes it: 5 property bytes, the
+ * length in 8 bytes, little-endian, and the stream, at level 9 with a 1 MB
+ * dictionary, or a smaller one for less data, and no end marker.
+ */
+export function lzmaEncode(data: Uint8Array): Uint8Array {
+  return call((x) => {
+    const at = input(x, data);
+    const bytes = at === 0 || x.lzmaEncode(at, data.length) !== DONE ? null : output(x, 0);
+    if (bytes === null) {
+      throw new RangeError(`no memory to compress ${data.length} bytes`);
+    }
+
+    return bytes;
+  });
+}
+
+/** The module's memory now, for measuring: 0 when no instance is kept. */
+export function memoryInUse(): number {
+  return kept.memory;
+}

package/src/instance.ts

@@ -0,0 +1,53 @@
+// One kept instance of a module that imports nothing, for compress and atf:
+// the module compiled from its base64 the first time it is called, an
+// instance made as needed, and let go after a call that threw, or whose
+// memory grew past MEMORY_KEPT, since memory never shrinks.
+import { decodeBase64 } from "./base64.js";
+
+/**
+ * Memory an instance may keep between calls: what a bitmap or a SWF of a
+ * few MB needs, less than an LZMA encoder's for a dictionary of 1 MB.
+ * Starting again costs an instantiation, a fraction of a millisecond.
+ */
+export const MEMORY_KEPT = 8 << 20;
+
+export class KeptInstance<Exports extends { memory: WebAssembly.Memory }> {
+  private readonly binary: string;
+  private compiled: WebAssembly.Module | null = null;
+  private instance: Exports | null = null;
+
+  constructor(binary: string) {
+    this.binary = binary;
+  }
+
+  /**
+   * Run `f` on the instance, made first if there is none (the module
+   * compiled synchronously the first time: some 100 KB, which browsers
+   * allow on the main thread).
+   */
+  call<T>(f: (x: Exports) => T): T {
+    this.compiled ??= new WebAssembly.Module(decodeBase64(this.binary));
+    this.instance ??= new WebAssembly.Instance(this.compiled).exports as unknown as Exports;
+    const x = this.instance;
+    try {
+      return f(x);
+    } catch (e) {
+      this.instance = null;
+      throw e;
+    } finally {
+      if (x.memory.buffer.byteLength > MEMORY_KEPT) {
+        this.instance = null;
+      }
+    }
+  }
+
+  /** Let the instance go, so that the next call starts a new one. */
+  drop(): void {
+    this.instance = null;
+  }
+
+  /** The instance's memory now, for measuring: 0 when none is kept. */
+  get memory(): number {
+    return this.instance ? this.instance.memory.buffer.byteLength : 0;
+  }
+}