@swf2es/player 0.0.0-stage → 0.1.1

package/src/avm1/globals/XMLSocket.ts

@@ -0,0 +1,267 @@
+// XMLSocket, AS1 and AS2's, as Ruffle's (https://github.com/ruffle-rs/
+// ruffle) core/src/avm1/globals/xml_socket.rs and core/src/socket.rs have
+// it: MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle
+// contributors. It connects through the host's sockets, as AS3's Socket
+// and XMLSocket do, so the same hosts serve both: the browser's refusal or
+// relay, the desktop app's TCP. Each message either way is a string ended
+// by a zero byte; each that comes is given to onData, whose default makes
+// an XML of it for onXML. Without a host, or refused, the connection fails
+// as Flash's does, with onConnect(false), never an error.
+import { avm1 } from "@swf2es/runtime";
+import type { SocketTransport } from "../../hosts.js";
+import { type Avm1Net, bytesFor, textFor } from "../net.js";
+
+type Value = avm1.Value;
+type Obj = avm1.Avm1Object;
+
+/** The SWF's domain, which a connect without a host goes to: localhost for a file's. */
+function swfDomain(url: string): string {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "file:" || !parsed.hostname ? "localhost" : parsed.hostname;
+  } catch {
+    return "localhost";
+  }
+}
+
+/** What XMLSocket needs of the movie. */
+export interface XmlSocketHost {
+  readonly realm: avm1.Realm;
+  readonly net: Avm1Net;
+  /** The SWF's URL, whose domain a connect without a host goes to. */
+  readonly url: string;
+  /** The SWF's version, which what comes is read by. */
+  readonly version: number;
+  /** `o[name](...args)`, as a callback between frames runs it. */
+  callback(o: Obj, name: string, args: Value[]): void;
+}
+
+interface Connection {
+  transport: SocketTransport | null;
+  /** Each connect and close starts a new one: events of an older are dropped. */
+  generation: number;
+  open: boolean;
+  /** What was sent before the connection opened, sent as it does. */
+  queued: Uint8Array[];
+  /** The bytes of a message not yet ended by its zero byte, as they came, and how many. */
+  partial: Uint8Array[];
+  partialLength: number;
+  timeout: number;
+}
+
+/**
+ * The most a message may hold before its zero byte: a server that never
+ * ends one has its connection closed, rather than the player's memory fill.
+ */
+const MAX_MESSAGE = 16 * 1024 * 1024;
+
+const decoder = new TextDecoder();
+
+/** `_global.XMLSocket`, given `_global.XML`'s constructor, which the default onData makes its XML with. */
+export function xmlSocketClass(host: XmlSocketHost, xml: avm1.Avm1Function): avm1.Avm1Function {
+  const realm = host.realm;
+  const connections = new WeakMap<Obj, Connection>();
+  const proto = new avm1.Avm1Object(realm.objectProto);
+  const constr = realm.classOf(
+    proto,
+    (self) => {
+      connections.set(self, {
+        transport: null,
+        generation: 0,
+        open: false,
+        queued: [],
+        partial: [],
+        partialLength: 0,
+        // Flash's default, 20 seconds.
+        timeout: 20000,
+      });
+      return self;
+    },
+    () => undefined,
+  );
+  // Each of them hidden from for..in (adl).
+  const HIDDEN = avm1.DONT_ENUM | avm1.DONT_DELETE;
+  const method = (name: string, fn: avm1.Native) => proto.define(name, realm.method(fn), HIDDEN);
+
+  /** The connection dropped, from the script's side or either end's: no event of it comes after. */
+  const drop = (c: Connection) => {
+    c.generation++;
+    if (c.transport !== null) {
+      host.net.closed(c.transport);
+    }
+
+    c.transport = null;
+    c.open = false;
+    c.queued = [];
+    c.partial = [];
+    c.partialLength = 0;
+  };
+
+  /**
+   * `bytes` come: each message they end to onData, while the connection is
+   * the one they came on. Only the new bytes are searched for a zero byte;
+   * what comes before one waits, up to MAX_MESSAGE.
+   */
+  const received = (self: Obj, c: Connection, generation: number, bytes: Uint8Array) => {
+    let start = 0;
+    for (let end = bytes.indexOf(0); end >= 0; end = bytes.indexOf(0, start)) {
+      let message: Uint8Array = bytes.subarray(start, end);
+      if (c.partialLength > 0) {
+        c.partial.push(message);
+        message = new Uint8Array(c.partialLength + message.length);
+        let at = 0;
+        for (const part of c.partial) {
+          message.set(part, at);
+          at += part.length;
+        }
+
+        c.partial = [];
+        c.partialLength = 0;
+      }
+
+      start = end + 1;
+      host.callback(self, "onData", [textFor(decoder.decode(message), host.version)]);
+      if (c.generation !== generation) {
+        return;
+      }
+    }
+
+    if (start < bytes.length) {
+      c.partial.push(bytes.slice(start));
+      c.partialLength += bytes.length - start;
+      if (c.partialLength > MAX_MESSAGE) {
+        drop(c);
+        host.callback(self, "onClose", []);
+      }
+    }
+  };
+
+  const timeout = proto.add("timeout", undefined, HIDDEN);
+  timeout.get = realm.method((self) => connections.get(self)?.timeout);
+  timeout.set = realm.method((self, args, v) => {
+    const c = connections.get(self);
+    if (c !== undefined) {
+      c.timeout = avm1.toNumber(args[0], v) >>> 0;
+    }
+
+    return undefined;
+  });
+  method("close", (self) => {
+    const c = connections.get(self);
+    if (c !== undefined && c.transport !== null) {
+      drop(c);
+    }
+
+    return undefined;
+  });
+  method("connect", (self, args, v) => {
+    const c = connections.get(self);
+    if (c === undefined) {
+      return undefined;
+    }
+
+    const given = args[0];
+    const name =
+      given === undefined || given === null ? swfDomain(host.url) : avm1.stringOf(given, v);
+    // A port out of range is refused, as AS3's Socket refuses it, and nothing connects.
+    const port = avm1.toNumber(args[1], v) | 0;
+    if (port < 0 || port > 0xffff) {
+      return false;
+    }
+
+    drop(c);
+    const generation = c.generation;
+    const current = () => c.generation === generation;
+    const failed = () => {
+      if (current()) {
+        drop(c);
+        host.callback(self, "onConnect", [false]);
+      }
+    };
+    c.transport = host.net.connect(
+      name,
+      port,
+      {
+        open: () => {
+          if (!current()) {
+            return;
+          }
+
+          c.open = true;
+          for (const bytes of c.queued) {
+            c.transport?.send(bytes);
+          }
+
+          c.queued = [];
+          host.callback(self, "onConnect", [true]);
+        },
+        data: (bytes) => {
+          if (current() && c.open) {
+            received(self, c, generation, bytes);
+          }
+        },
+        close: () => {
+          if (!current()) {
+            return;
+          }
+
+          if (!c.open) {
+            failed();
+            return;
+          }
+
+          c.generation++;
+          c.transport = null;
+          c.open = false;
+          c.partial = [];
+          c.partialLength = 0;
+          host.callback(self, "onClose", []);
+        },
+        error: () => {
+          if (!current()) {
+            return;
+          }
+
+          if (!c.open) {
+            failed();
+            return;
+          }
+
+          drop(c);
+          host.callback(self, "onClose", []);
+        },
+      },
+      failed,
+      c.timeout,
+    );
+    // Whether it connects is known only later: true says it was asked.
+    return true;
+  });
+  method("send", (self, args, v) => {
+    const c = connections.get(self);
+    if (c === undefined || c.transport === null) {
+      return undefined;
+    }
+
+    const text = bytesFor(avm1.stringOf(args[0], v), v);
+    const bytes = new Uint8Array(text.length + 1);
+    bytes.set(text);
+    if (c.open) {
+      c.transport.send(bytes);
+    } else {
+      c.queued.push(bytes);
+    }
+
+    return undefined;
+  });
+  method("onConnect", () => undefined);
+  method("onClose", () => undefined);
+  method("onData", (self, args, v) => {
+    const document = realm.construct(xml, args, v);
+    avm1.invoke(avm1.get(self, "onXML", v), self, [document], v);
+    return undefined;
+  });
+  method("onXML", () => undefined);
+
+  return constr;
+}

package/src/avm1/globals/drawing.ts

@@ -0,0 +1,253 @@
+// MovieClip's drawing methods, following Ruffle's avm1/globals/movie_clip.rs
+// (MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors),
+// with coercions and bounds checked against AIR. The paths use the same Drawing
+// as AS3; AVM1 keeps bounds even for commands with no fill or line style.
+import type { Line } from "@swf2es/format";
+import { avm1 } from "@swf2es/runtime";
+import { CONTENT, type MovieClip } from "../../display/display.js";
+import { Drawing } from "../../display/drawing.js";
+import type { Rect } from "../../display/geometry.js";
+import { CURVE, extent, MOVE } from "../../display/shapes.js";
+
+type Value = avm1.Value;
+type Method = (
+  name: string,
+  flags: number,
+  fn: (clip: MovieClip, args: Value[], version: number) => Value,
+) => void;
+
+/** x87's integer conversion, as Flash's drawing API uses it. */
+function integer(n: number): number {
+  return n > -2147483649 && n < 2147483648 ? Math.trunc(n) : -2147483648;
+}
+
+function coordinate(value: Value, version: number): number {
+  const n = avm1.toNumber(value, version);
+  return Number.isNaN(n) ? 0 : integer(n * 20) / 20;
+}
+
+function color(rgb: Value, alpha: Value, version: number): number {
+  const c = avm1.toNumber(rgb, version) & 0xffffff;
+  const percent = Math.fround(Math.max(0, Math.min(100, avm1.toNumber(alpha, version))));
+  const a = Math.fround(Math.fround(percent / 100) * 255) | 0;
+  return ((a << 24) | c) >>> 0;
+}
+
+/** Bounds before SWF 8 include control points and a line's full width. */
+class ClipDrawing extends Drawing {
+  private penX = 0;
+  private penY = 0;
+  private pad = 0;
+  private plain: Rect | null = null;
+  private outlined: Rect | null = null;
+  private plainAt = -1;
+  private outlinedAt = -1;
+  private plainResult: Rect | null = null;
+  private outlinedResult: Rect | null = null;
+
+  constructor(private readonly versionOfSwf: number) {
+    super();
+  }
+
+  override lineStyle(line: Line | null): void {
+    this.pad = (line?.width ?? 0) / (this.versionOfSwf < 8 ? 20 : 40);
+    super.lineStyle(line);
+  }
+
+  override moveTo(x: number, y: number): void {
+    this.penX = x;
+    this.penY = y;
+    super.moveTo(x, y);
+  }
+
+  override lineTo(x: number, y: number): void {
+    this.remember(
+      Math.min(this.penX, x),
+      Math.min(this.penY, y),
+      Math.max(this.penX, x),
+      Math.max(this.penY, y),
+    );
+    this.penX = x;
+    this.penY = y;
+    super.lineTo(x, y);
+  }
+
+  override curveTo(cx: number, cy: number, x: number, y: number): void {
+    if (this.versionOfSwf < 8) {
+      this.remember(
+        Math.min(this.penX, cx, x),
+        Math.min(this.penY, cy, y),
+        Math.max(this.penX, cx, x),
+        Math.max(this.penY, cy, y),
+      );
+    } else {
+      const r = extent([MOVE, this.penX, this.penY, CURVE, cx, cy, x, y]);
+      if (r) {
+        this.remember(
+          Math.floor(r[0] * 20) / 20,
+          Math.floor(r[1] * 20) / 20,
+          Math.floor(r[2] * 20) / 20,
+          Math.floor(r[3] * 20) / 20,
+        );
+      }
+    }
+
+    this.penX = x;
+    this.penY = y;
+    super.curveTo(cx, cy, x, y);
+  }
+
+  override clear(): void {
+    this.penX = 0;
+    this.penY = 0;
+    this.pad = 0;
+    this.plain = null;
+    this.outlined = null;
+    super.clear();
+  }
+
+  override bounds(lines: boolean): Rect | null {
+    // Keep snapshots stable for callers retaining the previous drawing's bounds.
+    if (lines) {
+      if (this.outlinedAt !== this.version) {
+        this.outlinedResult = this.outlined ? { ...this.outlined } : null;
+        this.outlinedAt = this.version;
+      }
+
+      return this.outlinedResult;
+    }
+
+    if (this.plainAt !== this.version) {
+      this.plainResult = this.plain ? { ...this.plain } : null;
+      this.plainAt = this.version;
+    }
+
+    return this.plainResult;
+  }
+
+  private remember(xMin: number, yMin: number, xMax: number, yMax: number): void {
+    if (this.plain && this.outlined) {
+      this.plain.xMin = Math.min(this.plain.xMin, xMin);
+      this.plain.yMin = Math.min(this.plain.yMin, yMin);
+      this.plain.xMax = Math.max(this.plain.xMax, xMax);
+      this.plain.yMax = Math.max(this.plain.yMax, yMax);
+      this.outlined.xMin = Math.min(this.outlined.xMin, xMin - this.pad);
+      this.outlined.yMin = Math.min(this.outlined.yMin, yMin - this.pad);
+      this.outlined.xMax = Math.max(this.outlined.xMax, xMax + this.pad);
+      this.outlined.yMax = Math.max(this.outlined.yMax, yMax + this.pad);
+    } else {
+      this.plain = { xMin, yMin, xMax, yMax };
+      this.outlined = {
+        xMin: xMin - this.pad,
+        yMin: yMin - this.pad,
+        xMax: xMax + this.pad,
+        yMax: yMax + this.pad,
+      };
+    }
+  }
+}
+
+/** The basic MovieClip drawing API, visible from SWF 6. */
+export function drawingMethods(method: Method, swfVersion: (clip: MovieClip) => number): void {
+  const drawing = (clip: MovieClip): Drawing => {
+    clip.drawing ??= new ClipDrawing(swfVersion(clip));
+    clip.invalidate(CONTENT);
+    return clip.drawing;
+  };
+
+  method("clear", avm1.VERSION_6, (clip) => {
+    if (clip.drawing) {
+      clip.drawing.clear();
+      clip.invalidate(CONTENT);
+    }
+
+    return undefined;
+  });
+  method("lineStyle", avm1.VERSION_6, (clip, args, version) => {
+    if (args.length === 0) {
+      if (clip.drawing) {
+        clip.drawing.lineStyle(null);
+        clip.invalidate(CONTENT);
+      }
+
+      return undefined;
+    }
+
+    const width = integer(args[0] === undefined ? 1 : avm1.toNumber(args[0], version));
+    const rgb = color(args[1] ?? 0, args.length > 2 ? args[2] : 100, version);
+    const advanced = version >= 8;
+    const hinted = advanced && avm1.toBoolean(args[3], version);
+    const scale = advanced && args.length > 4 ? avm1.stringOf(args[4], version) : "";
+    const caps = advanced && args.length > 5 ? avm1.stringOf(args[5], version) : "";
+    const join = advanced && args.length > 6 ? avm1.stringOf(args[6], version) : "";
+    const limit =
+      join === "miter" && args.length > 7
+        ? Math.max(0, Math.min(255, avm1.toNumber(args[7], version)))
+        : 3;
+    drawing(clip).lineStyle({
+      width: Math.max(0, Math.min(255, width)) * 20,
+      color: rgb,
+      startCap: caps === "square" ? 2 : caps === "none" ? 1 : 0,
+      endCap: caps === "square" ? 2 : caps === "none" ? 1 : 0,
+      join: join === "miter" ? 2 : join === "bevel" ? 1 : 0,
+      miterLimit: (Math.trunc(limit * 256) | 0) / 256,
+      noHScale: scale === "none" || scale === "horizontal",
+      noVScale: scale === "none" || scale === "vertical",
+      pixelHinting: hinted,
+      noClose: false,
+      fill: null,
+    });
+
+    return undefined;
+  });
+  method("beginFill", avm1.VERSION_6, (clip, args, version) => {
+    if (args[0] === undefined) {
+      if (clip.drawing) {
+        clip.drawing.endFill();
+        clip.invalidate(CONTENT);
+      }
+    } else {
+      const rgb = color(args[0], args.length > 1 ? args[1] : 100, version);
+      drawing(clip).beginFill({ type: "solid", color: rgb });
+    }
+
+    return undefined;
+  });
+  method("endFill", avm1.VERSION_6, (clip) => {
+    if (clip.drawing) {
+      clip.drawing.endFill();
+      clip.invalidate(CONTENT);
+    }
+
+    return undefined;
+  });
+  method("moveTo", avm1.VERSION_6, (clip, args, version) => {
+    if (args.length >= 2) {
+      const x = coordinate(args[0], version);
+      const y = coordinate(args[1], version);
+      drawing(clip).moveTo(x, y);
+    }
+
+    return undefined;
+  });
+  method("lineTo", avm1.VERSION_6, (clip, args, version) => {
+    if (args.length >= 2) {
+      const x = coordinate(args[0], version);
+      const y = coordinate(args[1], version);
+      drawing(clip).lineTo(x, y);
+    }
+
+    return undefined;
+  });
+  method("curveTo", avm1.VERSION_6, (clip, args, version) => {
+    if (args.length >= 4) {
+      const cx = coordinate(args[0], version);
+      const cy = coordinate(args[1], version);
+      const x = coordinate(args[2], version);
+      const y = coordinate(args[3], version);
+      drawing(clip).curveTo(cx, cy, x, y);
+    }
+
+    return undefined;
+  });
+}