jsbeeb 1.1.1

package/src/microphone-input.js

@@ -0,0 +1,149 @@
+import { AnalogueSource } from "./analogue-source.js";
+
+/**
+ * Provides microphone input as an analogue source for the BBC Micro's ADC
+ * Used for software like MicroMike that uses the analogue port for sound input
+ */
+export class MicrophoneInput extends AnalogueSource {
+    /**
+     * Create a new MicrophoneInput
+     */
+    constructor() {
+        super();
+        this.audioContext = null;
+        this.microphoneStream = null;
+        this.microphoneSource = null;
+        this.microphoneAnalyser = null;
+        this.microphoneDataArray = null;
+        this.errorCallback = null;
+        this.errorMessage = null;
+    }
+
+    /**
+     * Set error callback function
+     * @param {Function} callback - Function to call with error messages
+     */
+    setErrorCallback(callback) {
+        this.errorCallback = callback;
+    }
+
+    /**
+     * Initialise microphone access
+     * @returns {Promise<boolean>} True if initialiation was successful
+     */
+    async initialise() {
+        console.log("MicrophoneInput: Initialising microphone input");
+
+        // Create audio context if needed
+        if (!this.audioContext) {
+            try {
+                console.log("MicrophoneInput: Creating audio context");
+                this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
+                console.log("MicrophoneInput: Audio context created:", this.audioContext.state);
+            } catch (error) {
+                console.error("MicrophoneInput: Error creating audio context:", error);
+                this.errorMessage = `Could not create audio context: ${error.message}`;
+                if (this.errorCallback) this.errorCallback(this.errorMessage);
+                return false;
+            }
+        }
+
+        try {
+            console.log("MicrophoneInput: Requesting microphone access");
+            // Request microphone access
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            console.log("MicrophoneInput: Microphone access granted");
+
+            // Store the stream so we can stop it if needed
+            this.microphoneStream = stream;
+
+            // Create analyser node
+            console.log("MicrophoneInput: Creating audio analyser");
+            this.microphoneAnalyser = this.audioContext.createAnalyser();
+            this.microphoneAnalyser.fftSize = 1024; // Larger FFT size for better resolution
+            this.microphoneAnalyser.smoothingTimeConstant = 0.2; // Less smoothing for more responsive input
+
+            // Create buffer for analyser data
+            this.microphoneDataArray = new Uint8Array(this.microphoneAnalyser.frequencyBinCount);
+            console.log("MicrophoneInput: Created data buffer with", this.microphoneDataArray.length, "samples");
+
+            // Create media stream source from microphone
+            console.log("MicrophoneInput: Creating media stream source");
+            this.microphoneSource = this.audioContext.createMediaStreamSource(stream);
+
+            // Connect microphone to analyser
+            console.log("MicrophoneInput: Connecting microphone to analyser");
+            this.microphoneSource.connect(this.microphoneAnalyser);
+
+            this.errorMessage = null;
+            console.log("MicrophoneInput: Initialisation complete");
+            return true;
+        } catch (error) {
+            console.error("MicrophoneInput: Error accessing microphone:", error);
+            this.errorMessage = `Error accessing microphone: ${error.message}`;
+            if (this.errorCallback) this.errorCallback(this.errorMessage);
+            return false;
+        }
+    }
+
+    /**
+     * Get the last error message if any
+     * @returns {string|null} The last error message or null
+     */
+    getErrorMessage() {
+        return this.errorMessage;
+    }
+
+    /**
+     * Get analog value from microphone for the specified channel
+     * @param {number} _channel - The ADC channel (0-3)
+     * @returns {number} A value between 0 and 0xffff
+     */
+    getValue(_channel) {
+        if (!this.microphoneAnalyser || !this.microphoneDataArray) {
+            throw new Error("MicrophoneInput: getValue called but analyser not initialised");
+        }
+
+        // Get time domain data (waveform)
+        this.microphoneAnalyser.getByteTimeDomainData(this.microphoneDataArray);
+
+        // Calculate volume as average deviation from the center (128)
+        let sum = 0;
+        for (let i = 0; i < this.microphoneDataArray.length; i++) {
+            sum += Math.abs(this.microphoneDataArray[i] - 128);
+        }
+
+        const average = sum / this.microphoneDataArray.length;
+
+        // Scale up the signal using a configurable scaling factor
+        // This can be adjusted based on testing
+        const scaleFactor = 800; // Amplify the signal
+        const scaledValue = average * scaleFactor;
+
+        // Map to 16-bit range (0-0xFFFF)
+        return Math.min(0xffff, scaledValue) | 0;
+    }
+
+    /**
+     * Clean up resources when no longer needed
+     */
+    dispose() {
+        if (this.microphoneStream) {
+            this.microphoneStream.getTracks().forEach((track) => track.stop());
+            this.microphoneStream = null;
+        }
+
+        if (this.microphoneSource) {
+            this.microphoneSource.disconnect();
+            this.microphoneSource = null;
+        }
+
+        this.microphoneAnalyser = null;
+        this.microphoneDataArray = null;
+
+        if (this.audioContext && this.audioContext.state !== "closed") {
+            this.audioContext.close().catch((err) => console.error("Error closing audio context:", err));
+        }
+        this.audioContext = null;
+    }
+}

package/src/models.js

@@ -0,0 +1,200 @@
+"use strict";
+
+import { NoiseAwareWdFdc } from "./wd-fdc.js";
+import { NoiseAwareIntelFdc } from "./intel-fdc.js";
+import * as opcodes from "./6502.opcodes.js";
+
+const CpuModel = Object.freeze({
+    MOS6502: 0,
+    CMOS65C02: 1,
+    CMOS65C12: 2,
+});
+
+class Model {
+    constructor(name, synonyms, os, cpuModel, isMaster, swram, fdc, tube, cmosOverride) {
+        this.name = name;
+        this.synonyms = synonyms;
+        this.os = os;
+        this._cpuModel = cpuModel;
+        this.isMaster = isMaster;
+        this.Fdc = fdc;
+        this.swram = swram;
+        this.isTest = false;
+        this.tube = tube;
+        this.cmosOverride = cmosOverride;
+        this.hasEconet = false;
+        this.hasMusic5000 = false;
+    }
+
+    get nmos() {
+        return this._cpuModel === CpuModel.MOS6502;
+    }
+
+    get opcodesFactory() {
+        switch (this._cpuModel) {
+            case CpuModel.MOS6502:
+                return opcodes.Cpu6502;
+            case CpuModel.CMOS65C02:
+                return opcodes.Cpu65c02;
+            case CpuModel.CMOS65C12:
+                return opcodes.Cpu65c12;
+        }
+        throw new Error("Unknown CPU model");
+    }
+}
+
+function pickAdfs(cmos) {
+    cmos[19] = (cmos[19] & 0xf0) | 13;
+    return cmos;
+}
+
+function pickAnfs(cmos) {
+    cmos[19] = (cmos[19] & 0xf0) | 8;
+    return cmos;
+}
+
+function pickDfs(cmos) {
+    cmos[19] = (cmos[19] & 0xf0) | 9;
+    return cmos;
+}
+
+// TODO: semi-bplus-style to get swram for exile hardcoded here
+const beebSwram = [
+    true,
+    true,
+    true,
+    true, // Dunjunz variants. Exile (not picky).
+    true,
+    true,
+    true,
+    true, // Crazee Rider.
+    false,
+    false,
+    false,
+    false,
+    false,
+    false,
+    false,
+    false,
+];
+const masterSwram = [
+    false,
+    false,
+    false,
+    false,
+    true,
+    true,
+    true,
+    true,
+    false,
+    false,
+    false,
+    false,
+    false,
+    false,
+    false,
+    false,
+];
+
+export const allModels = [
+    new Model(
+        "BBC B with DFS 1.2",
+        ["B-DFS1.2"],
+        ["os.rom", "BASIC.ROM", "b/DFS-1.2.rom"],
+        CpuModel.MOS6502,
+        false,
+        beebSwram,
+        NoiseAwareIntelFdc,
+    ),
+    new Model(
+        "BBC B with DFS 0.9",
+        ["B-DFS0.9", "B"],
+        ["os.rom", "BASIC.ROM", "b/DFS-0.9.rom"],
+        CpuModel.MOS6502,
+        false,
+        beebSwram,
+        NoiseAwareIntelFdc,
+    ),
+    new Model(
+        "BBC B with 1770 (DFS)",
+        ["B1770"],
+        ["os.rom", "BASIC.ROM", "b1770/dfs1770.rom", "b1770/zADFS.ROM"],
+        CpuModel.MOS6502,
+        false,
+        beebSwram,
+        NoiseAwareWdFdc,
+    ),
+    // putting ADFS in a higher ROM slot gives it priority
+    new Model(
+        "BBC B with 1770 (ADFS)",
+        ["B1770A"],
+        ["os.rom", "BASIC.ROM", "b1770/zADFS.ROM", "b1770/dfs1770.rom"],
+        CpuModel.MOS6502,
+        false,
+        beebSwram,
+        NoiseAwareWdFdc,
+    ),
+    new Model(
+        "BBC Master 128 (DFS)",
+        ["Master"],
+        ["master/mos3.20"],
+        CpuModel.CMOS65C12,
+        true,
+        masterSwram,
+        NoiseAwareWdFdc,
+        null,
+        pickDfs,
+    ),
+    new Model(
+        "BBC Master 128 (ADFS)",
+        ["MasterADFS"],
+        ["master/mos3.20"],
+        CpuModel.CMOS65C12,
+        true,
+        masterSwram,
+        NoiseAwareWdFdc,
+        null,
+        pickAdfs,
+    ),
+    new Model(
+        "BBC Master 128 (ANFS)",
+        ["MasterANFS"],
+        ["master/mos3.20"],
+        CpuModel.CMOS65C12,
+        true,
+        masterSwram,
+        NoiseAwareWdFdc,
+        null,
+        pickAnfs,
+    ),
+    new Model("Tube65C02", [], ["tube/6502Tube.rom"], CpuModel.CMOS65C02, false), // Although this can not be explicitly selected as a model, it is required by the configuration builder later
+];
+
+export function findModel(name) {
+    name = name.toLowerCase();
+    for (let i = 0; i < allModels.length; ++i) {
+        const model = allModels[i];
+        if (model.name.toLowerCase() === name) return model;
+        for (let j = 0; j < model.synonyms.length; ++j) {
+            if (model.synonyms[j].toLowerCase() === name) return model;
+        }
+    }
+    return null;
+}
+
+export const TEST_6502 = new Model("TEST", ["TEST"], [], CpuModel.MOS6502, false, beebSwram, NoiseAwareIntelFdc);
+TEST_6502.isTest = true;
+export const TEST_65C02 = new Model("TEST", ["TEST"], [], CpuModel.CMOS65C02, false, masterSwram, NoiseAwareIntelFdc);
+TEST_65C02.isTest = true;
+export const TEST_65C12 = new Model("TEST", ["TEST"], [], CpuModel.CMOS65C12, false, masterSwram, NoiseAwareIntelFdc);
+TEST_65C12.isTest = true;
+
+export const basicOnly = new Model(
+    "Basic only",
+    ["Basic only"],
+    ["master/mos3.20"],
+    CpuModel.CMOS65C12,
+    true,
+    masterSwram,
+    NoiseAwareWdFdc,
+);

package/src/mouse-joystick-source.js

@@ -0,0 +1,107 @@
+import { AnalogueSource } from "./analogue-source.js";
+
+/**
+ * Mouse-based joystick implementation of AnalogueSource
+ * Maps mouse position relative to BBC display center to ADC channels
+ */
+export class MouseJoystickSource extends AnalogueSource {
+    /**
+     * Create a new MouseJoystickSource
+     * @param {HTMLCanvasElement} canvas - The BBC display canvas element
+     */
+    constructor(canvas) {
+        super();
+        this.canvas = canvas;
+        this.mouseX = 0.5; // Normalized position (0-1)
+        this.mouseY = 0.5; // Normalized position (0-1)
+        this.isActive = false;
+        this.via = null; // Will be set later
+    }
+
+    /**
+     * Set the VIA reference for button handling
+     * @param {object} via - The system VIA
+     */
+    setVia(via) {
+        this.via = via;
+    }
+
+    /**
+     * Handle mouse movement event from external handler
+     * @param {number} x - Normalized X position (0-1)
+     * @param {number} y - Normalized Y position (0-1)
+     */
+    onMouseMove(x, y) {
+        this.mouseX = Math.max(0, Math.min(1, x));
+        this.mouseY = Math.max(0, Math.min(1, y));
+        this.isActive = true;
+    }
+
+    /**
+     * Handle mouse button press from external handler
+     * @param {number} button - Mouse button number (0 = left, 1 = middle, 2 = right)
+     */
+    onMouseDown(button) {
+        if (!this.via) return;
+
+        // Only handle left mouse button (button 0)
+        if (button === 0) {
+            this.via.setJoystickButton(0, true);
+        }
+    }
+
+    /**
+     * Handle mouse button release from external handler
+     * @param {number} button - Mouse button number (0 = left, 1 = middle, 2 = right)
+     */
+    onMouseUp(button) {
+        if (!this.via) return;
+
+        // Only handle left mouse button (button 0)
+        if (button === 0) {
+            this.via.setJoystickButton(0, false);
+        }
+    }
+
+    /**
+     * Check if mouse joystick is enabled and ready
+     * @returns {boolean} True if mouse joystick can handle events
+     */
+    isEnabled() {
+        return !!this.via;
+    }
+
+    /**
+     * Get analog value from mouse position for the specified channel
+     * @param {number} channel - The ADC channel (0-3)
+     * @returns {number} A value between 0 and 0xffff
+     */
+    getValue(channel) {
+        switch (channel) {
+            case 0:
+                // X axis for joystick 1
+                // BBC Micro: left=65535, right=0
+                return Math.floor((1 - this.mouseX) * 0xffff);
+            case 1:
+                // Y axis for joystick 1
+                // BBC Micro: up=65535, down=0
+                return Math.floor((1 - this.mouseY) * 0xffff);
+            case 2:
+            case 3:
+                // Joystick 2 axes (not used for mouse)
+                return 0x8000;
+            default:
+                return 0x8000;
+        }
+    }
+
+    /**
+     * Clean up when source is no longer needed
+     * Called by ADC when switching to a different source
+     */
+    dispose() {
+        // Reset state
+        this.via = null;
+        this.isActive = false;
+    }
+}

package/src/music5000-worklet.js

@@ -0,0 +1,43 @@
+const BUFFER_SIZE = 65536;
+
+registerProcessor(
+    "music5000",
+    class extends AudioWorkletProcessor {
+        constructor() {
+            super();
+            this.port.onmessage = this.onmessage.bind(this);
+
+            this.sampleBuffer = new Float32Array(BUFFER_SIZE);
+            this.readPosition = 0;
+            this.writePosition = 0;
+        }
+
+        onmessage(event) {
+            // Receive a new 128-byte sample from the audio processor and write to the FIFO buffer
+            const { data } = event;
+            const sample = new Float32Array(data);
+
+            if (this.writePosition === BUFFER_SIZE) {
+                this.writePosition = 0;
+            }
+
+            for (let i = 0; i < data.length; i++) {
+                this.sampleBuffer[this.writePosition++] = sample[i] / 32768.0; // Conversion to a range -1 to +1
+            }
+        }
+
+        process(inputs, outputs) {
+            // Playback
+            if (this.readPosition === BUFFER_SIZE) {
+                this.readPosition = 0;
+            }
+
+            for (let i = 0; i < outputs[0][0].length; i++) {
+                outputs[0][0][i] = this.sampleBuffer[this.readPosition++];
+                outputs[0][1][i] = this.sampleBuffer[this.readPosition++];
+            }
+
+            return true;
+        }
+    },
+);

package/src/music5000.js

@@ -0,0 +1,207 @@
+"use strict";
+
+// Code ported from Beebem (C to .js) by Jason Robson
+const AUDIO_BUFFER_SIZE = 256;
+
+const RAM_SIZE = 2048;
+const WAVE_TABLE_SIZE = 128;
+const WAVE_TABLES = 14;
+const NUM_CHANNELS = 16;
+const CHANNEL_REG_OFFSET = WAVE_TABLES * WAVE_TABLE_SIZE;
+const CHANNEL_ROW_SIZE = 128;
+
+// Control register bits
+const CTRL_STEREO_POS = 0xf;
+const CTRL_INVERT_WAVE = 1 << 4;
+const CTRL_MODULATE_ADJ = 1 << 5;
+
+// Data bits
+const DATA_SIGN = 1 << 7;
+const DATA_VALUE = 0x7f;
+const FREQ_DISABLE = 1 << 0;
+const NOT_FREQ_DISABLE = 0xfe;
+
+// Channel register sets
+const REG_SET_NORMAL = 0;
+const REG_SET_ALT = 1;
+
+export class Music5000 {
+    constructor(onBuffer) {
+        this._onBufferMusic5000 = onBuffer;
+
+        this.waveRam = new Uint8Array(RAM_SIZE);
+        this.phaseRam = new Uint32Array(NUM_CHANNELS);
+        this.cycleCount = 0;
+        this.curCh = 0;
+        this.activeRegSet = REG_SET_NORMAL;
+        this.sampleLeft = 0;
+        this.sampleRight = 0;
+
+        this.chordBase = [0, 8.25, 24.75, 57.75, 123.75, 255.75, 519.75, 1047.75];
+        this.stepInc = [0.5, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0];
+
+        this.stereoLeft = [0, 0, 0, 0, 0, 0, 0, 0, 100, 100, 100, 83, 67, 50, 33, 17];
+        this.stereoRight = [100, 100, 100, 100, 100, 100, 100, 100, 0, 0, 0, 17, 33, 50, 67, 83];
+
+        this.D2ATable = new Uint16Array(128);
+
+        this.sampleBuffer = new Float64Array(AUDIO_BUFFER_SIZE);
+        this.position = 0;
+
+        // Helper functions to access the register set and wavetable
+        this.cReg_freqLow = function (channel, regSet) {
+            return this.waveRam[CHANNEL_REG_OFFSET + regSet * CHANNEL_ROW_SIZE + 0 * NUM_CHANNELS + channel];
+        };
+        this.cReg_freqMedium = function (channel, regSet) {
+            return this.waveRam[CHANNEL_REG_OFFSET + regSet * CHANNEL_ROW_SIZE + 1 * NUM_CHANNELS + channel];
+        };
+        this.cReg_freqHigh = function (channel, regSet) {
+            return this.waveRam[CHANNEL_REG_OFFSET + regSet * CHANNEL_ROW_SIZE + 2 * NUM_CHANNELS + channel];
+        };
+        this.cReg_waveformReg = function (channel, regSet) {
+            return this.waveRam[CHANNEL_REG_OFFSET + regSet * CHANNEL_ROW_SIZE + 5 * NUM_CHANNELS + channel];
+        };
+        this.cReg_amplitudeReg = function (channel, regSet) {
+            return this.waveRam[CHANNEL_REG_OFFSET + regSet * CHANNEL_ROW_SIZE + 6 * NUM_CHANNELS + channel];
+        };
+        this.cReg_controlReg = function (channel, regSet) {
+            return this.waveRam[CHANNEL_REG_OFFSET + regSet * CHANNEL_ROW_SIZE + 7 * NUM_CHANNELS + channel];
+        };
+
+        this.waveTableVal = function (table, b) {
+            return this.waveRam[table * WAVE_TABLE_SIZE + b];
+        };
+    }
+
+    reset(hard) {
+        if (hard) {
+            console.log("Music 5000: initialisation");
+
+            // Build the D2A table
+            let i = 0;
+            for (let chord = 0; chord < 8; chord++) {
+                let val = this.chordBase[chord];
+                for (let step = 0; step < 16; step++) {
+                    this.D2ATable[i] = Math.floor(val * 4); // Multiply up to get an integer
+                    val += this.stepInc[chord];
+                    i++;
+                }
+            }
+        }
+
+        // Clear RAM
+        for (let w = 0; w < RAM_SIZE; w++) {
+            this.waveRam[w] = 0;
+        }
+
+        for (let p = 0; p < NUM_CHANNELS; p++) {
+            this.phaseRam[p] = 0;
+        }
+    }
+
+    read(page, addr) {
+        // Bit0 unused
+        const offset = ((page & 0x0e) << 7) + addr;
+        return this.waveRam[offset];
+    }
+
+    write(page, addr, value) {
+        // Bit0 unused
+        const offset = ((page & 0x0e) << 7) + (addr & 0xff);
+        this.waveRam[offset] = value;
+    }
+
+    polltime(cycles) {
+        let c4d,
+            freq,
+            offset,
+            wavetable,
+            amplitude,
+            control,
+            data,
+            sign,
+            pos = 0 >>> 0;
+
+        // Convert 2MHz 6502 cycles to 6MHz Music5000 cycles
+        this.cycleCount += cycles * 3;
+
+        // Need 8 cycles to update a channel
+        while (this.cycleCount >= 8) {
+            // Update phase for active register set
+            if (this.cReg_freqLow(this.curCh, this.activeRegSet) & FREQ_DISABLE) {
+                this.phaseRam[this.curCh] = 0;
+                c4d = 0;
+            } else {
+                freq =
+                    (this.cReg_freqHigh(this.curCh, this.activeRegSet) << 16) +
+                    (this.cReg_freqMedium(this.curCh, this.activeRegSet) << 8) +
+                    (this.cReg_freqLow(this.curCh, this.activeRegSet) & NOT_FREQ_DISABLE);
+                this.phaseRam[this.curCh] += freq;
+                c4d = this.phaseRam[this.curCh] & (1 << 24);
+                this.phaseRam[this.curCh] &= 0xffffff;
+            }
+
+            // Pull wave sample out for the active register set
+            offset = (this.phaseRam[this.curCh] >> 17) & 0x7f;
+            wavetable = this.cReg_waveformReg(this.curCh, this.activeRegSet) >> 4;
+            data = this.waveTableVal(wavetable, offset);
+            amplitude = this.cReg_amplitudeReg(this.curCh, this.activeRegSet);
+            control = this.cReg_controlReg(this.curCh, this.activeRegSet);
+            sign = data & DATA_SIGN;
+            data &= DATA_VALUE;
+
+            // Modulate the next channel?
+            if (control & CTRL_MODULATE_ADJ && (sign || c4d)) this.activeRegSet = REG_SET_ALT;
+            else this.activeRegSet = REG_SET_NORMAL;
+
+            if (amplitude > 0x80) amplitude = 0x80;
+            data = (data * amplitude) / 0x80;
+
+            let sample = this.D2ATable[parseInt(data)];
+            if (control & CTRL_INVERT_WAVE) sign ^= DATA_SIGN;
+            if (sign) sample = -sample;
+
+            // Stereo
+            pos = control & CTRL_STEREO_POS;
+            this.sampleLeft += (sample * this.stereoLeft[pos]) / 100;
+            this.sampleRight += (sample * this.stereoRight[pos]) / 100;
+
+            this.curCh++;
+            if (this.curCh === NUM_CHANNELS) {
+                this.curCh = 0;
+                this.activeRegSet = REG_SET_NORMAL;
+
+                // Range check
+                if (this.sampleLeft < -32768) this.sampleLeft = -32768;
+                else if (this.sampleLeft > 32767) this.sampleLeft = 32767;
+
+                if (this.sampleRight < -32768) this.sampleRight = -32768;
+                else if (this.sampleRight > 32767) this.sampleRight = 32767;
+
+                this.sampleBuffer[this.position++] = this.sampleLeft;
+                this.sampleBuffer[this.position++] = this.sampleRight;
+
+                if (this.position === AUDIO_BUFFER_SIZE) {
+                    this._onBufferMusic5000(this.sampleBuffer);
+                    this.position = 0;
+                }
+
+                this.sampleLeft = 0;
+                this.sampleRight = 0;
+            }
+
+            this.cycleCount -= 8;
+        }
+    }
+}
+
+export class FakeMusic5000 {
+    constructor() {
+        this.reset = function () {};
+        this.polltime = function () {};
+        this.read = function () {
+            return 0;
+        };
+        this.write = function () {};
+    }
+}