jsbeeb 1.15.0 → 1.17.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;
@@ -478,6 +527,13 @@ class Side {
     }
 }
 
+/** How an image's tracks are laid out on the surface, and whether that is for the loader to decide. */
+export const DiscLayout = Object.freeze({
+    auto: "auto",
+    contiguous: "contiguous",
+    expanded40: "expanded40",
+});
+
 export class DiscConfig {
     constructor() {
         // TODO is this even useful?
@@ -504,6 +560,74 @@ class SsdFormat {
     static get tracksPerDisc() {
         return 80;
     }
+
+    static get trackSize() {
+        return SsdFormat.sectorSize * SsdFormat.sectorsPerTrack;
+    }
+}
+
+/** @returns {Number} how many logical tracks of `data` hold anything, ignoring a run of trailing zeros */
+function tracksWithData(data, numSides) {
+    let lastUsed = data.length - 1;
+    while (lastUsed >= 0 && data[lastUsed] === 0) lastUsed--;
+    return Math.floor(lastUsed / (SsdFormat.trackSize * numSides)) + 1;
+}
+
+// The DFS catalogue is the first two sectors of a side. Sector 1 holds how many files there are and
+// how many sectors the disc has.
+const DfsEntryCountOffset = 0x105;
+const DfsSectorCountOffset = 0x106;
+const DfsEntrySize = 8;
+const DfsMaxEntries = 31;
+
+/**
+ * Whether an SSD or DSD image was written by a 40 track drive. Only its catalogue can say: images
+ * are routinely padded out or cut short, so their size means nothing.
+ *
+ * @param {Uint8Array} data
+ * @param {boolean} isDsd
+ * @returns {{is40Track: boolean, reason: string}}
+ */
+export function sniffDfsLayout(data, isDsd) {
+    const contiguous = (reason) => ({ is40Track: false, reason });
+    if (data.length < 2 * SsdFormat.sectorSize) return contiguous("it is smaller than a catalogue");
+    const entryBytes = data[DfsEntryCountOffset];
+    if (entryBytes % DfsEntrySize !== 0 || entryBytes > DfsMaxEntries * DfsEntrySize)
+        return contiguous(`its catalogue claims ${entryBytes} bytes of file entries`);
+    const sectors = ((data[DfsSectorCountOffset] & 3) << 8) | data[DfsSectorCountOffset + 1];
+    const reason = `its catalogue claims ${sectors} sectors`;
+    const fortyTrackSectors = (SsdFormat.tracksPerDisc / 2) * SsdFormat.sectorsPerTrack;
+    if (sectors === 0 || sectors > fortyTrackSectors) return contiguous(reason);
+    const tracks = tracksWithData(data, isDsd ? 2 : 1);
+    if (tracks > IbmDiscFormat.tracksPerDisc / 2) return contiguous(`it holds data as far as track ${tracks - 1}`);
+    return { is40Track: true, reason };
+}
+
+// One track could match by luck; a disc's worth of them could not.
+const MinDoubleSteppedTracks = 4;
+
+/**
+ * Whether a surface holds a 40 track format, going by where its sectors say they are: a track
+ * written by a 48 tpi head sits at twice the number its own headers claim, with nothing readable
+ * on the tracks between. Only a flux image can be asked this, since for any other format the
+ * layout is the loader's own doing.
+ *
+ * @param {Disc} disc
+ * @returns {{is40Track: boolean, reason: string}}
+ */
+export function sniffSurfaceLayout(disc) {
+    let doubleStepped = 0;
+    // Both heads move together, so a disc has one pitch and the side that boots can speak for it.
+    // Track 0 is where it claims to be at either pitch, so it says nothing.
+    for (let trackNum = 1; trackNum < disc.tracksUsed; ++trackNum) {
+        const sectors = disc.getTrack(false, trackNum).findSectorIds(() => {});
+        if (!sectors.length) continue;
+        if (trackNum & 1) return { is40Track: false, reason: `track ${trackNum} holds sectors of its own` };
+        if (sectors.some((sector) => sector.trackNumber === trackNum / 2)) doubleStepped++;
+    }
+    if (doubleStepped < MinDoubleSteppedTracks)
+        return { is40Track: false, reason: `only ${doubleStepped} tracks sit at twice their own number` };
+    return { is40Track: true, reason: `${doubleStepped} tracks sit at twice the number their sectors claim` };
 }
 
 /**
@@ -527,10 +651,19 @@ export function loadSsd(disc, data, isDsd, onChange) {
         throw new Error("SSD file is too large");
     }
 
+    disc.is40Track = disc.config.expandTo80;
+    const trackStep = disc.is40Track ? 2 : 1;
+    // Tracks twice as far apart are half as many, and an image can run past the last of them as
+    // far as the surface has room for.
+    const numTracks = Math.min(
+        IbmDiscFormat.tracksPerDisc / trackStep,
+        Math.max(SsdFormat.tracksPerDisc / trackStep, tracksWithData(data, numSides)),
+    );
+
     let offset = 0;
-    for (let track = 0; track < SsdFormat.tracksPerDisc; ++track) {
+    for (let track = 0; track < numTracks; ++track) {
         for (let side = 0; side < numSides; ++side) {
-            const trackBuilder = disc.buildTrack(side === 1, track);
+            const trackBuilder = disc.buildTrack(side === 1, track * trackStep);
             // Sync pattern at start of track, as the index pulse starts, aka GAP 5.
             trackBuilder
                 .appendRepeatFmByte(0xff, IbmDiscFormat.stdGap1FFs)
@@ -580,16 +713,11 @@ 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];
-                }
+            (side, _trackNum, trackObj) => {
+                for (const sector of trackObj.findSectors())
+                    if (!sectorShortfall(sector)) dataCopy.set(sector.sectorData, ssdOffsetOf(sector, side, numSides));
                 onChange(dataCopy);
             },
         );
@@ -673,17 +801,30 @@ export function loadAdf(disc, data, isDsd) {
 }
 
 /** Why a sector will not fit in an SSD or DSD image, or null if it will. */
-function sectorShortfall(sector, trackNum) {
+function sectorShortfall(sector) {
     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}`;
+    if (sector.trackNumber >= SsdFormat.tracksPerDisc) return `past track ${SsdFormat.tracksPerDisc}`;
     return null;
 }
 
+/**
+ * Where a sector belongs in an SSD or DSD image, which is the track its own header claims rather
+ * than the one it sits on.
+ *
+ * @param {Sector} sector
+ * @param {boolean} isSideUpper
+ * @param {Number} numSides
+ */
+function ssdOffsetOf(sector, isSideUpper, numSides) {
+    const track = sector.trackNumber * numSides + (isSideUpper ? 1 : 0);
+    return track * SsdFormat.trackSize + sector.sectorNumber * SsdFormat.sectorSize;
+}
+
 /**
  * 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.
@@ -696,7 +837,7 @@ export function ssdOrDsdShortfalls(disc) {
     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);
+                const shortfall = sectorShortfall(sector);
                 if (shortfall) counts.set(shortfall, (counts.get(shortfall) ?? 0) + 1);
             }
         }
@@ -723,22 +864,19 @@ export function toSsdOrDsd(disc, { force = false } = {}) {
             );
     }
     const numSides = disc.isDoubleSided ? 2 : 1;
-    const result = new Uint8Array(
-        numSides * SsdFormat.tracksPerDisc * SsdFormat.sectorsPerTrack * SsdFormat.sectorSize,
-    );
-    let offset = 0;
+    const result = new Uint8Array(numSides * SsdFormat.tracksPerDisc * SsdFormat.trackSize);
+    let numTracks = 0;
     for (let trackNum = 0; trackNum < disc.tracksUsed; ++trackNum) {
         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;
-                for (let x = 0; x < SsdFormat.sectorSize; ++x) result[sectorOffset + x] = sector.sectorData[x];
+                if (sectorShortfall(sector)) continue;
+                result.set(sector.sectorData, ssdOffsetOf(sector, side === 1, numSides));
+                numTracks = Math.max(numTracks, sector.trackNumber + 1);
             }
-            offset += SsdFormat.sectorsPerTrack * SsdFormat.sectorSize;
         }
     }
-    return result.slice(0, offset);
+    return result.slice(0, numTracks * numSides * SsdFormat.trackSize);
 }
 
 export class Disc {
@@ -763,8 +901,10 @@ export class Disc {
         this.dirtyTrack = -1;
         this.tracksUsed = 0;
         this.isDoubleSided = false;
+        // Whether the surface holds a 48 tpi layout, which a drive reads by double stepping.
+        this.is40Track = false;
 
-        this.writeTrackCallback = undefined;
+        this._trackWriteListeners = new Set();
         this.isWriteable = isWriteable;
 
         // Track which tracks have been written since the last snapshot.
@@ -791,8 +931,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);
     }
 
     /**
@@ -891,10 +1037,11 @@ export class Disc {
         // console.log(`wrote to ${track}:${position * 32}`);
     }
 
+    /** @returns {?{isSideUpper: boolean, trackNum: Number}} the track written, if there was one */
     flushWrites() {
         if (!this.isDirty) {
             if (this.dirtySide !== -1 || this.dirtyTrack !== -1) throw new Error("Bad state in disc dirty tracking");
-            return;
+            return null;
         }
 
         const dirtySide = this.dirtySide;
@@ -902,10 +1049,27 @@ 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);
+        return { isSideUpper: dirtySide, trackNum: dirtyTrack };
+    }
+
+    /**
+     * Leave a track with no flux on it at all, as an erase head does.
+     *
+     * @param {boolean} isSideUpper
+     * @param {Number} trackNum
+     */
+    eraseTrack(isSideUpper, trackNum) {
+        const trackObj = this.getTrack(isSideUpper, trackNum);
+        trackObj.pulses2Us.fill(0);
+        trackObj.length = IbmDiscFormat.bytesPerTrack;
+        const dirtyKey = trackNum | (isSideUpper ? 0x100 : 0);
+        this._snapshotDirtyTracks.add(dirtyKey);
+        this._everDirtyTracks.add(dirtyKey);
+        this.setTrackUsed(isSideUpper, trackNum);
+        for (const listener of this._trackWriteListeners) listener(isSideUpper, trackNum, trackObj);
     }
 
     /**

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: