@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/avm1/queue.js

@@ -0,0 +1,303 @@
+// The AVM1 action queue: what a frame, an event or a script queues, run by
+// priority, the most urgent first, as Ruffle's
+// (https://github.com/ruffle-rs/ruffle) ActionQueue has it (MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors),
+// and the blocks each queued action runs (docs/avm1.md, "The frame").
+import { avm1 } from "../../runtime/index.js";
+import { ClipNative, nativeOf } from "./globals/MovieClip.js";
+// The queue's priorities, which it runs in order: initialize clip events
+// first, then the root's DoInitAction blocks, then constructions, then the
+// rest, frame actions, events and methods, each in the order queued
+// (Ruffle's ActionPriority; adl has a frame's initialize events before its
+// DoInitAction blocks, which Ruffle runs as the SWF loads).
+export const INITIALIZE = 0;
+export const INIT = 1;
+export const CONSTRUCT = 2;
+export const NORMAL = 3;
+// What a queued action is.
+/** A DoAction tag's blocks, `index` the tag's body's offset. */
+export const FRAME = 0;
+/** A block alone, a DoInitAction's or a clip event's, by its index. */
+export const BLOCK = 1;
+/** A timeline's clip's construction: its registered class's prototype and constructor, and its construct events. */
+export const CONSTRUCTION = 2;
+/** An AS2 event method, `name`, of the clip's object. */
+export const METHOD = 3;
+/** The SWF stopped, at a place whose clip actions Flash cannot read. */
+export const HALT = 4;
+/** A broadcaster's message, `name`, to its listeners: Key's and Mouse's, as the player sends them. */
+export const NOTIFY = 5;
+/** A method, `name`, of `object`, called with `args`, as a script would call it. */
+export const CALL = 6;
+/** An action waiting its turn in the frame. */
+export class Queued {
+    kind;
+    clip;
+    swf;
+    index;
+    entry;
+    unload;
+    name;
+    blocks;
+    object;
+    args;
+    constructor(kind, clip, 
+    /** The SWF whose blocks `index` and `blocks` are. */
+    swf = null, index = 0, 
+    /** Which of the clip's frame entries queued a FRAME: blocks of one share their constant pool. */
+    entry = 0, 
+    /** Whether it is an unload's, which runs for a clip removed since. */
+    unload = false, name = "", blocks = NO_BLOCKS, 
+    /** A NOTIFY's broadcaster or a CALL's object, and the arguments. */
+    object = null, args = NO_ARGS) {
+        this.kind = kind;
+        this.clip = clip;
+        this.swf = swf;
+        this.index = index;
+        this.entry = entry;
+        this.unload = unload;
+        this.name = name;
+        this.blocks = blocks;
+        this.object = object;
+        this.args = args;
+    }
+}
+export const NO_BLOCKS = [];
+/** How many queued actions of a priority run before those run are dropped from its queue. */
+const COMPACT_AT = 4096;
+export const NO_ARGS = [];
+/** The queue a movie's actions wait in, by priority, and what runs them. */
+export class ActionQueue {
+    movie;
+    /** The queue, by priority, and how far each has run. */
+    queues = [[], [], [], []];
+    heads = [0, 0, 0, 0];
+    /** Whether the queue is running, which a function's return runs the earlier passes of. */
+    running = false;
+    /** The pass of the action the queue runs, and the pass `next` last took from. */
+    priority = NORMAL;
+    taken = NORMAL;
+    constructor(movie) {
+        this.movie = movie;
+    }
+    enqueue(priority, q) {
+        this.queues[priority].push(q);
+    }
+    /** The next action of priorities `from` to `to`, the most urgent first; null for none. */
+    next(from = INITIALIZE, to = NORMAL) {
+        for (let p = from; p <= to; p++) {
+            const queue = this.queues[p];
+            // Gotos that go back and forth queue each other's frames for as long
+            // as they run, which is forever in a SWF that never stops them: what
+            // has run goes, and so do the clips they removed, so that such a SWF
+            // runs into the script timeout without its memory growing.
+            if (this.heads[p] >= COMPACT_AT) {
+                queue.splice(0, this.heads[p]);
+                this.heads[p] = 0;
+                const movie = this.movie;
+                movie.clips = movie.clips.filter((clip) => !movie.removed(clip));
+            }
+            if (this.heads[p] < queue.length) {
+                this.taken = p;
+                return queue[this.heads[p]++];
+            }
+        }
+        return null;
+    }
+    /**
+     * Run what is queued, by priority, what it queues included: the actions
+     * of a clip still on the display list but an unload's; a frame entry's
+     * blocks sharing a constant pool, each starting with the one the block
+     * before left.
+     */
+    run() {
+        const movie = this.movie;
+        if (!movie.loaded || this.running) {
+            return;
+        }
+        this.running = true;
+        let pool = [];
+        let last = null;
+        try {
+            for (let q = this.next(); q !== null; q = this.next()) {
+                if (movie.halted || movie.rt.disabled) {
+                    continue;
+                }
+                // A goto that queues its own frame again and again loops here, as a jump back does.
+                if (--movie.realm.budget < 0) {
+                    this.timeout();
+                }
+                this.priority = this.taken;
+                if (q.kind === FRAME) {
+                    if (last === null || last.clip !== q.clip || last.entry !== q.entry) {
+                        pool = [];
+                    }
+                    last = q;
+                    if (!this.gone(q.clip)) {
+                        pool = this.runOne(q, pool);
+                    }
+                }
+                else {
+                    this.runOne(q, []);
+                }
+            }
+        }
+        finally {
+            this.running = false;
+            for (let p = 0; p < this.queues.length; p++) {
+                this.queues[p].length = 0;
+                this.heads[p] = 0;
+            }
+        }
+    }
+    /** The queue's own check of the script timeout, which disables the movie's actions past it. */
+    timeout() {
+        const cx = this.movie.activationOf(this.movie.root);
+        if (cx !== null) {
+            this.movie.rt.call(cx, () => this.movie.realm.timeout());
+        }
+    }
+    /**
+     * A function of the SWF's returned to code the queue runs: Flash runs
+     * what was queued by then of the passes before that code's, a frame
+     * action's initializations and constructions, a construction's
+     * initializations (adl, and the corpus's register_and_init_order).
+     */
+    returned() {
+        if (!this.running) {
+            return;
+        }
+        const outer = this.priority;
+        try {
+            for (let q = this.next(INITIALIZE, outer - 1); q !== null; q = this.next(INITIALIZE, outer - 1)) {
+                if (!this.movie.halted && !this.movie.rt.disabled) {
+                    this.priority = this.taken;
+                    this.runOne(q, []);
+                }
+            }
+        }
+        finally {
+            this.priority = outer;
+        }
+    }
+    /**
+     * Whether the clip of a queued action is gone: its actions do not run
+     * but an unload's. One kept a frame for an unload handler is, where it
+     * has clip actions of its own; one without, kept for an onUnload or for
+     * a clip in it, runs what it queued before (adl; Ruffle skips them all).
+     */
+    gone(d) {
+        if (this.movie.removed(d)) {
+            return true;
+        }
+        const native = nativeOf(d);
+        return native?.pending === true && native.handlers !== null;
+    }
+    /** Run one queued action, from constant pool `pool` for a FRAME; the pool it leaves. */
+    runOne(q, pool) {
+        const clip = q.clip;
+        if (q.kind !== FRAME && !q.unload && this.gone(clip)) {
+            return pool;
+        }
+        switch (q.kind) {
+            case FRAME:
+                // A clip a load has filled since runs none of what it queued before.
+                if (q.swf !== this.movie.swfOf(clip)) {
+                    return pool;
+                }
+                for (const index of q.swf.list?.byTag.get(q.index) ?? NO_BLOCKS) {
+                    pool = this.runBlock(q.swf, index, pool, clip);
+                }
+                return pool;
+            case BLOCK:
+                this.runBlock(q.swf, q.index, [], clip);
+                break;
+            case CONSTRUCTION:
+                this.construction(q);
+                break;
+            case METHOD: {
+                const face = clip.avm1;
+                const cx = this.movie.activationOf(clip);
+                if (face !== null && cx !== null && !this.movie.removed(clip)) {
+                    this.movie.rt.callMethod(cx, face, q.name, NO_ARGS, this.movie.swfOf(clip).version);
+                }
+                break;
+            }
+            case HALT:
+                this.movie.halted = true;
+                break;
+            case CALL: {
+                const cx = this.movie.activationOf(clip);
+                if (cx !== null && q.object !== null) {
+                    this.movie.rt.callMethod(cx, q.object, q.name, q.args, this.movie.version);
+                }
+                break;
+            }
+            case NOTIFY: {
+                const cx = this.movie.activationOf(clip);
+                const object = q.object;
+                if (cx !== null && object !== null) {
+                    this.movie.rt.call(cx, () => {
+                        avm1.broadcastMessage(object, q.name, q.args, this.movie.version, (listener) => {
+                            const display = listener.display;
+                            return display instanceof ClipNative && this.movie.removed(display.target);
+                        });
+                    });
+                }
+                break;
+            }
+        }
+        return pool;
+    }
+    /**
+     * A timeline's clip constructed: its registered class's prototype, its
+     * construct events, then the class's constructor on it.
+     */
+    construction(q) {
+        const face = q.clip.avm1;
+        if (face === null) {
+            return;
+        }
+        const constr = this.movie.classes.classOf(q.clip);
+        if (constr !== null) {
+            face.define("__proto__", avm1.get(constr, "prototype", this.movie.swfOf(q.clip).version), avm1.DONT_ENUM | avm1.DONT_DELETE);
+        }
+        for (const block of q.blocks) {
+            this.runBlock(q.swf, block, [], q.clip);
+        }
+        if (constr !== null) {
+            this.movie.scriptClips.construct(q.clip, face, constr);
+        }
+    }
+    /** CallFrame: the actions of `clip`'s frame `frame`, run now in order, each with a pool of its own. */
+    callFrame(clip, frame) {
+        const swf = this.movie.swfOf(clip);
+        for (const command of clip.timeline.frames[frame - 1] ?? []) {
+            if (command.type === "actions") {
+                for (const index of swf.list?.byTag.get(command.tag) ?? []) {
+                    this.runBlock(swf, index, [], clip);
+                }
+            }
+        }
+    }
+    /**
+     * Run `swf`'s block `index` with `clip` as its target, starting from
+     * constant pool `pool`; the pool it leaves.
+     */
+    runBlock(swf, index, pool, clip) {
+        const regions = swf?.blocks[index];
+        const cx = regions ? this.movie.activationOf(clip, pool) : null;
+        if (!regions || cx === null) {
+            return pool;
+        }
+        try {
+            this.movie.rt.run(regions, cx);
+        }
+        catch (error) {
+            if (!(error instanceof avm1.Halt)) {
+                this.movie.onUncaught(error);
+            }
+        }
+        return cx.pool;
+    }
+}

package/dist/thread/player/avm1/sound.js

@@ -0,0 +1,106 @@
+import { updateMixes } from "../media/sounds.js";
+import { FULL, mixOfTransform, } from "./globals/Sound.js";
+import { asciiLower } from "./paths.js";
+import { NO_ARGS } from "./queue.js";
+/** The movie's sounds, as Sound and the timeline's sounds see them. */
+export class Avm1Sounds {
+    movie;
+    audio;
+    /** What the timeline's sounds, and Sound's, play by. */
+    sounds;
+    /** The frames played, which the timeline's sounds count by. */
+    frames = 0;
+    /** Each sound decoded once for the device. */
+    decodes = new WeakMap();
+    /** The transforms Sound gave clips, and the global one. */
+    soundTransforms = new WeakMap();
+    globalSoundTransform = FULL;
+    /** The Sounds whose sound ended, for their onSoundComplete after the frame's actions. */
+    completed = [];
+    constructor(movie, audio) {
+        this.movie = movie;
+        this.audio = audio;
+        const media = this;
+        this.sounds = {
+            get audio() {
+                return media.audio;
+            },
+            get now() {
+                return movie.timers.now();
+            },
+            get frames() {
+                return media.frames;
+            },
+            get frameRate() {
+                return movie.frameRate;
+            },
+            soundClip: (character) => this.soundClip(character),
+            ownMix: (d) => {
+                const t = this.soundTransforms.get(d);
+                return t === undefined ? undefined : mixOfTransform(t);
+            },
+            get mixer() {
+                return mixOfTransform(media.globalSoundTransform);
+            },
+            scriptSounds: () => 0,
+        };
+    }
+    get realm() {
+        return this.movie.realm;
+    }
+    resolve(value, version) {
+        return this.movie.resolve(value, version);
+    }
+    /** The DefineSound ExportAssets named `name`, any case, as attachSound finds it. */
+    exportedSound(name) {
+        const swf = this.movie.currentSwf();
+        const id = swf.exports.get(asciiLower(name));
+        const character = id === undefined ? undefined : swf.library?.characters.get(id);
+        return character?.type === "sound" ? character : null;
+    }
+    soundTransform(d) {
+        return d === null ? this.globalSoundTransform : (this.soundTransforms.get(d) ?? FULL);
+    }
+    setSoundTransform(d, transform) {
+        if (d === null) {
+            this.globalSoundTransform = transform;
+        }
+        else {
+            this.soundTransforms.set(d, transform);
+        }
+        updateMixes(this.sounds);
+    }
+    /** A Sound's sound has ended: its onSoundComplete runs once the frame's actions have. */
+    complete(o) {
+        this.completed.push(o);
+    }
+    /** Each ended Sound's onSoundComplete, in the root's activation: whether any ran. */
+    soundsCompleted() {
+        const completed = this.completed;
+        this.completed = [];
+        const movie = this.movie;
+        const root = movie.root;
+        if (completed.length === 0 || root === null) {
+            return false;
+        }
+        const cx = movie.activationOf(root);
+        for (const o of completed) {
+            if (cx !== null && !movie.halted) {
+                movie.rt.callMethod(cx, o, "onSoundComplete", NO_ARGS, movie.version);
+            }
+        }
+        return true;
+    }
+    soundClip(character) {
+        const audio = this.audio;
+        if (audio === null) {
+            return null;
+        }
+        let clip = this.decodes.get(character);
+        if (clip === undefined) {
+            clip = Promise.resolve().then(() => audio.decode(character.definition));
+            this.decodes.set(character, clip);
+        }
+        return clip;
+    }
+}

package/dist/thread/player/avm1/swf.js

@@ -0,0 +1,141 @@
+// One AVM1 SWF the player runs, the main one or one loadMovie loaded, and
+// what is read of its action list once: its root's frames' exports,
+// DoInitAction blocks, ScriptLimits and the places Flash cannot read, a
+// place's clip actions and a button's condition blocks.
+// The per-movie library and button conditions follow Ruffle's
+// (https://github.com/ruffle-rs/ruffle): MIT OR Apache-2.0, Copyright (c)
+// 2018-2022 Ruffle LLC and Ruffle contributors.
+import { ClipEvent, readExports, tags, } from "../../format/index.js";
+/** The first of `events`, a place's field of all events, by which Flash stops. */
+export function stopOf(events) {
+    if (events & (ClipEvent.load | ClipEvent.initialize)) {
+        return "place";
+    }
+    if (events & ClipEvent.construct) {
+        return "construct";
+    }
+    return events & ClipEvent.enterFrame ? "enterFrame" : null;
+}
+const STOPS = ["place", "construct", "enterFrame"];
+export const NO_HANDLERS = [];
+const NO_BUTTON_HANDLERS = [];
+/**
+ * One AVM1 SWF the player runs, the main one or one loadMovie loaded: its
+ * blocks, its library and what its root's frames export and initialize,
+ * which its own code and timelines use, not another's (Ruffle's per-movie
+ * library). Every SWF shares the player's realm, `_global` among it.
+ */
+export class Avm1Swf {
+    library;
+    list;
+    version;
+    url;
+    length;
+    size;
+    /** Its module's blocks, by index. */
+    blocks = [];
+    /** By its root's frame, 1 the first. */
+    frames = new Map();
+    /** The sprites whose DoInitAction has run. */
+    initialized = new Set();
+    /** Exported characters by name in lower case, as attachMovie finds them, and each one's name. */
+    exports = new Map();
+    exportNames = new Map();
+    /** Each button character's condition blocks, by its id, gathered from the action list once. */
+    buttonHandlers = null;
+    /** The clip that plays it as its root: level 0's, a level's or the clip it was loaded into. */
+    root = null;
+    constructor(library, list, version, 
+    /** Its URL, which `_url` gives. */
+    url, 
+    /** Its length in bytes, which getBytesTotal and getBytesLoaded give for its root. */
+    length, 
+    /** Its size as it came, compressed, which MovieClipLoader.getProgress gives. */
+    size = length) {
+        this.library = library;
+        this.list = list;
+        this.version = version;
+        this.url = url;
+        this.length = length;
+        this.size = size;
+    }
+}
+/** Each root frame's exports, DoInitAction blocks, the tags Flash cannot read and its ScriptLimits. */
+export function readRootFrames(swf, into) {
+    const list = into.list;
+    if (list === null) {
+        return;
+    }
+    // The root has a frame a ShowFrame tag ends; what follows the last is the last's.
+    const last = Math.max(1, swf.tags.filter((t) => t.code === tags.ShowFrame).length);
+    const frameOf = (frame) => {
+        const at = Math.min(frame, last);
+        let actions = into.frames.get(at);
+        if (!actions) {
+            actions = { exports: [], inits: [], stop: null, limits: null };
+            into.frames.set(at, actions);
+        }
+        return actions;
+    };
+    for (const block of list.blocks) {
+        const owner = block.owner;
+        if (block.length > 0 && owner.type === "init" && owner.timeline === null) {
+            frameOf(owner.frame + 1).inits.push({ sprite: owner.sprite, block: block.index });
+        }
+    }
+    // A ScriptLimits takes effect as its frame comes, before the frame's
+    // actions, the frame's last one if it has two (adl): two u16s, the
+    // recursion depth and the script timeout in seconds.
+    let frame = 1;
+    for (const tag of swf.tags) {
+        const events = list.corruptEvents.get(tag.offset);
+        if (tag.code === tags.ShowFrame) {
+            frame++;
+        }
+        else if (tag.code === tags.ScriptLimits && tag.length >= 4) {
+            const at = tag.offset;
+            const b = swf.bytes;
+            frameOf(frame).limits = [b[at] | (b[at + 1] << 8), b[at + 2] | (b[at + 3] << 8)];
+        }
+        else if (tag.code === tags.ExportAssets) {
+            frameOf(frame).exports.push(...readExports(swf.bytes, tag));
+        }
+        else if (events !== undefined) {
+            const actions = frameOf(frame);
+            const stop = stopOf(events);
+            if (stop && (!actions.stop || STOPS.indexOf(stop) < STOPS.indexOf(actions.stop))) {
+                actions.stop = stop;
+            }
+        }
+    }
+}
+/** A place's clip actions, with the events each runs for, as `swf`'s action list has them. */
+export function handlersOf(place, swf) {
+    const list = swf.list;
+    if (place.actions === null || place.actions.length === 0 || list === null) {
+        return null;
+    }
+    const handlers = [];
+    for (const index of place.actions) {
+        const owner = list.blocks[index].owner;
+        if (owner.type === "clip") {
+            handlers.push({ events: owner.events, key: owner.key, block: index });
+        }
+    }
+    return handlers;
+}
+/** `id`'s condition blocks: a DefineButton's one, or a DefineButton2's, one a BUTTONCONDACTION. */
+export function handlersOfButton(swf, id) {
+    if (swf.buttonHandlers === null) {
+        const handlers = new Map();
+        for (const [block, { owner }] of (swf.list?.blocks ?? []).entries()) {
+            if (owner.type === "button") {
+                const list = handlers.get(owner.button) ?? [];
+                list.push({ conditions: owner.conditions, key: owner.key, block });
+                handlers.set(owner.button, list);
+            }
+        }
+        swf.buttonHandlers = handlers;
+    }
+    return swf.buttonHandlers.get(id) ?? NO_BUTTON_HANDLERS;
+}

package/dist/thread/player/avm1/timers.js

@@ -0,0 +1,113 @@
+// An AVM1 movie's clock: the time getTimer and setInterval's timers go by,
+// the real clock's or the frames', and the script timeout's start and end
+// around the scripts that run. On the real clock, a script that spins on
+// getTimer to wait has the clock skip to the time it waits for, as AS3's
+// does (clock.ts).
+// GetTime's frame clock follows Ruffle's (https://github.com/ruffle-rs/
+// ruffle): MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle
+// contributors.
+import { SpinClock } from "../clock.js";
+import { MovieClip } from "../display/display.js";
+/** The ms in a frame of the SWF's rate. */
+const frameMs = (rate) => 1000 / (rate || 24);
+export const defaultClock = () => typeof performance !== "undefined" ? () => performance.now() : null;
+/** The real clock the script timeout reads, whatever clock the timers go by. */
+const timeoutClock = typeof performance !== "undefined" ? () => performance.now() : () => Date.now();
+/** The movie's clock and its timers, which fire between frames. */
+export class Timers {
+    movie;
+    realTime;
+    /** The frame clock, ms since the start, a frame's duration on each frame. */
+    frameClock = 0;
+    /** GetTime's calls in the frame, and what they have added to a frame clock that stands still. */
+    timeCalls = 0;
+    timeOffset = 0;
+    /** The real clock's reading at the start. */
+    start;
+    /** How deep begin() is: only the outermost begin and end start and stop the scripts' clock. */
+    beginDepth = 0;
+    /** getTimer on the real clock, skipping a spin on it; none on the frame clock. */
+    spin;
+    constructor(movie, realTime) {
+        this.movie = movie;
+        this.realTime = realTime;
+        this.start = this.realTime?.() ?? 0;
+        const real = this.realTime;
+        this.spin = real === null ? null : new SpinClock(() => real() - this.start);
+    }
+    /** A frame starts: GetTime's calls are counted afresh. */
+    frameStarted() {
+        this.timeCalls = 0;
+        this.spin?.settle();
+    }
+    /** Timers fire between frames: a spin's calls are counted afresh. */
+    idleStarted() {
+        this.spin?.settle();
+    }
+    /**
+     * How far getTimer and the timers run ahead of the real clock, in ms,
+     * since a spin had the clock skip to the time it waited for: the frames
+     * wait for the real clock (Player.advance). Ends the pass that ran.
+     */
+    ahead() {
+        return this.spin?.ahead() ?? 0;
+    }
+    /** A frame's actions have run: until the next frame, its time passes and the timers due fire. */
+    afterFrame(rate) {
+        this.frameClock += frameMs(rate);
+        this.fire();
+    }
+    /**
+     * The time on the player's clock: the real clock's since the start, and
+     * what a spin skipped on getTimer, so that the timers keep to it; or the
+     * frame clock.
+     */
+    now() {
+        if (this.realTime === null || this.spin === null) {
+            return this.frameClock;
+        }
+        const real = this.realTime() - this.start;
+        return real + this.spin.lead(real);
+    }
+    /**
+     * GetTime: whole ms since the start. A frame clock stands still through
+     * a frame, so, as Ruffle has it, a script that asks it again and again,
+     * waiting for it to move, sees a ms pass every fifth call from the 20th.
+     */
+    getTime() {
+        if (this.spin !== null) {
+            return Math.floor(this.spin.read());
+        }
+        this.timeCalls++;
+        if (this.timeCalls >= 20 && this.timeCalls % 5 === 0) {
+            this.timeOffset++;
+        }
+        return Math.floor(this.movie.realm.timers.now) + this.timeOffset;
+    }
+    /** Scripts start running: the script timeout counts from now. */
+    begin() {
+        if (this.beginDepth++ > 0) {
+            return;
+        }
+        this.movie.realm.timers.now = this.now();
+        this.movie.rt.begin(timeoutClock(), timeoutClock);
+    }
+    end() {
+        if (--this.beginDepth > 0) {
+            return;
+        }
+        this.movie.rt.end();
+    }
+    /** The timers due by now, each running what it queues after it. */
+    fire() {
+        const movie = this.movie;
+        const root = movie.root;
+        if (movie.realm.timers.size === 0 || root === null) {
+            return;
+        }
+        movie.rt.fireTimers(this.now(), movie.version, () => movie.activationOf(root), () => movie.queue.run(), (object) => {
+            const target = object.display?.target;
+            return target instanceof MovieClip && movie.removed(target);
+        });
+    }
+}