jsbeeb 1.11.0 → 1.13.0

package/src/snapshot-helpers.js

@@ -0,0 +1,208 @@
+"use strict";
+
+// Shared helpers for snapshot importers (bem-snapshot.js, uef-snapshot.js).
+// Contains volume table, default peripheral state, video state builder,
+// and the common snapshot envelope that wraps per-format parsed state.
+
+// Volume lookup table matching soundchip.js
+export const volumeTable = new Float32Array(16);
+(() => {
+    let f = 1.0;
+    for (let i = 0; i < 15; ++i) {
+        volumeTable[i] = f / 4;
+        f *= Math.pow(10, -0.1);
+    }
+    volumeTable[15] = 0;
+})();
+
+export const DefaultAcia = {
+    sr: 0x02,
+    cr: 0x00,
+    dr: 0x00,
+    rs423Selected: false,
+    motorOn: false,
+    tapeCarrierCount: 0,
+    tapeDcdLineLevel: false,
+    hadDcdHigh: false,
+    serialReceiveRate: 19200,
+    serialReceiveCyclesPerByte: 0,
+    txCompleteTaskOffset: null,
+    runTapeTaskOffset: null,
+    runRs423TaskOffset: null,
+};
+
+export const DefaultAdc = { status: 0x40, low: 0x00, high: 0x00, taskOffset: null };
+
+/**
+ * Build jsbeeb video state from parsed CRTC, ULA, and palette data.
+ * @param {number} ulaControl - VideoULA control register
+ * @param {Uint8Array} ulaPalette - 16-entry raw ULA palette register values (lower nibble of &FE21 writes)
+ * @param {Uint8Array} crtcRegs - CRTC registers (at least 18 bytes)
+ * @param {Int32Array|null} [nulaCollook] - NULA colour lookup (16 ABGR entries), or null for default BBC palette
+ * @param {object|null} [crtcCounters] - CRTC counter state {hc, vc, sc, ma, maback}, or null for defaults
+ */
+export function buildVideoState(ulaControl, ulaPalette, crtcRegs, nulaCollook, crtcCounters) {
+    const regs = new Uint8Array(32);
+    regs.set(crtcRegs.slice(0, 18));
+    const actualPal = new Uint8Array(16);
+    for (let i = 0; i < 16; i++) actualPal[i] = ulaPalette[i] & 0x0f;
+
+    // Use NULA collook if provided, otherwise use default BBC palette
+    const collook =
+        nulaCollook ||
+        new Int32Array([
+            0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff, 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff, 0xff000000,
+            0xff0000ff, 0xff00ff00, 0xff00ffff, 0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff,
+        ]);
+
+    // Compute ulaPal from actualPal + collook, matching jsbeeb's Ula._recomputeUlaPal
+    const flashEnabled = !!(ulaControl & 1);
+    const defaultFlash = new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1]);
+    const flash = defaultFlash;
+    const ulaPal = new Int32Array(16);
+    for (let i = 0; i < 16; i++) {
+        const palVal = actualPal[i];
+        let colour = collook[(palVal & 0xf) ^ 7];
+        if (palVal & 8 && flashEnabled && flash[(palVal & 7) ^ 7]) {
+            colour = collook[palVal & 0xf];
+        }
+        ulaPal[i] = colour;
+    }
+
+    return {
+        regs,
+        bitmapX: 0,
+        bitmapY: 0,
+        oddClock: false,
+        frameCount: 0,
+        doEvenFrameLogic: false,
+        isEvenRender: true,
+        lastRenderWasEven: false,
+        firstScanline: true,
+        inHSync: false,
+        inVSync: false,
+        hadVSyncThisRow: false,
+        checkVertAdjust: false,
+        endOfMainLatched: false,
+        endOfVertAdjustLatched: false,
+        endOfFrameLatched: false,
+        inVertAdjust: false,
+        inDummyRaster: false,
+        hpulseWidth: regs[3] & 0x0f,
+        vpulseWidth: (regs[3] & 0xf0) >>> 4,
+        hpulseCounter: 0,
+        vpulseCounter: 0,
+        dispEnabled: 0x3f,
+        horizCounter: crtcCounters ? crtcCounters.hc : 0,
+        vertCounter: crtcCounters ? crtcCounters.vc : 0,
+        scanlineCounter: crtcCounters ? crtcCounters.sc : 0,
+        vertAdjustCounter: 0,
+        addr: crtcCounters ? crtcCounters.ma : (regs[13] | (regs[12] << 8)) & 0x3fff,
+        lineStartAddr: crtcCounters ? crtcCounters.maback : (regs[13] | (regs[12] << 8)) & 0x3fff,
+        nextLineStartAddr: crtcCounters ? crtcCounters.maback : (regs[13] | (regs[12] << 8)) & 0x3fff,
+        ulactrl: ulaControl,
+        pixelsPerChar: ulaControl & 0x10 ? 8 : 16,
+        halfClock: !(ulaControl & 0x10),
+        ulaMode: (ulaControl >>> 2) & 3,
+        teletextMode: !!(ulaControl & 2),
+        displayEnableSkew: Math.min((regs[8] & 0x30) >>> 4, 2),
+        ulaPal,
+        actualPal,
+        cursorOn: false,
+        cursorOff: false,
+        cursorOnThisFrame: false,
+        cursorDrawIndex: 0,
+        cursorPos: (regs[15] | (regs[14] << 8)) & 0x3fff,
+        interlacedSyncAndVideo: (regs[8] & 3) === 3,
+        screenSubtract: 0,
+        ula: {
+            collook: collook.slice(),
+            flash: new Uint8Array([1, 1, 1, 1, 1, 1, 1, 1]),
+            paletteWriteFlag: false,
+            paletteFirstByte: 0,
+            paletteMode: 0,
+            horizontalOffset: 0,
+            leftBlank: 0,
+            disabled: false,
+            attributeMode: 0,
+            attributeText: 0,
+        },
+        crtc: { curReg: 0 },
+        teletext: {
+            prevCol: 0,
+            col: 7,
+            bg: 0,
+            sep: false,
+            dbl: false,
+            oldDbl: false,
+            secondHalfOfDouble: false,
+            wasDbl: false,
+            gfx: false,
+            flash: false,
+            flashOn: false,
+            flashTime: 0,
+            heldChar: 0,
+            holdChar: false,
+            dataQueue: [0, 0, 0, 0],
+            scanlineCounter: 0,
+            levelDEW: false,
+            levelDISPTMG: false,
+            levelRA0: false,
+            nextGlyphs: "normal",
+            curGlyphs: "normal",
+            heldGlyphs: "normal",
+        },
+    };
+}
+
+/**
+ * Build a jsbeeb snapshot envelope from parsed emulator components.
+ * @param {string} importedFrom - source identifier (e.g. "b-em", "beebem-uef")
+ * @param {string} modelName - jsbeeb model name/synonym
+ * @param {object} cpuState - parsed CPU state {a, x, y, flags, s, pc, nmi, fe30, fe34}
+ * @param {Uint8Array} ram - 128KB RAM array
+ * @param {Uint8Array|null} roms - 256KB sideways ROM/RAM array, or null
+ * @param {object} sysvia - jsbeeb sys VIA state
+ * @param {object} uservia - jsbeeb user VIA state
+ * @param {object} video - jsbeeb video state (from buildVideoState)
+ * @param {object} soundChip - jsbeeb sound chip state
+ */
+export function buildSnapshot(importedFrom, modelName, cpuState, ram, roms, sysvia, uservia, video, soundChip) {
+    return {
+        format: "jsbeeb-snapshot",
+        version: 2,
+        model: modelName,
+        timestamp: new Date().toISOString(),
+        importedFrom,
+        state: {
+            a: cpuState.a,
+            x: cpuState.x,
+            y: cpuState.y,
+            s: cpuState.s,
+            pc: cpuState.pc,
+            p: cpuState.flags | 0x30,
+            nmiLevel: !!cpuState.nmi,
+            nmiEdge: false,
+            halted: false,
+            takeInt: false,
+            romsel: cpuState.fe30 ?? 0,
+            acccon: cpuState.fe34 ?? 0,
+            videoDisplayPage: 0,
+            currentCycles: 0,
+            targetCycles: 0,
+            cycleSeconds: 0,
+            peripheralCycles: 0,
+            videoCycles: 0,
+            music5000PageSel: 0,
+            ram,
+            ...(roms instanceof Uint8Array ? { roms } : {}),
+            scheduler: { epoch: 0 },
+            sysvia,
+            uservia,
+            video,
+            soundChip,
+            acia: { ...DefaultAcia },
+            adc: { ...DefaultAdc },
+        },
+    };
+}

package/src/snapshot.js

@@ -7,24 +7,15 @@ const SnapshotFormat = "jsbeeb-snapshot";
 const SnapshotVersion = 2;
 
 /**
- * Check if two model names are compatible for state restore.
- * Resolves synonyms via findModel, then compares by stripping any
- * trailing parenthesised suffix (e.g. treating "BBC Master 128 (DFS)"
- * and "BBC Master 128 (ADFS)" as compatible). Does not treat
- * differently-named models like "BBC B with DFS 0.9" vs "BBC B with DFS 1.2"
- * as compatible — those are distinct models.
+ * Check if two model names resolve to the same model (accounting for
+ * synonyms and old names). Used to decide whether a page reload is
+ * needed when loading a snapshot saved under a different model name.
  */
-export function modelsCompatible(snapshotModel, currentModel) {
-    if (snapshotModel === currentModel) return true;
-    const resolvedSnapshot = findModel(snapshotModel);
-    const resolvedCurrent = findModel(currentModel);
-    if (resolvedSnapshot && resolvedCurrent) {
-        // Same model object, or same base machine (strip filesystem suffix)
-        if (resolvedSnapshot === resolvedCurrent) return true;
-        const base = (name) => name.replace(/\s*\(.*\)$/, "");
-        return base(resolvedSnapshot.name) === base(resolvedCurrent.name);
-    }
-    return false;
+export function isSameModel(nameA, nameB) {
+    if (nameA === nameB) return true;
+    const a = findModel(nameA);
+    const b = findModel(nameB);
+    return a !== null && a === b;
 }
 
 // Map of TypedArray constructor names for deserialization
@@ -100,7 +91,7 @@ export function restoreSnapshot(cpu, model, snapshot) {
     if (snapshot.version > SnapshotVersion) {
         throw new Error(`Snapshot version ${snapshot.version} is newer than supported version ${SnapshotVersion}`);
     }
-    if (!modelsCompatible(snapshot.model, model.name)) {
+    if (!isSameModel(snapshot.model, model.name)) {
         throw new Error(`Model mismatch: snapshot is for "${snapshot.model}" but current model is "${model.name}"`);
     }
     cpu.restoreState(snapshot.state);

package/src/soundchip.js

@@ -1,3 +1,7 @@
+// Atom speaker volume, scaled to be comparable with BBC tone channels.
+// The BBC volumeTable[0] (loudest) is 0.25 (1.0 / 4 channels).
+const speakerVolume = 0.5;
+
 const volumeTable = new Float32Array(16);
 (() => {
     let f = 1.0;
@@ -327,6 +331,94 @@ export class SoundChip {
     }
 }
 
+/**
+ * AtomSoundChip -- Acorn Atom sound via a 1-bit speaker driven by the PPIA.
+ * Uses only the sine channel (shared with BBC for tape tones) and a speaker
+ * channel with DC-blocking filter.
+ */
+export class AtomSoundChip extends SoundChip {
+    constructor(onBuffer, { cpuSpeed = 1000000 } = {}) {
+        super(onBuffer);
+        this.samplesPerCycle = this.soundchipFreq / cpuSpeed;
+        this.secondsPerCycle = 1 / cpuSpeed;
+
+        // Replace the BBC tone/noise generators with just sine + speaker.
+        this.generators = [this.sineChannel.bind(this), this.speakerChannel.bind(this)];
+        // Recompute sine attenuation for the Atom's 2-channel mix
+        // (parent computed it for 5 BBC channels).
+        this.sineTable = makeSineTable(1 / this.generators.length);
+
+        this.speakerGenerator = {
+            mute: () => {
+                this.catchUp();
+                this.speakerReset();
+            },
+            pushBit: (bit, cycles, seconds) => {
+                this.catchUp();
+                this.updateSpeaker(bit, cycles, seconds);
+            },
+        };
+
+        this.bitChange = [];
+        this.currentSpeakerBit = 0.0;
+        this._speakerPrevIn = 0;
+        this._speakerPrevOut = 0;
+        this._speakerCycleOffset = 0;
+    }
+
+    reset(hard) {
+        super.reset(hard);
+        if (hard) this.speakerReset();
+    }
+
+    catchUp() {
+        this._speakerCycleOffset = 0;
+        super.catchUp();
+        this._speakerCycleOffset = 0;
+    }
+
+    speakerReset() {
+        this.bitChange = [];
+        this.currentSpeakerBit = 0.0;
+        this._speakerPrevIn = 0;
+        this._speakerPrevOut = 0;
+        this._speakerCycleOffset = 0;
+    }
+
+    speakerChannel(channel, out, offset, length) {
+        const fromCycle = this.lastRunEpoch + this._speakerCycleOffset;
+        this._speakerCycleOffset += length / this.samplesPerCycle;
+        let bitIndex = 0;
+        // DC-blocking high-pass filter: y[n] = x[n] - x[n-1] + alpha * y[n-1]
+        // The SoundChip runs at 500 kHz (4 MHz / 8). For a ~20 Hz cutoff:
+        // alpha = 1 - 2*pi*fc/fs = 1 - 2*pi*20/500000 ≈ 0.99975
+        const alpha = 0.99975;
+
+        for (let i = 0; i < length; ++i) {
+            while (
+                bitIndex < this.bitChange.length &&
+                this.bitChange[bitIndex].cycles <= fromCycle + i / this.samplesPerCycle
+            ) {
+                this.currentSpeakerBit = this.bitChange[bitIndex].bit;
+                bitIndex++;
+            }
+            const input = this.currentSpeakerBit * speakerVolume;
+            this._speakerPrevOut = input - this._speakerPrevIn + alpha * this._speakerPrevOut;
+            this._speakerPrevIn = input;
+            out[i + offset] += this._speakerPrevOut;
+        }
+
+        if (bitIndex > 0) {
+            this.bitChange.splice(0, bitIndex);
+        }
+    }
+
+    updateSpeaker(value, microCycle, seconds) {
+        const cycles = microCycle + seconds / this.secondsPerCycle;
+        this.bitChange.push({ bit: value ? 1.0 : 0.0, cycles });
+    }
+}
+
 /**
  * InstrumentedSoundChip - wraps a real SoundChip and captures all writes
  * for debugging purposes. Provides the same interface as SoundChip.
@@ -423,11 +515,17 @@ export class FakeSoundChip {
             mute: () => {},
             tone: () => {},
         };
+        this.speakerGenerator = {
+            mute: () => {},
+            pushBit: () => {},
+        };
     }
 
     snapshotState() {
         return {};
     }
 
-    restoreState() {}
+    restoreState() {
+        this._speakerCycleOffset = 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));
-}