jsbeeb 1.19.1 → 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.1",
+  "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/teletext.js

@@ -16,7 +16,11 @@ export class Teletext {
         this.flashTime = 0;
         this.heldChar = 0;
         this.holdChar = false;
-        this.dataQueue = [0, 0, 0, 0];
+        this.cellGlyphIndex = 0;
+        this.cellFlash = false;
+        this.cellConceal = false;
+        this.cellPalette = 0;
+        this.dataQueue = new Uint8Array(4);
         this.scanlineCounter = 0;
         this.levelDEW = false;
         this.levelDISPTMG = false;
@@ -204,7 +208,7 @@ export class Teletext {
         this.flashTime = state.flashTime;
         this.heldChar = state.heldChar;
         this.holdChar = state.holdChar;
-        this.dataQueue = [...state.dataQueue];
+        this.dataQueue.set(state.dataQueue);
         this.scanlineCounter = state.scanlineCounter;
         this.levelDEW = state.levelDEW;
         this.levelDISPTMG = state.levelDISPTMG;
@@ -308,8 +312,11 @@ export class Teletext {
     }
 
     fetchData(data) {
-        this.dataQueue.shift();
-        this.dataQueue.push(data & 0x7f);
+        // `copyWithin` over four bytes costs more than the moves it saves.
+        this.dataQueue[0] = this.dataQueue[1];
+        this.dataQueue[1] = this.dataQueue[2];
+        this.dataQueue[2] = this.dataQueue[3];
+        this.dataQueue[3] = data & 0x7f;
     }
 
     setDEW(level) {
@@ -386,14 +393,13 @@ export class Teletext {
         this.levelRA0 = level;
     }
 
-    render(buf, offset) {
+    /**
+     * Clock one character through the chip: take the oldest byte in the pipeline, apply it
+     * to the character state, and latch how the resulting cell should look.
+     */
+    advance() {
         let data = this.dataQueue[0];
 
-        let scanline = this.scanlineCounter << 1;
-        if (this.levelRA0) {
-            scanline++;
-        }
-
         this.oldDbl = this.dbl;
 
         this.prevCol = this.col;
@@ -412,28 +418,49 @@ export class Teletext {
             this.heldChar = 32;
         }
 
+        // Flash (code 8) is "Set After" — flashThisCell retains the pre-control-code state.
+        // Steady (code 9) is "Set At" — update so this cell stops flashing immediately.
+        if (flashThisCell && !this.flash) flashThisCell = false;
+
+        // Conceal (code 24) is "Set At", and a colour code only reveals from the cell after itself.
+        if (this.conceal) concealThisCell = true;
+
+        this.cellGlyphIndex = (data - 32) * 20;
+        this.cellFlash = flashThisCell;
+        this.cellConceal = concealThisCell;
+        this.cellPalette = ((this.bg & 7) << 5) | ((this.prevCol & 7) << 2);
+    }
+
+    glyphScanline() {
+        let scanline = this.scanlineCounter << 1;
+        if (this.levelRA0) {
+            scanline++;
+        }
+
         if (this.oldDbl) {
             scanline = scanline >>> 1;
             if (this.secondHalfOfDouble) {
                 scanline += 10;
             }
         }
-        let chardef = this.curGlyphs[(data - 32) * 20 + scanline];
-
-        // Flash (code 8) is "Set After" — flashThisCell retains the pre-control-code state.
-        // Steady (code 9) is "Set At" — update so this cell stops flashing immediately.
-        if (flashThisCell && !this.flash) flashThisCell = false;
+        return scanline;
+    }
 
-        // Conceal (code 24) is "Set At", and a colour code only reveals from the cell after itself.
-        if (this.conceal) concealThisCell = true;
+    /**
+     * Paint the cell most recently latched by `advance`. Everything else read here changes
+     * per scanline or per field, not per character.
+     */
+    emit(buf, offset) {
+        const scanline = this.glyphScanline();
 
-        if (concealThisCell || (flashThisCell && this.hideFlashing) || (this.secondHalfOfDouble && !this.dbl)) {
-            const backgroundColour = this.colour[(this.bg & 7) << 5];
+        if (this.cellConceal || (this.cellFlash && this.hideFlashing) || (this.secondHalfOfDouble && !this.dbl)) {
+            const backgroundColour = this.colour[this.cellPalette & 0xe0];
             for (let i = 0; i < 16; ++i) {
                 buf[offset++] = backgroundColour;
             }
         } else {
-            const paletteIndex = ((this.bg & 7) << 5) | ((this.prevCol & 7) << 2);
+            let chardef = this.curGlyphs[this.cellGlyphIndex + scanline];
+            const paletteIndex = this.cellPalette;
 
             for (let pixel = 0; pixel < 16; ++pixel) {
                 buf[offset + pixel] = this.colour[paletteIndex + (chardef & 3)];
@@ -441,4 +468,27 @@ export class Teletext {
             }
         }
     }
+
+    // The second half of the cell `emit` last painted, for the ULA's 1MHz repaint.
+    emitSecondHalf(buf, offset) {
+        const scanline = this.glyphScanline();
+        if (this.cellConceal || (this.cellFlash && this.hideFlashing) || (this.secondHalfOfDouble && !this.dbl)) {
+            const backgroundColour = this.colour[this.cellPalette & 0xe0];
+            for (let pixel = 8; pixel < 16; ++pixel) {
+                buf[offset + pixel] = backgroundColour;
+            }
+        } else {
+            let chardef = this.curGlyphs[this.cellGlyphIndex + scanline] >>> 16;
+            const paletteIndex = this.cellPalette;
+            for (let pixel = 8; pixel < 16; ++pixel) {
+                buf[offset + pixel] = this.colour[paletteIndex + (chardef & 3)];
+                chardef >>>= 2;
+            }
+        }
+    }
+
+    render(buf, offset) {
+        this.advance();
+        this.emit(buf, offset);
+    }
 }

package/src/video.js

@@ -84,6 +84,7 @@ class Ula {
                 this._writeNulaPalette(val);
                 break;
         }
+        this.video.repaintSecondHalfOfCell();
     }
 
     snapshotState() {
@@ -385,7 +386,9 @@ export class Video {
         this.cursorOff = false;
         this.cursorOnThisFrame = false;
         this.cursorDrawIndex = 0;
+        this.cursorInvertedOffset = -1;
         this.cursorPos = 0;
+        this.cellData = 0;
         this.interlacedSyncAndVideo = false;
         this.doubledScanlines = true;
         this.frameSkipCount = 0;
@@ -546,6 +549,8 @@ export class Video {
         this.cursorOn = state.cursorOn;
         this.cursorOff = state.cursorOff;
         this.cursorOnThisFrame = state.cursorOnThisFrame;
+        this.cursorInvertedOffset = -1;
+        this.cellData = 0;
         this.cursorDrawIndex = state.cursorDrawIndex;
         this.cursorPos = state.cursorPos;
         this.interlacedSyncAndVideo = state.interlacedSyncAndVideo;
@@ -599,6 +604,7 @@ export class Video {
             if (this.frameCount % this.frameSkipCount) enable = 0;
         }
         this.dispEnabled |= enable;
+        this.cursorInvertedOffset = -1;
 
         this.bitmapY = 0;
         // Interlace even frame fires vsync midway through a scanline.
@@ -650,11 +656,7 @@ export class Video {
         destOffset |= 0;
         const offset = table4bppOffset(this.ulaMode, dat);
         const fb32 = this.fb32;
-        // In NULA palette mode, bypass the ULA palette (ulaPal) and look up
-        // pixel colours directly from the NULA 12-bit colour table (collook).
-        // This skips the XOR-7 logical↔physical colour mapping that the
-        // standard ULA applies.  Reference: b-em src/video.c lines 1083, 1117.
-        const colourLookup = this.ula.paletteMode ? this.ula.collook : this.ulaPal;
+        const colourLookup = this.pixelColours();
         const table4bpp = this.table4bpp;
         // Take advantage of numPixels being either 8 or 16
         if (numPixels === 8) {
@@ -668,20 +670,70 @@ export class Video {
         }
     }
 
+    // The second half of a 16 pixel cell, for the 1MHz repaint.
+    blitFbSecondHalf(dat, destOffset) {
+        const offset = table4bppOffset(this.ulaMode, dat);
+        const colourLookup = this.pixelColours();
+        for (let i = 8; i < 16; ++i) {
+            this.fb32[destOffset + i] = colourLookup[this.table4bpp[offset + i]];
+        }
+    }
+
+    // In NULA palette mode, bypass the ULA palette (ulaPal) and look up
+    // pixel colours directly from the NULA 12-bit colour table (collook).
+    // This skips the XOR-7 logical↔physical colour mapping that the
+    // standard ULA applies.  Reference: b-em src/video.c lines 1083, 1117.
+    pixelColours() {
+        return this.ula.paletteMode ? this.ula.collook : this.ulaPal;
+    }
+
     handleCursor(offset) {
         if (this.cursorOnThisFrame && this.ulactrl & this.cursorTable[this.cursorDrawIndex]) {
-            for (let i = 0; i < this.pixelsPerChar; ++i) {
-                this.fb32[offset + i] ^= 0x00ffffff;
-            }
-            if (this.doubledScanlines && !this.interlacedSyncAndVideo) {
-                for (let i = 0; i < this.pixelsPerChar; ++i) {
-                    this.fb32[offset + 1024 + i] ^= 0x00ffffff;
-                }
-            }
+            this.invertForCursor(offset, 0);
+            this.cursorInvertedOffset = offset;
+        } else {
+            this.cursorInvertedOffset = -1;
         }
         if (++this.cursorDrawIndex === 7) this.cursorDrawIndex = 0;
     }
 
+    invertForCursor(offset, fromPixel) {
+        for (let i = fromPixel; i < this.pixelsPerChar; ++i) {
+            this.fb32[offset + i] ^= 0x00ffffff;
+        }
+        if (this.doubledScanlines && !this.interlacedSyncAndVideo) {
+            for (let i = fromPixel; i < this.pixelsPerChar; ++i) {
+                this.fb32[offset + 1024 + i] ^= 0x00ffffff;
+            }
+        }
+    }
+
+    // The render loop paints a whole 1MHz cell on one 2MHz tick and skips the next, but the ULA
+    // output stage switches at 2MHz: a register write landing on the skipped tick changes the
+    // second half of the cell just painted. See https://github.com/mattgodbolt/jsbeeb/issues/766
+    repaintSecondHalfOfCell() {
+        if (!this.halfClock || !this.oddClock) return;
+        if ((this.dispEnabled & EVERYTHINGENABLED) !== EVERYTHINGENABLED) return;
+        if (this.bitmapX < 0 || this.bitmapX >= 1024 || this.bitmapY < 0 || this.bitmapY >= 625) return;
+        // The same line doubling decision as the render loop, which inlines it for speed.
+        const doubledLines =
+            (this.doubledScanlines && !this.interlacedSyncAndVideo) || this.isEvenRender === this.lastRenderWasEven;
+        const bitmapRow = doubledLines ? this.bitmapY & ~1 : this.bitmapY;
+        const offset = bitmapRow * 1024 + this.bitmapX;
+        const halfCell = this.pixelsPerChar >>> 1;
+        if (this.teletextMode) {
+            this.teletext.emitSecondHalf(this.fb32, offset);
+        } else {
+            this.blitFbSecondHalf(this.cellData, offset);
+        }
+        if (doubledLines) {
+            this.fb32.copyWithin(offset + 1024 + halfCell, offset + halfCell, offset + this.pixelsPerChar);
+        }
+        if (this.cursorInvertedOffset === offset) {
+            this.invertForCursor(offset, halfCell);
+        }
+    }
+
     setScreenHwScroll(viaScreenHwScroll) {
         this.screenSubtract = this.screenAddrSubtract[viaScreenHwScroll];
     }
@@ -984,11 +1036,15 @@ export class Video {
                 // Read data from address pointer if both horizontal and vertical display enabled.
                 const dat = this.readVideoMem();
                 if (insideBorder) {
-                    // Always feed the SAA5050 pipeline: on real hardware IC15
-                    // permanently connects the video bus to the SAA5050 inputs
-                    // regardless of ULA mode. Required for the "TTX trick".
+                    // Always clock the SAA5050, whatever the ULA mode: IC15 latches the video bus
+                    // into the chip and it is MA13, not the ULA's teletext bit, that gates it. We
+                    // do not model the MA13 gate yet, so this feeds unconditionally. The chip is
+                    // clocked here and painted later, so a control code seen while the ULA shows
+                    // bitmap still takes effect.
                     // See https://github.com/mattgodbolt/jsbeeb/issues/546
+                    // and https://github.com/mattgodbolt/jsbeeb/issues/832
                     this.teletext.fetchData(dat);
+                    this.teletext.advance();
 
                     // Check cursor start.
                     if (
@@ -1018,6 +1074,7 @@ export class Video {
                     }
 
                     const offset = bitmapRow * 1024 + this.bitmapX;
+                    this.cellData = dat;
 
                     if ((this.dispEnabled & EVERYTHINGENABLED) === EVERYTHINGENABLED) {
                         // Note this row's logical pixel size for display
@@ -1033,24 +1090,24 @@ export class Video {
                         if (this.teletextMode) {
                             if (this.halfClock) {
                                 // Proper MODE 7 (1MHz clock + teletext): render SAA5050 output normally.
-                                this.teletext.render(this.fb32, offset);
+                                this.teletext.emit(this.fb32, offset);
                             } else {
-                                // 2MHz clock + teletext bit set (the "TTX trick"): the Video ULA
-                                // forces DISPEN to the SAA5050 to 0 in 2MHz modes (0/1/2/3), so
-                                // the SAA5050 outputs black. Confirmed by Rich Talbot-Watkins (RTW)
-                                // at ABUG 2026-03-13.
+                                // 2MHz clock + teletext bit set (the "TTX trick"): the SAA5050
+                                // outputs black. Behaviour confirmed by Rich Talbot-Watkins (RTW)
+                                // at ABUG 2026-03-13; the mechanism is not established, as the
+                                // Model B ULA has no connection to the SAA5050 at all.
                                 // See https://github.com/mattgodbolt/jsbeeb/issues/546
                                 this.fb32.fill(OPAQUE_BLACK, offset, offset + this.pixelsPerChar);
                             }
                         } else {
-                            this.blitFb(dat, offset, this.pixelsPerChar, doubledLines);
+                            this.blitFb(dat, offset, this.pixelsPerChar);
                         }
                         if (doubledLines) {
                             this.fb32.copyWithin(offset + 1024, offset, offset + this.pixelsPerChar);
                         }
                     }
                     if (this.cursorDrawIndex) {
-                        this.handleCursor(offset, doubledLines);
+                        this.handleCursor(offset);
                     }
                 }
             }
@@ -1059,6 +1116,10 @@ export class Video {
             // the SAA5050 pipeline with the video bus data, forcing bit 6 high.
             // On real hardware IC37/IC36 operates regardless of ULA mode —
             // it is wired to the CRTC DISPEN signal, not the ULA teletext bit.
+            // Hardware also clocks the chip here, which we do not: our row reset fires
+            // too early relative to the pipeline for that to come out right, and adding
+            // `advance()` alone moves three of the hardware reference pages. See
+            // https://github.com/mattgodbolt/jsbeeb/issues/874
             if (!(this.dispEnabled & HDISPENABLE) && this.dispEnabled & VDISPENABLE) {
                 this.teletext.fetchData(this.readVideoMem() | 0x40);
             }

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;
     }

package/src/basic/multiline-tetris

@@ -1,9 +0,0 @@
-0d=d:IFd VDUd:p=POINT(64*POS,1E3-VPOS*32):RETURN ELSEMODE2:GCOL0,-9:CLG
-1d=9:REPEATVDU30:REPEATGOSUBFALSE:IFPOS=15VDU28,5,VPOS,14;11,26:IF0ELSEIFp=0PRINT:UNTIL0ELSEUNTILVPOS=25
-2b=ABSRND MOD7:k=0:VDU31,9,3
-3REPEATg=9-INKEY6MOD3
-4FORl=TRUE TO1:o=l ANDSGNo
-5IFo=l COLOURb-15:VDUl EORg:k=k+(g=7AND9-6*l)
-6IF0ELSEFORf=0TO11:d=f/3OR2EORd:GOSUBFALSE
-7IF2^((f+k)MOD12)AND975AND&C2590EC/8^b VDU2080*ABSl;:o=o+p:IF0ELSENEXT,
-8VDU20:UNTILo*LOGg:UNTIL0