jsbeeb 1.19.2 → 1.19.3

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.19.2",
+  "version": "1.19.3",
   "//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/main.js

@@ -174,8 +174,12 @@ const cpuMultiplier = parsedQuery.cpuMultiplier ?? 1;
 let fastAsPossible = false;
 let fastTape = false;
 let noSeek;
-let audioFilterFreq = 7000;
-let audioFilterQ = 5;
+// The board's output filter is an equal-component Sallen-Key (Service Manual
+// section 3.8: 10K and 2n2 twice, gain 1 + 22/39): f0 = 1/(2*pi*RC) = 7234 Hz,
+// Q = 1/(3 - K) = 0.696, below 1/sqrt(2), so no resonant peak. BiquadFilterNode
+// takes lowpass Q in decibels: 20*log10(0.696) = -3.15.
+let audioFilterFreq = 7234;
+let audioFilterQ = -3.15;
 let stationId = 101;
 let econet = null;
 

package/src/soundchip.js

@@ -5,6 +5,13 @@ const speakerVolume = 0.5;
 // Samples per output chunk handed to the onBuffer callback.
 export const SoundBufferSamples = 512;
 
+// The BBC's DC restoration circuit (Service Manual section 3.8: R8 10K, C2
+// 4u7) cancels the SN76489's unipolar pedestal. Modelled as a first-order DC
+// blocker with the same corner, 1/(2*pi*R*C). The generators must stay
+// unipolar: sampled speech is amplitude modulation of a 125 kHz carrier's
+// mean level, which a zero-mean output would silence (see issue #863).
+const DcRestoreCornerHz = 1 / (2 * Math.PI * 10e3 * 4.7e-6);
+
 const volumeTable = new Float32Array(16);
 (() => {
     let f = 1.0;
@@ -72,6 +79,10 @@ export class SoundChip {
         this.position = 0;
         this.buffer = new Float32Array(SoundBufferSamples);
 
+        this.dcAlpha = 1 - (2 * Math.PI * DcRestoreCornerHz) / sampleRate;
+        this.dcPrevIn = 0;
+        this.dcPrevOut = 0;
+
         this.latchedRegister = 0;
         this.slowDataBus = 0;
         this.active = false;
@@ -178,10 +189,22 @@ export class SoundChip {
         for (let i = 0; i < length; ++i) {
             out[i + offset] = 0.0;
         }
-        if (!this.enabled) return;
-        for (let i = 0; i < this.generators.length; ++i) {
-            this.generators[i](i, out, offset, length);
+        if (this.enabled) {
+            for (let i = 0; i < this.generators.length; ++i) {
+                this.generators[i](i, out, offset, length);
+            }
+        }
+        const alpha = this.dcAlpha;
+        let prevIn = this.dcPrevIn;
+        let prevOut = this.dcPrevOut;
+        for (let i = 0; i < length; ++i) {
+            const x = out[i + offset];
+            prevOut = x - prevIn + alpha * prevOut;
+            prevIn = x;
+            out[i + offset] = prevOut;
         }
+        this.dcPrevIn = prevIn;
+        this.dcPrevOut = prevOut;
     }
 
     catchUp() {
@@ -297,6 +320,8 @@ export class SoundChip {
             sineOn: this.sineOn,
             sineStep: this.sineStep,
             sineTime: this.sineTime,
+            dcPrevIn: this.dcPrevIn,
+            dcPrevOut: this.dcPrevOut,
         };
     }
 
@@ -322,6 +347,9 @@ export class SoundChip {
         // Reset output buffer
         this.position = 0;
         this.buffer.fill(0);
+        // Older snapshots predate the DC blocker
+        this.dcPrevIn = state.dcPrevIn ?? 0;
+        this.dcPrevOut = state.dcPrevOut ?? 0;
     }
 
     reset(hard) {

package/src/web/audio-renderer.js

@@ -8,6 +8,13 @@ const MaxQueuedMs = 250;
 
 const samplesFor = (ms) => (InputSampleRate * ms) / 1000;
 
+// Smoothing rejects the producer's per-frame bursts; proportional only, as
+// occupancy already integrates rate error; 0.05% authority covers clock skew
+// without audibly bending pitch.
+const OccupancySmoothingTau = 0.5;
+const ProportionalGain = 0.2;
+const MaxAdjust = InputSampleRate * 0.0005;
+
 class SoundChipProcessor extends AudioWorkletProcessor {
     constructor(...args) {
         super(...args);
@@ -15,12 +22,15 @@ class SoundChipProcessor extends AudioWorkletProcessor {
         this.inputSampleRate = InputSampleRate;
         this._lastSample = 0;
         this._lastFilteredOutput = 0;
+        this._phase = 0;
+        this._source = new Float32Array(0);
         this.queue = [];
         this._queueSizeSamples = 0;
         this.dropped = 0;
         this.underruns = 0;
         this.targetLatencyMs = 1000 * (1 / 50); // One frame
         this.startQueueSizeSamples = samplesFor(this.targetLatencyMs);
+        this.smoothedOccupancyError = 0;
         this.running = false;
         this.maxQueueSizeSamples = samplesFor(MaxQueuedMs);
         this.port.onmessage = (event) => {
@@ -50,6 +60,18 @@ class SoundChipProcessor extends AudioWorkletProcessor {
         return Date.now() - timeInBufferMs;
     }
 
+    _occupancySamples() {
+        return this._queueSizeSamples - (this.queue.length ? this.queue[0].offset : 0);
+    }
+
+    _effectiveSampleRate(dtSeconds) {
+        const error = this._occupancySamples() - this.startQueueSizeSamples;
+        const alpha = Math.min(1, dtSeconds / OccupancySmoothingTau);
+        this.smoothedOccupancyError += alpha * (error - this.smoothedOccupancyError);
+        const adjustment = ProportionalGain * this.smoothedOccupancyError;
+        return this.inputSampleRate + Math.min(MaxAdjust, Math.max(-MaxAdjust, adjustment));
+    }
+
     onBuffer(time, buffer) {
         this.queue.push({ offset: 0, time, buffer });
         this._queueSizeSamples += buffer.length;
@@ -88,30 +110,34 @@ class SoundChipProcessor extends AudioWorkletProcessor {
 
         // I looked into using https://www.npmjs.com/package/@alexanderolsen/libsamplerate-js or similar (the full API),
         // but we fiddle the sample rate here to catch up with the target latency, which is harder to do with that API.
-        const outByMs = this._queueAge() - this.targetLatencyMs;
-        const maxAdjust = this.inputSampleRate * 0.01;
-        const adjustment = Math.min(maxAdjust, Math.max(-maxAdjust, outByMs * 100));
-        const effectiveSampleRate = this.inputSampleRate + adjustment;
+        const channel = outputs[0][0];
+        const effectiveSampleRate = this._effectiveSampleRate(channel.length / sampleRate);
         const sampleRatio = effectiveSampleRate / sampleRate;
 
-        const channel = outputs[0][0];
         const dt = 1 / effectiveSampleRate;
         const filterAlpha = dt / (RC + dt);
 
-        const numInputSamples = Math.round(sampleRatio * channel.length);
-        const source = new Float32Array(numInputSamples);
+        // 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.
+        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._lastFilteredOutput;
         let prevSample = this._lastFilteredOutput;
-        for (let i = 0; i < numInputSamples; ++i) {
+        for (let i = 1; i <= numInputSamples; ++i) {
             prevSample += filterAlpha * (this.nextSample() - prevSample);
             source[i] = prevSample;
         }
         this._lastFilteredOutput = prevSample;
         for (let i = 0; i < channel.length; i++) {
-            const pos = (i + 0.5) * sampleRatio;
+            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;
         }
+        this._phase = end - numInputSamples;
         this.stats(sampleRatio);
         return true;
     }