jsbeeb 1.1.1

package/src/scheduler.js

@@ -0,0 +1,148 @@
+const MaxHeadroom = 0xffffffff;
+
+export class Scheduler {
+    static get MaxHeadroom() {
+        return MaxHeadroom;
+    }
+
+    constructor() {
+        /** @type {ScheduledTask|null} */
+        this.scheduled = null;
+        this.epoch = 0;
+    }
+
+    /**
+     * Schedule a task to run after a delay.
+     * @param {ScheduledTask} task
+     * @param {number} delay
+     */
+    schedule(task, delay) {
+        if (task.scheduler !== this) {
+            throw new Error("Wrong scheduler for task, or non-task");
+        }
+        if (task.scheduled()) {
+            throw new Error("Task is already scheduled");
+        }
+
+        const expireEpoch = delay + this.epoch;
+        task.expireEpoch = expireEpoch;
+        task._scheduled = true;
+
+        let before = this.scheduled;
+        let prev = null;
+        while (before && before.expireEpoch <= expireEpoch) {
+            prev = before;
+            before = before.next;
+        }
+        task.next = before;
+        task.prev = prev;
+        if (task.next) task.next.prev = task;
+        if (task.prev) {
+            task.prev.next = task;
+        } else {
+            this.scheduled = task;
+        }
+    }
+
+    /**
+     * Cancel a task.
+     * @param {ScheduledTask} task
+     */
+    cancel(task) {
+        if (!task.scheduled()) return;
+        if (!task.prev) {
+            // First element, we need to update the head element.
+            this.scheduled = task.next;
+        } else {
+            task.prev.next = task.next;
+        }
+        if (task.next) {
+            task.next.prev = task.prev;
+        }
+        task.next = task.prev = null;
+        task._scheduled = false;
+    }
+
+    /**
+     * Run all tasks that are due in the next ticks.
+     * @param {number} ticks number of cycles to run
+     */
+    polltime(ticks) {
+        const targetEpoch = this.epoch + ticks;
+        while (this.scheduled && this.scheduled.expireEpoch <= targetEpoch) {
+            const head = this.scheduled;
+            this.epoch = head.expireEpoch;
+            head.cancel(); // cancel first
+            head.onExpire(); // expiry may reschedule
+        }
+        this.epoch = targetEpoch;
+    }
+
+    /**
+     * The minimum number of cycles that can be run without needing to polltime.
+     * @returns {number} number of cycles
+     */
+    headroom() {
+        if (this.scheduled === null) return MaxHeadroom;
+        return this.scheduled.expireEpoch - this.epoch;
+    }
+
+    /**
+     * Create a new task.
+     * @param {function(): void} onExpire function to call when the task expires
+     * @returns {ScheduledTask} a handle to the new task
+     */
+    newTask(onExpire) {
+        return new ScheduledTask(this, onExpire);
+    }
+}
+
+class ScheduledTask {
+    /**
+     * @param {Scheduler} scheduler
+     * @param {function(): void} onExpire
+     */
+    constructor(scheduler, onExpire) {
+        this.scheduler = scheduler;
+        this.prev = null;
+        this.next = null;
+        this.expireEpoch = 0;
+        this.onExpire = onExpire;
+        this._scheduled = false;
+    }
+
+    scheduled() {
+        return this._scheduled;
+    }
+
+    /**
+     * @param {number} delay
+     */
+    schedule(delay) {
+        this.scheduler.schedule(this, delay);
+    }
+
+    /**
+     * @param {number} delay
+     */
+    reschedule(delay) {
+        this.scheduler.cancel(this);
+        this.scheduler.schedule(this, delay);
+    }
+
+    cancel() {
+        this.scheduler.cancel(this);
+    }
+
+    /**
+     * @param {boolean} state
+     * @param {number} delay
+     */
+    ensureScheduled(state, delay) {
+        if (state) {
+            if (!this.scheduled()) this.schedule(delay);
+        } else {
+            this.cancel();
+        }
+    }
+}

package/src/serial.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const table = [19200, 9600, 4800, 2400, 1200, 300, 150, 75];
+
+export class Serial {
+    constructor(acia) {
+        this.acia = acia;
+        this.reset();
+    }
+
+    reset() {
+        this.reg = 0;
+        this.transmitRate = 0;
+        this.receiveRate = 0;
+    }
+
+    write(addr, val) {
+        val &= 0xff;
+        this.reg = val;
+        this.transmitRate = val & 0x07;
+        this.receiveRate = (val >>> 3) & 0x07;
+        this.acia.setSerialReceive(table[this.receiveRate]);
+        this.acia.setMotor(!!(val & 0x80));
+        this.acia.selectRs423(!!(val & 0x40));
+    }
+
+    read() {
+        this.write(0, 0xfe);
+        return 0;
+    }
+}

package/src/soundchip.js

@@ -0,0 +1,314 @@
+const volumeTable = new Float32Array(16);
+(() => {
+    let f = 1.0;
+    for (let i = 0; i < 15; ++i) {
+        volumeTable[i] = f / 4; // Bakes in the per channel volume
+        f *= Math.pow(10, -0.1);
+    }
+    volumeTable[15] = 0;
+})();
+
+function makeSineTable(attenuation) {
+    const sineTable = new Float32Array(8192);
+    for (let i = 0; i < sineTable.length; ++i) {
+        sineTable[i] = Math.sin((2 * Math.PI * i) / sineTable.length) * attenuation;
+    }
+    return sineTable;
+}
+
+export class SoundChip {
+    constructor(onBuffer) {
+        this._onBuffer = onBuffer;
+        // 4MHz input signal. Internal divide-by-8
+        this.soundchipFreq = 4000000.0 / 8;
+        const sampleRate = this.soundchipFreq;
+        // Square wave changes every time a counter hits zero: A full wave needs to be 2x counter zeros.
+        this.waveDecrementPerSecond = this.soundchipFreq / 2;
+        // Each sample in the buffer represents (1/sampleRate) time, so each time
+        // we generate a sample, we need to decrement the counters by this amount:
+        this.sampleDecrement = this.waveDecrementPerSecond / sampleRate;
+        // How many samples are generated per CPU cycle.
+        this.samplesPerCycle = sampleRate / 2000000;
+        this.minCyclesWELow = 14; // Somewhat empirically derived; Repton 2 has only 14 cycles between WE low and WE high (@0x2caa)
+
+        this.registers = new Uint16Array(4);
+        this.counter = new Float32Array(4);
+        this.outputBit = [false, false, false, false];
+        this.volume = new Float32Array(4);
+        this.generators = [
+            this.toneChannel.bind(this),
+            this.toneChannel.bind(this),
+            this.toneChannel.bind(this),
+            this.noiseChannel.bind(this),
+            this.sineChannel.bind(this),
+        ];
+
+        this.sineTable = makeSineTable(1 / this.generators.length);
+        this.sineStep = 0;
+        this.sineOn = false;
+        this.sineTime = 0;
+
+        this.lfsr = 0;
+        this.shiftLfsr = this.shiftLfsrWhiteNoise.bind(this);
+
+        this.enabled = true;
+        this.scheduler = { epoch: 0 };
+        this.lastRunEpoch = 0;
+        this.activeTask = null;
+
+        this.residual = 0;
+        this.position = 0;
+        this.buffer = new Float32Array(512);
+
+        this.latchedRegister = 0;
+        this.slowDataBus = 0;
+        this.active = false;
+
+        this.toneGenerator = {
+            mute: () => {
+                this.catchUp();
+                this.sineOn = false;
+            },
+            tone: (freq) => {
+                this.catchUp();
+                this.sineOn = true;
+                this.sineStep = (freq / sampleRate) * this.sineTable.length;
+            },
+        };
+    }
+
+    sineChannel(channel, out, offset, length) {
+        if (!this.sineOn) return;
+
+        for (let i = 0; i < length; ++i) {
+            out[i + offset] += this.sineTable[this.sineTime & (this.sineTable.length - 1)];
+            this.sineTime += this.sineStep;
+        }
+        while (this.sineTime > this.sineTable.length) this.sineTime -= this.sineTable.length;
+    }
+
+    _doChannelStep(channel, addAmount) {
+        const newValue = this.counter[channel] - this.sampleDecrement;
+        if (newValue < 0) {
+            this.counter[channel] = Math.max(0, newValue + addAmount);
+            this.outputBit[channel] = !this.outputBit[channel];
+            return this.outputBit[channel];
+        } else {
+            this.counter[channel] = newValue;
+            return false;
+        }
+    }
+
+    toneChannel(channel, out, offset, length) {
+        const reg = this.registers[channel] === 0 ? 1024 : this.registers[channel];
+        const vol = this.volume[channel];
+        for (let i = 0; i < length; ++i) {
+            this._doChannelStep(channel, reg);
+            out[i + offset] += this.outputBit[channel] * vol;
+        }
+    }
+
+    shiftLfsrWhiteNoise() {
+        const bit = (this.lfsr & 1) ^ ((this.lfsr & (1 << 1)) >>> 1);
+        this.lfsr = (this.lfsr >>> 1) | (bit << 14);
+    }
+
+    shiftLfsrPeriodicNoise() {
+        this.lfsr >>= 1;
+        if (this.lfsr === 0) this.lfsr = 1 << 14;
+    }
+
+    noisePoked() {
+        this.shiftLfsr =
+            this.registers[3] & 4 ? this.shiftLfsrWhiteNoise.bind(this) : this.shiftLfsrPeriodicNoise.bind(this);
+        this.lfsr = 1 << 14;
+    }
+
+    addFor(channel) {
+        channel = channel | 0;
+        switch (this.registers[channel] & 3) {
+            case 0:
+                return 0x10;
+            case 1:
+                return 0x20;
+            case 2:
+                return 0x40;
+            case 3:
+                return this.registers[channel - 1];
+        }
+    }
+
+    noiseChannel(channel, out, offset, length) {
+        const add = this.addFor(channel),
+            vol = this.volume[channel];
+        for (let i = 0; i < length; ++i) {
+            if (this._doChannelStep(channel, add)) this.shiftLfsr();
+            out[i + offset] += (this.lfsr & 1) * vol;
+        }
+    }
+
+    debugPokeAll(c0, v0, c1, v1, c2, v2, c3, v3) {
+        this.catchUp();
+        this.registers[0] = c0 & 0xffffff;
+        this.registers[1] = c1 & 0xffffff;
+        this.registers[2] = c2 & 0xffffff;
+        this.registers[3] = c3 & 0xffffff;
+        this.volume[0] = volumeTable[v0];
+        this.volume[1] = volumeTable[v1];
+        this.volume[2] = volumeTable[v2];
+        this.volume[3] = volumeTable[v3];
+        this.noisePoked();
+    }
+
+    generate(out, offset, length) {
+        offset = offset | 0;
+        length = length | 0;
+        for (let i = 0; i < length; ++i) {
+            out[i + offset] = 0.0;
+        }
+        if (!this.enabled) return;
+        for (let i = 0; i < this.generators.length; ++i) {
+            this.generators[i](i, out, offset, length);
+        }
+    }
+
+    catchUp() {
+        const cyclesPending = this.scheduler.epoch - this.lastRunEpoch;
+        if (cyclesPending > 0) this.advance(cyclesPending);
+        this.lastRunEpoch = this.scheduler.epoch;
+    }
+
+    setScheduler(scheduler_) {
+        this.scheduler = scheduler_;
+        this.lastRunEpoch = this.scheduler.epoch;
+        this.activeTask = this.scheduler.newTask(() => {
+            if (this.active) this.poke(this.slowDataBus);
+        });
+    }
+
+    render(out, offset, length) {
+        this.catchUp();
+        const fromBuffer = this.position > length ? length : this.position;
+        for (let i = 0; i < fromBuffer; ++i) {
+            out[offset + i] = this.buffer[i];
+        }
+        offset += fromBuffer;
+        length -= fromBuffer;
+        for (let i = fromBuffer; i < this.position; ++i) {
+            this.buffer[i - fromBuffer] = this.buffer[i];
+        }
+        this.position -= fromBuffer;
+        if (length !== 0) {
+            this.generate(out, offset, length);
+        }
+    }
+
+    advance(cycles) {
+        const num = cycles * this.samplesPerCycle + this.residual;
+        let rounded = num | 0;
+        this.residual = num - rounded;
+        const bufferLength = this.buffer.length;
+        while (rounded > 0) {
+            const leftInBuffer = bufferLength - this.position;
+            const numSamplesToGenerate = Math.min(rounded, leftInBuffer);
+            this.generate(this.buffer, this.position, numSamplesToGenerate);
+            this.position += numSamplesToGenerate;
+            rounded -= numSamplesToGenerate;
+
+            if (this.position === bufferLength) {
+                this._onBuffer(this.buffer);
+                this.buffer = new Float32Array(bufferLength);
+                this.position = 0;
+            }
+        }
+    }
+
+    poke(value) {
+        this.catchUp();
+
+        let command;
+        if (value & 0x80) {
+            this.latchedRegister = value & 0x70;
+            command = value & 0xf0;
+        } else {
+            command = this.latchedRegister;
+        }
+        const channel = (command >> 5) & 0x03;
+
+        if (command & 0x10) {
+            // Volume setting
+            const newVolume = value & 0x0f;
+            this.volume[channel] = volumeTable[newVolume];
+        } else if (channel === 3) {
+            // For noise channel we always update the bottom bits.
+            this.registers[channel] = value & 0x0f;
+            this.noisePoked();
+        } else if (command & 0x80) {
+            // Low period bits.
+            this.registers[channel] = (this.registers[channel] & ~0x0f) | (value & 0x0f);
+        } else {
+            // High period bits.
+            this.registers[channel] = (this.registers[channel] & 0x0f) | ((value & 0x3f) << 4);
+        }
+    }
+
+    updateSlowDataBus(slowDataBus, active) {
+        this.slowDataBus = slowDataBus;
+        this.active = active;
+        // TODO: this probably isn't modeled correctly. Currently the sound chip "notices" a new data bus value some
+        // fixed number of cycles after WE (write enable) is triggered. In reality, the sound chip likely pulls data off
+        // the bus at a fixed point in its cycle, iff WE is active.
+        if (active) {
+            this.activeTask.ensureScheduled(true, this.minCyclesWELow);
+        }
+    }
+
+    reset(hard) {
+        if (!hard) return;
+        for (let i = 0; i < 4; ++i) {
+            this.counter[i] = 0;
+            this.registers[i] = 0;
+            // Real hardware would be volumeTable[0] but that's really quite loud and surprising...
+            this.volume[i] = volumeTable[8];
+        }
+        this.noisePoked();
+        this.lastRunEpoch = this.scheduler.epoch;
+    }
+
+    enable(e) {
+        this.enabled = e;
+    }
+
+    mute() {
+        this.enabled = false;
+    }
+
+    unmute() {
+        this.enabled = true;
+    }
+}
+
+export class FakeSoundChip {
+    reset() {}
+
+    enable() {}
+
+    catchUp() {}
+
+    mute() {}
+
+    unmute() {}
+
+    render() {}
+
+    updateSlowDataBus() {}
+
+    setScheduler() {}
+
+    constructor() {
+        this.toneGenerator = {
+            mute: () => {},
+            tone: () => {},
+        };
+    }
+}

package/src/sth.js

@@ -0,0 +1,59 @@
+"use strict";
+
+import * as utils from "./utils.js";
+
+const catalogUrl = "reclist.php?sort=name&filter=.zip";
+const sthArchive = "www.stairwaytohell.com/bbc/archive";
+
+async function _fetchAndParseCatalog(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error("Network response was not ok");
+    }
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(await response.text(), "text/html");
+    const result = [];
+    doc.querySelectorAll("tr td:nth-child(3) a").forEach((link) => {
+        const href = link.getAttribute("href");
+        if (href.indexOf(".zip") > 0) result.push(href);
+    });
+    result.sort();
+    return result;
+}
+
+export class StairwayToHell {
+    constructor(onStart, onCat, onError, tape) {
+        this._baseUrl = `${document.location.protocol}//${sthArchive}/${tape ? "tape" : "disk"}images/`;
+        this._catalog = [];
+        this._onStart = onStart;
+        this._onCat = onCat;
+        this._onError = onError;
+    }
+
+    async populate() {
+        this._onStart();
+        if (this._catalog.length === 0) {
+            try {
+                this._catalog = await _fetchAndParseCatalog(this._baseUrl + catalogUrl);
+            } catch (error) {
+                console.error("Failed to fetch catalog:", error);
+                if (this._onError) this._onError();
+                return;
+            }
+        }
+        if (this._onCat) this._onCat(this._catalog);
+    }
+
+    async fetch(file) {
+        const name = this._baseUrl + file;
+        console.log("Loading ZIP from " + name);
+        const response = await fetch(name);
+        if (!response.ok) throw new Error("Network response was not ok");
+        try {
+            return utils.unzipDiscImage(new Uint8Array(await response.arrayBuffer())).data;
+        } catch (error) {
+            console.error("Failed to fetch file:", error);
+            throw error;
+        }
+    }
+}