libadlmidi-js 1.1.0 → 1.2.0

package/src/core.js

@@ -11,6 +11,7 @@
 import {
     SIZEOF_ADL_INSTRUMENT,
     SIZEOF_ADL_BANK_ID,
+    SIZEOF_ADL_BANK,
     decodeInstrument,
     encodeInstrument,
 } from './utils/struct.js';
@@ -131,6 +132,14 @@ export class AdlMidiCore {
         this._module._adl_rt_resetState(this._player);
     }
 
+    /**
+     * Full reset to apply instrument/bank changes.
+     */
+    resetFull() {
+        this._ensurePlayer();
+        this._module._adl_reset(this._player);
+    }
+
     /**
      * Panic - immediately stop all notes.
      */
@@ -212,6 +221,87 @@ export class AdlMidiCore {
         return this._module._adl_setNumChips(this._player, count) === 0;
     }
 
+    /**
+     * Set the number of 4-operator channels.
+     *
+     * @param {number} count - Number of channels (-1 for auto)
+     * @returns {boolean} True if successful
+     */
+    setNumFourOpChannels(count) {
+        this._ensurePlayer();
+        return this._module._adl_setNumFourOpsChn(this._player, count) === 0;
+    }
+
+    /**
+     * Get the number of 4-operator channels.
+     *
+     * @returns {number} Count of channels
+     */
+    getNumFourOpChannels() {
+        this._ensurePlayer();
+        return this._module._adl_getNumFourOpsChn(this._player);
+    }
+
+    /**
+     * Enable/disable scaling of modulators by volume.
+     *
+     * @param {boolean} enabled
+     */
+    setScaleModulators(enabled) {
+        this._ensurePlayer();
+        this._module._adl_setScaleModulators(this._player, enabled ? 1 : 0);
+    }
+
+    /**
+     * Enable/disable full-range brightness (0-127).
+     *
+     * @param {boolean} enabled
+     */
+    setFullRangeBrightness(enabled) {
+        this._ensurePlayer();
+        this._module._adl_setFullRangeBrightness(this._player, enabled ? 1 : 0);
+    }
+
+    /**
+     * Enable/disable automatic arpeggio.
+     *
+     * @param {boolean} enabled
+     */
+    setAutoArpeggio(enabled) {
+        this._ensurePlayer();
+        this._module._adl_setAutoArpeggio(this._player, enabled ? 1 : 0);
+    }
+
+    /**
+     * Get automatic arpeggio state.
+     *
+     * @returns {boolean}
+     */
+    getAutoArpeggio() {
+        this._ensurePlayer();
+        return this._module._adl_getAutoArpeggio(this._player) !== 0;
+    }
+
+    /**
+     * Set channel allocation mode.
+     *
+     * @param {number} mode - Mode ID
+     */
+    setChannelAllocMode(mode) {
+        this._ensurePlayer();
+        this._module._adl_setChannelAllocMode(this._player, mode);
+    }
+
+    /**
+     * Get channel allocation mode.
+     *
+     * @returns {number} Mode ID
+     */
+    getChannelAllocMode() {
+        this._ensurePlayer();
+        return this._module._adl_getChannelAllocMode(this._player);
+    }
+
     /**
      * Enable/disable soft stereo panning.
      *
@@ -264,6 +354,81 @@ export class AdlMidiCore {
         return this._module.UTF8ToString(ptr);
     }
 
+    /**
+     * Get the version string of the linked libADLMIDI library.
+     *
+     * @returns {string} Version string (e.g., "1.5.1")
+     */
+    getLibraryVersion() {
+        const ptr = this._module._adl_linkedLibraryVersion();
+        return this._module.UTF8ToString(ptr);
+    }
+
+    /**
+     * Get the version of the linked libADLMIDI library as an object.
+     *
+     * @returns {{major: number, minor: number, patch: number}}
+     */
+    getVersion() {
+        const ptr = this._module._adl_linkedVersion();
+        return {
+            major: this._module.getValue(ptr, 'i16'),
+            minor: this._module.getValue(ptr + 2, 'i16'),
+            patch: this._module.getValue(ptr + 4, 'i16')
+        };
+    }
+
+    /**
+     * Get the number of emulated chips.
+     *
+     * @returns {number}
+     */
+    getNumChips() {
+        this._ensurePlayer();
+        return this._module._adl_getNumChips(this._player);
+    }
+
+    /**
+     * Get the number of emulated chips obtained.
+     *
+     * @returns {number}
+     */
+    getNumChipsObtained() {
+        this._ensurePlayer();
+        return this._module._adl_getNumChipsObtained(this._player);
+    }
+
+    /**
+     * Get the volume range model.
+     *
+     * @returns {number}
+     */
+    getVolumeModel() {
+        this._ensurePlayer();
+        return this._module._adl_getVolumeRangeModel(this._player);
+    }
+
+    /**
+     * Set the volume range model.
+     *
+     * @param {number} model - Volume model type
+     */
+    setVolumeModel(model) {
+        this._ensurePlayer();
+        this._module._adl_setVolumeRangeModel(this._player, model);
+    }
+
+    /**
+     * Run emulator with PCM rate to reduce CPU usage.
+     *
+     * @param {boolean} enabled
+     * @returns {boolean} True if successful
+     */
+    setRunAtPcmRate(enabled) {
+        this._ensurePlayer();
+        return this._module._adl_setRunAtPcmRate(this._player, enabled ? 1 : 0) === 0;
+    }
+
     // =========================================================================
     // Real-time Synthesis
     // =========================================================================
@@ -291,6 +456,29 @@ export class AdlMidiCore {
         this._module._adl_rt_noteOff(this._player, channel, note);
     }
 
+    /**
+     * Send a note aftertouch message.
+     *
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} note - MIDI note (0-127)
+     * @param {number} pressure - Aftertouch pressure (0-127)
+     */
+    noteAfterTouch(channel, note, pressure) {
+        this._ensurePlayer();
+        this._module._adl_rt_noteAfterTouch(this._player, channel, note, pressure);
+    }
+
+    /**
+     * Send a channel aftertouch message.
+     *
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} pressure - Aftertouch pressure (0-127)
+     */
+    channelAfterTouch(channel, pressure) {
+        this._ensurePlayer();
+        this._module._adl_rt_channelAfterTouch(this._player, channel, pressure);
+    }
+
     /**
      * Send a pitch bend message.
      *
@@ -325,6 +513,39 @@ export class AdlMidiCore {
         this._module._adl_rt_patchChange(this._player, channel, program);
     }
 
+    /**
+     * Send a bank change message (16-bit).
+     *
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} bank - Bank number
+     */
+    bankChange(channel, bank) {
+        this._ensurePlayer();
+        this._module._adl_rt_bankChange(this._player, channel, bank);
+    }
+
+    /**
+     * Send a bank change MSB message.
+     *
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} msb - Bank MSB (0-127)
+     */
+    bankChangeMSB(channel, msb) {
+        this._ensurePlayer();
+        this._module._adl_rt_bankChangeMSB(this._player, channel, msb);
+    }
+
+    /**
+     * Send a bank change LSB message.
+     *
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} lsb - Bank LSB (0-127)
+     */
+    bankChangeLSB(channel, lsb) {
+        this._ensurePlayer();
+        this._module._adl_rt_bankChangeLSB(this._player, channel, lsb);
+    }
+
     /**
      * Generate audio samples (real-time synthesis).
      *
@@ -382,6 +603,28 @@ export class AdlMidiCore {
         return result === 0;
     }
 
+    /**
+     * Get the music title of the loaded MIDI file.
+     *
+     * @returns {string} Title or empty string
+     */
+    getMusicTitle() {
+        this._ensurePlayer();
+        const ptr = this._module._adl_metaMusicTitle(this._player);
+        return ptr ? this._module.UTF8ToString(ptr) : '';
+    }
+
+    /**
+     * Get the copyright notice of the loaded MIDI file.
+     *
+     * @returns {string} Copyright or empty string
+     */
+    getMusicCopyright() {
+        this._ensurePlayer();
+        const ptr = this._module._adl_metaMusicCopyright(this._player);
+        return ptr ? this._module.UTF8ToString(ptr) : '';
+    }
+
     /**
      * Play MIDI file and generate audio.
      *
@@ -504,24 +747,34 @@ export class AdlMidiCore {
         this._module.HEAPU8[bankIdPtr + 1] = bankId.msb || 0;
         this._module.HEAPU8[bankIdPtr + 2] = bankId.lsb || 0;
 
-        // Allocate instrument struct
-        const instPtr = this._module._malloc(SIZEOF_ADL_INSTRUMENT);
+        // Allocate bank struct
+        const bankPtr = this._module._malloc(SIZEOF_ADL_BANK);
 
-        const result = this._module._adl_getInstrument(
-            this._player,
-            bankIdPtr,
-            program,
-            instPtr
-        );
+        // Get bank (create if needed)
+        const bankResult = this._module._adl_getBank(this._player, bankIdPtr, 1, bankPtr);
 
         let instrument = null;
-        if (result === 0) {
-            const bytes = this._module.HEAPU8.slice(instPtr, instPtr + SIZEOF_ADL_INSTRUMENT);
-            instrument = decodeInstrument(bytes);
+        if (bankResult === 0) {
+            // Allocate instrument struct
+            const instPtr = this._module._malloc(SIZEOF_ADL_INSTRUMENT);
+
+            const result = this._module._adl_getInstrument(
+                this._player,
+                bankPtr,
+                program,
+                instPtr
+            );
+
+            if (result === 0) {
+                const bytes = this._module.HEAPU8.slice(instPtr, instPtr + SIZEOF_ADL_INSTRUMENT);
+                instrument = decodeInstrument(bytes);
+            }
+
+            this._module._free(instPtr);
         }
 
         this._module._free(bankIdPtr);
-        this._module._free(instPtr);
+        this._module._free(bankPtr);
 
         return instrument;
     }
@@ -546,22 +799,34 @@ export class AdlMidiCore {
         this._module.HEAPU8[bankIdPtr + 1] = bankId.msb || 0;
         this._module.HEAPU8[bankIdPtr + 2] = bankId.lsb || 0;
 
-        // Encode and write instrument
-        const bytes = encodeInstrument(instrument);
-        const instPtr = this._module._malloc(SIZEOF_ADL_INSTRUMENT);
-        this._module.HEAPU8.set(bytes, instPtr);
+        // Allocate bank struct
+        const bankPtr = this._module._malloc(SIZEOF_ADL_BANK);
+
+        // Get bank (create if needed)
+        const bankResult = this._module._adl_getBank(this._player, bankIdPtr, 1, bankPtr);
 
-        const result = this._module._adl_setInstrument(
-            this._player,
-            bankIdPtr,
-            program,
-            instPtr
-        );
+        let success = false;
+        if (bankResult === 0) {
+            // Encode and write instrument
+            const bytes = encodeInstrument(instrument);
+            const instPtr = this._module._malloc(SIZEOF_ADL_INSTRUMENT);
+            this._module.HEAPU8.set(bytes, instPtr);
+
+            const result = this._module._adl_setInstrument(
+                this._player,
+                bankPtr,
+                program,
+                instPtr
+            );
+
+            success = result === 0;
+            this._module._free(instPtr);
+        }
 
         this._module._free(bankIdPtr);
-        this._module._free(instPtr);
+        this._module._free(bankPtr);
 
-        return result === 0;
+        return success;
     }
 
     // =========================================================================

package/src/libadlmidi.js

@@ -74,7 +74,7 @@
  */
 
 /**
- * Available OPL3 emulator cores.
+ * Available OPL2/OPL3 emulator cores.
  * Use with switchEmulator() to change the synthesis engine at runtime.
  * Note: Only emulators compiled into the current profile are available.
  * @readonly
@@ -103,6 +103,8 @@ export const Emulator = Object.freeze({
     NUKED_OPL2_LLE: 9,
     /** Nuked OPL3 LLE - Transistor-level emulation */
     NUKED_OPL3_LLE: 10,
+    /** Nuked OPL2 Lite - Lightweight OPL2 emulation for AdLib-era music */
+    NUKED_OPL2_LITE: 11,
 });
 
 export class AdlMidi {
@@ -156,13 +158,12 @@ export class AdlMidi {
         // For split builds, fetch the WASM binary from main thread
         // (AudioWorklet doesn't have fetch access)
         // If wasmUrl not provided, derive it from processorUrl
-        let wasmBinary = null;
         const effectiveWasmUrl = wasmUrl || processorUrl.replace('.processor.js', '.core.wasm');
         const response = await fetch(effectiveWasmUrl);
         if (!response.ok) {
             throw new Error(`Failed to fetch WASM: ${response.status}`);
         }
-        wasmBinary = await response.arrayBuffer();
+        const wasmBinary = await response.arrayBuffer();
 
         // Add the AudioWorklet module
         await this.ctx.audioWorklet.addModule(processorUrl);
@@ -289,6 +290,52 @@ export class AdlMidi {
         this.#send({ type: 'programChange', channel, program });
     }
 
+    /**
+     * Send note aftertouch
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} note - Note number (0-127)
+     * @param {number} pressure - Pressure (0-127)
+     */
+    noteAfterTouch(channel, note, pressure) {
+        this.#send({ type: 'noteAfterTouch', channel, note, pressure });
+    }
+
+    /**
+     * Send channel aftertouch
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} pressure - Pressure (0-127)
+     */
+    channelAfterTouch(channel, pressure) {
+        this.#send({ type: 'channelAfterTouch', channel, pressure });
+    }
+
+    /**
+     * Change bank (16-bit)
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} bank - Bank number
+     */
+    bankChange(channel, bank) {
+        this.#send({ type: 'bankChange', channel, bank });
+    }
+
+    /**
+     * Change bank MSB
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} msb - Bank MSB (0-127)
+     */
+    bankChangeMSB(channel, msb) {
+        this.#send({ type: 'bankChangeMSB', channel, msb });
+    }
+
+    /**
+     * Change bank LSB
+     * @param {number} channel - MIDI channel (0-15)
+     * @param {number} lsb - Bank LSB (0-127)
+     */
+    bankChangeLSB(channel, lsb) {
+        this.#send({ type: 'bankChangeLSB', channel, lsb });
+    }
+
     /**
      * Reset the real-time state (stops all notes, resets controllers)
      * @returns {void}
@@ -404,6 +451,85 @@ export class AdlMidi {
         this.#send({ type: 'setNumChips', chips });
     }
 
+    /**
+     * Set the number of 4-operator channels
+     * @param {number} channels - Number of channels (-1 for auto)
+     */
+    setNumFourOpChannels(channels) {
+        this.#send({ type: 'setNumFourOpChannels', channels });
+    }
+
+    /**
+     * Get the number of 4-operator channels
+     * @returns {Promise<number>}
+     */
+    async getNumFourOpChannels() {
+        return new Promise((resolve) => {
+            this.#onceMessage('numFourOpChannels', /** @param {{channels: number}} msg */(msg) => {
+                resolve(msg.channels);
+            });
+            this.#send({ type: 'getNumFourOpChannels' });
+        });
+    }
+
+    /**
+     * Enable/disable scaling of modulators by volume
+     * @param {boolean} enabled
+     */
+    setScaleModulators(enabled) {
+        this.#send({ type: 'setScaleModulators', enabled });
+    }
+
+    /**
+     * Enable/disable full-range brightness
+     * @param {boolean} enabled
+     */
+    setFullRangeBrightness(enabled) {
+        this.#send({ type: 'setFullRangeBrightness', enabled });
+    }
+
+    /**
+     * Enable/disable automatic arpeggio
+     * @param {boolean} enabled
+     */
+    setAutoArpeggio(enabled) {
+        this.#send({ type: 'setAutoArpeggio', enabled });
+    }
+
+    /**
+     * Get automatic arpeggio state
+     * @returns {Promise<boolean>}
+     */
+    async getAutoArpeggio() {
+        return new Promise((resolve) => {
+            this.#onceMessage('autoArpeggio', /** @param {{enabled: boolean}} msg */(msg) => {
+                resolve(msg.enabled);
+            });
+            this.#send({ type: 'getAutoArpeggio' });
+        });
+    }
+
+    /**
+     * Set channel allocation mode
+     * @param {number} mode - Mode ID
+     */
+    setChannelAllocMode(mode) {
+        this.#send({ type: 'setChannelAllocMode', mode });
+    }
+
+    /**
+     * Get channel allocation mode
+     * @returns {Promise<number>}
+     */
+    async getChannelAllocMode() {
+        return new Promise((resolve) => {
+            this.#onceMessage('channelAllocMode', /** @param {{mode: number}} msg */(msg) => {
+                resolve(msg.mode);
+            });
+            this.#send({ type: 'getChannelAllocMode' });
+        });
+    }
+
     /**
      * Set the volume model
      * @param {number} model - Volume model number
@@ -436,6 +562,14 @@ export class AdlMidi {
         this.#send({ type: 'setTremolo', enabled });
     }
 
+    /**
+     * Run emulator with PCM rate to reduce CPU usage
+     * @param {boolean} enabled
+     */
+    setRunAtPcmRate(enabled) {
+        this.#send({ type: 'setRunAtPcmRate', enabled });
+    }
+
     /**
      * Switch the OPL3 emulator core at runtime
      * 
@@ -480,6 +614,71 @@ export class AdlMidi {
         });
     }
 
+    /**
+     * Get the version string of the linked libADLMIDI library
+     * @returns {Promise<string>}
+     */
+    async getLibraryVersion() {
+        return new Promise((resolve) => {
+            this.#onceMessage('libraryVersion', /** @param {{version: string}} msg */(msg) => {
+                resolve(msg.version);
+            });
+            this.#send({ type: 'getLibraryVersion' });
+        });
+    }
+
+    /**
+     * Get the version of the linked libADLMIDI library as an object
+     * @returns {Promise<{major: number, minor: number, patch: number}>}
+     */
+    async getVersion() {
+        return new Promise((resolve) => {
+            this.#onceMessage('version', /** @param {{version: {major: number, minor: number, patch: number}}} msg */(msg) => {
+                resolve(msg.version);
+            });
+            this.#send({ type: 'getVersion' });
+        });
+    }
+
+    /**
+     * Get the number of emulated chips
+     * @returns {Promise<number>}
+     */
+    async getNumChips() {
+        return new Promise((resolve) => {
+            this.#onceMessage('numChips', /** @param {{chips: number}} msg */(msg) => {
+                resolve(msg.chips);
+            });
+            this.#send({ type: 'getNumChips' });
+        });
+    }
+
+    /**
+     * Get the number of emulated chips obtained
+     * @returns {Promise<number>}
+     */
+    async getNumChipsObtained() {
+        return new Promise((resolve) => {
+            this.#onceMessage('numChipsObtained', /** @param {{chips: number}} msg */(msg) => {
+                resolve(msg.chips);
+            });
+            this.#send({ type: 'getNumChipsObtained' });
+        });
+    }
+
+    /**
+     * Get the volume range model
+     * @returns {Promise<number>}
+     */
+    async getVolumeModel() {
+        return new Promise((resolve) => {
+            this.#onceMessage('volumeModel', /** @param {{model: number}} msg */(msg) => {
+                resolve(msg.model);
+            });
+            this.#send({ type: 'getVolumeModel' });
+        });
+    }
+
     /**
      * Get list of embedded banks available in this build
      * Note: Slim builds have no embedded banks and will return an empty array
@@ -518,7 +717,7 @@ export class AdlMidi {
                 if (msg.success) {
                     resolve({ duration: msg.duration });
                 } else {
-                    reject(new Error(msg.error || 'Failed to load MIDI data'));
+                    reject(new Error(msg.error || 'Failed to parse MIDI data'));
                 }
             });
 
@@ -526,6 +725,32 @@ export class AdlMidi {
         });
     }
 
+    /**
+     * Get the music title of the loaded MIDI file
+     * @returns {Promise<string>}
+     */
+    async getMusicTitle() {
+        return new Promise((resolve) => {
+            this.#onceMessage('musicTitle', /** @param {{title: string}} msg */(msg) => {
+                resolve(msg.title);
+            });
+            this.#send({ type: 'getMusicTitle' });
+        });
+    }
+
+    /**
+     * Get the copyright notice of the loaded MIDI file
+     * @returns {Promise<string>}
+     */
+    async getMusicCopyright() {
+        return new Promise((resolve) => {
+            this.#onceMessage('musicCopyright', /** @param {{copyright: string}} msg */(msg) => {
+                resolve(msg.copyright);
+            });
+            this.#send({ type: 'getMusicCopyright' });
+        });
+    }
+
     /**
      * Start or resume MIDI file playback
      * @returns {void}