spessasynth_lib 3.22.1 → 3.22.2

package/synthetizer/worklet_system/main_processor.js

@@ -49,6 +49,7 @@ import {
 import { applySynthesizerSnapshot, sendSynthesizerSnapshot } from "./worklet_methods/snapshot.js";
 import { WorkletSoundfontManager } from "./worklet_methods/worklet_soundfont_manager/worklet_soundfont_manager.js";
 import { interpolationTypes } from "./worklet_utilities/wavetable_oscillator.js";
+import { WorkletKeyModifierManager } from "./worklet_methods/worklet_key_modifier.js";
 import { getWorkletVoices } from "./worklet_utilities/worklet_voice.js";
 import { panVoice } from "./worklet_utilities/stereo_panner.js";
 
@@ -150,7 +151,13 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
         this.highPerformanceMode = false;
         
         /**
-         * Overrides the main soundfont (embedded for example
+         * Handlese custom key overrides: velocity and preset
+         * @type {WorkletKeyModifierManager}
+         */
+        this.keyModifierManager = new WorkletKeyModifierManager();
+        
+        /**
+         * Overrides the main soundfont (embedded for example)
          * @type {BasicSoundFont}
          */
         this.overrideSoundfont = undefined;

package/synthetizer/worklet_system/message_protocol/handle_message.js

@@ -203,6 +203,10 @@ export function handleMessage(message)
             this.clearSoundFont(true, false);
             break;
         
+        case workletMessageType.keyModifierManager:
+            this.keyModifierManager.handleMessage(data[0], data[1]);
+            break;
+        
         case workletMessageType.requestSynthesizerSnapshot:
             this.sendSynthesizerSnapshot();
             break;

package/synthetizer/worklet_system/message_protocol/worklet_message.js

@@ -27,6 +27,7 @@
  * @property {number} sequencerSpecific          - 23 -> [messageType<WorkletSequencerMessageType> messageData<any>] note: refer to sequencer_message.js
  * @property {number} requestSynthesizerSnapshot - 24 -> (no data)
  * @property {number} setLogLevel                - 25 -> [enableInfo<boolean>, enableWarning<boolean>, enableGroup<boolean>, enableTable<boolean>]
+ * @property {number} keyModifier                - 26 -> [messageType<workletKeyModifierMessageType> messageData<any>]
  */
 export const workletMessageType = {
     noteOff: 0,
@@ -54,7 +55,8 @@ export const workletMessageType = {
     lockController: 22,
     sequencerSpecific: 23,
     requestSynthesizerSnapshot: 24,
-    setLogLevel: 25
+    setLogLevel: 25,
+    keyModifierManager: 26
 };
 
 /**
@@ -83,6 +85,7 @@ export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
  *     |boolean
  *     |ArrayBuffer
  *     |{messageType: WorkletSequencerMessageType, messageData: any}
+ *     |{messageType: workletKeyModifierMessageType, messageData: any}
  *     )
  * }} WorkletMessage
  */

package/synthetizer/worklet_system/worklet_methods/note_on.js

@@ -50,6 +50,13 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
         velocity = channelObject.velocityOverride;
     }
     
+    // key velocity override
+    const keyVel = this.keyModifierManager.getVelocity(channel, midiNote);
+    if (keyVel > -1)
+    {
+        velocity = keyVel;
+    }
+    
     // get voices
     const voices = this.getWorkletVoices(
         channel,

package/synthetizer/worklet_system/worklet_methods/worklet_key_modifier.js

@@ -0,0 +1,141 @@
+export class KeyModifier
+{
+    
+    /**
+     * The new override velocity. -1 means unchanged
+     * @type {number}
+     */
+    velocity = -1;
+    /**
+     * The patch this key uses. -1 on either means default
+     * @type {{bank: number, program: number}}
+     */
+    patch = { bank: -1, program: -1 };
+    
+    /**
+     * @param velocity {number}
+     * @param bank {number}
+     * @param program {number}
+     */
+    constructor(velocity = -1, bank = -1, program = -1)
+    {
+        this.velocity = velocity;
+        this.patch = {
+            bank: bank,
+            program: program
+        };
+    }
+}
+
+/**
+ * @enum {number}
+ */
+export const workletKeyModifierMessageType = {
+    addMapping: 0,    // [channel<number, midiNote<number>, mapping<KeyModifier>]
+    deleteMapping: 1, // [channel<number, midiNote<number>]
+    clearMappings: 2  // <no data>
+};
+
+export class WorkletKeyModifierManager
+{
+    /**
+     * The velocity override mappings for MIDI keys
+     * @type {KeyModifier[][]}
+     * @private
+     */
+    _keyMappings = [];
+    
+    /**
+     * @param type {workletKeyModifierMessageType}
+     * @param data {any}
+     */
+    handleMessage(type, data)
+    {
+        switch (type)
+        {
+            default:
+                return;
+            
+            case workletKeyModifierMessageType.addMapping:
+                this.addMapping(...data);
+                break;
+            
+            case workletKeyModifierMessageType.clearMappings:
+                this.clearMappings();
+                break;
+            
+            case workletKeyModifierMessageType.deleteMapping:
+                this.deleteMapping(...data);
+        }
+    }
+    
+    /**
+     * @param channel {number}
+     * @param midiNote {number}
+     * @param mapping {KeyModifier}
+     */
+    addMapping(channel, midiNote, mapping)
+    {
+        if (this._keyMappings[channel] === undefined)
+        {
+            this._keyMappings[channel] = [];
+        }
+        this._keyMappings[channel][midiNote] = mapping;
+    }
+    
+    deleteMapping(channel, midiNote)
+    {
+        if (this._keyMappings[channel]?.[midiNote] === undefined)
+        {
+            return;
+        }
+        this._keyMappings[channel][midiNote] = undefined;
+    }
+    
+    clearMappings()
+    {
+        this._keyMappings = [];
+    }
+    
+    /**
+     * @param channel {number}
+     * @param midiNote {number}
+     * @returns {number} velocity, -1 if unchanged
+     */
+    getVelocity(channel, midiNote)
+    {
+        const modifier = this._keyMappings[channel]?.[midiNote];
+        if (modifier)
+        {
+            return modifier.velocity;
+        }
+        return -1;
+    }
+    
+    /**
+     * @param channel {number}
+     * @param midiNote {number}
+     * @returns {boolean}
+     */
+    hasOverridePatch(channel, midiNote)
+    {
+        const bank = this._keyMappings[channel]?.[midiNote]?.patch?.bank;
+        return bank !== undefined && bank > 0;
+    }
+    
+    /**
+     * @param channel {number}
+     * @param midiNote {number}
+     * @returns {{bank: number, program: number}} -1 if unchanged
+     */
+    getPatch(channel, midiNote)
+    {
+        const modifier = this._keyMappings[channel]?.[midiNote];
+        if (modifier)
+        {
+            return modifier.patch;
+        }
+        throw new Error("No modifier.");
+    }
+    
+}

package/synthetizer/worklet_system/worklet_utilities/lowpass_filter.js

@@ -152,7 +152,6 @@ export class WorkletLowpassFilter
         
         
         // code is ported from https://github.com/sinshu/meltysynth/ to work with js.
-        // I'm too dumb to understand the math behind this...
         let w = 2 * Math.PI * filter.cutoffHz / sampleRate; // we're in the audioworkletglobalscope so we can use sampleRate
         let cosw = Math.cos(w);
         let alpha = Math.sin(w) / (2 * filter.reasonanceGain);

package/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -333,112 +333,126 @@ export function getWorkletVoices(channel,
     let workletVoices;
     
     const cached = channelObject.cachedVoices[midiNote][velocity];
-    if (cached !== undefined)
+    
+    // override patch
+    const overridePatch = this.keyModifierManager.hasOverridePatch(channel, midiNote);
+    
+    // overriden patch is not cached
+    if (cached !== undefined && !overridePatch)
     {
         return cached.map(v => WorkletVoice.copy(v, currentTime));
     }
-    else
+    
+    // not cached...
+    let canCache = true;
+    let preset = channelObject.preset;
+    if (overridePatch)
     {
-        const preset = channelObject.preset;
-        /**
-         * @returns {WorkletVoice[]}
-         */
-        workletVoices = preset.getSamplesAndGenerators(midiNote, velocity)
-            .reduce((voices, sampleAndGenerators) =>
+        canCache = false;
+        const patchNum = this.keyModifierManager.getPatch(channel, midiNote);
+        preset = this.soundfontManager.getPreset(patchNum.bank, patchNum.program);
+    }
+    /**
+     * @returns {WorkletVoice[]}
+     */
+    workletVoices = preset.getSamplesAndGenerators(midiNote, velocity)
+        .reduce((voices, sampleAndGenerators) =>
+        {
+            if (sampleAndGenerators.sample.sampleData === undefined)
             {
-                if (sampleAndGenerators.sample.sampleData === undefined)
-                {
-                    SpessaSynthWarn(`Discarding invalid sample: ${sampleAndGenerators.sample.sampleName}`);
-                    return voices;
-                }
-                
-                // create the generator list
-                const generators = new Int16Array(60);
-                // apply and sum the gens
-                for (let i = 0; i < 60; i++)
-                {
-                    generators[i] = addAndClampGenerator(
-                        i,
-                        sampleAndGenerators.presetGenerators,
-                        sampleAndGenerators.instrumentGenerators
-                    );
-                }
-                
-                // !! EMU initial attenuation correction, multiply initial attenuation by 0.4
-                generators[generatorTypes.initialAttenuation] = Math.floor(generators[generatorTypes.initialAttenuation] * 0.4);
-                
-                // key override
-                let rootKey = sampleAndGenerators.sample.samplePitch;
-                if (generators[generatorTypes.overridingRootKey] > -1)
-                {
-                    rootKey = generators[generatorTypes.overridingRootKey];
-                }
-                
-                let targetKey = midiNote;
-                if (generators[generatorTypes.keyNum] > -1)
-                {
-                    targetKey = generators[generatorTypes.keyNum];
-                }
-                
-                // determine looping mode now. if the loop is too small, disable
-                let loopStart = sampleAndGenerators.sample.sampleLoopStartIndex;
-                let loopEnd = sampleAndGenerators.sample.sampleLoopEndIndex;
-                let loopingMode = generators[generatorTypes.sampleModes];
-                /**
-                 * create the worklet sample
-                 * offsets are calculated at note on time (to allow for modulation of them)
-                 * @type {WorkletSample}
-                 */
-                const workletSample = new WorkletSample(
-                    sampleAndGenerators.sample.getAudioData(),
-                    (sampleAndGenerators.sample.sampleRate / sampleRate) * Math.pow(
-                        2,
-                        sampleAndGenerators.sample.samplePitchCorrection / 1200
-                    ), // cent tuning
-                    0,
-                    rootKey,
-                    loopStart,
-                    loopEnd,
-                    Math.floor(sampleAndGenerators.sample.sampleData.length) - 1,
-                    loopingMode
-                );
-                // velocity override
-                if (generators[generatorTypes.velocity] > -1)
-                {
-                    velocity = generators[generatorTypes.velocity];
-                }
-                
-                if (debug)
-                {
-                    SpessaSynthTable([{
-                        Sample: sampleAndGenerators.sample.sampleName,
-                        Generators: generators,
-                        Modulators: sampleAndGenerators.modulators.map(m => m.debugString()),
-                        Velocity: velocity,
-                        TargetKey: targetKey,
-                        MidiNote: midiNote,
-                        WorkletSample: workletSample
-                    }]);
-                }
-                
-                
-                voices.push(
-                    new WorkletVoice(
-                        sampleRate,
-                        workletSample,
-                        midiNote,
-                        velocity,
-                        channel,
-                        currentTime,
-                        targetKey,
-                        realKey,
-                        generators,
-                        sampleAndGenerators.modulators.map(m => Modulator.copy(m))
-                    )
-                );
+                SpessaSynthWarn(`Discarding invalid sample: ${sampleAndGenerators.sample.sampleName}`);
                 return voices;
-            }, []);
-        // cache the voice
+            }
+            
+            // create the generator list
+            const generators = new Int16Array(60);
+            // apply and sum the gens
+            for (let i = 0; i < 60; i++)
+            {
+                generators[i] = addAndClampGenerator(
+                    i,
+                    sampleAndGenerators.presetGenerators,
+                    sampleAndGenerators.instrumentGenerators
+                );
+            }
+            
+            // !! EMU initial attenuation correction, multiply initial attenuation by 0.4
+            generators[generatorTypes.initialAttenuation] = Math.floor(generators[generatorTypes.initialAttenuation] * 0.4);
+            
+            // key override
+            let rootKey = sampleAndGenerators.sample.samplePitch;
+            if (generators[generatorTypes.overridingRootKey] > -1)
+            {
+                rootKey = generators[generatorTypes.overridingRootKey];
+            }
+            
+            let targetKey = midiNote;
+            if (generators[generatorTypes.keyNum] > -1)
+            {
+                targetKey = generators[generatorTypes.keyNum];
+            }
+            
+            // determine looping mode now. if the loop is too small, disable
+            let loopStart = sampleAndGenerators.sample.sampleLoopStartIndex;
+            let loopEnd = sampleAndGenerators.sample.sampleLoopEndIndex;
+            let loopingMode = generators[generatorTypes.sampleModes];
+            /**
+             * create the worklet sample
+             * offsets are calculated at note on time (to allow for modulation of them)
+             * @type {WorkletSample}
+             */
+            const workletSample = new WorkletSample(
+                sampleAndGenerators.sample.getAudioData(),
+                (sampleAndGenerators.sample.sampleRate / sampleRate) * Math.pow(
+                    2,
+                    sampleAndGenerators.sample.samplePitchCorrection / 1200
+                ), // cent tuning
+                0,
+                rootKey,
+                loopStart,
+                loopEnd,
+                Math.floor(sampleAndGenerators.sample.sampleData.length) - 1,
+                loopingMode
+            );
+            // velocity override
+            if (generators[generatorTypes.velocity] > -1)
+            {
+                velocity = generators[generatorTypes.velocity];
+            }
+            
+            if (debug)
+            {
+                SpessaSynthTable([{
+                    Sample: sampleAndGenerators.sample.sampleName,
+                    Generators: generators,
+                    Modulators: sampleAndGenerators.modulators.map(m => m.debugString()),
+                    Velocity: velocity,
+                    TargetKey: targetKey,
+                    MidiNote: midiNote,
+                    WorkletSample: workletSample
+                }]);
+            }
+            
+            
+            voices.push(
+                new WorkletVoice(
+                    sampleRate,
+                    workletSample,
+                    midiNote,
+                    velocity,
+                    channel,
+                    currentTime,
+                    targetKey,
+                    realKey,
+                    generators,
+                    sampleAndGenerators.modulators.map(m => Modulator.copy(m))
+                )
+            );
+            return voices;
+        }, []);
+    // cache the voice
+    if (canCache)
+    {
         channelObject.cachedVoices[midiNote][velocity] = workletVoices.map(v => WorkletVoice.copy(v, currentTime));
     }
     return workletVoices;