@swf2es/format 0.0.0-stage → 0.1.1

package/src/display.ts

@@ -0,0 +1,419 @@
+// The display list's tags (SWF specification, chapter 3), and the ones that
+// tie a SWF's classes to its symbols: PlaceObject 1 to 4, RemoveObject 1
+// and 2, FrameLabel, DefineSprite, DefineScalingGrid, SymbolClass and
+// DoABC. Filters are kept as their bytes for now, and clip actions are the
+// SWF's action blocks (actions.ts), which a place gives by their indices.
+import type { ActionList } from "./actions.js";
+import { type ColorTransform, type Matrix, readColorTransform, readMatrix } from "./shape.js";
+import { type Rect, readTags, SwfReader, type Tag } from "./swf.js";
+import {
+  DoABC,
+  PlaceObject,
+  PlaceObject3,
+  PlaceObject4,
+  RemoveObject,
+  RemoveObject2,
+} from "./tags.js";
+
+/**
+ * A place: a new character at a depth, or a move of the one there, with
+ * what it sets. Fields it does not set are null or undefined.
+ */
+export interface Place {
+  depth: number;
+  /** Whether it changes the character already at the depth, rather than placing one. */
+  move: boolean;
+  character: number | null;
+  matrix: Matrix | null;
+  colorTransform: ColorTransform | null;
+  ratio: number | null;
+  name: string | null;
+  clipDepth: number | null;
+  /** PlaceObject3's class name, for a character made by a class. */
+  className: string | null;
+  /** PlaceObject3's HasImage: the character is a bitmap, as Flash Pro marks one it places. */
+  hasImage: boolean;
+  blendMode: number | null;
+  cacheAsBitmap: boolean | null;
+  visible: boolean | null;
+  opaqueBackground: number | null;
+  /** The filter list's bytes, undecoded; null without one. */
+  filters: Uint8Array | null;
+  /** PlaceObject4's trailing AMF3 value, undecoded; null without one. */
+  metaData: Uint8Array | null;
+  /**
+   * The indices of its AVM1 clip actions in the SWF's ActionList; null
+   * without them, or when read without the list.
+   */
+  actions: number[] | null;
+  /**
+   * The field of all events of clip actions that run past the tag, which
+   * Flash cannot read: it stops the SWF as the first of them comes; 0 for
+   * none (ActionList.corrupt).
+   */
+  corrupt: number;
+}
+
+export function readString(r: SwfReader): string {
+  const start = r.pos;
+  while (r.pos < r.end && r.bytes[r.pos] !== 0) {
+    r.pos++;
+  }
+
+  const s = utf8(r.bytes.subarray(start, r.pos));
+  r.pos++;
+  return s;
+}
+
+/**
+ * UTF-8 as SWF 6 and later write strings, read as avmplus' Utf8ToUtf16 does
+ * (fromUtf8 in the runtime): a malformed or overlong sequence is no
+ * sequence, and its first byte stands for itself.
+ */
+export function utf8(bytes: Uint8Array): string {
+  let s = "";
+  const length = bytes.length;
+
+  for (let i = 0; i < length; ) {
+    const b = bytes[i++];
+    // ASCII, and a continuation byte on its own, stand for themselves.
+    if (b < 0xc0) {
+      s += String.fromCharCode(b);
+      continue;
+    }
+
+    const n = b < 0xe0 ? 1 : b < 0xf0 ? 2 : 3;
+    const minimum = n === 1 ? 0x80 : n === 2 ? 0x800 : 0x10000;
+    let c = b & (n === 1 ? 0x1f : n === 2 ? 0x0f : 0x07);
+    let ok = i + n <= length;
+    for (let k = 0; ok && k < n; k++) {
+      const next = bytes[i + k];
+      ok = (next & 0xc0) === 0x80;
+      c = (c << 6) | (next & 0x3f);
+    }
+
+    if (!ok || c < minimum) {
+      s += String.fromCharCode(b);
+      continue;
+    }
+
+    i += n;
+    if (n === 3) {
+      // A surrogate pair however large the value, as avmplus makes one;
+      // fromCodePoint would refuse one past U+10FFFF.
+      const u = c - 0x10000;
+      s += String.fromCharCode(0xd800 + ((u >> 10) & 0x3ff), 0xdc00 + (u & 0x3ff));
+    } else {
+      s += String.fromCharCode(c);
+    }
+  }
+
+  return s;
+}
+
+/**
+ * A PlaceObject 1 to 4 tag's body; given the SWF's
+ * action list, with the indices of its clip actions.
+ */
+export function readPlace(bytes: Uint8Array, tag: Tag, actions?: ActionList): Place {
+  const { place } = parsePlace(bytes, tag);
+  place.actions = actions?.byTag.get(tag.offset) ?? null;
+  place.corrupt = actions?.corruptEvents.get(tag.offset) ?? 0;
+  return place;
+}
+
+/** Where a PlaceObject 2 to 4's clip actions start, -1 without them, and its depth. */
+export function clipActionsOffset(bytes: Uint8Array, tag: Tag): { depth: number; offset: number } {
+  const { place, clipActions } = parsePlace(bytes, tag);
+  return { depth: place.depth, offset: clipActions };
+}
+
+function parsePlace(bytes: Uint8Array, tag: Tag): { place: Place; clipActions: number } {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const place: Place = {
+    depth: 0,
+    move: false,
+    character: null,
+    matrix: null,
+    colorTransform: null,
+    ratio: null,
+    name: null,
+    clipDepth: null,
+    className: null,
+    hasImage: false,
+    blendMode: null,
+    cacheAsBitmap: null,
+    visible: null,
+    opaqueBackground: null,
+    filters: null,
+    metaData: null,
+    actions: null,
+    corrupt: 0,
+  };
+
+  if (tag.code === PlaceObject) {
+    place.character = r.u16();
+    place.depth = r.u16();
+    place.matrix = readMatrix(r);
+    if (r.pos < r.end) {
+      place.colorTransform = readColorTransform(r, false);
+    }
+
+    return { place, clipActions: -1 };
+  }
+
+  const flags = r.u8();
+  const flags2 = tag.code === PlaceObject3 || tag.code === PlaceObject4 ? r.u8() : 0;
+  place.depth = r.u16();
+  place.move = (flags & 0x01) !== 0;
+
+  // SWF19 has a class name follow HasImage with a character; Flash reads
+  // one with HasImage only without a character, as Ruffle's reader notes.
+  const hasImage = (flags2 & 0x10) !== 0;
+  place.hasImage = hasImage;
+  if (flags2 & 0x08 || (hasImage && !(flags & 0x02))) {
+    place.className = readString(r);
+  }
+
+  if (flags & 0x02) {
+    place.character = r.u16();
+  }
+
+  if (flags & 0x04) {
+    place.matrix = readMatrix(r);
+  }
+
+  if (flags & 0x08) {
+    place.colorTransform = readColorTransform(r, true);
+  }
+
+  if (flags & 0x10) {
+    place.ratio = r.u16();
+  }
+
+  if (flags & 0x20) {
+    place.name = readString(r);
+  }
+
+  if (flags & 0x40) {
+    place.clipDepth = r.u16();
+  }
+
+  if (flags2 & 0x01) {
+    place.filters = readFilterBytes(r);
+  }
+
+  if (flags2 & 0x02) {
+    place.blendMode = r.u8();
+  }
+
+  if (flags2 & 0x04) {
+    place.cacheAsBitmap = r.u8() !== 0;
+  }
+
+  if (flags2 & 0x20) {
+    place.visible = r.u8() !== 0;
+  }
+
+  // The background follows its own flag, not HasVisible as SWF19 lays it out.
+  if (flags2 & 0x40) {
+    const a = r.u8();
+    const rgb = (r.u8() << 16) | (r.u8() << 8) | r.u8();
+    place.opaqueBackground = ((a << 24) | rgb) >>> 0;
+  }
+
+  const clipActions = flags & 0x80 && r.pos < r.end ? r.pos : -1;
+  if (tag.code === PlaceObject4) {
+    if (clipActions >= 0) {
+      // PlaceObject4 postdates SWF 6: its clip event flags are always 32 bits.
+      r.u16();
+      r.u32();
+      while (r.pos < r.end) {
+        const events = r.u32();
+        if (events === 0) {
+          break;
+        }
+
+        const length = r.u32();
+        // Flash still consumes keyPress's key code when its record says length 0.
+        r.pos += events & (1 << 17) ? Math.max(1, length) : length;
+      }
+    }
+
+    if (r.pos < r.end) {
+      place.metaData = bytes.subarray(r.pos, r.end);
+    }
+  }
+
+  return { place, clipActions };
+}
+
+/** Filter sizes by id, as FILTER's variants lay them out (6 and 7 have variable length). */
+export function readFilterBytes(r: SwfReader): Uint8Array {
+  const start = r.pos;
+  const count = r.u8();
+
+  for (let i = 0; i < count && !r.overrun; i++) {
+    const id = r.u8();
+    switch (id) {
+      case 0:
+        r.pos += 23; // DropShadow
+        break;
+      case 1:
+        r.pos += 9; // Blur
+        break;
+      case 2:
+        r.pos += 15; // Glow
+        break;
+      case 3:
+        r.pos += 27; // Bevel
+        break;
+      case 4:
+      case 7: {
+        const stops = r.u8(); // GradientGlow, GradientBevel
+        r.pos += stops * 5 + 19;
+        break;
+      }
+      case 5: {
+        const x = r.u8(); // Convolution
+        const y = r.u8();
+        r.pos += 8 + x * y * 4 + 5;
+        break;
+      }
+      case 6:
+        r.pos += 80; // ColorMatrix
+        break;
+    }
+  }
+
+  return r.bytes.subarray(start, Math.min(r.pos, r.end));
+}
+
+/** A RemoveObject's or RemoveObject2's depth. */
+export function readRemove(bytes: Uint8Array, tag: Tag): number {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+
+  if (tag.code === RemoveObject) {
+    r.u16();
+  } else if (tag.code !== RemoveObject2) {
+    throw new Error(`tag ${tag.code} is not a remove`);
+  }
+
+  return r.u16();
+}
+
+export function readFrameLabel(bytes: Uint8Array, tag: Tag): string {
+  return readString(new SwfReader(bytes, tag.offset, tag.offset + tag.length));
+}
+
+/** A root's scenes and frame labels, each frame counted from 0 the first. */
+export interface SceneData {
+  scenes: { frame: number; name: string }[];
+  labels: { frame: number; name: string }[];
+}
+
+/** An EncodedU32: seven bits a byte, low first, while the top bit is set. */
+function encodedU32(r: SwfReader): number {
+  let value = 0;
+  for (let shift = 0; shift < 35; shift += 7) {
+    const b = r.u8();
+    value += (b & 0x7f) * 2 ** shift;
+    if (!(b & 0x80)) {
+      break;
+    }
+  }
+
+  return value >>> 0;
+}
+
+/** DefineSceneAndFrameLabelData; a count past the tag's end stops where its bytes do. */
+export function readSceneData(bytes: Uint8Array, tag: Tag): SceneData {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const list = () => {
+    const out: { frame: number; name: string }[] = [];
+    const count = encodedU32(r);
+    for (let i = 0; i < count && !r.overrun; i++) {
+      const frame = encodedU32(r);
+      const name = readString(r);
+      if (!r.overrun) {
+        out.push({ frame, name });
+      }
+    }
+
+    return out;
+  };
+  const scenes = list();
+
+  return { scenes, labels: list() };
+}
+
+/** A DefineSprite's id, frame count and its own tags. */
+export function readSprite(
+  bytes: Uint8Array,
+  tag: Tag,
+): { id: number; frameCount: number; tags: Tag[] } {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const id = r.u16();
+  const frameCount = r.u16();
+  return { id, frameCount, tags: readTags(bytes, r.pos, tag.offset + tag.length).tags };
+}
+
+/** DefineScalingGrid: the sprite or button it is for, and its grid, in twips, in the character's space. */
+export function readScalingGrid(bytes: Uint8Array, tag: Tag): { id: number; grid: Rect } {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const id = r.u16();
+  return { id, grid: r.rect() };
+}
+
+/** DefineBinaryData: a character's bytes, after its id and 4 reserved bytes, which a ByteArray subclass SymbolClass binds to it holds. */
+export function readBinaryData(bytes: Uint8Array, tag: Tag): { id: number; data: Uint8Array } {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const id = r.u16();
+  r.u32();
+  return {
+    id,
+    data: bytes.subarray(Math.min(r.pos, tag.offset + tag.length), tag.offset + tag.length),
+  };
+}
+
+/** SymbolClass's links, including multiple classes of one character; id 0 is the document class. */
+export function readSymbolClass(bytes: Uint8Array, tag: Tag): [number, string][] {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const count = r.u16();
+  const symbols: [number, string][] = [];
+
+  for (let i = 0; i < count && !r.overrun; i++) {
+    const id = r.u16();
+    symbols.push([id, readString(r)]);
+  }
+
+  return symbols;
+}
+
+/** A DoABC's or DoABC2's ABC bytes, its name, and whether it is to be run lazily (kDoAbcLazyInitializeFlag). */
+export function readDoAbc(
+  bytes: Uint8Array,
+  tag: Tag,
+): { name: string; lazy: boolean; abc: Uint8Array } {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  if (tag.code === DoABC) {
+    return { name: "", lazy: false, abc: bytes.subarray(tag.offset, tag.offset + tag.length) };
+  }
+
+  const flags = r.u32();
+  const name = readString(r);
+  return { name, lazy: (flags & 1) !== 0, abc: bytes.subarray(r.pos, tag.offset + tag.length) };
+}
+
+/** ExportAssets: the characters it names, each id with its name, in tag order. */
+export function readExports(bytes: Uint8Array, tag: Tag): { id: number; name: string }[] {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const exports: { id: number; name: string }[] = [];
+  const n = r.end - r.pos >= 2 ? r.u16() : 0;
+  for (let i = 0; i < n && r.end - r.pos >= 2; i++) {
+    const id = r.u16();
+    exports.push({ id, name: readString(r) });
+  }
+
+  return exports;
+}

package/src/filters.ts

@@ -0,0 +1,206 @@
+// The filters a PlaceObject3 gives a display object, as the SWF stores
+// them: FILTERLIST's records, with their fixed-point and float fields.
+import { SwfReader } from "./swf.js";
+
+/** A colour of a filter: RGB and alpha 0 to 255, as RGBA stores them. */
+export interface FilterColor {
+  rgb: number;
+  alpha: number;
+}
+
+export type SwfFilter =
+  | {
+      type: "dropShadow";
+      color: FilterColor;
+      blurX: number;
+      blurY: number;
+      /** In radians. */
+      angle: number;
+      distance: number;
+      strength: number;
+      inner: boolean;
+      knockout: boolean;
+      /** The object drawn with its shadow: false hides it. */
+      composite: boolean;
+      passes: number;
+    }
+  | { type: "blur"; blurX: number; blurY: number; passes: number }
+  | {
+      type: "glow";
+      color: FilterColor;
+      blurX: number;
+      blurY: number;
+      strength: number;
+      inner: boolean;
+      knockout: boolean;
+      composite: boolean;
+      passes: number;
+    }
+  | {
+      type: "bevel" | "gradientGlow" | "gradientBevel";
+      /** A bevel's shadow and highlight, in that order; a gradient's stops. */
+      colors: FilterColor[];
+      ratios: number[];
+      blurX: number;
+      blurY: number;
+      angle: number;
+      distance: number;
+      strength: number;
+      inner: boolean;
+      knockout: boolean;
+      composite: boolean;
+      onTop: boolean;
+      passes: number;
+    }
+  | {
+      type: "convolution";
+      matrixX: number;
+      matrixY: number;
+      divisor: number;
+      bias: number;
+      matrix: number[];
+      color: FilterColor;
+      clamp: boolean;
+      preserveAlpha: boolean;
+    }
+  | { type: "colorMatrix"; matrix: number[] };
+
+function color(r: SwfReader): FilterColor {
+  const red = r.u8();
+  const green = r.u8();
+  const blue = r.u8();
+  return { rgb: (red << 16) | (green << 8) | blue, alpha: r.u8() };
+}
+
+const fixed = (r: SwfReader) => (r.u32() | 0) / 65536;
+const fixed8 = (r: SwfReader) => ((r.u16() << 16) >> 16) / 256;
+
+function float(r: SwfReader): number {
+  const v = new DataView(new ArrayBuffer(4));
+  v.setUint32(0, r.u32());
+  return v.getFloat32(0);
+}
+
+/** A FILTERLIST's filters, as far as the bytes go. */
+export function readFilters(bytes: Uint8Array): SwfFilter[] {
+  const r = new SwfReader(bytes, 0, bytes.length);
+  const count = r.u8();
+  const filters: SwfFilter[] = [];
+  for (let i = 0; i < count && !r.overrun; i++) {
+    const id = r.u8();
+    let filter: SwfFilter | null = null;
+    switch (id) {
+      case 0: {
+        const c = color(r);
+        const [blurX, blurY, angle, distance] = [fixed(r), fixed(r), fixed(r), fixed(r)];
+        const strength = fixed8(r);
+        const flags = r.u8();
+        filter = {
+          type: "dropShadow",
+          color: c,
+          blurX,
+          blurY,
+          angle,
+          distance,
+          strength,
+          inner: (flags & 0x80) !== 0,
+          knockout: (flags & 0x40) !== 0,
+          composite: (flags & 0x20) !== 0,
+          passes: flags & 0x1f,
+        };
+        break;
+      }
+      case 1: {
+        const [blurX, blurY] = [fixed(r), fixed(r)];
+        filter = { type: "blur", blurX, blurY, passes: r.u8() >> 3 };
+        break;
+      }
+      case 2: {
+        const c = color(r);
+        const [blurX, blurY] = [fixed(r), fixed(r)];
+        const strength = fixed8(r);
+        const flags = r.u8();
+        filter = {
+          type: "glow",
+          color: c,
+          blurX,
+          blurY,
+          strength,
+          inner: (flags & 0x80) !== 0,
+          knockout: (flags & 0x40) !== 0,
+          composite: (flags & 0x20) !== 0,
+          passes: flags & 0x1f,
+        };
+        break;
+      }
+      case 3:
+      case 4:
+      case 7: {
+        let colors: FilterColor[];
+        let ratios: number[];
+        if (id === 3) {
+          // The highlight, then the shadow: the SWF spec has them the other way, adl this.
+          const highlight = color(r);
+          colors = [color(r), highlight];
+          ratios = [];
+        } else {
+          const n = r.u8();
+          colors = Array.from({ length: n }, () => color(r));
+          ratios = Array.from({ length: n }, () => r.u8());
+        }
+
+        const [blurX, blurY, angle, distance] = [fixed(r), fixed(r), fixed(r), fixed(r)];
+        const strength = fixed8(r);
+        const flags = r.u8();
+        filter = {
+          type: id === 3 ? "bevel" : id === 4 ? "gradientGlow" : "gradientBevel",
+          colors,
+          ratios,
+          blurX,
+          blurY,
+          angle,
+          distance,
+          strength,
+          inner: (flags & 0x80) !== 0,
+          knockout: (flags & 0x40) !== 0,
+          composite: (flags & 0x20) !== 0,
+          onTop: (flags & 0x10) !== 0,
+          passes: flags & 0x0f,
+        };
+        break;
+      }
+      case 5: {
+        const matrixX = r.u8();
+        const matrixY = r.u8();
+        const divisor = float(r);
+        const bias = float(r);
+        const matrix = Array.from({ length: matrixX * matrixY }, () => float(r));
+        const c = color(r);
+        const flags = r.u8();
+        filter = {
+          type: "convolution",
+          matrixX,
+          matrixY,
+          divisor,
+          bias,
+          matrix,
+          color: c,
+          clamp: (flags & 0x02) !== 0,
+          preserveAlpha: (flags & 0x01) !== 0,
+        };
+        break;
+      }
+      case 6:
+        filter = { type: "colorMatrix", matrix: Array.from({ length: 20 }, () => float(r)) };
+        break;
+    }
+
+    if (!filter || r.overrun) {
+      break;
+    }
+
+    filters.push(filter);
+  }
+
+  return filters;
+}