jsbeeb 1.15.0 → 1.16.0

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "//engines": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": ">=24.15.0"
@@ -54,10 +54,6 @@
     "electron-builder": "^26.15.3",
     "electron-store": "^11.0.2"
   },
-  "//overrides": "brace-expansion forced to the patched version for GHSA-mh99-v99m-4gvg; the electron-builder dependency chain still pins vulnerable versions. Remove once `npm audit` is clean without it.",
-  "overrides": {
-    "brace-expansion": "^5.0.8"
-  },
   "license": "GPL-3.0-or-later",
   "build": {
     "appId": "org.godbolt.bbc",
@@ -99,15 +95,21 @@
     "test:unit": "vitest run --silent=true tests/unit",
     "test:integration": "vitest run --silent=true tests/integration",
     "test:cpu": "node tests/test-suite.js",
+    "test:shader": "vitest run --silent=true tests/shader",
     "coverage:unit": "vitest run tests/unit --coverage",
     "coverage:all-tests": "vitest run --coverage",
     "benchmark": "node src/app-bench.js",
+    "mirror-sth": "node tools/mirror-sth.js --out .sth-mirror",
+    "mirror-sth:check": "node tools/mirror-sth.js --index-only",
+    "mirror-sth:upload": "npm-run-all mirror-sth:upload:*",
+    "mirror-sth:upload:blobs": "aws s3 sync .sth-mirror s3://bbc.xania.org/archive/sth/ --no-progress --exclude '*manifest.json' --exclude 'meta/*' --cache-control 'public, max-age=31536000, immutable'",
+    "mirror-sth:upload:index": "aws s3 sync .sth-mirror s3://bbc.xania.org/archive/sth/ --no-progress --exclude '*' --include '*manifest.json' --include 'meta/*' --cache-control 'public, max-age=300'",
     "electron": "npm run build && ELECTRON_DISABLE_SANDBOX=1 electron .",
     "electron:build": "electron-builder"
   },
   "lint-staged": {
     "*.js": [
-      "vitest related --run --exclude tests/integration --no-file-parallelism",
+      "vitest related --run --exclude tests/integration --exclude tests/shader --no-file-parallelism",
       "eslint --cache --fix",
       "prettier --write"
     ],

package/src/6502.js

@@ -213,6 +213,9 @@ class Base6502 {
         if (this._nmiLevel && !prevLevel) this._nmiEdge = true;
     }
 
+    /** Called as the NMI vector is taken, for devices that withdraw their request at that point. */
+    nmiAcknowledged() {}
+
     polltime() {
         throw new Error("Must be overridden");
     }
@@ -239,6 +242,7 @@ class Base6502 {
         if ((this.model.nmos || isIrq) && this._nmiEdge) {
             vector = 0xfffa;
             this._nmiEdge = false;
+            this.nmiAcknowledged();
         }
         this.takeInt = false;
         this.pc = this.readmem(vector) | (this.readmem(vector + 1) << 8);
@@ -451,6 +455,10 @@ class Tube6502 extends Base6502 {
         return this.memory[offset & 0xffff];
     }
 
+    nmiAcknowledged() {
+        this.tube.acknowledgeNmi();
+    }
+
     writemem(addr, b) {
         if ((addr & 0xfff8) === 0xfef8) {
             return this.tube.parasiteWrite(addr, b);
@@ -666,7 +674,7 @@ export class Cpu6502 extends Base6502 {
         this.resetLine = true;
         this.cpuMultiplier = this.config.cpuMultiplier;
         this.videoCyclesBatch = this.config.videoCyclesBatch | 0;
-        this.peripheralCyclesPerSecond = 2 * 1000 * 1000;
+        this.peripheralCyclesPerSecond = model.cyclesPerSecond;
         this.hasTube = !!this.config.tube;
         this.hasMusic5000 = !!this.config.hasMusic5000;
         this.hasTeletextAdaptor = !!this.config.hasTeletextAdaptor;
@@ -1361,7 +1369,7 @@ export class Cpu6502 extends Base6502 {
         this.fdc.powerOnReset();
         this.adconverter.reset();
 
-        this.touchScreen = new TouchScreen(this.scheduler);
+        this.touchScreen = new TouchScreen(this.scheduler, this.model.cyclesPerSecond);
         if (this.econet) this.filestore = new Filestore(this, this.econet);
     }
 
@@ -1478,9 +1486,10 @@ export class Cpu6502 extends Base6502 {
         // that from both, to keep the domain low (while accumulating seconds). Take care to preserve the bottom
         // bit though; as that encodes whether we're on an even or odd bus cycle.
         const smaller = Math.min(this.targetCycles, this.currentCycles) & 0xfffffffe;
-        if (smaller >= 2 * 1000 * 1000) {
-            this.targetCycles -= 2 * 1000 * 1000;
-            this.currentCycles -= 2 * 1000 * 1000;
+        const cyclesPerSecond = this.model.cyclesPerSecond;
+        if (smaller >= cyclesPerSecond) {
+            this.targetCycles -= cyclesPerSecond;
+            this.currentCycles -= cyclesPerSecond;
             this.cycleSeconds++;
         }
         // Any tracing or debugging means we need to run the potentially slower version: the debug read or
@@ -1614,8 +1623,6 @@ export class AtomCpu6502 extends Cpu6502 {
             this.ramRomOs = expanded;
         }
 
-        // Atom runs at 1 MHz
-        this.peripheralCyclesPerSecond = 1 * 1000 * 1000;
         // reset() and debugger.setCpu() are called by initialise() after loadOs().
     }
 

package/src/6847.js

@@ -1,6 +1,7 @@
 "use strict";
 import * as utils from "./utils.js";
 import * as fontData from "./6847_fontdata.js";
+import { encodeLineGrid } from "./video-filters/pixel-grid.js";
 
 const VDISPENABLE = 1 << 0,
     HDISPENABLE = 1 << 1,
@@ -111,6 +112,11 @@ only 1 bit is used of SG6 - to get yellow/red, cyan/orange
 // constant for the graphics mode
 const MODE_AG = 0x10; // graphics mode
 
+// The MC6847 datasheet specifies 3.579545 MHz, but 3.638004 is used here as an
+// empirical correction to align VSync/interrupt timing with the CPU clock.
+// TODO: revisit once full integration is testable.
+const VdgClockMhz = 3.638004;
+
 export class Video6847 {
     constructor(video) {
         this.video = video;
@@ -175,6 +181,7 @@ export class Video6847 {
         this.bitmapPxPerPixel = 2; // each pixel is 2 bitmap pixels wide and high
         this.pixelsPerBit = this.bitmapPxPerPixel;
         this.bpp = 1;
+        this.updateLineGrid();
 
         this.cpuAddr = 0;
         this.dispEnabled = 0;
@@ -225,6 +232,9 @@ export class Video6847 {
     reset(cpu, ppia) {
         this.cpu = cpu;
         this.ppia = ppia;
+        // polltime() is handed CPU cycles, so how far the VDG advances per
+        // cycle depends on how fast the CPU it's attached to runs.
+        this.vdgCyclesPerCpuCycle = cpu ? VdgClockMhz / cpu.model.clockMhz : 0;
     }
 
     // USE PAINT from VIDEO
@@ -315,6 +325,7 @@ export class Video6847 {
         this.pixelsPerBit = this.bitmapPxPerPixel * this.modes[mode][1];
         let linesPerRow = this.modes[mode][2]; // move to reg9
         this.bpp = this.modes[mode][3];
+        this.updateLineGrid();
 
         this.charLinesreg9 = linesPerRow - 1; //2  - scanlines per char
 
@@ -344,11 +355,7 @@ export class Video6847 {
         // it doesn't draw the whole frame.  It regularly gives control back to the CPU.
 
         const vdgcharclock = this.pixelsPerChar / 2; // 4 or 8
-        // The MC6847 datasheet specifies 3.579545 MHz, but 3.638004 is used here
-        // as an empirical correction to align VSync/interrupt timing with the Atom's
-        // 1 MHz CPU clock. TODO: revisit once full integration is testable.
-        const vdgclock = 3.638004;
-        this.vdg_cycles += clocks * vdgclock;
+        this.vdg_cycles += clocks * this.vdgCyclesPerCpuCycle;
 
         const vdgframelines = 262; //  312 PAL (but no pal on standard atom)  262; // NTSC
         const vdglinetime = 228; // vdg cycles to do a line; not 227.5
@@ -491,9 +498,9 @@ export class Video6847 {
                         {
                             // TODO: Add in the INTEXT modifiers to mode (if necessary)
                             // blit into the fb32 buffer which is painted by VIDEO
-                            if ((mode & MODE_AG) === 0)
-                                // MODE_AG - bit 4; 0x10 is the AG bit
-                                this.blitChar(this.video.fb32, dat, offset, this.pixelsPerChar, css);
+                            const textMode = (mode & MODE_AG) === 0; // 0x10 is the AG bit
+                            this.recordLineGrid(textMode);
+                            if (textMode) this.blitChar(this.video.fb32, dat, offset, this.pixelsPerChar, css);
                             else this.blitPixels(this.video.fb32, dat, offset, css);
                         }
                     }
@@ -619,6 +626,41 @@ export class Video6847 {
         }
     }
 
+    /**
+     * Precompute this mode's grid descriptors, one per blitter.
+     *
+     * The two blitters derive their widths differently and cannot be unified:
+     * `blitChar` splits the character's texels across eight glyph bits, while
+     * `blitPixels` takes the bit width from the mode table — which for text
+     * mode holds -1, since it does not blit pixels at all.
+     *
+     * `pixelsPerBit` is right for graphics at 2bpp as well as 1bpp: the blitter
+     * steps its bit groups by `pixelsPerBit / bpp`, but reads the colour with
+     * `j & 0xe`, so pairs of groups share one and each pixel is twice as wide.
+     */
+    updateLineGrid() {
+        // Every 6847 blitter writes each pixel row into two framebuffer lines.
+        // Text mode's entry is only reachable through blitChar, which is just
+        // as well: the mode table holds -1 for it and would not encode.
+        this.lineGridText = encodeLineGrid((this.pixelsPerChar * this.bitmapPxPerPixel) / 8, true);
+        this.lineGridGraphics = this.pixelsPerBit > 0 ? encodeLineGrid(this.pixelsPerBit, true) : this.lineGridText;
+    }
+
+    /**
+     * Note the logical pixel size of the two rows about to be written, so
+     * display filters can see the picture as pixels rather than as raster
+     * samples (see video-filters/pixel-grid.js). Only the picture records a
+     * grid: the border is a solid colour, and letting it write here would
+     * leave the row describing the border rather than the picture on it.
+     *
+     * @param {boolean} textMode whether the character blitter is about to run
+     */
+    recordLineGrid(textMode) {
+        const grid = textMode ? this.lineGridText : this.lineGridGraphics;
+        this.video.lineGrid[this.bitmapY] = grid;
+        this.video.lineGrid[this.bitmapY + 1] = grid;
+    }
+
     blitChar(buf, data, destOffset, numPixels, css) {
         const scanline = this.scanlineCounter;
         const chr = data & 0x7f;

package/src/acia.js

@@ -265,8 +265,9 @@ export class Acia {
         }
     }
 
+    // Byte times are held in CPU cycles because that's what the scheduler counts.
     secondsToCycles(sec) {
-        return Math.floor(2 * 1000 * 1000 * sec) | 0;
+        return Math.floor(this.cpu.model.cyclesPerSecond * sec) | 0;
     }
 
     numBitsPerByte() {

package/src/canvas.js

@@ -2,10 +2,12 @@
 import webglDebug from "./lib/webgl-debug.js";
 import { PALCompositeFilter } from "./video-filters/pal-composite.js";
 import { PassthroughFilter } from "./video-filters/passthrough-filter.js";
+import { XbrFilter } from "./video-filters/xbr-filter.js";
 
 const DISPLAY_MODE_FILTERS = {
     pal: PALCompositeFilter,
     rgb: PassthroughFilter,
+    xbr: XbrFilter,
 };
 
 export function getFilterForMode(mode) {
@@ -13,8 +15,9 @@ export function getFilterForMode(mode) {
 }
 
 export class Canvas {
-    isWebGl() {
-        return false;
+    /** The 2D canvas draws the framebuffer as-is, which is what this filter is. */
+    get filterClass() {
+        return PassthroughFilter;
     }
 
     constructor(canvas) {
@@ -27,24 +30,29 @@ export class Canvas {
         this.backBuffer.height = 625;
         this.backCtx = this.backBuffer.getContext("2d", { alpha: false });
         this.imageData = this.backCtx.createImageData(this.backBuffer.width, this.backBuffer.height);
-        this.canvasWidth = canvas.width;
-        this.canvasHeight = canvas.height;
+        this.canvas = canvas;
 
         this.fb32 = new Uint32Array(this.imageData.data.buffer);
     }
-    paint(minx, miny, maxx, maxy, _frameCount) {
+
+    /** Nothing to release: the 2D context owns no objects of ours. */
+    dispose() {}
+
+    paint(minx, miny, maxx, maxy, _frame) {
         const width = maxx - minx;
         const height = maxy - miny;
         this.backCtx.putImageData(this.imageData, 0, 0, minx, miny, width, height);
-        this.ctx.drawImage(this.backBuffer, minx, miny, width, height, 0, 0, this.canvasWidth, this.canvasHeight);
+        // Read the size each time: it can change when the window is resized.
+        this.ctx.drawImage(this.backBuffer, minx, miny, width, height, 0, 0, this.canvas.width, this.canvas.height);
     }
 }
 
 const width = 1024;
 const height = 1024;
 export class GlCanvas {
-    isWebGl() {
-        return true;
+    /** The filter actually built, which may not be the one that was asked for. */
+    get filterClass() {
+        return this.filter.constructor;
     }
 
     constructor(canvas, filterClass) {
@@ -74,6 +82,10 @@ export class GlCanvas {
         const program = this.filter.program;
         checkedGl.useProgram(program);
 
+        // Filters that pick their own samples want the texels they asked for,
+        // not a hardware blend of the ones either side.
+        const sampling = filterClass.getDisplayConfig().nearestSampling ? checkedGl.NEAREST : checkedGl.LINEAR;
+
         this.fb8 = new Uint8Array(width * height * 4);
         this.fb32 = new Uint32Array(this.fb8.buffer);
         this.texture = checkedGl.createTexture();
@@ -81,8 +93,8 @@ export class GlCanvas {
         checkedGl.pixelStorei(checkedGl.UNPACK_ALIGNMENT, 4);
         checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_WRAP_S, checkedGl.CLAMP_TO_EDGE);
         checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_WRAP_T, checkedGl.CLAMP_TO_EDGE);
-        checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_MAG_FILTER, checkedGl.LINEAR);
-        checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_MIN_FILTER, checkedGl.LINEAR);
+        checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_MAG_FILTER, sampling);
+        checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_MIN_FILTER, sampling);
         checkedGl.texImage2D(
             checkedGl.TEXTURE_2D,
             0,
@@ -98,8 +110,8 @@ export class GlCanvas {
 
         const vertexPositionAttrLoc = checkedGl.getAttribLocation(program, "pos");
         checkedGl.enableVertexAttribArray(vertexPositionAttrLoc);
-        const vertexPositionBuffer = checkedGl.createBuffer();
-        checkedGl.bindBuffer(checkedGl.ARRAY_BUFFER, vertexPositionBuffer);
+        this.vertexPositionBuffer = checkedGl.createBuffer();
+        checkedGl.bindBuffer(checkedGl.ARRAY_BUFFER, this.vertexPositionBuffer);
         checkedGl.bufferData(checkedGl.ARRAY_BUFFER, new Float32Array([0, 0, 0, 1, 1, 0, 1, 1]), checkedGl.STATIC_DRAW);
         checkedGl.vertexAttribPointer(vertexPositionAttrLoc, 2, checkedGl.FLOAT, false, 0, 0);
 
@@ -112,14 +124,42 @@ export class GlCanvas {
         checkedGl.activeTexture(gl.TEXTURE0);
         checkedGl.bindTexture(gl.TEXTURE_2D, this.texture);
 
+        this.checkedGl = checkedGl;
+        this.viewportWidth = this.viewportHeight = 0;
         this.uvFloatArray = new Float32Array(8);
         this.lastExtent = {};
 
         console.log("GL Canvas set up");
     }
 
-    paint(minx, miny, maxx, maxy, frameCount) {
+    /**
+     * Release the GL objects this canvas owns.
+     *
+     * Switching display mode builds a new canvas over the same element, and a
+     * canvas only ever hands out one WebGL context — so the new one inherits
+     * the old one's context and the old one's objects stay resident unless
+     * they are deleted here. That is a megabytes-per-switch leak: the
+     * framebuffer texture alone is 1024x1024 RGBA.
+     */
+    dispose() {
+        const gl = this.checkedGl;
+        this.filter.dispose();
+        gl.deleteTexture(this.texture);
+        gl.deleteBuffer(this.vertexPositionBuffer);
+        gl.deleteBuffer(this.uvBuffer);
+        this.texture = this.vertexPositionBuffer = this.uvBuffer = null;
+    }
+
+    paint(minx, miny, maxx, maxy, frame) {
         const gl = this.gl;
+        // The drawing buffer can be resized under us — modes that scale to the
+        // display do it on every window resize — and the viewport does not
+        // follow it.
+        if (gl.drawingBufferWidth !== this.viewportWidth || gl.drawingBufferHeight !== this.viewportHeight) {
+            this.viewportWidth = gl.drawingBufferWidth;
+            this.viewportHeight = gl.drawingBufferHeight;
+            gl.viewport(0, 0, this.viewportWidth, this.viewportHeight);
+        }
         // We can't specify a stride for the source, so have to use the full width.
         gl.texSubImage2D(
             gl.TEXTURE_2D,
@@ -157,7 +197,17 @@ export class GlCanvas {
             gl.bufferData(gl.ARRAY_BUFFER, this.uvFloatArray, gl.DYNAMIC_DRAW);
         }
 
-        this.filter.setUniforms({ width, height, frameCount });
+        this.filter.setUniforms({
+            width,
+            height,
+            frameCount: frame.frameCount,
+            lineGrid: frame.lineGrid,
+            // How much of the framebuffer each output pixel covers, which sets
+            // how wide an edge-smoothing ramp should be. `extent` holds texel
+            // counts; the scaling into texture coordinates above applies only
+            // to the local copies that go into the UV buffer.
+            texelsPerOutputPixel: (extent.maxx - extent.minx) / gl.drawingBufferWidth,
+        });
 
         gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
     }
@@ -167,11 +217,20 @@ export function bestCanvas(canvas, filterClass) {
     try {
         return new GlCanvas(canvas, filterClass);
     } catch (e) {
-        console.log("Unable to use OpenGL: " + e);
-        if (filterClass.requiresGl()) {
-            const config = filterClass.getDisplayConfig();
-            console.warn(`${config.name} requires WebGL. Falling back to standard 2D canvas.`);
+        // Either WebGL is unavailable or this particular filter declined it.
+        console.log(`Unable to use ${filterClass.getDisplayConfig().name} with WebGL: ${e}`);
+    }
+
+    // A canvas that has handed out a WebGL context can never hand out a 2D one,
+    // so if the failure came from the filter rather than from WebGL itself, the
+    // 2D fallback below would throw and take the emulator with it.
+    if (filterClass !== PassthroughFilter) {
+        try {
+            return new GlCanvas(canvas, PassthroughFilter);
+        } catch (e) {
+            console.log("Unable to fall back to the passthrough filter: " + e);
         }
     }
+
     return new Canvas(canvas);
 }

package/src/disc-drive.js

@@ -33,6 +33,11 @@ export class BaseDiscDrive extends EventTarget {
         throw new Error("Not implemented: headPosition getter");
     }
 
+    /** @returns {boolean} */
+    get isSideUpper() {
+        throw new Error("Not implemented: isSideUpper getter");
+    }
+
     /** @returns {boolean} */
     get indexPulse() {
         throw new Error("Not implemented: indexPulse getter");
@@ -240,6 +245,10 @@ export class DiscDrive extends BaseDiscDrive {
         return this._track;
     }
 
+    get isSideUpper() {
+        return this._isSideUpper;
+    }
+
     get positionFraction() {
         return (this._headPosition + this._pulsePosition / 32) / this.trackLength;
     }

package/src/disc-hfe.js

@@ -190,9 +190,8 @@ export function loadHfe(disc, data, onChange) {
         }
     }
 
-    // Set up write track callback if onChange is provided
     if (onChange) {
-        disc.setWriteTrackCallback((_side, _trackNum, _trackObj) => {
+        disc.addTrackWriteListener((_side, _trackNum, _trackObj) => {
             // Generate a complete HFE image from the current disc state
             const hfeData = toHfe(disc);
             // Call the onChange handler with the updated HFE data