@swf2es/player 0.0.0-stage → 0.1.0

package/src/playerglobal/flash/display/Stage.ts

@@ -0,0 +1,298 @@
+// flash.display.Stage: the stage's size and frame rate, invalidate, which
+// asks for a RENDER event before the frame is drawn, focus, which keys go
+// to (input/keyboard.ts), and the two container methods Stage declares native
+// again, which do as a container's do.
+import { avm2 } from "@swf2es/runtime";
+import { setFocus } from "../../../input/keyboard.js";
+import type { Scripting } from "../../../scripting.js";
+import { stageAlignment } from "../../../stage.js";
+import { displayOf } from "./DisplayObject.js";
+import { containerNatives } from "./DisplayObjectContainer.js";
+import { nativeWindowOf } from "./NativeWindow.js";
+
+type Value = avm2.Value;
+
+export function stageNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class StageNatives {
+    "flash.display:Stage::requireOwnerPermissions"(): void {
+      // One owner: the SWF the player runs.
+    }
+
+    get frameRate(): number {
+      return s.frameRate;
+    }
+
+    /** The AIR application's window the stage is in; null outside AIR, or where the host has none. */
+    get nativeWindow(): Value {
+      return nativeWindowOf(s);
+    }
+
+    set frameRate(v: Value) {
+      s.frameRate = Math.max(0.01, Math.min(1000, Number(v)));
+    }
+
+    get stageWidth(): number {
+      return s.stageWidth;
+    }
+
+    /** The embedding page sizes the stage: a SWF's own sizes are taken and dropped, as in Ruffle. */
+    set stageWidth(_v: Value) {}
+
+    get stageHeight(): number {
+      return s.stageHeight;
+    }
+
+    set stageHeight(_v: Value) {}
+
+    /** Undocumented; null in AIR's adl, and in Flash Player as Ruffle found it. */
+    get displayContextInfo(): Value {
+      return null;
+    }
+
+    invalidate(): void {
+      s.invalidated = true;
+    }
+
+    get scaleMode(): string {
+      return s.liveStageLayout ? s.stageScaleMode : "showAll";
+    }
+
+    set scaleMode(v: Value) {
+      if (!s.liveStageLayout) {
+        return;
+      }
+
+      if (v == null) {
+        throw s.rt.error("TypeError", 2007, "scaleMode");
+      }
+
+      const value = s.rt.toString(v);
+      switch (value) {
+        case "showAll":
+        case "noScale":
+        case "noBorder":
+        case "exactFit":
+          break;
+        default:
+          throw s.rt.error("ArgumentError", 2008, "scaleMode");
+      }
+
+      s.stageScaleModeSet = true;
+      if (value !== s.stageScaleMode) {
+        s.stageScaleMode = value;
+        s.onStageLayout?.();
+      }
+    }
+
+    get align(): string {
+      return s.liveStageLayout ? s.stageAlign : "";
+    }
+
+    set align(v: Value) {
+      if (!s.liveStageLayout) {
+        return;
+      }
+
+      if (v == null) {
+        throw s.rt.error("TypeError", 2007, "align");
+      }
+
+      const value = stageAlignment(s.rt.toString(v));
+      s.stageAlignSet = true;
+      if (value !== s.stageAlign) {
+        s.stageAlign = value;
+        s.onStageLayout?.();
+      }
+    }
+
+    get quality(): string {
+      return s.quality;
+    }
+
+    set quality(v: Value) {
+      s.quality = String(v).toUpperCase();
+    }
+
+    get displayState(): string {
+      return "normal";
+    }
+
+    set displayState(_v: Value) {
+      // No full screen.
+    }
+
+    get focus(): Value {
+      return s.focus?.object ?? null;
+    }
+
+    // A field given focus keeps its selection (the corpus's edittext_focus_selection).
+    set focus(v: Value) {
+      setFocus(s, v ? (displayOf(v as avm2.AsObject) ?? null) : null);
+    }
+
+    get showDefaultContextMenu(): boolean {
+      return s.showDefaultContextMenu;
+    }
+
+    set showDefaultContextMenu(v: Value) {
+      s.showDefaultContextMenu = s.rt.toBoolean(v);
+    }
+
+    // Kept, though no focus rectangle is drawn.
+    get stageFocusRect(): boolean {
+      return focusRect;
+    }
+
+    set stageFocusRect(v: Value) {
+      focusRect = !!v;
+    }
+
+    /** The background, opaque: what a SWF's SetBackgroundColor gave until set, the alpha set ignored. */
+    get color(): number {
+      return ((s.stageColor ?? 0xffffff) | 0xff000000) >>> 0;
+    }
+
+    set color(v: Value) {
+      s.stageColor = s.rt.toUint(v) & 0xffffff;
+      // A redraw asked for: a host that reads Player.background as it draws shows it.
+      s.updates++;
+    }
+
+    get allowsFullScreen(): boolean {
+      return true;
+    }
+
+    get allowsFullScreenInteractive(): boolean {
+      return false;
+    }
+
+    get browserZoomFactor(): number {
+      return 1;
+    }
+
+    get contentsScaleFactor(): number {
+      return 1;
+    }
+
+    get fullScreenWidth(): number {
+      return s.screenCapabilities.screenResolutionX;
+    }
+
+    get fullScreenHeight(): number {
+      return s.screenCapabilities.screenResolutionY;
+    }
+
+    get fullScreenSourceRect(): Value {
+      return fullScreenSource;
+    }
+
+    set fullScreenSourceRect(v: Value) {
+      fullScreenSource = v ?? null;
+    }
+
+    get colorCorrection(): string {
+      return colorCorrection;
+    }
+
+    set colorCorrection(v: Value) {
+      if (v === null || v === undefined) {
+        throw s.rt.error("TypeError", 2007, "colorCorrection");
+      }
+
+      colorCorrection = s.rt.toString(v);
+    }
+
+    get colorCorrectionSupport(): string {
+      return "unsupported";
+    }
+
+    // Kept: the pointer is not locked, which only full screen allows.
+    get mouseLock(): boolean {
+      return mouseLock;
+    }
+
+    set mouseLock(v: Value) {
+      mouseLock = !!v;
+    }
+
+    get wmodeGPU(): boolean {
+      return false;
+    }
+
+    get softKeyboardRect(): Value {
+      return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), 0, 0, 0, 0);
+    }
+
+    get orientation(): string {
+      return "unknown";
+    }
+
+    get deviceOrientation(): string {
+      return "unknown";
+    }
+
+    get autoOrients(): boolean {
+      return false;
+    }
+
+    "flash.display:Stage::setAutoOrients"(_v: Value): void {}
+
+    get supportedOrientations(): Value {
+      const strings = s.rt.resolve(s.rt.vector("String")).$it.instance();
+      strings.$a = [];
+      return strings;
+    }
+
+    static get supportsOrientationChange(): boolean {
+      return false;
+    }
+
+    isFocusInaccessible(): boolean {
+      return false;
+    }
+
+    /** No StageVideo: the vector is empty. */
+    get stageVideos(): Value {
+      return vectorOf("flash.media::StageVideo", []);
+    }
+
+    /** Flash's four, each of which fails to get a Context3D, as Flash without a GPU (Stage3D.ts). */
+    get stage3Ds(): Value {
+      stage3Ds ??= [0, 1, 2, 3].map(() =>
+        s.rt.construct(s.rt.classNamed("flash.display::Stage3D")),
+      );
+      return vectorOf("flash.display::Stage3D", stage3Ds, true);
+    }
+  }
+
+  let focusRect = true;
+  let fullScreenSource: Value = null;
+  let colorCorrection = "default";
+  let mouseLock = false;
+  let stage3Ds: Value[] | null = null;
+
+  /** A Vector of the named class holding `values`. */
+  const vectorOf = (name: string, values: Value[], fixed = false): Value => {
+    const cls = s.rt.applyType(s.rt.classNamed("__AS3__.vec::Vector"), [s.rt.classNamed(name)]);
+    const o = cls.$it.instance();
+    o.$a = [...values];
+    o.$fixed = fixed;
+    return o;
+  };
+
+  avm2.registerNativeClass(natives, "flash.display::Stage", StageNatives);
+  const container = containerNatives(s);
+  for (const name of ["removeChildAt", "swapChildrenAt"]) {
+    natives[`flash.display::Stage#${name}`] =
+      container[`flash.display::DisplayObjectContainer#${name}`];
+  }
+
+  // Undocumented accessors Stage declares: null, and a write that changes
+  // nothing, as adl gives them. A JavaScript class cannot spell them.
+  natives["flash.display::Stage#get:constructor"] = avm2.plain(() => null);
+  natives["flash.display::Stage#set:constructor"] = avm2.plain(() => undefined);
+
+  return natives;
+}

package/src/playerglobal/flash/display/Stage3D.ts

@@ -0,0 +1,90 @@
+// flash.display.Stage3D without Stage3D rendering: its position and
+// visibility kept, and each request for a Context3D answered as Flash
+// answers it without a GPU, an ErrorEvent #3702 in a later frame, so that
+// content that falls back to the display list can.
+import { avm2 } from "@swf2es/runtime";
+import { dispatchEvent } from "../../../scripting/events.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+export function stage3DNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  const unavailable = (target: AsObject): void => {
+    s.loads.deferHostEvent(() =>
+      dispatchEvent(
+        s,
+        target,
+        s.rt.construct(
+          s.rt.classNamed("flash.events::ErrorEvent"),
+          "error",
+          false,
+          false,
+          "Error #3702: Context3D not available.",
+          3702,
+        ) as AsObject,
+      ),
+    );
+  };
+
+  /** A position within -8192 to 8191; else ArgumentError 2006, as the corpus's `stage3d_x_y` has Flash's. */
+  const position = (v: Value): number => {
+    const n = s.rt.toNumber(v);
+    if (!(n >= -8192 && n <= 8191)) {
+      throw s.rt.error("ArgumentError", 2006);
+    }
+
+    return n;
+  };
+
+  class Stage3DNatives {
+    declare $x: number | undefined;
+    declare $y: number | undefined;
+    declare $visible: boolean | undefined;
+
+    get context3D(): Value {
+      return null;
+    }
+
+    requestContext3D(_mode: Value = "auto", _profile: Value = "baseline"): void {
+      unavailable(this as unknown as AsObject);
+    }
+
+    requestContext3DMatchingProfiles(profiles: Value): void {
+      if (profiles === null || profiles === undefined) {
+        throw s.rt.error("TypeError", 2007, "profiles");
+      }
+
+      unavailable(this as unknown as AsObject);
+    }
+
+    get x(): number {
+      return this.$x ?? 0;
+    }
+
+    set x(v: Value) {
+      this.$x = position(v);
+    }
+
+    get y(): number {
+      return this.$y ?? 0;
+    }
+
+    set y(v: Value) {
+      this.$y = position(v);
+    }
+
+    get visible(): boolean {
+      return this.$visible ?? true;
+    }
+
+    set visible(v: Value) {
+      this.$visible = !!v;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::Stage3D", Stage3DNatives);
+  return natives;
+}

package/src/playerglobal/flash/display/shaders.ts

@@ -0,0 +1,296 @@
+// What a Shader's kernel runs with, read from its ShaderData as adl reads
+// it: each parameter's numbers and each input's image. A ShaderJob reads
+// them as it starts; a ShaderFilter, a blend shader and a shader fill as
+// they are set, and draw with those after, whatever the script sets later
+// (the shader-filters and shader-blends cases).
+import {
+  PBJ_TYPE_SIZES,
+  PBJ_TYPES,
+  type PbjKernel,
+  type PbjParameter,
+  pbjFloatType,
+} from "@swf2es/format";
+import { avm2 } from "@swf2es/runtime";
+import { OUT_COORD, type ShaderImage, type ShaderUse } from "../../../bitmap/pixel-bender.js";
+import type { Scripting } from "../../../scripting.js";
+import { storeOf } from "./BitmapData.js";
+import { programOf } from "./ShaderData.js";
+import { shaderClasses } from "./ShaderInput.js";
+
+type Value = avm2.Value;
+type AsObject = avm2.AsObject;
+
+/** A parameter value's number as its register takes it: float32, or an int as SSE truncates one. */
+function numberOf(v: number, float: boolean): number {
+  if (float) {
+    return Math.fround(v);
+  }
+
+  const t = Math.trunc(v);
+  return t >= -2147483648 && t <= 2147483647 ? t : -2147483648;
+}
+
+/** The kernel a Shader holds: its ShaderData's, or null for none. */
+export function kernelOfShader(shader: Value): { data: AsObject; kernel: PbjKernel } | null {
+  const data: AsObject | null = (shader as AsObject | null)?.$data ?? null;
+  const kernel: PbjKernel | undefined = data?.$kernel;
+  return data && kernel ? { data, kernel } : null;
+}
+
+/**
+ * A parameter's numbers: those of the ShaderParameter of its name, where
+ * one of its type is there, else its default, as adl takes them; each a
+ * number, or ArgumentError 2004, as many as its type holds, 0 past the
+ * Array's end.
+ */
+export function parameterValues(s: Scripting, data: AsObject, p: PbjParameter): number[] {
+  const classes = shaderClasses(s);
+  const size = PBJ_TYPE_SIZES[p.type] ?? 0;
+  const float = pbjFloatType(p.type);
+  const own = data.$d.get(p.name);
+  let value: Value;
+  if (s.rt.isInstance(own, classes.shaderParameter) && own.$type === (PBJ_TYPES[p.type] ?? null)) {
+    value = own.$value ?? null;
+  } else {
+    const fallback = p.metadata.filter((m) => m.key === "defaultValue").pop();
+    value = fallback && typeof fallback.value !== "string" ? s.rt.array([...fallback.value]) : null;
+  }
+
+  const values: number[] = [];
+  const items: Value[] = s.rt.isInstance(value, classes.array) ? (value as AsObject).$a : [];
+  for (let k = 0; k < size; k++) {
+    if (k >= items.length) {
+      values.push(0);
+      continue;
+    }
+
+    const item = items[k];
+    if (typeof item !== "number") {
+      throw s.rt.error("ArgumentError", 2004);
+    }
+
+    values.push(numberOf(item as number, float));
+  }
+
+  return values;
+}
+
+/** Every input parameter's numbers, but _OutCoord's, which each pixel sets. */
+export function kernelValues(
+  s: Scripting,
+  data: AsObject,
+  kernel: PbjKernel,
+): Map<PbjParameter, number[]> {
+  const values = new Map<PbjParameter, number[]>();
+  for (const p of kernel.parameters) {
+    if (!p.output && p.name !== OUT_COORD) {
+      values.set(p, parameterValues(s, data, p));
+    }
+  }
+
+  return values;
+}
+
+/** How a use takes its inputs' images: read as they are now, copied to draw with later, or checked alone. */
+export const READ = 0;
+export const COPY = 1;
+export const CHECK = 2;
+
+/**
+ * The copy of each input taken last, by its BitmapData's store, its Vector
+ * or its ByteArray: kept while a use holds it, and shared by the uses that
+ * take the same pixels (its store's version) or numbers (their hash), as a
+ * fill begun on every frame takes them, its texture with them.
+ */
+const copies = new WeakMap<
+  object,
+  { version: number; width: number; height: number; channels: number; image: WeakRef<ShaderImage> }
+>();
+
+/** The copy of `source` kept for `version` and this size, else the one `make` makes, kept now. */
+function shared(
+  source: object,
+  version: number,
+  width: number,
+  height: number,
+  channels: number,
+  make: () => ShaderImage,
+): ShaderImage {
+  const kept = copies.get(source);
+  const image =
+    kept &&
+    kept.version === version &&
+    kept.width === width &&
+    kept.height === height &&
+    kept.channels === channels
+      ? kept.image.deref()
+      : undefined;
+  if (image) {
+    return image;
+  }
+
+  const made = make();
+  copies.set(source, { version, width, height, channels, image: new WeakRef(made) });
+
+  return made;
+}
+
+/** A hash of `floats`' bits, FNV-1a, which says whether numbers taken again are the same. */
+function hashOf(floats: Float32Array): number {
+  const words = new Uint32Array(floats.buffer, floats.byteOffset, floats.length);
+  let h = 0x811c9dc5;
+  for (let i = 0; i < words.length; i++) {
+    h = Math.imul(h ^ words[i], 0x01000193);
+  }
+
+  return h >>> 0;
+}
+
+/**
+ * An input's image, read now: a BitmapData's pixels, or as many floats
+ * as its size needs; a ByteArray's position is moved past them by
+ * `read`, once nothing refuses the job, as adl leaves it where it was
+ * then. `how` READ takes them as they are, COPY as a copy (shared, as
+ * `copies` keeps them) for a use that draws with them later, and CHECK
+ * only checks them, null.
+ */
+export function inputImage(
+  s: Scripting,
+  data: AsObject,
+  name: string,
+  channels: number,
+  read: (() => void)[],
+  how = READ,
+): ShaderImage | null {
+  const classes = shaderClasses(s);
+  const refuse = (id: number, ...args: Value[]): never => {
+    throw s.rt.error("ArgumentError", id, ...args);
+  };
+  const own = data.$d.get(name);
+  if (!s.rt.isInstance(own, classes.shaderInput)) {
+    refuse(2167);
+  }
+
+  const o = own as AsObject;
+  const input: Value = o.$input ?? null;
+  if (input === null) {
+    refuse(2164, name);
+  }
+
+  if (s.rt.isInstance(input, classes.bitmapData)) {
+    const store = storeOf(s, input as AsObject);
+    const { width, height } = store;
+    switch (how) {
+      case CHECK:
+        return null;
+      case COPY:
+        return shared(store, store.version, width, height, channels, () => ({
+          width,
+          height,
+          pixels: store.readable.slice(),
+          channels,
+        }));
+      default:
+        return { width, height, pixels: store.readable, channels };
+    }
+  }
+
+  const width: number = o.$width ?? 0;
+  const height: number = o.$height ?? 0;
+  if (width <= 0 || height <= 0) {
+    refuse(2166, name);
+  }
+
+  // Allocated once the input is known to hold them, whatever size the script set.
+  const count = width * height * channels;
+  if (s.rt.isInstance(input, classes.vector)) {
+    const items: number[] = (input as AsObject).$a;
+    if (items.length < count) {
+      refuse(2165, name);
+    }
+
+    if (how === CHECK) {
+      return null;
+    }
+
+    const floats = Float32Array.from(items.slice(0, count));
+    const image = { width, height, floats, channels };
+
+    return how === COPY
+      ? shared(input as object, hashOf(floats), width, height, channels, () => image)
+      : image;
+  }
+
+  // From the start, whatever the position, which is left past what was read.
+  const bytes = avm2.bytesOf(s.rt, input as AsObject);
+  if (bytes.length < count * 4) {
+    refuse(2165, name);
+  }
+
+  if (how === CHECK) {
+    return null;
+  }
+
+  const floats = new Float32Array(count);
+  for (let i = 0; i < count; i++) {
+    floats[i] = bytes.view.getFloat32(i * 4, bytes.littleEndian);
+  }
+
+  read.push(() => {
+    bytes.position = count * 4;
+  });
+  const image = { width, height, floats, channels };
+
+  return how === COPY
+    ? shared(input as object, hashOf(floats), width, height, channels, () => image)
+    : image;
+}
+
+/**
+ * What a ShaderFilter, a blend shader or a shader fill draws with, read as
+ * it is set, and what applyFilter runs with: `bound` inputs, the first
+ * ones, are the use's own (a filter's object, a blend's background and
+ * foreground), and the rest must be set; each needs `bound` inputs at
+ * least (2167), and a filter and a blend a kernel of four channels out
+ * (2162). `how` takes its inputs' images (inputImage); CHECK takes no
+ * values either, and moves no ByteArray.
+ */
+export function shaderUse(s: Scripting, shader: Value, bound: number, how = COPY): ShaderUse {
+  const found = kernelOfShader(shader) as { data: AsObject; kernel: PbjKernel };
+  const { data, kernel } = found;
+  const outputs = kernel.parameters.filter((p) => p.output);
+  if (bound > 0 && outputs[outputs.length - 1]?.type !== 0x4) {
+    throw s.rt.error("ArgumentError", 2162);
+  }
+
+  if (kernel.inputs.length < bound) {
+    throw s.rt.error("ArgumentError", 2167);
+  }
+
+  const images = new Map<number, ShaderImage>();
+  const read: (() => void)[] = [];
+  for (const input of kernel.inputs.slice(bound)) {
+    const image = inputImage(s, data, input.name, input.channels, read, how);
+    if (image) {
+      images.set(input.index, image);
+    }
+  }
+
+  // A texture sampled that no input declares, as a job refuses it.
+  for (const texture of programOf(kernel).sampled) {
+    if (!kernel.inputs.some((input) => input.index === texture)) {
+      throw s.rt.error("ArgumentError", 2167);
+    }
+  }
+
+  if (how === CHECK) {
+    return { kernel, values: new Map(), images };
+  }
+
+  const values = kernelValues(s, data, kernel);
+  for (const move of read) {
+    move();
+  }
+
+  return { kernel, values, images };
+}