@swf2es/player 0.0.0-stage → 0.1.0

package/src/playerglobal/context3d/resources.ts

@@ -0,0 +1,406 @@
+import { blockBytes, Context3DError, SamplerBiasError, type Texture3D } from "@swf2es/context3d";
+import {
+  AtfError,
+  type AtfHeader,
+  type AtfImage,
+  atfKind,
+  decodeAtf,
+  readAtfHeader,
+} from "@swf2es/native/atf";
+import { avm2 } from "@swf2es/runtime";
+import { dispatchEvent } from "../../scripting/events.js";
+import type { Scripting } from "../../scripting.js";
+import { storeOf } from "../flash/display/BitmapData.js";
+
+import { flashError } from "./errors.js";
+import type { AsObject, Bindings } from "./lifecycle.js";
+
+export function registerResources(natives: avm2.Natives, s: Scripting, bindings: Bindings): void {
+  const {
+    buffers,
+    programs,
+    textures,
+    contexts,
+    disposeResource,
+    context,
+    buffer,
+    program,
+    texture,
+    bytes,
+  } = bindings;
+
+  class BufferNatives {
+    uploadFromByteArray(data: AsObject | null, offset: number, start: number, count: number): void {
+      if (!data) {
+        throw s.rt.error("TypeError", 2007, "data");
+      }
+
+      const entry = buffers.get(this as unknown as AsObject);
+      if (!entry) {
+        throw s.rt.error("Error", 3694);
+      }
+
+      // Unlike vector uploads, AIR ignores byte uploads after explicit disposal.
+      if (entry.disposed) {
+        return;
+      }
+
+      context(entry.owner);
+
+      const storage = avm2.bytesOf(s.rt, data);
+      const value = entry.value;
+      const length = count * (value.stride === 0 ? 2 : value.stride * 4);
+      if (
+        offset < 0 ||
+        offset >= storage.length ||
+        start < 0 ||
+        count < 0 ||
+        start > value.count - count ||
+        length > storage.length - offset
+      ) {
+        throw s.rt.error("RangeError", 3669);
+      }
+
+      value.uploadBytes(storage.buffer, offset, start, count);
+    }
+
+    uploadFromVector(values: AsObject, start: number, count: number): void {
+      buffer(this as unknown as AsObject).upload(values.$a, start, count);
+    }
+
+    dispose(): void {
+      const object = this as unknown as AsObject;
+      disposeResource(object, buffers.get(object));
+    }
+  }
+
+  class ProgramNatives {
+    upload(vertex: AsObject, fragment: AsObject): void {
+      try {
+        program(this as unknown as AsObject).upload(bytes(vertex), bytes(fragment));
+      } catch (error) {
+        if (error instanceof SamplerBiasError) {
+          throw s.rt.error("Error", 3696);
+        }
+
+        throw error;
+      }
+    }
+
+    dispose(): void {
+      const object = this as unknown as AsObject;
+      disposeResource(object, programs.get(object));
+    }
+  }
+
+  function uploadTexture(object: AsObject, source: AsObject, level: number, face: number): void {
+    const value = texture(object);
+    // AIR accepts this call after explicit texture disposal without reviving
+    // the resource. A disposed owner context is still rejected above.
+    if (textures.get(object)?.disposed) {
+      return;
+    }
+
+    if (face >= (value.cube ? 6 : 1)) {
+      throw s.rt.error("ArgumentError", 3673);
+    }
+    if (level >= value.levels) {
+      throw s.rt.error("ArgumentError", 3674);
+    }
+    if (!source) {
+      throw s.rt.error("TypeError", 2007, "source");
+    }
+
+    const bitmap = storeOf(s, source);
+
+    value.upload(bitmap.readable, level, face, bitmap.width, bitmap.height);
+    const entry = textures.get(object);
+    if (entry && level === 0 && !value.cube) {
+      entry.initialized = true;
+    }
+  }
+
+  function uploadTextureBytes(
+    object: AsObject,
+    data: AsObject,
+    offset: number,
+    level: number,
+    face: number,
+  ): void {
+    if (!data) {
+      throw s.rt.error("TypeError", 2007, "data");
+    }
+
+    // Unlike bitmap uploads, explicit disposal wins over owner disposal.
+    if (textures.get(object)?.disposed) {
+      return;
+    }
+
+    const value = texture(object);
+    if (face >= (value.cube ? 6 : 1)) {
+      throw s.rt.error("ArgumentError", 3673);
+    }
+    if (level >= value.levels) {
+      throw s.rt.error("ArgumentError", 3674);
+    }
+
+    const storage = avm2.bytesOf(s.rt, data);
+    const length = Math.max(1, value.width >> level) * Math.max(1, value.height >> level) * 4;
+    if (offset > storage.length - length) {
+      throw s.rt.error("RangeError", 3669);
+    }
+
+    value.uploadBytes(storage.buffer, offset, level, face);
+    const entry = textures.get(object);
+    if (entry && level === 0 && !value.cube) {
+      entry.initialized = true;
+    }
+  }
+
+  /** AIR's errors for an ATF it refuses, their classes, and an ErrorEvent's whole text. */
+  const ATF_IDS = { size: 3669, decode: 3677, format: 3675 } as const;
+  const ATF_ERRORS: Record<number, string> = {
+    3669: "RangeError",
+    3675: "ArgumentError",
+    3677: "ArgumentError",
+    3679: "ArgumentError",
+  };
+
+  /**
+   * The ATF's levels uploaded to `value`, checked as AIR checks them after
+   * its header: a format AIR knows (#3677), the texture's (#3675), levels
+   * that decode (#3677), then the texture's size (#3679). 0 where it is
+   * uploaded, else the error's ID, and nothing uploaded.
+   */
+  function applyAtf(
+    object: AsObject,
+    value: Texture3D,
+    data: Uint8Array,
+    header: AtfHeader,
+  ): number {
+    // AIR reads the new header and CompressedAlpha for content from SWF 17,
+    // and version 3, with ETC2's blocks, from SWF 29: before, they are corrupt.
+    const kind = atfKind(header.format);
+    const swf = s.rt.swfVersion;
+    if (
+      kind === undefined ||
+      (swf < 17 && (!header.old || kind === "compressedAlpha")) ||
+      (swf < 29 && header.version >= 3)
+    ) {
+      return ATF_IDS.decode;
+    }
+    if (kind !== value.format || header.cube !== value.cube) {
+      return ATF_IDS.format;
+    }
+
+    let images: AtfImage[];
+    try {
+      images = decodeAtf(data, header);
+    } catch (error) {
+      if (error instanceof AtfError) {
+        return ATF_IDS[error.reason];
+      }
+
+      throw error;
+    }
+
+    if (header.width !== value.width || header.height !== value.height) {
+      return 3679;
+    }
+
+    // Every level is checked before any goes up, so that an upload is whole or
+    // nothing, as AIR's is. Then the backend cannot refuse one: it checks only
+    // these ranges and lengths, and its context, which nothing here changes;
+    // WebGL reports its own failures by getError, not by throwing, and a
+    // context lost meanwhile takes calls as no-ops.
+    for (const image of images) {
+      const face = value.cube ? image.face ^ 1 : 0;
+      const width = Math.max(1, value.width >> image.level);
+      const height = Math.max(1, value.height >> image.level);
+      const length =
+        kind === "bgra"
+          ? width * height * 4
+          : blockBytes(width, height, kind === "compressedAlpha");
+      if (
+        image.level >= value.levels ||
+        face >= (value.cube ? 6 : 1) ||
+        image.width !== width ||
+        image.height !== height ||
+        image.bytes.length !== length
+      ) {
+        return ATF_IDS.decode;
+      }
+    }
+
+    for (const image of images) {
+      // ATF's faces go -X, +X, -Y, +Y, -Z, +Z; CubeTexture's sides +X, -X, and so on.
+      const face = value.cube ? image.face ^ 1 : 0;
+      if (kind === "bgra") {
+        value.uploadBytes(image.bytes, 0, image.level, face);
+      } else {
+        value.uploadCompressed(image.bytes, image.level, face);
+      }
+    }
+
+    const entry = textures.get(object);
+    if (entry && !value.cube && images.some((image) => image.level === 0)) {
+      entry.initialized = true;
+    }
+
+    return 0;
+  }
+
+  /**
+   * uploadCompressedTextureFromByteArray. AIR checks the signature and the
+   * length before returning, even for an asynchronous upload; the rest of
+   * an asynchronous one it reports as an ErrorEvent on the texture, or
+   * textureReady once it is uploaded, at the next frame before its
+   * enterFrame. The bytes are read when it is called.
+   */
+  function uploadAtf(
+    object: AsObject,
+    data: AsObject | null,
+    offset: number,
+    async: boolean,
+  ): void {
+    if (!data) {
+      throw s.rt.error("TypeError", 2007, "data");
+    }
+
+    // As for byte uploads, explicit disposal wins over the owner's.
+    if (textures.get(object)?.disposed) {
+      return;
+    }
+
+    const value = texture(object);
+    const storage = avm2.bytesOf(s.rt, data);
+    const bytes = storage.buffer.subarray(0, storage.length);
+    let header: AtfHeader;
+    try {
+      header = readAtfHeader(bytes, offset);
+    } catch (error) {
+      if (error instanceof AtfError) {
+        throw s.rt.error(ATF_ERRORS[ATF_IDS[error.reason]], ATF_IDS[error.reason]);
+      }
+
+      throw error;
+    }
+
+    if (!async) {
+      const id = applyAtf(object, value, bytes, header);
+      if (id) {
+        throw s.rt.error(ATF_ERRORS[id], id);
+      }
+
+      return;
+    }
+
+    // AIR reads on past the length, as far as the data goes.
+    const copy = bytes.slice(offset);
+    s.loads.deferHostEvent(() => {
+      // A texture whose context is gone hears nothing; one disposed meanwhile, #3677, as in AIR.
+      const entry = textures.get(object);
+      if (!entry || !contexts.has(entry.owner) || s.destroyed) {
+        return;
+      }
+
+      let id: number = ATF_IDS.decode;
+      try {
+        id = entry.disposed ? id : applyAtf(object, value, copy, readAtfHeader(copy, 0));
+      } catch (error) {
+        // The backend's own failure, which a synchronous upload throws translated, as an event.
+        if (!(error instanceof Context3DError)) {
+          throw error;
+        }
+
+        id = flashError(error).id;
+      }
+
+      const event = id
+        ? (s.rt.construct(
+            s.rt.classNamed("flash.events::ErrorEvent"),
+            "error",
+            false,
+            false,
+            // AIR's whole message, in debugger players and release ones alike.
+            `Error #${id}: ${avm2.errorMessages[id] ?? ""}`,
+            id,
+          ) as AsObject)
+        : s.event("textureReady");
+      dispatchEvent(s, object, event);
+    });
+  }
+
+  class TextureNatives {
+    uploadCompressedTextureFromByteArray(
+      data: AsObject | null,
+      offset: number,
+      async = false,
+    ): void {
+      uploadAtf(this as unknown as AsObject, data, offset, async);
+    }
+
+    uploadFromByteArray(data: AsObject, offset: number, level = 0): void {
+      uploadTextureBytes(this as unknown as AsObject, data, offset, level, 0);
+    }
+
+    uploadFromBitmapData(source: AsObject, level = 0): void {
+      uploadTexture(this as unknown as AsObject, source, level, 0);
+    }
+  }
+
+  class RectangleTextureNatives {
+    uploadFromByteArray(data: AsObject, offset: number): void {
+      uploadTextureBytes(this as unknown as AsObject, data, offset, 0, 0);
+    }
+
+    uploadFromBitmapData(source: AsObject): void {
+      if (!source) {
+        throw s.rt.error("TypeError", 2007, "source");
+      }
+
+      if (textures.get(this as unknown as AsObject)?.disposed) {
+        return;
+      }
+
+      uploadTexture(this as unknown as AsObject, source, 0, 0);
+    }
+  }
+
+  class CubeTextureNatives {
+    uploadCompressedTextureFromByteArray(
+      data: AsObject | null,
+      offset: number,
+      async = false,
+    ): void {
+      uploadAtf(this as unknown as AsObject, data, offset, async);
+    }
+
+    uploadFromByteArray(data: AsObject, offset: number, face: number, level = 0): void {
+      uploadTextureBytes(this as unknown as AsObject, data, offset, level, face);
+    }
+
+    uploadFromBitmapData(source: AsObject, face: number, level = 0): void {
+      uploadTexture(this as unknown as AsObject, source, level, face);
+    }
+  }
+
+  class TextureBaseNatives {
+    dispose(): void {
+      const object = this as unknown as AsObject;
+      disposeResource(object, textures.get(object));
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display3D::VertexBuffer3D", BufferNatives);
+  avm2.registerNativeClass(natives, "flash.display3D::IndexBuffer3D", BufferNatives);
+  avm2.registerNativeClass(natives, "flash.display3D::Program3D", ProgramNatives);
+  avm2.registerNativeClass(natives, "flash.display3D.textures::Texture", TextureNatives);
+  avm2.registerNativeClass(natives, "flash.display3D.textures::CubeTexture", CubeTextureNatives);
+  avm2.registerNativeClass(
+    natives,
+    "flash.display3D.textures::RectangleTexture",
+    RectangleTextureNatives,
+  );
+  avm2.registerNativeClass(natives, "flash.display3D.textures::TextureBase", TextureBaseNatives);
+}

package/src/playerglobal/context3d.ts

@@ -0,0 +1,111 @@
+// Experimental opt-in bindings. Install before loading playerglobal and close
+// the host before destroying Scripting; default playback keeps ErrorEvent #3702.
+import type { Stage3DHost } from "@swf2es/context3d";
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../scripting.js";
+import { registerContext } from "./context3d/context.js";
+import { translateErrors } from "./context3d/errors.js";
+import { type AsObject, createBindings } from "./context3d/lifecycle.js";
+import { registerResources } from "./context3d/resources.js";
+
+/** Returns the host teardown; it also cancels creation queued before teardown. */
+export function installContext3D(s: Scripting, host: Stage3DHost): () => void {
+  s.liveStageLayout = true;
+  const natives: avm2.Natives = {};
+  const bindings = createBindings(s, host);
+  const { slots, place, request, unavailable } = bindings;
+  // The profiles the backend serves, best first: baselineConstrained asks for less of it than
+  // baseline does, and is Starling 1.x's default.
+  const served = ["baseline", "baselineConstrained"];
+  const profileName = (value: string | null): string => {
+    switch (value) {
+      case null:
+        return "baseline";
+      case "baseline":
+      case "baselineConstrained":
+      case "baselineExtended":
+      case "standardConstrained":
+      case "standard":
+      case "standardExtended":
+        return value;
+      default:
+        throw s.rt.error("ArgumentError", 2008, "profile");
+    }
+  };
+
+  class StageNatives {
+    get context3D(): AsObject | null {
+      return slots.get(this as unknown as AsObject) ?? null;
+    }
+
+    requestContext3D(mode: string | null = "auto", profile: string | null = "baseline"): void {
+      const slot = this as unknown as AsObject;
+      if (mode === null) {
+        throw s.rt.error("TypeError", 2007, "context3DRenderMode");
+      }
+      if (mode !== "auto" && mode !== "software") {
+        throw s.rt.error("ArgumentError", 2008, "context3DRenderMode");
+      }
+
+      const selected = profileName(profile);
+      if (bindings.closed) {
+        throw s.rt.error("Error", 3694);
+      }
+      if (mode !== "auto" || !served.includes(selected)) {
+        unavailable(slot);
+        return;
+      }
+
+      request(slot, selected);
+    }
+
+    requestContext3DMatchingProfiles(profiles: AsObject | null): void {
+      if (!profiles) {
+        throw s.rt.error("ArgumentError", 1508, "profiles");
+      }
+
+      const values = profiles.$a as (string | null)[];
+      if (!values.length) {
+        throw s.rt.error("ArgumentError", 2008, "profiles");
+      }
+      const asked = new Set<string>();
+      for (let i = 0; i < values.length; i++) {
+        asked.add(profileName(values[i]));
+      }
+      if (bindings.closed) {
+        throw s.rt.error("Error", 3694);
+      }
+      // The best of them the backend serves, as Flash takes the best its device has.
+      const best = served.find((p) => asked.has(p));
+      if (best) {
+        request(this as unknown as AsObject, best);
+      } else {
+        unavailable(this as unknown as AsObject);
+      }
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::Stage3D", StageNatives);
+  registerContext(natives, s, bindings);
+  registerResources(natives, s, bindings);
+
+  // Keep the existing Flash-tested position validation and property storage.
+  for (const property of ["x", "y", "visible"]) {
+    const key = `flash.display::Stage3D#set:${property}`;
+    const original = s.rt.natives[key];
+    natives[key] = (rt) => {
+      const setter = original(rt);
+      return function (this: AsObject, value: avm2.Value) {
+        setter.call(this, value);
+        place(this);
+      };
+    };
+  }
+
+  translateErrors(natives, s);
+  Object.assign(s.rt.natives, natives);
+
+  return bindings.close;
+}
+
+export type { Context3D, Context3DLifecycle, Stage3DHost } from "@swf2es/context3d";

package/src/playerglobal/flash/accessibility/Accessibility.ts

@@ -0,0 +1,30 @@
+// flash.accessibility.Accessibility: this player has no platform accessibility bridge.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function accessibilityNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class AccessibilityNatives {
+    static get active(): boolean {
+      return false;
+    }
+
+    static sendEvent(source: Value, _childId: Value, _eventType: Value, _nonHtml: Value): void {
+      if (source === null || source === undefined) {
+        throw s.rt.error("TypeError", 2007, "source");
+      }
+
+      // No platform accessibility bridge receives events.
+    }
+
+    static updateProperties(): void {
+      // No platform accessibility bridge holds properties.
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.accessibility::Accessibility", AccessibilityNatives);
+  return natives;
+}

package/src/playerglobal/flash/crypto/generateRandomBytes.ts

@@ -0,0 +1,38 @@
+// flash.crypto contains one function: cryptographically strong bytes from
+// the host, with Flash's bounded length and a fresh ByteArray at position 0.
+import { avm2 } from "@swf2es/runtime";
+
+type Value = avm2.Value;
+
+export function cryptoNatives(): avm2.Natives {
+  return {
+    "flash.crypto::generateRandomBytes": (rt) => (count: Value) => {
+      const length = rt.toUint(count);
+      if (length === 0) {
+        // AIR returns null here, though the API reference gives 1 as the minimum.
+        return null;
+      }
+
+      if (length > 1024) {
+        throw rt.error("Error", 2004);
+      }
+
+      const crypto = globalThis.crypto;
+      if (!crypto?.getRandomValues) {
+        throw rt.error("Error", 0);
+      }
+
+      const array = rt.construct(rt.classNamed("flash.utils::ByteArray")) as avm2.AsObject;
+      const bytes = avm2.bytesOf(rt, array);
+      bytes.setLength(length);
+      try {
+        // A new ByteArray, never shared.
+        crypto.getRandomValues(bytes.buffer.subarray(0, length) as Uint8Array<ArrayBuffer>);
+      } catch {
+        throw rt.error("Error", 0);
+      }
+
+      return array;
+    },
+  };
+}

package/src/playerglobal/flash/data/EncryptedLocalStore.ts

@@ -0,0 +1,75 @@
+// flash.data.EncryptedLocalStore over the host's EncryptedStoreHost
+// (hosts.ts), as adl (AIR 51.3) has it: an item is the whole of a
+// ByteArray, whatever its position, which stays as it was; getItem gives
+// a new ByteArray of it at position 0, and null for a name of none or of
+// empty bytes. A null name or data is ArgumentError 2007, an empty name
+// 2085. stronglyBound, which ties an item to the application's signature,
+// is taken and changes nothing: there is no signature to tie it to.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+export function encryptedLocalStoreNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const store = () => s.encryptedStore;
+  /** An item's name; ArgumentError for none, or for "". */
+  const nameOf = (name: Value): string => {
+    if (name === null || name === undefined) {
+      throw s.rt.error("ArgumentError", 2007, "name");
+    }
+
+    const named = s.rt.toString(name);
+    if (named === "") {
+      throw s.rt.error("ArgumentError", 2085, "name");
+    }
+
+    return named;
+  };
+
+  class EncryptedLocalStoreNatives {
+    static get isSupported(): boolean {
+      return store() !== null;
+    }
+
+    static setItem(name: Value, data: Value, _stronglyBound: Value = false): void {
+      const named = nameOf(name);
+      if (data === null || data === undefined) {
+        throw s.rt.error("ArgumentError", 2007, "data");
+      }
+
+      const bytes = avm2.bytesOf(s.rt, data as AsObject);
+      const copy = bytes.buffer.slice(0, bytes.length);
+      if (copy.length === 0) {
+        store()?.removeItem(named);
+      } else {
+        store()?.setItem(named, copy);
+      }
+    }
+
+    static getItem(name: Value): Value {
+      const bytes = store()?.getItem(nameOf(name));
+      if (!bytes || bytes.length === 0) {
+        return null;
+      }
+
+      const out = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray")) as AsObject;
+      const into = avm2.bytesOf(s.rt, out);
+      into.write(bytes);
+      into.position = 0;
+      return out;
+    }
+
+    static removeItem(name: Value): void {
+      store()?.removeItem(nameOf(name));
+    }
+
+    static reset(): void {
+      store()?.reset();
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.data::EncryptedLocalStore", EncryptedLocalStoreNatives);
+  return natives;
+}