jsbeeb 1.15.0 → 1.17.0

package/src/disc-drive.js

@@ -33,6 +33,21 @@ export class BaseDiscDrive extends EventTarget {
         throw new Error("Not implemented: headPosition getter");
     }
 
+    /** @returns {boolean} */
+    get isSideUpper() {
+        throw new Error("Not implemented: isSideUpper getter");
+    }
+
+    /** @returns {Number} */
+    get tracksPerStep() {
+        throw new Error("Not implemented: tracksPerStep getter");
+    }
+
+    /** @param {Number} _tracksPerStep */
+    set tracksPerStep(_tracksPerStep) {
+        throw new Error("Not implemented: tracksPerStep setter");
+    }
+
     /** @returns {boolean} */
     get indexPulse() {
         throw new Error("Not implemented: indexPulse getter");
@@ -155,8 +170,10 @@ export class DiscDrive extends BaseDiscDrive {
         this._scheduler = scheduler;
         /** @type {Disc|undefined} */
         this._disc = undefined;
-        this._is40Track = false;
-        // Physically always 80 tracks even if we're in 40 track mode. 40 track mode essentially double steps.
+        // Two for a drive whose 40/80 switch is set to 40, which reaches a 48 tpi format by
+        // stepping twice for each track the controller counts.
+        this._tracksPerStep = 1;
+        // Where the head is over the 96 tpi surface, whatever the controller believes.
         this._track = 0;
         this._isSideUpper = false;
         // In units where 3125 is a normal track length.
@@ -240,6 +257,10 @@ export class DiscDrive extends BaseDiscDrive {
         return this._track;
     }
 
+    get isSideUpper() {
+        return this._isSideUpper;
+    }
+
     get positionFraction() {
         return (this._headPosition + this._pulsePosition / 32) / this.trackLength;
     }
@@ -296,6 +317,22 @@ export class DiscDrive extends BaseDiscDrive {
         this._disc = disc;
     }
 
+    /** @returns {Number} how many of the surface's tracks the head crosses for one of the format's */
+    get tracksPerStep() {
+        return this._tracksPerStep;
+    }
+
+    set tracksPerStep(tracksPerStep) {
+        if (tracksPerStep !== 1 && tracksPerStep !== 2)
+            throw new Error(`Drives step over one or two tracks at a time, not ${tracksPerStep}`);
+        this._tracksPerStep = tracksPerStep;
+    }
+
+    /** @returns {Number} the track the controller believes the head is on */
+    get logicalTrack() {
+        return (this._track / this._tracksPerStep) | 0;
+    }
+
     get indexPulse() {
         // With no disc loaded the drive asserts the index all the time.
         if (!this.disc) return true;
@@ -330,22 +367,22 @@ export class DiscDrive extends BaseDiscDrive {
      * @param {Number} delta track step delta, either 1 or -1
      */
     seekOneTrack(delta) {
-        if (this._is40Track) delta *= 2;
-        this._selectTrack(this._track + delta);
+        this._selectTrack(this._track + delta * this._tracksPerStep);
     }
 
     /**
      * Notify that an overall seek is happening to a particular track. Purely informational.
      */
     notifySeek(newTrack) {
-        this.notifySeekAmount(newTrack - this._track);
+        this.notifySeekAmount(newTrack - this.logicalTrack);
     }
 
     /**
-     * Notify that an overall seek is happening by some delta smount. Purely informational.
+     * Notify that an overall seek is happening by some delta amount. Purely informational.
      */
     notifySeekAmount(delta) {
-        this.dispatchEvent(new StepEvent(delta));
+        // The step drives the seek noise, so it counts the tracks the head crosses.
+        this.dispatchEvent(new StepEvent(delta * this._tracksPerStep));
     }
 
     /**
@@ -353,11 +390,12 @@ export class DiscDrive extends BaseDiscDrive {
      */
     _selectTrack(track) {
         this._checkTrackNeedsWrite();
+        const lastTrack = IbmDiscFormat.tracksPerDisc - this._tracksPerStep;
         if (track < 0) {
             track = 0;
             console.log("Clang! disc head stopped at track 0");
-        } else if (track >= IbmDiscFormat.tracksPerDisc) {
-            track = IbmDiscFormat.tracksPerDisc - 1;
+        } else if (track > lastTrack) {
+            track = lastTrack;
             console.log("Clang! disc head stopper at track max");
         }
         const fraction = this.positionFraction;
@@ -366,7 +404,11 @@ export class DiscDrive extends BaseDiscDrive {
     }
 
     _checkTrackNeedsWrite() {
-        if (this.disc) this.disc.flushWrites();
+        if (!this.disc) return;
+        const written = this.disc.flushWrites();
+        // A 48 tpi head writes across most of its band but not as far as the neighbouring 96 tpi
+        // track, which is left in the guard band with nothing readable on it.
+        if (written && this._tracksPerStep === 2) this.disc.eraseTrack(written.isSideUpper, written.trackNum ^ 1);
     }
 
     snapshotState() {
@@ -377,7 +419,7 @@ export class DiscDrive extends BaseDiscDrive {
             pulsePosition: this._pulsePosition,
             in32usMode: this._in32usMode,
             spinning: this._spinning,
-            is40Track: this._is40Track,
+            is40Track: this._tracksPerStep === 2,
             timerTaskOffset: this._timer.scheduled() ? this._timer.expireEpoch - this._scheduler.epoch : null,
             disc: this._disc ? this._disc.snapshotState() : null,
         };
@@ -389,7 +431,7 @@ export class DiscDrive extends BaseDiscDrive {
         this._headPosition = state.headPosition;
         this._pulsePosition = state.pulsePosition;
         this._in32usMode = state.in32usMode;
-        this._is40Track = state.is40Track;
+        this._tracksPerStep = state.is40Track ? 2 : 1;
 
         // Restore spinning state and timer
         this._timer.cancel();

package/src/disc-hfe.js

@@ -12,6 +12,7 @@ const HfeV3OpcodeSetIndex = 0xf1;
 const HfeV3OpcodeSetBitrate = 0xf2;
 const HfeV3OpcodeSkipBits = 0xf3;
 const HfeV3OpcodeRand = 0xf4;
+const HfeTrackCountOffset = 9;
 const HfeBlockSideSize = 256;
 const HfeBlockSize = HfeBlockSideSize * 2;
 const HfeShugartDdFloppyMode = 7;
@@ -52,6 +53,21 @@ function hfeGetTrackOffsetAndLength(metadata, track) {
     return { offset, length };
 }
 
+/**
+ * Whether an HFE image holds a 40 track format. A capture with no more tracks than half a surface
+ * cannot be one of an 80 track disc, whatever drive read it.
+ *
+ * @param {Uint8Array} data
+ * @returns {{is40Track: boolean, reason: string}}
+ */
+export function sniffHfeLayout(data) {
+    const numTracks = data.length > HfeTrackCountOffset ? data[HfeTrackCountOffset] : 0;
+    return {
+        is40Track: numTracks > 0 && numTracks * 2 <= IbmDiscFormat.tracksPerDisc,
+        reason: `its header declares ${numTracks} tracks`,
+    };
+}
+
 /**
  * Load a disc image in HFE format (v1 or v3)
  * @param {import("./disc.js").Disc} disc - The disc object to load into
@@ -84,11 +100,12 @@ export function loadHfe(disc, data, onChange) {
     const numSides = data[10];
     if (numSides < 1 || numSides > 2) throw new Error(`Invalid number of sides: ${numSides}`);
 
-    const numTracks = data[9];
+    const numTracks = data[HfeTrackCountOffset];
     if (numTracks > IbmDiscFormat.tracksPerDisc) throw new Error(`Too many tracks: ${numTracks}`);
     let expandShift = 0;
     if (disc.config.expandTo80 && numTracks * 2 <= IbmDiscFormat.tracksPerDisc) {
         expandShift = 1;
+        disc.is40Track = true;
         console.log("Expanding 40 tracks to 80");
     }
 
@@ -190,9 +207,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

package/src/disc-surface.js

@@ -0,0 +1,350 @@
+"use strict";
+
+// Pure geometry and colour mapping, free of the DOM; disc-visualiser.js owns the canvases.
+
+import { IbmDiscFormat } from "./disc.js";
+
+/** One FM byte, or two MFM bytes; 2us a slot. */
+export const PulsesPerWord = 32;
+
+/**
+ * Both FM and MFM put between eight and sixteen flux transitions in a formatted word, so the ramp
+ * spans exactly that and gets one step per count.
+ */
+export const MinDensity = 8;
+export const MaxDensity = 16;
+
+/** Dark to light, for a dark surface. */
+export const DensityRampHex = [
+    "#1c5cab",
+    "#256abf",
+    "#2a78d6",
+    "#3987e5",
+    "#5598e7",
+    "#6da7ec",
+    "#86b6ef",
+    "#9ec5f4",
+    "#cde2fb",
+];
+
+export const UnformattedHex = "#2a2a28";
+
+export const Region = {
+    Unformatted: 0,
+    Gap: 1,
+    Header: 2,
+    Data: 3,
+    Deleted: 4,
+};
+
+/**
+ * Indexed by {@link Region}. Gap and unformatted are recessive neutrals; header, data and deleted
+ * carry identity.
+ */
+export const RegionStyles = [
+    { name: "unformatted", hex: UnformattedHex },
+    { name: "gap", hex: "#3f3f3c" },
+    { name: "header", hex: "#d95926" },
+    { name: "data", hex: "#3987e5" },
+    { name: "deleted data", hex: "#199e70" },
+];
+
+/** Reserved status colour, never used as a fill. */
+export const ErrorHex = "#d03b3b";
+
+/** Canvas pixel buffers are little-endian ABGR, as in bbc-palette.js. */
+function hexToAbgr(hex) {
+    const value = parseInt(hex.slice(1), 16);
+    const r = (value >>> 16) & 0xff;
+    const g = (value >>> 8) & 0xff;
+    const b = value & 0xff;
+    return ((0xff << 24) | (b << 16) | (g << 8) | r) >>> 0;
+}
+
+const UnformattedColour = hexToAbgr(UnformattedHex);
+
+/** Indexed by pulse count. */
+export const DensityPalette = Uint32Array.from({ length: PulsesPerWord + 1 }, (_, density) => {
+    if (density === 0) return UnformattedColour;
+    const step = Math.min(Math.max(density - MinDensity, 0), DensityRampHex.length - 1);
+    return hexToAbgr(DensityRampHex[step]);
+});
+
+export const RegionPalette = Uint32Array.from(RegionStyles, ({ hex }) => hexToAbgr(hex));
+
+/**
+ * @param {number} pulses one word of surface data
+ * @returns {number} flux transitions it holds
+ */
+export function pulseDensity(pulses) {
+    let bits = pulses - ((pulses >>> 1) & 0x55555555);
+    bits = (bits & 0x33333333) + ((bits >>> 2) & 0x33333333);
+    return (((bits + (bits >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+}
+
+/**
+ * @param {Track} track
+ * @returns {Uint8Array} flux transitions in each word of the track
+ */
+export function trackPulseDensity(track) {
+    const density = new Uint8Array(track.length);
+    for (let word = 0; word < track.length; ++word) density[word] = pulseDensity(track.pulses2Us[word]);
+    return density;
+}
+
+/** Address mark aside, a sector header is four bytes of identity and two of CRC. */
+const HeaderBytes = 6;
+const CrcBytes = 2;
+
+/**
+ * Pick the sectors out of a track and say what each word of it holds.
+ *
+ * @param {Track} track
+ * @param {function(string): void} [warn] where to send the decoder's complaints
+ * @returns {{codes: Uint8Array, sectorNumbers: Int16Array, errors: {firstWord: number, lastWord: number, kind: string, sectorNumber: number}[]}}
+ */
+export function trackRegions(track, warn) {
+    const codes = new Uint8Array(track.length);
+    const sectorNumbers = new Int16Array(track.length).fill(-1);
+    const errors = [];
+    for (let word = 0; word < track.length; ++word)
+        codes[word] = track.pulses2Us[word] === 0 ? Region.Unformatted : Region.Gap;
+
+    /** Marks the words a bit range covers, wrapping at the index. */
+    const fill = (startBit, endBit, code, sectorNumber) => {
+        for (let word = Math.floor(startBit / PulsesPerWord); word < Math.ceil(endBit / PulsesPerWord); ++word) {
+            const index = ((word % track.length) + track.length) % track.length;
+            codes[index] = code;
+            sectorNumbers[index] = sectorNumber;
+        }
+    };
+
+    for (const sector of track.findSectors(warn)) {
+        const pulsesPerByte = sector.isMfm ? PulsesPerWord / 2 : PulsesPerWord;
+        const noteError = (kind, startBit, endBit) =>
+            errors.push({
+                firstWord: Math.floor(startBit / PulsesPerWord) % track.length,
+                lastWord: Math.ceil(endBit / PulsesPerWord) % track.length,
+                kind,
+                sectorNumber: sector.sectorNumber,
+            });
+
+        // A region starts at its address mark, which sits one byte before the offset the reader
+        // was handed.
+        const idStart = sector.idPosBitOffset - pulsesPerByte;
+        const idEnd = sector.idPosBitOffset + HeaderBytes * pulsesPerByte;
+        fill(idStart, idEnd, Region.Header, sector.sectorNumber);
+        if (sector.hasHeaderCrcError) noteError("header CRC", idStart, idEnd);
+
+        if (sector.dataPosBitOffset === null) continue;
+        // A failed CRC leaves no confirmed length, so fall back to what the header claimed.
+        const bytes = sector.byteLength ?? 128 << Math.min(sector.header[3], 4);
+        const dataStart = sector.dataPosBitOffset - pulsesPerByte;
+        const dataEnd = sector.dataPosBitOffset + (bytes + CrcBytes) * pulsesPerByte;
+        const code = sector.isDeleted ? Region.Deleted : Region.Data;
+        fill(dataStart, dataEnd, code, sector.sectorNumber);
+        if (sector.hasDataCrcError) noteError("data CRC", dataStart, dataEnd);
+    }
+    return { codes, sectorNumbers, errors };
+}
+
+/** Enough to fill the view with a couple of tracks. */
+export const MaxZoom = 32;
+
+export const clampZoom = (zoom) => Math.min(Math.max(zoom, 1), MaxZoom);
+
+const OuterRadiusFraction = 0.97;
+const InnerRadiusFraction = 0.36;
+const HubRadiusFraction = 0.26;
+
+/**
+ * Maps between a square canvas and the surface of a disc drawn on it. Disc space is the canvas at
+ * rest, with the platter filling a `size` square; zoom and pan move the canvas over it.
+ */
+export class DiscGeometry {
+    /**
+     * @param {number} size canvas edge in device pixels
+     * @param {number} numTracks
+     */
+    constructor(size, numTracks = IbmDiscFormat.tracksPerDisc) {
+        this.size = size;
+        this.numTracks = numTracks;
+        this.centre = size / 2;
+        this.outerRadius = this.centre * OuterRadiusFraction;
+        this.innerRadius = this.centre * InnerRadiusFraction;
+        this.hubRadius = this.centre * HubRadiusFraction;
+        this.trackPitch = (this.outerRadius - this.innerRadius) / numTracks;
+        this.zoom = 1;
+        this.originX = 0;
+        this.originY = 0;
+    }
+
+    /**
+     * @param {number} zoom canvas pixels per disc pixel, at least 1
+     * @param {number} originX disc-space coordinate shown at the canvas's left edge
+     * @param {number} originY disc-space coordinate shown at the canvas's top edge
+     */
+    setView(zoom, originX, originY) {
+        this.zoom = clampZoom(zoom);
+        // Holding the window inside the platter's square keeps the disc from being panned away.
+        const slack = this.size - this.size / this.zoom;
+        this.originX = Math.min(Math.max(originX, 0), slack);
+        this.originY = Math.min(Math.max(originY, 0), slack);
+        return this;
+    }
+
+    /** The origin is in disc pixels, which scale with the canvas. */
+    adoptView({ zoom, originX, originY, size }) {
+        return this.setView(zoom, (originX * this.size) / size, (originY * this.size) / size);
+    }
+
+    toDisc(x, y) {
+        return { x: x / this.zoom + this.originX, y: y / this.zoom + this.originY };
+    }
+
+    get screenCentreX() {
+        return (this.centre - this.originX) * this.zoom;
+    }
+
+    get screenCentreY() {
+        return (this.centre - this.originY) * this.zoom;
+    }
+
+    screenRadiusOf(track) {
+        return this.radiusOf(track) * this.zoom;
+    }
+
+    /** Track 0 is the outermost, as on the real thing. */
+    trackAt(radius) {
+        const track = Math.floor((this.outerRadius - radius) / this.trackPitch);
+        return track >= 0 && track < this.numTracks ? track : null;
+    }
+
+    radiusOf(track) {
+        return this.outerRadius - (track + 0.5) * this.trackPitch;
+    }
+
+    /** Index sits at twelve o'clock, with the surface running clockwise from there. */
+    angleOf(fraction) {
+        return fraction * 2 * Math.PI - Math.PI / 2;
+    }
+
+    /**
+     * @param {number} dx offset from the centre
+     * @param {number} dy offset from the centre
+     * @returns {number} how far round from the index, in [0, 1)
+     */
+    fractionAt(dx, dy) {
+        const fraction = (Math.atan2(dy, dx) + Math.PI / 2) / (2 * Math.PI);
+        return fraction - Math.floor(fraction);
+    }
+
+    /** @returns {{x: number, y: number}} where on the canvas that point of the surface is drawn */
+    pointAt(track, fraction) {
+        const angle = this.angleOf(fraction);
+        const radius = this.screenRadiusOf(track);
+        return { x: this.screenCentreX + radius * Math.cos(angle), y: this.screenCentreY + radius * Math.sin(angle) };
+    }
+
+    /**
+     * @returns {{track: number, fraction: number}|null} what the surface holds under a canvas point
+     */
+    positionAt(x, y) {
+        const disc = this.toDisc(x, y);
+        const dx = disc.x - this.centre;
+        const dy = disc.y - this.centre;
+        const track = this.trackAt(Math.hypot(dx, dy));
+        return track === null ? null : { track, fraction: this.fractionAt(dx, dy) };
+    }
+}
+
+const Supersample = 2;
+const InvTwoPi = 1 / (2 * Math.PI);
+
+/** Math.hypot's overflow scaling is pure cost at canvas coordinates, and this is the hot path. */
+function distance(dx, dy) {
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ * Paint a range of tracks into a square ABGR pixel buffer. Only pixels whose centres fall in the
+ * band those tracks occupy are written.
+ *
+ * @param {Uint32Array} pixels size * size ABGR pixels
+ * @param {DiscGeometry} geometry
+ * @param {(Uint8Array|null)[]} codes one value per word, indexed by track
+ * @param {Uint32Array} palette ABGR for each code
+ * @param {number} firstTrack
+ * @param {number} lastTrack inclusive
+ * @param {number} [supersample] samples per pixel edge; 1 trades the smoothed edges for speed
+ */
+export function renderTracks(pixels, geometry, codes, palette, firstTrack, lastTrack, supersample = Supersample) {
+    const { size, outerRadius, trackPitch, numTracks, zoom } = geometry;
+    // Work in canvas pixels throughout: zooming and panning scale and shift the radius, and leave
+    // the angle alone.
+    const centreX = geometry.screenCentreX;
+    const centreY = geometry.screenCentreY;
+    const bandOuter = (outerRadius - firstTrack * trackPitch) * zoom;
+    const bandInner = (outerRadius - (lastTrack + 1) * trackPitch) * zoom;
+    const bandOuterSquared = bandOuter * bandOuter;
+    const bandInnerSquared = bandInner * bandInner;
+    const samplesPerPixel = supersample * supersample;
+    const subStep = 1 / supersample;
+
+    /** @returns {number} the pixel's ABGR, averaged over its samples, or zero if no track covers it */
+    const samplePixel = (x, y) => {
+        let covered = 0;
+        let red = 0;
+        let green = 0;
+        let blue = 0;
+        for (let subY = 0; subY < supersample; ++subY) {
+            const sampleY = y + (subY + 0.5) * subStep - centreY;
+            for (let subX = 0; subX < supersample; ++subX) {
+                const sampleX = x + (subX + 0.5) * subStep - centreX;
+                const at = (outerRadius - distance(sampleX, sampleY) / zoom) / trackPitch;
+                if (at < 0 || at >= numTracks) continue;
+                const trackCodes = codes[at | 0];
+                if (!trackCodes || trackCodes.length === 0) continue;
+                let fraction = Math.atan2(sampleY, sampleX) * InvTwoPi + 0.25;
+                if (fraction < 0) fraction += 1;
+                const word = Math.min((fraction * trackCodes.length) | 0, trackCodes.length - 1);
+                const colour = palette[trackCodes[word]];
+                red += colour & 0xff;
+                green += (colour >>> 8) & 0xff;
+                blue += (colour >>> 16) & 0xff;
+                covered++;
+            }
+        }
+        if (covered === 0) return 0;
+        const alpha = ((255 * covered) / samplesPerPixel) | 0;
+        return (
+            ((alpha << 24) |
+                (((blue / covered) | 0) << 16) |
+                (((green / covered) | 0) << 8) |
+                ((red / covered) | 0)) >>>
+            0
+        );
+    };
+
+    const firstRow = Math.max(0, Math.floor(centreY - bandOuter));
+    const lastRow = Math.min(size, Math.ceil(centreY + bandOuter) + 1);
+    for (let y = firstRow; y < lastRow; ++y) {
+        const dy = y + 0.5 - centreY;
+        const halfWidth = Math.sqrt(Math.max(0, bandOuterSquared - dy * dy));
+        const low = Math.max(0, Math.floor(centreX - halfWidth));
+        const high = Math.min(size, Math.ceil(centreX + halfWidth) + 1);
+        const holeHalfWidth = Math.abs(dy) < bandInner ? Math.sqrt(bandInnerSquared - dy * dy) : 0;
+        const pastHole = Math.ceil(centreX + holeHalfWidth - 0.5);
+        for (let x = low; x < high; ++x) {
+            const dx = x + 0.5 - centreX;
+            if (Math.abs(dx) < holeHalfWidth) {
+                x = Math.max(x, pastHole - 1);
+                continue;
+            }
+            const radiusSquared = dx * dx + dy * dy;
+            if (radiusSquared < bandInnerSquared || radiusSquared >= bandOuterSquared) continue;
+            const colour = samplePixel(x, y);
+            if (colour !== 0) pixels[y * size + x] = colour;
+        }
+    }
+}