jsbeeb 1.14.0 → 1.16.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() {

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,7 +206,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");
     }
@@ -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];