@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/bitmap/png.js

@@ -0,0 +1,139 @@
+// BitmapData.encode's PNG: a file of IHDR, one IDAT and IEND, as Flash
+// writes, RGBA for a transparent bitmap and RGB for an opaque one. The
+// colours are divided out of alpha as Flash's encoder does it,
+// floor(c * 256 / a) up to 255 (every alpha and value checked under adl),
+// which is not getPixel32's rounding. The bytes need not be Flash's, only
+// what they decode to: fast compression filters no row and deflates at
+// level 1, as Flash does; otherwise each row takes the filter whose output
+// sums smallest, libpng's heuristic, deflated at level 6 where Flash uses
+// 9: a 1080p frame takes a quarter of the time for 1% more bytes.
+import { zlibCompress } from "../../format/index.js";
+const CRC = new Uint32Array(256);
+for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    CRC[n] = c >>> 0;
+}
+function crc32(bytes, start, end) {
+    let c = 0xffffffff;
+    for (let i = start; i < end; i++) {
+        c = CRC[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+/** `rect` of the store, clipped to it and not empty, as a PNG file. */
+export function encodePng(store, rect, fast) {
+    const { x: x0, y: y0, width, height } = rect;
+    const channels = store.transparent ? 4 : 3;
+    const stride = 1 + width * channels;
+    const raw = new Uint8Array(stride * height);
+    const pixels = store.drawable;
+    for (let y = 0; y < height; y++) {
+        let j = y * stride + 1;
+        for (let i = (y0 + y) * store.width + x0, end = i + width; i < end; i++) {
+            const p = pixels[i];
+            const a = p >>> 24;
+            let r = (p >>> 16) & 0xff;
+            let g = (p >>> 8) & 0xff;
+            let b = p & 0xff;
+            if (a === 0) {
+                r = g = b = 0;
+            }
+            else if (a !== 255) {
+                r = Math.min(255, ((r << 8) / a) | 0);
+                g = Math.min(255, ((g << 8) / a) | 0);
+                b = Math.min(255, ((b << 8) / a) | 0);
+            }
+            raw[j++] = r;
+            raw[j++] = g;
+            raw[j++] = b;
+            if (channels === 4) {
+                raw[j++] = a;
+            }
+        }
+    }
+    if (!fast) {
+        filterRows(raw, stride, height, channels);
+    }
+    const data = zlibCompress(raw, fast ? 1 : 6);
+    const out = new Uint8Array(8 + 25 + 12 + data.length + 12);
+    const view = new DataView(out.buffer);
+    out.set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    let at = 8;
+    const chunk = (type, length, write) => {
+        view.setUint32(at, length);
+        for (let k = 0; k < 4; k++) {
+            out[at + 4 + k] = type.charCodeAt(k);
+        }
+        write(at + 8);
+        view.setUint32(at + 8 + length, crc32(out, at + 4, at + 8 + length));
+        at += 12 + length;
+    };
+    chunk("IHDR", 13, (p) => {
+        view.setUint32(p, width);
+        view.setUint32(p + 4, height);
+        // 8 bits a channel, RGBA (6) or RGB (2), deflate, adaptive filtering, no interlace.
+        out.set([8, channels === 4 ? 6 : 2, 0, 0, 0], p + 8);
+    });
+    chunk("IDAT", data.length, (p) => out.set(data, p));
+    chunk("IEND", 0, () => { });
+    return out;
+}
+/**
+ * Each row, its filter byte 0 as written, given the filter of the five
+ * whose output's bytes, taken as signed, sum smallest; rows are filtered
+ * bottom up, so each still sees the unfiltered row above it.
+ */
+function filterRows(raw, stride, height, bpp) {
+    const length = stride - 1;
+    const candidates = Array.from({ length: 5 }, () => new Uint8Array(length));
+    for (let y = height - 1; y >= 0; y--) {
+        const row = y * stride + 1;
+        const up = y > 0 ? row - stride : -1;
+        let best = 0;
+        let bestSum = Number.POSITIVE_INFINITY;
+        for (let f = 0; f < 5; f++) {
+            const out = candidates[f];
+            let sum = 0;
+            for (let i = 0; i < length; i++) {
+                const x = raw[row + i];
+                const a = i >= bpp ? raw[row + i - bpp] : 0;
+                const b = up >= 0 ? raw[up + i] : 0;
+                const c = up >= 0 && i >= bpp ? raw[up + i - bpp] : 0;
+                let v;
+                switch (f) {
+                    case 0:
+                        v = x;
+                        break;
+                    case 1:
+                        v = x - a;
+                        break;
+                    case 2:
+                        v = x - b;
+                        break;
+                    case 3:
+                        v = x - ((a + b) >> 1);
+                        break;
+                    default: {
+                        const p = a + b - c;
+                        const pa = Math.abs(p - a);
+                        const pb = Math.abs(p - b);
+                        const pc = Math.abs(p - c);
+                        v = x - (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+                    }
+                }
+                out[i] = v;
+                const s = out[i];
+                sum += s < 128 ? s : 256 - s;
+            }
+            if (sum < bestSum) {
+                bestSum = sum;
+                best = f;
+            }
+        }
+        raw[row - 1] = best;
+        raw.set(candidates[best], row);
+    }
+}

package/dist/thread/player/bitmap/turbulence.js

@@ -0,0 +1,89 @@
+// Perlin noise as BitmapData.perlinNoise makes it: the reference
+// implementation of SVG's feTurbulence, which Flash's matches, with an
+// offset for each octave, as Ruffle ports it (turbulence.rs).
+//
+// Derived from https://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement,
+// Copyright © 2015 W3C® (MIT, ERCIM, Keio, Beihang), under the W3C software
+// license.
+const RAND_M = 2147483647;
+const RAND_A = 16807;
+const RAND_Q = 127773;
+const RAND_R = 2836;
+const B_SIZE = 0x100;
+/** Park and Miller's minimal standard seed: in [1, 2^31 - 2]. */
+function setupSeed(seed) {
+    let s = seed;
+    if (s <= 0) {
+        s = -(s % (RAND_M - 1)) + 1;
+    }
+    if (s > RAND_M - 1) {
+        s = RAND_M - 1;
+    }
+    return s;
+}
+function random(seed) {
+    let result = RAND_A * (seed % RAND_Q) - RAND_R * Math.trunc(seed / RAND_Q);
+    if (result <= 0) {
+        result += RAND_M;
+    }
+    return result;
+}
+/**
+ * perlinNoise's set-up of `seed`: the lattice, and four channels'
+ * gradients, x and y interleaved, one after another; the frequencies,
+ * adjusted where stitching to tile a `width` by `height` image, and the
+ * tile in lattice cells at the first octave. The render module draws the
+ * noise of them (pixels.zig).
+ */
+export function perlinSetup(seed, base, stitching, width, height) {
+    const lattice = new Int32Array(B_SIZE + B_SIZE + 2);
+    const cells = (B_SIZE + B_SIZE + 2) * 2;
+    const gradients = new Float64Array(cells * 4);
+    let s = setupSeed(seed);
+    for (let c = 0; c < 4; c++) {
+        const g = gradients.subarray(c * cells, (c + 1) * cells);
+        for (let i = 0; i < B_SIZE; i++) {
+            lattice[i] = i;
+            for (let j = 0; j < 2; j++) {
+                s = random(s);
+                g[i * 2 + j] = ((s % (B_SIZE + B_SIZE)) - B_SIZE) / B_SIZE;
+            }
+            const length = Math.sqrt(g[i * 2] * g[i * 2] + g[i * 2 + 1] * g[i * 2 + 1]);
+            g[i * 2] /= length;
+            g[i * 2 + 1] /= length;
+        }
+    }
+    for (let i = B_SIZE - 1; i > 0; i--) {
+        const k = lattice[i];
+        s = random(s);
+        const j = s % B_SIZE;
+        lattice[i] = lattice[j];
+        lattice[j] = k;
+    }
+    for (let i = 0; i < B_SIZE + 2; i++) {
+        lattice[B_SIZE + i] = lattice[i];
+        for (let c = 0; c < 4; c++) {
+            gradients[c * cells + (B_SIZE + i) * 2] = gradients[c * cells + i * 2];
+            gradients[c * cells + (B_SIZE + i) * 2 + 1] = gradients[c * cells + i * 2 + 1];
+        }
+    }
+    let [fx, fy] = base;
+    let stitchWidth = 0;
+    let stitchHeight = 0;
+    if (stitching) {
+        if (fx !== 0) {
+            const lo = Math.floor(width * fx) / width;
+            const hi = Math.ceil(width * fx) / width;
+            fx = fx / lo < hi / fx ? lo : hi;
+        }
+        // Not the reference's slip, which Ruffle keeps, the y frequency's floor from the x one (adl).
+        if (fy !== 0) {
+            const lo = Math.floor(height * fy) / height;
+            const hi = Math.ceil(height * fy) / height;
+            fy = fy / lo < hi / fy ? lo : hi;
+        }
+        stitchWidth = Math.trunc(width * fx + 0.5);
+        stitchHeight = Math.trunc(height * fy + 0.5);
+    }
+    return { lattice, gradients, fx, fy, stitch: stitching, stitchWidth, stitchHeight };
+}

package/dist/thread/player/clock.js

@@ -0,0 +1,182 @@
+// A script's clock that skips a spin on getTimer: a loop that only reads
+// the clock until it reaches a time, as a game that caps its frame rate
+// waits for the next frame. In Flash the wait costs nothing visible; in a
+// browser it holds the main thread. Once a spin is told from other reads,
+// each read moves the clock a small step on instead, so the wait ends at
+// once, and the clock holds at the time it waited for until the real one
+// passes it, the next frame with it (Player.advance). AS3's getTimer
+// (scripting/timers.ts) and AVM1's (avm1/timers.ts) share one of these
+// each, so both clocks skip alike.
+/**
+ * The clock of one movie's scripts on a real clock: what getTimer tells,
+ * unrounded, and how far ahead of the real clock a spin has moved it.
+ */
+export class SpinClock {
+    elapsed;
+    /**
+     * How far a spin on getTimer in the running pass has moved the clock
+     * ahead of the real one, in ms; once the pass is over, `floor` holds it.
+     */
+    skip = 0;
+    /** The least time the clock tells: where the last pass that skipped left it, until the real clock passes it. */
+    floor = Number.NEGATIVE_INFINITY;
+    /** The time getTimer last told, unrounded: a spin's steps go on from it. */
+    told = Number.NEGATIVE_INFINITY;
+    /** The spin's detection: the real time of the last call to getTimer, and of the run of calls. */
+    lastCall = Number.NEGATIVE_INFINITY;
+    windowStart = Number.NaN;
+    windowCalls = 0;
+    denseSince = Number.NaN;
+    /** Set while the running pass's calls to getTimer are a spin, each moving the clock a step. */
+    spinning = false;
+    /** Set once the running pass's dense calls came from more than one place: no spin in it. */
+    refused = false;
+    /** A call site being checked over the next calls, and how many are still to be checked. */
+    checking = "";
+    checks = 0;
+    /** Where the last spin called getTimer from: the same loop next time is known at once. */
+    site = null;
+    /** `elapsed`: the real clock's ms since the start, unrounded, never going back. */
+    constructor(elapsed) {
+        this.elapsed = elapsed;
+    }
+    /**
+     * What getTimer tells, unrounded: the real time, or past it by what a
+     * spin has skipped. Each call counts towards telling a spin.
+     */
+    read() {
+        const real = this.elapsed();
+        let time = Math.max(real + this.skip, this.floor);
+        if (real - this.lastCall > SPIN_GAP) {
+            // A pause between calls: whatever ran was no spin, or the spin is over.
+            this.spinning = false;
+            this.checks = 0;
+            this.windowStart = real;
+            this.windowCalls = 0;
+            this.denseSince = Number.NaN;
+        }
+        this.lastCall = real;
+        if (this.spinning || this.spins(real)) {
+            // Each call a small step on from the last, so the wait ends within a
+            // step of its time, and the time read just after it is the same ms.
+            const next = Math.max(time, this.told + SPIN_STEP);
+            if (next - real <= MAX_SKIP) {
+                this.skip = next - real;
+                time = next;
+            }
+            else {
+                // Waiting longer than any frame limiter: it spins in real time, as it did.
+                this.spinning = false;
+                this.refused = true;
+            }
+        }
+        this.told = time;
+        return time;
+    }
+    /**
+     * Whether the calls to getTimer up to this one make a spin, a loop that
+     * does nothing but read the clock until it reaches a time: at least
+     * SPIN_DENSITY calls a ms, for SPIN_MS on end, all from one place in the
+     * script. Code that times itself, or does work between its reads, calls
+     * it far less often; a profiler's begin and end are two places. A place
+     * that spun before is known after one dense window.
+     */
+    spins(real) {
+        if (this.refused) {
+            return false;
+        }
+        if (this.checks === 0) {
+            this.windowCalls++;
+            if (this.windowCalls < SPIN_WINDOW) {
+                return false;
+            }
+            const dense = real - this.windowStart <= SPIN_WINDOW / SPIN_DENSITY;
+            if (dense && Number.isNaN(this.denseSince)) {
+                this.denseSince = this.windowStart;
+            }
+            else if (!dense) {
+                this.denseSince = Number.NaN;
+            }
+            this.windowStart = real;
+            this.windowCalls = 0;
+            if (!dense) {
+                return false;
+            }
+        }
+        // Read on this one line alone: the stacks differ by where they were read.
+        const site = callSite();
+        if (this.checks > 0) {
+            this.checks--;
+            if (site !== this.checking) {
+                this.refused = true;
+                this.checks = 0;
+                return false;
+            }
+            if (this.checks > 0) {
+                return false;
+            }
+            this.site = site;
+        }
+        else if (site !== this.site) {
+            if (real - this.denseSince >= SPIN_MS) {
+                this.checking = site;
+                this.checks = SPIN_CHECKS;
+            }
+            return false;
+        }
+        this.spinning = true;
+        return true;
+    }
+    /**
+     * A pass is over: a spin's skip becomes the floor the clock holds at
+     * until the real clock passes it, and the next pass's calls start anew.
+     */
+    settle() {
+        if (this.skip > 0) {
+            this.floor = Math.max(this.floor, this.elapsed() + this.skip);
+            this.skip = 0;
+        }
+        this.spinning = false;
+        this.refused = false;
+        this.checks = 0;
+        this.lastCall = Number.NEGATIVE_INFINITY;
+    }
+    /**
+     * 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() {
+        this.settle();
+        return Math.max(0, this.floor - this.elapsed());
+    }
+    /** What the clock tells beyond the real clock at `real`: the timers' time keeps to getTimer's. */
+    lead(real) {
+        return Math.max(real + this.skip, this.floor) - real;
+    }
+}
+/** Calls to getTimer a spin's dense windows are counted in. */
+const SPIN_WINDOW = 1024;
+/**
+ * Calls a ms that a window must reach to be dense: a loop that only reads
+ * the clock makes 5,000 to 10,000 in Chrome, one with a microsecond's
+ * work between its reads at most 1,000.
+ */
+const SPIN_DENSITY = 1000;
+/** Real ms of dense calls before a place not seen spinning before counts as a spin. */
+const SPIN_MS = 2;
+/** Consecutive calls whose place is checked to be the first's. */
+const SPIN_CHECKS = 3;
+/** Real ms between two calls that end a spin or a run of dense calls. */
+const SPIN_GAP = 1;
+/** How far each call in a spin moves the clock on, in ms: a wait overshoots its time by about that. */
+const SPIN_STEP = 1 / 8;
+/** The most a pass's spin moves the clock ahead of the real one, in ms. */
+const MAX_SKIP = 1000;
+/**
+ * Where getTimer was called from, the script's frames included, AS3's or
+ * AVM1's: the same loop's calls give the same, whatever depth they are at.
+ */
+function callSite() {
+    return new Error().stack ?? "";
+}

package/dist/thread/player/display/bitmapobject.js

@@ -0,0 +1,25 @@
+import { CONTENT, DisplayObject } from "./displayobject.js";
+/** A Bitmap: a display object that shows a BitmapData's pixels, its bounds the data's size. */
+export class BitmapObject extends DisplayObject {
+    shown = null;
+    smoothing = false;
+    pixelSnapping = "auto";
+    /** The SWF's bitmap it shows a copy of, placed by a timeline or made by its class; null for one a script made. */
+    character = null;
+    /** PlaceObject3's HasImage where a timeline placed it: Flash then takes a bound class for its data's. */
+    hasImage = false;
+    constructor(store) {
+        super();
+        this.store = store;
+    }
+    /** The store shown; the object watches it, so a pixel set marks the object for the renderer. */
+    get store() {
+        return this.shown;
+    }
+    set store(store) {
+        this.shown?.views.delete(this.ref);
+        this.shown = store;
+        store?.views.add(this.ref);
+        this.invalidate(CONTENT);
+    }
+}