jsbeeb 1.14.0 → 1.16.0

package/src/disc.js

@@ -257,10 +257,12 @@ class Sector {
      * @param {Track} track
      * @param {boolean} isMfm
      * @param {Number} idPosBitOffset
+     * @param {function(string): void} [warn] where to report anomalies; the console by default
      */
-    constructor(track, isMfm, idPosBitOffset) {
+    constructor(track, isMfm, idPosBitOffset, warn = console.log) {
         this.track = track;
         this.isMfm = isMfm;
+        this._warn = warn;
         this.idPosBitOffset = idPosBitOffset;
         this.dataPosBitOffset = null;
         this.isDeleted = false;
@@ -271,7 +273,7 @@ class Sector {
         const idReader = this._readerAt(this.idPosBitOffset);
         const { data: headerData, iffyPulses } = idReader.read(6);
         if (iffyPulses) {
-            console.log(`Iffy pulse in sector header ${this.description}`);
+            this._warn(`Iffy pulse in sector header ${this.description}`);
         }
         this.header = headerData;
         let crc = idReader.initialCrc;
@@ -304,7 +306,7 @@ class Sector {
     read(nextSector) {
         const pulsesPerByte = this.isMfm ? 16 : 32; // todo put in reader
         if (this.dataPosBitOffset === null) {
-            console.log(`"Sector header without data ${this.description}"`);
+            this._warn(`Sector header without data ${this.description}`);
             return;
         }
 
@@ -331,7 +333,7 @@ class Sector {
             sectorSize = sectorSize >>> 1;
         } while (sectorSize >= 128);
         if (seenIffyData) {
-            console.log(`"Iffy pulse in sector data ${this.description}"`);
+            this._warn(`Iffy pulse in sector data ${this.description}`);
         }
     }
 
@@ -355,6 +357,61 @@ class Sector {
     }
 }
 
+/**
+ * A 64 bit shift register, held as a pair of unsigned 32 bit halves. BigInt would say this more
+ * directly but costs an order of magnitude more per bit shifted.
+ */
+export class BitWindow64 {
+    constructor() {
+        this.hi = 0;
+        this.lo = 0;
+    }
+
+    /**
+     * @param {Number} bit 0 or 1, shifted into bit 0
+     * @returns {Number} the bit shifted out of bit 63
+     */
+    shiftIn(bit) {
+        const shiftedOut = this.hi >>> 31;
+        this.hi = ((this.hi << 1) | (this.lo >>> 31)) >>> 0;
+        this.lo = ((this.lo << 1) | bit) >>> 0;
+        return shiftedOut;
+    }
+
+    /**
+     * @returns {boolean} whether all 64 bits match the halves given
+     */
+    equals(hi, lo) {
+        return this.hi === hi && this.lo === lo;
+    }
+
+    /**
+     * @param {Number} nibble
+     * @returns {Number} the length of the run of `nibble` ending at bit 0
+     */
+    countTrailingNibbles(nibble) {
+        const nibblesPerHalf = 8;
+        let count = 0;
+        for (let bits = this.lo; (bits & 0xf) === nibble; bits >>>= 4) count++;
+        // Only a low half that matched all the way up can have a run continuing into the high half.
+        if (count === nibblesPerHalf) for (let bits = this.hi; (bits & 0xf) === nibble; bits >>>= 4) count++;
+        return count;
+    }
+}
+
+// What the mark detector holds at an address mark. The FM case only pins down the high half,
+// the tail of the zero sync run; the low half is the marker byte itself, decoded separately.
+const FmSyncHi = 0x88888888;
+const MfmMarkerHi = 0xaaaa4489;
+const MfmMarkerLo = 0x44894489;
+// One data bit of zero, FM encoded with its clock, is the pulse nibble 0x8.
+const FmZeroBitPulses = 0x8;
+// FmSyncHi is eight of those, so a match has already seen this much of the sync run.
+const FmSyncHiZeroBits = 8;
+// Sync is counted in zero data bits, so a run no longer than two bytes' worth is short enough
+// to be worth logging.
+const ShortSyncZeros = 16;
+
 class Track {
     constructor(upper, trackNum, initialByte) {
         this.length = IbmDiscFormat.bytesPerTrack; // Default size, will be updated when track is populated
@@ -371,10 +428,11 @@ class Track {
 
     /**
      * Debug functionality to try and interpret the track.
+     * @param {function(string): void} [warn] where to report anomalies; the console by default
      * @returns {Sector[]}
      */
-    findSectors() {
-        const sectors = this.findSectorIds();
+    findSectors(warn = console.log) {
+        const sectors = this.findSectorIds(warn);
         for (let sectorIndex = 0; sectorIndex !== sectors.length; ++sectorIndex) {
             const nextSector = sectors[sectorIndex + 1]; // Will be unset for last
             sectors[sectorIndex].read(nextSector);
@@ -383,9 +441,10 @@ class Track {
     }
 
     /**
+     * @param {function(string): void} [warn] where to report anomalies; the console by default
      * @returns {Sector[]}
      */
-    findSectorIds() {
+    findSectorIds(warn = console.log) {
         const sectors = [];
         // Pass 1: walk the track and find header and data markers.
         const bitLength = this.length * 32;
@@ -394,40 +453,30 @@ class Track {
         let doMfmMarkerByte = false;
         let isMfm = false;
         let pulses = 0;
-        let markDetector = 0n;
-        let markDetectorPrev = 0n;
-        const all64b = 0xffffffffffffffffn;
-        const top32of64b = 0xffffffff00000000n;
-        const fmMarker = 0x8888888800000000n;
-        const mfmMarker = 0xaaaa448944894489n;
+        // The mark detector is a 64 bit sliding window over the pulse stream; the bits leaving it
+        // spill into a second window, which the sync run length is counted from.
+        const markDetector = new BitWindow64();
+        const markDetectorPrev = new BitWindow64();
         let dataByte;
         let sector = null;
         for (let pulseIndex = 0; pulseIndex < bitLength; ++pulseIndex) {
             if ((pulseIndex & 31) === 0) pulses = this.pulses2Us[pulseIndex >>> 5];
-            markDetectorPrev = (markDetectorPrev << 1n) & all64b;
-            markDetectorPrev |= markDetector >> 63n;
-            markDetector = (markDetector << 1n) & all64b;
-            shiftRegister = (shiftRegister << 1) & 0xffffffff;
+            const pulseBit = pulses >>> 31;
+            markDetectorPrev.shiftIn(markDetector.shiftIn(pulseBit));
+            shiftRegister = ((shiftRegister << 1) | pulseBit) & 0xffffffff;
             numShifts++;
-            if (pulses & 0x80000000) {
-                markDetector |= 1n;
-                shiftRegister |= 1;
-            }
             pulses = (pulses << 1) & 0xffffffff;
-            if ((markDetector & top32of64b) === fmMarker) {
-                const { clocks, data, iffyPulses } = IbmDiscFormat._2usPulsesToFm(Number(markDetector & 0xffffffffn));
+            if (markDetector.hi === FmSyncHi) {
+                const { clocks, data, iffyPulses } = IbmDiscFormat._2usPulsesToFm(markDetector.lo);
                 if (iffyPulses || clocks !== IbmDiscFormat.markClockPattern) continue;
                 isMfm = false;
                 doMfmMarkerByte = false;
-                let num0s = 8;
-                for (let bits = markDetectorPrev; (bits & 0xfn) === 0x8n; bits >>= 4n) {
-                    num0s++;
-                }
-                if (num0s <= 16) {
-                    console.log(`Short zeros sync ${this.description}`);
+                const num0s = FmSyncHiZeroBits + markDetectorPrev.countTrailingNibbles(FmZeroBitPulses);
+                if (num0s <= ShortSyncZeros) {
+                    warn(`Short zeros sync ${this.description}`);
                 }
                 dataByte = data;
-            } else if (markDetector === mfmMarker) {
+            } else if (markDetector.equals(MfmMarkerHi, MfmMarkerLo)) {
                 // Next byte is MFM marker.
                 isMfm = true;
                 doMfmMarkerByte = true;
@@ -442,7 +491,7 @@ class Track {
             }
             switch (dataByte) {
                 case IbmDiscFormat.idMarkDataPattern: {
-                    sector = new Sector(this, isMfm, pulseIndex + 1);
+                    sector = new Sector(this, isMfm, pulseIndex + 1, warn);
                     sectors.push(sector);
                     shiftRegister = 0;
                     numShifts = 0;
@@ -451,7 +500,7 @@ class Track {
                 case IbmDiscFormat.dataMarkDataPattern:
                 case IbmDiscFormat.deletedDataMarkDataPattern:
                     if (!sector || sector.dataPosBitOffset) {
-                        console.log(
+                        warn(
                             `Sector data without header ${this.description}; mark bitpos ${pulseIndex}; previous good sector ${sector ? sector.description : "none"}`,
                         );
                     } else {
@@ -464,7 +513,7 @@ class Track {
                     }
                     break;
                 default:
-                    console.log(`Unknown marker byte ${hexbyte(dataByte)} ${this.description}`);
+                    warn(`Unknown marker byte ${hexbyte(dataByte)} ${this.description}`);
             }
         }
         return sectors;
@@ -580,16 +629,14 @@ export function loadSsd(disc, data, isDsd, onChange) {
         // Create a dataCopy large enough for all the sectors and tracks.
         const dataCopy = new Uint8Array(maxSize);
         dataCopy.set(data);
-        disc.setWriteTrackCallback(
+        disc.addTrackWriteListener(
             /** @param {Track} trackObj  */
             (side, trackNum, trackObj) => {
                 const trackOffset =
                     SsdFormat.sectorSize * SsdFormat.sectorsPerTrack * (trackNum * numSides + (side ? 1 : 0));
-                for (const sector of trackObj.findSectors()) {
-                    const sectorOffset = sector.sectorNumber * SsdFormat.sectorSize;
-                    for (let x = 0; x < SsdFormat.sectorSize; ++x)
-                        dataCopy[trackOffset + sectorOffset + x] = sector.sectorData[x];
-                }
+                for (const sector of trackObj.findSectors())
+                    if (!sectorShortfall(sector, trackNum))
+                        dataCopy.set(sector.sectorData, trackOffset + sector.sectorNumber * SsdFormat.sectorSize);
                 onChange(dataCopy);
             },
         );
@@ -672,11 +719,56 @@ export function loadAdf(disc, data, isDsd) {
     return disc;
 }
 
+/** Why a sector will not fit in an SSD or DSD image, or null if it will. */
+function sectorShortfall(sector, trackNum) {
+    if (sector.hasDataCrcError || sector.hasHeaderCrcError) return "with a CRC error";
+    // A header whose data mark never arrives leaves the sector with nothing to write.
+    if (!sector.sectorData) return "with no data";
+    if (sector.sectorNumber >= SsdFormat.sectorsPerTrack)
+        return `numbered past the ${SsdFormat.sectorsPerTrack} a track holds`;
+    if (sector.sectorData.length !== SsdFormat.sectorSize) return `not ${SsdFormat.sectorSize} bytes`;
+    if (trackNum >= SsdFormat.tracksPerDisc) return `past track ${SsdFormat.tracksPerDisc}`;
+    return null;
+}
+
+/**
+ * SSD and DSD images hold sector contents and nothing else, so anything a DFS sector could not
+ * have held is lost. Copy protection usually shows up as one of these.
+ *
+ * @returns {string[]} what `disc` holds that an SSD or DSD cannot, worst first
+ * @param {Disc} disc
+ */
+export function ssdOrDsdShortfalls(disc) {
+    const counts = new Map();
+    for (let trackNum = 0; trackNum < disc.tracksUsed; ++trackNum) {
+        for (const upper of disc.isDoubleSided ? [false, true] : [false]) {
+            for (const sector of disc.getTrack(upper, trackNum).findSectors()) {
+                const shortfall = sectorShortfall(sector, trackNum);
+                if (shortfall) counts.set(shortfall, (counts.get(shortfall) ?? 0) + 1);
+            }
+        }
+    }
+    return [...counts]
+        .sort(([, a], [, b]) => b - a)
+        .map(([shortfall, count]) => `${count} sector${count === 1 ? "" : "s"} ${shortfall}`);
+}
+
 /**
  * @returns {Uint8Array}
  * @param {Disc} disc
+ * @param {object} [options]
+ * @param {boolean} [options.force] save what fits instead of refusing a disc that will not fit
+ * @throws if the disc holds anything an SSD or DSD cannot, and `force` is not set
  */
-export function toSsdOrDsd(disc) {
+export function toSsdOrDsd(disc, { force = false } = {}) {
+    if (!force) {
+        const shortfalls = ssdOrDsdShortfalls(disc);
+        if (shortfalls.length)
+            throw new Error(
+                `This disc cannot be saved as SSD or DSD: it has ${shortfalls.join(", ")}. ` +
+                    `Save it as HFE to keep everything.`,
+            );
+    }
     const numSides = disc.isDoubleSided ? 2 : 1;
     const result = new Uint8Array(
         numSides * SsdFormat.tracksPerDisc * SsdFormat.sectorsPerTrack * SsdFormat.sectorSize,
@@ -686,11 +778,8 @@ export function toSsdOrDsd(disc) {
         for (let side = 0; side < numSides; ++side) {
             const trackObj = disc.getTrack(side === 1, trackNum);
             for (const sector of trackObj.findSectors()) {
+                if (sectorShortfall(sector, trackNum)) continue;
                 const sectorOffset = offset + sector.sectorNumber * SsdFormat.sectorSize;
-                if (sector.hasDataCrcError || sector.hasHeaderCrcError) {
-                    console.log(`Skipping sector ${sector.description} with bad CRC`);
-                    continue;
-                }
                 for (let x = 0; x < SsdFormat.sectorSize; ++x) result[sectorOffset + x] = sector.sectorData[x];
             }
             offset += SsdFormat.sectorsPerTrack * SsdFormat.sectorSize;
@@ -722,7 +811,7 @@ export class Disc {
         this.tracksUsed = 0;
         this.isDoubleSided = false;
 
-        this.writeTrackCallback = undefined;
+        this._trackWriteListeners = new Set();
         this.isWriteable = isWriteable;
 
         // Track which tracks have been written since the last snapshot.
@@ -749,8 +838,14 @@ export class Disc {
         this.initSurface(0);
     }
 
-    setWriteTrackCallback(callback) {
-        this.writeTrackCallback = callback;
+    /** @param {function(boolean, Number, Track): void} listener called once per flushed track */
+    addTrackWriteListener(listener) {
+        this._trackWriteListeners.add(listener);
+    }
+
+    /** @param {function(boolean, Number, Track): void} listener */
+    removeTrackWriteListener(listener) {
+        this._trackWriteListeners.delete(listener);
     }
 
     /**
@@ -860,10 +955,9 @@ export class Disc {
         this.isDirty = false;
         this.dirtySide = -1;
         this.dirtyTrack = -1;
-        if (!this.writeTrackCallback) return;
         const trackObj = this.getTrack(dirtySide, dirtyTrack);
-        this.writeTrackCallback(dirtySide, dirtyTrack, trackObj);
         this.setTrackUsed(dirtySide, dirtyTrack);
+        for (const listener of this._trackWriteListeners) listener(dirtySide, dirtyTrack, trackObj);
     }
 
     /**

package/src/dom-utils.js

@@ -30,3 +30,19 @@ export function fadeOut(el, duration = 400) {
         if (el.style.opacity === "0") el.style.display = "none";
     }, duration);
 }
+
+// Safari fetches the blob a task or more after the click, so the URL must outlive it.
+// 40s matches FileSaver.js.
+const BlobUrlLifetimeMs = 40000;
+
+/** Save a blob to the user's downloads under the given file name. */
+export function downloadBlob(blob, fileName) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = fileName;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    setTimeout(() => URL.revokeObjectURL(url), BlobUrlLifetimeMs);
+}

package/src/econet.js

@@ -1,6 +1,9 @@
 // Code ported from Beebem (C to .js) by Jason Robson
 // The majority of the commentary here is also from Beebem
 
+// How long a four-way handshake may stall before we resend.
+const RetryTimeoutSecs = 0.5;
+
 // Econet support classes
 class ADLC {
     constructor() {
@@ -57,10 +60,11 @@ export class ReceiveBlock {
 
 // Econet class definition
 export class Econet {
-    constructor(stationId_) {
+    constructor(stationId_, cyclesPerSecond) {
         // Config parameters
         this.TIME_BETWEEN_BYTES = 128;
         this.SERVER_STATION_ID = 254;
+        this.retryCycles = (cyclesPerSecond * RetryTimeoutSecs) | 0;
 
         // 4-way handshake states
         this.FWH_Idle = 0;
@@ -156,7 +160,7 @@ export class Econet {
             }
 
             // Re-tries
-            if (this.pollTotalCycles > this.wireStateEntryTimer + 1000000) {
+            if (this.pollTotalCycles > this.wireStateEntryTimer + this.retryCycles) {
                 if (this.wireState !== this.FWH_Idle) {
                     switch (this.wireState) {
                         case this.FWH_RX_Scout_Received:

package/src/fake6502.js

@@ -3,7 +3,7 @@
 
 import { FakeVideo } from "./video.js";
 import { FakeSoundChip } from "./soundchip.js";
-import { TEST_6502, TEST_65C02, TEST_65C12, TubeModel } from "./models.js";
+import { TEST_6502, TEST_65C02, TEST_65C12, tubeModelFor } from "./models.js";
 import { FakeDdNoise } from "./ddnoise.js";
 import { FakeRelayNoise } from "./relaynoise.js";
 import { Cpu6502, AtomCpu6502 } from "./6502.js";
@@ -30,7 +30,7 @@ export function fake6502(model, opts) {
         cmos: new Cmos(),
         cycleAccurate: opts.cycleAccurate,
         config: {
-            tube: opts.tube ? TubeModel : null,
+            tube: opts.tube ? tubeModelFor(model) : null,
             tubeCpuMultiplier: opts.tubeCpuMultiplier,
             cpuMultiplier: opts.cpuMultiplier,
             hasTeletextAdaptor: opts.hasTeletextAdaptor,

package/src/gamepads.js

@@ -39,16 +39,21 @@ export class GamePad {
          this.gamepadAxisMapping[3][-1] = BBC.COLON_STAR; // up
          this.gamepadAxisMapping[3][1] = BBC.SLASH;      // down
          */
+    /**
+     * Maps a gamepad button or stick direction to a BBC key.
+     * @param {string} gamepadKey - the gamepad control, eg `FIRE2`
+     * @param {string} bbcKey - the BBC key to press, eg `RETURN`
+     * @returns {?string} a description of the problem, or null if the mapping was applied
+     */
     remap(gamepadKey, bbcKey) {
         // convert "1" into "K1"
-        if ("0123456789".indexOf(bbcKey) > 0) {
+        if (bbcKey.length === 1 && bbcKey >= "0" && bbcKey <= "9") {
             bbcKey = "K" + bbcKey;
         }
 
         const mappedBbcKey = BBC[bbcKey];
         if (!mappedBbcKey) {
-            console.log("unknown BBC key: " + bbcKey);
-            return;
+            return `unknown BBC key "${bbcKey}".`;
         }
 
         switch (gamepadKey) {
@@ -152,8 +157,10 @@ export class GamePad {
                 this.gamepadMapping[6] = mappedBbcKey;
                 break;
             default:
-                console.log("unknown gamepad key: " + gamepadKey);
+                return `unknown gamepad control "${gamepadKey}".`;
         }
+
+        return null;
     }
 
     update(sysvia) {

package/src/jsbeeb.css

@@ -441,6 +441,132 @@ small {
   pointer-events: none;
 }
 
+#disc-panel {
+  position: fixed;
+  top: 56px;
+  right: 8px;
+  width: min(420px, 46vw);
+  max-height: calc(100vh - 104px);
+  overflow-y: auto;
+  background: rgba(0, 0, 0, 0.9);
+  border: 1px solid #555;
+  border-radius: 4px;
+  z-index: 10;
+  padding: 8px;
+}
+
+.disc-header {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  margin-bottom: 8px;
+  cursor: move;
+  user-select: none;
+  /* Claim touch gestures, or a drag scrolls the page instead. */
+  touch-action: none;
+}
+
+.disc-controls {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin-bottom: 8px;
+}
+
+.disc-header button {
+  cursor: pointer;
+}
+
+.disc-title {
+  color: #ccc;
+  font-size: 12px;
+  font-weight: bold;
+  flex: none;
+}
+
+/* The only item in the header with no bound on its width, so it is the one that yields. */
+#disc-name {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: #888;
+  font-family: consolas, monospace;
+  font-size: 11px;
+}
+
+#disc-close {
+  flex: none;
+  margin-left: auto;
+}
+
+.disc-stack {
+  position: relative;
+}
+
+.disc-stack canvas {
+  display: block;
+  width: 100%;
+  aspect-ratio: 1;
+}
+
+#disc-overlay {
+  position: absolute;
+  inset: 0;
+  cursor: crosshair;
+  /* Claim wheel and drag gestures, or the page scrolls instead. */
+  touch-action: none;
+}
+
+.disc-legend {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 4px 8px;
+  margin-top: 8px;
+  color: #aaa;
+  font-size: 10px;
+}
+
+.disc-legend-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  white-space: nowrap;
+}
+
+.disc-legend-grow {
+  flex: 1;
+  min-width: 150px;
+}
+
+.disc-legend-ramp {
+  flex: 1;
+  min-width: 40px;
+  height: 8px;
+  border-radius: 2px;
+}
+
+.disc-legend-swatch {
+  width: 12px;
+  height: 8px;
+  border-radius: 2px;
+  flex: none;
+}
+
+.disc-status {
+  margin-top: 4px;
+  color: #ccc;
+  font-family: consolas, monospace;
+  font-size: 11px;
+  /* Rewritten every frame, so the height must not depend on the content. */
+  min-height: 14px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 div.smoothie-chart-tooltip {
   background: #444;
   padding: 1em;