jsbeeb 1.15.0 → 1.17.0

package/src/video.js

@@ -3,6 +3,7 @@ import { Teletext } from "./teletext.js";
 import * as utils from "./utils.js";
 import { BbcDefaultPalette as NulaDefaultPalette } from "./bbc-palette.js";
 import { Video6847 } from "./6847.js";
+import { encodeLineGrid, texelsPerPixel, LineGridRows } from "./video-filters/pixel-grid.js";
 
 export const VDISPENABLE = 1 << 0;
 export const HDISPENABLE = 1 << 1;
@@ -16,6 +17,8 @@ export const EVERYTHINGENABLED =
 export const OPAQUE_BLACK = 0xff000000;
 export const OPAQUE_WHITE = 0xffffffff;
 
+export const MinPaintedFrameRows = 64;
+
 ////////////////////
 // VideoNULA - programmable 12-bit RGB palette extension (RobC hardware mod).
 // Reference: b-em src/video.c (stardot/b-em).
@@ -127,6 +130,7 @@ class Ula {
             this.video.ulaMode = newMode;
         }
         this.video.teletextMode = !!(val & 2);
+        this.video.updateLineGridUla();
     }
 
     // ULA palette register (&FE21).
@@ -386,6 +390,17 @@ export class Video {
         this.doubledScanlines = true;
         this.frameSkipCount = 0;
         this.screenSubtract = 0;
+        // Describes the logical pixel grid of each framebuffer row: how many
+        // texels wide and tall one BBC pixel is on that line. Display filters
+        // need this to see the picture as pixels rather than as raster samples;
+        // see video-filters/pixel-grid.js. One byte per row, written as each
+        // character cell renders, so a mode change between rows is recorded
+        // faithfully. A row whose mode changes part way along keeps only the
+        // last mode on it — enough for a raster split, not for a mid-line one.
+        this.lineGrid = new Uint8Array(LineGridRows);
+        this.lineGridUla = 0;
+        this.lineGridUlaDoubled = 0;
+        this.updateLineGridUla();
 
         this.topBorder = 12;
         this.bottomBorder = 13;
@@ -524,6 +539,8 @@ export class Video {
         this.halfClock = state.halfClock;
         this.ulaMode = state.ulaMode;
         this.teletextMode = state.teletextMode;
+        // Derived from the above, so it is recomputed rather than snapshotted.
+        this.updateLineGridUla();
         this.displayEnableSkew = state.displayEnableSkew;
         this.actualPal.set(state.actualPal);
         this.cursorOn = state.cursorOn;
@@ -555,20 +572,24 @@ export class Video {
 
     clearPaintBuffer() {
         const fb32 = this.fb32;
+        // The line grid is cleared exactly where the pixels are: in interlaced
+        // modes the other field's rows survive, and so must their grid.
         if (this.interlacedSyncAndVideo || !this.doubledScanlines) {
             let line = this.frameCount & 1;
             while (line < 625) {
                 const start = line * 1024;
                 fb32.fill(OPAQUE_BLACK, start, start + 1024);
+                this.lineGrid[line] = 0;
                 line += 2;
             }
         } else {
             fb32.fill(OPAQUE_BLACK);
+            this.lineGrid.fill(0);
         }
     }
 
-    paintAndClear() {
-        if (this.dispEnabled & FRAMESKIPENABLE) {
+    flyback() {
+        if (this.bitmapY >= MinPaintedFrameRows && this.dispEnabled & FRAMESKIPENABLE) {
             this.paint();
             this.clearPaintBuffer();
         }
@@ -610,6 +631,21 @@ export class Video {
         debugCopyFb(this.fb32, this.debugPrevScreen);
     }
 
+    /**
+     * Recompute the ULA-dependent half of the line grid descriptor: everything
+     * except whether this particular scanline was doubled. Called whenever the
+     * ULA control register changes, so the render loop only has to store it.
+     *
+     * MODE 7 counts as one texel per pixel: the SAA5050 emulation writes each
+     * of its 16 texels per character individually, so its output is already at
+     * the framebuffer's own resolution.
+     */
+    updateLineGridUla() {
+        const texelsWide = this.teletextMode ? 1 : texelsPerPixel(this.ulaMode);
+        this.lineGridUla = encodeLineGrid(texelsWide, false);
+        this.lineGridUlaDoubled = encodeLineGrid(texelsWide, true);
+    }
+
     blitFb(dat, destOffset, numPixels) {
         destOffset |= 0;
         const offset = table4bppOffset(this.ulaMode, dat);
@@ -816,14 +852,12 @@ export class Video {
             // an approximation that works if hsyncs are spaced evenly.
             this.bitmapY += 2;
 
-            // If no VSync occurs this frame, go back to the top and force a repaint
-            if (this.bitmapY >= 768) {
-                // Arbitrary moment when TV will give up and start flyback in the absence of an explicit VSync signal
-                this.paintAndClear();
-            }
+            // Arbitrary moment when TV will give up and start flyback in the absence of an explicit VSync signal
+            return this.bitmapY >= 768;
         } else if (this.hpulseCounter === (this.regs[3] & 0x0f)) {
             this.inHSync = false;
         }
+        return false;
     }
 
     cb2changed(level, output) {
@@ -871,7 +905,7 @@ export class Video {
             // This emulates the Hitachi 6845SP CRTC.
             // Other variants have different quirks.
             // Handle HSync
-            if (this.inHSync) this.handleHSync();
+            if (this.inHSync && this.handleHSync()) this.flyback();
 
             // Handle delayed display enable due to skew
             const displayEnablePos = this.displayEnableSkew + (this.teletextMode ? 2 : 0);
@@ -935,11 +969,7 @@ export class Video {
                 this.hadVSyncThisRow = true;
                 this.vpulseCounter = 0;
 
-                // Avoid intense painting if registers have boot-up or
-                // otherwise small values.
-                if (this.regs[0] && this.regs[4]) {
-                    this.paintAndClear();
-                }
+                this.flyback();
             }
 
             if (vSyncStarting || vSyncEnding) {
@@ -974,7 +1004,7 @@ export class Video {
                 // Render data depending on display enable state.
                 if (this.bitmapX >= 0 && this.bitmapX < 1024 && this.bitmapY < 625) {
                     let doubledLines = false;
-                    let offset = this.bitmapY;
+                    let bitmapRow = this.bitmapY;
                     // There's a painting subtlety here: if we're in an
                     // interlace mode but R6>R4 then we'll get stuck
                     // painting just an odd or even frame, so we double up
@@ -984,12 +1014,22 @@ export class Video {
                         this.isEvenRender === this.lastRenderWasEven
                     ) {
                         doubledLines = true;
-                        offset &= ~1;
+                        bitmapRow &= ~1;
                     }
 
-                    offset = offset * 1024 + this.bitmapX;
+                    const offset = bitmapRow * 1024 + this.bitmapX;
 
                     if ((this.dispEnabled & EVERYTHINGENABLED) === EVERYTHINGENABLED) {
+                        // Note this row's logical pixel size for display
+                        // filters; see video-filters/pixel-grid.js. The ULA half
+                        // of the descriptor is precomputed on register writes so
+                        // this stays a store or two in the hottest loop we have.
+                        if (doubledLines) {
+                            this.lineGrid[bitmapRow] = this.lineGridUlaDoubled;
+                            this.lineGrid[bitmapRow + 1] = this.lineGridUlaDoubled;
+                        } else {
+                            this.lineGrid[bitmapRow] = this.lineGridUla;
+                        }
                         if (this.teletextMode) {
                             if (this.halfClock) {
                                 // Proper MODE 7 (1MHz clock + teletext): render SAA5050 output normally.

package/src/wd-fdc.js

@@ -46,6 +46,17 @@ const CommandBits = Object.freeze({
     typeIIDeleted: 0x01,
 });
 
+/**
+ * Type IV (force interrupt) condition bits, taken from the command's low nibble.
+ *
+ * @readonly
+ * @enum {Number}
+ */
+const ForceInterruptBits = Object.freeze({
+    indexPulse: 0x04,
+    immediate: 0x08,
+});
+
 /**
  * The drive control register is documented here:
  * https://www.cloud9.co.uk/james/BBCMicro/Documentation/wd1770.html
@@ -512,6 +523,8 @@ export class WdFdc {
         //   insofar as index pulse appears to be reported in the status register.
         // - Interrupt on index pulse is only active for the current command.
         if (this._statusRegister & Status.busy) {
+            // Any pending timer belongs to the command being aborted.
+            this._clearTimer();
             this._commandDone(false);
         } else {
             if (this._state !== State.idle) throw new Error(`Unexpected state when force interrupt: ${this._state}`);
@@ -523,13 +536,10 @@ export class WdFdc {
                 this._currentDrive.startSpinning();
             }
         }
-        if (forceInterruptBits === 0) {
-            this._isInterruptOnIndexPulse = false;
-        } else if (forceInterruptBits === 4) {
-            this._isInterruptOnIndexPulse = true;
-        } else {
-            throw new Error(`1700 force interrupt flags not handled: ${forceInterruptBits}`);
-        }
+        if (forceInterruptBits & ForceInterruptBits.immediate) this._setIntRq(true);
+        this._isInterruptOnIndexPulse = !!(forceInterruptBits & ForceInterruptBits.indexPulse);
+        // The remaining two bits select interrupts on the ready line's transitions. The BBC ties
+        // the 1770's READY input active, so neither transition can ever occur.
     }
 
     _timerFired() {
@@ -1404,8 +1414,15 @@ export class WdFdc {
      * @param {Number} drive
      * @param {Disc} disc
      */
-    loadDisc(drive, disc) {
+    /**
+     * @param {Number} drive
+     * @param {Disc} disc
+     * @param {Number} [tracksPerStep] where to leave the drive's 40/80 switch, which by default
+     *   follows the disc, since no drive can tell what pitch the disc in it was written at
+     */
+    loadDisc(drive, disc, tracksPerStep = disc?.is40Track ? 2 : 1) {
         this._drives[drive].setDisc(disc);
+        this._drives[drive].tracksPerStep = tracksPerStep;
     }
 
     get motorOn() {

package/src/web/audio-handler.js

@@ -15,6 +15,7 @@ export class AudioHandler {
         this.cpuSpeed = cpuSpeed;
         this.isAtom = isAtom;
         this.warningNode = warningNode;
+        this.noAudioWorklet = false;
         toggle(this.warningNode, false);
         this.stats = {};
         if (statsNode) {
@@ -41,14 +42,15 @@ export class AudioHandler {
         } else {
             if (this.audioContext && !this.audioContext.audioWorklet) {
                 this.audioContext = null;
+                this.noAudioWorklet = true;
                 console.log("Unable to initialise audio: no audio worklet API");
-                toggle(this.warningNode, true);
                 const localhost = new URL(window.location);
                 localhost.hostname = "localhost";
                 this.warningNode.innerHTML = `No audio worklet API was found - there will be no audio.
                     If you are running a local jsbeeb, you must either use a host of
                     <a href="${localhost}">localhost</a>,
                     or serve the content over <em>https</em>.`;
+                toggle(this.warningNode, true);
             }
             this.soundChip = new FakeSoundChip();
             this.ddNoise = new FakeDdNoise();
@@ -56,7 +58,6 @@ export class AudioHandler {
         }
 
         this.warningNode.addEventListener("mousedown", () => this.tryResume());
-        toggle(this.warningNode, false);
 
         // Initialise Music 5000 audio context
         this.audioContextM5000 = createAudioContext({ sampleRate: 46875 });
@@ -145,6 +146,7 @@ export class AudioHandler {
     }
 
     checkStatus() {
+        if (this.noAudioWorklet) return;
         if (!this.audioContext && !this.audioContextM5000) return;
         const suspended =
             (this.audioContext && this.audioContext.state === "suspended") ||

package/src/web/toast.js

@@ -0,0 +1,79 @@
+import * as bootstrap from "bootstrap";
+
+/**
+ * Passing notices: something happened that is worth knowing and needs nothing doing about it.
+ * The error dialog is for the other kind.
+ */
+
+let nextQuietId = 0;
+
+function toastContainer() {
+    const existing = document.querySelector(".toast-container");
+    if (existing) return existing;
+    const container = document.createElement("div");
+    container.className = "toast-container position-fixed bottom-0 end-0 p-3";
+    document.body.appendChild(container);
+    return container;
+}
+
+// Storage can be unreachable or full, and a notice that nothing needs doing about is not worth
+// failing over: forget the answer and say the thing again.
+function remembered(key) {
+    try {
+        return !!window.localStorage.getItem(key);
+    } catch (e) {
+        console.log(`Unable to read ${key}: ${e}`);
+        return false;
+    }
+}
+
+function remember(key, wanted) {
+    try {
+        if (wanted) window.localStorage.setItem(key, "yes");
+        else window.localStorage.removeItem(key);
+    } catch (e) {
+        console.log(`Unable to remember ${key}: ${e}`);
+    }
+}
+
+/**
+ * @param {string} message
+ * @param {object} [options]
+ * @param {string} [options.title] a heading, for a notice whose message does not say where it came from
+ * @param {string} [options.quietKey] offer to stop showing this kind of notice, remembering the answer here
+ */
+export function toast(message, { title = "", quietKey = "" } = {}) {
+    if (quietKey && remembered(quietKey)) return;
+
+    const element = document.createElement("div");
+    element.className = "toast text-bg-dark";
+    element.setAttribute("role", "status");
+    element.setAttribute("aria-live", "polite");
+    element.setAttribute("aria-atomic", "true");
+    const quietId = `toast-quiet-${nextQuietId++}`;
+    element.innerHTML = `
+        <div class="toast-header text-bg-dark">
+            <strong class="me-auto"></strong>
+            <button type="button" class="btn-close btn-close-white" data-bs-dismiss="toast" aria-label="Close"></button>
+        </div>
+        <div class="toast-body">
+            <div class="message"></div>
+            <div class="form-check mt-2">
+                <input class="form-check-input" type="checkbox" id="${quietId}" />
+                <label class="form-check-label small" for="${quietId}">Stop telling me this</label>
+            </div>
+        </div>`;
+    // Disc names and the like come from the outside world, so they are set as text, never as markup.
+    element.querySelector(".message").textContent = message;
+    element.querySelector(".toast-header strong").textContent = title;
+    element.querySelector(".toast-header").hidden = !title;
+
+    const quiet = element.querySelector(".form-check");
+    quiet.hidden = !quietKey;
+    quiet.querySelector("input").addEventListener("change", (event) => remember(quietKey, event.target.checked));
+
+    toastContainer().appendChild(element);
+    element.addEventListener("hidden.bs.toast", () => element.remove());
+    bootstrap.Toast.getOrCreateInstance(element).show();
+    return element;
+}

package/tests/test-machine.js

@@ -178,7 +178,7 @@ export class TestMachine {
                     return true;
                 }
             });
-            await this.runFor(secs * 1 * 1000 * 1000); // Atom is 1 MHz
+            await this.runFor(secs * this.model.cyclesPerSecond);
             hook.remove();
             assert(hit, "Atom did not reach keyboard input in time");
             return this.runFor(10 * 1000);
@@ -191,7 +191,7 @@ export class TestMachine {
                 return true;
             }
         });
-        await this.runFor(secs * 2 * 1000 * 1000);
+        await this.runFor(secs * this.model.cyclesPerSecond);
         hook.remove();
         assert(hit, "did not hit appropriate breakpoint in time");
         return this.runFor(10 * 1000);
@@ -206,14 +206,14 @@ export class TestMachine {
                 return true;
             }
         });
-        await this.runFor(secs * 2 * 1000 * 1000);
+        await this.runFor(secs * this.model.cyclesPerSecond);
         hook.remove();
         assert(hit, "did not hit appropriate breakpoint in time");
     }
 
     async loadDisc(image) {
         const data = await fdc.load(image);
-        this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, "", data));
+        this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, image, data));
     }
 
     /**
@@ -370,7 +370,8 @@ export class TestMachine {
         let nextEventCycle = 0;
         let done = false;
 
-        const currentCycle = () => this.processor.cycleSeconds * 2000000 + this.processor.currentCycles;
+        const currentCycle = () =>
+            this.processor.cycleSeconds * this.model.cyclesPerSecond + this.processor.currentCycles;
 
         const hook = this.processor.debugInstruction.add(() => {
             if (currentCycle() < nextEventCycle) return;
@@ -425,7 +426,8 @@ export class TestMachine {
         let done = false;
         let shiftHeld = false;
 
-        const currentCycle = () => this.processor.cycleSeconds * 1000000 + this.processor.currentCycles;
+        const currentCycle = () =>
+            this.processor.cycleSeconds * this.model.cyclesPerSecond + this.processor.currentCycles;
 
         const isShift = (entry) => entry[0] === SHIFT[0] && entry[1] === SHIFT[1];