@swf2es/player 0.0.0-stage → 0.1.0

package/src/avm1/globals/SharedObject.ts

@@ -0,0 +1,300 @@
+// SharedObject, AS1 and AS2's local kind, as Ruffle's (https://github.com/
+// ruffle-rs/ruffle) core/src/avm1/globals/shared_object.rs and
+// core/src/avm1/amf.rs have it: MIT OR Apache-2.0, Copyright (c) 2018-2022
+// Ruffle LLC and Ruffle contributors. Its data is kept in the host's
+// storage as the .sol file Flash writes for AVM1, AMF0, under the key AS3's
+// SharedObject uses (playerglobal/flash/net/SharedObject.ts), so that
+// one SWF's saves are found whichever AVM reads them.
+//
+// A .sol file: 0x00BF, the length of what follows, "TCSO", 00 04 00 00 00
+// 00, the name (u16 length, UTF-8), the AMF version as a u32 (0 here), then
+// each of the data's properties: its name (u16 length), its AMF0 value, a 0.
+import { avm1 } from "@swf2es/runtime";
+import type { SharedObjectStorage } from "../../hosts.js";
+import { put, Reader, Writer } from "../amf.js";
+
+const encoder = new TextEncoder();
+
+type Value = avm1.Value;
+type Obj = avm1.Avm1Object;
+
+/** What SharedObject reads of the movie. */
+export interface SharedObjectHost {
+  readonly realm: avm1.Realm;
+  /** The SWF's URL, which the key is made of. */
+  readonly url: string;
+  readonly storage: SharedObjectStorage;
+  /** The name Object.registerClass gave `constr`, which AMF0 writes an object of as typed; null for none. */
+  registeredName(constr: Value): string | null;
+}
+
+/** What a name may not hold, white space included: getLocal then gives null (adl; Ruffle's INVALID_CHARS). */
+const BAD_NAME = /[~%&\\;:"',<>?#\s]/;
+
+/** The .sol file of `data` under `name`: empty for no properties, as Flash writes none. */
+function serialize(host: SharedObjectHost, name: string, data: Value, version: number): Uint8Array {
+  if (!(data instanceof avm1.Avm1Object)) {
+    return new Uint8Array(0);
+  }
+
+  const body = new Writer((c) => host.registeredName(c), version, data);
+  // Each property a name, a value and a 0, the object's own references shared across them.
+  const entry = new Writer((c) => host.registeredName(c), version, data);
+  for (const key of avm1.keys(data, version).reverse()) {
+    const v = avm1.find(data, key, version)?.get ? undefined : avm1.get(data, key, version);
+    if (v instanceof avm1.Avm1Function) {
+      continue;
+    }
+
+    entry.name(key);
+    entry.value(v);
+    entry.bytes(0);
+  }
+
+  if (entry.size === 0) {
+    return new Uint8Array(0);
+  }
+
+  const title = encoder.encode(name).subarray(0, 0xffff);
+  body.bytes(0x00, 0xbf);
+  body.u32(0);
+  body.bytes(0x54, 0x43, 0x53, 0x4f, 0, 4, 0, 0, 0, 0);
+  body.u16(title.length);
+  body.push(title);
+  body.u32(0);
+  body.push(entry.finish());
+
+  const file = body.finish();
+
+  new DataView(file.buffer).setUint32(2, file.length - 6);
+  return file;
+}
+
+/** The data a .sol file holds, or null for one that is not AMF0's or cannot be read. */
+function deserialize(bytes: Uint8Array, realm: avm1.Realm, version: number): Obj | null {
+  if (bytes.length < 18 || bytes[0] !== 0x00 || bytes[1] !== 0xbf) {
+    return null;
+  }
+
+  const reader = new Reader(bytes, realm, version, true, Infinity);
+  const data = realm.newObject(version);
+  try {
+    reader.at = 16;
+    reader.name();
+    // An AMF3 file, AS3's, is not AS2's to read.
+    if (reader.u32() !== 0) {
+      return null;
+    }
+
+    while (reader.at < bytes.length) {
+      const key = reader.name();
+      put(data, key, reader.value(), version);
+      // The 0 after each value.
+      reader.at++;
+    }
+  } catch {
+    return null;
+  }
+
+  return data;
+}
+
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE;
+
+/** `_global.SharedObject`, and what writes its objects changed since read or written, as a player goes. */
+export function sharedObjectClass(host: SharedObjectHost): {
+  constr: Obj;
+  flush(version: number): void;
+} {
+  const realm = host.realm;
+  const proto = new avm1.Avm1Object(realm.objectProto);
+  const constr = realm.classOf(
+    proto,
+    (self) => self,
+    () => undefined,
+  );
+  /** The objects getLocal made, by key, and what each was last read or written as. */
+  const open = new Map<string, { o: Obj; name: string; saved: Uint8Array }>();
+  const entryOf = (self: Obj) => {
+    for (const entry of open.values()) {
+      if (entry.o === self) {
+        return entry;
+      }
+    }
+
+    return undefined;
+  };
+  const method = (name: string, f: avm1.Native) => proto.define(name, realm.method(f), FIXED);
+  const stub = () => undefined;
+
+  constr.define(
+    "getLocal",
+    realm.method((_, args, v) => {
+      const name = avm1.stringOf(args[0], v);
+      if (name === "" || BAD_NAME.test(name)) {
+        return null;
+      }
+
+      let url: URL;
+      try {
+        url = new URL(host.url, "file:///");
+      } catch {
+        return null;
+      }
+
+      const secure = args.length > 2 && avm1.toBoolean(args[2], v);
+      if (secure && url.protocol !== "https:") {
+        return null;
+      }
+
+      // The SWF's own path by default; a path it names must lead to the SWF, as AS3's.
+      const own = url.pathname.endsWith("/") ? `${url.pathname}[swf]` : url.pathname;
+      let path = own;
+      if (args.length > 1 && typeof args[1] === "string") {
+        path = args[1];
+        if (path === "") {
+          return null;
+        }
+
+        const directory = path.endsWith("/") ? path : `${path}/`;
+        if (path !== own && !own.startsWith(directory)) {
+          return null;
+        }
+      }
+
+      const key = `${url.host}${path.startsWith("/") ? "" : "/"}${path}/${name}${secure ? "#secure" : ""}`;
+      if (key.split("/").some((part) => part.startsWith("."))) {
+        return null;
+      }
+
+      const known = open.get(key);
+      if (known) {
+        return known.o;
+      }
+
+      const o = new avm1.Avm1Object(avm1.get(constr, "prototype", v));
+      let stored: Uint8Array | null = null;
+      try {
+        stored = host.storage.get(key);
+      } catch {
+        stored = null;
+      }
+
+      const data = (stored && deserialize(stored, realm, v)) ?? realm.newObject(v);
+      o.define("data", data, avm1.DONT_DELETE);
+      open.set(key, { o, name, saved: serialize(host, name, data, v) });
+      return o;
+    }),
+    0,
+  );
+  constr.define("getRemote", realm.method(stub), 0);
+  constr.define("deleteAll", realm.method(stub), avm1.DONT_ENUM);
+  constr.define("getDiskUsage", realm.method(stub), avm1.DONT_ENUM);
+
+  // Written now: true, or false where storage refuses it, a full quota say. Flash writes no
+  // empty one, and says it did.
+  method("flush", (self, _, v) => {
+    const entry = entryOf(self);
+    if (!entry) {
+      return undefined;
+    }
+
+    // Data nested too deep to write fails as a refused write does.
+    let file: Uint8Array;
+    try {
+      file = serialize(host, entry.name, avm1.get(self, "data", v), v);
+    } catch {
+      return false;
+    }
+
+    if (file.length === 0) {
+      return true;
+    }
+
+    for (const [key, e] of open) {
+      if (e === entry) {
+        try {
+          host.storage.set(key, file);
+        } catch {
+          return false;
+        }
+      }
+    }
+
+    entry.saved = file;
+    return true;
+  });
+  // The file's size, header and all; 0 for none.
+  method("getSize", (self, _, v) => {
+    const entry = entryOf(self);
+    if (!entry) {
+      return undefined;
+    }
+
+    try {
+      return serialize(host, entry.name, avm1.get(self, "data", v), v).length;
+    } catch {
+      return 0;
+    }
+  });
+  // Every property of the data deleted, and the file with them.
+  method("clear", (self, _, v) => {
+    const entry = entryOf(self);
+    const data = avm1.get(self, "data", v);
+    if (data instanceof avm1.Avm1Object) {
+      for (const key of avm1.keys(data, v)) {
+        avm1.removeOwn(data, key, v);
+      }
+    }
+
+    for (const [key, e] of open) {
+      if (e === entry) {
+        try {
+          host.storage.remove(key);
+        } catch {
+          // Storage the host refuses keeps nothing to remove.
+        }
+
+        e.saved = new Uint8Array(0);
+      }
+    }
+
+    return undefined;
+  });
+  for (const name of ["connect", "send", "close", "setFps", "onStatus", "onSync"]) {
+    method(name, stub);
+  }
+
+  return {
+    constr,
+    // Flash wrote each open object as its SWF went: what a script changed since it was read or
+    // written. Never a removal: an object whose stored file could not be read starts empty.
+    flush(version) {
+      for (const [key, entry] of open) {
+        try {
+          const file = serialize(host, entry.name, avm1.get(entry.o, "data", version), version);
+          if (file.length && !sameBytes(file, entry.saved)) {
+            host.storage.set(key, file);
+            entry.saved = file;
+          }
+        } catch {
+          // One that cannot be written keeps the others from nothing.
+        }
+      }
+    },
+  };
+}
+
+function sameBytes(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/avm1/globals/Sound.ts

@@ -0,0 +1,326 @@
+// Sound, AS1 and AS2's, as Ruffle's (https://github.com/ruffle-rs/ruffle)
+// core/src/avm1/globals/sound.rs has it: MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors. A Sound keeps its target
+// as given and finds the clip again each time it is used: its transform is
+// the clip's, which every sound under the clip plays by; with no target it
+// is the global one, over every sound. The sounds it starts are the
+// timeline's kind, held to the same 32 and stopped with them.
+import { avm1 } from "@swf2es/runtime";
+import type { DisplayObject } from "../../display/display.js";
+import type { SoundCharacter } from "../../display/timeline.js";
+import type { SoundMix } from "../../media/audio.js";
+import {
+  type SoundHost,
+  soundsOf,
+  startScriptSound,
+  stopSoundsOf,
+  stopTimelineSound,
+  stopTimelineSounds,
+  type TimelineSound,
+} from "../../media/sounds.js";
+
+type Obj = avm1.Avm1Object;
+
+/** A transform as AVM1 keeps it: whole percentages, as getVolume and getTransform give them back. */
+export interface Avm1SoundTransform {
+  volume: number;
+  leftToLeft: number;
+  leftToRight: number;
+  rightToLeft: number;
+  rightToRight: number;
+}
+
+export const FULL: Readonly<Avm1SoundTransform> = {
+  volume: 100,
+  leftToLeft: 100,
+  leftToRight: 0,
+  rightToLeft: 0,
+  rightToRight: 100,
+};
+
+/** What Sound reads of the movie. */
+export interface SoundClassHost {
+  readonly realm: avm1.Realm;
+  readonly sounds: SoundHost;
+  /** What `value`, an object or a path from the code's target, names; null for nothing. */
+  resolve(value: avm1.Value, version: number): DisplayObject | null;
+  /** The DefineSound ExportAssets named `name`, any case; null for none. */
+  exportedSound(name: string): SoundCharacter | null;
+  /** `d`'s transform, the global one for null. */
+  soundTransform(d: DisplayObject | null): Avm1SoundTransform;
+  /** `d`'s transform, the global one for null, set: the sounds playing follow it. */
+  setSoundTransform(d: DisplayObject | null, transform: Avm1SoundTransform): void;
+  /** `o.onSoundComplete()`, as the frame's actions run. */
+  complete(o: Obj): void;
+}
+
+interface State {
+  /** The target as given; undefined or null for the global sound. */
+  target: avm1.Value;
+  character: SoundCharacter | null;
+  /** The ms attachSound found, rounded. */
+  duration: number | undefined;
+  playing: TimelineSound | null;
+  /** Where start began, in ms, for the position while it plays. */
+  offset: number;
+  /** The position once it stopped or ended. */
+  position: number;
+}
+
+const FIXED = avm1.DONT_ENUM | avm1.DONT_DELETE | avm1.READ_ONLY;
+
+/**
+ * A volume or pan as Windows' Flash Player 32 and AIR take it: a 32-bit
+ * integer, wrapped, NaN 0. Ruffle's corpus (`sound`) expects another
+ * player's, which saturates, NaN to -2^31: a game that sets its sounds'
+ * volume from a setting not yet loaded, undefined, gets 0 from Flash.
+ */
+function int32(n: number): number {
+  return n | 0;
+}
+
+/** loops as Rust's `as u16` casts it, at least 1. */
+function loopsOf(n: number): number {
+  return Math.max(1, Number.isNaN(n) ? 0 : Math.trunc(Math.max(0, Math.min(0xffff, n))));
+}
+
+/**
+ * The pan as Flash gives it back from the left and right volumes (Ruffle's
+ * `sound` test): it is neither's plain difference.
+ */
+function panOf(t: Avm1SoundTransform): number {
+  return t.leftToLeft !== 100 ? 100 - Math.abs(t.leftToLeft) : Math.abs(t.rightToRight) - 100;
+}
+
+/** `_global.Sound`. */
+export function soundClass(host: SoundClassHost): Obj {
+  const realm = host.realm;
+  const h = host.sounds;
+  const states = new WeakMap<Obj, State>();
+  const proto = new avm1.Avm1Object(realm.objectProto);
+  const constr = realm.classOf(
+    proto,
+    (self, args, v) => {
+      // The target is made a path now, a clip's too, its toString called once (the corpus's
+      // sound_owner_reference): a clip renamed is found by its path, as a variable or a child.
+      const given = args.length > 0 ? args[0] : undefined;
+      const target = given === undefined || given === null ? given : avm1.stringOf(given, v);
+      states.set(self, {
+        target,
+        character: null,
+        duration: undefined,
+        playing: null,
+        offset: 0,
+        position: 0,
+      });
+      return self;
+    },
+    () => undefined,
+  );
+
+  const global = (state: State) => state.target === undefined || state.target === null;
+  // The clip a targeted Sound works on, null where the target names none.
+  const owner = (state: State, v: number) => (global(state) ? null : host.resolve(state.target, v));
+  const valid = (state: State, v: number) => global(state) || owner(state, v) !== null;
+  // The transform it reads and sets: its clip's, or the global one; undefined for no clip.
+  const transformOf = (state: State, v: number): Avm1SoundTransform | undefined => {
+    if (global(state)) {
+      return host.soundTransform(null);
+    }
+
+    const d = owner(state, v);
+    return d === null ? undefined : host.soundTransform(d);
+  };
+  const setTransform = (state: State, v: number, f: (t: Avm1SoundTransform) => void) => {
+    const g = global(state);
+    const d = g ? null : owner(state, v);
+    if (g || d !== null) {
+      const t = { ...host.soundTransform(d) };
+      f(t);
+      host.setSoundTransform(d, t);
+    }
+  };
+  // Where it plays: from its offset, each loop after the first from the offset again, as the
+  // device loops it; where it was stopped, by whatever stopped it; the end once it ended.
+  const positionOf = (state: State): number => {
+    const playing = state.playing;
+    if (playing === null || playing.endedAt !== null) {
+      return state.position;
+    }
+
+    const length = state.duration ?? 0;
+    const elapsed = Math.max(0, (playing.stoppedAt ?? h.now) - playing.started);
+    const loop = length - state.offset;
+    return Math.round(state.offset + (loop > 0 && elapsed >= loop ? elapsed % loop : elapsed));
+  };
+  const method = (
+    name: string,
+    f: (state: State, args: avm1.Value[], v: number, self: Obj) => avm1.Value,
+    flags = 0,
+  ) =>
+    proto.define(
+      name,
+      realm.method((self, args, v) => {
+        const state = states.get(self);
+        return state === undefined ? undefined : f(state, args, v, self);
+      }),
+      FIXED | flags,
+    );
+  const duration = (state: State, _: avm1.Value[], v: number) =>
+    valid(state, v) ? state.duration : undefined;
+  const position = (state: State, _: avm1.Value[], v: number) =>
+    state.character !== null && valid(state, v) ? positionOf(state) : undefined;
+
+  method("getPan", (state, _, v) => {
+    const t = transformOf(state, v);
+    return t === undefined ? undefined : panOf(t);
+  });
+  // Surprisingly, lr is right to left and rl left to right (Ruffle).
+  method("getTransform", (state, _, v) => {
+    const t = transformOf(state, v);
+    if (t === undefined) {
+      return undefined;
+    }
+
+    const o = realm.newObject(v);
+    avm1.set(o, "ll", t.leftToLeft, v);
+    avm1.set(o, "lr", t.rightToLeft, v);
+    avm1.set(o, "rr", t.rightToRight, v);
+    avm1.set(o, "rl", t.leftToRight, v);
+    return o;
+  });
+  method("getVolume", (state, _, v) => transformOf(state, v)?.volume);
+  method("setPan", (state, args, v) => {
+    const pan = int32(avm1.toNumber(args.length > 0 ? args[0] : 0, v));
+    setTransform(state, v, (t) => {
+      t.leftToLeft = pan >= 0 ? 100 - pan : 100;
+      t.rightToRight = pan >= 0 ? 100 : 100 + pan;
+      t.leftToRight = 0;
+      t.rightToLeft = 0;
+    });
+    return undefined;
+  });
+  // Only the keys the object has of its own change, each wrapped to 32 bits.
+  method("setTransform", (state, args, v) => {
+    const o = args[0];
+    setTransform(state, v, (t) => {
+      if (!(o instanceof avm1.Avm1Object)) {
+        return;
+      }
+
+      const own = (key: string) =>
+        o.own(key, v) ? avm1.toNumber(avm1.get(o, key, v), v) | 0 : undefined;
+      t.leftToLeft = own("ll") ?? t.leftToLeft;
+      t.leftToRight = own("rl") ?? t.leftToRight;
+      t.rightToLeft = own("lr") ?? t.rightToLeft;
+      t.rightToRight = own("rr") ?? t.rightToRight;
+    });
+    return undefined;
+  });
+  method("setVolume", (state, args, v) => {
+    const volume = int32(avm1.toNumber(args.length > 0 ? args[0] : 0, v));
+    setTransform(state, v, (t) => {
+      t.volume = volume;
+    });
+    return undefined;
+  });
+  // A name stops every sound of that export, whoever started it; none, the
+  // sounds under its clip, or, for the global Sound, all of them.
+  method("stop", (state, args, v) => {
+    if (args.length > 0) {
+      const name = avm1.stringOf(args[0], v);
+      const character = valid(state, v) ? host.exportedSound(name) : null;
+      if (character !== null) {
+        stopSoundsOf(h, character);
+      }
+
+      return undefined;
+    }
+
+    if (global(state)) {
+      stopTimelineSounds(h);
+    } else {
+      const d = owner(state, v);
+      if (d !== null) {
+        for (const sound of soundsOf(h, d)) {
+          stopTimelineSound(h, sound);
+        }
+      }
+    }
+
+    return undefined;
+  });
+  method("attachSound", (state, args, v, self) => {
+    if (!valid(state, v)) {
+      return undefined;
+    }
+
+    const character = host.exportedSound(avm1.stringOf(args[0], v));
+    if (character === null) {
+      return undefined;
+    }
+
+    const definition = character.definition;
+    state.character = character;
+    state.duration = Math.round((definition.sampleCount * 1000) / definition.sampleRate);
+    state.position = 0;
+    // position and duration are the object's own from its first sound, as getters.
+    for (const [name, get] of [
+      ["position", position],
+      ["duration", duration],
+    ] as const) {
+      if (!avm1.has(self, name, v)) {
+        const p = self.add(name, undefined, avm1.DONT_ENUM | avm1.DONT_DELETE);
+        p.get = realm.method((o, a, version) => {
+          const s = states.get(o);
+          return s === undefined ? undefined : get(s, a, version);
+        });
+      }
+    }
+
+    return undefined;
+  });
+  // From `offset` seconds in, `loops` times.
+  method("start", (state, args, v, self) => {
+    if (!valid(state, v) || state.character === null) {
+      return undefined;
+    }
+
+    const offset = avm1.toNumber(args.length > 0 ? args[0] : 0, v) * 1000;
+    const loops = loopsOf(avm1.toNumber(args.length > 1 ? args[1] : 1, v));
+    const start = Number.isNaN(offset) ? 0 : Math.max(0, offset);
+    const sound = startScriptSound(h, owner(state, v), state.character, start, loops, () => {
+      if (state.playing === sound) {
+        state.position = state.duration ?? 0;
+      }
+
+      host.complete(self);
+    });
+    if (sound !== null) {
+      state.playing = sound;
+      state.offset = start;
+    }
+
+    return undefined;
+  });
+  method("getDuration", duration, avm1.VERSION_6);
+  method("setDuration", () => undefined, avm1.VERSION_6);
+  method("getPosition", position, avm1.VERSION_6);
+  method("setPosition", () => undefined, avm1.VERSION_6);
+  // Loading a sound by URL is not here yet: nothing starts, and onLoad never comes.
+  method("loadSound", () => undefined, avm1.VERSION_6);
+  method("getBytesLoaded", () => 1, avm1.VERSION_6);
+  method("getBytesTotal", () => 1, avm1.VERSION_6);
+  return constr;
+}
+
+/** An AVM1 transform as the device mixes it, from percentages to fractions. */
+export function mixOfTransform(t: Avm1SoundTransform): SoundMix {
+  return {
+    volume: t.volume / 100,
+    leftToLeft: t.leftToLeft / 100,
+    leftToRight: t.leftToRight / 100,
+    rightToLeft: t.rightToLeft / 100,
+    rightToRight: t.rightToRight / 100,
+  };
+}

package/src/avm1/globals/Stage.ts

@@ -0,0 +1,19 @@
+// AVM1's Stage singleton: its dimensions belong to the outer player,
+// including for a SWF loaded inside AS3. Flash exposes them as enumerable,
+// deletable getters, so assigning to them never changes the stage's size.
+import { avm1 } from "@swf2es/runtime";
+
+export interface StageSize {
+  readonly stageWidth: number;
+  readonly stageHeight: number;
+}
+
+export function stageObject(realm: avm1.Realm, size: StageSize): avm1.Avm1Object {
+  const stage = new avm1.Avm1Object(realm.objectProto);
+  // Older SWFs can reveal these functions by clearing their version flags.
+  avm1.initializeBroadcaster(stage, realm, 6);
+  stage.add("width", undefined, 0).get = realm.method(() => size.stageWidth);
+  stage.add("height", undefined, 0).get = realm.method(() => size.stageHeight);
+
+  return stage;
+}