spessasynth_lib 3.12.0 → 3.12.3

package/synthetizer/worklet_system/main_processor.js

@@ -22,6 +22,7 @@ import {
     transposeChannel,
 } from './worklet_methods/tuning_control.js'
 import {
+    clearSoundFont, getPreset,
     programChange,
     reloadSoundFont,
     sampleDump,
@@ -114,6 +115,12 @@ class SpessaSynthProcessor extends AudioWorkletProcessor {
 
         this.highPerformanceMode = false;
 
+        /**
+         * Overrides the main soundfont (embedded for example
+         * @type {SoundFont2}
+         */
+        this.overrideSoundfont = undefined;
+
         /**
          * the pan of the right channel
          * @type {number}
@@ -136,8 +143,8 @@ class SpessaSynthProcessor extends AudioWorkletProcessor {
         }
         this.sendPresetList();
 
-        this.defaultPreset = this.soundfont.getPreset(0, 0);
-        this.drumPreset = this.soundfont.getPreset(128, 0);
+        this.defaultPreset = this.getPreset(0, 0);
+        this.drumPreset = this.getPreset(128, 0);
 
         /**
          * @type {Float32Array[]}
@@ -355,9 +362,11 @@ SpessaSynthProcessor.prototype.pitchWheel = pitchWheel;
 
 // program related
 SpessaSynthProcessor.prototype.programChange = programChange;
+SpessaSynthProcessor.prototype.getPreset = getPreset;
 SpessaSynthProcessor.prototype.setPreset = setPreset;
 SpessaSynthProcessor.prototype.setDrums = setDrums;
 SpessaSynthProcessor.prototype.reloadSoundFont = reloadSoundFont;
+SpessaSynthProcessor.prototype.clearSoundFont = clearSoundFont;
 SpessaSynthProcessor.prototype.sampleDump = sampleDump;
 SpessaSynthProcessor.prototype.sendPresetList = sendPresetList;
 

package/synthetizer/worklet_system/worklet_methods/note_on.js

@@ -21,16 +21,17 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
         return;
     }
 
+    const channelObject = this.workletProcessorChannels[channel]
     if (
         (this.highPerformanceMode && this.totalVoicesAmount > 200 && velocity < 40) ||
         (this.highPerformanceMode && velocity < 10) ||
-        (this.workletProcessorChannels[channel].isMuted)
+        (channelObject.isMuted)
     )
     {
         return;
     }
 
-    midiNote += this.workletProcessorChannels[channel].channelTransposeKeyShift;
+    midiNote += channelObject.channelTransposeKeyShift;
 
     if(midiNote > 127 || midiNote < 0)
     {
@@ -42,16 +43,21 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
         channel,
         midiNote,
         velocity,
-        this.workletProcessorChannels[channel].preset,
+        channelObject.preset,
         startTime,
         sampleRate,
-        data => this.sampleDump(data.channel, data.sampleID, data.sampleData),
-        this.workletProcessorChannels[channel].cachedVoices,
+        data => this.sampleDump(
+            data.channel,
+            data.sampleID,
+            data.sampleData
+        ),
+        channelObject.cachedVoices,
+        channelObject.presetUsesOverride ? this.soundfont.samples.length : 0, // this is done to prevent samples overlapping
         enableDebugging
     );
 
     // add voices and exclusive class apply
-    const channelVoices = this.workletProcessorChannels[channel].voices;
+    const channelVoices = channelObject.voices;
     voices.forEach(voice => {
         const exclusive = voice.generators[generatorTypes.exclusiveClass];
         if(exclusive !== 0)
@@ -67,7 +73,7 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
             })
         }
         // compute all modulators
-        computeModulators(voice, this.workletProcessorChannels[channel].midiControllers);
+        computeModulators(voice, channelObject.midiControllers);
         // set initial pan to avoid split second changing from middle to the correct value
         voice.currentPan = ((Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan] )) + 500) / 1000) // 0 to 1
     });
@@ -83,7 +89,7 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
     {
         this.sendChannelProperties();
         this.callEvent("noteon", {
-            midiNote: midiNote - this.workletProcessorChannels[channel].channelTransposeKeyShift,
+            midiNote: midiNote - channelObject.channelTransposeKeyShift,
             channel: channel,
             velocity: velocity,
         });

package/synthetizer/worklet_system/worklet_methods/program_control.js

@@ -24,18 +24,67 @@ export function programChange(channel, programNumber, userChange=false)
         return;
     }
     // always 128 for percussion
-    const bankWithOffset = Math.max(0, channelObject.midiControllers[midiControllers.bankSelect] - this.soundfontBankOffset);
-    const bank = channelObject.drumChannel ? 128 : bankWithOffset;
-    const preset = this.soundfont.getPreset(bank, programNumber);
+    const bank = channelObject.drumChannel ? 128 : channelObject.midiControllers[midiControllers.bankSelect];
+    let sentBank;
+    let preset;
+
+    // check if override
+    if(this.overrideSoundfont)
+    {
+        const bankWithOffset = bank === 128 ? 128 : Math.max(0, bank - this.soundfontBankOffset);
+        const p = this.overrideSoundfont.presets.find(p => p.program === programNumber && p.bank === bankWithOffset);
+        if(p)
+        {
+            sentBank = bank;
+            preset = p;
+            channelObject.presetUsesOverride = true;
+        }
+        else
+        {
+            preset = this.soundfont.getPreset(bank, programNumber);
+            sentBank = preset.bank;
+            channelObject.presetUsesOverride = false;
+        }
+    }
+    else
+    {
+        preset = this.soundfont.getPreset(bank, programNumber);
+        sentBank = preset.bank;
+        channelObject.presetUsesOverride = false;
+    }
+
     this.setPreset(channel, preset);
     this.callEvent("programchange",{
         channel: channel,
         program: preset.program,
-        bank: preset.bank,
+        bank: sentBank,
         userCalled: userChange
     });
 }
 
+/**
+ * @this {SpessaSynthProcessor}
+ * @param program {number}
+ * @param bank {number}
+ * @returns {Preset}
+ */
+export function getPreset(bank, program)
+{
+    if(this.overrideSoundfont)
+    {
+        // if overriden soundfont
+        const bankWithOffset = bank === 128 ? 128 : Math.max(0, bank - this.soundfontBankOffset);
+        const preset = this.overrideSoundfont.presets.find(p => p.program === program && p.bank === bankWithOffset);
+        if(preset)
+        {
+            return preset;
+        }
+    }
+    return this.soundfont.getPreset(bank, program);
+}
+
+
+
 /**
  * @param channel {number}
  * @param preset {Preset}
@@ -51,7 +100,8 @@ export function setPreset(channel, preset)
 
     // reset cached voices
     this.workletProcessorChannels[channel].cachedVoices = [];
-    for (let i = 0; i < 128; i++) {
+    for (let i = 0; i < 128; i++)
+    {
         this.workletProcessorChannels[channel].cachedVoices.push([]);
     }
 }
@@ -78,13 +128,14 @@ export function setDrums(channel, isDrum)
         // clear transpose
         channelObject.channelTransposeKeyShift = 0;
         channelObject.drumChannel = true;
-        this.setPreset(channel, this.soundfont.getPreset(128, channelObject.preset.program));
+        this.setPreset(channel, this.getPreset(128, channelObject.preset.program));
     }
     else
     {
         channelObject.drumChannel = false;
-        this.setPreset(channel, this.soundfont.getPreset(channelObject.midiControllers[midiControllers.bankSelect], channelObject.preset.program));
+        this.setPreset(channel, this.getPreset(channelObject.midiControllers[midiControllers.bankSelect], channelObject.preset.program));
     }
+    channelObject.presetUsesOverride = false;
     this.callEvent("drumchange",{
         channel: channel,
         isDrumChannel: channelObject.drumChannel
@@ -97,37 +148,44 @@ export function setDrums(channel, isDrum)
  */
 export function sendPresetList()
 {
-    this.callEvent("presetlistchange", this.soundfont.presets.map(p => {
+    const mainFont =  this.soundfont.presets.map(p => {
         return {presetName: p.presetName, bank: p.bank, program: p.program};
-    }));
+    });
+    if(this.overrideSoundfont !== undefined)
+    {
+        this.overrideSoundfont.presets.forEach(p => {
+            const bankCheck = p.bank === 128 ? 128 : p.bank + this.soundfontBankOffset;
+            const exists = mainFont.find(pr => pr.bank === bankCheck && pr.program === p.program);
+            if(exists !== undefined)
+            {
+                exists.presetName = p.presetName;
+            }
+            else
+            {
+                mainFont.push({presetName: p.presetName, bank: bankCheck, program: p.program});
+            }
+        });
+    }
+    this.callEvent("presetlistchange", mainFont);
 }
 
 /**
- * @param buffer {ArrayBuffer}
  * @this {SpessaSynthProcessor}
+ * @param sendPresets {boolean}
+ * @param clearOverride {boolean}
  */
-export function reloadSoundFont(buffer)
+export function clearSoundFont(sendPresets = true, clearOverride = true)
 {
     this.stopAllChannels(true);
-    delete this.soundfont;
-
-
-    try {
-        this.soundfont = new SoundFont2(buffer);
-    }
-    catch (e)
+    clearSamplesList();
+    if(clearOverride)
     {
-        this.post({
-            messageType: returnMessageType.soundfontError,
-            messageData: e
-        });
-        return;
+        delete this.overrideSoundfont;
     }
-    clearSamplesList();
     delete this.workletDumpedSamplesList;
     this.workletDumpedSamplesList = [];
-    this.defaultPreset = this.soundfont.getPreset(0, 0);
-    this.drumPreset = this.soundfont.getPreset(128, 0);
+    this.defaultPreset = this.getPreset(0, 0);
+    this.drumPreset = this.getPreset(128, 0);
 
     for(let i = 0; i < this.workletProcessorChannels.length; i++)
     {
@@ -140,6 +198,43 @@ export function reloadSoundFont(buffer)
         channelObject.lockPreset = false;
         this.programChange(i, channelObject.preset.program);
     }
+    if(sendPresets)
+    {
+        this.sendPresetList();
+    }
+}
+
+/**
+ * @param buffer {ArrayBuffer}
+ * @param isOverride {Boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function reloadSoundFont(buffer, isOverride = false)
+{
+    this.clearSoundFont(false, isOverride);
+    if(!isOverride)
+    {
+        delete this.soundfont;
+    }
+    try
+    {
+        if(isOverride)
+        {
+            this.overrideSoundfont = new SoundFont2(buffer);
+        }
+        else
+        {
+            this.soundfont = new SoundFont2(buffer);
+        }
+    }
+    catch (e)
+    {
+        this.post({
+            messageType: returnMessageType.soundfontError,
+            messageData: e
+        });
+        return;
+    }
     this.post({messageType: returnMessageType.ready, messageData: undefined});
     this.sendPresetList();
     SpessaSynthInfo("%cSpessaSynth is ready!", consoleColors.recognized);

package/synthetizer/worklet_system/worklet_methods/reset_controllers.js

@@ -29,6 +29,7 @@ export function resetAllControllers()
         // if preset is unlocked, switch to non drums and call event
         if(!ch.lockPreset)
         {
+            ch.presetUsesOverride = true;
             ch.midiControllers[midiControllers.bankSelect] = 0;
             if (channelNumber % 16 === DEFAULT_PERCUSSION)
             {

package/synthetizer/worklet_system/worklet_utilities/wavetable_oscillator.js

@@ -69,6 +69,10 @@ export function getOscillatorData(voice, sampleData, outputBuffer)
                 return;
             }
 
+            // cur += voice.sample.playbackStep * voice.currentTuningCalculated;
+            // outputBuffer[i] = sampleData[ceil];
+            // continue;
+
             const fraction = cur - floor;
 
             // grab the samples and interpolate

package/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js

@@ -17,6 +17,7 @@ import { modulatorSources } from '../../../soundfont/read/modulators.js'
  *
  * @property {Preset} preset - the channel's preset
  * @property {boolean} lockPreset - indicates whether the program on the channel is locked
+ * @property {boolean} presetUsesOverride - indcates if the channel uses a preset from the override soundfont.
  *
  * @property {boolean} lockVibrato - indicates whether the custom vibrato is locked
  * @property {Object} channelVibrato - vibrato settings for the channel
@@ -53,6 +54,7 @@ export function createWorkletChannel(sendEvent = false)
         sustainedVoices: [],
         cachedVoices: [],
         preset: this.defaultPreset,
+        presetUsesOverride: false,
 
         channelTransposeKeyShift: 0,
         channelVibrato: {delay: 0, depth: 0, rate: 0},

package/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -126,6 +126,7 @@ function deepClone(obj) {
  * @param sampleRate {number}
  * @param sampleDumpCallback {function({channel: number, sampleID: number, sampleData: Float32Array})}
  * @param cachedVoices {WorkletVoice[][][]} first is midi note, second is velocity. output is an array of WorkletVoices
+ * @param sampleIDOffset {number}
  * @param debug {boolean}
  * @returns {WorkletVoice[]}
  */
@@ -137,6 +138,7 @@ export function getWorkletVoices(channel,
                                  sampleRate,
                                  sampleDumpCallback,
                                  cachedVoices,
+                                 sampleIDOffset,
                                  debug=false)
 {
     /**
@@ -159,9 +161,10 @@ export function getWorkletVoices(channel,
          */
         workletVoices = preset.getSamplesAndGenerators(midiNote, velocity).reduce((voices, sampleAndGenerators) => {
             // dump the sample if haven't already
-            if (globalDumpedSamplesList[sampleAndGenerators.sampleID] !== true)
+            const sampleID = sampleAndGenerators.sampleID + sampleIDOffset;
+            if (globalDumpedSamplesList[sampleID] !== true)
             {
-                dumpSample(channel, sampleAndGenerators.sample, sampleAndGenerators.sampleID, sampleDumpCallback);
+                dumpSample(channel, sampleAndGenerators.sample, sampleID, sampleDumpCallback);
             }
             if(sampleAndGenerators.sample.sampleData === undefined)
             {
@@ -205,7 +208,7 @@ export function getWorkletVoices(channel,
              * @type {WorkletSample}
              */
             const workletSample = {
-                sampleID: sampleAndGenerators.sampleID,
+                sampleID: sampleID,
                 playbackStep: (sampleAndGenerators.sample.sampleRate / sampleRate) * Math.pow(2, sampleAndGenerators.sample.samplePitchCorrection / 1200),// cent tuning
                 cursor: generators[generatorTypes.startAddrsOffset] + (generators[generatorTypes.startAddrsCoarseOffset] * 32768),
                 rootKey: rootKey,