jsbeeb 1.4.0 → 1.5.0

package/src/teletext.js

@@ -1,6 +1,7 @@
 "use strict";
 import { makeChars } from "./teletext_data.js";
 import { makeFast32 } from "./utils.js";
+import { BbcDefaultPalette as BbcDefaultCollook } from "./bbc-palette.js";
 
 export class Teletext {
     constructor() {
@@ -35,22 +36,8 @@ export class Teletext {
     init() {
         const charData = makeChars();
 
-        // Build palette
-        const gamma = 1.0 / 2.2;
-        for (let i = 0; i < 256; ++i) {
-            const alpha = (i & 3) / 3.0;
-            const foregroundR = !!(i & 4);
-            const foregroundG = !!(i & 8);
-            const foregroundB = !!(i & 16);
-            const backgroundR = !!(i & 32);
-            const backgroundG = !!(i & 64);
-            const backgroundB = !!(i & 128);
-            // Gamma-corrected blending
-            const blendedR = Math.pow(foregroundR * alpha + backgroundR * (1.0 - alpha), gamma) * 240;
-            const blendedG = Math.pow(foregroundG * alpha + backgroundG * (1.0 - alpha), gamma) * 240;
-            const blendedB = Math.pow(foregroundB * alpha + backgroundB * (1.0 - alpha), gamma) * 240;
-            this.colour[i] = blendedR | (blendedG << 8) | (blendedB << 16) | (0xff << 24);
-        }
+        // Build palette from BBC default colours.
+        this.rebuildColours(BbcDefaultCollook);
 
         function getLoResGlyphRow(c, row) {
             if (row < 0 || row >= 20) {
@@ -135,6 +122,34 @@ export class Teletext {
         makeHiResGlyphs(this.separatedGlyphs, true);
     }
 
+    /**
+     * Rebuild the 256-entry colour lookup from a 16-entry ABGR collook palette.
+     * Each entry encodes: bits 7-5 = background colour index (0-7),
+     * bits 4-2 = foreground colour index (0-7), bits 1-0 = blend weight.
+     * Reference: b-em mode7_gen_nula_lookup().
+     * @param {Uint32Array} collook - 16-entry palette in ABGR format (0xffBBGGRR).
+     */
+    rebuildColours(collook) {
+        const gamma = 1.0 / 2.2;
+        for (let i = 0; i < 256; ++i) {
+            const weight = (i & 3) / 3.0;
+            const fgIndex = (i >> 2) & 7;
+            const bgIndex = (i >> 5) & 7;
+            const fgColour = collook[fgIndex];
+            const bgColour = collook[bgIndex];
+            const fgR = (fgColour & 0xff) / 255;
+            const fgG = ((fgColour >> 8) & 0xff) / 255;
+            const fgB = ((fgColour >> 16) & 0xff) / 255;
+            const bgR = (bgColour & 0xff) / 255;
+            const bgG = ((bgColour >> 8) & 0xff) / 255;
+            const bgB = ((bgColour >> 16) & 0xff) / 255;
+            const blendedR = Math.pow(fgR * weight + bgR * (1.0 - weight), gamma) * 240;
+            const blendedG = Math.pow(fgG * weight + bgG * (1.0 - weight), gamma) * 240;
+            const blendedB = Math.pow(fgB * weight + bgB * (1.0 - weight), gamma) * 240;
+            this.colour[i] = blendedR | 0 | ((blendedG | 0) << 8) | ((blendedB | 0) << 16) | (0xff << 24);
+        }
+    }
+
     setNextChars() {
         if (this.gfx) {
             if (this.sep) {

package/src/via.js

@@ -460,7 +460,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;

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,182 @@ 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;
+        }
+    }
+
+    // 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);
         }
     }
 }
@@ -320,16 +460,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 +800,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 +837,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 +861,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 +941,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({