@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,471 @@
+// A SWF's characters, and its timelines as frames of display commands:
+// what the root and each sprite place, move and remove on each frame, and
+// the frames' labels. Definitions are read once, at load, as the whole
+// file is there.
+import { isAs3, isBitmapTag, readActions, readBinaryData, readBitmap, readButton, readButtonSound, readCsmTextSettings, readEditText, readFont, readFont4, readFontAlignZones, readFontInfo, readFrameLabel, readMorphShape, readPlace, readRemove, readScalingGrid, readSceneData, readShape, readSound, readSoundStreamBlock, readSoundStreamHead, readSprite, readStartSound, readStaticText, tags, } from "../../format/index.js";
+import { FontSet } from "../text/fonts.js";
+import { boundsOf, shapeLayers } from "./shapes.js";
+/** What Flash makes of a bitmap it cannot read. */
+export const INVALID_PIXELS = {
+    width: 0,
+    height: 0,
+    transparent: false,
+    pixels: new Uint32Array(0),
+};
+/**
+ * Shapes by their tag's bytes, shared by every SWF that defines one alike:
+ * a SWF loaded again, as each of a crowd of one creature may be, draws
+ * with the first's fills and lines, which the renderer keeps by shape,
+ * rather than building and holding its own. A shape filled with a bitmap
+ * keeps to its SWF, whose bitmap it is. Held weakly: one no library holds
+ * goes, and its entry after it.
+ */
+const sharedShapes = new Map();
+const sharedGone = new FinalizationRegistry(({ hash, tag }) => {
+    const list = sharedShapes.get(hash)?.filter((entry) => entry.tag !== tag) ?? [];
+    if (list.length > 0) {
+        sharedShapes.set(hash, list);
+    }
+    else {
+        sharedShapes.delete(hash);
+    }
+});
+/**
+ * Bitmaps by their tag's bytes, as shapes are: a SWF loaded again reads
+ * the first's pixels rather than inflating its own and keeping them, its
+ * images decode once (images.ts), and its fills draw from one store and
+ * one texture of them (characterStore), as an animation a crowd of loads
+ * plays holds a copy of each frame's bitmap, not one a load. DefineBits
+ * keeps to its SWF, as it is read with that SWF's JPEGTables.
+ */
+const sharedBitmaps = new Map();
+const bitmapsGone = new FinalizationRegistry(({ hash, tag }) => {
+    const list = sharedBitmaps.get(hash)?.filter((entry) => entry.tag !== tag) ?? [];
+    if (list.length > 0) {
+        sharedBitmaps.set(hash, list);
+    }
+    else {
+        sharedBitmaps.delete(hash);
+    }
+});
+/**
+ * The largest bitmap tag shared, in bytes: each entry keeps a copy of its
+ * tag to tell it from another of the same hash, and hashes it at each read,
+ * which pays for a crowd of small ones, not for one large atlas.
+ */
+const SHARED_BITMAP_MOST = 1 << 20;
+/** The bitmap tag `t` defines, the one a SWF read before defined alike where there is one. */
+function sharedBitmap(bytes, t, tables) {
+    // A short header is a bitmap Flash refuses: read as invalid, never shared with a long one.
+    if (t.code === tags.DefineBits || !t.long || t.length > SHARED_BITMAP_MOST) {
+        return readBitmap(bytes, t, tables);
+    }
+    const tag = bytes.subarray(t.offset, t.offset + t.length);
+    const hash = sampledHash(t.code, tag);
+    for (const entry of sharedBitmaps.get(hash) ?? []) {
+        const definition = entry.definition.deref();
+        if (definition && sameBytes(entry.tag, tag)) {
+            return definition;
+        }
+    }
+    const definition = readBitmap(bytes, t, tables);
+    // An image's definition holds its bytes in the SWF's already; a lossless one only its pixels.
+    const own = definition.type === "image" ? tag : tag.slice();
+    const list = sharedBitmaps.get(hash) ?? [];
+    list.push({ tag: own, definition: new WeakRef(definition) });
+    sharedBitmaps.set(hash, list);
+    bitmapsGone.register(definition, { hash, tag: own });
+    return definition;
+}
+/**
+ * FNV-1a over the tag's code, its length and up to 256 of its bytes, evenly
+ * apart: a match is told by comparing the bytes, so the hash need only
+ * spread the tags, and a large one costs no pass of its own.
+ */
+function sampledHash(code, tag) {
+    let hash = Math.imul(0x811c9dc5 ^ code, 0x01000193);
+    hash = Math.imul(hash ^ tag.length, 0x01000193);
+    const step = Math.max(1, Math.floor(tag.length / 256));
+    for (let i = 0; i < tag.length; i += step) {
+        hash = Math.imul(hash ^ tag[i], 0x01000193);
+    }
+    return hash >>> 0;
+}
+/** FNV-1a over the tag's code and bytes. */
+function tagHash(code, tag) {
+    let hash = Math.imul(0x811c9dc5 ^ code, 0x01000193);
+    for (let i = 0; i < tag.length; i++) {
+        hash = Math.imul(hash ^ tag[i], 0x01000193);
+    }
+    return hash >>> 0;
+}
+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;
+}
+/** The shape a DefineShape tag defines, as another SWF defined it alike if one did. */
+function shapeOf(bytes, t, bitmap, version) {
+    const tag = bytes.subarray(t.offset, t.offset + t.length);
+    const hash = tagHash(t.code, tag);
+    for (const entry of sharedShapes.get(hash) ?? []) {
+        const shared = entry.shape.deref();
+        if (shared && sameBytes(entry.tag, tag)) {
+            return shared;
+        }
+    }
+    const shape = readShape(bytes, t.code, t.offset, t.length, version);
+    // Its bitmap fills' bitmaps as the SWF has them now, which defines them before the shapes that
+    // use them; a shape with any is the SWF's own, not shared.
+    // The parse is not kept: no function made here refers to it, so its records go.
+    const bitmaps = new Map();
+    const styles = [shape.fills];
+    for (const r of shape.records) {
+        if (r.type === "style" && r.styles) {
+            styles.push(r.styles.fills);
+        }
+    }
+    for (const fills of styles) {
+        for (const fill of fills) {
+            if (fill.type === "bitmap" && !bitmaps.has(fill.bitmap)) {
+                bitmaps.set(fill.bitmap, bitmap(fill.bitmap));
+            }
+        }
+    }
+    let layers = null;
+    const character = {
+        type: "shape",
+        id: shape.id,
+        shape: boundsOf(shape),
+        // Drawn into layers when first asked for, from the tag: most of the shapes a large
+        // application's SWFs define are never shown, and their layers were most of its memory.
+        get layers() {
+            layers ??= shapeLayers(readShape(bytes, t.code, t.offset, t.length, version), (id) => bitmaps.get(id) ?? null);
+            return layers;
+        },
+    };
+    if (bitmaps.size === 0) {
+        const own = tag.slice();
+        const list = sharedShapes.get(hash) ?? [];
+        list.push({ tag: own, shape: new WeakRef(character) });
+        sharedShapes.set(hash, list);
+        sharedGone.register(character, { hash, tag: own });
+    }
+    return character;
+}
+function timelineOf(bytes, list, frameCount, library, jpeg, actions, 
+// The SWF's version, which its shapes' bitmap fills are read by.
+version) {
+    const avm1 = actions !== null;
+    const frames = [[]];
+    const tagged = [];
+    const frameLabels = new Map();
+    const sounds = new Map();
+    let head = null;
+    const blocks = [];
+    const byFrame = new Map();
+    let scenes = null;
+    for (const t of list) {
+        const frame = frames[frames.length - 1];
+        switch (t.code) {
+            case tags.ShowFrame:
+                frames.push([]);
+                break;
+            case tags.PlaceObject:
+            case tags.PlaceObject2:
+            case tags.PlaceObject3:
+            case tags.PlaceObject4:
+                frame.push({ type: "place", place: readPlace(bytes, t, actions ?? undefined) });
+                break;
+            case tags.RemoveObject:
+            case tags.RemoveObject2:
+                frame.push({ type: "remove", depth: readRemove(bytes, t) });
+                break;
+            case tags.DoAction:
+                if (avm1 && t.length > 0) {
+                    frame.push({ type: "actions", tag: t.offset });
+                }
+                break;
+            case tags.FrameLabel: {
+                const name = readFrameLabel(bytes, t);
+                tagged.push({ name, frame: frames.length });
+                // A frame may have aliases: gotos find every name, currentFrameLabel the first.
+                if (!frameLabels.has(frames.length)) {
+                    frameLabels.set(frames.length, name);
+                }
+                break;
+            }
+            case tags.StartSound:
+            case tags.StartSound2: {
+                const list = sounds.get(frames.length) ?? [];
+                list.push(readStartSound(bytes, t));
+                sounds.set(frames.length, list);
+                break;
+            }
+            case tags.SoundStreamHead:
+            case tags.SoundStreamHead2:
+                head ??= readSoundStreamHead(bytes, t);
+                break;
+            case tags.SoundStreamBlock:
+                // A block before the head, or a second on a frame, has no place in the stream.
+                if (head && !byFrame.has(frames.length)) {
+                    byFrame.set(frames.length, blocks.length);
+                    blocks.push(readSoundStreamBlock(bytes, t, head.format));
+                }
+                break;
+            case tags.DefineSceneAndFrameLabelData:
+                scenes = readSceneData(bytes, t);
+                break;
+            case tags.DefineShape:
+            case tags.DefineShape2:
+            case tags.DefineShape3:
+            case tags.DefineShape4: {
+                // Its bitmap fills' bitmaps, which a SWF defines before the shapes that use them.
+                const bitmap = (id) => {
+                    const c = library.get(id);
+                    return c?.type === "bitmap" ? c : null;
+                };
+                const shape = shapeOf(bytes, t, bitmap, version);
+                library.set(shape.id, shape);
+                break;
+            }
+            case tags.DefineMorphShape:
+            case tags.DefineMorphShape2: {
+                const morph = readMorphShape(bytes, t.code, t.offset, t.length, version);
+                library.set(morph.id, {
+                    type: "morph",
+                    id: morph.id,
+                    morph,
+                    blends: new Map(),
+                    bitmap: (id) => {
+                        const c = library.get(id);
+                        return c?.type === "bitmap" ? c : null;
+                    },
+                });
+                break;
+            }
+            case tags.DefineSprite: {
+                const sprite = readSprite(bytes, t);
+                library.set(sprite.id, {
+                    type: "sprite",
+                    id: sprite.id,
+                    timeline: {
+                        ...timelineOf(bytes, sprite.tags, sprite.frameCount, library, jpeg, actions, version),
+                        length: t.length - 4,
+                    },
+                    grid: null,
+                });
+                break;
+            }
+            case tags.DefineButton:
+            case tags.DefineButton2: {
+                const button = readButton(bytes, t);
+                library.set(button.id, {
+                    type: "button",
+                    id: button.id,
+                    records: button.records,
+                    trackAsMenu: button.trackAsMenu,
+                    sounds: null,
+                    grid: null,
+                });
+                break;
+            }
+            case tags.DefineButtonSound: {
+                const given = readButtonSound(bytes, t);
+                const button = library.get(given.id);
+                if (button?.type === "button") {
+                    button.sounds = given.sounds;
+                }
+                break;
+            }
+            case tags.DefineScalingGrid: {
+                const { id, grid } = readScalingGrid(bytes, t);
+                const symbol = library.get(id);
+                if (symbol?.type === "sprite" || symbol?.type === "button") {
+                    symbol.grid = {
+                        xMin: grid.xMin / 20,
+                        yMin: grid.yMin / 20,
+                        xMax: grid.xMax / 20,
+                        yMax: grid.yMax / 20,
+                    };
+                }
+                break;
+            }
+            case tags.DefineFont:
+            case tags.DefineFont2:
+            case tags.DefineFont3: {
+                const font = readFont(bytes, t);
+                library.set(font.id, {
+                    type: "font",
+                    id: font.id,
+                    name: font.name,
+                    bold: font.bold,
+                    italic: font.italic,
+                    font,
+                });
+                break;
+            }
+            case tags.DefineFontInfo:
+            case tags.DefineFontInfo2: {
+                const info = readFontInfo(bytes, t);
+                const font = library.get(info.id);
+                if (font?.type === "font") {
+                    font.name = font.font.name = info.name;
+                    font.bold = font.font.bold = info.bold;
+                    font.italic = font.font.italic = info.italic;
+                    for (let i = 0; i < Math.min(info.codes.length, font.font.glyphs.length); i++) {
+                        font.font.glyphs[i].code = info.codes[i];
+                    }
+                }
+                break;
+            }
+            case tags.DefineFontAlignZones: {
+                const { id, csmHint } = readFontAlignZones(bytes, t);
+                const font = library.get(id);
+                if (font?.type === "font") {
+                    font.font.csmHint = csmHint;
+                }
+                break;
+            }
+            case tags.CSMTextSettings: {
+                const csm = readCsmTextSettings(bytes, t);
+                const text = library.get(csm.id);
+                if (text?.type === "static" || text?.type === "text") {
+                    text.csm = csm;
+                }
+                break;
+            }
+            case tags.DefineFont4: {
+                const font = readFont4(bytes, t);
+                library.set(font.id, {
+                    type: "fontCff",
+                    id: font.id,
+                    name: font.name,
+                    bold: font.bold,
+                    italic: font.italic,
+                    font,
+                });
+                break;
+            }
+            case tags.DefineText:
+            case tags.DefineText2: {
+                const definition = readStaticText(bytes, t);
+                library.set(definition.id, { type: "static", id: definition.id, definition });
+                break;
+            }
+            case tags.DefineEditText: {
+                const definition = readEditText(bytes, t);
+                const font = definition.fontId === null ? null : library.get(definition.fontId);
+                library.set(definition.id, {
+                    type: "text",
+                    id: definition.id,
+                    definition,
+                    font: font?.type === "font" ? font : null,
+                });
+                break;
+            }
+            case tags.DefineBinaryData: {
+                const { id, data } = readBinaryData(bytes, t);
+                library.set(id, { type: "binary", id, data });
+                break;
+            }
+            case tags.DefineSound: {
+                const definition = readSound(bytes, t);
+                library.set(definition.id, { type: "sound", id: definition.id, definition });
+                break;
+            }
+            case tags.JPEGTables:
+                jpeg.tables = bytes.slice(t.offset, t.offset + t.length);
+                break;
+            default:
+                if (isBitmapTag(t.code)) {
+                    const definition = sharedBitmap(bytes, t, jpeg.tables);
+                    library.set(definition.id, {
+                        type: "bitmap",
+                        id: definition.id,
+                        definition,
+                        pixels: definition.type === "pixels"
+                            ? definition
+                            : definition.type === "invalid"
+                                ? INVALID_PIXELS
+                                : null,
+                    });
+                }
+        }
+    }
+    // An AVM1 timeline has as many frames as its ShowFrame tags end, whatever
+    // its header says, as Flash plays and loops one (the corpus's
+    // looping_real_*): what follows the last places nothing, and its actions
+    // run with the last frame where the timeline loops, and once after it, as
+    // the clip stops there, where it does not (`tail`): a timeline of one
+    // frame, or without an End tag (adl, and the corpus's `looping_child_*`).
+    // An AS3 one has as many as its header says.
+    const loops = !avm1 || list.at(-1)?.code === tags.End;
+    let tail = [];
+    if (avm1) {
+        tail = frames.length > 1 ? frames[frames.length - 1].filter((c) => c.type === "actions") : [];
+        frames.length = Math.max(1, frames.length - 1);
+        if (loops && frames.length > 1) {
+            frames[frames.length - 1].push(...tail);
+            tail = [];
+        }
+    }
+    else {
+        frames.length = Math.max(1, Math.min(frames.length, frameCount || 1));
+        while (frames.length < (frameCount || 1)) {
+            frames.push([]);
+        }
+    }
+    // Scene data counts frames from 0; a frame name from 1, as scripts do.
+    const named = (list) => list.map(({ frame, name }) => ({ name, frame: frame + 1 }));
+    // Scene data that names no scene is none, as Flash reads it; its first
+    // scene starts the timeline whatever frame it gives.
+    const data = scenes?.scenes.length ? scenes : null;
+    const labels = data ? named(data.labels).sort((a, b) => a.frame - b.frame) : tagged;
+    const sceneList = data ? named(data.scenes) : [{ name: "", frame: 1 }];
+    sceneList[0].frame = 1;
+    return {
+        frames,
+        labels,
+        gotoLabels: labels.length > 0 ? labels : tagged,
+        frameLabels,
+        scenes: sceneList,
+        sounds,
+        stream: head && blocks.length > 0 ? { head, blocks, byFrame } : null,
+        loops,
+        tail,
+    };
+}
+/** The characters a SWF defines, and its root timeline. */
+export function readLibrary(swf) {
+    const characters = new Map();
+    // An AVM1 SWF's action blocks, which its places' clip actions are among.
+    const actions = isAs3(swf) ? null : readActions(swf);
+    const root = timelineOf(swf.bytes, swf.tags, swf.frameCount, characters, { tables: null }, actions, swf.header.version);
+    const fonts = new FontSet();
+    for (const c of characters.values()) {
+        if (c.type === "font") {
+            fonts.add(c.font);
+        }
+    }
+    return {
+        characters,
+        root,
+        classes: new Map(),
+        construct: null,
+        constructLater: null,
+        constructPlaced: null,
+        uncaught: null,
+        removing: null,
+        fonts,
+        version: swf.header.version,
+        sounds: null,
+        actions,
+    };
+}

package/dist/thread/player/display/value-lists.js

@@ -0,0 +1,40 @@
+// Caches kept as short lists of entries found by their values, the latest
+// used last, rather than in maps by keys formatted from those values on
+// every frame: the renderer's lines, gradients and device runs, and the
+// slices of a set of layers. Each finds its entry in a loop of its own,
+// comparing its fields with `same`, and keeps its list with these.
+/** Whether two numbers are the same as a cache's key: NaN the same as NaN, as "NaN" was. */
+export function same(x, y) {
+    return x === y || (Number.isNaN(x) && Number.isNaN(y));
+}
+/** Entry `i` of `list` moved to its end, as the latest used: the entry. */
+export function moveLast(list, i) {
+    const entry = list[i];
+    for (let k = i; k < list.length - 1; k++) {
+        list[k] = list[k + 1];
+    }
+    list[list.length - 1] = entry;
+    return entry;
+}
+/**
+ * Room made in `list` for one more, where it holds `most` already: those
+ * `gone` dropped in place, then the least lately used, each `let go`.
+ */
+export function makeRoom(list, most, gone, letGo) {
+    if (list.length < most) {
+        return;
+    }
+    let kept = 0;
+    for (const entry of list) {
+        if (gone(entry)) {
+            letGo(entry);
+        }
+        else {
+            list[kept++] = entry;
+        }
+    }
+    list.length = kept;
+    while (list.length >= most) {
+        letGo(list.shift());
+    }
+}

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

@@ -0,0 +1,6 @@
+import { DisplayObject } from "./displayobject.js";
+/** A Video: a box of the size it was made at, its bounds; the player plays no video in it, so it draws nothing. */
+export class VideoObject extends DisplayObject {
+    boxWidth = 320;
+    boxHeight = 240;
+}

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

@@ -0,0 +1,127 @@
+import { BUTTON, CLIP, OTHER } from "./displayobject.js";
+/** The shortest list a container keeps for itself; a shorter one its parent's making walks again. */
+const KEPT_WALK = 32;
+/**
+ * Those the frame's walks visit at and under `root`, as WalkList lays them
+ * out: kept on each container till a clip or a container comes or goes
+ * under it (Container.relist), so that a frame visits the clips alone,
+ * where its walks visited every object with children, twice or more.
+ * Made again in the arrays it had, as a busy movie's are made again every
+ * frame, some ten thousand objects long.
+ */
+export function walkList(root) {
+    let list = root.walk;
+    if (list?.current) {
+        return list;
+    }
+    list ??= { items: [], ends: [], current: false };
+    const length = listInto(root, list, 0, false);
+    // Cut to length, which keeps the arrays' room unless far shorter: a length of 0 would not.
+    list.items.length = length;
+    list.ends.length = length;
+    list.current = true;
+    root.walk = list;
+    return list;
+}
+/**
+ * `c` and those under it written to `list` from index `at`, each
+ * container's kept list copied where it has one; `c`'s own kept too where
+ * `keep`, and long enough. Returns the index after the last written.
+ */
+function listInto(c, list, at, keep = true) {
+    // AS3 sees a loaded AVM1 movie as one opaque object; its VM owns the frame walk.
+    if (c.avm1Root) {
+        return at;
+    }
+    const { items, ends } = list;
+    const start = at;
+    let n = at;
+    if (c.kind === CLIP) {
+        items[n] = c;
+        ends[n++] = 0;
+    }
+    const children = c.children;
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child.kind === BUTTON) {
+            items[n] = child;
+            ends[n] = n + 1;
+            n++;
+            continue;
+        }
+        if (child.kind === OTHER && child.frameChildren.length === 0) {
+            continue;
+        }
+        const kept = child.walk;
+        if (!kept?.current) {
+            n = listInto(child, list, n);
+            continue;
+        }
+        const base = n;
+        const keptItems = kept.items;
+        const keptEnds = kept.ends;
+        for (let k = 0; k < keptItems.length; k++) {
+            items[n] = keptItems[k];
+            ends[n++] = keptEnds[k] + base;
+        }
+    }
+    if (c.kind === CLIP) {
+        ends[start] = n;
+    }
+    // Long enough, kept for the next list made above it, which then copies it.
+    const length = n - start;
+    if (keep && length >= KEPT_WALK) {
+        let own = c.walk;
+        if (!own) {
+            own = { items: [], ends: [], current: false };
+            c.walk = own;
+        }
+        const ownItems = own.items;
+        const ownEnds = own.ends;
+        for (let k = 0; k < length; k++) {
+            ownItems[k] = items[start + k];
+            ownEnds[k] = ends[start + k] - start;
+        }
+        ownItems.length = length;
+        ownEnds.length = length;
+        own.current = true;
+    }
+    return n;
+}
+/**
+ * The display objects whose frame scripts a display object's run: those
+ * whose frames its frames run, but a button's first, in a SWF after 9, up,
+ * over, down, then hit test, as Flash runs them while the button is made.
+ */
+export function scriptChildren(d) {
+    if (d.kind === BUTTON && d.firstScripts) {
+        const b = d;
+        b.firstScripts = false;
+        return [b.upState, b.overState, b.downState, b.hitTestState].filter((o, i, all) => o !== null && all.indexOf(o) === i && !o.encloses(b));
+    }
+    return d.kind === BUTTON ? d.playingStates() : d.frameChildren;
+}
+/**
+ * A walk of a container's children in render order, for the timeline
+ * masks that clip each: a mask clips the children after it until one
+ * placed deeper than its clip depth; one a script put among them has no
+ * depth and ends nothing. A class, not a generator: the renderer walks
+ * every child each time a container's children change.
+ */
+export class Clips {
+    /** The masks open, outermost first. */
+    masks = [];
+    /** The next child: how many of `masks`, from the first, clip it; it clips those after it, if a mask. */
+    enter(child) {
+        const depth = child.depth;
+        const masks = this.masks;
+        while (depth !== null && masks.length > 0 && masks[masks.length - 1].clipDepth < depth) {
+            masks.pop();
+        }
+        const n = masks.length;
+        if (child.clipDepth > 0) {
+            masks.push(child);
+        }
+        return n;
+    }
+}