jsbeeb 1.13.0 → 1.14.0

package/src/snapshot-helpers.js

@@ -166,12 +166,25 @@ export function buildVideoState(ulaControl, ulaPalette, crtcRegs, nulaCollook, c
  * @param {object} uservia - jsbeeb user VIA state
  * @param {object} video - jsbeeb video state (from buildVideoState)
  * @param {object} soundChip - jsbeeb sound chip state
+ * @param {object|null} [tube] - jsbeeb tube state, or null if no co-processor was fitted
  */
-export function buildSnapshot(importedFrom, modelName, cpuState, ram, roms, sysvia, uservia, video, soundChip) {
+export function buildSnapshot(
+    importedFrom,
+    modelName,
+    cpuState,
+    ram,
+    roms,
+    sysvia,
+    uservia,
+    video,
+    soundChip,
+    tube = null,
+) {
     return {
         format: "jsbeeb-snapshot",
-        version: 2,
+        version: 3,
         model: modelName,
+        coProcessor: !!tube,
         timestamp: new Date().toISOString(),
         importedFrom,
         state: {
@@ -203,6 +216,7 @@ export function buildSnapshot(importedFrom, modelName, cpuState, ram, roms, sysv
             soundChip,
             acia: { ...DefaultAcia },
             adc: { ...DefaultAdc },
+            ...(tube ? { tube } : {}),
         },
     };
 }

package/src/snapshot.js

@@ -4,7 +4,15 @@ import { typedArrayToBase64, base64ToTypedArray } from "./state-utils.js";
 import { findModel } from "./models.js";
 
 const SnapshotFormat = "jsbeeb-snapshot";
-const SnapshotVersion = 2;
+const SnapshotVersion = 3;
+
+/**
+ * Whether a snapshot was taken on a machine with a second processor fitted.
+ * Nothing before version 3 captured tube state, so those snapshots are always host-only.
+ */
+export function hasCoProcessor(snapshot) {
+    return !!snapshot.coProcessor;
+}
 
 /**
  * Check if two model names resolve to the same model (accounting for
@@ -70,6 +78,9 @@ export function createSnapshot(cpu, model, media) {
         format: SnapshotFormat,
         version: SnapshotVersion,
         model: model.name,
+        // The model name cannot distinguish a Turbo from a plain Master: the co-processor is
+        // emulation config rather than part of the model.
+        coProcessor: cpu.hasTube,
         timestamp: new Date().toISOString(),
         state,
     };
@@ -94,6 +105,13 @@ export function restoreSnapshot(cpu, model, snapshot) {
     if (!isSameModel(snapshot.model, model.name)) {
         throw new Error(`Model mismatch: snapshot is for "${snapshot.model}" but current model is "${model.name}"`);
     }
+    if (hasCoProcessor(snapshot) !== cpu.hasTube) {
+        const fitted = (yes) => (yes ? "with a second processor" : "without a second processor");
+        throw new Error(
+            `Co-processor mismatch: snapshot was taken ${fitted(hasCoProcessor(snapshot))} ` +
+                `but this machine is ${fitted(cpu.hasTube)}`,
+        );
+    }
     cpu.restoreState(snapshot.state);
 }
 

package/src/soundchip.js

@@ -2,6 +2,9 @@
 // The BBC volumeTable[0] (loudest) is 0.25 (1.0 / 4 channels).
 const speakerVolume = 0.5;
 
+// Samples per output chunk handed to the onBuffer callback.
+export const SoundBufferSamples = 512;
+
 const volumeTable = new Float32Array(16);
 (() => {
     let f = 1.0;
@@ -21,6 +24,11 @@ function makeSineTable(attenuation) {
 }
 
 export class SoundChip {
+    /**
+     * @param {function(Float32Array): void} onBuffer called with each full
+     *     SoundBufferSamples-sized buffer of output. Receives the same buffer
+     *     every call, overwritten afterwards: copy the contents if they are kept.
+     */
     constructor(onBuffer) {
         this._onBuffer = onBuffer;
         // 4MHz input signal. Internal divide-by-8
@@ -62,7 +70,7 @@ export class SoundChip {
 
         this.residual = 0;
         this.position = 0;
-        this.buffer = new Float32Array(512);
+        this.buffer = new Float32Array(SoundBufferSamples);
 
         this.latchedRegister = 0;
         this.slowDataBus = 0;
@@ -211,17 +219,27 @@ export class SoundChip {
         const num = cycles * this.samplesPerCycle + this.residual;
         let rounded = num | 0;
         this.residual = num - rounded;
-        const bufferLength = this.buffer.length;
+        // The buffer is deliberately reused for the chip's whole life: the
+        // previous transfer-then-reallocate pattern is miscompiled by a V8
+        // optimiser bug (Chrome 150, crbug.com/537801199) which allocates the
+        // replacement with length 0, even when the reallocation is reordered
+        // before the transfer, wedging this loop forever. Reuse is also
+        // cheaper, so this needn't be reverted once the crbug is fixed. The
+        // guard fails loudly if the buffer is ever detached or the accounting
+        // goes bad.
         while (rounded > 0) {
-            const leftInBuffer = bufferLength - this.position;
+            const leftInBuffer = SoundBufferSamples - this.position;
             const numSamplesToGenerate = Math.min(rounded, leftInBuffer);
+            if (numSamplesToGenerate <= 0 || this.buffer.length !== SoundBufferSamples)
+                throw new Error(
+                    `Sound buffer accounting error (buffer=${this.buffer.length}, position=${this.position}, rounded=${rounded})`,
+                );
             this.generate(this.buffer, this.position, numSamplesToGenerate);
             this.position += numSamplesToGenerate;
             rounded -= numSamplesToGenerate;
 
-            if (this.position === bufferLength) {
+            if (this.position === SoundBufferSamples) {
                 this._onBuffer(this.buffer);
-                this.buffer = new Float32Array(bufferLength);
                 this.position = 0;
             }
         }

package/src/teletext_adaptor.js

@@ -146,7 +146,8 @@ export class TeletextAdaptor {
         this.teletextStatus &= 0x0f;
         this.teletextStatus |= 0xd0; // data ready so latch INT, DOR, and FSYN
 
-        if (this.teletextEnable) {
+        // The stream arrives asynchronously, so software can enable us before there is anything to copy.
+        if (this.teletextEnable && this.streamData) {
             // Copy current stream position into the frame buffer
             for (let i = 0; i < 16; ++i) {
                 if (this.streamData[offset + i * 43] !== 0) {

package/src/tube.js

@@ -219,7 +219,7 @@ export class Tube {
                 if (this.hostStatus[TUBE_ULA_R3] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
                     if (this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_2_BYTE_R3_DATA) {
                         if (this.hostToParasiteFifoByteCount3 < 2) {
-                            this.hostToParasiteData[this.hostToParasiteFifoByteCount3++] = value;
+                            this.hostToParasiteData[TUBE_ULA_R3][this.hostToParasiteFifoByteCount3++] = value;
                         }
                         if (this.hostToParasiteFifoByteCount3 === 2) {
                             this.parasiteStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
@@ -294,6 +294,38 @@ export class Tube {
         }
         return result;
     }
+    snapshotState() {
+        return {
+            internalStatusRegister: this.internalStatusRegister,
+            hostStatus: this.hostStatus.slice(),
+            parasiteStatus: this.parasiteStatus.slice(),
+            parasiteToHostData: this.parasiteToHostData.map((fifo) => fifo.slice()),
+            hostToParasiteData: this.hostToParasiteData.map((fifo) => fifo.slice()),
+            parasiteToHostFifoByteCount1: this.parasiteToHostFifoByteCount1,
+            parasiteToHostFifoByteCount3: this.parasiteToHostFifoByteCount3,
+            hostToParasiteFifoByteCount3: this.hostToParasiteFifoByteCount3,
+        };
+    }
+
+    /**
+     * The interrupt and reset lines are not saved: they are derived from the status registers
+     * and FIFO counts, in the same way the host's `interrupt` is rebuilt by the VIA and ACIA
+     * restores.
+     */
+    restoreState(state) {
+        this.internalStatusRegister = state.internalStatusRegister;
+        this.hostStatus.set(state.hostStatus);
+        this.parasiteStatus.set(state.parasiteStatus);
+        for (let i = 0; i < 4; i++) {
+            this.parasiteToHostData[i].set(state.parasiteToHostData[i]);
+            this.hostToParasiteData[i].set(state.hostToParasiteData[i]);
+        }
+        this.parasiteToHostFifoByteCount1 = state.parasiteToHostFifoByteCount1;
+        this.parasiteToHostFifoByteCount3 = state.parasiteToHostFifoByteCount3;
+        this.hostToParasiteFifoByteCount3 = state.hostToParasiteFifoByteCount3;
+        this.updateInterrupts();
+    }
+
     parasiteWrite(address, value) {
         //  Not implemented - needs to be integrated with the parasite CPU code:
         //  Boot mode is terminated by the software when it selects any one of the Tube addresses.

package/src/web/audio-handler.js

@@ -123,7 +123,10 @@ export class AudioHandler {
     }
 
     _onBuffer(buffer) {
-        if (this._jsAudioNode) this._jsAudioNode.port.postMessage({ time: Date.now(), buffer }, [buffer.buffer]);
+        // No transfer list, deliberately: the chip reuses this buffer, and
+        // transferring would detach it and trip crbug.com/537801199. The clone
+        // costs little (512 floats per 1.024ms of chip output, ~2MB/s).
+        if (this._jsAudioNode) this._jsAudioNode.port.postMessage({ time: Date.now(), buffer });
     }
 
     // Recent browsers, particularly Safari and Chrome, require a user interaction in order to enable sound playback.

package/tests/test-machine.js

@@ -11,9 +11,9 @@ const MaxCyclesPerIter = 100 * 1000;
 export class TestMachine {
     constructor(model, opts) {
         model = model || "B-DFS1.2";
-        const modelObj = findModel(model);
-        this.model = modelObj;
-        this.processor = fake6502(modelObj, opts || {});
+        this.model = findModel(model);
+        if (!this.model) throw new Error(`Unknown model "${model}"`);
+        this.processor = fake6502(this.model, opts || {});
         this._capturedChars = [];
         this._captureHookInstalled = false;
     }
@@ -362,7 +362,9 @@ export class TestMachine {
         }
         const fullText = text + "\n"; // append RETURN
         const keys = fullText.split("").map((ch) => this._charToKey(ch));
-        const holdCycles = 40000;
+        // Key hold is counted in CPU cycles, so scale it to keep the hold constant in
+        // real time: the OS scans the keyboard on a peripheral-rate interrupt.
+        const holdCycles = (40000 * this.processor.cpuMultiplier) | 0;
         let index = 0;
         let phase = "idle"; // "idle" → "down" → "idle"
         let nextEventCycle = 0;
@@ -414,7 +416,7 @@ export class TestMachine {
         // toggle the ROM's internal caps lock state.
         const keySequence = utils_atom.stringToATOMKeys(text + "\n");
         const ppia = this.processor.atomppia;
-        const holdCycles = 80000; // Atom at 1 MHz needs longer hold than BBC at 2 MHz
+        const holdCycles = (80000 * this.processor.cpuMultiplier) | 0; // Atom at 1 MHz needs longer hold than BBC at 2 MHz
         const SHIFT = utils_atom.ATOM.SHIFT;
 
         let index = 0;