jsbeeb 1.4.0 → 1.6.0

package/src/via.js

@@ -402,6 +402,73 @@ class Via {
         this.portBUpdated();
     }
 
+    snapshotState() {
+        return {
+            ora: this.ora,
+            orb: this.orb,
+            ira: this.ira,
+            irb: this.irb,
+            ddra: this.ddra,
+            ddrb: this.ddrb,
+            sr: this.sr,
+            t1l: this.t1l,
+            t2l: this.t2l,
+            t1c: this.t1c,
+            t2c: this.t2c,
+            acr: this.acr,
+            pcr: this.pcr,
+            ifr: this.ifr,
+            ier: this.ier,
+            t1hit: this.t1hit,
+            t2hit: this.t2hit,
+            portapins: this.portapins,
+            portbpins: this.portbpins,
+            ca1: this.ca1,
+            ca2: this.ca2,
+            cb1: this.cb1,
+            cb2: this.cb2,
+            justhit: this.justhit,
+            t1_pb7: this.t1_pb7,
+            lastPolltime: this.lastPolltime,
+            taskOffset: this.task.scheduled() ? this.task.expireEpoch - this.scheduler.epoch : null,
+        };
+    }
+
+    restoreState(state) {
+        this.ora = state.ora;
+        this.orb = state.orb;
+        this.ira = state.ira;
+        this.irb = state.irb;
+        this.ddra = state.ddra;
+        this.ddrb = state.ddrb;
+        this.sr = state.sr;
+        this.t1l = state.t1l;
+        this.t2l = state.t2l;
+        this.t1c = state.t1c;
+        this.t2c = state.t2c;
+        this.acr = state.acr;
+        this.pcr = state.pcr;
+        this.ifr = state.ifr;
+        this.ier = state.ier;
+        this.t1hit = state.t1hit;
+        this.t2hit = state.t2hit;
+        this.portapins = state.portapins;
+        this.portbpins = state.portbpins;
+        this.ca1 = state.ca1;
+        this.ca2 = state.ca2;
+        this.cb1 = state.cb1;
+        this.cb2 = state.cb2;
+        this.justhit = state.justhit;
+        this.t1_pb7 = state.t1_pb7;
+        this.lastPolltime = state.lastPolltime;
+        this.updateIFR();
+        if (state.taskOffset !== null) {
+            this.task.reschedule(state.taskOffset);
+        } else {
+            this.task.cancel();
+        }
+    }
+
     setca1(level) {
         if (level === this.ca1) return;
         const pcrSet = !!(this.pcr & 1);
@@ -460,7 +527,7 @@ class Via {
 }
 
 export class SysVia extends Via {
-    constructor(cpu, scheduler, video, soundChip, cmos, isMaster, initialLayout, getGamepads) {
+    constructor(cpu, scheduler, { video, soundChip, cmos, isMaster, initialLayout, getGamepads } = {}) {
         super(cpu, scheduler, 0x01);
 
         this.IC32 = 0;
@@ -484,6 +551,30 @@ export class SysVia extends Via {
         this.reset();
     }
 
+    snapshotState() {
+        return {
+            ...super.snapshotState(),
+            IC32: this.IC32,
+            capsLockLight: this.capsLockLight,
+            shiftLockLight: this.shiftLockLight,
+        };
+    }
+
+    restoreState(state) {
+        super.restoreState(state);
+        this.IC32 = state.IC32;
+        this.capsLockLight = state.capsLockLight;
+        this.shiftLockLight = state.shiftLockLight;
+        // Re-apply IC32 side effects (sound chip data bus, CMOS, port A)
+        // Must call portBUpdated directly (not recalculatePortBPins which
+        // overwrites IC32 based on portbpins) and then re-set IC32.
+        this.portBUpdated();
+        this.IC32 = state.IC32;
+        this.capsLockLight = state.capsLockLight;
+        this.shiftLockLight = state.shiftLockLight;
+        this.recalculatePortAPins();
+    }
+
     setKeyLayout(map) {
         this.keycodeToRowCol = utils.getKeyMap(map);
     }

package/src/video.js

@@ -1,6 +1,7 @@
 "use strict";
 import { Teletext } from "./teletext.js";
 import * as utils from "./utils.js";
+import { BbcDefaultPalette as NulaDefaultPalette } from "./bbc-palette.js";
 
 export const VDISPENABLE = 1 << 0;
 export const HDISPENABLE = 1 << 1;
@@ -15,43 +16,212 @@ export const OPAQUE_BLACK = 0xff000000;
 export const OPAQUE_WHITE = 0xffffffff;
 
 ////////////////////
-// ULA interface
+// VideoNULA - programmable 12-bit RGB palette extension (RobC hardware mod).
+// Reference: b-em src/video.c (stardot/b-em).
+// Addresses &FE22 (control) and &FE23 (palette) via 2-byte write protocol.
+
+////////////////////
+// ULA interface (includes NULA programmable palette support)
 class Ula {
     constructor(video) {
         this.video = video;
+        // NULA state
+        this.collook = new Uint32Array(16);
+        this.flash = new Uint8Array(8);
+        this.paletteWriteFlag = false;
+        this.paletteFirstByte = 0;
+        this.paletteMode = 0;
+        this.horizontalOffset = 0;
+        this.leftBlank = 0;
+        this.disabled = false;
+        this.attributeMode = 0;
+        this.attributeText = 0;
+        this.reset();
+    }
+
+    reset() {
+        this.collook.set(NulaDefaultPalette);
+        this.flash.fill(1);
+        this.paletteWriteFlag = false;
+        this.paletteFirstByte = 0;
+        this.paletteMode = 0;
+        this.horizontalOffset = 0;
+        this.leftBlank = 0;
+        this.attributeMode = 0;
+        this.attributeText = 0;
+        // Note: disabled is NOT cleared by reset (matches b-em behaviour).
+        // Recompute rendered palette so any custom NULA colours are flushed.
+        this._recomputeUlaPal(!!(this.video.ulactrl & 1));
+        // Rebuild MODE 7 teletext colours from the restored default palette.
+        this.video.teletext.rebuildColours(this.collook);
     }
 
     write(addr, val) {
         addr |= 0;
         val |= 0;
-        if (addr & 1) {
-            const index = (val >>> 4) & 0xf;
-            this.video.actualPal[index] = val & 0xf;
-            let ulaCol = val & 7;
-            if (!(val & 8 && this.video.ulactrl & 1)) ulaCol ^= 7;
-            if (this.video.ulaPal[index] !== this.video.collook[ulaCol]) {
-                this.video.ulaPal[index] = this.video.collook[ulaCol];
-            }
+        let reg = addr & 3;
+
+        // When NULA is disabled, mask off bit 1 so &FE22/&FE23 become &FE20/&FE21.
+        if (reg >= 2 && this.disabled) {
+            reg &= ~2;
+        }
+
+        switch (reg) {
+            case 0:
+                this._writeControl(val);
+                break;
+            case 1:
+                this._writePalette(val);
+                break;
+            case 2:
+                this._writeNulaControl(val);
+                break;
+            case 3:
+                this._writeNulaPalette(val);
+                break;
+        }
+    }
+
+    snapshotState() {
+        return {
+            collook: this.collook.slice(),
+            flash: this.flash.slice(),
+            paletteWriteFlag: this.paletteWriteFlag,
+            paletteFirstByte: this.paletteFirstByte,
+            paletteMode: this.paletteMode,
+            horizontalOffset: this.horizontalOffset,
+            leftBlank: this.leftBlank,
+            disabled: this.disabled,
+            attributeMode: this.attributeMode,
+            attributeText: this.attributeText,
+        };
+    }
+
+    restoreState(state) {
+        this.collook.set(state.collook);
+        this.flash.set(state.flash);
+        this.paletteWriteFlag = state.paletteWriteFlag;
+        this.paletteFirstByte = state.paletteFirstByte;
+        this.paletteMode = state.paletteMode;
+        this.horizontalOffset = state.horizontalOffset;
+        this.leftBlank = state.leftBlank;
+        this.disabled = state.disabled;
+        this.attributeMode = state.attributeMode;
+        this.attributeText = state.attributeText;
+        this._recomputeUlaPal(!!(this.video.ulactrl & 1));
+        this.video.teletext.rebuildColours(this.collook);
+    }
+
+    // ULA control register (&FE20).
+    _writeControl(val) {
+        if ((this.video.ulactrl ^ val) & 1) {
+            // Flash state has changed - recompute all palette entries.
+            this._recomputeUlaPal(!!(val & 1));
+        }
+        this.video.ulactrl = val;
+        this.video.pixelsPerChar = val & 0x10 ? 8 : 16;
+        this.video.halfClock = !(val & 0x10);
+        const newMode = (val >>> 2) & 3;
+        if (newMode !== this.video.ulaMode) {
+            this.video.ulaMode = newMode;
+        }
+        this.video.teletextMode = !!(val & 2);
+    }
+
+    // ULA palette register (&FE21).
+    _writePalette(val) {
+        const index = (val >>> 4) & 0xf;
+        this.video.actualPal[index] = val & 0xf;
+        // Default: XOR lower 3 bits with 7 for steady colour.
+        let colour = this.collook[(val & 0xf) ^ 7];
+        // Flash override: if flash bit set, flash globally enabled, and per-colour flash active.
+        if (val & 8 && this.video.ulactrl & 1 && this.flash[(val & 7) ^ 7]) {
+            colour = this.collook[val & 0xf];
+        }
+        if (this.video.ulaPal[index] !== colour) {
+            this.video.ulaPal[index] = colour;
+        }
+    }
+
+    // NULA control register (&FE22).
+    _writeNulaControl(val) {
+        const reg = (val >>> 4) & 0xf;
+        const param = val & 0xf;
+        switch (reg) {
+            case 1:
+                this.paletteMode = param & 1;
+                break;
+            case 2:
+                this.horizontalOffset = param & 7;
+                break;
+            case 3:
+                this.leftBlank = param & 0xf;
+                break;
+            case 4:
+                this.reset();
+                break;
+            case 5:
+                this.disabled = true;
+                break;
+            case 6:
+                this.attributeMode = param & 3;
+                break;
+            case 7:
+                this.attributeText = param & 1;
+                break;
+            case 8:
+                this.flash[0] = param & 8 ? 1 : 0;
+                this.flash[1] = param & 4 ? 1 : 0;
+                this.flash[2] = param & 2 ? 1 : 0;
+                this.flash[3] = param & 1 ? 1 : 0;
+                this._recomputeUlaPal(!!(this.video.ulactrl & 1));
+                break;
+            case 9:
+                this.flash[4] = param & 8 ? 1 : 0;
+                this.flash[5] = param & 4 ? 1 : 0;
+                this.flash[6] = param & 2 ? 1 : 0;
+                this.flash[7] = param & 1 ? 1 : 0;
+                this._recomputeUlaPal(!!(this.video.ulactrl & 1));
+                break;
+            // Regs 14 (border colour) and 15 (blank colour) are stubbed - rendering not yet implemented.
+        }
+    }
+
+    // NULA palette register (&FE23) - 2-byte write protocol.
+    _writeNulaPalette(val) {
+        if (this.paletteWriteFlag) {
+            const c = (this.paletteFirstByte >>> 4) & 0xf;
+            const r = this.paletteFirstByte & 0x0f;
+            const g = (val >>> 4) & 0x0f;
+            const b = val & 0x0f;
+            // Expand 4-bit channels to 8-bit by duplicating the nibble.
+            // Store in ABGR format (Uint32Array on little-endian = canvas RGBA).
+            this.collook[c] = 0xff000000 | ((b | (b << 4)) << 16) | ((g | (g << 4)) << 8) | (r | (r << 4));
+            // Colours 8-15 default to solid (non-flashing) when programmed.
+            if (c >= 8) this.flash[c - 8] = 0;
+            // Recompute all rendered palette entries from current state.
+            this._recomputeUlaPal(!!(this.video.ulactrl & 1));
+            // MODE 7 teletext uses its own colour lookup; rebuild when a base colour changes.
+            if (c < 8) this.video.teletext.rebuildColours(this.collook);
         } else {
-            if ((this.video.ulactrl ^ val) & 1) {
-                // Flash colour has changed.
-                const flashEnabled = !!(val & 1);
-                for (let i = 0; i < 16; ++i) {
-                    let index = this.video.actualPal[i] & 7;
-                    if (!(flashEnabled && this.video.actualPal[i] & 8)) index ^= 7;
-                    if (this.video.ulaPal[i] !== this.video.collook[index]) {
-                        this.video.ulaPal[i] = this.video.collook[index];
-                    }
-                }
+            this.paletteFirstByte = val;
+        }
+        this.paletteWriteFlag = !this.paletteWriteFlag;
+    }
+
+    // Recompute all 16 ulaPal entries from actualPal + NULA collook + flash state.
+    // Follows b-em's palette recomputation logic exactly.
+    _recomputeUlaPal(flashEnabled) {
+        const video = this.video;
+        for (let i = 0; i < 16; ++i) {
+            const palVal = video.actualPal[i];
+            let colour = this.collook[(palVal & 0xf) ^ 7];
+            if (palVal & 8 && flashEnabled && this.flash[(palVal & 7) ^ 7]) {
+                colour = this.collook[palVal & 0xf];
             }
-            this.video.ulactrl = val;
-            this.video.pixelsPerChar = val & 0x10 ? 8 : 16;
-            this.video.halfClock = !(val & 0x10);
-            const newMode = (val >>> 2) & 3;
-            if (newMode !== this.video.ulaMode) {
-                this.video.ulaMode = newMode;
+            if (video.ulaPal[i] !== colour) {
+                video.ulaPal[i] = colour;
             }
-            this.video.teletextMode = !!(val & 2);
         }
     }
 }
@@ -68,6 +238,14 @@ class Crtc {
         ]);
     }
 
+    snapshotState() {
+        return { curReg: this.curReg };
+    }
+
+    restoreState(state) {
+        this.curReg = state.curReg;
+    }
+
     read(addr) {
         if (!(addr & 1)) return 0;
         switch (this.curReg) {
@@ -249,6 +427,111 @@ export class Video {
         this.paint();
     }
 
+    snapshotState() {
+        return {
+            regs: this.regs.slice(),
+            bitmapX: this.bitmapX,
+            bitmapY: this.bitmapY,
+            oddClock: this.oddClock,
+            frameCount: this.frameCount,
+            doEvenFrameLogic: this.doEvenFrameLogic,
+            isEvenRender: this.isEvenRender,
+            lastRenderWasEven: this.lastRenderWasEven,
+            firstScanline: this.firstScanline,
+            inHSync: this.inHSync,
+            inVSync: this.inVSync,
+            hadVSyncThisRow: this.hadVSyncThisRow,
+            checkVertAdjust: this.checkVertAdjust,
+            endOfMainLatched: this.endOfMainLatched,
+            endOfVertAdjustLatched: this.endOfVertAdjustLatched,
+            endOfFrameLatched: this.endOfFrameLatched,
+            inVertAdjust: this.inVertAdjust,
+            inDummyRaster: this.inDummyRaster,
+            hpulseWidth: this.hpulseWidth,
+            vpulseWidth: this.vpulseWidth,
+            hpulseCounter: this.hpulseCounter,
+            vpulseCounter: this.vpulseCounter,
+            dispEnabled: this.dispEnabled,
+            horizCounter: this.horizCounter,
+            vertCounter: this.vertCounter,
+            scanlineCounter: this.scanlineCounter,
+            vertAdjustCounter: this.vertAdjustCounter,
+            addr: this.addr,
+            lineStartAddr: this.lineStartAddr,
+            nextLineStartAddr: this.nextLineStartAddr,
+            ulactrl: this.ulactrl,
+            pixelsPerChar: this.pixelsPerChar,
+            halfClock: this.halfClock,
+            ulaMode: this.ulaMode,
+            teletextMode: this.teletextMode,
+            displayEnableSkew: this.displayEnableSkew,
+            ulaPal: this.ulaPal.slice(),
+            actualPal: this.actualPal.slice(),
+            cursorOn: this.cursorOn,
+            cursorOff: this.cursorOff,
+            cursorOnThisFrame: this.cursorOnThisFrame,
+            cursorDrawIndex: this.cursorDrawIndex,
+            cursorPos: this.cursorPos,
+            interlacedSyncAndVideo: this.interlacedSyncAndVideo,
+            screenSubtract: this.screenSubtract,
+            ula: this.ula.snapshotState(),
+            crtc: this.crtc.snapshotState(),
+            teletext: this.teletext.snapshotState(),
+        };
+    }
+
+    restoreState(state) {
+        this.regs.set(state.regs);
+        this.bitmapX = state.bitmapX;
+        this.bitmapY = state.bitmapY;
+        this.oddClock = state.oddClock;
+        this.frameCount = state.frameCount;
+        this.doEvenFrameLogic = state.doEvenFrameLogic;
+        this.isEvenRender = state.isEvenRender;
+        this.lastRenderWasEven = state.lastRenderWasEven;
+        this.firstScanline = state.firstScanline;
+        this.inHSync = state.inHSync;
+        this.inVSync = state.inVSync;
+        this.hadVSyncThisRow = state.hadVSyncThisRow;
+        this.checkVertAdjust = state.checkVertAdjust;
+        this.endOfMainLatched = state.endOfMainLatched;
+        this.endOfVertAdjustLatched = state.endOfVertAdjustLatched;
+        this.endOfFrameLatched = state.endOfFrameLatched;
+        this.inVertAdjust = state.inVertAdjust;
+        this.inDummyRaster = state.inDummyRaster;
+        this.hpulseWidth = state.hpulseWidth;
+        this.vpulseWidth = state.vpulseWidth;
+        this.hpulseCounter = state.hpulseCounter;
+        this.vpulseCounter = state.vpulseCounter;
+        this.dispEnabled = state.dispEnabled;
+        this.horizCounter = state.horizCounter;
+        this.vertCounter = state.vertCounter;
+        this.scanlineCounter = state.scanlineCounter;
+        this.vertAdjustCounter = state.vertAdjustCounter;
+        this.addr = state.addr;
+        this.lineStartAddr = state.lineStartAddr;
+        this.nextLineStartAddr = state.nextLineStartAddr;
+        this.ulactrl = state.ulactrl;
+        this.pixelsPerChar = state.pixelsPerChar;
+        this.halfClock = state.halfClock;
+        this.ulaMode = state.ulaMode;
+        this.teletextMode = state.teletextMode;
+        this.displayEnableSkew = state.displayEnableSkew;
+        this.actualPal.set(state.actualPal);
+        this.cursorOn = state.cursorOn;
+        this.cursorOff = state.cursorOff;
+        this.cursorOnThisFrame = state.cursorOnThisFrame;
+        this.cursorDrawIndex = state.cursorDrawIndex;
+        this.cursorPos = state.cursorPos;
+        this.interlacedSyncAndVideo = state.interlacedSyncAndVideo;
+        this.screenSubtract = state.screenSubtract;
+        this.ula.restoreState(state.ula);
+        this.crtc.restoreState(state.crtc);
+        this.teletext.restoreState(state.teletext);
+        // Restore ulaPal after ULA restore, since ULA recomputation may overwrite it
+        this.ulaPal.set(state.ulaPal);
+    }
+
     reset(cpu, via) {
         this.cpu = cpu;
         this.sysvia = via;
@@ -320,16 +603,20 @@ export class Video {
         destOffset |= 0;
         const offset = table4bppOffset(this.ulaMode, dat);
         const fb32 = this.fb32;
-        const ulaPal = this.ulaPal;
+        // 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 table4bpp = this.table4bpp;
         // Take advantage of numPixels being either 8 or 16
         if (numPixels === 8) {
             for (let i = 0; i < 8; ++i) {
-                fb32[destOffset + i] = ulaPal[table4bpp[offset + i]];
+                fb32[destOffset + i] = colourLookup[table4bpp[offset + i]];
             }
         } else {
             for (let i = 0; i < 16; ++i) {
-                fb32[destOffset + i] = ulaPal[table4bpp[offset + i]];
+                fb32[destOffset + i] = colourLookup[table4bpp[offset + i]];
             }
         }
     }
@@ -656,9 +943,11 @@ export class Video {
                 // Read data from address pointer if both horizontal and vertical display enabled.
                 const dat = this.readVideoMem();
                 if (insideBorder) {
-                    if (this.teletextMode) {
-                        this.teletext.fetchData(dat);
-                    }
+                    // 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".
+                    // See https://github.com/mattgodbolt/jsbeeb/issues/546
+                    this.teletext.fetchData(dat);
 
                     // Check cursor start.
                     if (
@@ -691,7 +980,17 @@ export class Video {
 
                     if ((this.dispEnabled & EVERYTHINGENABLED) === EVERYTHINGENABLED) {
                         if (this.teletextMode) {
-                            this.teletext.render(this.fb32, offset);
+                            if (this.halfClock) {
+                                // Proper MODE 7 (1MHz clock + teletext): render SAA5050 output normally.
+                                this.teletext.render(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.
+                                // 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);
                         }
@@ -705,6 +1004,14 @@ export class Video {
                 }
             }
 
+            // IC37/IC36: during H blanking with V display active, always feed
+            // 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.
+            if (!(this.dispEnabled & HDISPENABLE) && this.dispEnabled & VDISPENABLE) {
+                this.teletext.fetchData(this.readVideoMem() | 0x40);
+            }
+
             // CRTC MA always increments, inside display border or not.
             this.addr = (this.addr + 1) & 0x3fff;
 
@@ -777,11 +1084,19 @@ export class Video {
 
 export class FakeVideo {
     constructor() {
-        this.ula = this.crtc = {
+        this.crtc = {
+            read: function () {
+                return 0xff;
+            },
+            write: utils.noop,
+        };
+        this.ula = {
             read: function () {
                 return 0xff;
             },
             write: utils.noop,
+            reset: utils.noop,
+            disabled: false,
         };
         this.regs = new Uint8Array(32);
     }

package/src/wd-fdc.js

@@ -804,7 +804,12 @@ export class WdFdc {
         if (this._indexPulseCount < 6) return;
         if (this._commandType === 1) this._statusRegister |= Status.typeISpinUpDone;
         if (this._isCommandSettle) {
-            const settleMs = this._is1772 ? 15 : 30;
+            // The WD1770 datasheet specifies 30ms head settle, but empirical testing
+            // against b-em (which uses 15ms for all WD1770/2 variants) shows 15ms is
+            // correct for BBC hardware. Using 30ms causes disc streaming demos (e.g.
+            // STNICC-beeb on Master 128) to hang because sectors don't arrive before
+            // the first vsync IRQ. The WD1772 also uses 15ms per its datasheet.
+            const settleMs = 15;
             this._startTimer(TimerState.settle, settleMs * 1000);
         } else {
             this._dispatchCommand();

package/src/web/audio-handler.js

@@ -9,7 +9,7 @@ const rendererUrl = new URL("./audio-renderer.js", import.meta.url).href;
 const music5000WorkletUrl = new URL("../music5000-worklet.js", import.meta.url).href;
 
 export class AudioHandler {
-    constructor(warningNode, statsNode, audioFilterFreq, audioFilterQ, noSeek) {
+    constructor({ warningNode, statsNode, audioFilterFreq, audioFilterQ, noSeek } = {}) {
         this.warningNode = warningNode;
         this.warningNode.toggle(false);
         this.chart = new SmoothieChart({