@swf2es/player 0.0.0-stage → 0.1.0

package/src/media/dynamic-sound.ts

@@ -0,0 +1,118 @@
+// SampleDataEvent's bytes belong to the script; only detached float buffers reach the audio host.
+import { avm2 } from "@swf2es/runtime";
+import { dispatchEvent } from "../scripting/events.js";
+import type { Scripting } from "../scripting.js";
+import type { StreamingSound } from "./audio.js";
+import { type ChannelState, mixerMix, outputMix } from "./sounds.js";
+
+export interface DynamicChannel {
+  position(): number;
+  pump(): void;
+  complete(): boolean;
+}
+
+export function startDynamicSound(
+  s: Scripting,
+  owner: avm2.AsObject,
+  state: ChannelState,
+  onFailure: (error: unknown) => void,
+): void {
+  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: StreamingSound | undefined;
+  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/src/media/extract.ts

@@ -0,0 +1,191 @@
+// Sound.extract's samples: a sound's own, at its own rate, given out at
+// 44.1 kHz in stereo, each sample held for as many as its rate falls short,
+// as adl gives them (the sound-extract case). Where extract is in a sound,
+// and where a script tells it to start, count the sound's own samples, not
+// those it writes. Ruffle's extract writes zeros (sound.rs's extract is a
+// stub).
+import type { Sound } from "@swf2es/format";
+import { decodeAdpcm, NellymoserDecoder } from "@swf2es/native/audio";
+import { Mp3Decoder, mp3Available } from "@swf2es/native/mp3";
+import { mp3Frames } from "./mp3.js";
+
+export const EXTRACT_RATE = 44100;
+
+/** A sound's samples to extract from. */
+export interface ExtractSource {
+  rate: number;
+  /** One channel, which extract writes to both, or two. */
+  channels: Float32Array[];
+  /** Samples at the start that extract never reaches: an MP3 DefineSound's seekSamples. */
+  skip: number;
+  /**
+   * Whether it writes whole samples of its own only, as adl does for a
+   * sound uncompressed or ADPCM in the SWF: a length short of one writes
+   * none.
+   */
+  whole: boolean;
+  /** Where a script may start it, short of its end: an ADPCM sound's samples, not the silence after them. */
+  starts?: number;
+  /** Where a start lands, for a sound whose seeking adl gets wrong. */
+  seek?: (start: number) => number;
+}
+
+/**
+ * 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: Uint8Array): ExtractSource | null {
+  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: Sound): ExtractSource | null {
+  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: Uint8Array,
+  n: 1 | 2,
+): Pick<ExtractSource, "channels" | "starts" | "seek"> {
+  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: number, n: number, at: (i: number) => number): Float32Array[] {
+  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: Float32Array[], rate: number): Float32Array[] {
+  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: ExtractSource,
+  position: number,
+  length: number,
+): { samples: Float32Array; position: number; count: number } {
+  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 };
+}

package/src/media/mp3.ts

@@ -0,0 +1,205 @@
+// 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;
+
+export interface Mp3Frames {
+  rate: number;
+  channels: 1 | 2;
+  samplesPerFrame: number;
+  /** Frames whole and cut short, as Sound.length counts them. */
+  frames: number;
+  /** Where each whole frame starts and ends, in pairs. */
+  whole: number[];
+  /** Where reading goes on from with more bytes: after the last whole frame. */
+  end: number;
+}
+
+interface Header {
+  version: number;
+  rate: number;
+  channels: 1 | 2;
+  samples: number;
+  length: number;
+  mpeg1: boolean;
+}
+
+function header(bytes: Uint8Array, at: number): Header | null {
+  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: Uint8Array, at: number, like: Header | null): Header | null {
+  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: Uint8Array, at: number, like: Header | null): Header | null {
+  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: Uint8Array, at: number): number {
+  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: Uint8Array, at: number, like: Header | null): [number, Header] | null {
+  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: Uint8Array, before: Mp3Frames | null = null): Mp3Frames | 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: Uint8Array, from: number, like: Header, before: number[]): Mp3Frames {
+  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: Uint8Array, at: number, h: Header): boolean {
+  const tag = (offset: number) =>
+    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: Uint8Array): [number, number] | null {
+  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)];
+}