jsbeeb 1.13.1 → 1.15.0

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

@@ -34,9 +34,20 @@ Status register:
 
 */
 
-export class TeletextAdaptor {
+/**
+ * Emulates the Acorn teletext adaptor. Dispatches a `showError` CustomEvent, carrying
+ * `context` and `error` in its detail, when a channel's stream cannot be loaded.
+ */
+export class TeletextAdaptor extends EventTarget {
     constructor(cpu) {
+        super();
         this.cpu = cpu;
+        // Not cleared by a reset, so a fetch still in flight across one is recognised as stale.
+        this.streamRequest = 0;
+        this.clearState();
+    }
+
+    clearState() {
         this.teletextStatus = 0x0f; /* low nibble comes from LK4-7 and mystery links which are left floating */
         this.teletextInts = false;
         this.teletextEnable = false;
@@ -45,26 +56,40 @@ export class TeletextAdaptor {
         this.totalFrames = 0;
         this.rowPtr = 0x00;
         this.colPtr = 0x00;
-        this.frameBuffer = new Array(16).fill(0).map(() => new Array(64).fill(0));
         this.streamData = null;
         this.pollCount = 0;
+        this.frameBuffer = new Array(16).fill(0).map(() => new Array(64).fill(0));
+        // Only a register access clears our IRQ, so an interrupt latched before the reset would hang the machine.
+        this.cpu.interrupt &= ~(1 << TELETEXT_IRQ);
     }
 
     reset(hard) {
-        if (hard) {
-            console.log("Teletext adaptor: initialisation");
-            this.loadChannelStream(this.channel);
-        }
+        if (!hard) return;
+        this.clearState();
+        this.loadChannelStream(this.channel);
     }
 
-    loadChannelStream(channel) {
+    async loadChannelStream(channel) {
         console.log("Teletext adaptor: switching to channel " + channel);
-        const teletextRef = this;
-        utils.loadData("teletext/txt" + channel + ".dat").then(function (data) {
-            teletextRef.streamData = data;
-            teletextRef.totalFrames = data.length / TELETEXT_FRAME_SIZE;
-            teletextRef.currentFrame = 0;
-        });
+        const request = ++this.streamRequest;
+        let data;
+        try {
+            data = await utils.loadData(`teletext/txt${channel}.dat`);
+        } catch (error) {
+            if (request !== this.streamRequest) return;
+            console.error(`Teletext adaptor: failed to load channel ${channel}`, error);
+            this.dispatchEvent(
+                new CustomEvent("showError", {
+                    detail: { context: `loading teletext channel ${channel}`, error },
+                }),
+            );
+            return;
+        }
+        // Fetches can resolve out of order; only the newest request may apply its data.
+        if (request !== this.streamRequest) return;
+        this.streamData = data;
+        this.totalFrames = Math.floor(data.length / TELETEXT_FRAME_SIZE);
+        this.currentFrame = 0;
     }
 
     read(addr) {
@@ -146,7 +171,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/url-params.js

@@ -161,52 +161,56 @@ export function buildUrlFromParams(baseUrl, parsedQuery, paramTypes = {}) {
 }
 
 /**
- * Process keyboard mapping parameters from query string
+ * Process keyboard and gamepad mapping parameters from query string
  * @param {Object} parsedQuery - The parsed query parameters
- * @param {Object} BBC - BBC key constants
+ * @param {Object} machineKeys - Emulated machine's key constants (`BBC`, or `ATOM` for the Atom)
  * @param {Object} keyCodes - Key code constants
  * @param {Array} userKeymap - Array to store user key mappings
  * @param {Object} gamepad - Gamepad object for handling mapping
- * @returns {Object} Updated query parameters
+ * @returns {string[]} descriptions of any mappings that were skipped, for showing to the user
  */
-export function processKeyboardParams(parsedQuery, BBC, keyCodes, userKeymap, gamepad) {
+export function processInputParams(parsedQuery, machineKeys, keyCodes, userKeymap, gamepad) {
+    const warnings = [];
+
     Object.entries(parsedQuery).forEach(([key, val]) => {
         if (!val) return;
 
-        // eg KEY.CAPSLOCK=CTRL
+        // `KEY.<host key>=<machine key>`, eg `KEY.CAPSLOCK=CTRL`. Host names come from
+        // `keyCodes`, so the BBC's RETURN is ENTER here; both lists are in the README.
         if (key.toUpperCase().indexOf("KEY.") === 0) {
-            const bbcKey = val.toUpperCase();
+            const machineKey = val.toUpperCase();
+            const nativeKey = key.substring(4).toUpperCase(); // remove KEY.
 
-            if (BBC[bbcKey]) {
-                const nativeKey = key.substring(4).toUpperCase(); // remove KEY.
-                if (keyCodes[nativeKey]) {
-                    console.log("mapping " + nativeKey + " to " + bbcKey);
-                    userKeymap.push({ native: nativeKey, bbc: bbcKey });
-                } else {
-                    console.log("unknown key: " + nativeKey);
-                }
+            if (!machineKeys[machineKey]) {
+                warnings.push(`${key}=${val}: "${machineKey}" is not a key on the emulated machine.`);
+            } else if (!keyCodes[nativeKey]) {
+                warnings.push(`${key}=${val}: "${nativeKey}" is not a key on your keyboard.`);
             } else {
-                console.log("unknown BBC key: " + val);
+                console.log("mapping " + nativeKey + " to " + machineKey);
+                userKeymap.push({ native: nativeKey, key: machineKey });
             }
         } else if (key.indexOf("GP.") === 0) {
             // gamepad mapping
             // eg ?GP.FIRE2=RETURN
             const gamepadKey = key.substring(3).toUpperCase(); // remove GP. prefix
-            gamepad.remap(gamepadKey, val.toUpperCase());
+            const problem = gamepad.remap(gamepadKey, val.toUpperCase());
+            if (problem) warnings.push(`${key}=${val}: ${problem}`);
         } else {
             switch (key) {
                 case "LEFT":
                 case "RIGHT":
                 case "UP":
                 case "DOWN":
-                case "FIRE":
-                    gamepad.remap(key, val.toUpperCase());
+                case "FIRE": {
+                    const problem = gamepad.remap(key, val.toUpperCase());
+                    if (problem) warnings.push(`${key}=${val}: ${problem}`);
                     break;
+                }
             }
         }
     });
 
-    return parsedQuery;
+    return warnings;
 }
 
 /**

package/src/utils.js

@@ -657,6 +657,12 @@ export function getKeyMap(keyLayout) {
         keys2[shiftDown][s] = colRow;
     }
 
+    // Overriding a default is the point here, so unlike `map` this doesn't warn about the clash.
+    function remap(s, colRow) {
+        keys2[true][s] = colRow;
+        keys2[false][s] = colRow;
+    }
+
     // shiftDown undefined -> map both
     function map(s, colRow, shiftDown) {
         if ((!s && s !== 0) || !colRow) {
@@ -935,11 +941,10 @@ export function getKeyMap(keyLayout) {
     // eg Master Dunjunz needs # Del 3 , * Enter
     // https://web.archive.org/web/20080305042238/http://bbc.nvg.org/doc/games/Dunjunz-docs.txt
 
-    // user keymapping
-    // do last (to override defaults)
-    while (userKeymap.length > 0) {
-        const mapping = userKeymap.pop();
-        map(keyCodes[mapping.native], BBC[mapping.bbc]);
+    // `KEY.` URL parameters, applied last so they win. Not consumed: this map is rebuilt on
+    // layout and model changes, and the user's mapping has to survive that.
+    for (const mapping of userKeymap) {
+        remap(keyCodes[mapping.native], BBC[mapping.key]);
     }
 
     return keys2;

package/src/utils_atom.js

@@ -249,6 +249,12 @@ export function getKeyMapAtom(keyLayout) {
         keys2[shiftDown][s] = colRow;
     }
 
+    // Overriding a default is the point here, so unlike `map` this doesn't warn about the clash.
+    function remap(s, colRow) {
+        keys2[true][s] = colRow;
+        keys2[false][s] = colRow;
+    }
+
     // shiftDown undefined -> map both
     function map(s, colRow, shiftDown) {
         if ((!s && s !== 0) || !colRow) {
@@ -477,11 +483,9 @@ export function getKeyMapAtom(keyLayout) {
         // Z - M normal
     }
 
-    // user keymapping
-    // do last (to override defaults)
-    while (userKeymap.length > 0) {
-        const mapping = userKeymap.pop();
-        map(keyCodes[mapping.native], ATOM[mapping.atom]);
+    // `KEY.` URL parameters, applied last so they win. See the equivalent in `getKeyMap`.
+    for (const mapping of userKeymap) {
+        remap(keyCodes[mapping.native], ATOM[mapping.key]);
     }
 
     return keys2;

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;