romdev-mcp 0.1.1

package/src/platforms/snes/brr.js

@@ -0,0 +1,208 @@
+// BRR encoder for SNES SPC700 samples.
+//
+// Bit-accurate against snes9x's SPC_DSP::decode_brr (see
+// snes9x/src/apu/bapu/dsp/SPC_DSP.cpp). Earlier versions of this file
+// guessed at the decode math from wiki descriptions and produced buzz —
+// real BRR encoding requires simulating the actual DSP at encode time
+// because:
+//   1. The DSP multiplies the decoded sample by 2 AFTER clamping to int16
+//      and re-wraps (`s = (int16_t)(s * 2)`). So values outside [-16384,
+//      +16383] wrap into noise. Encoder MUST keep reconstructed values
+//      inside that window.
+//   2. Filter prediction uses the PREVIOUS DECODED SAMPLES (post-clamp,
+//      post-doubling). Encoder must track p1/p2 state exactly the way
+//      the DSP will, or filters 1-3 produce drift.
+//   3. p2 is right-shifted by 1 before use in filters 2/3.
+//   4. The "decoded sample" stored as p1 is `s * 2 (wrapped int16)`,
+//      which is the final post-multiply value.
+//
+// Algorithm: brute-force every (filter 0..3, shift 0..12) combo per
+// block. For each combo, encode each sample by inverting the DSP formula
+// to get the ideal nibble, clamp to [-8,+7], then run the exact decode
+// to update p1/p2 and accumulate squared error. Pick the combo with the
+// lowest error and use that. The first block of any sample MUST use
+// filter 0 (no other choice has valid p1/p2 history).
+
+const BRR_BUF_DECODE = 16;  // samples per block
+
+/** snes9x CLAMP16: saturate to int16. */
+function clamp16(io) {
+  // The macro: if int16(io) != io, io = (io >> 31) ^ 0x7FFF
+  // i.e. if out of range, pick whichever signed-saturation matches the
+  // sign of the overflow.
+  const asI16 = (io << 16) >> 16;
+  if (asI16 !== io) {
+    return (io >> 31) ^ 0x7FFF;
+  }
+  return io;
+}
+
+/** Apply the DSP filter prediction. p1/p2 are post-clamp post-doubled prior decoded samples. */
+function applyFilter(filter, p1, p2) {
+  // p2 is read pre-shifted by 1 in the source code; we pass actual p2
+  // and divide here to match.
+  const p2h = p2 >> 1;
+  switch (filter) {
+    case 0: return 0;
+    case 1: // s += p1 + (-p1 >> 4)  →  ~p1 * 15/16
+      return p1 + ((-p1) >> 4);
+    case 2: // s += p1 + p1 + (p1*-3 >> 6) - p2h + (p2h >> 4)
+      return p1 + p1 + ((p1 * -3) >> 6) - p2h + (p2h >> 4);
+    case 3: // s += p1 + p1 + (p1*-13 >> 7) - p2h + (p2h*3 >> 4)
+      return p1 + p1 + ((p1 * -13) >> 7) - p2h + ((p2h * 3) >> 4);
+    default: return 0;
+  }
+}
+
+/**
+ * Decode one sample exactly as snes9x does, given the encoded nibble,
+ * shift, filter, and prior decoded samples p1/p2.
+ *
+ * Returns the new decoded sample (post-clamp, post-doubling, as int16).
+ */
+function decodeSample(nib, shift, filter, p1, p2) {
+  // sign-extend 4-bit (snes9x: `(int16_t)nybbles >> 12`)
+  let s = (nib & 0x08) ? (nib | 0xFFFFFFF0) : (nib & 0x0F);
+  if (shift <= 12) {
+    s = (s << shift) >> 1;
+  } else {
+    s = s & ~0x7FF;  // clears low 11 bits → 0 or 0xFFFFF800 (= -2048)
+  }
+  s += applyFilter(filter, p1, p2);
+  s = clamp16(s);
+  s = ((s * 2) << 16) >> 16;  // (int16_t)(s*2), wrapping
+  return s;
+}
+
+/**
+ * Encode 16-bit signed PCM (mono, little-endian s16) into BRR blocks.
+ *
+ * @param {Int16Array | Buffer} pcm  signed 16-bit samples, mono
+ * @param {{ loop?: boolean }} [opts]
+ *   loop: if true, set the LOOP bit on the final block so the sample
+ *         repeats. Default false (one-shot SFX).
+ * @returns {{ brr: Uint8Array, blocks: number, samples: number }}
+ */
+export function pcmToBrr(pcm, opts = {}) {
+  // Normalize input to Int16Array.
+  let samples;
+  if (pcm instanceof Int16Array) {
+    samples = pcm;
+  } else {
+    const buf = Buffer.isBuffer(pcm) ? pcm : Buffer.from(pcm);
+    samples = new Int16Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 2));
+  }
+
+  // The DSP's post-decode `*2` wraps int16, so reconstructed samples must
+  // stay inside [-16384, +16383] to not wrap into noise. Pre-scale the
+  // input to fit safely inside that envelope. Real BRR tools (BRRtools,
+  // snesbrr) do the same; the alternative is brutal high-amplitude buzz.
+  const SAFE_MAX = 16000;  // a hair under 16384 for filter-prediction headroom
+  let peak = 0;
+  for (let i = 0; i < samples.length; i++) {
+    const v = Math.abs(samples[i]);
+    if (v > peak) peak = v;
+  }
+  let scaled = samples;
+  if (peak > SAFE_MAX) {
+    const factor = SAFE_MAX / peak;
+    scaled = new Int16Array(samples.length);
+    for (let i = 0; i < samples.length; i++) {
+      scaled[i] = Math.round(samples[i] * factor);
+    }
+  }
+
+  // Pad up to a multiple of 16 samples so we emit whole blocks.
+  const padded = scaled.length % 16 === 0
+    ? scaled
+    : (() => {
+        const out = new Int16Array(scaled.length + (16 - scaled.length % 16));
+        out.set(scaled);
+        return out;
+      })();
+
+  const blockCount = padded.length / 16;
+  const brr = new Uint8Array(blockCount * 9);
+
+  // Running state — the decoder's p1/p2 (post-clamp post-doubled samples).
+  // Must match exactly across the encode so filters 1-3 stay in sync with
+  // what the DSP will reconstruct.
+  let p1 = 0;
+  let p2 = 0;
+
+  for (let b = 0; b < blockCount; b++) {
+    const blockStart = b * 16;
+    const isFirstBlock = b === 0;
+    const isLastBlock = b === blockCount - 1;
+
+    // Try every (filter, shift) combination; pick the one with lowest
+    // squared reconstruction error vs the source PCM. The first block of
+    // a sample MUST use filter 0 — filters 1-3 reference p1/p2 which are
+    // undefined at sample start (DSP fills them with whatever was there
+    // before KON, which we can't predict).
+    let bestError = Infinity;
+    let bestFilter = 0;
+    let bestShift = 0;
+    let bestNibbles = new Int8Array(16);
+    let bestP1 = p1, bestP2 = p2;
+
+    const filterRange = isFirstBlock ? [0] : [0, 1, 2, 3];
+    for (const filter of filterRange) {
+      for (let shift = 0; shift <= 12; shift++) {
+        let trialP1 = p1, trialP2 = p2;
+        let error = 0;
+        const nibs = new Int8Array(16);
+        for (let i = 0; i < 16; i++) {
+          const target = padded[blockStart + i];
+          // Want: decoded == target, where decoded comes from decodeSample.
+          // Invert the filter: ideal pre-filter value = target/2 - prediction
+          // (since the final step is s = (clamp16(s) * 2) & int16).
+          // We choose the nibble that minimizes |decoded - target|.
+          // Brute force all 16 nibble values — way cheaper than algebra
+          // and guaranteed correct against the DSP code.
+          let bestNib = 0;
+          let bestNibErr = Infinity;
+          for (let nib = -8; nib <= 7; nib++) {
+            const reconstructed = decodeSample(nib & 0x0F, shift, filter, trialP1, trialP2);
+            const diff = reconstructed - target;
+            const sq = diff * diff;
+            if (sq < bestNibErr) {
+              bestNibErr = sq;
+              bestNib = nib;
+            }
+          }
+          nibs[i] = bestNib;
+          const reconstructed = decodeSample(bestNib & 0x0F, shift, filter, trialP1, trialP2);
+          error += bestNibErr;
+          trialP2 = trialP1;
+          trialP1 = reconstructed;
+        }
+        if (error < bestError) {
+          bestError = error;
+          bestFilter = filter;
+          bestShift = shift;
+          bestNibbles = nibs;
+          bestP1 = trialP1;
+          bestP2 = trialP2;
+        }
+      }
+    }
+
+    // Commit the running state forward.
+    p1 = bestP1;
+    p2 = bestP2;
+
+    const header = ((bestShift & 0x0F) << 4)
+                 | ((bestFilter & 0x03) << 2)
+                 | (opts.loop && isLastBlock ? 0x02 : 0)
+                 | (isLastBlock ? 0x01 : 0);
+    brr[b * 9] = header;
+    for (let i = 0; i < 8; i++) {
+      const hi = bestNibbles[i * 2 + 0] & 0x0F;
+      const lo = bestNibbles[i * 2 + 1] & 0x0F;
+      brr[b * 9 + 1 + i] = (hi << 4) | lo;
+    }
+  }
+
+  return { brr, blocks: blockCount, samples: samples.length };
+}

package/src/platforms/snes/image-to-tilemap.js

@@ -0,0 +1,227 @@
+// SNES image-to-tilemap converter (4bpp / mode 1 BG1).
+//
+// Way simpler than the 2bpp version because we don't need per-cell palette
+// clustering: 16 colors per tile is enough that the WHOLE image fits in a
+// single 16-color global palette. Caller is expected to dither the source
+// to exactly 16 colors via imagemagick first; we just chop into tiles.
+//
+// Outputs:
+//   - chr      4bpp tile data, 32 bytes per 8x8 tile.
+//              Byte layout: first 16 bytes = planes 0+1 row-interleaved
+//              (row0p0, row0p1, row1p0, row1p1, ..., row7p1), then next
+//              16 bytes = planes 2+3 in the same order.
+//   - tilemap  2 bytes per cell × 32×32 cells = 2048 bytes. All entries
+//              use palette 0 (the only palette we populate).
+//   - palette  32 bytes (16 BGR555 colors, little-endian). Goes to CGRAM
+//              starting at index 0.
+
+import { PNG } from "pngjs";
+
+const W = 256;
+const H = 224;
+
+function rgbToBgr555(r, g, b) {
+  const r5 = (r >> 3) & 0x1F;
+  const g5 = (g >> 3) & 0x1F;
+  const b5 = (b >> 3) & 0x1F;
+  return (b5 << 10) | (g5 << 5) | r5;
+}
+
+/**
+ * @param {Object} args
+ * @param {Buffer | Uint8Array} args.pngBytes  256×224 PNG, ideally already
+ *   dithered to ≤16 colors via imagemagick.
+ * @returns {{
+ *   chr: Uint8Array,
+ *   tilemap: Uint8Array,
+ *   palette: Uint8Array,
+ *   uniqueTiles: number,
+ *   imageColors: number,
+ *   previewPng: Buffer,
+ * }}
+ */
+export function snesImageToTilemap(args) {
+  const png = PNG.sync.read(Buffer.from(args.pngBytes));
+  if (png.width !== W || png.height !== H) {
+    throw new Error(`SNES image must be ${W}×${H}, got ${png.width}×${png.height}`);
+  }
+
+  // 1) Convert every pixel to BGR555. Collect the up-to-16 distinct colors.
+  // Color 0 = whichever appears as the FIRST pixel (top-left), which makes
+  // the universal backdrop deterministic — imagemagick's quantizer puts the
+  // most-common color at index 0 in its output palette anyway.
+  /** @type {Map<number, number>} BGR555 → palette index 0..15 */
+  const colorIndex = new Map();
+  const pxIdx = new Uint8Array(W * H);
+  for (let i = 0; i < W * H; i++) {
+    const k = i * 4;
+    const c = rgbToBgr555(png.data[k], png.data[k + 1], png.data[k + 2]);
+    let idx = colorIndex.get(c);
+    if (idx === undefined) {
+      idx = colorIndex.size;
+      if (idx >= 16) {
+        throw new Error(
+          `SNES 4bpp requires ≤16 distinct colors; image has more. Use \`magick … -colors 16 -dither FloydSteinberg\` first.`
+        );
+      }
+      colorIndex.set(c, idx);
+    }
+    pxIdx[i] = idx;
+  }
+
+  // 2) Build 32-byte palette: 16 colors × 2 bytes (BGR555 little-endian).
+  // Slot 0 (backdrop) is the first color we saw.
+  const palette = new Uint8Array(32);
+  for (const [c, idx] of colorIndex) {
+    palette[idx * 2 + 0] = c & 0xFF;
+    palette[idx * 2 + 1] = (c >> 8) & 0xFF;
+  }
+
+  // 3) Encode each 8×8 tile in 4bpp format and dedupe identical bitmaps.
+  const tilesAcross = W / 8;   // 32
+  const tilesDown = H / 8;     // 28
+
+  const makeTile = (tx, ty) => {
+    const t = new Uint8Array(32);
+    for (let yy = 0; yy < 8; yy++) {
+      let p0 = 0, p1 = 0, p2 = 0, p3 = 0;
+      for (let xx = 0; xx < 8; xx++) {
+        const c = pxIdx[(ty * 8 + yy) * W + (tx * 8 + xx)];
+        if (c & 1) p0 |= 1 << (7 - xx);
+        if (c & 2) p1 |= 1 << (7 - xx);
+        if (c & 4) p2 |= 1 << (7 - xx);
+        if (c & 8) p3 |= 1 << (7 - xx);
+      }
+      // SNES 4bpp tile layout — confirmed by trial:
+      // Row Y uses 4 bytes: planes 0+1+2+3 interleaved at offsets:
+      //   yy*2+0     plane 0 (LSB)
+      //   yy*2+1     plane 1
+      //   16+yy*2+0  plane 2
+      //   16+yy*2+1  plane 3 (MSB)
+      t[yy * 2 + 0] = p0;
+      t[yy * 2 + 1] = p1;
+      t[16 + yy * 2 + 0] = p2;
+      t[16 + yy * 2 + 1] = p3;
+    }
+    return t;
+  };
+
+  /** @type {Uint8Array[]} */
+  const tileList = [];
+  const tileMap = new Map();
+  // Tilemap is 32×32 entries (2 bytes each) = 2048 bytes. Visible area is
+  // 32×28; bottom 4 rows stay as tile 0 (no-op).
+  const tilemap = new Uint8Array(32 * 32 * 2);
+  for (let ty = 0; ty < tilesDown; ty++) {
+    for (let tx = 0; tx < tilesAcross; tx++) {
+      const t = makeTile(tx, ty);
+      const key = Buffer.from(t).toString("hex");
+      let idx = tileMap.get(key);
+      if (idx === undefined) {
+        idx = tileList.length;
+        tileList.push(t);
+        tileMap.set(key, idx);
+      }
+      // Tilemap word: bits 0-9 tile index, bits 11-13 palette (we use 0).
+      const entry = idx & 0x3FF;
+      const off = (ty * 32 + tx) * 2;
+      tilemap[off + 0] = entry & 0xFF;
+      tilemap[off + 1] = (entry >> 8) & 0xFF;
+    }
+  }
+
+  // Hard fail past 1024 tiles (max BG1 can address).
+  if (tileList.length > 1024) {
+    throw new Error(`SNES 4bpp BG1 can address 1024 tiles; image needs ${tileList.length}.`);
+  }
+
+  const chr = Buffer.concat(tileList.map((t) => Buffer.from(t)));
+
+  // 4) Preview PNG (render from CHR + tilemap + palette).
+  const preview = new PNG({ width: W, height: H });
+  const palRgb = new Array(16);
+  for (const [c, idx] of colorIndex) {
+    const r = ((c >> 0) & 0x1F) << 3;
+    const g = ((c >> 5) & 0x1F) << 3;
+    const b = ((c >> 10) & 0x1F) << 3;
+    palRgb[idx] = [r, g, b];
+  }
+  for (let ty = 0; ty < tilesDown; ty++) {
+    for (let tx = 0; tx < tilesAcross; tx++) {
+      const off = (ty * 32 + tx) * 2;
+      const entry = tilemap[off] | (tilemap[off + 1] << 8);
+      const tileIdx = entry & 0x3FF;
+      const tile = tileList[tileIdx];
+      for (let yy = 0; yy < 8; yy++) {
+        const p0 = tile[yy * 2 + 0];
+        const p1 = tile[yy * 2 + 1];
+        const p2 = tile[16 + yy * 2 + 0];
+        const p3 = tile[16 + yy * 2 + 1];
+        for (let xx = 0; xx < 8; xx++) {
+          const ci =
+            ((p0 >> (7 - xx)) & 1) |
+            (((p1 >> (7 - xx)) & 1) << 1) |
+            (((p2 >> (7 - xx)) & 1) << 2) |
+            (((p3 >> (7 - xx)) & 1) << 3);
+          const [r, g, b] = palRgb[ci];
+          const i = ((ty * 8 + yy) * W + (tx * 8 + xx)) * 4;
+          preview.data[i] = r;
+          preview.data[i + 1] = g;
+          preview.data[i + 2] = b;
+          preview.data[i + 3] = 255;
+        }
+      }
+    }
+  }
+  const previewPng = PNG.sync.write(preview);
+
+  return {
+    chr,
+    tilemap,
+    palette,
+    uniqueTiles: tileList.length,
+    imageColors: colorIndex.size,
+    previewPng,
+  };
+}
+
+/**
+ * Emit a 16-color sample SNES palette PNG (useful as imagemagick -remap
+ * target). For SNES we generally want imagemagick to PICK its own 16
+ * colors via `-colors 16`, then quantize within those — there's no
+ * "canonical 16 SNES greys" the way the NES has a fixed master palette.
+ *
+ * We provide a generic vibrant 16-color palette as a default. Caller can
+ * override by using their own remap PNG.
+ */
+export function snesPalettePng() {
+  // 16 well-spaced colors covering the BGR555 gamut.
+  const cs = [
+    [0, 0, 0],
+    [128, 128, 128],
+    [255, 255, 255],
+    [128, 0, 0],
+    [255, 0, 0],
+    [255, 128, 0],
+    [255, 255, 0],
+    [0, 128, 0],
+    [0, 255, 0],
+    [0, 128, 128],
+    [0, 255, 255],
+    [0, 0, 128],
+    [0, 0, 255],
+    [128, 0, 128],
+    [255, 0, 255],
+    [128, 64, 0],
+  ];
+  const png = new PNG({ width: 16, height: 1 });
+  for (let i = 0; i < 16; i++) {
+    const [r, g, b] = cs[i];
+    const k = i * 4;
+    png.data[k] = r;
+    png.data[k + 1] = g;
+    png.data[k + 2] = b;
+    png.data[k + 3] = 255;
+  }
+  return PNG.sync.write(png);
+}

package/src/platforms/snes/lib/audio/apu_blob.asm

@@ -0,0 +1,228 @@
+; ── apu_blob.asm ── SPC700 driver + sample-bank + music assembler ───
+;
+; This file is the top-level asar input for building apu_blob.bin (the
+; payload the SNES uploads into SPC700 ARAM at $0200).
+;
+; ARAM layout produced (R46):
+;   $0200..$02xx    driver code   (~230 bytes — sfx + music engine)
+;   $02xx..$0FFF    padding       (zero-filled by org)
+;   $1000..$2417    sample bank   (5656 bytes — directory + BRR samples)
+;     of which:
+;       $1000..$100F  sample directory (4-byte entries × 2 samples + filler)
+;       $1100..$1807  shoot.brr      (1800 bytes)
+;       $1808..$261B  explosion.brr  (3600 bytes)
+;   $2618..$4FFF    padding       (zero-filled)
+;   $5000..$50xx    music data    (3 bytes per row × N rows, $00 terminator)
+;
+; The driver code below is duplicated from spc_driver.asm so this file
+; can be assembled standalone by asar (asar 1.91 has trouble with
+; `incsrc` inside `arch spc700` blocks). If you change spc_driver.asm,
+; mirror the changes here.
+
+arch spc700
+norom
+org $0000
+base $0200
+
+; ── Driver code at $0200 ───────────────────────────────────────────
+start:
+  mov $f2, #$6c
+  mov $f3, #$20
+
+  mov $f2, #$0d
+  mov $f3, #$00
+  mov $f2, #$2c
+  mov $f3, #$00
+  mov $f2, #$3c
+  mov $f3, #$00
+  mov $f2, #$4d
+  mov $f3, #$00
+  mov $f2, #$6d
+  mov $f3, #$00
+  mov $f2, #$7d
+  mov $f3, #$00
+
+  mov $f2, #$5d
+  mov $f3, #$10
+
+  mov $f2, #$0c
+  mov $f3, #$7f
+  mov $f2, #$1c
+  mov $f3, #$7f
+
+  mov $f2, #$00
+  mov $f3, #$7f
+  mov $f2, #$01
+  mov $f3, #$7f
+
+  mov $f2, #$02
+  mov $f3, #$00
+  mov $f2, #$03
+  mov $f3, #$10
+
+  mov $f2, #$05
+  mov $f3, #$00
+  mov $f2, #$06
+  mov $f3, #$00
+  mov $f2, #$07
+  mov $f3, #$7f
+
+  ; Voice 1 vol (music)
+  mov $f2, #$10
+  mov $f3, #$50
+  mov $f2, #$11
+  mov $f3, #$50
+
+  ; Voice 1 ADSR off, GAIN $5F
+  mov $f2, #$15
+  mov $f3, #$00
+  mov $f2, #$16
+  mov $f3, #$00
+  mov $f2, #$17
+  mov $f3, #$5f
+
+  ; Timer 0 setup: target $80 -> ~62.5 Hz
+  mov $fa, #$80
+  mov $f1, #$01
+  mov a, $fd
+
+  ; State init
+  mov a, $f4
+  mov $00, a
+  mov $01, #$00
+  mov $02, #$00
+  mov $03, #$50
+  mov $04, #$00
+
+main_loop:
+  mov a, $f4
+  cmp a, $00
+  beq cmd_done
+  mov $00, a
+  cmp a, #$01
+  beq play_shoot
+  cmp a, #$02
+  beq play_explosion
+  cmp a, #$03
+  beq music_start
+  cmp a, #$04
+  beq music_stop
+
+cmd_done:
+  mov a, $01
+  beq main_loop
+  mov a, $fd
+  beq main_loop
+  mov a, $04
+  beq music_next_row
+  dec a
+  mov $04, a
+  bra main_loop
+
+play_shoot:
+  mov $f2, #$04
+  mov $f3, #$00
+  mov $f2, #$4c
+  mov $f3, #$01
+  bra cmd_done
+
+play_explosion:
+  mov $f2, #$04
+  mov $f3, #$01
+  mov $f2, #$4c
+  mov $f3, #$01
+  bra cmd_done
+
+music_start:
+  mov $02, #$00
+  mov $03, #$50
+  mov $04, #$00
+  mov $01, #$01
+  bra cmd_done
+
+music_stop:
+  mov $01, #$00
+  mov $f2, #$5c
+  mov $f3, #$02
+  mov $f2, #$5c
+  mov $f3, #$00
+  bra cmd_done
+
+music_next_row:
+  mov y, #$00
+  mov a, ($02)+y
+  cmp a, #$00
+  beq music_loop_end
+  mov $04, a
+
+  mov y, #$01
+  mov a, ($02)+y
+  mov $f2, #$12
+  mov $f3, a
+
+  mov y, #$02
+  mov a, ($02)+y
+  mov $f2, #$13
+  mov $f3, a
+
+  mov $f2, #$14
+  mov $f3, #$00
+
+  mov $f2, #$4c
+  mov $f3, #$02
+
+  mov a, $02
+  clrc
+  adc a, #$03
+  mov $02, a
+  mov a, $03
+  adc a, #$00
+  mov $03, a
+  jmp main_loop
+
+music_loop_end:
+  mov $02, #$00
+  mov $03, #$50
+  jmp music_next_row
+
+; ── Sample bank at $1000 ───────────────────────────────────────────
+; file-offset $0E00 = ARAM $1000 - base $0200. Asar 1.91 mis-handles
+; the arithmetic form `$1000 - $200`, so we hardcode the literal.
+org $0E00
+base $1000
+incbin "sample_bank.bin"
+
+; ── Music data at $5000 ────────────────────────────────────────────
+; file-offset $4E00 = ARAM $5000 - base $0200. sample_bank.bin is
+; 5656 bytes ($1618), so it ends at file offset $2417 (ARAM $2618).
+; Padding bytes from $2417..$4DFF will be zero-filled by the next org.
+;
+; Format: each row = [duration_ticks, pitch_lo, pitch_hi].
+; Tick rate is ~62.5 Hz, so duration $10 ≈ 256 ms (an eighth-note at
+; ~115 BPM). Terminator: a single $00 byte (duration 0) → loop.
+;
+; Melody is a 16-step ascending/descending C-major-ish run over a
+; non-looping BRR sample — the shoot.brr is short so each "note" is
+; really a re-trigger of the sample at a different playback rate.
+; It sounds like a chirpy chiptune arpeggio, which is exactly the
+; vibe we want for a minimum-viable music demo.
+org $4E00
+base $5000
+song:
+  db $10, $00, $04        ; pitch $0400
+  db $10, $80, $04        ; pitch $0480
+  db $10, $00, $05        ; pitch $0500
+  db $10, $80, $05        ; pitch $0580
+  db $10, $00, $06        ; pitch $0600
+  db $10, $00, $07        ; pitch $0700
+  db $10, $00, $08        ; pitch $0800
+  db $10, $00, $0A        ; pitch $0A00
+  db $10, $00, $08
+  db $10, $00, $07
+  db $10, $00, $06
+  db $10, $80, $05
+  db $10, $00, $05
+  db $10, $80, $04
+  db $10, $00, $04
+  db $10, $80, $03        ; pitch $0380 — slight bass note
+  db $00                  ; loop marker