@swf2es/player 0.0.0-stage → 0.1.0

package/src/avm1/queue.ts

@@ -0,0 +1,335 @@
+// The AVM1 action queue: what a frame, an event or a script queues, run by
+// priority, the most urgent first, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) ActionQueue has it (MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors),
+// and the blocks each queued action runs (docs/avm1.md, "The frame").
+import { avm1 } from "@swf2es/runtime";
+import type { DisplayObject, MovieClip } from "../display/display.js";
+import type { Avm1 } from "./avm1.js";
+import { ClipNative, nativeOf } from "./globals/MovieClip.js";
+import type { Avm1Swf } from "./swf.js";
+
+type Value = avm1.Value;
+
+// The queue's priorities, which it runs in order: initialize clip events
+// first, then the root's DoInitAction blocks, then constructions, then the
+// rest, frame actions, events and methods, each in the order queued
+// (Ruffle's ActionPriority; adl has a frame's initialize events before its
+// DoInitAction blocks, which Ruffle runs as the SWF loads).
+export const INITIALIZE = 0;
+export const INIT = 1;
+export const CONSTRUCT = 2;
+export const NORMAL = 3;
+
+// What a queued action is.
+/** A DoAction tag's blocks, `index` the tag's body's offset. */
+export const FRAME = 0;
+/** A block alone, a DoInitAction's or a clip event's, by its index. */
+export const BLOCK = 1;
+/** A timeline's clip's construction: its registered class's prototype and constructor, and its construct events. */
+export const CONSTRUCTION = 2;
+/** An AS2 event method, `name`, of the clip's object. */
+export const METHOD = 3;
+/** The SWF stopped, at a place whose clip actions Flash cannot read. */
+export const HALT = 4;
+/** A broadcaster's message, `name`, to its listeners: Key's and Mouse's, as the player sends them. */
+export const NOTIFY = 5;
+/** A method, `name`, of `object`, called with `args`, as a script would call it. */
+export const CALL = 6;
+
+/** An action waiting its turn in the frame. */
+export class Queued {
+  constructor(
+    readonly kind: number,
+    readonly clip: DisplayObject,
+    /** The SWF whose blocks `index` and `blocks` are. */
+    readonly swf: Avm1Swf | null = null,
+    readonly index = 0,
+    /** Which of the clip's frame entries queued a FRAME: blocks of one share their constant pool. */
+    readonly entry = 0,
+    /** Whether it is an unload's, which runs for a clip removed since. */
+    readonly unload = false,
+    readonly name = "",
+    readonly blocks: number[] = NO_BLOCKS,
+    /** A NOTIFY's broadcaster or a CALL's object, and the arguments. */
+    readonly object: avm1.Avm1Object | null = null,
+    readonly args: avm1.Value[] = NO_ARGS,
+  ) {}
+}
+
+export const NO_BLOCKS: number[] = [];
+
+/** How many queued actions of a priority run before those run are dropped from its queue. */
+const COMPACT_AT = 4096;
+
+export const NO_ARGS: Value[] = [];
+
+/** The queue a movie's actions wait in, by priority, and what runs them. */
+export class ActionQueue {
+  /** The queue, by priority, and how far each has run. */
+  private readonly queues: Queued[][] = [[], [], [], []];
+  private readonly heads = [0, 0, 0, 0];
+  /** Whether the queue is running, which a function's return runs the earlier passes of. */
+  private running = false;
+  /** The pass of the action the queue runs, and the pass `next` last took from. */
+  priority = NORMAL;
+  private taken = NORMAL;
+
+  constructor(private readonly movie: Avm1) {}
+
+  enqueue(priority: number, q: Queued): void {
+    this.queues[priority].push(q);
+  }
+
+  /** The next action of priorities `from` to `to`, the most urgent first; null for none. */
+  private next(from = INITIALIZE, to = NORMAL): Queued | null {
+    for (let p = from; p <= to; p++) {
+      const queue = this.queues[p];
+      // Gotos that go back and forth queue each other's frames for as long
+      // as they run, which is forever in a SWF that never stops them: what
+      // has run goes, and so do the clips they removed, so that such a SWF
+      // runs into the script timeout without its memory growing.
+      if (this.heads[p] >= COMPACT_AT) {
+        queue.splice(0, this.heads[p]);
+        this.heads[p] = 0;
+        const movie = this.movie;
+        movie.clips = movie.clips.filter((clip) => !movie.removed(clip));
+      }
+
+      if (this.heads[p] < queue.length) {
+        this.taken = p;
+        return queue[this.heads[p]++];
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Run what is queued, by priority, what it queues included: the actions
+   * of a clip still on the display list but an unload's; a frame entry's
+   * blocks sharing a constant pool, each starting with the one the block
+   * before left.
+   */
+  run(): void {
+    const movie = this.movie;
+    if (!movie.loaded || this.running) {
+      return;
+    }
+
+    this.running = true;
+    let pool: avm1.Value[] = [];
+    let last: Queued | null = null;
+    try {
+      for (let q = this.next(); q !== null; q = this.next()) {
+        if (movie.halted || movie.rt.disabled) {
+          continue;
+        }
+
+        // A goto that queues its own frame again and again loops here, as a jump back does.
+        if (--movie.realm.budget < 0) {
+          this.timeout();
+        }
+
+        this.priority = this.taken;
+        if (q.kind === FRAME) {
+          if (last === null || last.clip !== q.clip || last.entry !== q.entry) {
+            pool = [];
+          }
+
+          last = q;
+          if (!this.gone(q.clip)) {
+            pool = this.runOne(q, pool);
+          }
+        } else {
+          this.runOne(q, []);
+        }
+      }
+    } finally {
+      this.running = false;
+      for (let p = 0; p < this.queues.length; p++) {
+        this.queues[p].length = 0;
+        this.heads[p] = 0;
+      }
+    }
+  }
+
+  /** The queue's own check of the script timeout, which disables the movie's actions past it. */
+  private timeout(): void {
+    const cx = this.movie.activationOf(this.movie.root);
+    if (cx !== null) {
+      this.movie.rt.call(cx, () => this.movie.realm.timeout());
+    }
+  }
+
+  /**
+   * A function of the SWF's returned to code the queue runs: Flash runs
+   * what was queued by then of the passes before that code's, a frame
+   * action's initializations and constructions, a construction's
+   * initializations (adl, and the corpus's register_and_init_order).
+   */
+  returned(): void {
+    if (!this.running) {
+      return;
+    }
+
+    const outer = this.priority;
+    try {
+      for (
+        let q = this.next(INITIALIZE, outer - 1);
+        q !== null;
+        q = this.next(INITIALIZE, outer - 1)
+      ) {
+        if (!this.movie.halted && !this.movie.rt.disabled) {
+          this.priority = this.taken;
+          this.runOne(q, []);
+        }
+      }
+    } finally {
+      this.priority = outer;
+    }
+  }
+
+  /**
+   * Whether the clip of a queued action is gone: its actions do not run
+   * but an unload's. One kept a frame for an unload handler is, where it
+   * has clip actions of its own; one without, kept for an onUnload or for
+   * a clip in it, runs what it queued before (adl; Ruffle skips them all).
+   */
+  private gone(d: DisplayObject): boolean {
+    if (this.movie.removed(d)) {
+      return true;
+    }
+
+    const native = nativeOf(d);
+    return native?.pending === true && native.handlers !== null;
+  }
+
+  /** Run one queued action, from constant pool `pool` for a FRAME; the pool it leaves. */
+  runOne(q: Queued, pool: avm1.Value[]): avm1.Value[] {
+    const clip = q.clip;
+    if (q.kind !== FRAME && !q.unload && this.gone(clip)) {
+      return pool;
+    }
+
+    switch (q.kind) {
+      case FRAME:
+        // A clip a load has filled since runs none of what it queued before.
+        if (q.swf !== this.movie.swfOf(clip)) {
+          return pool;
+        }
+
+        for (const index of q.swf.list?.byTag.get(q.index) ?? NO_BLOCKS) {
+          pool = this.runBlock(q.swf, index, pool, clip);
+        }
+
+        return pool;
+      case BLOCK:
+        this.runBlock(q.swf, q.index, [], clip);
+        break;
+      case CONSTRUCTION:
+        this.construction(q);
+        break;
+      case METHOD: {
+        const face = clip.avm1;
+        const cx = this.movie.activationOf(clip);
+        if (face !== null && cx !== null && !this.movie.removed(clip)) {
+          this.movie.rt.callMethod(cx, face, q.name, NO_ARGS, this.movie.swfOf(clip).version);
+        }
+        break;
+      }
+      case HALT:
+        this.movie.halted = true;
+        break;
+      case CALL: {
+        const cx = this.movie.activationOf(clip);
+        if (cx !== null && q.object !== null) {
+          this.movie.rt.callMethod(cx, q.object, q.name, q.args, this.movie.version);
+        }
+        break;
+      }
+      case NOTIFY: {
+        const cx = this.movie.activationOf(clip);
+        const object = q.object;
+        if (cx !== null && object !== null) {
+          this.movie.rt.call(cx, () => {
+            avm1.broadcastMessage(object, q.name, q.args, this.movie.version, (listener) => {
+              const display = listener.display;
+              return display instanceof ClipNative && this.movie.removed(display.target);
+            });
+          });
+        }
+        break;
+      }
+    }
+
+    return pool;
+  }
+
+  /**
+   * A timeline's clip constructed: its registered class's prototype, its
+   * construct events, then the class's constructor on it.
+   */
+  private construction(q: Queued): void {
+    const face = q.clip.avm1;
+    if (face === null) {
+      return;
+    }
+
+    const constr = this.movie.classes.classOf(q.clip);
+    if (constr !== null) {
+      face.define(
+        "__proto__",
+        avm1.get(constr, "prototype", this.movie.swfOf(q.clip).version),
+        avm1.DONT_ENUM | avm1.DONT_DELETE,
+      );
+    }
+
+    for (const block of q.blocks) {
+      this.runBlock(q.swf, block, [], q.clip);
+    }
+
+    if (constr !== null) {
+      this.movie.scriptClips.construct(q.clip, face, constr);
+    }
+  }
+
+  /** CallFrame: the actions of `clip`'s frame `frame`, run now in order, each with a pool of its own. */
+  callFrame(clip: MovieClip, frame: number): void {
+    const swf = this.movie.swfOf(clip);
+    for (const command of clip.timeline.frames[frame - 1] ?? []) {
+      if (command.type === "actions") {
+        for (const index of swf.list?.byTag.get(command.tag) ?? []) {
+          this.runBlock(swf, index, [], clip);
+        }
+      }
+    }
+  }
+
+  /**
+   * Run `swf`'s block `index` with `clip` as its target, starting from
+   * constant pool `pool`; the pool it leaves.
+   */
+  runBlock(
+    swf: Avm1Swf | null,
+    index: number,
+    pool: avm1.Value[],
+    clip: DisplayObject,
+  ): avm1.Value[] {
+    const regions = swf?.blocks[index];
+    const cx = regions ? this.movie.activationOf(clip, pool) : null;
+    if (!regions || cx === null) {
+      return pool;
+    }
+
+    try {
+      this.movie.rt.run(regions, cx);
+    } catch (error) {
+      if (!(error instanceof avm1.Halt)) {
+        this.movie.onUncaught(error);
+      }
+    }
+
+    return cx.pool;
+  }
+}

package/src/avm1/sound.ts

@@ -0,0 +1,135 @@
+// An AVM1 movie's sound, what Sound and the timeline's sounds play by: the
+// transforms Sound gives clips and the movie, each sound decoded once for
+// the device, and the Sounds whose sound ended, whose onSoundComplete runs
+// after the frame's actions.
+// Sound's state follows Ruffle's (https://github.com/ruffle-rs/ruffle): MIT
+// OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+import type { avm1 } from "@swf2es/runtime";
+import type { DisplayObject, MovieClip } from "../display/display.js";
+import type { SoundCharacter } from "../display/timeline.js";
+import type { AudioHost, DecodedSound } from "../media/audio.js";
+import { type SoundHost, updateMixes } from "../media/sounds.js";
+import type { Avm1 } from "./avm1.js";
+import {
+  type Avm1SoundTransform,
+  FULL,
+  mixOfTransform,
+  type SoundClassHost,
+} from "./globals/Sound.js";
+import { asciiLower } from "./paths.js";
+import { NO_ARGS } from "./queue.js";
+
+/** The movie's sounds, as Sound and the timeline's sounds see them. */
+export class Avm1Sounds implements SoundClassHost {
+  /** What the timeline's sounds, and Sound's, play by. */
+  readonly sounds: SoundHost;
+  /** The frames played, which the timeline's sounds count by. */
+  frames = 0;
+  /** Each sound decoded once for the device. */
+  private readonly decodes = new WeakMap<SoundCharacter, Promise<DecodedSound>>();
+  /** The transforms Sound gave clips, and the global one. */
+  private readonly soundTransforms = new WeakMap<DisplayObject, Avm1SoundTransform>();
+  private globalSoundTransform: Avm1SoundTransform = FULL;
+  /** The Sounds whose sound ended, for their onSoundComplete after the frame's actions. */
+  private completed: avm1.Avm1Object[] = [];
+
+  constructor(
+    private readonly movie: Avm1,
+    readonly audio: AudioHost | null,
+  ) {
+    const media = this;
+    this.sounds = {
+      get audio() {
+        return media.audio;
+      },
+      get now() {
+        return movie.timers.now();
+      },
+      get frames() {
+        return media.frames;
+      },
+      get frameRate() {
+        return movie.frameRate;
+      },
+      soundClip: (character) => this.soundClip(character),
+      ownMix: (d) => {
+        const t = this.soundTransforms.get(d);
+        return t === undefined ? undefined : mixOfTransform(t);
+      },
+      get mixer() {
+        return mixOfTransform(media.globalSoundTransform);
+      },
+      scriptSounds: () => 0,
+    };
+  }
+
+  get realm(): avm1.Realm {
+    return this.movie.realm;
+  }
+
+  resolve(value: avm1.Value, version: number): DisplayObject | null {
+    return this.movie.resolve(value, version);
+  }
+
+  /** The DefineSound ExportAssets named `name`, any case, as attachSound finds it. */
+  exportedSound(name: string): SoundCharacter | null {
+    const swf = this.movie.currentSwf();
+    const id = swf.exports.get(asciiLower(name));
+    const character = id === undefined ? undefined : swf.library?.characters.get(id);
+    return character?.type === "sound" ? character : null;
+  }
+
+  soundTransform(d: DisplayObject | null): Avm1SoundTransform {
+    return d === null ? this.globalSoundTransform : (this.soundTransforms.get(d) ?? FULL);
+  }
+
+  setSoundTransform(d: DisplayObject | null, transform: Avm1SoundTransform): void {
+    if (d === null) {
+      this.globalSoundTransform = transform;
+    } else {
+      this.soundTransforms.set(d, transform);
+    }
+
+    updateMixes(this.sounds);
+  }
+
+  /** A Sound's sound has ended: its onSoundComplete runs once the frame's actions have. */
+  complete(o: avm1.Avm1Object): void {
+    this.completed.push(o);
+  }
+
+  /** Each ended Sound's onSoundComplete, in the root's activation: whether any ran. */
+  soundsCompleted(): boolean {
+    const completed = this.completed;
+    this.completed = [];
+    const movie = this.movie;
+    const root = movie.root as MovieClip | null;
+    if (completed.length === 0 || root === null) {
+      return false;
+    }
+
+    const cx = movie.activationOf(root);
+    for (const o of completed) {
+      if (cx !== null && !movie.halted) {
+        movie.rt.callMethod(cx, o, "onSoundComplete", NO_ARGS, movie.version);
+      }
+    }
+
+    return true;
+  }
+
+  soundClip(character: SoundCharacter): Promise<DecodedSound> | null {
+    const audio = this.audio;
+    if (audio === null) {
+      return null;
+    }
+
+    let clip = this.decodes.get(character);
+    if (clip === undefined) {
+      clip = Promise.resolve().then(() => audio.decode(character.definition));
+      this.decodes.set(character, clip);
+    }
+
+    return clip;
+  }
+}

package/src/avm1/swf.ts

@@ -0,0 +1,193 @@
+// One AVM1 SWF the player runs, the main one or one loadMovie loaded, and
+// what is read of its action list once: its root's frames' exports,
+// DoInitAction blocks, ScriptLimits and the places Flash cannot read, a
+// place's clip actions and a button's condition blocks.
+// The per-movie library and button conditions follow Ruffle's
+// (https://github.com/ruffle-rs/ruffle): MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors.
+import {
+  type ActionList,
+  ClipEvent,
+  type Place,
+  readExports,
+  type Swf,
+  tags,
+} from "@swf2es/format";
+import type { avm1 } from "@swf2es/runtime";
+import type { MovieClip } from "../display/display.js";
+import type { Library } from "../display/timeline.js";
+
+/**
+ * Where in a frame Flash stops the SWF at a place whose clip actions it
+ * cannot read: it reads them as the first of the place's events comes, so
+ * as it places the clip for load and initialize, before any of the
+ * frame's actions; after the frame's DoInitActions for construct; at the
+ * next frame for enterFrame, the frame's actions run. A place of other
+ * events stops it as one comes to the clip (`dispatch`).
+ */
+export type Stop = "place" | "construct" | "enterFrame";
+
+/** The first of `events`, a place's field of all events, by which Flash stops. */
+export function stopOf(events: number): Stop | null {
+  if (events & (ClipEvent.load | ClipEvent.initialize)) {
+    return "place";
+  }
+
+  if (events & ClipEvent.construct) {
+    return "construct";
+  }
+
+  return events & ClipEvent.enterFrame ? "enterFrame" : null;
+}
+
+const STOPS: Stop[] = ["place", "construct", "enterFrame"];
+
+/** What happens as the root enters a frame, before its places and DoAction blocks. */
+interface RootFrame {
+  /** Its ExportAssets' names, which attachMovie and registerClass find characters by. */
+  exports: { id: number; name: string }[];
+  /** Its DoInitAction blocks, by index, with the sprite each is of. */
+  inits: { sprite: number; block: number }[];
+  /** Where a place in the frame whose clip actions Flash cannot read stops the SWF. */
+  stop: Stop | null;
+  /** The frame's last ScriptLimits: its recursion depth and script timeout, in seconds. */
+  limits: [number, number] | null;
+}
+
+/** A clip action: the block, the events it runs for, and keyPress's key code. */
+export interface Handler {
+  events: number;
+  key: number;
+  block: number;
+}
+
+export const NO_HANDLERS: Handler[] = [];
+
+/** A button's condition block: the transitions it runs on, and its key (0 for none). */
+export interface ButtonHandler {
+  conditions: number;
+  key: number;
+  block: number;
+}
+
+const NO_BUTTON_HANDLERS: readonly ButtonHandler[] = [];
+
+/**
+ * One AVM1 SWF the player runs, the main one or one loadMovie loaded: its
+ * blocks, its library and what its root's frames export and initialize,
+ * which its own code and timelines use, not another's (Ruffle's per-movie
+ * library). Every SWF shares the player's realm, `_global` among it.
+ */
+export class Avm1Swf {
+  /** Its module's blocks, by index. */
+  blocks: avm1.Blocks = [];
+  /** By its root's frame, 1 the first. */
+  readonly frames = new Map<number, RootFrame>();
+  /** The sprites whose DoInitAction has run. */
+  readonly initialized = new Set<number>();
+  /** Exported characters by name in lower case, as attachMovie finds them, and each one's name. */
+  readonly exports = new Map<string, number>();
+  readonly exportNames = new Map<number, string>();
+  /** Each button character's condition blocks, by its id, gathered from the action list once. */
+  buttonHandlers: Map<number, ButtonHandler[]> | null = null;
+  /** The clip that plays it as its root: level 0's, a level's or the clip it was loaded into. */
+  root: MovieClip | null = null;
+
+  constructor(
+    readonly library: Library | null,
+    readonly list: ActionList | null,
+    readonly version: number,
+    /** Its URL, which `_url` gives. */
+    readonly url: string,
+    /** Its length in bytes, which getBytesTotal and getBytesLoaded give for its root. */
+    readonly length: number,
+    /** Its size as it came, compressed, which MovieClipLoader.getProgress gives. */
+    readonly size = length,
+  ) {}
+}
+
+/** Each root frame's exports, DoInitAction blocks, the tags Flash cannot read and its ScriptLimits. */
+export function readRootFrames(swf: Swf, into: Avm1Swf): void {
+  const list = into.list;
+  if (list === null) {
+    return;
+  }
+
+  // The root has a frame a ShowFrame tag ends; what follows the last is the last's.
+  const last = Math.max(1, swf.tags.filter((t) => t.code === tags.ShowFrame).length);
+  const frameOf = (frame: number) => {
+    const at = Math.min(frame, last);
+    let actions = into.frames.get(at);
+    if (!actions) {
+      actions = { exports: [], inits: [], stop: null, limits: null };
+      into.frames.set(at, actions);
+    }
+
+    return actions;
+  };
+  for (const block of list.blocks) {
+    const owner = block.owner;
+    if (block.length > 0 && owner.type === "init" && owner.timeline === null) {
+      frameOf(owner.frame + 1).inits.push({ sprite: owner.sprite, block: block.index });
+    }
+  }
+
+  // A ScriptLimits takes effect as its frame comes, before the frame's
+  // actions, the frame's last one if it has two (adl): two u16s, the
+  // recursion depth and the script timeout in seconds.
+  let frame = 1;
+  for (const tag of swf.tags) {
+    const events = list.corruptEvents.get(tag.offset);
+    if (tag.code === tags.ShowFrame) {
+      frame++;
+    } else if (tag.code === tags.ScriptLimits && tag.length >= 4) {
+      const at = tag.offset;
+      const b = swf.bytes;
+      frameOf(frame).limits = [b[at] | (b[at + 1] << 8), b[at + 2] | (b[at + 3] << 8)];
+    } else if (tag.code === tags.ExportAssets) {
+      frameOf(frame).exports.push(...readExports(swf.bytes, tag));
+    } else if (events !== undefined) {
+      const actions = frameOf(frame);
+      const stop = stopOf(events);
+      if (stop && (!actions.stop || STOPS.indexOf(stop) < STOPS.indexOf(actions.stop))) {
+        actions.stop = stop;
+      }
+    }
+  }
+}
+
+/** A place's clip actions, with the events each runs for, as `swf`'s action list has them. */
+export function handlersOf(place: Place, swf: Avm1Swf): Handler[] | null {
+  const list = swf.list;
+  if (place.actions === null || place.actions.length === 0 || list === null) {
+    return null;
+  }
+
+  const handlers: Handler[] = [];
+  for (const index of place.actions) {
+    const owner = list.blocks[index].owner;
+    if (owner.type === "clip") {
+      handlers.push({ events: owner.events, key: owner.key, block: index });
+    }
+  }
+
+  return handlers;
+}
+
+/** `id`'s condition blocks: a DefineButton's one, or a DefineButton2's, one a BUTTONCONDACTION. */
+export function handlersOfButton(swf: Avm1Swf, id: number): readonly ButtonHandler[] {
+  if (swf.buttonHandlers === null) {
+    const handlers = new Map<number, ButtonHandler[]>();
+    for (const [block, { owner }] of (swf.list?.blocks ?? []).entries()) {
+      if (owner.type === "button") {
+        const list = handlers.get(owner.button) ?? [];
+        list.push({ conditions: owner.conditions, key: owner.key, block });
+        handlers.set(owner.button, list);
+      }
+    }
+
+    swf.buttonHandlers = handlers;
+  }
+
+  return swf.buttonHandlers.get(id) ?? NO_BUTTON_HANDLERS;
+}