@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/playerglobal/flash/display/ShaderData.js

@@ -0,0 +1,85 @@
+// flash.display.ShaderData: a Pixel Bender kernel read from its bytecode
+// (format's readPbj), and as dynamic properties what adl gives a script of
+// it: the kernel's metadata of the first opcode, an int or a string, its
+// name, a ShaderParameter for each parameter but the outputs and
+// _OutCoord, and a ShaderInput for each input.
+import { PBJ_STRING, PBJ_TYPES, PbjError, readPbj } from "../../../../format/index.js";
+import { avm2 } from "../../../../runtime/index.js";
+import { OUT_COORD, PixelBender } from "../../../bitmap/pixel-bender.js";
+/** A kernel's program, compiled when a job first runs it. */
+const programs = new WeakMap();
+export function programOf(kernel) {
+    let program = programs.get(kernel);
+    if (!program) {
+        program = new PixelBender(kernel);
+        programs.set(kernel, program);
+    }
+    return program;
+}
+/** A metadata value as adl gives it: a string, else a new Array of its numbers. */
+function metadataValue(s, value) {
+    return typeof value === "string" ? value : s.rt.array([...value]);
+}
+export function shaderDataNatives(s) {
+    const natives = {};
+    class ShaderDataNatives {
+        "flash.display:ShaderData::_setByteCode"(code) {
+            if (code === null || code === undefined) {
+                throw s.rt.error("TypeError", 2007, "byteCode");
+            }
+            // The whole ByteArray, whatever its position, which is left at its end.
+            const bytes = avm2.bytesOf(s.rt, code);
+            let kernel;
+            try {
+                kernel = readPbj(bytes.buffer.subarray(0, bytes.length));
+            }
+            catch (e) {
+                if (!(e instanceof PbjError)) {
+                    throw e;
+                }
+                throw e.errorID === 2030
+                    ? s.rt.error("flash.errors::EOFError", 2030)
+                    : s.rt.error("ArgumentError", 2004);
+            }
+            finally {
+                bytes.position = bytes.length;
+            }
+            this.$kernel = kernel;
+            const own = this.$d;
+            for (const m of kernel.metadata) {
+                // An int of the kernel's is an int, not an Array of one.
+                own.set(m.key, typeof m.value === "string" ? m.value : m.value[0]);
+            }
+            if (kernel.name !== null) {
+                own.set("name", kernel.name);
+            }
+            let index = 0;
+            for (const p of kernel.parameters) {
+                if (p.output || p.name === OUT_COORD) {
+                    continue;
+                }
+                const o = s.rt.construct(s.rt.classNamed("flash.display::ShaderParameter"));
+                o.$type = PBJ_TYPES[p.type] ?? null;
+                o.$index = index++;
+                o.$value = null;
+                for (const m of p.metadata) {
+                    o.$d.set(m.key, metadataValue(s, m.value));
+                    if (m.key === "defaultValue") {
+                        o.$value = m.type === PBJ_STRING ? null : metadataValue(s, m.value);
+                    }
+                }
+                o.$d.set("name", p.name);
+                own.set(p.name, o);
+            }
+            for (const input of kernel.inputs) {
+                const o = s.rt.construct(s.rt.classNamed("flash.display::ShaderInput"));
+                o.$channels = input.channels;
+                o.$index = input.index;
+                o.$d.set("name", input.name);
+                own.set(input.name, o);
+            }
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::ShaderData", ShaderDataNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/ShaderInput.js

@@ -0,0 +1,64 @@
+// flash.display.ShaderInput: an image a kernel samples, a BitmapData or
+// floats in a ByteArray or a Vector.<Number>, which then need the width and
+// height set; its channels and index are the kernel's.
+import { avm2 } from "../../../../runtime/index.js";
+const resolved = new WeakMap();
+/** The classes, looked up at the first call, once playerglobal is loaded. */
+export function shaderClasses(s) {
+    let classes = resolved.get(s);
+    if (!classes) {
+        classes = {
+            array: s.rt.classNamed("Array"),
+            bitmapData: s.rt.classNamed("flash.display::BitmapData"),
+            byteArray: s.rt.classNamed("flash.utils::ByteArray"),
+            vector: s.rt.resolve(s.rt.vector("Number")),
+            shaderParameter: s.rt.classNamed("flash.display::ShaderParameter"),
+            shaderInput: s.rt.classNamed("flash.display::ShaderInput"),
+            shaderEvent: s.rt.classNamed("flash.events::ShaderEvent"),
+        };
+        resolved.set(s, classes);
+    }
+    return classes;
+}
+/** Whether `v` is what a ShaderInput takes, and a ShaderJob writes: a BitmapData, a ByteArray or a Vector.<Number>. */
+export function isShaderImage(s, v) {
+    const c = shaderClasses(s);
+    return (s.rt.isInstance(v, c.bitmapData) ||
+        s.rt.isInstance(v, c.byteArray) ||
+        s.rt.isInstance(v, c.vector));
+}
+export function shaderInputNatives(s) {
+    const natives = {};
+    class ShaderInputNatives {
+        get input() {
+            return this.$input ?? null;
+        }
+        // null too is refused, as adl refuses it.
+        set input(v) {
+            if (!isShaderImage(s, v)) {
+                throw s.rt.error("ArgumentError", 2004);
+            }
+            this.$input = v;
+        }
+        get width() {
+            return this.$width ?? 0;
+        }
+        set width(v) {
+            this.$width = s.rt.toInt(v);
+        }
+        get height() {
+            return this.$height ?? 0;
+        }
+        set height(v) {
+            this.$height = s.rt.toInt(v);
+        }
+        get channels() {
+            return this.$channels ?? 0;
+        }
+        get index() {
+            return this.$index ?? 0;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::ShaderInput", ShaderInputNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/ShaderJob.js

@@ -0,0 +1,181 @@
+// flash.display.ShaderJob: a kernel run over a BitmapData, a ByteArray or
+// a Vector.<Number> (bitmap/pixel-bender.ts), as adl runs one. A job runs
+// once; start() checks everything and runs the kernel then, its
+// parameters and inputs read as they stand, and an asynchronous job's
+// result reaches the target, with ShaderEvent.COMPLETE, after the frame's
+// EXIT_FRAME (Scripting.afterExitFrame).
+// adl runs those jobs on a thread of its own and drops some, one started
+// while another runs among them; here each job completes.
+import { avm2 } from "../../../../runtime/index.js";
+import { outputPixel } from "../../../bitmap/pixel-bender.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+import { programOf } from "./ShaderData.js";
+import { isShaderImage, shaderClasses } from "./ShaderInput.js";
+import { inputImage, kernelValues } from "./shaders.js";
+const IDLE = 0;
+const RUNNING = 1;
+const DONE = 2;
+export function shaderJobNatives(s) {
+    const natives = {};
+    const classes = () => shaderClasses(s);
+    const isBitmapData = (v) => s.rt.isInstance(v, classes().bitmapData);
+    const isVector = (v) => s.rt.isInstance(v, classes().vector);
+    const refuse = (id, ...args) => {
+        throw s.rt.error("ArgumentError", id, ...args);
+    };
+    /** Write the output, `channels` floats a pixel, to the target. */
+    const deliver = (target, out, channels) => {
+        if (isBitmapData(target)) {
+            const store = target.$store;
+            if (store.disposed) {
+                return;
+            }
+            // Premultiplied as they come, each colour at most its alpha; three channels are opaque.
+            const pixels = new Uint32Array(store.width * store.height);
+            for (let i = 0, at = 0; i < pixels.length; i++, at += channels) {
+                pixels[i] = outputPixel(out, at, channels, store.transparent);
+            }
+            store.pixels = pixels;
+            store.changed();
+            return;
+        }
+        if (isVector(target)) {
+            // A Vector made fixed since start, at another length: adl crashes; refused here.
+            if (target.$fixed && target.$a.length !== out.length) {
+                throw s.rt.error("RangeError", 1126);
+            }
+            target.$a = Array.from(out);
+            return;
+        }
+        const bytes = avm2.bytesOf(s.rt, target);
+        const data = new Uint8Array(out.length * 4);
+        const view = new DataView(data.buffer);
+        for (let i = 0; i < out.length; i++) {
+            view.setFloat32(i * 4, out[i], bytes.littleEndian);
+        }
+        bytes.setLength(0);
+        bytes.position = 0;
+        bytes.write(data);
+    };
+    class ShaderJobNatives {
+        get shader() {
+            return this.$jobShader ?? null;
+        }
+        set shader(v) {
+            this.$jobShader = v ?? null;
+        }
+        get target() {
+            return this.$jobTarget ?? null;
+        }
+        set target(v) {
+            this.$jobTarget = v ?? null;
+        }
+        get width() {
+            return this.$jobWidth ?? 0;
+        }
+        set width(v) {
+            this.$jobWidth = s.rt.toInt(v);
+        }
+        get height() {
+            return this.$jobHeight ?? 0;
+        }
+        set height(v) {
+            this.$jobHeight = s.rt.toInt(v);
+        }
+        get progress() {
+            return this.$jobProgress ?? Number.NaN;
+        }
+        start(waitForCompletion) {
+            if ((this.$jobState ?? IDLE) !== IDLE) {
+                refuse(2172);
+            }
+            const shader = this.$jobShader ?? null;
+            if (shader === null) {
+                throw s.rt.error("TypeError", 2007, "shader");
+            }
+            const data = shader.$data ?? null;
+            if (data === null || !data.$kernel) {
+                refuse(2171);
+            }
+            const program = programOf(data.$kernel);
+            const target = this.$jobTarget ?? null;
+            let width = this.$jobWidth ?? 0;
+            let height = this.$jobHeight ?? 0;
+            if (isBitmapData(target)) {
+                // A BitmapData is written whole, whatever the job's size; a disposed one is
+                // an output adl cannot write.
+                const store = target.$store;
+                const type = program.output.type;
+                if (!store || store.disposed || (type !== 0x3 && type !== 0x4)) {
+                    refuse(2162);
+                }
+                width = store.width;
+                height = store.height;
+            }
+            else if (!isShaderImage(s, target) || width <= 0 || height <= 0) {
+                refuse(2004);
+            }
+            const kernel = program.kernel;
+            const images = new Map();
+            const read = [];
+            for (const input of kernel.inputs) {
+                const image = inputImage(s, data, input.name, input.channels, read);
+                images.set(input.index, image);
+            }
+            for (const texture of program.sampled) {
+                if (!images.has(texture)) {
+                    refuse(2167);
+                }
+            }
+            const values = kernelValues(s, data, kernel);
+            // Read: adl moves the positions before it refuses a fixed Vector (1126).
+            for (const move of read) {
+                move();
+            }
+            // A ByteArray or a Vector the browser cannot allocate is refused, not the player ended.
+            let out;
+            try {
+                out = new Float32Array(width * height * program.channels);
+            }
+            catch (e) {
+                if (e instanceof RangeError) {
+                    refuse(2004);
+                }
+                throw e;
+            }
+            const vector = isVector(target) ? target : null;
+            if (vector?.$fixed && vector.$a.length !== out.length) {
+                throw s.rt.error("RangeError", 1126);
+            }
+            program.run(values, images, width, height, out);
+            if (waitForCompletion) {
+                deliver(target, out, program.channels);
+                this.$jobState = DONE;
+                this.$jobProgress = 1;
+                return;
+            }
+            // Done already, as adl's thread nearly is by the time start returns; the target waits.
+            this.$jobState = RUNNING;
+            this.$jobProgress = 1;
+            s.afterExitFrame.push(() => {
+                if (this.$jobState !== RUNNING) {
+                    return;
+                }
+                this.$jobState = DONE;
+                deliver(target, out, program.channels);
+                const o = target;
+                const event = s.rt.construct(classes().shaderEvent, "complete", false, false, isBitmapData(o) ? o : null, s.rt.isInstance(o, classes().byteArray) ? o : null, vector);
+                dispatchEvent(s, this, event);
+            });
+        }
+        /** A running job's result is dropped, its progress 0 again; before start, or after, nothing happens. */
+        cancel() {
+            if (this.$jobState === RUNNING) {
+                this.$jobState = DONE;
+                this.$jobProgress = 0;
+            }
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::ShaderJob", ShaderJobNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/ShaderParameter.js

@@ -0,0 +1,23 @@
+// flash.display.ShaderParameter: a kernel parameter's value, its type's
+// name and its index among the kernel's parameters, set by ShaderData; its
+// metadata are dynamic properties.
+import { avm2 } from "../../../../runtime/index.js";
+export function shaderParameterNatives(_s) {
+    const natives = {};
+    class ShaderParameterNatives {
+        get value() {
+            return this.$value ?? null;
+        }
+        set value(v) {
+            this.$value = v ?? null;
+        }
+        get type() {
+            return this.$type ?? null;
+        }
+        get index() {
+            return this.$index ?? 0;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::ShaderParameter", ShaderParameterNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/Shape.js

@@ -0,0 +1,13 @@
+// flash.display.Shape: a display object with a Graphics and nothing else.
+import { avm2 } from "../../../../runtime/index.js";
+import { graphicsOf } from "./Graphics.js";
+export function shapeNatives(s) {
+    const natives = {};
+    class ShapeNatives {
+        get graphics() {
+            return graphicsOf(s, this);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::Shape", ShapeNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/SimpleButton.js

@@ -0,0 +1,103 @@
+// flash.display.SimpleButton: a button's four states and its flags, on the
+// player's ButtonObject. The state it shows is the up one until the pointer
+// moves it (input/pointer.ts); a state set while shown takes its place at once.
+import { avm2 } from "../../../../runtime/index.js";
+import { pickWork } from "../../../display/display.js";
+import { mixerTransform, setMixerTransform } from "../media/Sound.js";
+import { displayOf } from "./DisplayObject.js";
+/** The ButtonObject a SimpleButton is the face of. */
+function buttonOf(o) {
+    return displayOf(o);
+}
+export function simpleButtonNatives(s) {
+    const natives = {};
+    const get = (o, state) => {
+        const b = buttonOf(o);
+        const d = state === "hitTest" ? b.hitTestState : b.stateObject(state);
+        return d?.object ?? null;
+    };
+    const set = (o, state, v) => {
+        const b = buttonOf(o);
+        const d = v === null || v === undefined ? null : displayOf(v);
+        // A state is the button's own: out of the container it was in. One that holds the button
+        // stays where it is: it cannot be the button's child (show).
+        if (d?.parent && d.parent !== b && !d.encloses(b)) {
+            d.parent.removeChild(d);
+        }
+        if (state === "up") {
+            b.upState = d;
+        }
+        else if (state === "over") {
+            b.overState = d;
+        }
+        else if (state === "down") {
+            b.downState = d;
+        }
+        else {
+            b.hitTestState = d;
+        }
+        b.show();
+        // adl reports #2150 as an error nothing caught, from the setter of the state the button
+        // shows, and the script goes on with the state set (`button-cycle`).
+        if (d?.encloses(b) && state === b.state) {
+            s.reportUncaught(s.rt.error("ArgumentError", 2150));
+        }
+    };
+    class SimpleButtonNatives {
+        "flash.display:SimpleButton::_updateButton"() {
+            buttonOf(this).show();
+        }
+        get upState() {
+            return get(this, "up");
+        }
+        set upState(v) {
+            set(this, "up", v);
+        }
+        get overState() {
+            return get(this, "over");
+        }
+        set overState(v) {
+            set(this, "over", v);
+        }
+        get downState() {
+            return get(this, "down");
+        }
+        set downState(v) {
+            set(this, "down", v);
+        }
+        get hitTestState() {
+            return get(this, "hitTest");
+        }
+        set hitTestState(v) {
+            set(this, "hitTest", v);
+        }
+        get enabled() {
+            return buttonOf(this).enabled;
+        }
+        set enabled(v) {
+            buttonOf(this).enabled = !!v;
+            pickWork.changes++;
+        }
+        get useHandCursor() {
+            return buttonOf(this).useHandCursor;
+        }
+        set useHandCursor(v) {
+            buttonOf(this).useHandCursor = !!v;
+        }
+        get trackAsMenu() {
+            return buttonOf(this).trackAsMenu;
+        }
+        set trackAsMenu(v) {
+            buttonOf(this).trackAsMenu = !!v;
+        }
+        // SoundMixer's, as Flash has it, not the button's own (the sound-mixer case).
+        get soundTransform() {
+            return mixerTransform(s);
+        }
+        set soundTransform(v) {
+            setMixerTransform(s, v);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::SimpleButton", SimpleButtonNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/display/Sprite.js

@@ -0,0 +1,84 @@
+// flash.display.Sprite: its constructor's private native constructChildren
+// makes a symbol's first frame alive, placed before the constructor for a
+// timeline's child and here for a script's, so that the subclass's
+// constructor finds the children by name; a Sprite a script makes has none.
+// Its soundTransform is kept, in whole percents as a channel's, and read
+// back as a copy; it mixes the timeline sounds of the sprite and all in it.
+import { avm2 } from "../../../../runtime/index.js";
+import { MovieClip } from "../../../display/display.js";
+import { dropTargetOf, hitAreaOf, setHitArea } from "../../../input/pointer.js";
+import { mixOf, updateTimelineMixes } from "../../../media/sounds.js";
+import { channelMix, transformOf } from "../media/Sound.js";
+import { graphicsOf } from "./Graphics.js";
+export function spriteNatives(s) {
+    const natives = {};
+    class SpriteNatives {
+        get graphics() {
+            return graphicsOf(s, this);
+        }
+        "flash.display:Sprite::constructChildren"() {
+            const d = this.$display;
+            if (d instanceof MovieClip) {
+                d.enterFirstFrame();
+            }
+        }
+        get soundTransform() {
+            return transformOf(s, this.$soundMix ?? mixOf(null));
+        }
+        set soundTransform(v) {
+            // Named so in Sprite's error, where SimpleButton's and SoundMixer's say sndTransform.
+            if (v === null || v === undefined) {
+                throw s.rt.error("TypeError", 2007, "soundTransform");
+            }
+            this.$soundMix = channelMix(mixOf(v));
+            updateTimelineMixes(s);
+        }
+        /** Kept for Tab, which visits a sprite in button mode, and the pointer, which shows a hand over it. */
+        get buttonMode() {
+            return this.$buttonMode ?? false;
+        }
+        set buttonMode(v) {
+            this.$buttonMode = !!v;
+        }
+        get useHandCursor() {
+            return this.$useHandCursor ?? true;
+        }
+        set useHandCursor(v) {
+            this.$useHandCursor = !!v;
+        }
+        /** Another sprite whose drawing the pointer hits this one by (input/pointer.ts). */
+        get hitArea() {
+            return hitAreaOf(this.$display)?.object ?? null;
+        }
+        set hitArea(v) {
+            setHitArea(this.$display, v?.$display ?? null);
+        }
+        /** The object the sprite was last dragged over, kept once it is dropped. */
+        get dropTarget() {
+            return dropTargetOf(this.$display)?.object ?? null;
+        }
+        startDrag(lockCenter, bounds) {
+            let rect = null;
+            if (bounds !== null && bounds !== undefined) {
+                const o = bounds;
+                const get = (key) => s.rt.toNumber(s.rt.getProperty(o, avm2.qname(avm2.publicNs, key)));
+                const x = get("x");
+                const y = get("y");
+                const right = x + get("width");
+                const bottom = y + get("height");
+                rect = {
+                    xMin: Math.min(x, right),
+                    yMin: Math.min(y, bottom),
+                    xMax: Math.max(x, right),
+                    yMax: Math.max(y, bottom),
+                };
+            }
+            s.pointer?.startDrag(this.$display, !!lockCenter, rect);
+        }
+        stopDrag() {
+            s.pointer?.stopDrag();
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.display::Sprite", SpriteNatives);
+    return natives;
+}