jsbeeb 1.20.1 → 1.20.2

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.20.1",
+  "version": "1.20.2",
   "//engines": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": ">=24.15.0"

package/src/app/app.js

@@ -250,6 +250,16 @@ const template = [
                 click: sendAction("rewind"),
             },
             { type: "separator" },
+            {
+                label: "Pause and Show Debugger",
+                accelerator: "CmdOrCtrl+Home",
+                click: sendAction("pause"),
+            },
+            {
+                label: "Resume",
+                click: sendAction("resume"),
+            },
+            { type: "separator" },
             {
                 label: "Soft Reset",
                 click: sendAction("soft-reset"),

package/src/jsbeeb.css

@@ -81,6 +81,12 @@ body {
   width: 90px;
 }
 
+#debug-keys {
+  clear: both;
+  padding-top: 3px;
+  color: #aaaaaa;
+}
+
 #crtc_debug {
   background-color: #333333;
   border: 1px solid #555555;

package/src/main.js

@@ -795,11 +795,18 @@ let keyboard; // This will be initialised after the processor is created
 
 const debugPause = document.getElementById("debug-pause");
 const debugPlay = document.getElementById("debug-play");
-debugPause.addEventListener("click", () => stop(true));
-debugPlay.addEventListener("click", () => {
+
+function pauseIntoDebugger() {
+    stop(true);
+}
+
+function resumeFromDebugger() {
     dbgr.hide();
-    go();
-});
+    keyboard.resumeEmulation();
+}
+
+debugPause.addEventListener("click", pauseIntoDebugger);
+debugPlay.addEventListener("click", resumeFromDebugger);
 
 // To lower chance of data loss, only accept drop events in the drop
 // zone in the menu bar.
@@ -2711,6 +2718,8 @@ electron({
         "hard-reset": hardReset,
         "save-state": () => document.getElementById("save-state").click(),
         rewind: () => rewindUI.open(),
+        pause: pauseIntoDebugger,
+        resume: resumeFromDebugger,
     },
 });
 

package/src/resampler.js

@@ -0,0 +1,92 @@
+function besselI0(x) {
+    let sum = 1;
+    let term = 1;
+    for (let k = 1; k < 50; ++k) {
+        term *= (x / (2 * k)) ** 2;
+        sum += term;
+        if (term < sum * 1e-12) break;
+    }
+    return sum;
+}
+
+/**
+ * Rate conversion by a Kaiser-windowed sinc evaluated only where an output
+ * sample falls, so the cost scales with the output rate, not the input rate.
+ * The kernel is tabulated at `phases` fractional offsets and interpolated
+ * between them. Each quantum the caller reserves room for its input, renders
+ * into `buffer` at `inputOffset`, reads the output with `read`, then calls
+ * `commit` to carry the last `taps` input samples over as the next quantum's
+ * history. Nothing is allocated once the buffer has reached its working size.
+ */
+export class PolyphaseResampler {
+    constructor(inputRate, cutoffHz, { taps = 201, phases = 64, beta = 8.5 } = {}) {
+        this.taps = taps;
+        this.phases = phases;
+        this.half = (taps - 1) / 2;
+        this.table = new Float32Array((phases + 1) * taps);
+        const scale = (2 * cutoffHz) / inputRate;
+        const norm = besselI0(beta);
+        for (let p = 0; p <= phases; ++p) {
+            const row = p * taps;
+            let sum = 0;
+            for (let k = 0; k < taps; ++k) {
+                const t = k - this.half - p / phases;
+                const x = Math.PI * scale * t;
+                const sinc = x === 0 ? 1 : Math.sin(x) / x;
+                const u = t / (this.half + 1);
+                const window = u <= -1 || u >= 1 ? 0 : besselI0(beta * Math.sqrt(1 - u * u)) / norm;
+                this.table[row + k] = scale * sinc * window;
+                sum += this.table[row + k];
+            }
+            for (let k = 0; k < taps; ++k) this.table[row + k] /= sum;
+        }
+        this.buffer = new Float32Array(taps);
+        this.newSamples = 0;
+    }
+
+    /** Make room for `count` new input samples after the history. */
+    reserve(count) {
+        const needed = this.taps + count + 1;
+        if (this.buffer.length < needed) {
+            const grown = new Float32Array(needed * 2);
+            grown.set(this.buffer.subarray(0, this.taps));
+            this.buffer = grown;
+        }
+        this.newSamples = count;
+    }
+
+    get inputOffset() {
+        return this.taps;
+    }
+
+    /**
+     * Fill `out` with samples taken `ratio` input samples apart, the first at
+     * `phase` (0 to 1) past the last sample of the previous quantum. The
+     * output lags the input by `half` samples, which the kernel needs ahead.
+     */
+    read(out, phase, ratio) {
+        const { buffer, table, taps, phases } = this;
+        for (let i = 0; i < out.length; ++i) {
+            const pos = phase + i * ratio;
+            const loc = Math.floor(pos);
+            const fracPhase = (pos - loc) * phases;
+            const p = Math.min(Math.floor(fracPhase), phases - 1);
+            const mix = fracPhase - p;
+            const rowA = p * taps;
+            const rowB = rowA + taps;
+            let a = 0;
+            let b = 0;
+            for (let k = 0; k < taps; ++k) {
+                const x = buffer[loc + k];
+                a += table[rowA + k] * x;
+                b += table[rowB + k] * x;
+            }
+            out[i] = a + (b - a) * mix;
+        }
+    }
+
+    /** Keep the last `taps` input samples as history for the next quantum. */
+    commit() {
+        this.buffer.copyWithin(0, this.newSamples, this.newSamples + this.taps);
+    }
+}

package/src/web/audio-renderer.js

@@ -1,14 +1,21 @@
 /* global sampleRate, currentTime, registerProcessor, AudioWorkletProcessor */
 import { SoundChip, AtomSoundChip } from "../soundchip.js";
 import { LowPassBiquad } from "../biquad.js";
+import { PolyphaseResampler } from "../resampler.js";
 
 // The board's output filter is an equal-component Sallen-Key (Service Manual
 // section 3.8: 10K and 2n2 twice, gain K = 1 + 22/39): f0 = 1/(2*pi*RC) = 7234 Hz,
 // Q = 1/(3 - K) = 0.696, below 1/sqrt(2), so no resonant peak. Run at the chip
-// rate, ahead of decimation, it is also the anti-alias filter.
+// rate, ahead of the resampler.
 const OutputFilterHz = 7234;
 const OutputFilterQ = 0.696;
 
+// The resampler's sinc is cut off below the output Nyquist so that its
+// transition band has finished before anything folds; sampled sound rides on
+// a 31 kHz or higher carrier that would otherwise land in the audible band.
+const ResamplerCutoffOfOutputRate = 0.4;
+const ResamplerTaps = 201;
+
 const DefaultTargetLatencyMs = 1000 * (1 / 50); // One frame
 const MaxTargetLatencyMs = 250;
 
@@ -38,6 +45,9 @@ class SoundChipProcessor extends AudioWorkletProcessor {
         this.inputSampleRate = this.chip.soundchipFreq;
         this.samplesPerCycle = this.chip.samplesPerCycle;
         this.outputFilter = this._makeOutputFilter(audioFilterFreq, audioFilterQ);
+        this.resampler = new PolyphaseResampler(this.inputSampleRate, ResamplerCutoffOfOutputRate * sampleRate, {
+            taps: ResamplerTaps,
+        });
 
         this.events = [];
         this.eventsHead = 0;
@@ -48,9 +58,7 @@ class SoundChipProcessor extends AudioWorkletProcessor {
         this.skippedMs = 0;
         this.minLeadMs = Infinity;
 
-        this._lastInputSample = 0;
         this._phase = 0;
-        this._source = new Float32Array(0);
         this.smoothedLeadError = 0;
         this.setTargetLatency(targetLatencyMs);
         this.port.onmessage = (event) => {
@@ -210,21 +218,15 @@ class SoundChipProcessor extends AudioWorkletProcessor {
 
         // The fractional read position carries across quanta, so consumption
         // averages exactly sampleRatio and the pitch never steps at a rounding
-        // boundary. source[0] is the last input sample of the previous quantum.
+        // boundary.
         const end = this._phase + channel.length * sampleRatio;
         const numInputSamples = Math.floor(end);
-        if (this._source.length <= numInputSamples) this._source = new Float32Array(numInputSamples * 2);
-        const source = this._source;
-        source[0] = this._lastInputSample;
-        this._renderInput(source, 1, numInputSamples);
-        this.outputFilter?.process(source, 1, numInputSamples);
-        this._lastInputSample = source[numInputSamples];
-        for (let i = 0; i < channel.length; i++) {
-            const pos = this._phase + i * sampleRatio;
-            const loc = Math.floor(pos);
-            const alpha = pos - loc;
-            channel[i] = source[loc] * (1 - alpha) + source[loc + 1] * alpha;
-        }
+        const resampler = this.resampler;
+        resampler.reserve(numInputSamples);
+        this._renderInput(resampler.buffer, resampler.inputOffset, numInputSamples);
+        this.outputFilter?.process(resampler.buffer, resampler.inputOffset, numInputSamples);
+        resampler.read(channel, this._phase, sampleRatio);
+        resampler.commit();
         this._phase = end - numInputSamples;
         this.minLeadMs = Math.min(this.minLeadMs, this.leadMs());
         this.stats(sampleRatio);