@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,376 @@
+import { decodeAdpcm, NellymoserDecoder } from "../../native/audio/index.js";
+import { mp3HeaderFrame } from "./mp3.js";
+import { browserStream } from "./streaming-audio.js";
+/** Below Firefox's limit for a scheduled stop, 2^23 s, with room for the context's own clock. */
+const SCHEDULED_STOP_LIMIT = 2 ** 22;
+/** The browser's decoder handles MP3; SWF's two uncompressed forms need no codec. */
+export function browserAudioHost() {
+    const Context = globalThis.AudioContext;
+    if (!Context) {
+        return null;
+    }
+    let context = null;
+    let closed = false;
+    const streams = new Set();
+    // Closed, it decodes nothing more: a new context would outlive the player.
+    const getContext = () => {
+        if (closed) {
+            throw new Error("the audio host is closed");
+        }
+        context ??= new Context();
+        return context;
+    };
+    return {
+        stream(mix, refill) {
+            const stream = browserStream(getContext(), mix, refill, () => streams.delete(stream));
+            streams.add(stream);
+            return stream;
+        },
+        close() {
+            // A browser keeps a context, and its thread, until it is closed.
+            closed = true;
+            for (const stream of streams) {
+                stream.stop();
+            }
+            void context?.close().catch(() => { });
+            context = null;
+        },
+        async decode(given) {
+            const ctx = getContext();
+            const source = given instanceof Uint8Array
+                ? given
+                : given.format === 1
+                    ? adpcmSound(given)
+                    : isNellymoser(given.format)
+                        ? nellymoserSound(given)
+                        : given;
+            let buffer;
+            if (source instanceof Uint8Array || source.format === 2) {
+                const data = (source instanceof Uint8Array ? source : source.data).slice();
+                if (!(source instanceof Uint8Array)) {
+                    // SWF supplies the delay itself. Keep the header frame's silence,
+                    // without letting the browser trim it by Xing/LAME metadata too.
+                    const header = mp3HeaderFrame(data);
+                    if (header) {
+                        data.fill(0, header[0] + 4, header[1]);
+                    }
+                }
+                buffer = await ctx.decodeAudioData(data.buffer);
+            }
+            else if (source.format === 0 || source.format === 3) {
+                buffer = ctx.createBuffer(source.channels, source.sampleCount, source.sampleRate);
+                const view = new DataView(source.data.buffer, source.data.byteOffset, source.data.byteLength);
+                const channels = Array.from({ length: source.channels }, (_, i) => buffer.getChannelData(i));
+                const bytesPerFrame = source.channels * (source.sampleSize / 8);
+                const frames = Math.min(source.sampleCount, Math.floor(source.data.byteLength / bytesPerFrame));
+                if (source.sampleSize === 8) {
+                    for (let i = 0; i < frames; i++) {
+                        for (let channel = 0; channel < source.channels; channel++) {
+                            channels[channel][i] = (view.getUint8(i * bytesPerFrame + channel) - 128) / 128;
+                        }
+                    }
+                }
+                else {
+                    for (let i = 0; i < frames; i++) {
+                        for (let channel = 0; channel < source.channels; channel++) {
+                            channels[channel][i] = view.getInt16(i * bytesPerFrame + channel * 2, true) / 32768;
+                        }
+                    }
+                }
+            }
+            else {
+                throw new Error(`Unsupported SWF sound format ${source.format}`);
+            }
+            // DefineSound's offsets count from after the encoder delay, in its
+            // own sample rate; Web Audio may have resampled the decoded buffer.
+            const origin = !(source instanceof Uint8Array) && source.format === 2
+                ? Math.max(0, source.seekSamples) / source.sampleRate
+                : 0;
+            const duration = !(source instanceof Uint8Array) && source.format === 2
+                ? Math.max(0, Math.min(buffer.duration - origin, source.sampleCount / source.sampleRate))
+                : buffer.duration;
+            return {
+                durationMs: duration * 1000,
+                play(startMs, loops, mix, shape) {
+                    const offset = Math.max(0, startMs / 1000);
+                    const end = Math.min(duration, (shape?.endMs ?? Infinity) / 1000);
+                    const keepsTime = shape?.atMs !== undefined;
+                    const at = Math.max(0, (shape?.atMs ?? 0) / 1000);
+                    const length = end - offset;
+                    const total = length * Math.max(1, loops);
+                    if (length <= 0 || at >= total) {
+                        return null;
+                    }
+                    const sourceNode = ctx.createBufferSource();
+                    let ended = false;
+                    let started = false;
+                    let beganAt = 0;
+                    let from = 0;
+                    let position = Number.NaN;
+                    const positionMs = () => started && !ended
+                        ? Math.min(total, from + Math.max(0, ctx.currentTime - beganAt)) * 1000
+                        : position;
+                    const finish = () => {
+                        if (ended) {
+                            return;
+                        }
+                        position = positionMs();
+                        ended = true;
+                        ctx.removeEventListener?.("statechange", running);
+                        sourceNode.disconnect();
+                        splitter.disconnect();
+                        for (const gain of [...gains, ...levels]) {
+                            gain.disconnect();
+                        }
+                        merger.disconnect();
+                    };
+                    sourceNode.buffer = buffer;
+                    const splitter = ctx.createChannelSplitter(2);
+                    const merger = ctx.createChannelMerger(2);
+                    const gains = Array.from({ length: 4 }, () => ctx.createGain());
+                    const right = buffer.numberOfChannels === 1 ? 0 : 1;
+                    sourceNode.onended = finish;
+                    sourceNode.connect(splitter);
+                    // An envelope scales each source channel, a mono one as both, before the mix crosses them.
+                    const levels = shape?.envelope ? [ctx.createGain(), ctx.createGain()] : [];
+                    if (shape?.envelope) {
+                        splitter.connect(levels[0], 0);
+                        splitter.connect(levels[1], right);
+                        levels[0].connect(gains[0]);
+                        levels[0].connect(gains[1]);
+                        levels[1].connect(gains[2]);
+                        levels[1].connect(gains[3]);
+                    }
+                    else {
+                        splitter.connect(gains[0], 0);
+                        splitter.connect(gains[1], 0);
+                        splitter.connect(gains[2], right);
+                        splitter.connect(gains[3], right);
+                    }
+                    gains[0].connect(merger, 0, 0);
+                    gains[1].connect(merger, 0, 1);
+                    gains[2].connect(merger, 0, 0);
+                    gains[3].connect(merger, 0, 1);
+                    merger.connect(ctx.destination);
+                    const setMix = (next) => {
+                        gains[0].gain.value = next.volume * next.leftToLeft;
+                        gains[1].gain.value = next.volume * next.leftToRight;
+                        gains[2].gain.value = next.volume * next.rightToLeft;
+                        gains[3].gain.value = next.volume * next.rightToRight;
+                    };
+                    setMix(mix);
+                    sourceNode.loop = loops > 1;
+                    sourceNode.loopStart = origin + offset;
+                    sourceNode.loopEnd = origin + end;
+                    const asked = performance.now();
+                    // `late` seconds after it was asked for, as a stream waits for the device to run.
+                    const begin = (late) => {
+                        from = at + late;
+                        if (from >= total) {
+                            position = total * 1000;
+                            finish();
+                            return;
+                        }
+                        started = true;
+                        beganAt = ctx.currentTime;
+                        if (shape?.envelope) {
+                            envelopeLevels(levels[0].gain, levels[1].gain, shape.envelope, ctx.currentTime, from);
+                        }
+                        if (loops > 1) {
+                            sourceNode.start(0, origin + offset + (from % length));
+                            // Firefox refuses a stop time past 2^23 s (about 97 days) with a RangeError,
+                            // which a loop count such as 999999 asks for; a loop that long is ended by
+                            // stop() instead, and the channel's completion is timed by the player's clock.
+                            const remaining = total - from;
+                            if (ctx.currentTime + remaining < SCHEDULED_STOP_LIMIT) {
+                                sourceNode.stop(ctx.currentTime + remaining);
+                            }
+                        }
+                        else if (origin + end < buffer.duration) {
+                            sourceNode.start(0, origin + offset + from, length - from);
+                        }
+                        else {
+                            sourceNode.start(0, origin + offset + from);
+                        }
+                    };
+                    // A suspended context's time stands still, before the page's first
+                    // gesture or a slow resume: a stream starts when it runs, as far in
+                    // as the wait; any other sound plays whole once it does.
+                    function running() {
+                        if (ctx.state === "running" && !started && !ended) {
+                            ctx.removeEventListener?.("statechange", running);
+                            begin((performance.now() - asked) / 1000);
+                        }
+                    }
+                    if (keepsTime && ctx.state === "suspended") {
+                        ctx.addEventListener?.("statechange", running);
+                    }
+                    else {
+                        begin(0);
+                    }
+                    void ctx.resume().catch(() => { });
+                    return {
+                        stop: () => {
+                            if (!ended) {
+                                if (started) {
+                                    try {
+                                        sourceNode.stop();
+                                    }
+                                    catch {
+                                        // Already stopped, or stopped by the browser: disconnected all the same.
+                                    }
+                                }
+                                finish();
+                            }
+                        },
+                        setMix,
+                        get ended() {
+                            return ended;
+                        },
+                        get positionMs() {
+                            return positionMs();
+                        },
+                    };
+                },
+            };
+        },
+    };
+}
+/**
+ * An envelope as gain automation, `at` seconds into it at `now`: the first
+ * point's level held before it, as Ruffle holds it, then lines between
+ * points; a late start begins at the level the lines reach by then.
+ */
+function envelopeLevels(left, right, envelope, now, at) {
+    const ms = at * 1000;
+    let level = envelope[0] ?? { ms: 0, left: 1, right: 1 };
+    for (let i = 0; i < envelope.length && envelope[i].ms <= ms; i++) {
+        const next = envelope[i + 1];
+        level = envelope[i];
+        if (next && next.ms > ms && next.ms > level.ms) {
+            const t = (ms - level.ms) / (next.ms - level.ms);
+            level = {
+                ms,
+                left: level.left + (next.left - level.left) * t,
+                right: level.right + (next.right - level.right) * t,
+            };
+            break;
+        }
+    }
+    left.setValueAtTime(level.left, now);
+    right.setValueAtTime(level.right, now);
+    for (const point of envelope) {
+        if (point.ms >= ms) {
+            left.linearRampToValueAtTime(point.left, now + (point.ms - ms) / 1000);
+            right.linearRampToValueAtTime(point.right, now + (point.ms - ms) / 1000);
+        }
+    }
+}
+/** 16-bit samples as uncompressed little-endian bytes, SWF's format 3. */
+function pcmBytes(samples) {
+    const bytes = new Uint8Array(samples.length * 2);
+    const view = new DataView(bytes.buffer);
+    for (let i = 0; i < samples.length; i++) {
+        view.setInt16(i * 2, samples[i], true);
+    }
+    return bytes;
+}
+/** Whether `format` is Nellymoser's: 4 and 5 at 16 and 8 kHz, 6 at any rate. */
+function isNellymoser(format) {
+    return format === 4 || format === 5 || format === 6;
+}
+/** The sample rate of Nellymoser in `format`: 16 or 8 kHz for 4 and 5 whatever their flags say, `flagged` for 6. */
+function nellymoserRate(format, flagged) {
+    return format === 4 ? 16000 : format === 5 ? 8000 : flagged;
+}
+/** Samples from -1 to 1 as 16-bit ones. */
+function int16Samples(samples) {
+    const out = new Int16Array(samples.length);
+    for (let i = 0; i < samples.length; i++) {
+        const v = Math.round(samples[i] * 32768);
+        out[i] = v > 32767 ? 32767 : v < -32768 ? -32768 : v;
+    }
+    return out;
+}
+/** A Nellymoser DefineSound, which is mono, as the uncompressed sound it decodes to, cut to its count. */
+function nellymoserSound(sound) {
+    const decoded = new NellymoserDecoder().decode(sound.data);
+    const samples = decoded.subarray(0, Math.min(decoded.length, sound.sampleCount));
+    return {
+        ...sound,
+        format: 3,
+        sampleRate: nellymoserRate(sound.format, sound.sampleRate),
+        sampleSize: 16,
+        channels: 1,
+        sampleCount: samples.length,
+        data: pcmBytes(int16Samples(samples)),
+    };
+}
+/** An ADPCM DefineSound as the uncompressed sound it decodes to. */
+function adpcmSound(sound) {
+    const samples = decodeAdpcm(sound.data, sound.channels);
+    return {
+        ...sound,
+        format: 3,
+        sampleSize: 16,
+        sampleCount: samples.length / sound.channels,
+        data: pcmBytes(samples),
+    };
+}
+/**
+ * A timeline's stream as one sound, its blocks back to back, and the
+ * sample each block starts at, the last entry the end. MP3 blocks give
+ * their counts; PCM's are whole frames of their bytes; each ADPCM block
+ * is a sound of its own, headers and all; Nellymoser's decode one after
+ * another, each block's overlap carried into the next.
+ */
+export function streamSound(head, blocks) {
+    const parts = [];
+    const starts = [0];
+    const adpcm = head.format === 1;
+    const nellymoser = isNellymoser(head.format) ? new NellymoserDecoder() : null;
+    const decoded = adpcm || nellymoser !== null;
+    const sampleSize = decoded ? 16 : head.sampleSize;
+    const channels = nellymoser ? 1 : head.channels;
+    const frameBytes = channels * (sampleSize / 8);
+    let samples = 0;
+    for (const block of blocks) {
+        let data = block.data;
+        let count;
+        if (head.format === 2) {
+            count = block.sampleCount ?? 0;
+        }
+        else {
+            if (adpcm) {
+                data = pcmBytes(decodeAdpcm(data, head.channels));
+            }
+            else if (nellymoser) {
+                data = pcmBytes(int16Samples(nellymoser.decode(data)));
+            }
+            count = Math.floor(data.length / frameBytes);
+            data = data.subarray(0, count * frameBytes);
+        }
+        parts.push(data);
+        samples += count;
+        starts.push(samples);
+    }
+    const data = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+    let at = 0;
+    for (const part of parts) {
+        data.set(part, at);
+        at += part.length;
+    }
+    return {
+        sound: {
+            id: 0,
+            format: decoded ? 3 : head.format,
+            sampleRate: nellymoser ? nellymoserRate(head.format, head.sampleRate) : head.sampleRate,
+            sampleSize,
+            channels,
+            sampleCount: samples,
+            seekSamples: 0,
+            data,
+        },
+        starts,
+    };
+}

package/dist/thread/player/media/dynamic-sound.js

@@ -0,0 +1,90 @@
+// SampleDataEvent's bytes belong to the script; only detached float buffers reach the audio host.
+import { avm2 } from "../../runtime/index.js";
+import { dispatchEvent } from "../scripting/events.js";
+import { mixerMix, outputMix } from "./sounds.js";
+export function startDynamicSound(s, owner, state, onFailure) {
+    const data = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray"));
+    const bytes = avm2.bytesOf(s.rt, data);
+    let generated = 0;
+    let requestOffset = 0;
+    let finished = false;
+    let requesting = false;
+    let ready = false;
+    let starting = true;
+    let stream;
+    const position = () => stream?.positionMs ?? Math.min((generated * 1000) / 44100, s.timers.now - state.started);
+    const request = () => {
+        // AIR preserves the ByteArray's contents and endian, resetting only its write cursor.
+        bytes.position = 0;
+        const event = s.rt.construct(s.rt.classNamed("flash.events::SampleDataEvent"), "sampleData", false, false, generated + requestOffset, data);
+        dispatchEvent(s, owner, event);
+        if (state.stopped) {
+            return;
+        }
+        const frames = Math.floor(bytes.position / 8);
+        if (frames > 8192 || bytes.position > bytes.length) {
+            finished = true;
+            stream?.finish();
+            s.reportUncaught(frames > 8192 ? s.rt.error("RangeError", 2004) : s.rt.error("flash.errors::EOFError", 2030));
+            return;
+        }
+        if (frames > 0) {
+            const channels = [new Float32Array(frames), new Float32Array(frames)];
+            for (let i = 0; i < frames; i++) {
+                for (let c = 0; c < 2; c++) {
+                    const sample = bytes.view.getFloat32(i * 8 + c * 4, bytes.littleEndian);
+                    channels[c][i] = Number.isFinite(sample) ? sample : 0;
+                }
+            }
+            generated += frames;
+            stream?.append(channels);
+        }
+        if (frames < 2048) {
+            finished = true;
+            stream?.finish();
+        }
+    };
+    const pump = () => {
+        if (!ready || requesting || finished || state.stopped) {
+            return;
+        }
+        requesting = true;
+        try {
+            if (generated - (position() * 44100) / 1000 < 8192) {
+                request();
+            }
+        }
+        catch (error) {
+            if (starting) {
+                throw error;
+            }
+            finished = true;
+            onFailure(error);
+        }
+        finally {
+            requesting = false;
+        }
+    };
+    state.dynamic = {
+        position: () => state.start + position(),
+        pump,
+        complete: () => finished && (stream ? stream.ended === true : position() >= generated / 44.1),
+    };
+    stream = s.audio?.stream?.(outputMix(state.mix, mixerMix(s)), pump);
+    state.playing = stream ?? null;
+    ready = true;
+    pump();
+    // AIR fills another buffer synchronously when the first supplied the full 8192 frames.
+    if (!finished && !state.stopped && generated === 8192) {
+        requesting = true;
+        try {
+            request();
+        }
+        finally {
+            requesting = false;
+        }
+    }
+    // AIR applies startTime to later request positions, after its synchronous initial fill.
+    requestOffset = Math.floor(state.start * 44.1);
+    starting = false;
+}

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

@@ -0,0 +1,135 @@
+import { decodeAdpcm, NellymoserDecoder } from "../../native/audio/index.js";
+import { Mp3Decoder, mp3Available } from "../../native/mp3/index.js";
+import { mp3Frames } from "./mp3.js";
+export const EXTRACT_RATE = 44100;
+/**
+ * Whole MP3 frames, including a header frame's silence, without gapless
+ * trimming. None where the engine could not compile the decoder: extract
+ * then writes nothing, as Flash does for a sound it cannot decode.
+ */
+export function mp3Source(bytes) {
+    const mp3 = mp3Frames(bytes);
+    if (!mp3?.whole.length || !mp3Available()) {
+        return null;
+    }
+    const frames = (mp3.whole.length / 2) * mp3.samplesPerFrame;
+    const channels = Array.from({ length: mp3.channels }, () => new Float32Array(frames));
+    const decoder = new Mp3Decoder();
+    let at = 0;
+    for (let k = 0; k < mp3.whole.length; k += 2) {
+        const count = decoder.read(bytes.subarray(mp3.whole[k], mp3.whole[k + 1]));
+        if (decoder.channels === mp3.channels && decoder.rate === mp3.rate) {
+            const take = Math.min(count, mp3.samplesPerFrame);
+            for (let i = 0; i < take; i++) {
+                for (let c = 0; c < mp3.channels; c++) {
+                    channels[c][at + i] = decoder.pcm[i * mp3.channels + c];
+                }
+            }
+        }
+        at += mp3.samplesPerFrame;
+    }
+    return { rate: mp3.rate, channels, skip: 0, whole: false };
+}
+/** An uncompressed, ADPCM or Nellymoser DefineSound's samples to extract, or null for another format. */
+export function embeddedSource(sound) {
+    const n = sound.channels;
+    const source = { rate: sound.sampleRate, skip: 0, whole: true };
+    if (sound.format === 1) {
+        return { ...source, ...adpcmSource(sound.data, n) };
+    }
+    // Mono, at the rate its flags give, as adl extracts it, formats 4 and 5
+    // too, which play at 16 and 8 kHz (audio.ts). adl's own extract of it is
+    // erratic past 4096 samples a call and near the sound's end
+    // (scripts/SoundExtractNellymoser.as): those are not copied.
+    if (sound.format === 4 || sound.format === 5 || sound.format === 6) {
+        const samples = new NellymoserDecoder().decode(sound.data);
+        return {
+            ...source,
+            channels: [samples.subarray(0, Math.min(samples.length, sound.sampleCount))],
+        };
+    }
+    if (sound.format !== 0 && sound.format !== 3) {
+        return null;
+    }
+    const view = new DataView(sound.data.buffer, sound.data.byteOffset, sound.data.byteLength);
+    const size = sound.sampleSize / 8;
+    const frames = Math.min(sound.sampleCount, Math.floor(sound.data.byteLength / (size * n)));
+    return {
+        ...source,
+        channels: deinterleave(frames, n, (i) => size === 1 ? (view.getUint8(i) - 128) / 128 : view.getInt16(i * 2, true) / 32768),
+    };
+}
+/** Samples adl decodes in blocks of 2048, the last run on past the data as if its bits went on as zeros. */
+const ADPCM_BLOCK = 2048;
+/** Samples a packet: its header's and 4095 codes'. */
+const ADPCM_PACKET = 4096;
+/**
+ * An ADPCM sound's samples as adl extracts them: blocks of samples, the
+ * last running on as if the data's bits went on as zeros (where adl reads
+ * on into whatever follows the data), though a script may start only
+ * within the data. A start's packet's offset in bits is reckoned in 32
+ * bits: where that wraps negative, adl starts from the first packet, as
+ * far into it as the start is into its own.
+ */
+function adpcmSource(data, n) {
+    const frames = decodeAdpcm(data, n).length / n;
+    const padded = (Math.floor(frames / ADPCM_BLOCK) + 1) * ADPCM_BLOCK;
+    const bits = data.length ? (data[0] >> 6) + 2 : 4;
+    const more = new Uint8Array(data.length + Math.ceil(((padded - frames) * bits * n) / 8) + 8 * n);
+    more.set(data);
+    const samples = decodeAdpcm(more, n);
+    const packetBits = 22 * n + (ADPCM_PACKET - 1) * bits * n;
+    return {
+        channels: deinterleave(padded, n, (i) => samples[i] / 32768),
+        starts: frames,
+        seek: (start) => Math.imul(Math.floor(start / ADPCM_PACKET), packetBits) < 0 ? start % ADPCM_PACKET : start,
+    };
+}
+function deinterleave(frames, n, at) {
+    const channels = Array.from({ length: n }, () => new Float32Array(frames));
+    for (let i = 0; i < frames; i++) {
+        for (let c = 0; c < n; c++) {
+            channels[c][i] = at(i * n + c);
+        }
+    }
+    return channels;
+}
+/** Samples at `rate` brought to 44.1 kHz as loadPCMFromByteArray does: each output sample the one it falls in. */
+export function toExtractRate(channels, rate) {
+    if (rate === EXTRACT_RATE) {
+        return channels;
+    }
+    const frames = Math.floor((channels[0].length * EXTRACT_RATE) / rate);
+    return channels.map((channel) => {
+        const out = new Float32Array(frames);
+        for (let i = 0; i < frames; i++) {
+            out[i] = channel[Math.floor((i * rate) / EXTRACT_RATE)];
+        }
+        return out;
+    });
+}
+/**
+ * Up to `length` samples from `position`, interleaved, and the position
+ * after them. What extract returns is how many it wrote, but once the
+ * sound runs out, how many of its own samples it read, as adl counts them.
+ */
+export function extractSamples(source, position, length) {
+    const total = source.channels[0].length - source.skip;
+    const ratio = EXTRACT_RATE / source.rate;
+    const room = Math.max(0, total - position);
+    const wanted = Math.floor(length);
+    let written = wanted > 0 ? Math.min(wanted, Math.floor(room * ratio)) : 0;
+    if (source.whole) {
+        written = Math.floor(Math.floor(written / ratio) * ratio);
+    }
+    const read = Math.min(room, Math.ceil(written / ratio));
+    const [left, right = left] = source.channels;
+    const samples = new Float32Array(written * 2);
+    for (let i = 0; i < written; i++) {
+        const at = source.skip + position + Math.floor(i / ratio);
+        samples[i * 2] = left[at];
+        samples[i * 2 + 1] = right[at];
+    }
+    const end = position + read >= total;
+    return { samples, position: position + read, count: end ? read : written };
+}