jsbeeb 1.12.0 → 1.13.0

package/src/tapes.js

@@ -1,10 +1,18 @@
 "use strict";
 import * as utils from "./utils.js";
 
-function secsToClocks(secs) {
-    return (2 * 1000 * 1000 * secs) | 0;
+const BbcCpuSpeed = 2 * 1000 * 1000;
+const AtomCpuSpeed = 1 * 1000 * 1000;
+
+function secsToClocks(secs, cpuSpeed) {
+    return (cpuSpeed * secs) | 0;
 }
 
+// Atom tape encoding: wavebits sent one per poll via receiveBit().
+// '0' bit = 4 cycles at 1200 Hz (toggle every 2 wavebits).
+// '1' bit = 8 cycles at 2400 Hz (toggle every 1 wavebit).
+// Carrier = continuous '1' bits.
+
 function parityOf(curByte) {
     let parity = false;
     while (curByte) {
@@ -17,9 +25,11 @@ function parityOf(curByte) {
 const ParityN = "N".charCodeAt(0);
 
 class UefTape {
-    constructor(stream) {
+    constructor(stream, isAtom = false) {
         this.stream = stream;
         this.baseFrequency = 1200;
+        this.isAtom = isAtom;
+        this.cpuSpeed = isAtom ? AtomCpuSpeed : BbcCpuSpeed;
         this.rewind();
 
         this.curChunk = this.readChunk();
@@ -36,6 +46,11 @@ class UefTape {
         this.numStopBits = 1;
         this.carrierBefore = 0;
         this.carrierAfter = 0;
+        this.shortWave = 0;
+        this.atomPhase = 0;
+        this.atomSubCount = 0;
+        this.atomWavebitsLeft = 0;
+        this.atomToggleEvery = 1;
 
         this.stream.seek(10);
         const minor = this.stream.readByte();
@@ -52,8 +67,22 @@ class UefTape {
         };
     }
 
+    // On BBC, acia is the ACIA (6850); on Atom, it's the PPIA (8255).
+    // Both provide setTapeCarrier(), tone(), and receive/receiveBit().
     poll(acia) {
         if (!this.curChunk) return;
+
+        // Atom: deliver one wavebit per poll.
+        if (this.isAtom && this.atomWavebitsLeft > 0) {
+            if (++this.atomSubCount >= this.atomToggleEvery) {
+                this.atomPhase ^= 1;
+                this.atomSubCount = 0;
+            }
+            acia.receiveBit(this.atomPhase);
+            this.atomWavebitsLeft--;
+            return secsToClocks(0.25 / this.baseFrequency, this.cpuSpeed);
+        }
+
         if (this.state === -1) {
             if (this.stream.eof()) {
                 this.curChunk = null;
@@ -77,13 +106,17 @@ class UefTape {
                     if (this.state === 0) {
                         // Start bit
                         acia.tone(this.baseFrequency);
+                        if (this.isAtom) this.queueAtomBit(false);
                     } else {
-                        acia.tone(this.curByte & (1 << (this.state - 1)) ? 2 * this.baseFrequency : this.baseFrequency);
+                        const bit = this.curByte & (1 << (this.state - 1));
+                        acia.tone(bit ? 2 * this.baseFrequency : this.baseFrequency);
+                        if (this.isAtom) this.queueAtomBit(!!bit);
                     }
                     this.state++;
                 } else {
                     acia.receive(this.curByte);
                     acia.tone(2 * this.baseFrequency); // Stop bit
+                    if (this.isAtom) this.queueAtomBit(true);
                     if (this.curChunk.stream.eof()) {
                         this.state = -1;
                     } else {
@@ -91,6 +124,7 @@ class UefTape {
                         this.curByte = this.curChunk.stream.readByte();
                     }
                 }
+                if (this.isAtom) return 0; // wavebits queued, drained on next poll
                 return this.cycles(1);
             case 0x0104: // Defined data
                 acia.setTapeCarrier(false);
@@ -99,8 +133,14 @@ class UefTape {
                     this.parity = this.curChunk.stream.readByte();
                     this.numStopBits = this.curChunk.stream.readByte();
                     this.numParityBits = this.parity !== ParityN ? 1 : 0;
+                    // Atom: negative stop bits (high bit set) means short wave
+                    this.shortWave = 0;
+                    if (this.isAtom && this.numStopBits & 0x80) {
+                        this.numStopBits = Math.abs(this.numStopBits - 256);
+                        this.shortWave = 1;
+                    }
                     console.log(
-                        `Defined data with ${this.numDataBits}${String.fromCharCode(this.parity)}${this.numStopBits}`,
+                        `Defined data with ${this.numDataBits}${String.fromCharCode(this.parity)}${this.shortWave ? "-" : ""}${this.numStopBits}`,
                     );
                     this.state = 0;
                 }
@@ -110,24 +150,30 @@ class UefTape {
                     } else {
                         this.curByte = this.curChunk.stream.readByte() & ((1 << this.numDataBits) - 1);
                         acia.tone(this.baseFrequency); // Start bit
+                        if (this.isAtom) this.queueAtomBit(false);
                         this.state++;
                     }
                 } else if (this.state < 1 + this.numDataBits) {
-                    acia.tone(this.curByte & (1 << (this.state - 1)) ? 2 * this.baseFrequency : this.baseFrequency);
+                    const bit = this.curByte & (1 << (this.state - 1));
+                    acia.tone(bit ? 2 * this.baseFrequency : this.baseFrequency);
+                    if (this.isAtom) this.queueAtomBit(!!bit);
                     this.state++;
                 } else if (this.state < 1 + this.numDataBits + this.numParityBits) {
                     let bit = parityOf(this.curByte);
                     if (this.parity === ParityN) bit = !bit;
                     acia.tone(bit ? 2 * this.baseFrequency : this.baseFrequency);
+                    if (this.isAtom) this.queueAtomBit(!!bit);
                     this.state++;
                 } else if (this.state < 1 + this.numDataBits + this.numParityBits + this.numStopBits) {
                     acia.tone(2 * this.baseFrequency); // Stop bits
+                    if (this.isAtom) this.queueAtomBit(true);
                     this.state++;
                 } else {
                     acia.receive(this.curByte);
                     this.state = 0;
                     return 0;
                 }
+                if (this.isAtom) return 0;
                 return this.cycles(1);
             case 0x0111: // Carrier tone with dummy data
                 if (this.state === -1) {
@@ -139,11 +185,13 @@ class UefTape {
                 if (this.state === 0) {
                     acia.setTapeCarrier(true);
                     acia.tone(2 * this.baseFrequency);
+                    if (this.isAtom) this.queueAtomBit(true);
                     this.carrierBefore--;
                     if (this.carrierBefore <= 0) this.state = 1;
                 } else if (this.state < 11) {
                     acia.setTapeCarrier(false);
                     acia.tone(this.dummyData[this.state - 1] ? this.baseFrequency : 2 * this.baseFrequency);
+                    if (this.isAtom) this.queueAtomBit(!this.dummyData[this.state - 1]);
                     if (this.state === 10) {
                         acia.receive(0xaa);
                     }
@@ -151,9 +199,11 @@ class UefTape {
                 } else {
                     acia.setTapeCarrier(true);
                     acia.tone(2 * this.baseFrequency);
+                    if (this.isAtom) this.queueAtomBit(true);
                     this.carrierAfter--;
                     if (this.carrierAfter <= 0) this.state = -1;
                 }
+                if (this.isAtom) return 0;
                 return this.cycles(1);
             case 0x0114:
                 console.log("Ignoring security cycles");
@@ -165,11 +215,16 @@ class UefTape {
                 if (this.state === -1) {
                     this.state = 0;
                     this.count = this.curChunk.stream.readInt16();
+                    // Each Atom carrier cycle expands to 16 wavebits, so
+                    // divide the count to avoid 16x too many cycles.
+                    if (this.isAtom) this.count = Math.max(1, (this.count / 16) | 0);
                 }
                 acia.setTapeCarrier(true);
                 acia.tone(2 * this.baseFrequency);
+                if (this.isAtom) this.queueAtomBit(true);
                 this.count--;
                 if (this.count <= 0) this.state = -1;
+                if (this.isAtom) return 0;
                 return this.cycles(1);
             case 0x0113:
                 this.baseFrequency = this.curChunk.stream.readFloat32();
@@ -180,13 +235,13 @@ class UefTape {
                 gap = 1 / (2 * this.curChunk.stream.readInt16() * this.baseFrequency);
                 console.log("Tape gap of " + gap + "s");
                 acia.tone(0);
-                return secsToClocks(gap);
+                return secsToClocks(gap, this.cpuSpeed);
             case 0x0116:
                 acia.setTapeCarrier(false);
                 gap = this.curChunk.stream.readFloat32();
                 console.log("Tape gap of " + gap + "s");
                 acia.tone(0);
-                return secsToClocks(gap);
+                return secsToClocks(gap, this.cpuSpeed);
             default:
                 console.log("Skipping unknown chunk " + utils.hexword(this.curChunk.id));
                 this.curChunk = this.readChunk();
@@ -195,8 +250,15 @@ class UefTape {
         return this.cycles(1);
     }
 
+    // Queue 16 wavebits for an Atom tape bit. atomPhase and atomSubCount
+    // carry across calls so bit boundaries don't break carrier detection.
+    queueAtomBit(isOne) {
+        this.atomWavebitsLeft = 16;
+        this.atomToggleEvery = isOne ? 1 : 2;
+    }
+
     cycles(count) {
-        return secsToClocks(count / this.baseFrequency);
+        return secsToClocks(count / this.baseFrequency, this.cpuSpeed);
     }
 }
 
@@ -245,7 +307,7 @@ class TapefileTape {
     }
 }
 
-export async function loadTapeFromData(name, data) {
+export async function loadTapeFromData(name, data, isAtom = false) {
     const stream = await utils.DataStream.create(name, data);
     if (stream.readByte(0) === 0xff && stream.readByte(1) === 0x04) {
         console.log("Detected a 'tapefile' tape");
@@ -253,13 +315,8 @@ export async function loadTapeFromData(name, data) {
     }
     if (stream.readNulString(0) === "UEF File!") {
         console.log("Detected a UEF tape");
-        return new UefTape(stream);
+        return new UefTape(stream, isAtom);
     }
     console.log("Unknown tape format");
     return null;
 }
-
-export async function loadTape(name) {
-    console.log("Loading tape from " + name);
-    return loadTapeFromData(name, await utils.loadData(name));
-}

package/src/url-params.js

@@ -240,6 +240,7 @@ export function processAutobootParams(parsedQuery) {
 export function guessModelFromHostname(hostname) {
     if (hostname.startsWith("bbc")) return "B-DFS1.2";
     if (hostname.startsWith("master")) return "Master";
+    if (hostname.startsWith("atom")) return "Atom";
     return "B-DFS1.2";
 }
 
@@ -247,10 +248,14 @@ export function guessModelFromHostname(hostname) {
  * Parse disc or tape images from the query parameters
  * @param {Object} parsedQuery - The query parameters
  * @returns {Object} Object containing disc and tape information
+ *   - discImage: disc image URL (?disc= or ?disc1=)
+ *   - secondDiscImage: second disc URL (?disc2=)
+ *   - tapeImage: tape image URL (?tape=)
+ *   - mmcImage: MMC/SD card image URL (?mmc=, Atom only)
  */
 export function parseMediaParams(parsedQuery) {
-    const { disc, disc1, disc2, tape } = parsedQuery;
+    const { disc, disc1, disc2, tape, mmc } = parsedQuery;
     const discImage = disc || disc1;
 
-    return { discImage, secondDiscImage: disc2, tapeImage: tape };
+    return { discImage, secondDiscImage: disc2, tapeImage: tape, mmcImage: mmc };
 }

package/src/utils.js

@@ -77,7 +77,7 @@ export async function decompress(data, format) {
 }
 
 // Extract all files from a ZIP archive.  Returns {filename: Uint8Array}.
-async function unzip(buf) {
+export async function unzip(buf) {
     if (!(buf instanceof Uint8Array)) buf = new Uint8Array(buf);
     const eocdOff = findEocd(buf);
     const cdOff = readU32(buf, eocdOff + 16);
@@ -120,6 +120,79 @@ async function unzip(buf) {
     return files;
 }
 
+// Standard CRC-32/ISO-HDLC.
+export function crc32(data) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; ++i) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; ++j) {
+            const doEor = crc & 1;
+            crc = crc >>> 1;
+            if (doEor) crc ^= 0xedb88320;
+        }
+    }
+    return ~crc;
+}
+
+// Create a ZIP blob from an array of {name: string, data: Uint8Array} entries.
+// Uses stored method (no compression) with CRC-32 for maximum compatibility.
+export function createZipBlob(files) {
+    const encoder = new TextEncoder();
+    const localHeaders = [];
+    const centralHeaders = [];
+    let offset = 0;
+
+    for (const { name, data } of files) {
+        const nameBytes = encoder.encode(name);
+        const crc = crc32(data);
+        // Local file header (30 + nameLen + data)
+        const local = new Uint8Array(30 + nameBytes.length + data.length);
+        const lv = new DataView(local.buffer);
+        lv.setUint32(0, 0x04034b50, true); // signature
+        lv.setUint16(4, 20, true); // version needed
+        lv.setUint16(8, 0, true); // method: stored
+        lv.setUint32(14, crc, true); // CRC-32
+        lv.setUint32(18, data.length, true); // compressed size
+        lv.setUint32(22, data.length, true); // uncompressed size
+        lv.setUint16(26, nameBytes.length, true); // name length
+        local.set(nameBytes, 30);
+        local.set(data, 30 + nameBytes.length);
+        localHeaders.push(local);
+
+        // Central directory entry (46 + nameLen)
+        const central = new Uint8Array(46 + nameBytes.length);
+        const cv = new DataView(central.buffer);
+        cv.setUint32(0, 0x02014b50, true); // signature
+        cv.setUint16(4, 20, true); // version made by
+        cv.setUint16(6, 20, true); // version needed
+        cv.setUint16(10, 0, true); // method: stored
+        cv.setUint32(16, crc, true); // CRC-32
+        cv.setUint32(20, data.length, true); // compressed size
+        cv.setUint32(24, data.length, true); // uncompressed size
+        cv.setUint16(28, nameBytes.length, true); // name length
+        cv.setUint32(42, offset, true); // local header offset
+        central.set(nameBytes, 46);
+        centralHeaders.push(central);
+
+        offset += local.length;
+    }
+
+    const cdOffset = offset;
+    let cdSize = 0;
+    for (const c of centralHeaders) cdSize += c.length;
+
+    // End of central directory (22 bytes)
+    const eocd = new Uint8Array(22);
+    const ev = new DataView(eocd.buffer);
+    ev.setUint32(0, 0x06054b50, true); // signature
+    ev.setUint16(8, files.length, true); // entries on this disc
+    ev.setUint16(10, files.length, true); // total entries
+    ev.setUint32(12, cdSize, true); // central directory size
+    ev.setUint32(16, cdOffset, true); // central directory offset
+
+    return new Blob([...localHeaders, ...centralHeaders, eocd], { type: "application/zip" });
+}
+
 export function debounce(fn, wait) {
     let timeout;
     return function (...args) {