@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/avm1/globals/SharedObject.js

@@ -0,0 +1,245 @@
+// 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 "../../../runtime/index.js";
+import { put, Reader, Writer } from "../amf.js";
+const encoder = new TextEncoder();
+/** 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, name, data, version) {
+    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, realm, version) {
+    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) {
+    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();
+    const entryOf = (self) => {
+        for (const entry of open.values()) {
+            if (entry.o === self) {
+                return entry;
+            }
+        }
+        return undefined;
+    };
+    const method = (name, f) => 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;
+        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 = 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;
+        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, b) {
+    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/dist/thread/player/avm1/globals/Sound.js

@@ -0,0 +1,238 @@
+// 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 "../../../runtime/index.js";
+import { soundsOf, startScriptSound, stopSoundsOf, stopTimelineSound, stopTimelineSounds, } from "../../media/sounds.js";
+export const FULL = {
+    volume: 100,
+    leftToLeft: 100,
+    leftToRight: 0,
+    rightToLeft: 0,
+    rightToRight: 100,
+};
+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) {
+    return n | 0;
+}
+/** loops as Rust's `as u16` casts it, at least 1. */
+function loopsOf(n) {
+    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) {
+    return t.leftToLeft !== 100 ? 100 - Math.abs(t.leftToLeft) : Math.abs(t.rightToRight) - 100;
+}
+/** `_global.Sound`. */
+export function soundClass(host) {
+    const realm = host.realm;
+    const h = host.sounds;
+    const states = new WeakMap();
+    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.target === undefined || state.target === null;
+    // The clip a targeted Sound works on, null where the target names none.
+    const owner = (state, v) => (global(state) ? null : host.resolve(state.target, v));
+    const valid = (state, v) => 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, v) => {
+        if (global(state)) {
+            return host.soundTransform(null);
+        }
+        const d = owner(state, v);
+        return d === null ? undefined : host.soundTransform(d);
+    };
+    const setTransform = (state, v, f) => {
+        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) => {
+        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, f, 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, _, v) => valid(state, v) ? state.duration : undefined;
+    const position = (state, _, v) => 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) => 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],
+        ]) {
+            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) {
+    return {
+        volume: t.volume / 100,
+        leftToLeft: t.leftToLeft / 100,
+        leftToRight: t.leftToRight / 100,
+        rightToLeft: t.rightToLeft / 100,
+        rightToRight: t.rightToRight / 100,
+    };
+}

package/dist/thread/player/avm1/globals/Stage.js

@@ -0,0 +1,12 @@
+// 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 "../../../runtime/index.js";
+export function stageObject(realm, size) {
+    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;
+}