@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/media/mp3.js

@@ -0,0 +1,152 @@
+// What Flash reads of MP3 bytes before it decodes them: its frames, by
+// their headers, past ID3v2 tags and other bytes between them. Flash
+// counts a frame the bytes cut short in a sound's length but decodes only
+// whole frames, and decodes a Xing, Info or VBRI frame as a frame of
+// silence like any other (adl, the sound-extract case), where a browser's
+// decoder reads it to trim the encoder's delay and padding. A header is
+// trusted as the start of a run only with the next two frames' headers
+// where it says they are, as decoders find their way into a stream, so
+// that bytes that happen to look like one, in a tag or another format,
+// are passed over.
+/** Kilobits a second by bitrate index: MPEG-1 Layer III, then MPEG-2 and 2.5. */
+const BITRATES = [
+    [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320],
+    [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160],
+];
+/** Rates by index for MPEG-2.5, (reserved), MPEG-2 and MPEG-1, as the version bits number them. */
+const RATES = [[11025, 12000, 8000], [], [22050, 24000, 16000], [44100, 48000, 32000]];
+/** How many headers in a row, the first included, make a run. */
+const RUN = 3;
+function header(bytes, at) {
+    if (at + 4 > bytes.length || bytes[at] !== 0xff || (bytes[at + 1] & 0xe0) !== 0xe0) {
+        return null;
+    }
+    const version = (bytes[at + 1] >> 3) & 3;
+    const layer = (bytes[at + 1] >> 1) & 3;
+    const bitrate = bytes[at + 2] >> 4;
+    const rateIndex = (bytes[at + 2] >> 2) & 3;
+    if (version === 1 || layer !== 1 || bitrate === 0 || bitrate === 15 || rateIndex === 3) {
+        return null;
+    }
+    const mpeg1 = version === 3;
+    const rate = RATES[version][rateIndex];
+    const padding = (bytes[at + 2] >> 1) & 1;
+    const kbps = BITRATES[mpeg1 ? 0 : 1][bitrate];
+    return {
+        version,
+        rate,
+        channels: bytes[at + 3] >> 6 === 3 ? 1 : 2,
+        samples: mpeg1 ? 1152 : 576,
+        length: Math.floor(((mpeg1 ? 144 : 72) * kbps * 1000) / rate) + padding,
+        mpeg1,
+    };
+}
+/** A header of the stream's kind at `at`: its version, rate and channels those of `like`. */
+function frameAt(bytes, at, like) {
+    const h = header(bytes, at);
+    if (!h ||
+        (like && (h.version !== like.version || h.rate !== like.rate || h.channels !== like.channels))) {
+        return null;
+    }
+    return h;
+}
+/** A header at `at` the next frames' headers follow, as many as the bytes hold up to a run. */
+function runAt(bytes, at, like) {
+    const first = frameAt(bytes, at, like);
+    let next = first ? at + first.length : 0;
+    for (let k = 1; first && k < RUN && next + 4 <= bytes.length; k++) {
+        const h = frameAt(bytes, next, first);
+        if (!h) {
+            return null;
+        }
+        next += h.length;
+    }
+    return first;
+}
+/** The length of an ID3v2 tag at `at`, header, body and footer, or 0 for none. */
+function id3Length(bytes, at) {
+    if (at + 10 > bytes.length ||
+        bytes[at] !== 0x49 ||
+        bytes[at + 1] !== 0x44 ||
+        bytes[at + 2] !== 0x33 ||
+        (bytes[at + 6] | bytes[at + 7] | bytes[at + 8] | bytes[at + 9]) & 0x80) {
+        return 0;
+    }
+    // Its size in seven-bit bytes.
+    const size = (bytes[at + 6] << 21) | (bytes[at + 7] << 14) | (bytes[at + 8] << 7) | bytes[at + 9];
+    return 10 + size + (bytes[at + 5] & 0x10 ? 10 : 0);
+}
+/** The next run of frames from `at`, past tags and anything else, and where it starts; null for none. */
+function nextRun(bytes, at, like) {
+    for (let p = at; p + 4 <= bytes.length;) {
+        const tag = id3Length(bytes, p);
+        if (tag) {
+            p += tag;
+            continue;
+        }
+        const h = runAt(bytes, p, like);
+        if (h) {
+            return [p, h];
+        }
+        p++;
+    }
+    return null;
+}
+/**
+ * The frames of MP3 bytes, or null for bytes with none. Given what it read
+ * of the bytes before more came after them, it reads on from there.
+ */
+export function mp3Frames(bytes, before = null) {
+    const like = before?.whole.length ? header(bytes, before.whole[0]) : null;
+    if (!like) {
+        const run = nextRun(bytes, 0, null);
+        return run ? readFrames(bytes, run[0], run[1], []) : null;
+    }
+    return readFrames(bytes, before?.end ?? 0, like, before?.whole ?? []);
+}
+function readFrames(bytes, from, like, before) {
+    const whole = before.slice();
+    let frames = whole.length / 2;
+    let at = from;
+    let end = from;
+    while (at + 4 <= bytes.length) {
+        let h = frameAt(bytes, at, like);
+        if (!h) {
+            const run = nextRun(bytes, at, like);
+            if (!run) {
+                break;
+            }
+            [at, h] = run;
+        }
+        frames++;
+        if (at + h.length > bytes.length) {
+            break;
+        }
+        whole.push(at, at + h.length);
+        at += h.length;
+        end = at;
+    }
+    return {
+        rate: like.rate,
+        channels: like.channels,
+        samplesPerFrame: like.samples,
+        frames,
+        whole,
+        end,
+    };
+}
+/** Whether the frame at `at` is a Xing, Info or VBRI header rather than sound. */
+function isHeaderFrame(bytes, at, h) {
+    const tag = (offset) => String.fromCharCode(...bytes.subarray(at + offset, at + offset + 4));
+    const side = h.mpeg1 ? (h.channels === 1 ? 17 : 32) : h.channels === 1 ? 9 : 17;
+    const xing = tag(4 + side);
+    return xing === "Xing" || xing === "Info" || tag(36) === "VBRI";
+}
+/** The first frame's gapless metadata, without scanning and retaining every frame of a long sound. */
+export function mp3HeaderFrame(bytes) {
+    const first = nextRun(bytes, 0, null);
+    if (!first || !isHeaderFrame(bytes, first[0], first[1])) {
+        return null;
+    }
+    return [first[0], Math.min(bytes.length, first[0] + first[1].length)];
+}

package/dist/thread/player/media/sounds.js

@@ -0,0 +1,507 @@
+import { dispatchEvent } from "../scripting/events.js";
+import { streamSound, } from "./audio.js";
+export const channels = new WeakMap();
+/** SoundMixer's transform, applied over every channel's own. */
+export const mixerMixes = new WeakMap();
+export const mixOf = (o) => ({
+    volume: o?.$soundVolume ?? 1,
+    leftToLeft: o?.$soundLeftToLeft ?? 1,
+    leftToRight: o?.$soundLeftToRight ?? 0,
+    rightToLeft: o?.$soundRightToLeft ?? 0,
+    rightToRight: o?.$soundRightToRight ?? 1,
+});
+/**
+ * What a channel sends to the device: its own transform and the mixer's,
+ * combined as Ruffle's SoundTransform::concat computes them. Only
+ * transforms that both cross channels depend on the order, which no trace
+ * can show; Ruffle's is kept.
+ */
+export function outputMix(local, global) {
+    return {
+        volume: Math.abs(local.volume * global.volume),
+        leftToLeft: local.leftToLeft * global.leftToLeft + local.rightToLeft * global.leftToRight,
+        leftToRight: local.leftToRight * global.leftToLeft + local.rightToRight * global.leftToRight,
+        rightToLeft: local.leftToLeft * global.rightToLeft + local.rightToLeft * global.rightToRight,
+        rightToRight: local.leftToRight * global.rightToLeft + local.rightToRight * global.rightToRight,
+    };
+}
+export const mixerMix = (s) => mixerMixes.get(s) ?? mixOf(null);
+const hosts = new WeakMap();
+/** An AS3 movie's SoundHost: its device, clock and symbols, its sprites' and SoundMixer's transforms. */
+export function soundHostOf(s) {
+    let host = hosts.get(s);
+    if (!host) {
+        host = {
+            get audio() {
+                return s.audio;
+            },
+            get now() {
+                return s.timers.now;
+            },
+            get frames() {
+                return s.frames;
+            },
+            get frameRate() {
+                return s.frameRate;
+            },
+            soundClip: (character) => s.symbols.soundClip(character),
+            ownMix: (o) => o.object?.$soundMix,
+            get mixer() {
+                return mixerMix(s);
+            },
+            scriptSounds() {
+                let n = 0;
+                for (const channel of channels.get(s) ?? []) {
+                    const state = channel.$channel;
+                    if (!state.stopped && (state.dynamic || state.sound.length > 0)) {
+                        n++;
+                    }
+                }
+                return n;
+            },
+        };
+        hosts.set(s, host);
+    }
+    return host;
+}
+export const positionOf = (s, state) => state.stopped
+    ? state.stoppedAt
+    : (state.dynamic?.position() ??
+        Math.min(state.sound.length, state.start + Math.max(0, s.timers.now - state.started)));
+export function stopChannel(s, state) {
+    state.stoppedAt = positionOf(s, state);
+    state.stopped = true;
+    state.playing?.stop();
+}
+/**
+ * SoundMixer.stopAll: every channel stays where it was, and none completes;
+ * the timeline's sounds stop too, though a stream starts again at the next
+ * block its clip plays on to, as Ruffle has it.
+ */
+export function stopAllSounds(s) {
+    const active = channels.get(s);
+    for (const channel of active ?? []) {
+        stopChannel(s, channel.$channel);
+    }
+    active?.clear();
+    stopTimelineSounds(soundHostOf(s));
+}
+/** Every sound the timeline, or AVM1's Sound, started stops, none completing. */
+export function stopTimelineSounds(h) {
+    for (const sound of [...(timelineSounds.get(h) ?? [])]) {
+        stopTimelineSound(h, sound);
+    }
+}
+const timelineSounds = new WeakMap();
+const streamSounds = new WeakMap();
+/** How long a sound over by the clock may still sound on the device before it is stopped. */
+const TAIL = 100;
+/**
+ * The sounds that may play at once, timeline and script alike: Flash's 32
+ * channels, Ruffle's AudioManager::MAX_SOUNDS. A timeline sound past them
+ * does not start, nor queue on a device that is not yet running.
+ */
+export const MAX_SOUNDS = 32;
+/** Whether the device has, or will have, a timeline sound playing. */
+function onDevice(sound) {
+    if (sound.stream) {
+        return sound.decoding || (!!sound.playing && sound.playing.ended !== true);
+    }
+    return (sound.endedAt === null || sound.decoding || (!!sound.playing && sound.playing.ended !== true));
+}
+/**
+ * The sounds that hold a channel: a script's whose sound is there to play
+ * (one still loading holds none until it can start), and the timeline's
+ * the device has or will have.
+ */
+export function liveSounds(s) {
+    return liveSoundsOf(soundHostOf(s));
+}
+function liveSoundsOf(h) {
+    let n = h.scriptSounds();
+    for (const sound of timelineSounds.get(h) ?? []) {
+        if (onDevice(sound)) {
+            n++;
+        }
+    }
+    return n;
+}
+/** SOUNDINFO's points and envelope are in samples at 44.1 kHz, whatever the sound's rate. */
+const ENVELOPE_RATE = 44.1;
+/**
+ * What a timeline sound sends to the device: the transforms of its owner
+ * and each ancestor, then the mixer's, concatenated as Ruffle's
+ * transform_for_sound does. A sprite's is its soundTransform; a button's
+ * is the mixer's, so it has none of its own.
+ */
+function timelineMix(h, owner) {
+    let mix = mixOf(null);
+    for (let o = owner; o; o = o.parent) {
+        const own = h.ownMix(o);
+        if (own) {
+            mix = outputMix(mix, own);
+        }
+    }
+    return outputMix(mix, h.mixer);
+}
+/** A sprite's transform or the mixer's changed: every timeline sound's mix follows. */
+export function updateTimelineMixes(s) {
+    updateMixes(soundHostOf(s));
+}
+export function updateMixes(h) {
+    for (const sound of timelineSounds.get(h) ?? []) {
+        sound.playing?.setMix(timelineMix(h, sound.owner));
+    }
+}
+export function stopTimelineSound(h, sound) {
+    sound.stoppedAt ??= h.now;
+    sound.stopped = true;
+    sound.playing?.stop();
+    timelineSounds.get(h)?.delete(sound);
+    if (sound.stream) {
+        streamSounds.get(h)?.delete(sound);
+    }
+    if (sound.clip?.stream === sound) {
+        sound.clip.stream = null;
+    }
+}
+function playTimelineSound(h, owner, character, clip, start, loops, shape, duration) {
+    const task = h.soundClip(character);
+    if (!task || liveSoundsOf(h) >= MAX_SOUNDS) {
+        return null;
+    }
+    const sound = {
+        owner,
+        character,
+        clip,
+        started: h.now,
+        duration,
+        playing: null,
+        stopped: false,
+        decoding: true,
+        endedAt: null,
+        onEnd: null,
+        stoppedAt: null,
+        stream: null,
+    };
+    let active = timelineSounds.get(h);
+    if (!active) {
+        active = new Set();
+        timelineSounds.set(h, active);
+    }
+    active.add(sound);
+    void task.then((decoded) => {
+        sound.decoding = false;
+        // A stream whose decode took frames starts as far in as the clock has
+        // run, to keep with its timeline; an event sound plays whole, late.
+        const late = Math.max(0, h.now - sound.started);
+        if (!sound.stopped && (!clip || late < sound.duration)) {
+            sound.playing = decoded.play(start, loops, timelineMix(h, owner), clip ? { ...shape, atMs: late } : shape);
+        }
+    }, () => {
+        sound.decoding = false;
+    });
+    return sound;
+}
+/**
+ * An event sound, as StartSound and a button start one: SyncStop stops
+ * every instance of the sound the timeline started, SyncNoMultiple starts
+ * none while one plays, and otherwise it plays from its in point to its
+ * out point, as many loops as it says, under its envelope. AS3's channels
+ * of the sound are left be: adl plays one on through a SyncStop of it.
+ */
+function startEventSound(h, owner, character, info) {
+    const active = timelineSounds.get(h);
+    if (info.stop) {
+        for (const sound of [...(active ?? [])]) {
+            if (sound.character === character) {
+                stopTimelineSound(h, sound);
+            }
+        }
+        return;
+    }
+    if (info.noMultiple &&
+        active &&
+        [...active].some((sound) => sound.character === character && sound.endedAt === null)) {
+        return;
+    }
+    const definition = character.definition;
+    const length = (definition.sampleCount * 1000) / definition.sampleRate;
+    const start = (info.inPoint ?? 0) / ENVELOPE_RATE;
+    const end = info.outPoint === null ? length : Math.min(length, info.outPoint / ENVELOPE_RATE);
+    const loops = Math.max(1, info.loops);
+    const shape = {};
+    if (info.outPoint !== null) {
+        shape.endMs = end;
+    }
+    if (info.envelope) {
+        shape.envelope = info.envelope.map((point) => ({
+            ms: point.sample / ENVELOPE_RATE,
+            left: point.left,
+            right: point.right,
+        }));
+    }
+    playTimelineSound(h, owner, character, null, start, loops, shape, Math.max(0, end - start) * loops);
+}
+/**
+ * AVM1's Sound.start: an event sound of `character` from `offset` ms, `loops`
+ * times, under `owner`'s transforms (none for the global Sound), whose end
+ * `onEnd` hears with the frame; null where it cannot play.
+ */
+export function startScriptSound(h, owner, character, offset, loops, onEnd) {
+    const definition = character.definition;
+    const length = (definition.sampleCount * 1000) / definition.sampleRate;
+    const start = Math.min(length, Math.max(0, offset));
+    const sound = playTimelineSound(h, owner, character, null, start, loops, {}, (length - start) * loops);
+    if (sound) {
+        sound.onEnd = onEnd;
+    }
+    return sound;
+}
+/** The sounds playing under exactly `owner`, as AVM1's Sound.stop() of a clip stops them; null for the global Sound's. */
+export function soundsOf(h, owner) {
+    return [...(timelineSounds.get(h) ?? [])].filter((sound) => sound.owner === owner);
+}
+/** Every sound of `character` stops, whoever started it, as AVM1's Sound.stop(name) does. */
+export function stopSoundsOf(h, character) {
+    for (const sound of [...(timelineSounds.get(h) ?? [])]) {
+        if (sound.character === character) {
+            stopTimelineSound(h, sound);
+        }
+    }
+}
+/** The DefineSound a StartSound names, by id or, for StartSound2, by the class bound to it. */
+function startSoundCharacter(library, start) {
+    let id = start.id;
+    if (start.className !== null) {
+        const dot = start.className.lastIndexOf(".");
+        const name = dot < 0
+            ? start.className
+            : `${start.className.slice(0, dot)}::${start.className.slice(dot + 1)}`;
+        id = null;
+        for (const [bound, className] of library.classes) {
+            if (className === name) {
+                id = bound;
+                break;
+            }
+        }
+    }
+    const character = id === null ? undefined : library.characters.get(id);
+    return character?.type === "sound" ? character : null;
+}
+/** A stream's blocks made one sound on its first play, shared by every clip of its timeline. */
+function streamOf(stream) {
+    if (!stream.sound) {
+        const { sound, starts } = streamSound(stream.head, stream.blocks);
+        stream.sound = { character: { type: "sound", id: 0, definition: sound }, starts };
+    }
+    return stream.sound;
+}
+/**
+ * The block on `frame` of a playing clip with no stream playing starts it
+ * from there, as Ruffle's sound_stream_block does, to the end of the run of
+ * frames with blocks after it, where Ruffle's stream ends, whatever its
+ * format: a gap is silence, as the frames carry no sound there, and the
+ * next block starts the stream again from its own samples. An MP3 stream
+ * that played on over a gap ran ahead of its timeline by the gap's length,
+ * a scene's narration heard before its pictures. Its device cursor lets
+ * the player advance overdue frames together, drawing only after the
+ * batch.
+ */
+function startStream(h, clip, stream, frame) {
+    const block = stream.byFrame.get(frame);
+    if (block === undefined || !clip.playing || clip.stream) {
+        return;
+    }
+    // What the timeline took off plays the frame it went in, but its streams no more.
+    let top = clip;
+    while (top.parent) {
+        top = top.parent;
+    }
+    if (unloaded.get(top) === h.frames) {
+        return;
+    }
+    // The last moments of its stream before, over by the clock, give way to this one.
+    for (const sound of [...(timelineSounds.get(h) ?? [])]) {
+        if (sound.clip === clip) {
+            stopTimelineSound(h, sound);
+        }
+    }
+    const { character, starts } = streamOf(stream);
+    let last = block + 1;
+    while (stream.byFrame.get(frame + last - block) === last) {
+        last++;
+    }
+    const rate = character.definition.sampleRate;
+    const start = (starts[block] * 1000) / rate;
+    const end = (starts[last] * 1000) / rate;
+    const sound = playTimelineSound(h, clip, character, clip, start, 1, { endMs: end }, end - start);
+    clip.stream = sound;
+    if (sound) {
+        sound.stream = {
+            elapsedMs: 0,
+            endFrame: frame + last - block,
+        };
+        let active = streamSounds.get(h);
+        if (!active) {
+            active = new Set();
+            streamSounds.set(h, active);
+        }
+        active.add(sound);
+    }
+}
+/** Whole frames by which a playing stream's device is ahead of its timeline. */
+export function streamFrames(h) {
+    const active = streamSounds.get(h);
+    if (!active || active.size === 0) {
+        return 0;
+    }
+    let frames = 0;
+    const frameMs = 1000 / h.frameRate;
+    for (const sound of active) {
+        if (sound.stream && sound.clip?.stream === sound) {
+            const position = sound.playing?.positionMs;
+            if (position !== undefined && Number.isFinite(position)) {
+                frames = Math.max(frames, Math.floor((position - sound.stream.elapsedMs) / frameMs + 1e-7));
+            }
+        }
+    }
+    return frames;
+}
+/** What the timeline took off, by the frame it did. */
+const unloaded = new WeakMap();
+/** Whether `inner` is `outer` or under it. */
+function within(inner, outer) {
+    for (let o = inner; o; o = o.parent) {
+        if (o === outer) {
+            return true;
+        }
+    }
+    return false;
+}
+/** unloadAndStop: the sounds of the timelines under `display` stop, its event sounds too. */
+export function stopTimelineSoundsUnder(s, display) {
+    const h = soundHostOf(s);
+    for (const sound of [...(timelineSounds.get(h) ?? [])]) {
+        if (within(sound.owner, display)) {
+            stopTimelineSound(h, sound);
+        }
+    }
+}
+/** What plays the timelines' sounds of every library a host loads. */
+export function timelineSoundsOf(h) {
+    return {
+        frame(clip, frame) {
+            if (!h.audio) {
+                return;
+            }
+            const timeline = clip.timeline;
+            const sound = clip.stream;
+            if (sound?.stream) {
+                if (frame >= sound.stream.endFrame) {
+                    stopTimelineSound(h, sound);
+                }
+                else {
+                    sound.stream.elapsedMs += 1000 / h.frameRate;
+                }
+            }
+            for (const start of timeline.sounds.get(frame) ?? []) {
+                const character = startSoundCharacter(clip.library, start);
+                if (character) {
+                    startEventSound(h, clip, character, start.info);
+                }
+            }
+            if (timeline.stream) {
+                startStream(h, clip, timeline.stream, frame);
+            }
+        },
+        stopStream(clip) {
+            clip.stream = null;
+            for (const sound of [...(timelineSounds.get(h) ?? [])]) {
+                if (sound.clip === clip) {
+                    stopTimelineSound(h, sound);
+                }
+            }
+        },
+        start(owner, library, id, info) {
+            const character = library.characters.get(id);
+            if (h.audio && character?.type === "sound") {
+                startEventSound(h, owner, character, info);
+            }
+        },
+        removed(display) {
+            if (!h.audio) {
+                return;
+            }
+            unloaded.set(display, h.frames);
+            for (const sound of [...(timelineSounds.get(h) ?? [])]) {
+                if (sound.clip && within(sound.clip, display)) {
+                    stopTimelineSound(h, sound);
+                }
+            }
+        },
+    };
+}
+/**
+ * The timeline's sounds that have played their time are over, with the
+ * frame: a NoMultiple may start one again, and AVM1 Sound's hears it.
+ * Streams remain attached until the timeline passes their blocks: the
+ * device finishing first must not restart one from a lagging frame.
+ */
+export function finishTimelineSounds(h) {
+    const ended = [];
+    for (const sound of [...(timelineSounds.get(h) ?? [])]) {
+        if (sound.stream) {
+            continue;
+        }
+        if (sound.endedAt === null && h.now - sound.started >= sound.duration) {
+            sound.endedAt = h.now;
+            if (sound.clip?.stream === sound) {
+                sound.clip.stream = null;
+            }
+            if (sound.onEnd) {
+                ended.push(sound);
+            }
+        }
+        else if (sound.endedAt !== null && !onDevice(sound)) {
+            stopTimelineSound(h, sound);
+        }
+        else if (sound.endedAt !== null &&
+            sound.playing?.ended === undefined &&
+            h.now - sound.endedAt >= TAIL) {
+            stopTimelineSound(h, sound);
+        }
+    }
+    for (const sound of ended) {
+        sound.onEnd?.();
+    }
+}
+/** Sound completions run with the next SWF frame, even if the device ended between frames. */
+export function finishSounds(s) {
+    finishTimelineSounds(soundHostOf(s));
+    const active = channels.get(s);
+    if (!active) {
+        return;
+    }
+    for (const channel of [...active]) {
+        const state = channel.$channel;
+        if (state.stopped) {
+            continue;
+        }
+        if (state.dynamic) {
+            state.dynamic.pump();
+            if (state.stopped || !active.has(channel) || !state.dynamic.complete()) {
+                continue;
+            }
+        }
+        else {
+            const duration = (state.sound.length - state.start) * Math.max(1, state.loops);
+            if (state.sound.length <= 0 || s.timers.now - state.started < duration) {
+                continue;
+            }
+        }
+        stopChannel(s, state);
+        active.delete(channel);
+        dispatchEvent(s, channel, s.event("soundComplete"));
+    }
+}