@swf2es/format 0.0.0-stage → 0.1.1

package/src/sound.ts

@@ -0,0 +1,173 @@
+// DefineSound's header and encoded samples, and the tags that play sounds
+// from a timeline: StartSound and StartSound2, the stream of
+// SoundStreamHead and SoundStreamBlock, and DefineButtonSound. Decoding
+// belongs to the player, where a host can supply an audio device.
+import { readString } from "./display.js";
+import { SwfReader, type Tag } from "./swf.js";
+import { StartSound2 } from "./tags.js";
+
+export interface Sound {
+  id: number;
+  format: number;
+  sampleRate: number;
+  sampleSize: 8 | 16;
+  channels: 1 | 2;
+  sampleCount: number;
+  /** For MP3, the signed sample offset at the front of SoundData. */
+  seekSamples: number;
+  data: Uint8Array;
+}
+
+const RATES = [5512.5, 11025, 22050, 44100];
+
+export function readSound(bytes: Uint8Array, tag: Tag): Sound {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const id = r.u16();
+  const flags = r.u8();
+  const format = flags >> 4;
+  const sampleRate = RATES[(flags >> 2) & 3];
+  const sampleSize = (flags & 2) === 0 ? 8 : 16;
+  const channels = (flags & 1) === 0 ? 1 : 2;
+  const sampleCount = r.u32();
+  const seekSamples = format === 2 ? r.s16() : 0;
+  return {
+    id,
+    format,
+    sampleRate,
+    sampleSize,
+    channels,
+    sampleCount,
+    seekSamples,
+    data: bytes.subarray(r.pos, tag.offset + tag.length),
+  };
+}
+
+/** A point of SOUNDINFO's envelope: its sample at 44.1 kHz from the start, and each channel's level, 0 to 1. */
+export interface SoundEnvelopePoint {
+  sample: number;
+  left: number;
+  right: number;
+}
+
+/** SOUNDINFO: how StartSound, StartSound2 and DefineButtonSound play a sound. */
+export interface SoundInfo {
+  /** SyncStop: stop the sound wherever it plays, and start none. */
+  stop: boolean;
+  /** SyncNoMultiple: start none while the sound plays. */
+  noMultiple: boolean;
+  /** Where each loop starts and ends, in samples at 44.1 kHz; null for the sound's own. */
+  inPoint: number | null;
+  outPoint: number | null;
+  /** 1 without HasLoops. */
+  loops: number;
+  envelope: SoundEnvelopePoint[] | null;
+}
+
+export function readSoundInfo(r: SwfReader): SoundInfo {
+  const flags = r.u8();
+  const inPoint = flags & 0x01 ? r.u32() : null;
+  const outPoint = flags & 0x02 ? r.u32() : null;
+  const loops = flags & 0x04 ? r.u16() : 1;
+  let envelope: SoundEnvelopePoint[] | null = null;
+  if (flags & 0x08) {
+    envelope = [];
+    for (let n = r.u8(); n > 0 && !r.overrun; n--) {
+      envelope.push({ sample: r.u32(), left: r.u16() / 32768, right: r.u16() / 32768 });
+    }
+  }
+
+  return {
+    stop: (flags & 0x20) !== 0,
+    noMultiple: (flags & 0x10) !== 0,
+    inPoint,
+    outPoint,
+    loops,
+    envelope,
+  };
+}
+
+/** StartSound names its sound by id, StartSound2 by the class bound to it. */
+export interface StartSound {
+  id: number | null;
+  className: string | null;
+  info: SoundInfo;
+}
+
+export function readStartSound(bytes: Uint8Array, tag: Tag): StartSound {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  if (tag.code === StartSound2) {
+    const className = readString(r);
+    return { id: null, className, info: readSoundInfo(r) };
+  }
+
+  const id = r.u16();
+  return { id, className: null, info: readSoundInfo(r) };
+}
+
+/** SoundStreamHead or SoundStreamHead2: the format of a timeline's SoundStreamBlocks. */
+export interface SoundStreamHead {
+  format: number;
+  sampleRate: number;
+  sampleSize: 8 | 16;
+  channels: 1 | 2;
+  /** The samples each frame's block holds, on average. */
+  samplesPerBlock: number;
+}
+
+export function readSoundStreamHead(bytes: Uint8Array, tag: Tag): SoundStreamHead {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  // The playback format is only a hint; the stream's own follows it.
+  r.u8();
+  const flags = r.u8();
+  return {
+    format: flags >> 4,
+    sampleRate: RATES[(flags >> 2) & 3],
+    sampleSize: (flags & 2) === 0 ? 8 : 16,
+    channels: (flags & 1) === 0 ? 1 : 2,
+    samplesPerBlock: r.u16(),
+  };
+}
+
+/** A SoundStreamBlock's samples: for MP3, the frames after its sample count and seek. */
+export interface SoundStreamBlock {
+  /** MP3's own count; null for the other formats, whose bytes tell it. */
+  sampleCount: number | null;
+  data: Uint8Array;
+}
+
+export function readSoundStreamBlock(
+  bytes: Uint8Array,
+  tag: Tag,
+  format: number,
+): SoundStreamBlock {
+  const end = tag.offset + tag.length;
+  if (format !== 2) {
+    return { sampleCount: null, data: bytes.subarray(tag.offset, end) };
+  }
+
+  const r = new SwfReader(bytes, tag.offset, end);
+  const sampleCount = r.u16();
+  return { sampleCount, data: bytes.subarray(Math.min(end, tag.offset + 4), end) };
+}
+
+/**
+ * DefineButtonSound: the sounds a button plays as its state changes, in
+ * the tag's order: over to up, up to over, over to down, down to over.
+ * Some tools write fewer than four, as Ruffle notes; the missing are none.
+ */
+export interface ButtonSounds {
+  id: number;
+  sounds: ({ id: number; info: SoundInfo } | null)[];
+}
+
+export function readButtonSound(bytes: Uint8Array, tag: Tag): ButtonSounds {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const id = r.u16();
+  const sounds: ButtonSounds["sounds"] = [];
+  for (let i = 0; i < 4; i++) {
+    const sound = r.pos + 2 <= r.end ? r.u16() : 0;
+    sounds.push(sound === 0 ? null : { id: sound, info: readSoundInfo(r) });
+  }
+
+  return { id, sounds };
+}

package/src/swf.ts

@@ -0,0 +1,234 @@
+// A SWF's movie header and its tags, as the SWF file format specification
+// (version 19) lays them out: after the 8-byte file header and the body's
+// decompression, the frame size as a RECT, the frame rate as 8.8 fixed
+// point, the frame count, then tags to an End tag or the body's end.
+import { decompressSwf, decompressSwfPrefix } from "./compression.js";
+import { End, FileAttributes, SetBackgroundColor } from "./tags.js";
+
+export type SwfCompression = "none" | "zlib" | "lzma";
+
+export interface SwfHeader {
+  compression: SwfCompression;
+  /** SWF version byte (e.g. 10 for Flash Player 10). */
+  version: number;
+  /** Uncompressed length of the whole file, header included. */
+  fileLength: number;
+}
+
+/** A rectangle in twips (1/20 pixel), as a RECT holds one. */
+export interface Rect {
+  xMin: number;
+  xMax: number;
+  yMin: number;
+  yMax: number;
+}
+
+/** A tag: its code, and where its body is in the decompressed file. */
+export interface Tag {
+  code: number;
+  /** Offset of the body in the decompressed file, after the tag's header. */
+  offset: number;
+  length: number;
+  /** Whether the header was the long form, which Flash requires of a bitmap tag. */
+  long: boolean;
+}
+
+export interface Swf {
+  header: SwfHeader;
+  /** The whole file, decompressed, header included; tags' offsets are into it. */
+  bytes: Uint8Array;
+  frameSize: Rect;
+  /** Frames per second: the 8.8 fixed-point value as a number. */
+  frameRate: number;
+  frameCount: number;
+  tags: Tag[];
+  /** Whether the tags ran past the end of the file, and were cut there. */
+  truncated: boolean;
+}
+
+const SIGNATURES: Record<string, SwfCompression> = { FWS: "none", CWS: "zlib", ZWS: "lzma" };
+
+/** Read the 8-byte header every SWF starts with. */
+export function readSwfHeader(bytes: Uint8Array): SwfHeader {
+  if (bytes.length < 8) {
+    throw new RangeError(`SWF header needs 8 bytes, got ${bytes.length}`);
+  }
+
+  const signature = String.fromCharCode(bytes[0], bytes[1], bytes[2]);
+  const compression = SIGNATURES[signature];
+  if (!compression) {
+    throw new TypeError(`Not a SWF file (signature ${JSON.stringify(signature)})`);
+  }
+
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { compression, version: bytes[3], fileLength: view.getUint32(4, true) };
+}
+
+/** Reads bits and bytes of a SWF body, bits most significant first, as the format packs them. */
+export class SwfReader {
+  private bit = 0;
+  private byte = 0;
+
+  constructor(
+    readonly bytes: Uint8Array,
+    public pos = 0,
+    readonly end = bytes.length,
+  ) {}
+
+  /** Past the end: every read after it gives 0. */
+  get overrun(): boolean {
+    return this.pos > this.end;
+  }
+
+  align(): void {
+    this.bit = 0;
+  }
+
+  ub(n: number): number {
+    let v = 0;
+    for (let i = 0; i < n; i++) {
+      if (this.bit === 0) {
+        this.byte = this.pos < this.end ? this.bytes[this.pos] : 0;
+        this.pos++;
+        this.bit = 8;
+      }
+
+      this.bit--;
+      v = v * 2 + ((this.byte >> this.bit) & 1);
+    }
+
+    return v;
+  }
+
+  sb(n: number): number {
+    if (n > 0 && n <= 32 && n === (n | 0)) {
+      const shift = 32 - n;
+      return (this.ub(n) << shift) >> shift;
+    }
+
+    if (n === 0) {
+      return 0;
+    }
+
+    const v = this.ub(n);
+    return v >= 2 ** (n - 1) ? v - 2 ** n : v;
+  }
+
+  u8(): number {
+    this.align();
+    const v = this.pos < this.end ? this.bytes[this.pos] : 0;
+    this.pos++;
+    return v;
+  }
+
+  u16(): number {
+    return this.u8() | (this.u8() << 8);
+  }
+
+  u32(): number {
+    return (this.u16() | (this.u16() << 16)) >>> 0;
+  }
+
+  s16(): number {
+    return (this.u16() << 16) >> 16;
+  }
+
+  rect(): Rect {
+    this.align();
+    const n = this.ub(5);
+    const rect = { xMin: this.sb(n), xMax: this.sb(n), yMin: this.sb(n), yMax: this.sb(n) };
+    this.align();
+    return rect;
+  }
+}
+
+/** A SWF's header and tags, its body decompressed. */
+export function readSwf(file: Uint8Array): Swf {
+  const header = readSwfHeader(file);
+  const bytes = decompressSwf(file);
+  const r = new SwfReader(bytes, 8);
+  const frameSize = r.rect();
+  const frameRate = r.u16() / 256;
+  const frameCount = r.u16();
+  const { tags, truncated } = readTags(bytes, r.pos, bytes.length);
+  return { header, bytes, frameSize, frameRate, frameCount, tags, truncated };
+}
+
+/** The tags from `start` to an End tag or `end`, as a sprite's or the file's. */
+export function readTags(
+  bytes: Uint8Array,
+  start: number,
+  end: number,
+): { tags: Tag[]; truncated: boolean } {
+  const tags: Tag[] = [];
+  const r = new SwfReader(bytes, start, end);
+  while (r.pos + 2 <= end) {
+    const codeAndLength = r.u16();
+    const code = codeAndLength >> 6;
+    let length = codeAndLength & 0x3f;
+    const long = length === 0x3f;
+    if (long) {
+      length = r.u32();
+    }
+
+    if (r.pos + length > end) {
+      tags.push({ code, offset: r.pos, length: Math.max(0, end - r.pos), long });
+      return { tags, truncated: true };
+    }
+
+    tags.push({ code, offset: r.pos, length, long });
+    r.pos += length;
+    if (code === End) {
+      break;
+    }
+  }
+
+  return { tags, truncated: false };
+}
+
+/** The background colour SetBackgroundColor sets, 0xRRGGBB, or white without one. */
+export function backgroundColor(swf: Swf): number {
+  const tag = swf.tags.find((t) => t.code === SetBackgroundColor);
+  if (!tag || tag.length < 3) {
+    return 0xffffff;
+  }
+
+  const b = swf.bytes;
+  return (b[tag.offset] << 16) | (b[tag.offset + 1] << 8) | b[tag.offset + 2];
+}
+
+/**
+ * The flags of a SWF file's FileAttributes, from the start of the file
+ * alone, as Flash Player reads them, FileAttributes being the first tag:
+ * 0 for a SWF whose first tag is another. For a host that must not
+ * decompress the whole of a SWF it does not trust, as a desktop shell
+ * choosing a local SWF's sandbox; ActionScript3 is 0x08, UseNetwork 0x01.
+ */
+export function fileAttributes(file: Uint8Array): number {
+  // The header's rect is 17 bytes at most, then the rate, count, and a long tag header.
+  const bytes = decompressSwfPrefix(file, 64);
+  try {
+    const r = new SwfReader(bytes, 8);
+    r.rect();
+    r.u16();
+    r.u16();
+    const head = r.u16();
+    if (head >> 6 !== FileAttributes) {
+      return 0;
+    }
+
+    if ((head & 0x3f) === 0x3f) {
+      r.u32();
+    }
+
+    return r.u8();
+  } catch {
+    return 0;
+  }
+}
+
+/** Whether FileAttributes marks the SWF as ActionScript 3; without the bit it is an AVM1 movie. */
+export function isAs3(swf: Swf): boolean {
+  const tag = swf.tags.find((t) => t.code === FileAttributes);
+  return !!tag && tag.length >= 1 && (swf.bytes[tag.offset] & 0x08) !== 0;
+}

package/src/tags.ts

@@ -0,0 +1,58 @@
+// SWF tag codes, as the specification numbers them. The player reads these
+// first; any other tag is kept by its code.
+export const End = 0;
+export const ShowFrame = 1;
+export const DefineShape = 2;
+export const PlaceObject = 4;
+export const RemoveObject = 5;
+export const DefineBits = 6;
+export const DefineButton = 7;
+export const JPEGTables = 8;
+export const SetBackgroundColor = 9;
+export const DefineFont = 10;
+export const DefineText = 11;
+export const DoAction = 12;
+export const DefineFontInfo = 13;
+export const DefineSound = 14;
+export const StartSound = 15;
+export const DefineButtonSound = 17;
+export const SoundStreamHead = 18;
+export const SoundStreamBlock = 19;
+export const DefineBitsLossless = 20;
+export const DefineBitsJPEG2 = 21;
+export const DefineShape2 = 22;
+export const DefineButtonCxform = 23;
+export const PlaceObject2 = 26;
+export const RemoveObject2 = 28;
+export const DefineShape3 = 32;
+export const DefineText2 = 33;
+export const DefineButton2 = 34;
+export const DefineBitsJPEG3 = 35;
+export const DefineBitsLossless2 = 36;
+export const DefineEditText = 37;
+export const DefineSprite = 39;
+export const FrameLabel = 43;
+export const SoundStreamHead2 = 45;
+export const DefineMorphShape = 46;
+export const DefineFont2 = 48;
+export const ExportAssets = 56;
+export const ScriptLimits = 65;
+export const DoInitAction = 59;
+export const DefineFontInfo2 = 62;
+export const FileAttributes = 69;
+export const PlaceObject3 = 70;
+export const DoABC = 72;
+export const DefineFontAlignZones = 73;
+export const CSMTextSettings = 74;
+export const DefineFont3 = 75;
+export const SymbolClass = 76;
+export const DefineScalingGrid = 78;
+export const DoABC2 = 82;
+export const DefineShape4 = 83;
+export const DefineMorphShape2 = 84;
+export const DefineSceneAndFrameLabelData = 86;
+export const DefineBinaryData = 87;
+export const StartSound2 = 89;
+export const DefineBitsJPEG4 = 90;
+export const DefineFont4 = 91;
+export const PlaceObject4 = 94;

package/src/text.ts

@@ -0,0 +1,213 @@
+// The text characters a SWF places on its timeline: editable text
+// (DefineEditText) and static text (DefineText, DefineText2).
+import { readString, utf8 } from "./display.js";
+import { type Matrix, readMatrix } from "./shape.js";
+import { type Rect, SwfReader, type Tag } from "./swf.js";
+import { DefineText2 } from "./tags.js";
+
+export interface EditText {
+  id: number;
+  bounds: Rect;
+  variable: string;
+  text: string;
+  color: number | null;
+  fontId: number | null;
+  fontClass: string | null;
+  fontHeight: number | null;
+  align: number;
+  leftMargin: number;
+  rightMargin: number;
+  indent: number;
+  leading: number;
+  maxLength: number | null;
+  wordWrap: boolean;
+  multiline: boolean;
+  password: boolean;
+  readOnly: boolean;
+  autoSize: boolean;
+  selectable: boolean;
+  border: boolean;
+  html: boolean;
+  useOutlines: boolean;
+}
+
+/** DefineEditText (tag 37), including every conditional field before its variable and text. */
+export function readEditText(bytes: Uint8Array, tag: Tag): EditText {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const id = r.u16();
+  const bounds = r.rect();
+  const flags = r.u8();
+  const flags2 = r.u8();
+  const hasText = (flags & 0x80) !== 0;
+  const hasFont = (flags & 0x01) !== 0;
+  const hasFontClass = (flags2 & 0x80) !== 0;
+  const fontId = hasFont ? r.u16() : null;
+  const fontClass = hasFontClass ? readString(r) : null;
+  const fontHeight = hasFont || hasFontClass ? r.u16() : null;
+  const color = flags & 0x04 ? r.u32() : null;
+  const maxLength = flags & 0x02 ? r.u16() : null;
+  let align = 0;
+  let leftMargin = 0;
+  let rightMargin = 0;
+  let indent = 0;
+  let leading = 0;
+  if (flags2 & 0x20) {
+    align = r.u8();
+    leftMargin = r.u16();
+    rightMargin = r.u16();
+    // Signed, as Flash reads it, though the specification says UI16: a hanging indent is negative.
+    indent = r.s16();
+    leading = r.s16();
+  }
+
+  return {
+    id,
+    bounds,
+    variable: readString(r),
+    text: hasText ? readString(r) : "",
+    color,
+    fontId,
+    fontClass,
+    fontHeight,
+    align,
+    leftMargin,
+    rightMargin,
+    indent,
+    leading,
+    maxLength,
+    wordWrap: (flags & 0x40) !== 0,
+    multiline: (flags & 0x20) !== 0,
+    password: (flags & 0x10) !== 0,
+    readOnly: (flags & 0x08) !== 0,
+    autoSize: (flags2 & 0x40) !== 0,
+    selectable: (flags2 & 0x10) === 0,
+    border: (flags2 & 0x08) !== 0,
+    html: (flags2 & 0x02) !== 0,
+    useOutlines: (flags2 & 0x01) !== 0,
+  };
+}
+
+/** A DefineFont2 or DefineFont3's name and style: what a field in it shows its text in, the glyphs left. */
+export interface FontName {
+  id: number;
+  name: string;
+  bold: boolean;
+  italic: boolean;
+}
+
+/** DefineFont2 (48) or DefineFont3 (75): the id, flags, language, then the name, a length-prefixed string. */
+export function readFontName(bytes: Uint8Array, tag: Tag): FontName {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const id = r.u16();
+  const flags = r.u8();
+  r.u8();
+  const length = r.u8();
+  const start = r.pos;
+  let end = Math.min(start + length, r.end);
+  // A trailing NUL, which some tools write, is no part of the name.
+  while (end > start && bytes[end - 1] === 0) {
+    end--;
+  }
+
+  const name = utf8(bytes.subarray(start, end));
+  return { id, name, bold: (flags & 0x01) !== 0, italic: (flags & 0x02) !== 0 };
+}
+
+/** A run of DefineText's glyphs: what its record sets, null where it keeps the run before's. */
+export interface TextRecord {
+  font: number | null;
+  /** 0xAARRGGBB; DefineText's opaque. */
+  color: number | null;
+  /** The pen's place, in twips. */
+  x: number | null;
+  y: number | null;
+  /** The glyphs' height, in twips; set with the font. */
+  height: number | null;
+  /** Each glyph's index into the font's glyphs, and the pen's advance after it, in twips. */
+  glyphs: { index: number; advance: number }[];
+}
+
+/** DefineText or DefineText2: static text, glyphs of embedded fonts placed by the authoring tool. */
+export interface StaticText {
+  id: number;
+  bounds: Rect;
+  matrix: Matrix;
+  records: TextRecord[];
+}
+
+/** DefineText (11) or DefineText2 (33, whose colours have alpha), up to its end record or the tag's end. */
+export function readStaticText(bytes: Uint8Array, tag: Tag): StaticText {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const alpha = tag.code === DefineText2;
+  const id = r.u16();
+  const bounds = r.rect();
+  const matrix = readMatrix(r);
+  const glyphBits = r.u8();
+  const advanceBits = r.u8();
+  const records: TextRecord[] = [];
+  for (;;) {
+    const flags = r.u8();
+    if (flags === 0 || r.overrun) {
+      break;
+    }
+
+    const font = flags & 0x08 ? r.u16() : null;
+    let color: number | null = null;
+    if (flags & 0x04) {
+      const red = r.u8();
+      const green = r.u8();
+      const blue = r.u8();
+      const a = alpha ? r.u8() : 255;
+      color = ((a << 24) | (red << 16) | (green << 8) | blue) >>> 0;
+    }
+
+    const x = flags & 0x01 ? r.s16() : null;
+    const y = flags & 0x02 ? r.s16() : null;
+    const height = font !== null ? r.u16() : null;
+    const count = r.u8();
+    const glyphs: { index: number; advance: number }[] = [];
+    for (let i = 0; i < count && !r.overrun; i++) {
+      glyphs.push({ index: r.ub(glyphBits), advance: r.sb(advanceBits) });
+    }
+
+    // A record the tag's end cuts off is left out, not read as zeros.
+    if (r.overrun) {
+      break;
+    }
+
+    r.align();
+    records.push({ font, color, x, y, height, glyphs });
+  }
+
+  return { id, bounds, matrix, records };
+}
+
+/** CSMTextSettings (74): how a text character is anti-aliased, as TextField's settings of the same names. */
+export interface CsmTextSettings {
+  id: number;
+  /** Advanced anti-aliasing (Saffron) rather than normal. */
+  useFlashType: boolean;
+  /** 0 none, 1 pixel, 2 subpixel. */
+  gridFit: number;
+  thickness: number;
+  sharpness: number;
+}
+
+export function readCsmTextSettings(bytes: Uint8Array, tag: Tag): CsmTextSettings {
+  const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+  const id = r.u16();
+  const flags = r.u8();
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const float = () => {
+    const at = r.pos;
+    r.pos += 4;
+    return at + 4 <= r.end ? view.getFloat32(at, true) : 0;
+  };
+  return {
+    id,
+    useFlashType: flags >> 6 === 1,
+    gridFit: (flags >> 3) & 7,
+    thickness: float(),
+    sharpness: float(),
+  };
+}