spessasynth_lib 3.25.17 → 3.25.19

package/index.js

@@ -27,6 +27,8 @@ import { DEFAULT_SYNTH_CONFIG } from "./synthetizer/audio_effects/effects_config
 import { WORKLET_URL_ABSOLUTE } from './synthetizer/worklet_url.js';
 import { SynthesizerSnapshot} from "./synthetizer/worklet_system/snapshot/synthesizer_snapshot.js";
 import { ChannelSnapshot } from "./synthetizer/worklet_system/snapshot/channel_snapshot.js";
+import { NON_CC_INDEX_OFFSET } from "./synthetizer/worklet_system/worklet_utilities/controller_tables.js";
+import { ALL_CHANNELS_OR_DIFFERENT_ACTION } from "./synthetizer/worklet_system/message_protocol/worklet_message.js";
 
 // Export modules
 export {
@@ -38,6 +40,8 @@ export {
     DEFAULT_PERCUSSION,
     VOICE_CAP,
     DEFAULT_SYNTH_CONFIG,
+    ALL_CHANNELS_OR_DIFFERENT_ACTION,
+    NON_CC_INDEX_OFFSET,
     
     // SoundFont
     BasicSoundBank,

package/midi_parser/midi_builder.js

@@ -80,7 +80,8 @@ export class MIDIBuilder extends BasicMIDI
         }
         if (event === messageTypes.endOfTrack)
         {
-            SpessaSynthWarn("The EndOfTrack is added automatically. Ignoring!");
+            SpessaSynthWarn(
+                "The EndOfTrack is added automatically and does not influence the duration. Consider adding a voice event instead.");
             return;
         }
         // remove the end of track

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.25.17",
+  "version": "3.25.19",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "type": "module",

package/sequencer/worklet_sequencer/play.js

@@ -316,7 +316,7 @@ export function play(resetTime = false)
     {
         this.playingNotes.forEach(n =>
         {
-            this.synth.noteOn(n.channel, n.midiNote, n.velocity, false, true);
+            this.synth.noteOn(n.channel, n.midiNote, n.velocity);
         });
     }
     this.setProcessHandler();
@@ -333,7 +333,7 @@ export function setTimeTicks(ticks)
     this.pausedTime = undefined;
     this.post(
         WorkletSequencerReturnMessageType.timeChange,
-        currentTime - this.midiData.MIDIticksToSeconds(ticks)
+        this.synth.currentSynthTime - this.midiData.MIDIticksToSeconds(ticks)
     );
     const isNotFinished = this._playTo(0, ticks);
     this._recalculateStartTime(this.playedTime);
@@ -351,5 +351,5 @@ export function setTimeTicks(ticks)
  */
 export function _recalculateStartTime(time)
 {
-    this.absoluteStartTime = currentTime - time / this._playbackRate;
+    this.absoluteStartTime = this.synth.currentSynthTime - time / this._playbackRate;
 }

package/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -83,7 +83,7 @@ class WorkletSequencer
      * Absolute playback startTime, bases on the synth's time
      * @type {number}
      */
-    absoluteStartTime = currentTime;
+    absoluteStartTime = 0;
     /**
      * Currently playing notes (for pausing and resuming)
      * @type {{
@@ -142,6 +142,7 @@ class WorkletSequencer
     constructor(spessasynthProcessor)
     {
         this.synth = spessasynthProcessor;
+        this.absoluteStartTime = this.synth.currentSynthTime;
     }
     
     /**
@@ -169,7 +170,7 @@ class WorkletSequencer
             return this.pausedTime;
         }
         
-        return (currentTime - this.absoluteStartTime) * this._playbackRate;
+        return (this.synth.currentSynthTime - this.absoluteStartTime) * this._playbackRate;
     }
     
     set currentTime(time)
@@ -199,7 +200,7 @@ class WorkletSequencer
         this.playingNotes = [];
         const wasPaused = this.paused && this.preservePlaybackState;
         this.pausedTime = undefined;
-        this.post(WorkletSequencerReturnMessageType.timeChange, currentTime - time);
+        this.post(WorkletSequencerReturnMessageType.timeChange, this.synth.currentSynthTime - time);
         if (this.midiData.duration === 0)
         {
             SpessaSynthWarn("No duration!");

package/soundfont/basic_soundfont/generator.js

@@ -129,7 +129,7 @@ generatorLimits[generatorTypes.startloopAddrsCoarseOffset] = { min: -32768, max:
 generatorLimits[generatorTypes.keyNum] = { min: -1, max: 127, def: -1 };
 generatorLimits[generatorTypes.velocity] = { min: -1, max: 127, def: -1 };
 
-generatorLimits[generatorTypes.initialAttenuation] = { min: -250, max: 1440, def: 0 }; // sound blaster allows 10dB of gain (divide by 0.4)
+generatorLimits[generatorTypes.initialAttenuation] = { min: 0, max: 1440, def: 0 };
 
 generatorLimits[generatorTypes.endloopAddrsCoarseOffset] = { min: -32768, max: 32768, def: 0 };
 

package/soundfont/dls/read_articulation.js

@@ -39,6 +39,14 @@ export function readArticulation(chunk, disableVibrato)
         const scale = readLittleEndian(artData, 4) | 0;
         const value = scale >> 16; // convert it to 16 bit as soundfont uses that
         
+        // modulatorConverterDebug(
+        //     source,
+        //     control,
+        //     destination,
+        //     value,
+        //     transform
+        // );
+        
         // interpret this somehow...
         // if source and control are both zero, it's a generator
         if (source === 0 && control === 0 && transform === 0)
@@ -147,6 +155,29 @@ export function readArticulation(chunk, disableVibrato)
             // if not, modulator?
         {
             let isGenerator = true;
+            
+            const applyKeyToCorrection = (value, keyToGen, realGen) =>
+            {
+                // according to viena and another strange (with modulators) rendition of gm.dls in sf2,
+                // it shall be divided by -128
+                // and a strange correction needs to be applied to the real value:
+                // real + (60 / 128) * scale
+                const keyToGenValue = value / -128;
+                generators.push(new Generator(keyToGen, keyToGenValue));
+                // airfont 340 fix
+                if (keyToGenValue <= 120)
+                {
+                    const correction = Math.round((60 / 128) * value);
+                    generators.forEach(g =>
+                    {
+                        if (g.generatorType === realGen)
+                        {
+                            g.generatorValue += correction;
+                        }
+                    });
+                }
+            };
+            
             // a few special cases which are generators:
             if (control === DLSSources.none)
             {
@@ -197,73 +228,25 @@ export function readArticulation(chunk, disableVibrato)
                     // key to vol env hold
                 if (source === DLSSources.keyNum && destination === DLSDestinations.volEnvHold)
                 {
-                    // according to viena and another strange (with modulators) rendition of gm.dls in sf2,
-                    // it shall be divided by -128
-                    // and a strange correction needs to be applied to the real value:
-                    // real + (60 / 128) * scale
-                    generators.push(new Generator(generatorTypes.keyNumToVolEnvHold, value / -128));
-                    const correction = Math.round((60 / 128) * value);
-                    generators.forEach(g =>
-                    {
-                        if (g.generatorType === generatorTypes.holdVolEnv)
-                        {
-                            g.generatorValue += correction;
-                        }
-                    });
+                    applyKeyToCorrection(value, generatorTypes.keyNumToVolEnvHold, generatorTypes.holdVolEnv);
                 }
                 else
                     // key to vol env decay
                 if (source === DLSSources.keyNum && destination === DLSDestinations.volEnvDecay)
                 {
-                    // according to viena and another strange (with modulators) rendition of gm.dls in sf2,
-                    // it shall be divided by -128
-                    // and a strange correction needs to be applied to the real value:
-                    // real + (60 / 128) * scale
-                    generators.push(new Generator(generatorTypes.keyNumToVolEnvDecay, value / -128));
-                    const correction = Math.round((60 / 128) * value);
-                    generators.forEach(g =>
-                    {
-                        if (g.generatorType === generatorTypes.decayVolEnv)
-                        {
-                            g.generatorValue += correction;
-                        }
-                    });
+                    applyKeyToCorrection(value, generatorTypes.keyNumToVolEnvDecay, generatorTypes.decayVolEnv);
                 }
                 else
                     // key to mod env hold
                 if (source === DLSSources.keyNum && destination === DLSDestinations.modEnvHold)
                 {
-                    // according to viena and another strange (with modulators) rendition of gm.dls in sf2,
-                    // it shall be divided by -128
-                    // and a strange correction needs to be applied to the real value:
-                    // real + (60 / 128) * scale
-                    generators.push(new Generator(generatorTypes.keyNumToModEnvHold, value / -128));
-                    const correction = Math.round((60 / 128) * value);
-                    generators.forEach(g =>
-                    {
-                        if (g.generatorType === generatorTypes.holdModEnv)
-                        {
-                            g.generatorValue += correction;
-                        }
-                    });
+                    applyKeyToCorrection(value, generatorTypes.keyNumToModEnvHold, generatorTypes.holdModEnv);
                 }
                 else
                     // key to mod env decay
                 if (source === DLSSources.keyNum && destination === DLSDestinations.modEnvDecay)
                 {
-                    // according to viena and another strange (with modulators) rendition of gm.dls in sf2,
-                    // it shall be divided by -128
-                    // and a strange correction needs to be applied to the real value:
-                    // real + (60 / 128) * scale
-                    generators.push(new Generator(generatorTypes.keyNumToModEnvDecay, value / -128));
-                    const correction = Math.round((60 / 128) * value);
-                    generators.forEach(g =>
-                    {
-                        if (g.generatorType === generatorTypes.decayModEnv)
-                        {
-                            g.generatorValue += correction;
-                        }
-                    });
+                    applyKeyToCorrection(value, generatorTypes.keyNumToModEnvDecay, generatorTypes.decayModEnv);
                 }
                 else
                 {

package/soundfont/dls/read_region.js

@@ -37,11 +37,7 @@ export function readRegion(chunk)
         velMax = 127;
         velMin = 0;
     }
-    if (keyMin === 0 && keyMax === 0)
-    {
-        keyMax = 127;
-        keyMin = 0;
-    }
+    // cannot do the same to key zones sadly
     
     const zone = new DLSZone(
         { min: keyMin, max: keyMax },

package/synthetizer/synth_event_handler.js

@@ -27,7 +27,6 @@
  * @property {number} channel - The MIDI channel number.
  * @property {number} program - The program number.
  * @property {number} bank - The bank number.
- * @property {boolean} userCalled - Indicates if the change was user-initiated.
  */
 
 /**

package/synthetizer/synthetizer.js

@@ -1,6 +1,5 @@
-import { IndexedByteArray } from "../utils/indexed_array.js";
 import { consoleColors } from "../utils/other.js";
-import { getEvent, messageTypes, midiControllers } from "../midi_parser/midi_message.js";
+import { messageTypes, midiControllers } from "../midi_parser/midi_message.js";
 import { EventHandler } from "./synth_event_handler.js";
 import { FancyChorus } from "./audio_effects/fancy_chorus.js";
 import { getReverbProcessor } from "./audio_effects/reverb.js";
@@ -32,7 +31,20 @@ import { DEFAULT_SEQUENCER_OPTIONS } from "../sequencer/default_sequencer_option
  * purpose: responds to midi messages and called functions, managing the channels and passing the messages to them
  */
 
+/**
+ * @typedef {Object} SynthMethodOptions
+ * @property {number} time - the audio context time when the event should execute, in seconds.
+ */
 
+/**
+ * @type {SynthMethodOptions}
+ */
+const DEFAULT_SYNTH_METHOD_OPTIONS = {
+    time: 0
+};
+
+
+// the "remote controller" of the worklet processor in the audio thread from the main thread
 export class Synthetizer
 {
     
@@ -566,20 +578,53 @@ export class Synthetizer
         });
     }
     
+    /**
+     * sends a raw MIDI message to the synthesizer.
+     * @param message {number[]|Uint8Array} the midi message, each number is a byte.
+     * @param channelOffset {number} the channel offset of the message.
+     * @param eventOptions {SynthMethodOptions} additional options for this command.
+     */
+    sendMessage(message, channelOffset = 0, eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS)
+    {
+        this._sendInternal(message, channelOffset, false, eventOptions);
+    }
+    
+    /**
+     * @param message {number[]|Uint8Array}
+     * @param offset {number}
+     * @param force {boolean}
+     * @param eventOptions {SynthMethodOptions}
+     * @private
+     */
+    _sendInternal(message, offset, force = false, eventOptions)
+    {
+        const opts = fillWithDefaults(eventOptions ?? {}, DEFAULT_SYNTH_METHOD_OPTIONS);
+        this.post({
+            messageType: workletMessageType.midiMessage,
+            messageData: [new Uint8Array(message), offset, force, opts]
+        });
+    }
+    
+    
     /**
      * Starts playing a note
      * @param channel {number} usually 0-15: the channel to play the note.
      * @param midiNote {number} 0-127 the key number of the note.
      * @param velocity {number} 0-127 the velocity of the note (generally controls loudness).
-     * @param enableDebugging {boolean} set to true to log technical details to console.
+     * @param eventOptions {SynthMethodOptions} additional options for this command.
      */
-    noteOn(channel, midiNote, velocity, enableDebugging = false)
+    noteOn(channel, midiNote, velocity, eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS)
     {
-        this.post({
-            channelNumber: channel,
-            messageType: workletMessageType.noteOn,
-            messageData: [midiNote, velocity, enableDebugging]
-        });
+        const ch = channel % 16;
+        const offset = channel - ch;
+        midiNote %= 128;
+        velocity %= 128;
+        // check for legacy "enableDebugging"
+        if (eventOptions === true)
+        {
+            eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS;
+        }
+        this.sendMessage([messageTypes.noteOn | ch, midiNote, velocity], offset, eventOptions);
     }
     
     /**
@@ -587,25 +632,15 @@ export class Synthetizer
      * @param channel {number} usually 0-15: the channel of the note.
      * @param midiNote {number} 0-127 the key number of the note.
      * @param force {boolean} instantly kills the note if true.
+     * @param eventOptions {SynthMethodOptions} additional options for this command.
      */
-    noteOff(channel, midiNote, force = false)
+    noteOff(channel, midiNote, force = false, eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS)
     {
-        if (force)
-        {
-            this.post({
-                channelNumber: channel,
-                messageType: workletMessageType.killNote,
-                messageData: midiNote
-            });
-        }
-        else
-        {
-            this.post({
-                channelNumber: channel,
-                messageType: workletMessageType.noteOff,
-                messageData: midiNote
-            });
-        }
+        midiNote %= 128;
+        
+        const ch = channel % 16;
+        const offset = channel - ch;
+        this._sendInternal([messageTypes.noteOff | ch, midiNote], offset, force, eventOptions);
     }
     
     /**
@@ -628,20 +663,25 @@ export class Synthetizer
      * @param controllerNumber {number} 0-127 the MIDI CC number.
      * @param controllerValue {number} 0-127 the controller value.
      * @param force {boolean} forces the controller-change message, even if it's locked or gm system is set and the cc is bank select.
+     * @param eventOptions {SynthMethodOptions} additional options for this command.
      */
-    controllerChange(channel, controllerNumber, controllerValue, force = false)
+    controllerChange(channel, controllerNumber, controllerValue, force = false, eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS)
     {
         if (controllerNumber > 127 || controllerNumber < 0)
         {
             throw new Error(`Invalid controller number: ${controllerNumber}`);
         }
-        controllerValue = Math.floor(controllerValue);
-        controllerNumber = Math.floor(controllerNumber);
-        this.post({
-            channelNumber: channel,
-            messageType: workletMessageType.ccChange,
-            messageData: [controllerNumber, controllerValue, force]
-        });
+        controllerValue = Math.floor(controllerValue) % 128;
+        controllerNumber = Math.floor(controllerNumber) % 128;
+        // controller change has its own message for the force property
+        const ch = channel % 16;
+        const offset = channel - ch;
+        this._sendInternal(
+            [messageTypes.controllerChange | ch, controllerNumber, controllerValue],
+            offset,
+            force,
+            eventOptions
+        );
     }
     
     /**
@@ -660,14 +700,14 @@ export class Synthetizer
      * Applies pressure to a given channel.
      * @param channel {number} usually 0-15: the channel to change the controller.
      * @param pressure {number} 0-127: the pressure to apply.
+     * @param eventOptions {SynthMethodOptions} additional options for this command.
      */
-    channelPressure(channel, pressure)
+    channelPressure(channel, pressure, eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS)
     {
-        this.post({
-            channelNumber: channel,
-            messageType: workletMessageType.channelPressure,
-            messageData: pressure
-        });
+        const ch = channel % 16;
+        const offset = channel - ch;
+        pressure %= 128;
+        this.sendMessage([messageTypes.channelPressure | ch, pressure], offset, eventOptions);
     }
     
     /**
@@ -675,14 +715,29 @@ export class Synthetizer
      * @param channel {number} usually 0-15: the channel to change the controller.
      * @param midiNote {number} 0-127: the MIDI note.
      * @param pressure {number} 0-127: the pressure to apply.
+     * @param eventOptions {SynthMethodOptions} additional options for this command.
      */
-    polyPressure(channel, midiNote, pressure)
+    polyPressure(channel, midiNote, pressure, eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS)
     {
-        this.post({
-            channelNumber: channel,
-            messageType: workletMessageType.polyPressure,
-            messageData: [midiNote, pressure]
-        });
+        const ch = channel % 16;
+        const offset = channel - ch;
+        midiNote %= 128;
+        pressure %= 128;
+        this.sendMessage([messageTypes.polyPressure | ch, midiNote, pressure], offset, eventOptions);
+    }
+    
+    /**
+     * Sets the pitch of the given channel.
+     * @param channel {number} usually 0-15: the channel to change pitch.
+     * @param MSB {number} SECOND byte of the MIDI pitchWheel message.
+     * @param LSB {number} FIRST byte of the MIDI pitchWheel message.
+     * @param eventOptions {SynthMethodOptions} additional options for this command.
+     */
+    pitchWheel(channel, MSB, LSB, eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS)
+    {
+        const ch = channel % 16;
+        const offset = channel - ch;
+        this.sendMessage([messageTypes.pitchBend | ch, LSB, MSB], offset, eventOptions);
     }
     
     /**
@@ -697,21 +752,6 @@ export class Synthetizer
         this.worklet.port.postMessage(data);
     }
     
-    /**
-     * Sets the pitch of the given channel.
-     * @param channel {number} usually 0-15: the channel to change pitch.
-     * @param MSB {number} SECOND byte of the MIDI pitchWheel message.
-     * @param LSB {number} FIRST byte of the MIDI pitchWheel message.
-     */
-    pitchWheel(channel, MSB, LSB)
-    {
-        this.post({
-            channelNumber: channel,
-            messageType: workletMessageType.pitchWheel,
-            messageData: [MSB, LSB]
-        });
-    }
-    
     /**
      * Transposes the synthetizer's pitch by given semitones amount (percussion channels don’t get affected).
      * @param semitones {number} the semitones to transpose by.
@@ -776,16 +816,14 @@ export class Synthetizer
      * Changes the patch for a given channel
      * @param channel {number} usually 0-15: the channel to change
      * @param programNumber {number} 0-127 the MIDI patch number
-     * @param userChange {boolean} indicates if user has called the program change.
      * defaults to false
      */
-    programChange(channel, programNumber, userChange = false)
+    programChange(channel, programNumber)
     {
-        this.post({
-            channelNumber: channel,
-            messageType: workletMessageType.programChange,
-            messageData: [programNumber, userChange]
-        });
+        const ch = channel % 16;
+        const offset = channel - ch;
+        programNumber %= 128;
+        this.sendMessage([messageTypes.programChange | ch, programNumber], offset);
     }
     
     /**
@@ -796,11 +834,14 @@ export class Synthetizer
      */
     velocityOverride(channel, velocity)
     {
-        this.post({
-            channelNumber: channel,
-            messageType: workletMessageType.ccChange,
-            messageData: [channelConfiguration.velocityOverride, velocity, true]
-        });
+        const ch = channel % 16;
+        const offset = channel - ch;
+        this._sendInternal(
+            [messageTypes.controllerChange | ch, channelConfiguration.velocityOverride, velocity],
+            offset,
+            true,
+            DEFAULT_SYNTH_METHOD_OPTIONS
+        );
     }
     
     /**
@@ -851,14 +892,16 @@ export class Synthetizer
      * @param messageData {number[]|ArrayLike|Uint8Array} the message's data
      * (excluding the F0 byte, but including the F7 at the end).
      * @param channelOffset {number} channel offset for the system exclusive message, defaults to zero.
+     * @param eventOptions {SynthMethodOptions} additional options for this command.
      */
-    systemExclusive(messageData, channelOffset = 0)
+    systemExclusive(messageData, channelOffset = 0, eventOptions = DEFAULT_SYNTH_METHOD_OPTIONS)
     {
-        this.post({
-            channelNumber: ALL_CHANNELS_OR_DIFFERENT_ACTION,
-            messageType: workletMessageType.systemExclusive,
-            messageData: [Array.from(messageData), channelOffset]
-        });
+        this._sendInternal(
+            [messageTypes.systemExclusive, ...Array.from(messageData)],
+            channelOffset,
+            false,
+            eventOptions
+        );
     }
     
     // noinspection JSUnusedGlobalSymbols
@@ -919,70 +962,6 @@ export class Synthetizer
         });
     }
     
-    /**
-     * sends a raw MIDI message to the synthesizer.
-     * @param message {number[]|Uint8Array} the midi message, each number is a byte.
-     * @param channelOffset {number} the channel offset of the message.
-     */
-    sendMessage(message, channelOffset = 0)
-    {
-        // discard as soon as possible if high perf
-        const statusByteData = getEvent(message[0]);
-        
-        statusByteData.channel += channelOffset;
-        // process the event
-        switch (statusByteData.status)
-        {
-            case messageTypes.noteOn:
-                const velocity = message[2];
-                if (velocity > 0)
-                {
-                    this.noteOn(statusByteData.channel, message[1], velocity);
-                }
-                else
-                {
-                    this.noteOff(statusByteData.channel, message[1]);
-                }
-                break;
-            
-            case messageTypes.noteOff:
-                this.noteOff(statusByteData.channel, message[1]);
-                break;
-            
-            case messageTypes.pitchBend:
-                this.pitchWheel(statusByteData.channel, message[2], message[1]);
-                break;
-            
-            case messageTypes.controllerChange:
-                this.controllerChange(statusByteData.channel, message[1], message[2]);
-                break;
-            
-            case messageTypes.programChange:
-                this.programChange(statusByteData.channel, message[1]);
-                break;
-            
-            case messageTypes.polyPressure:
-                this.polyPressure(statusByteData.channel, message[0], message[1]);
-                break;
-            
-            case messageTypes.channelPressure:
-                this.channelPressure(statusByteData.channel, message[1]);
-                break;
-            
-            case messageTypes.systemExclusive:
-                this.systemExclusive(new IndexedByteArray(message.slice(1)));
-                break;
-            
-            case messageTypes.reset:
-                this.stopAll(true);
-                this.resetControllers();
-                break;
-            
-            default:
-                break;
-        }
-    }
-    
     /**
      * Updates the reverb processor with a new impulse response.
      * @param buffer {AudioBuffer} the new reverb impulse response.