jsbeeb 1.10.0 → 1.12.0

package/src/models.js

@@ -98,8 +98,8 @@ const masterSwram = [
 
 export const allModels = [
     new Model({
-        name: "BBC B with DFS 1.2",
-        synonyms: ["B-DFS1.2"],
+        name: "BBC B with 8271 (DFS 1.2)",
+        synonyms: ["B-DFS1.2", "BBC B with DFS 1.2"],
         os: ["os.rom", "BASIC.ROM", "b/DFS-1.2.rom"],
         cpuModel: CpuModel.MOS6502,
         isMaster: false,
@@ -107,8 +107,8 @@ export const allModels = [
         fdc: NoiseAwareIntelFdc,
     }),
     new Model({
-        name: "BBC B with DFS 0.9",
-        synonyms: ["B-DFS0.9", "B"],
+        name: "BBC B with 8271 (DFS 0.9)",
+        synonyms: ["B-DFS0.9", "B", "BBC B with DFS 0.9"],
         os: ["os.rom", "BASIC.ROM", "b/DFS-0.9.rom"],
         cpuModel: CpuModel.MOS6502,
         isMaster: false,

package/src/snapshot-helpers.js

@@ -0,0 +1,208 @@
+"use strict";
+
+// Shared helpers for snapshot importers (bem-snapshot.js, uef-snapshot.js).
+// Contains volume table, default peripheral state, video state builder,
+// and the common snapshot envelope that wraps per-format parsed state.
+
+// Volume lookup table matching soundchip.js
+export const volumeTable = new Float32Array(16);
+(() => {
+    let f = 1.0;
+    for (let i = 0; i < 15; ++i) {
+        volumeTable[i] = f / 4;
+        f *= Math.pow(10, -0.1);
+    }
+    volumeTable[15] = 0;
+})();
+
+export const DefaultAcia = {
+    sr: 0x02,
+    cr: 0x00,
+    dr: 0x00,
+    rs423Selected: false,
+    motorOn: false,
+    tapeCarrierCount: 0,
+    tapeDcdLineLevel: false,
+    hadDcdHigh: false,
+    serialReceiveRate: 19200,
+    serialReceiveCyclesPerByte: 0,
+    txCompleteTaskOffset: null,
+    runTapeTaskOffset: null,
+    runRs423TaskOffset: null,
+};
+
+export const DefaultAdc = { status: 0x40, low: 0x00, high: 0x00, taskOffset: null };
+
+/**
+ * Build jsbeeb video state from parsed CRTC, ULA, and palette data.
+ * @param {number} ulaControl - VideoULA control register
+ * @param {Uint8Array} ulaPalette - 16-entry raw ULA palette register values (lower nibble of &FE21 writes)
+ * @param {Uint8Array} crtcRegs - CRTC registers (at least 18 bytes)
+ * @param {Int32Array|null} [nulaCollook] - NULA colour lookup (16 ABGR entries), or null for default BBC palette
+ * @param {object|null} [crtcCounters] - CRTC counter state {hc, vc, sc, ma, maback}, or null for defaults
+ */
+export function buildVideoState(ulaControl, ulaPalette, crtcRegs, nulaCollook, crtcCounters) {
+    const regs = new Uint8Array(32);
+    regs.set(crtcRegs.slice(0, 18));
+    const actualPal = new Uint8Array(16);
+    for (let i = 0; i < 16; i++) actualPal[i] = ulaPalette[i] & 0x0f;
+
+    // Use NULA collook if provided, otherwise use default BBC palette
+    const collook =
+        nulaCollook ||
+        new Int32Array([
+            0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff, 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff, 0xff000000,
+            0xff0000ff, 0xff00ff00, 0xff00ffff, 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff,
+        ]);
+
+    // Compute ulaPal from actualPal + collook, matching jsbeeb's Ula._recomputeUlaPal
+    const flashEnabled = !!(ulaControl & 1);
+    const defaultFlash = new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1]);
+    const flash = defaultFlash;
+    const ulaPal = new Int32Array(16);
+    for (let i = 0; i < 16; i++) {
+        const palVal = actualPal[i];
+        let colour = collook[(palVal & 0xf) ^ 7];
+        if (palVal & 8 && flashEnabled && flash[(palVal & 7) ^ 7]) {
+            colour = collook[palVal & 0xf];
+        }
+        ulaPal[i] = colour;
+    }
+
+    return {
+        regs,
+        bitmapX: 0,
+        bitmapY: 0,
+        oddClock: false,
+        frameCount: 0,
+        doEvenFrameLogic: false,
+        isEvenRender: true,
+        lastRenderWasEven: false,
+        firstScanline: true,
+        inHSync: false,
+        inVSync: false,
+        hadVSyncThisRow: false,
+        checkVertAdjust: false,
+        endOfMainLatched: false,
+        endOfVertAdjustLatched: false,
+        endOfFrameLatched: false,
+        inVertAdjust: false,
+        inDummyRaster: false,
+        hpulseWidth: regs[3] & 0x0f,
+        vpulseWidth: (regs[3] & 0xf0) >>> 4,
+        hpulseCounter: 0,
+        vpulseCounter: 0,
+        dispEnabled: 0x3f,
+        horizCounter: crtcCounters ? crtcCounters.hc : 0,
+        vertCounter: crtcCounters ? crtcCounters.vc : 0,
+        scanlineCounter: crtcCounters ? crtcCounters.sc : 0,
+        vertAdjustCounter: 0,
+        addr: crtcCounters ? crtcCounters.ma : (regs[13] | (regs[12] << 8)) & 0x3fff,
+        lineStartAddr: crtcCounters ? crtcCounters.maback : (regs[13] | (regs[12] << 8)) & 0x3fff,
+        nextLineStartAddr: crtcCounters ? crtcCounters.maback : (regs[13] | (regs[12] << 8)) & 0x3fff,
+        ulactrl: ulaControl,
+        pixelsPerChar: ulaControl & 0x10 ? 8 : 16,
+        halfClock: !(ulaControl & 0x10),
+        ulaMode: (ulaControl >>> 2) & 3,
+        teletextMode: !!(ulaControl & 2),
+        displayEnableSkew: Math.min((regs[8] & 0x30) >>> 4, 2),
+        ulaPal,
+        actualPal,
+        cursorOn: false,
+        cursorOff: false,
+        cursorOnThisFrame: false,
+        cursorDrawIndex: 0,
+        cursorPos: (regs[15] | (regs[14] << 8)) & 0x3fff,
+        interlacedSyncAndVideo: (regs[8] & 3) === 3,
+        screenSubtract: 0,
+        ula: {
+            collook: collook.slice(),
+            flash: new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1]),
+            paletteWriteFlag: false,
+            paletteFirstByte: 0,
+            paletteMode: 0,
+            horizontalOffset: 0,
+            leftBlank: 0,
+            disabled: false,
+            attributeMode: 0,
+            attributeText: 0,
+        },
+        crtc: { curReg: 0 },
+        teletext: {
+            prevCol: 0,
+            col: 7,
+            bg: 0,
+            sep: false,
+            dbl: false,
+            oldDbl: false,
+            secondHalfOfDouble: false,
+            wasDbl: false,
+            gfx: false,
+            flash: false,
+            flashOn: false,
+            flashTime: 0,
+            heldChar: 0,
+            holdChar: false,
+            dataQueue: [0, 0, 0, 0],
+            scanlineCounter: 0,
+            levelDEW: false,
+            levelDISPTMG: false,
+            levelRA0: false,
+            nextGlyphs: "normal",
+            curGlyphs: "normal",
+            heldGlyphs: "normal",
+        },
+    };
+}
+
+/**
+ * Build a jsbeeb snapshot envelope from parsed emulator components.
+ * @param {string} importedFrom - source identifier (e.g. "b-em", "beebem-uef")
+ * @param {string} modelName - jsbeeb model name/synonym
+ * @param {object} cpuState - parsed CPU state {a, x, y, flags, s, pc, nmi, fe30, fe34}
+ * @param {Uint8Array} ram - 128KB RAM array
+ * @param {Uint8Array|null} roms - 256KB sideways ROM/RAM array, or null
+ * @param {object} sysvia - jsbeeb sys VIA state
+ * @param {object} uservia - jsbeeb user VIA state
+ * @param {object} video - jsbeeb video state (from buildVideoState)
+ * @param {object} soundChip - jsbeeb sound chip state
+ */
+export function buildSnapshot(importedFrom, modelName, cpuState, ram, roms, sysvia, uservia, video, soundChip) {
+    return {
+        format: "jsbeeb-snapshot",
+        version: 2,
+        model: modelName,
+        timestamp: new Date().toISOString(),
+        importedFrom,
+        state: {
+            a: cpuState.a,
+            x: cpuState.x,
+            y: cpuState.y,
+            s: cpuState.s,
+            pc: cpuState.pc,
+            p: cpuState.flags | 0x30,
+            nmiLevel: !!cpuState.nmi,
+            nmiEdge: false,
+            halted: false,
+            takeInt: false,
+            romsel: cpuState.fe30 ?? 0,
+            acccon: cpuState.fe34 ?? 0,
+            videoDisplayPage: 0,
+            currentCycles: 0,
+            targetCycles: 0,
+            cycleSeconds: 0,
+            peripheralCycles: 0,
+            videoCycles: 0,
+            music5000PageSel: 0,
+            ram,
+            ...(roms instanceof Uint8Array ? { roms } : {}),
+            scheduler: { epoch: 0 },
+            sysvia,
+            uservia,
+            video,
+            soundChip,
+            acia: { ...DefaultAcia },
+            adc: { ...DefaultAdc },
+        },
+    };
+}

package/src/snapshot.js

@@ -7,24 +7,15 @@ const SnapshotFormat = "jsbeeb-snapshot";
 const SnapshotVersion = 2;
 
 /**
- * Check if two model names are compatible for state restore.
- * Resolves synonyms via findModel, then compares by stripping any
- * trailing parenthesised suffix (e.g. treating "BBC Master 128 (DFS)"
- * and "BBC Master 128 (ADFS)" as compatible). Does not treat
- * differently-named models like "BBC B with DFS 0.9" vs "BBC B with DFS 1.2"
- * as compatible — those are distinct models.
+ * Check if two model names resolve to the same model (accounting for
+ * synonyms and old names). Used to decide whether a page reload is
+ * needed when loading a snapshot saved under a different model name.
  */
-export function modelsCompatible(snapshotModel, currentModel) {
-    if (snapshotModel === currentModel) return true;
-    const resolvedSnapshot = findModel(snapshotModel);
-    const resolvedCurrent = findModel(currentModel);
-    if (resolvedSnapshot && resolvedCurrent) {
-        // Same model object, or same base machine (strip filesystem suffix)
-        if (resolvedSnapshot === resolvedCurrent) return true;
-        const base = (name) => name.replace(/\s*\(.*\)$/, "");
-        return base(resolvedSnapshot.name) === base(resolvedCurrent.name);
-    }
-    return false;
+export function isSameModel(nameA, nameB) {
+    if (nameA === nameB) return true;
+    const a = findModel(nameA);
+    const b = findModel(nameB);
+    return a !== null && a === b;
 }
 
 // Map of TypedArray constructor names for deserialization
@@ -100,7 +91,7 @@ export function restoreSnapshot(cpu, model, snapshot) {
     if (snapshot.version > SnapshotVersion) {
         throw new Error(`Snapshot version ${snapshot.version} is newer than supported version ${SnapshotVersion}`);
     }
-    if (!modelsCompatible(snapshot.model, model.name)) {
+    if (!isSameModel(snapshot.model, model.name)) {
         throw new Error(`Model mismatch: snapshot is for "${snapshot.model}" but current model is "${model.name}"`);
     }
     cpu.restoreState(snapshot.state);

package/src/sth.js

@@ -52,7 +52,7 @@ export class StairwayToHell {
         const response = await fetch(name);
         if (!response.ok) throw new Error("Network response was not ok");
         try {
-            return utils.unzipDiscImage(new Uint8Array(await response.arrayBuffer())).data;
+            return (await utils.unzipDiscImage(new Uint8Array(await response.arrayBuffer()))).data;
         } catch (error) {
             console.error("Failed to fetch file:", error);
             throw error;

package/src/tapes.js

@@ -245,8 +245,8 @@ class TapefileTape {
     }
 }
 
-export function loadTapeFromData(name, data) {
-    const stream = new utils.DataStream(name, data);
+export async function loadTapeFromData(name, data) {
+    const stream = await utils.DataStream.create(name, data);
     if (stream.readByte(0) === 0xff && stream.readByte(1) === 0x04) {
         console.log("Detected a 'tapefile' tape");
         return new TapefileTape(stream);