@swf2es/player 0.0.0-stage → 0.1.0

package/src/avm1/compile.ts

@@ -0,0 +1,179 @@
+// AVM1's blocks compiled on first use, each byte for byte its AOT entry,
+// and the units their code goes on in (docs/avm1.md, "Units") likewise.
+import type { ActionBlocks, Codegen } from "@swf2es/codegen";
+import { avm1 } from "@swf2es/runtime";
+import { evaluateFunction } from "../scripting/evaluate.js";
+
+let scripts = 0;
+
+/**
+ * Stable region arrays let the runtime and ExternalInterface identify a
+ * block before it is compiled; its functions keep that same array after.
+ */
+export function lazyBlocks(
+  codegen: Codegen,
+  bytes: Uint8Array,
+  actions: ActionBlocks,
+  rt: avm1.Runtime,
+): avm1.Blocks {
+  const script = ++scripts;
+  const version = actions.version;
+  const evaluate = (entry: string, name: string): avm1.Region[] => {
+    // AVM1 identifies its callers by region arrays, including on engines
+    // whose Function stack frames do not name their sourceURL.
+    const source = `export default function (rt) {\nconst V = rt.version(${version});\n${version < 5 ? "const V5 = rt.version(5);\n" : ""}return [\n${entry}\n];\n}\n`;
+    const factory = evaluateFunction(source, `swf2es-avm1-${script}-${name}.js`);
+    return (factory as unknown as avm1.Factory)(rt)[0];
+  };
+  const blocks = actions.blocks.map((_, index) => {
+    const regions: avm1.Region[] = [];
+    regions.push((cx) => {
+      const entry = codegen.compileActionBlocks(bytes, actions, [index]).get(index);
+      if (entry === undefined) {
+        throw new Error(`swf2es: no compiled AVM1 block ${index}`);
+      }
+
+      const compiled = evaluate(entry, `${index}`);
+      regions.length = 0;
+      for (const region of compiled) {
+        regions.push(region);
+      }
+
+      return regions[0](cx);
+    });
+    return regions;
+  });
+  const units = unitsOf(codegen, bytes, actions, blocks, rt.realm.units, evaluate);
+  for (const regions of blocks) {
+    rt.realm.units.set(regions, units);
+  }
+
+  return blocks;
+}
+
+/** A unit's first choice: its code until it runs, then its regions; and its limits. */
+interface Unit {
+  code: string | null;
+  regions: avm1.Region[] | null;
+  high: number;
+  reach: number;
+}
+
+/**
+ * A SWF's units, each compiled as control first goes on in it: first the
+ * one of a region and bytes that end at the next bound of a block, which
+ * most regions can run, else the region's own (codegen's module.ts).
+ */
+function unitsOf(
+  codegen: Codegen,
+  bytes: Uint8Array,
+  actions: ActionBlocks,
+  blocks: avm1.Blocks,
+  known: WeakMap<avm1.Region[], avm1.Units>,
+  evaluate: (entry: string, name: string) => avm1.Region[],
+): avm1.Units {
+  const bounds = blockBounds(bytes.length, actions);
+  // By offset, twice and once more for SWF 5's functions; by key, those of a region alone.
+  const first = new Map<number, Unit>();
+  const own = new avm1.OwnUnits<avm1.Region[]>();
+  // Units of the same code are one, as the module writes them once: by
+  // the code's hash and length, the code itself not kept.
+  const byCode = new Map<number, avm1.Region[][]>();
+  const units: avm1.Units = {
+    blocks,
+    unit(at, end, bound, five) {
+      const index = at * 2 + (five ? 1 : 0);
+      let unit = first.get(index);
+      if (unit === undefined) {
+        const segment = segmentEnd(bounds, bytes.length, at);
+        const compiled = codegen.compileActionUnit(bytes, actions, {
+          at,
+          end: segment,
+          bound: segment,
+          five,
+        });
+        // One that only its own region runs never runs as a first choice.
+        unit = { ...compiled, code: compiled.high >= 0 ? compiled.code : null, regions: null };
+        first.set(index, unit);
+      }
+
+      if (unit.high >= 0 && unit.high <= end && unit.reach <= bound) {
+        if (unit.regions === null) {
+          unit.regions = regionsOf(unit.code ?? "", at);
+          unit.code = null;
+        }
+
+        return unit.regions;
+      }
+
+      let regions = own.get(at, end, bound, five);
+      if (regions === undefined) {
+        const { code } = codegen.compileActionUnit(bytes, actions, { at, end, bound, five });
+        regions = regionsOf(code, at);
+        own.set(at, end, bound, five, regions);
+      }
+
+      return regions;
+    },
+  };
+  const regionsOf = (code: string, at: number): avm1.Region[] => {
+    const hash = hashOf(code);
+    const same = byCode.get(hash);
+    for (const regions of same ?? []) {
+      // The regions' source is the code they were made of.
+      if (`[${regions.join(", ")}]` === code) {
+        return regions;
+      }
+    }
+
+    const regions = evaluate(code, `at-${at}`);
+    known.set(regions, units);
+    if (same === undefined) {
+      byCode.set(hash, [regions]);
+    } else {
+      same.push(regions);
+    }
+
+    return regions;
+  };
+  return units;
+}
+
+/** FNV-1a of `text`'s code units, and its length. */
+function hashOf(text: string): number {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < text.length; i++) {
+    hash = Math.imul(hash ^ text.charCodeAt(i), 0x01000193);
+  }
+
+  return (hash >>> 0) * 0x100000 + (text.length & 0xfffff);
+}
+
+/** The starts and ends of the SWF's blocks within its bytes, ascending, once each. */
+function blockBounds(size: number, actions: ActionBlocks): number[] {
+  const bounds = new Set<number>();
+  for (const { offset, length } of actions.blocks) {
+    if (offset >= 0 && length >= 0 && offset + length <= size) {
+      bounds.add(offset);
+      bounds.add(offset + length);
+    }
+  }
+
+  return [...bounds].sort((a, b) => a - b);
+}
+
+/** The first of `bounds` past `at`, else the SWF's end, as codegen's units.ts finds it. */
+function segmentEnd(bounds: number[], size: number, at: number): number {
+  let low = 0;
+  let high = bounds.length;
+  while (low < high) {
+    const mid = (low + high) >>> 1;
+    if (bounds[mid] <= at) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+
+  return low < bounds.length ? bounds[low] : size;
+}

package/src/avm1/external.ts

@@ -0,0 +1,99 @@
+// What an AVM1 movie's calls out to the page are let through by: the page's
+// ExternalInterface, where every SWF calling it is allowed, and the URLs of
+// the SWFs whose code calls it or fscommand, known by their compiled blocks
+// (docs/avm1.md, "ExternalInterface").
+import type { avm1 } from "@swf2es/runtime";
+import type { MovieClip } from "../display/display.js";
+import type { ExternalInterfaceHost } from "../hosts.js";
+import type { Avm1 } from "./avm1.js";
+import type { ExternalHost } from "./globals/ExternalInterface.js";
+import type { Avm1Swf } from "./swf.js";
+
+type Value = avm1.Value;
+
+/** The page's ExternalInterface, and the SWFs that call out to the page. */
+export class ExternalCalls implements ExternalHost {
+  /** Each SWF's blocks, by which a function's or block's code is known as that SWF's. */
+  private readonly codeSwfs = new WeakMap<avm1.Region[], Avm1Swf>();
+  /** The URLs of every SWF that has had code to run, unloaded ones too. */
+  private readonly codeUrls = new Set<string>();
+
+  constructor(
+    private readonly movie: Avm1,
+    private readonly host: ExternalInterfaceHost | null,
+  ) {}
+
+  get realm(): avm1.Realm {
+    return this.movie.realm;
+  }
+
+  /**
+   * The page's ExternalInterface, where it lets the code calling use it:
+   * the SWF whose block or function is running, known by its code; where
+   * a native is called with no code of a SWF's running, as a timer, a
+   * network callback or the page's call calls one straight, every SWF that
+   * has run code so far must be allowed, as AS3's natives ask when they
+   * cannot tell their caller (hosts.ts's allows). The clip a function was
+   * made in is not enough: a load can put another SWF in it.
+   */
+  externalBridge(): ExternalInterfaceHost | null {
+    const host = this.host;
+    const allows = host?.allows;
+    if (host === null || allows === undefined) {
+      return host;
+    }
+
+    return this.callerUrls().every((url) => allows.call(host, url)) ? host : null;
+  }
+
+  /**
+   * The URL of the SWF whose code is running, known by its blocks; where
+   * no SWF's code is running, as a timer, a network callback or the page
+   * calls a native straight, every URL of a SWF that has had code.
+   */
+  callerUrls(): string[] {
+    // A unit's code is its SWF's blocks'.
+    const code = this.movie.realm.current?.code ?? [];
+    const caller = this.codeSwfs.get(this.movie.realm.units.get(code)?.blocks[0] ?? code);
+    return caller !== undefined ? [caller.url] : [...this.codeUrls];
+  }
+
+  /** `swf`'s code compiled: its blocks known as its own, and its URL among those that ran code. */
+  ownCode(swf: Avm1Swf): void {
+    for (const block of swf.blocks) {
+      this.codeSwfs.set(block, swf);
+    }
+
+    if (swf.blocks.length > 0) {
+      this.codeUrls.add(swf.url);
+    }
+  }
+
+  /**
+   * `body`, the page's call into a callback, run between frames or inside
+   * a call out, in the root's activation as a timer's callback runs, and
+   * what it queued run after it: what it returned, undefined where it did
+   * not run or threw.
+   */
+  callIn(body: () => Value): Value {
+    const movie = this.movie;
+    const root = movie.root as MovieClip | null;
+    const cx = root === null || movie.halted || !movie.loaded ? null : movie.activationOf(root);
+    if (cx === null) {
+      return undefined;
+    }
+
+    let result: Value;
+    movie.timers.begin();
+    try {
+      movie.rt.call(cx, () => {
+        result = body();
+      });
+      movie.queue.run();
+    } finally {
+      movie.timers.end();
+    }
+
+    return result;
+  }
+}

package/src/avm1/focus.ts

@@ -0,0 +1,342 @@
+// An AVM1 movie's focus, as Ruffle's FocusTracker keeps it: what has it,
+// whether its highlight shows, and the events a move of it sends. Its
+// tab order, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/focus_tracker.rs and display_object/container.rs fill it: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+// The display list is walked as it is drawn, each object before what is in
+// it; a hidden object is left out with what is in it, and so is what is in
+// a clip whose tabChildren is false. Once any object has a tabIndex, the
+// order is by tabIndex, objects of equal ones as walked, and those without
+// one are left out; otherwise it is by place, 6 × y + x of each object's
+// top left corner on the stage in twips, of which only the first walked at
+// a place is kept, as Ruffle keeps it.
+import { ClipEvent } from "@swf2es/format";
+import { avm1 } from "@swf2es/runtime";
+import { boundsIn } from "../display/bounds.js";
+import {
+  ButtonObject,
+  CONTENT,
+  Container,
+  type DisplayObject,
+  MovieClip,
+  TextObject,
+} from "../display/display.js";
+import type { Avm1 } from "./avm1.js";
+import { nativeOf } from "./globals/MovieClip.js";
+import { stateOf } from "./globals/TextField.js";
+
+/** What the tab order reads of the movie's objects, their AS2 properties as code reads them. */
+export interface TabHost {
+  /** A tabEnabled set, or undefined where none is. */
+  tabEnabled(d: DisplayObject): boolean | undefined;
+  /** tabChildren, true where it is not set. */
+  tabChildren(d: DisplayObject): boolean;
+  /** A tabIndex set, as an int, or undefined where none is. */
+  tabIndex(d: DisplayObject): number | undefined;
+  buttonMode(clip: MovieClip): boolean;
+}
+
+interface Tabbed {
+  d: DisplayObject;
+  index: number | undefined;
+}
+
+/** The objects Tab moves the focus through, in order, from `root`, on `stage`. */
+function tabOrder(root: MovieClip, stage: Container, host: TabHost): DisplayObject[] {
+  const found: Tabbed[] = [];
+  let custom = false;
+  const walk = (d: DisplayObject) => {
+    if (!d.visible) {
+      return;
+    }
+
+    if (d !== root && tabbable(d, host)) {
+      const index = host.tabIndex(d);
+      custom ||= index !== undefined;
+      found.push({ d, index });
+    }
+
+    // A button's states are no part of the order.
+    if (d instanceof Container && !(d instanceof ButtonObject) && host.tabChildren(d)) {
+      for (const child of d.children) {
+        walk(child);
+      }
+    }
+  };
+  walk(root);
+
+  if (custom) {
+    // Array.prototype.sort is stable: equal indices keep the walk's order.
+    return found
+      .filter((t) => t.index !== undefined)
+      .sort((a, b) => (a.index as number) - (b.index as number))
+      .map((t) => t.d);
+  }
+
+  const placed = found.map((t) => ({ d: t.d, key: placeKey(t.d, stage) }));
+  placed.sort((a, b) => a.key - b.key);
+  return placed.filter((p, i) => i === 0 || p.key !== placed[i - 1].key).map((p) => p.d);
+}
+
+/**
+ * Whether Tab reaches `d`: a button, or an input field, unless its
+ * tabEnabled is false; a clip whose tabEnabled is true, or, where it is not
+ * set, one in button mode or with a tabIndex.
+ */
+function tabbable(d: DisplayObject, host: TabHost): boolean {
+  if (d instanceof TextObject) {
+    return d.type === "input" && (host.tabEnabled(d) ?? true);
+  }
+
+  if (d instanceof ButtonObject) {
+    return host.tabEnabled(d) ?? true;
+  }
+
+  if (d instanceof MovieClip) {
+    return host.tabEnabled(d) ?? (host.buttonMode(d) || host.tabIndex(d) !== undefined);
+  }
+
+  return false;
+}
+
+/** 6 × y + x of `d`'s top left corner on the stage, in twips: a button's hit area's. */
+function placeKey(d: DisplayObject, stage: Container): number {
+  const area = d instanceof ButtonObject ? d.hitTestState : null;
+  const parent = area?.parent ?? null;
+  if (area) {
+    area.parent = d as ButtonObject;
+  }
+
+  try {
+    const r = boundsIn(area ?? d, stage, stage, true);
+    return 6 * Math.round(r.yMin * 20) + Math.round(r.xMin * 20);
+  } finally {
+    if (area) {
+      area.parent = parent;
+    }
+  }
+}
+
+/** The movie's focus: the object that has it, its highlight, and Tab's and Enter's moves of it. */
+export class FocusTracker implements TabHost {
+  /** `_global.Selection`, whose listeners hear the focus move. */
+  selectionFace: avm1.Avm1Object | null = null;
+  /** The button or clip with the focus. */
+  focusedObject: DisplayObject | null = null;
+  /**
+   * Whether keyboard navigation shows the focus (Ruffle's highlight): a
+   * focused object's onKeyDown and onKeyUp fire while it is not inactive,
+   * and Enter and Space press it while it is visible.
+   */
+  highlight: "inactive" | "visible" | "hidden" = "inactive";
+
+  constructor(private readonly movie: Avm1) {}
+
+  get focused(): DisplayObject | null {
+    return this.focusedObject;
+  }
+
+  /**
+   * Focus `d`, or none: where it changes, the one that had it hears
+   * onKillFocus(new), `d` onSetFocus(old), then Selection's listeners
+   * onSetFocus(old, new), at once, not queued (Ruffle's FocusTracker). The
+   * highlight shows where `d` may show it.
+   */
+  focus(d: DisplayObject | null): void {
+    const old = this.focusedObject;
+    this.focusedObject = d;
+    this.highlight =
+      d === null
+        ? "inactive"
+        : !(d instanceof TextObject) && this.highlightable(d)
+          ? "visible"
+          : "hidden";
+    if (d === old) {
+      this.selectFocused();
+      return;
+    }
+
+    // A field that loses the focus loses its selection.
+    if (old instanceof TextObject) {
+      old.focused = false;
+      stateOf(old).selected = false;
+      old.invalidate(CONTENT);
+    }
+
+    if (d instanceof TextObject) {
+      d.focused = true;
+      d.invalidate(CONTENT);
+    }
+
+    // Each object's method in an activation of its own, as its other event methods run.
+    const version = this.movie.version;
+    const oldFace = old?.avm1 ?? null;
+    const newFace = d?.avm1 ?? null;
+    this.movie.timers.begin();
+    try {
+      const oldCx = old === null ? null : this.movie.activationOf(old);
+      if (oldFace !== null && oldCx !== null) {
+        this.movie.rt.callMethod(oldCx, oldFace, "onKillFocus", [newFace], version);
+      }
+
+      const newCx = d === null ? null : this.movie.activationOf(d);
+      if (newFace !== null && newCx !== null) {
+        this.movie.rt.callMethod(newCx, newFace, "onSetFocus", [oldFace], version);
+      }
+
+      const selection = this.selectionFace;
+      const cx = this.movie.root !== null ? this.movie.activationOf(this.movie.root) : null;
+      if (selection !== null && cx !== null) {
+        this.movie.rt.call(cx, () => {
+          avm1.broadcastMessage(selection, "onSetFocus", [oldFace, newFace], version);
+        });
+      }
+    } finally {
+      this.movie.timers.end();
+    }
+
+    this.selectFocused();
+  }
+
+  /**
+   * A field given the focus, again too, has all its text selected, after
+   * the focus's events, which see none (Ruffle's update_edittext_selection;
+   * the corpus's `selection` and `edittext_programmatic_focus`).
+   */
+  private selectFocused(): void {
+    const d = this.focusedObject;
+    if (d instanceof TextObject) {
+      stateOf(d).selected = true;
+      d.select(0, d.model.text.length);
+    }
+  }
+
+  /** Whether a script may focus `d`: a button, or a clip below the root in button mode or with focusEnabled true. */
+  focusable(d: DisplayObject): boolean {
+    // A field, selectable or not, as a script may focus any (Ruffle).
+    if (d instanceof ButtonObject || d instanceof TextObject) {
+      return true;
+    }
+
+    return (
+      d instanceof MovieClip &&
+      d !== this.movie.root &&
+      (this.movie.input.buttonMode(d) ||
+        avm1.toBoolean(this.movie.input.read(d, "focusEnabled"), this.movie.version))
+    );
+  }
+
+  /**
+   * Whether the focus shows on `d`: not the root, something drawn, and its
+   * `_focusrect`, from SWF 6 its own where it has one, else the stage's.
+   */
+  private highlightable(d: DisplayObject): boolean {
+    if (d === this.movie.root || d.parent === null) {
+      return false;
+    }
+
+    const own = this.movie.version >= 6 ? (nativeOf(d)?.focusRect ?? null) : null;
+    if (!(own ?? this.movie.focusRect)) {
+      return false;
+    }
+
+    // A button's by its hit area, which it is tested by whatever it shows.
+    const area = d instanceof ButtonObject ? d.hitTestState : null;
+    const parent = area?.parent ?? null;
+    if (area) {
+      area.parent = d as ButtonObject;
+    }
+
+    try {
+      const r = boundsIn(area ?? d, d.parent, null, true);
+      return r.xMax > r.xMin || r.yMax > r.yMin;
+    } finally {
+      if (area) {
+        area.parent = parent;
+      }
+    }
+  }
+
+  tabEnabled(d: DisplayObject): boolean | undefined {
+    const value = this.movie.input.read(d, "tabEnabled");
+    return value === undefined ? undefined : avm1.toBoolean(value, this.movie.version);
+  }
+
+  tabChildren(d: DisplayObject): boolean {
+    const value = this.movie.input.read(d, "tabChildren");
+    return value === undefined || avm1.toBoolean(value, this.movie.version);
+  }
+
+  buttonMode(clip: MovieClip): boolean {
+    return this.movie.input.buttonMode(clip);
+  }
+
+  /** A tabIndex as an int: a number's or a boolean's, any other value's the least; -1 is none (Ruffle). */
+  tabIndex(d: DisplayObject): number | undefined {
+    const value = this.movie.input.read(d, "tabIndex");
+    if (value === undefined || value === null) {
+      return undefined;
+    }
+
+    const index =
+      typeof value === "number" || typeof value === "boolean"
+        ? avm1.toNumber(value, this.movie.version) | 0
+        : -2147483648;
+    return index === -1 ? undefined : index;
+  }
+
+  /** Tab, or Shift+Tab: the focus to the next object in the tab order, or the one before, round. */
+  tab(reverse: boolean): boolean {
+    const root = this.movie.root;
+    const stage = root?.parent;
+    if (!(root instanceof MovieClip) || !stage) {
+      return false;
+    }
+
+    const order = tabOrder(root, stage, this);
+    if (order.length === 0) {
+      return false;
+    }
+
+    const at = this.focusedObject === null ? -1 : order.indexOf(this.focusedObject);
+    const step = reverse ? order.length - 1 : 1;
+    const next = at < 0 ? (reverse ? order.length - 1 : 0) : (at + step) % order.length;
+    this.focus(order[next]);
+    return true;
+  }
+
+  /**
+   * Enter or Space on what has the focus, where the highlight shows: a press
+   * and a release of it. Whether it was pressed, the key then the SWF's.
+   */
+  activate(): boolean {
+    const d = this.focusedObject;
+    if (
+      this.highlight !== "visible" ||
+      d === null ||
+      this.movie.removed(d) ||
+      !this.movie.input.flag(d, "enabled")
+    ) {
+      return false;
+    }
+
+    this.movie.input.buttonDispatch(d, ClipEvent.press);
+    this.movie.input.buttonDispatch(d, ClipEvent.release);
+    return true;
+  }
+
+  /**
+   * The pointer's input, which hides the focus's highlight until Tab moves
+   * the focus again: a left press always, and, below SWF 9, any press,
+   * release or move.
+   */
+  pointerInput(type: "move" | "down" | "up", button: number): void {
+    const left = button === 0;
+    if (
+      (type === "down" && left) ||
+      (this.movie.version < 9 && (left || button === 2 || type === "move"))
+    ) {
+      this.highlight = "inactive";
+    }
+  }
+}