romdevtools 0.71.1 → 0.84.0

package/src/playtest/playtest.js

@@ -6,8 +6,10 @@ import {
   RETRO_PIXEL_FORMAT_0RGB1555,
   RETRO_PIXEL_FORMAT_RGB565,
   RETRO_PIXEL_FORMAT_XRGB8888,
+  ROMDEV_PIXEL_FORMAT_RGBA8888,
 } from "../host/retroConstants.js";
 import { log } from "../mcp/log.js";
+import { initResampler, resampleS16Stereo } from "./resampler/index.mjs";
 import path from "node:path";
 import { existsSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
 import { execFile } from "node:child_process";
@@ -203,10 +205,39 @@ const SDL_BUTTON_TO_LIBRETRO_BIT = {
   back: 2,      // SELECT
   guide: 2,
   start: 3,
-  leftShoulder: 10,
-  rightShoulder: 11,
-  leftStick: 14,
-  rightStick: 15,
+  leftShoulder: 10,   // RETRO L
+  rightShoulder: 11,  // RETRO R
+  leftStick: 14,      // RETRO L3
+  rightStick: 15,     // RETRO R3
+  // NOTE: L2/R2 (bits 12/13) are ANALOG triggers in libretro — node-sdl exposes
+  // them as axes (leftTrigger/rightTrigger), not buttons, so they're read from
+  // inst.axes below, not here.
+};
+
+// N64-specific pad map. parallel_n64's RetroPad layout (its digital_cbuttons_map)
+// is NOT the generic NES/SNES one — RETRO B="N64 A", RETRO Y="N64 B", RETRO X/A/L/R
+// are the four C-buttons, RETRO Select="N64 L", RETRO R2="N64 R", RETRO L2="N64 Z".
+// The N64's Z/L/R are DIGITAL buttons (its analog triggers don't exist), so on a
+// modern pad they go on the SHOULDER buttons, NOT the analog triggers (which idle
+// half-pressed and would stick). Layout for a standard X360-style pad:
+//   Xbox A (bottom) = N64 A   (accelerate)
+//   Xbox B (right)  = N64 B   (brake)
+//   Xbox X (left)   = N64 Z   (FIRE ITEM)  ← a free face button, easy to reach
+//   Xbox Y (top)    = N64 B   (alias, so either right/top brakes)
+//   L shoulder      = N64 L
+//   R shoulder      = N64 R   (hop / drift)
+//   right stick     = the four C-buttons (in readControllerInto)
+//   left stick/dpad = N64 analog stick (via the dpad→ANALOG synth in callbacks.js)
+const SDL_BUTTON_TO_LIBRETRO_BIT_N64 = {
+  dpadUp: 4, dpadDown: 5, dpadLeft: 6, dpadRight: 7,  // N64 d-pad (literal)
+  a: 0,               // Xbox A (bottom) → RETRO B  = N64 A   (accelerate)
+  b: 1,               // Xbox B (right)  → RETRO Y  = N64 B   (brake)
+  y: 1,               // Xbox Y (top)    → RETRO Y  = N64 B   (alias)
+  x: 12,              // Xbox X (left)   → RETRO L2 = N64 Z   (FIRE ITEM)
+  start: 3,           // Start
+  leftShoulder: 2,    // L shoulder → RETRO Select = N64 L
+  rightShoulder: 13,  // R shoulder → RETRO R2     = N64 R   (hop/drift)
+  // C-buttons (RETRO X/A/L/R) come from the RIGHT STICK in readControllerInto.
 };
 
 // Analog stick → dpad direction (for games that only read dpad)
@@ -479,12 +510,22 @@ export async function playtest(args) {
   }
 
   // Open the window.
+  //
+  // HW-render cores (n64/ps1/dreamcast) already own a GL context via native-gles
+  // (the EGL pbuffer the core renders its RDP/GPU into; we glReadPixels it to CPU
+  // pixels). If the SDL window ALSO requests an accelerated (GL) renderer, node-sdl
+  // calls glXMakeCurrent on the same X display and the two GL contexts collide →
+  // `X Error BadAccess (GLX X_GLXMakeCurrent)`, crashing the process. The window only
+  // ever presents CPU pixels (window.render(..., "rgba32", rgba)), so it does NOT need
+  // its own GL context — open a SOFTWARE-blit window for HW-render cores to avoid the
+  // context fight. Software cores keep the accelerated path (faster upscale blit).
+  const hwRenderCore = !!host.hwRender;
   const window = sdl.video.createWindow({
     title,
     width: winInitW,
     height: winInitH,
     resizable: true,
-    accelerated: true,
+    accelerated: hwRenderCore ? false : true,
     vsync: false,
   });
   log.debug(`[playtest] window opened: ${winInitW}x${winInitH}, fb=${fbWidth}x${fbHeight}, aspect=${aspectMode}`);
@@ -494,16 +535,38 @@ export async function playtest(args) {
   // Mismatched rates produce choppy/sped-up/cracking playback because the
   // SDL device consumes samples at the wrong rate, alternately starving
   // (clicks) and overflowing.
+  //
+  // EXCEPTION — very-low-rate cores (the GameTank ACP emits ~13983 Hz, 3x lower
+  // than anything else): SDL's device buffer granularity (thousands of samples)
+  // dwarfs a 60 fps core's ~233-sample-per-frame chunks at that rate, so the
+  // device starves between ticks = clicks and pops. (RetroArch avoids this with
+  // a sinc resampler + dynamic rate control to the device rate.) So for low
+  // rates we open the device at 48 kHz and LINEAR-RESAMPLE each chunk up to it,
+  // which makes the per-frame chunks big enough for clean playback.
   let audio = null;
   const coreSampleRate = Math.round(host.status.audioSampleRate ?? 48000);
+  const AUDIO_RESAMPLE_TO = 48000;
+  let needsResample = coreSampleRate > 0 && coreSampleRate < 24000;
+  // Load the WASM+SIMD resampler if this core needs upsampling. If it fails to
+  // load, fall back to opening the device at the native rate (better than no
+  // audio) — needsResample is forced off so we never call a missing resampler.
+  if (needsResample) {
+    const ready = await initResampler();
+    if (!ready) {
+      log.error("[playtest] resampler WASM failed to load — using native rate (audio may click)");
+      needsResample = false;
+    }
+  }
+  const deviceSampleRate = needsResample ? AUDIO_RESAMPLE_TO : coreSampleRate;
   try {
     audio = sdl.audio.openDevice({ type: "playback" }, {
       channels: 2,
-      frequency: coreSampleRate,
+      frequency: deviceSampleRate,
       format: "s16",
     });
     audio.play();
-    log.debug(`[playtest] audio: ${coreSampleRate} Hz, stereo, s16`);
+    log.debug(`[playtest] audio: ${deviceSampleRate} Hz, stereo, s16` +
+      (needsResample ? ` (resampled from core ${coreSampleRate} Hz)` : ""));
   } catch (e) {
     log.error("[playtest] audio init failed (continuing silent):", e.message);
   }
@@ -688,7 +751,15 @@ export async function playtest(args) {
 
   // Tick = one emulated frame + render + audio drain. Driven by setInterval
   // so the Node event loop stays free for MCP requests on the same host.
-  const frameMs = 1000 / 60;
+  // Pace to the CORE's native refresh rate (status.coreFps), not a hardcoded 60: a
+  // 30fps title (Sonic Adventure on flycast) at a 60Hz tick gets double-ticked —
+  // wasting half the budget and, on the heavy interpreter-only DC core (23ms/frame,
+  // no JIT), falling behind every tick → the black-flash/glitch. At its real 30fps
+  // each frame gets a full 33ms tick, which the core can actually hit. Clamped so a
+  // bogus report can't run the window absurdly fast or slow.
+  const coreFps = openHost?.status?.coreFps;
+  const fps = (coreFps >= 20 && coreFps <= 120) ? coreFps : 60;
+  const frameMs = 1000 / fps;
 
   function tick() {
     if (!running || window.destroyed) { stop(); return; }
@@ -704,7 +775,12 @@ export async function playtest(args) {
     // the N-second cadence; serialize off the live host so it captures the human's
     // exact progress. Skipped while paused (nothing changed) and on the very first
     // ticks (let the core settle).
-    if (checkpointPath && tickCount - lastCheckpointTick >= checkpointEverySec * 60 && !h.status.paused) {
+    // Auto-checkpoint serializes the WHOLE machine state — cheap for 8/16-bit (KB,
+    // instant) but BRUTAL for the hwRender 3D cores (DC/N64 savestate ≈16MB, ~18ms
+    // to serialize), which would freeze the window for ~18ms every cadence on an
+    // already-slow core. Skip it entirely for hwRender — same call as the rewind
+    // buffer skip. (Eviction recovery matters less than a playable window here.)
+    if (!h.hwRender && checkpointPath && tickCount - lastCheckpointTick >= checkpointEverySec * 60 && !h.status.paused) {
       lastCheckpointTick = tickCount;
       writeCheckpoint(h, "auto");
     }
@@ -726,6 +802,7 @@ export async function playtest(args) {
     // window leaves it alone. Select+Start on any controller quits.
     let quit = false;
     const isC64 = h.status?.platform === "c64";
+    const isN64 = h.status?.platform === "n64";
     function readControllerInto(port, inst) {
       if (!inst) return;
       const btn = inst.buttons || {};
@@ -733,7 +810,8 @@ export async function playtest(args) {
         quit = true;
         return;
       }
-      for (const [sdlName, bit] of Object.entries(SDL_BUTTON_TO_LIBRETRO_BIT)) {
+      const buttonMap = isN64 ? SDL_BUTTON_TO_LIBRETRO_BIT_N64 : SDL_BUTTON_TO_LIBRETRO_BIT;
+      for (const [sdlName, bit] of Object.entries(buttonMap)) {
         if (btn[sdlName]) port[bitToName(bit)] = true;
       }
       const axes = inst.axes || {};
@@ -743,6 +821,9 @@ export async function playtest(args) {
       else if (lx < -STICK_DEADZONE) port.left = true;
       if (ly > STICK_DEADZONE) port.down = true;
       else if (ly < -STICK_DEADZONE) port.up = true;
+      // NOTE: the analog triggers are NOT used for N64 — its Z/L/R are digital and
+      // map to the SHOULDER buttons (see SDL_BUTTON_TO_LIBRETRO_BIT_N64). (node-sdl's
+      // X360 trigger axes also idle at ~0.5, so reading them as buttons would stick.)
       // C64: the RIGHT stick selects the function keys (F1/F3/F5/F7) — the
       // Batocera/RetroDeck convention so a controller alone reaches the keyboard
       // keys C64 setup screens need. Emitted as virtual buttons the host's C64
@@ -755,6 +836,19 @@ export async function playtest(args) {
         if (rx < -STICK_DEADZONE) port.c64_f3 = true;        // left  → F3
         else if (rx > STICK_DEADZONE) port.c64_f5 = true;    // right → F5
       }
+      // N64: the RIGHT stick drives the four C-buttons — the standard emulation
+      // convention so a modern dual-stick pad plays N64 naturally (left stick =
+      // analog stick via the d-pad synthesis in callbacks.js; right stick = C). The
+      // C-buttons land on libretro bits A/X/L/R, which parallel_n64 reads as
+      // C-Down/C-Up/C-Left/C-Right. Z is the left trigger (mapped above).
+      if (isN64) {
+        const rx = axes.rightStickX ?? 0;
+        const ry = axes.rightStickY ?? 0;
+        if (ry < -STICK_DEADZONE) port.x = true;        // up    → C-Up    (RETRO X)
+        else if (ry > STICK_DEADZONE) port.a = true;    // down  → C-Down  (RETRO A)
+        if (rx < -STICK_DEADZONE) port.l = true;        // left  → C-Left  (RETRO L)
+        else if (rx > STICK_DEADZONE) port.r = true;    // right → C-Right (RETRO R)
+      }
     }
 
     const port0 = {};
@@ -792,8 +886,14 @@ export async function playtest(args) {
       // either port)?
       const humanPressing = anyButtonHeld(port0) || anyButtonHeld(port1);
       humanInput.note(humanPressing, tickCount);
-      // Capture snapshot before stepping so R can rewind to it later.
-      if (h.status?.loaded) {
+      // Capture snapshot before stepping so R can rewind to it later. SKIP for
+      // hwRender cores (n64/ps1/dreamcast): their savestates are HUGE (N64 ≈16MB
+      // each — 600 frames would be ~9GB of RAM) and serializeState costs ~8ms/frame
+      // there, eating half the 16.6ms budget and starving the audio feed (the choppy
+      // playback). The R-key rewind is a nicety, not worth that on the 3D engines —
+      // pause + savestate still work for those. (Rewind buffer is playtest-only; it's
+      // NOT part of the debug ABI, so dropping it on these cores changes nothing else.)
+      if (h.status?.loaded && !h.hwRender) {
         try {
           const snap = h.serializeState();
           rewindBuffer.push(snap);
@@ -810,9 +910,39 @@ export async function playtest(args) {
         h.setInput({ ports: [port0, port1] });
         humanInputDirty = humanPressing;
       }
+      // AUDIO-PACED stepping, BUDGETED BY WALL-CLOCK. We catch the buffer up by
+      // stepping extra frames per tick to keep SDL's queue topped — but a fast core
+      // (n64 2.4ms/frame) and a SUB-REALTIME core (flycast DC ~60ms/frame) need very
+      // different burst sizes. A fixed MAX_STEPS frame-count cap is the trap: 8 frames
+      // is 19ms on n64 (fine) but 480ms on DC — which BLOCKS the Node event loop for
+      // half a second per tick, so the window can't repaint and audio drains dry →
+      // "breaks down, super choppy" death spiral that never recovers. The fix is to
+      // cap by TIME: keep stepping only while we're under a wall-clock budget (~1.5
+      // ticks). A sub-realtime core then runs steady-slow (audio underruns gracefully,
+      // a constant low pitch) instead of stuttering — and the loop ALWAYS yields the
+      // event loop promptly so the window stays responsive.
       let stepped = 0;
       try {
-        stepped = h.stepFrames(1);
+        if (audio && deviceSampleRate > 0) {
+          const bps = deviceSampleRate * 4; // stereo s16
+          const TARGET_MS = 60;             // keep ~60ms queued — drain sets the speed
+          const BUDGET_MS = frameMs * 1.5;  // wall-clock ceiling for the whole burst
+          const burstStart = performance.now();
+          do {
+            stepped += h.stepFrames(1);
+            // Stop the instant we've spent our wall-clock budget — this is what keeps
+            // a slow core from freezing the loop. A single frame already over budget
+            // still steps once (progress), then we yield.
+            if (performance.now() - burstStart >= BUDGET_MS) break;
+            const qMs = ((audio.queued ?? 0) / bps) * 1000;
+            let ringMs = 0;
+            for (const b of h.state.audioRing) ringMs += (b.length / 2);
+            ringMs = (ringMs / deviceSampleRate) * 1000;
+            if (qMs + ringMs >= TARGET_MS) break;
+          } while (true);
+        } else {
+          stepped = h.stepFrames(1); // no audio device → plain 1 frame/tick
+        }
       } catch (e) {
         // A step error mid-swap (host being torn down/rebuilt) is transient —
         // skip this frame and let the next tick pick up the new host. Don't kill
@@ -879,17 +1009,16 @@ export async function playtest(args) {
     }
 
     if (running && audio && h.state.audioRing.length > 0) {
-      // SDL device tells us how many bytes are still queued (not yet played).
-      // If we get >200ms ahead, the player got a stutter and is now
-      // building latency — drop new samples until the queue drains back
-      // to ~50ms. This keeps audio synced to wall clock without underruns.
-      // Wrap the whole block in try/catch — stop() may have closed the
-      // audio device between the running check and the access below.
+      // Enqueue the real audio the core produced this tick. The AUDIO-PACED stepping
+      // above already steps however many frames are needed to keep ~60ms queued, so
+      // the buffer stays full from REAL samples — no silence padding, no rate-deficit
+      // starvation. SDL's steady drain at the device rate is what sets emulation speed.
+      // We only stop enqueuing if latency runs away (>250ms) — a safety valve, not
+      // the normal path.
       try {
-        const bytesPerSecond = coreSampleRate * 2 /* ch */ * 2 /* s16 */;
-        const queuedBytes = audio.queued ?? 0;
-        const queuedMs = (queuedBytes / bytesPerSecond) * 1000;
-        if (queuedMs < 200) {
+        const bytesPerSecond = deviceSampleRate * 2 /* ch */ * 2 /* s16 */;
+        const queuedMs = ((audio.queued ?? 0) / bytesPerSecond) * 1000;
+        if (queuedMs < 250) {
           let total = 0;
           for (const buf of h.state.audioRing) total += buf.byteLength;
           const merged = Buffer.alloc(total);
@@ -898,14 +1027,15 @@ export async function playtest(args) {
             merged.set(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength), off);
             off += buf.byteLength;
           }
-          audio.enqueue(merged);
+          audio.enqueue(needsResample
+            ? resampleS16Stereo(merged, coreSampleRate, deviceSampleRate)
+            : merged);
         }
       } catch (e) {
         if (!e.message?.includes("closed")) {
           log.error("[playtest] audio enqueue error:", e.message);
         }
       }
-      // Always clear the ring — if we skipped enqueue we drop those samples.
       h.state.audioRing.length = 0;
     }
   }
@@ -992,7 +1122,25 @@ function bitToName(bit) {
 /** Convert libretro framebuffer (any pixel format) to RGBA32. */
 function framebufferToRgba(f) {
   const out = Buffer.alloc(f.width * f.height * 4);
-  if (f.format === RETRO_PIXEL_FORMAT_XRGB8888) {
+  if (f.format === ROMDEV_PIXEL_FORMAT_RGBA8888) {
+    // HW-render readback (n64/ps1/dreamcast via native-gles): pixels are ALREADY
+    // RGBA in row order. Copy straight through but FORCE alpha=255 — the GL render
+    // target leaves alpha=0 (unused channel), which SDL would composite as fully
+    // transparent → a black window. This is the on-screen analogue of the same
+    // alpha fix framebufferToRgba() in framebuffer.js does for screenshots.
+    for (let y = 0; y < f.height; y++) {
+      const src = y * f.pitch;
+      const dst = y * f.width * 4;
+      for (let x = 0; x < f.width; x++) {
+        const s = src + x * 4;
+        const d = dst + x * 4;
+        out[d + 0] = f.pixels[s + 0];
+        out[d + 1] = f.pixels[s + 1];
+        out[d + 2] = f.pixels[s + 2];
+        out[d + 3] = 0xff;
+      }
+    }
+  } else if (f.format === RETRO_PIXEL_FORMAT_XRGB8888) {
     for (let y = 0; y < f.height; y++) {
       const src = y * f.pitch;
       const dst = y * f.width * 4;

package/src/playtest/resampler/build.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Build the WASM+SIMD audio resampler for the playtest sink.
+# Mirrors simdpipe's emcc style (-O3 -msimd128, MODULARIZE ES6). Single-thread,
+# small heap (audio chunks are a few KB). Output: resampler.mjs + resampler.wasm.
+set -euo pipefail
+cd "$(dirname "$0")"
+
+source "$HOME/code/mine/emsdk/emsdk_env.sh" >/dev/null 2>&1 || true
+
+emcc resampler.c \
+  -O3 -msimd128 -ffast-math \
+  -s WASM=1 -s MODULARIZE=1 -s EXPORT_ES6=1 \
+  -s ENVIRONMENT=node,web,worker \
+  -s ALLOW_MEMORY_GROWTH=1 -s INITIAL_MEMORY=4194304 \
+  -s EXPORTED_RUNTIME_METHODS='["HEAP16","HEAPU8","cwrap","ccall"]' \
+  -s EXPORTED_FUNCTIONS='["_rs_alloc","_rs_free","_rs_resample","_malloc","_free"]' \
+  -o resampler.mjs
+
+echo "built resampler.mjs + resampler.wasm ($(stat -c%s resampler.wasm 2>/dev/null || echo '?') bytes)"

package/src/playtest/resampler/index.mjs

@@ -0,0 +1,75 @@
+/* ── resampler/index.mjs — JS wrapper for the WASM+SIMD audio resampler ────────
+ *
+ * Loads the WASM module once and exposes resampleS16Stereo(buf, src, dst) that
+ * resamples an interleaved S16LE stereo Node Buffer. Used by the playtest audio
+ * sink for low-rate cores (the GameTank ACP at ~13983 Hz) — see resampler.c for
+ * the why (libretro frontends resample; only GameTank is low enough to need it).
+ *
+ * The WASM scratch buffers are sized once to the largest chunk seen and reused.
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let mod = null;        // the emscripten Module
+let inPtr = 0, inCap = 0;    // input scratch (bytes)
+let outPtr = 0, outCap = 0;  // output scratch (bytes)
+
+/** Lazily instantiate the WASM module. Returns true once ready, false if it
+ * failed to load (caller falls back to passing audio through unresampled). */
+export async function initResampler() {
+  if (mod) return true;
+  try {
+    const factory = (await import(path.join(__dirname, "resampler.mjs"))).default;
+    mod = await factory();
+    return true;
+  } catch (e) {
+    mod = null;
+    return false;
+  }
+}
+
+function ensureCap(needIn, needOut) {
+  if (needIn > inCap) {
+    if (inPtr) mod._rs_free(inPtr);
+    inCap = needIn * 2; // grow with headroom
+    inPtr = mod._rs_alloc(inCap);
+  }
+  if (needOut > outCap) {
+    if (outPtr) mod._rs_free(outPtr);
+    outCap = needOut * 2;
+    outPtr = mod._rs_alloc(outCap);
+  }
+}
+
+/**
+ * Resample an interleaved S16LE stereo Buffer from srcRate to dstRate using the
+ * WASM+SIMD core. Synchronous; initResampler() must have resolved true first.
+ * Falls back to returning the input unchanged if the module isn't loaded.
+ * @param {Buffer} buf interleaved S16LE stereo at srcRate
+ * @param {number} srcRate
+ * @param {number} dstRate
+ * @returns {Buffer} interleaved S16LE stereo at dstRate
+ */
+export function resampleS16Stereo(buf, srcRate, dstRate) {
+  if (!mod || srcRate === dstRate || srcRate <= 0 || dstRate <= 0) return buf;
+  const inFrames = (buf.length / 4) | 0; // 4 bytes/stereo frame
+  if (inFrames < 2) return buf;
+  const maxOutFrames = Math.ceil(inFrames * (dstRate / srcRate)) + 2;
+
+  ensureCap(inFrames * 4, maxOutFrames * 4);
+
+  // copy input into WASM heap
+  mod.HEAPU8.set(new Uint8Array(buf.buffer, buf.byteOffset, buf.length), inPtr);
+
+  const outFrames = mod._rs_resample(
+    inPtr, inFrames, outPtr, maxOutFrames, srcRate, dstRate
+  );
+  if (outFrames <= 0) return buf;
+
+  // copy result out into a fresh Buffer (the audio device owns its own memory,
+  // and the WASM heap may move on the next call).
+  const outBytes = outFrames * 4;
+  return Buffer.from(new Uint8Array(mod.HEAPU8.buffer, outPtr, outBytes));
+}

package/src/playtest/resampler/resampler.c

@@ -0,0 +1,129 @@
+/* ── resampler.c — WASM+SIMD linear resampler for the romdev playtest audio sink ─
+ *
+ * Resamples interleaved S16 STEREO PCM from a source rate to a device rate.
+ *
+ * WHY this exists: the libretro CONTRACT is that a core declares its native audio
+ * rate in get_system_av_info and emits raw samples at that rate; the FRONTEND is
+ * responsible for resampling to the audio device (RetroArch does this in C with a
+ * sinc resampler). Every romdev core sits at 31–48 kHz EXCEPT the GameTank ACP at
+ * ~13983 Hz — 2.3x lower than the next core. At that rate SDL's fixed device
+ * buffer (4096 samples ≈ 293 ms) starves between 60 fps ticks that each feed only
+ * ~233 samples → clicks and pops. So the playtest sink opens the device at 48 kHz
+ * and resamples low-rate cores up to it. Doing that per-frame in JS is wasteful;
+ * this is the native-speed SIMD path (linear interp, 4 output frames/iteration).
+ *
+ * Build: see build.sh (emcc -O3 -msimd128). Exports rs_alloc/rs_free/rs_resample.
+ *
+ * Contract:
+ *   rs_resample(inPtr, inFrames, outPtr, outCap, srcRate, dstRate) -> outFrames
+ *     inPtr  : int16_t* interleaved L,R,L,R… at srcRate (inFrames stereo frames)
+ *     outPtr : int16_t* interleaved buffer with room for outCap stereo frames
+ *     returns the number of stereo frames written (<= outCap).
+ * The caller sizes outCap >= ceil(inFrames * dstRate/srcRate) + 1.
+ */
+#include <stdint.h>
+#include <wasm_simd128.h>
+#include <emscripten.h>
+
+#define EXPORT EMSCRIPTEN_KEEPALIVE
+
+/* scratch buffers live in the WASM heap, allocated from JS via rs_alloc. */
+EXPORT void *rs_alloc(int bytes) { return __builtin_malloc((unsigned long)bytes); }
+EXPORT void  rs_free(void *p)    { __builtin_free(p); }
+
+/* Linear-resample interleaved S16 stereo. Returns stereo frames written.
+ *
+ * For output frame i: srcPos = i / ratio = i * srcRate/dstRate. We split srcPos
+ * into integer index i0 and fraction f in [0,1): out = in[i0]*(1-f) + in[i0+1]*f
+ * per channel. We vectorize across 4 consecutive output frames: compute their 4
+ * srcPos in f32x4, their 4 integer indices and 4 fractions, gather the 8 source
+ * samples (can't SIMD-gather in wasm128, so scalar gather) but do the lerp math in
+ * SIMD. The gather dominates, but keeping the arithmetic in f32x4 + a single
+ * saturating narrow per 4 frames is still a clear win over per-sample JS.
+ */
+EXPORT int rs_resample(const int16_t *in, int inFrames,
+                       int16_t *out, int outCap,
+                       int srcRate, int dstRate) {
+  if (inFrames < 2 || srcRate <= 0 || dstRate <= 0) return 0;
+  if (srcRate == dstRate) {
+    int n = inFrames < outCap ? inFrames : outCap;
+    for (int i = 0; i < n * 2; i++) out[i] = in[i];
+    return n;
+  }
+
+  /* step = srcRate/dstRate in source frames per output frame (fixed math in f64). */
+  const double step = (double)srcRate / (double)dstRate;
+  long outFrames = (long)((double)inFrames * (double)dstRate / (double)srcRate);
+  if (outFrames > outCap) outFrames = outCap;
+  const int maxI0 = inFrames - 2; /* so i0+1 is valid */
+
+  long i = 0;
+  /* SIMD body: 4 output frames per iteration. */
+  for (; i + 4 <= outFrames; i += 4) {
+    /* source positions for the 4 frames */
+    double p0 = (double)(i + 0) * step;
+    double p1 = (double)(i + 1) * step;
+    double p2 = (double)(i + 2) * step;
+    double p3 = (double)(i + 3) * step;
+
+    int i0_0 = (int)p0, i0_1 = (int)p1, i0_2 = (int)p2, i0_3 = (int)p3;
+    if (i0_0 > maxI0) i0_0 = maxI0; if (i0_1 > maxI0) i0_1 = maxI0;
+    if (i0_2 > maxI0) i0_2 = maxI0; if (i0_3 > maxI0) i0_3 = maxI0;
+
+    /* fractions as f32x4 */
+    v128_t frac = wasm_f32x4_make((float)(p0 - i0_0), (float)(p1 - i0_1),
+                                  (float)(p2 - i0_2), (float)(p3 - i0_3));
+    v128_t inv  = wasm_f32x4_sub(wasm_f32x4_splat(1.0f), frac);
+
+    /* gather the 8 source samples per channel (scalar — no wasm128 gather). */
+    v128_t l0 = wasm_f32x4_make((float)in[(i0_0*2)],   (float)in[(i0_1*2)],
+                                (float)in[(i0_2*2)],   (float)in[(i0_3*2)]);
+    v128_t l1 = wasm_f32x4_make((float)in[(i0_0*2)+2], (float)in[(i0_1*2)+2],
+                                (float)in[(i0_2*2)+2], (float)in[(i0_3*2)+2]);
+    v128_t r0 = wasm_f32x4_make((float)in[(i0_0*2)+1], (float)in[(i0_1*2)+1],
+                                (float)in[(i0_2*2)+1], (float)in[(i0_3*2)+1]);
+    v128_t r1 = wasm_f32x4_make((float)in[(i0_0*2)+3], (float)in[(i0_1*2)+3],
+                                (float)in[(i0_2*2)+3], (float)in[(i0_3*2)+3]);
+
+    /* lerp: l = l0*inv + l1*frac */
+    v128_t lo = wasm_f32x4_add(wasm_f32x4_mul(l0, inv), wasm_f32x4_mul(l1, frac));
+    v128_t ro = wasm_f32x4_add(wasm_f32x4_mul(r0, inv), wasm_f32x4_mul(r1, frac));
+
+    /* round to nearest, convert to i32, store interleaved. */
+    v128_t half = wasm_f32x4_splat(0.5f);
+    v128_t lneg = wasm_f32x4_lt(lo, wasm_f32x4_splat(0.0f));
+    v128_t rneg = wasm_f32x4_lt(ro, wasm_f32x4_splat(0.0f));
+    lo = wasm_f32x4_add(lo, wasm_v128_bitselect(wasm_f32x4_splat(-0.5f), half, lneg));
+    ro = wasm_f32x4_add(ro, wasm_v128_bitselect(wasm_f32x4_splat(-0.5f), half, rneg));
+    v128_t li = wasm_i32x4_trunc_sat_f32x4(lo);
+    v128_t ri = wasm_i32x4_trunc_sat_f32x4(ro);
+
+    int li_[4], ri_[4];
+    wasm_v128_store(li_, li);
+    wasm_v128_store(ri_, ri);
+    for (int k = 0; k < 4; k++) {
+      int lv = li_[k], rv = ri_[k];
+      if (lv > 32767) lv = 32767; else if (lv < -32768) lv = -32768;
+      if (rv > 32767) rv = 32767; else if (rv < -32768) rv = -32768;
+      out[(i + k) * 2]     = (int16_t)lv;
+      out[(i + k) * 2 + 1] = (int16_t)rv;
+    }
+  }
+
+  /* scalar tail */
+  for (; i < outFrames; i++) {
+    double p = (double)i * step;
+    int i0 = (int)p; if (i0 > maxI0) i0 = maxI0;
+    float f = (float)(p - i0), invf = 1.0f - f;
+    float l = in[i0*2]   * invf + in[(i0+1)*2]   * f;
+    float r = in[i0*2+1] * invf + in[(i0+1)*2+1] * f;
+    int lv = (int)(l < 0 ? l - 0.5f : l + 0.5f);
+    int rv = (int)(r < 0 ? r - 0.5f : r + 0.5f);
+    if (lv > 32767) lv = 32767; else if (lv < -32768) lv = -32768;
+    if (rv > 32767) rv = 32767; else if (rv < -32768) rv = -32768;
+    out[i*2]   = (int16_t)lv;
+    out[i*2+1] = (int16_t)rv;
+  }
+
+  return (int)outFrames;
+}

package/src/playtest/resampler/resampler.mjs

@@ -0,0 +1,2 @@
+async function Module(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("module");var require=createRequire(import.meta.url)}var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("path").dirname(require("url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var isFileURI=filename=>filename.startsWith("file://");var readyPromiseResolve,readyPromiseReject;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["c"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("resampler.wasm")}return new URL("resampler.wasm",import.meta.url).href}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var noExitRuntime=true;var stackRestore=val=>__emscripten_stack_restore(val);var stackSave=()=>_emscripten_stack_get_current();var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["ccall"]=ccall;Module["cwrap"]=cwrap;var _rs_alloc,_malloc,_rs_free,_free,_rs_resample,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,memory,__indirect_function_table,wasmMemory;function assignWasmExports(wasmExports){_rs_alloc=Module["_rs_alloc"]=wasmExports["d"];_malloc=Module["_malloc"]=wasmExports["e"];_rs_free=Module["_rs_free"]=wasmExports["f"];_free=Module["_free"]=wasmExports["g"];_rs_resample=Module["_rs_resample"]=wasmExports["h"];__emscripten_stack_restore=wasmExports["i"];__emscripten_stack_alloc=wasmExports["j"];_emscripten_stack_get_current=wasmExports["k"];memory=wasmMemory=wasmExports["b"];__indirect_function_table=wasmExports["__indirect_function_table"]}var wasmImports={a:_emscripten_resize_heap};function run(){preRun();function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})}
+;return moduleRtn}export default Module;