spessasynth_lib 3.20.35 → 3.20.40

package/synthetizer/worklet_system/main_processor.js

@@ -49,7 +49,9 @@ import { getWorkletVoices } from './worklet_utilities/worklet_voice.js'
  * purpose: manages the synthesizer (and worklet sequencer) from the AudioWorkletGlobalScope and renders the audio data
  */
 
-export const MIN_NOTE_LENGTH = 0.07; // if the note is released faster than that, it forced to last that long
+// if the note is released faster than that, it forced to last that long
+// this is used mostly for drum channels, where a lot of midis like to send instant note off after a note on
+export const MIN_NOTE_LENGTH = 0.03;
 
 export const SYNTHESIZER_GAIN = 1.0;
 
@@ -84,7 +86,7 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
          * Interpolation type used
          * @type {interpolationTypes}
          */
-        this.interpolationType = interpolationTypes.linear;
+        this.interpolationType = interpolationTypes.fourthOrder;
 
         /**
          * @type {function}

package/synthetizer/worklet_system/worklet_methods/controller_control.js

@@ -1,6 +1,6 @@
 import { consoleColors } from '../../../utils/other.js'
 import { midiControllers } from '../../../midi_parser/midi_message.js'
-import { dataEntryStates } from '../worklet_utilities/worklet_processor_channel.js'
+import { channelConfiguration, dataEntryStates } from '../worklet_utilities/worklet_processor_channel.js'
 import { computeModulators } from '../worklet_utilities/worklet_modulator.js'
 import { SpessaSynthInfo, SpessaSynthWarn } from '../../../utils/loggin.js'
 import { SYNTHESIZER_GAIN } from '../main_processor.js'
@@ -8,7 +8,7 @@ import { DEFAULT_PERCUSSION } from '../../synthetizer.js'
 
 /**
  * @param channel {number}
- * @param controllerNumber {midiControllers}
+ * @param controllerNumber {number}
  * @param controllerValue {number}
  * @param force {boolean}
  * @this {SpessaSynthProcessor}
@@ -24,6 +24,19 @@ export function controllerChange(channel, controllerNumber, controllerValue, for
         SpessaSynthWarn(`Trying to access channel ${channel} which does not exist... ignoring!`);
         return;
     }
+    if(controllerNumber > 127)
+    {
+        // channel configuration. force must be set to true
+        if(!force) return;
+        switch (controllerNumber)
+        {
+            default:
+                return;
+
+            case channelConfiguration.velocityOverride:
+                channelObject.velocityOverride = controllerValue;
+        }
+    }
     // lsb controller values: append them as the lower nibble of the 14 bit value
     // excluding bank select and data entry as it's handled separately
     if(

package/synthetizer/worklet_system/worklet_methods/note_on.js

@@ -43,6 +43,12 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
         sentMidiNote = this.tunings[program]?.[midiNote].midiNote;
     }
 
+    // velocity override
+    if(channelObject.velocityOverride > 0)
+    {
+        velocity = channelObject.velocityOverride;
+    }
+
     // get voices
     const voices = this.getWorkletVoices(
         channel,
@@ -59,6 +65,7 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
         const exclusive = voice.generators[generatorTypes.exclusiveClass];
         if(exclusive !== 0)
         {
+            // kill all voices with the same exclusive class
             channelVoices.forEach(v => {
                 if(v.generators[generatorTypes.exclusiveClass] === exclusive)
                 {
@@ -72,7 +79,33 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
         }
         // compute all modulators
         computeModulators(voice, channelObject.midiControllers);
-        WorkletVolumeEnvelope.intialize(voice);
+        // modulate sample offsets (these are not real time)
+        const cursorStartOffset = voice.modulatedGenerators[generatorTypes.startAddrsOffset] + voice.modulatedGenerators[generatorTypes.startAddrsCoarseOffset] * 32768;
+        const endOffset = voice.modulatedGenerators[generatorTypes.endAddrOffset] + voice.modulatedGenerators[generatorTypes.endAddrsCoarseOffset] * 32768;
+        const loopStartOffset = voice.modulatedGenerators[generatorTypes.startloopAddrsOffset] + voice.modulatedGenerators[generatorTypes.startloopAddrsCoarseOffset] * 32768;
+        const loopEndOffset = voice.modulatedGenerators[generatorTypes.endloopAddrsOffset] + voice.modulatedGenerators[generatorTypes.endloopAddrsCoarseOffset] * 32768;
+        const sm = voice.sample;
+        // apply them
+        const clamp = num => Math.max(0, Math.min(sm.sampleData.length - 1, num));
+        sm.cursor = clamp( sm.cursor + cursorStartOffset);
+        sm.end = clamp(sm.end + endOffset);
+        sm.loopStart = clamp(sm.loopStart + loopStartOffset);
+        sm.loopEnd = clamp(sm.loopEnd + loopEndOffset);
+        // swap loops if needed
+        if(sm.loopEnd < sm.loopStart)
+        {
+            const temp = sm.loopStart;
+            sm.loopStart = sm.loopEnd;
+            sm.loopEnd = temp;
+        }
+        if (sm.loopEnd - sm.loopStart < 1)
+        {
+            sm.loopingMode = 0;
+            sm.isLooping = false;
+        }
+        // set the current attenuation to target,
+        // as it's interpolated (we don't want 0 attenuation for even a split second)
+        voice.volumeEnvelope.attenuation = voice.volumeEnvelope.attenuationTarget;
         // 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
     });

package/synthetizer/worklet_system/worklet_methods/voice_control.js

@@ -4,6 +4,7 @@ import { getLFOValue } from '../worklet_utilities/lfo.js'
 import { customControllers } from '../worklet_utilities/worklet_processor_channel.js'
 import { WorkletModulationEnvelope } from '../worklet_utilities/modulation_envelope.js'
 import {
+    getSampleCubic,
     getSampleLinear,
     getSampleNearest,
     interpolationTypes,
@@ -15,7 +16,7 @@ import { WorkletVolumeEnvelope } from '../worklet_utilities/volume_envelope.js'
 
 
 const HALF_PI = Math.PI / 2;
-export const PAN_SMOOTHING_FACTOR = 0.01;
+export const PAN_SMOOTHING_FACTOR = 0.05;
 /**
  * Renders a voice to the stereo output buffer
  * @param channel {WorkletProcessorChannel} the voice's channel
@@ -40,10 +41,14 @@ export function renderVoice(
         // if not in release, check if the release time is
         if (currentTime >= voice.releaseStartTime)
         {
-
+            // release the voice here
             voice.isInRelease = true;
             WorkletVolumeEnvelope.startRelease(voice);
             WorkletModulationEnvelope.startRelease(voice);
+            if(voice.sample.loopingMode === 3)
+            {
+                voice.sample.isLooping = false;
+            }
         }
     }
 
@@ -163,6 +168,9 @@ export function renderVoice(
         case interpolationTypes.nearestNeighbor:
             getSampleNearest(voice, bufferOut);
             break;
+
+        case interpolationTypes.fourthOrder:
+            getSampleCubic(voice, bufferOut);
     }
 
     // lowpass filter
@@ -264,8 +272,4 @@ export function releaseVoice(voice)
     {
         voice.releaseStartTime = voice.startTime + MIN_NOTE_LENGTH;
     }
-    if(voice.sample.loopingMode === 3)
-    {
-        voice.sample.isLooping = false;
-    }
 }

package/synthetizer/worklet_system/worklet_utilities/lowpass_filter.js

@@ -140,10 +140,7 @@ export class WorkletLowpassFilter
         filter.cutoffHz = absCentsToHz(filter.cutoffCents);
 
         // fix cutoff on low frequencies (fluid_iir_filter.c line 392)
-        if(filter.cutoffHz > 0.45 * sampleRate)
-        {
-            filter.cutoffHz = 0.45 * sampleRate;
-        }
+        filter.cutoffHz = Math.min(filter.cutoffHz, 0.45 * sampleRate);
 
         // adjust the filterQ (fluid_iir_filter.c line 204)
         const qDb = (filter.reasonanceCb / 10) - 3.01;

package/synthetizer/worklet_system/worklet_utilities/volume_envelope.js

@@ -10,7 +10,8 @@ export const VOLUME_ENVELOPE_SMOOTHING_FACTOR = 0.001;
 
 const DB_SILENCE = 100;
 const PERCEIVED_DB_SILENCE = 90;
-const PERCEIVED_GAIN_SILENCE = 0.005;
+// around 96 dB of attenuation
+const PERCEIVED_GAIN_SILENCE = 0.000015; // can't go lower than that (see #50)
 
 /**
  * VOL ENV STATES:
@@ -147,22 +148,11 @@ export class WorkletVolumeEnvelope
         WorkletVolumeEnvelope.recalculate(voice);
     }
 
-    /**
-     * Initializes a volume envelope
-     * @param voice {WorkletVoice}
-     */
-    static intialize(voice)
-    {
-        WorkletVolumeEnvelope.recalculate(voice, true);
-        voice.volumeEnvelope.attenuation = voice.volumeEnvelope.attenuationTarget;
-    }
-
     /**
      * Recalculates the envelope
      * @param voice {WorkletVoice} the voice this envelope belongs to
-     * @param setupInterpolated {boolean} if we should initialize the interpolated values (attenuation and sustain)
      */
-    static recalculate(voice, setupInterpolated = false)
+    static recalculate(voice)
     {
         const env = voice.volumeEnvelope;
         const timecentsToSamples = tc =>
@@ -172,10 +162,6 @@ export class WorkletVolumeEnvelope
         // calculate absolute times (they can change so we have to recalculate every time
         env.attenuationTarget = Math.max(0, Math.min(voice.modulatedGenerators[generatorTypes.initialAttenuation], 1440)) / 10; // divide by ten to get decibels
         env.sustainDbRelative = Math.min(DB_SILENCE, voice.modulatedGenerators[generatorTypes.sustainVolEnv] / 10);
-        if(setupInterpolated)
-        {
-            env.attenuation = env.attenuationTarget;
-        }
         const sustainDb = Math.min(DB_SILENCE, env.sustainDbRelative);
 
         // calculate durations

package/synthetizer/worklet_system/worklet_utilities/wavetable_oscillator.js

@@ -57,11 +57,6 @@ export function getSampleLinear(voice, outputBuffer)
     }
     else
     {
-        // check and correct end errors
-        if(sample.end >= sampleData.length)
-        {
-            sample.end = sampleData.length - 1;
-        }
         for (let i = 0; i < outputBuffer.length; i++)
         {
 
@@ -124,11 +119,6 @@ export function getSampleNearest(voice, outputBuffer)
     }
     else
     {
-        // check and correct end errors
-        if(sample.end >= sampleData.length)
-        {
-            sample.end = sampleData.length - 1;
-        }
         for (let i = 0; i < outputBuffer.length; i++)
         {
 
@@ -148,4 +138,98 @@ export function getSampleNearest(voice, outputBuffer)
         }
     }
     sample.cursor = cur;
+}
+
+
+
+/**
+ * Fills the output buffer with raw sample data using cubic interpolation
+ * @param voice {WorkletVoice} the voice we're working on
+ * @param outputBuffer {Float32Array} the output buffer to write to
+ */
+export function getSampleCubic(voice, outputBuffer)
+{
+    const sample = voice.sample;
+    let cur = sample.cursor;
+    const sampleData = sample.sampleData;
+
+    if(sample.isLooping)
+    {
+        const loopLength = sample.loopEnd - sample.loopStart;
+        for (let i = 0; i < outputBuffer.length; i++)
+        {
+            // check for loop
+            while(cur >= sample.loopEnd)
+            {
+                cur -= loopLength;
+            }
+
+            // math comes from
+            // https://stackoverflow.com/questions/1125666/how-do-you-do-bicubic-or-other-non-linear-interpolation-of-re-sampled-audio-da
+
+            // grab the 4 points
+            const y0 = ~~cur;   // point before the cursor. twice bitwise not is just a faster Math.floor
+            let y1 = y0 + 1;    // point after the cursor
+            let y2 = y1 + 1;    // point 1 after the cursor
+            let y3 = y2 + 1;    // point 2 after the cursor
+            const t = cur - y0; // distance from y0 to cursor
+            // y0 is not handled here
+            // as it's math.floor of cur which is handled above
+            if(y1 >= sample.loopEnd) y1 -= loopLength;
+            if(y2 >= sample.loopEnd) y2 -= loopLength;
+            if(y3 >= sample.loopEnd) y3 -= loopLength;
+
+            // grab the samples
+            const x0 = sampleData[y0];
+            const x1 = sampleData[y1];
+            const x2 = sampleData[y2];
+            const x3 = sampleData[y3];
+
+            // interpolate
+            // const c0 = x1
+            const c1 = 0.5 * (x2 - x0);
+            const c2 = x0 - (2.5 * x1) + (2 * x2) - (0.5 * x3);
+            const c3 = (0.5 * (x3 - x0)) + (1.5 * (x1 - x2));
+            outputBuffer[i] = (((((c3 * t) + c2) * t) + c1) * t) + x1;
+
+
+            cur += sample.playbackStep * voice.currentTuningCalculated;
+        }
+    }
+    else
+    {
+        for (let i = 0; i < outputBuffer.length; i++)
+        {
+
+            // math comes from
+            // https://stackoverflow.com/questions/1125666/how-do-you-do-bicubic-or-other-non-linear-interpolation-of-re-sampled-audio-da
+
+            // grab the 4 points
+            const y0 = ~~cur;   // point before the cursor. twice bitwise not is just a faster Math.floor
+            let y1 = y0 + 1;    // point after the cursor
+            let y2 = y1 + 1;    // point 1 after the cursor
+            let y3 = y2 + 1;    // point 2 after the cursor
+            const t = cur - y0; // distance from y0 to cursor
+
+            // flag as finished if needed
+            if(y1 >= sample.end ||
+            y2 >= sample.end ||
+            y3 >= sample.end) {voice.finished = true; return;}
+
+            // grab the samples
+            const x0 = sampleData[y0];
+            const x1 = sampleData[y1];
+            const x2 = sampleData[y2];
+            const x3 = sampleData[y3];
+
+            // interpolate
+            const c1 = 0.5 * (x2 - x0);
+            const c2 = x0 - (2.5 * x1) + (2 * x2) - (0.5 * x3);
+            const c3 = (0.5 * (x3 - x0)) + (1.5 * (x1 - x2));
+            outputBuffer[i] = (((((c3 * t) + c2) * t) + c1) * t) + x1;
+
+            cur += sample.playbackStep * voice.currentTuningCalculated;
+        }
+    }
+    voice.sample.cursor = cur;
 }

package/synthetizer/worklet_system/worklet_utilities/worklet_modulator.js

@@ -1,4 +1,4 @@
-import { modulatorSources } from '../../../soundfont/read_sf2/modulators.js'
+import { Modulator, modulatorSources } from '../../../soundfont/read_sf2/modulators.js'
 import { getModulatorCurveValue, MOD_PRECOMPUTED_LENGTH } from './modulator_curves.js'
 import { NON_CC_INDEX_OFFSET } from './worklet_processor_channel.js'
 import { generatorLimits, generatorTypes } from '../../../soundfont/read_sf2/generators.js'
@@ -21,6 +21,7 @@ export function computeWorkletModulator(controllerTable, modulator, voice)
 {
     if(modulator.transformAmount === 0)
     {
+        modulator.currentValue = 0;
         return 0;
     }
     // mapped to 0-16384
@@ -95,13 +96,15 @@ export function computeWorkletModulator(controllerTable, modulator, voice)
 
 
     // compute the modulator
-    const computedValue = sourceValue * secondSrcValue * modulator.transformAmount;
+    let computedValue = sourceValue * secondSrcValue * modulator.transformAmount;
 
     if(modulator.transformType === 2)
     {
         // abs value
-        return Math.abs(computedValue);
+        computedValue = Math.abs(computedValue);
     }
+
+    modulator.currentValue = computedValue;
     return computedValue;
 }
 
@@ -113,9 +116,13 @@ export function computeWorkletModulator(controllerTable, modulator, voice)
  * @param sourceIndex {number} enum for the source
  */
 export function computeModulators(voice, controllerTable, sourceUsesCC = -1, sourceIndex = 0) {
-    const { modulators, generators, modulatedGenerators } = voice;
+    const modulators = voice.modulators;
+    const generators = voice.generators;
+    const modulatedGenerators = voice.modulatedGenerators;
 
     // Modulation envelope is cheap to recalculate
+    // why here and not at the bottom?
+    // I dunno, seems to work fine
     WorkletModulationEnvelope.recalculate(voice);
 
     if (sourceUsesCC === -1)
@@ -156,13 +163,14 @@ export function computeModulators(voice, controllerTable, sourceUsesCC = -1, sou
             {
                 // Reset this destination
                 modulatedGenerators[destination] = generators[destination];
-                // Compute all modulators for this destination
+                // compute our modulator
+                computeWorkletModulator(controllerTable, mod, voice);
+                // sum the values of all modulators for this destination
                 modulators.forEach(m => {
                     if (m.modulatorDestination === destination)
                     {
                         const limits = generatorLimits[mod.modulatorDestination];
-                        const current = modulatedGenerators[mod.modulatorDestination];
-                        const newValue = current + computeWorkletModulator(controllerTable, m, voice);
+                        const newValue = modulatedGenerators[mod.modulatorDestination] + m.currentValue;
                         modulatedGenerators[mod.modulatorDestination] = Math.max(limits.min, Math.min(newValue, limits.max));
                     }
                 });

package/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js

@@ -11,6 +11,7 @@ import { modulatorSources } from '../../../soundfont/read_sf2/modulators.js'
  * @property {Int16Array} keyCentTuning - tuning of individual keys in cents
  * @property {boolean} holdPedal - indicates whether the hold pedal is active
  * @property {boolean} drumChannel - indicates whether the channel is a drum channel
+ * @property {number} velocityOverride - overrides velocity if > 0 otherwise disabled
  *
  * @property {dataEntryStates} dataEntryState - the current state of the data entry
  * @property {number} NRPCoarse - the current coarse value of the Non-Registered Parameter
@@ -62,6 +63,8 @@ export function createWorkletChannel(sendEvent = false)
         channelOctaveTuning: new Int8Array(12),
         keyCentTuning: new Int16Array(128),
         channelVibrato: {delay: 0, depth: 0, rate: 0},
+        velocityOverride: 0,
+
         lockGSNRPNParams: false,
         holdPedal: false,
         isMuted: false,
@@ -92,6 +95,7 @@ resetArray[midiControllers.expressionController] = 127 << 7;
 resetArray[midiControllers.pan] = 64 << 7;
 resetArray[midiControllers.releaseTime] = 64 << 7;
 resetArray[midiControllers.brightness] = 64 << 7;
+resetArray[midiControllers.timbreHarmonicContent] = 64 << 7;
 resetArray[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel] = 8192;
 resetArray[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = 2 << 7;
 
@@ -119,3 +123,11 @@ export const customControllers = {
 export const CUSTOM_CONTROLLER_TABLE_SIZE = Object.keys(customControllers).length;
 export const customResetArray = new Float32Array(CUSTOM_CONTROLLER_TABLE_SIZE);
 customResetArray[customControllers.modulationMultiplier] = 1;
+
+/**
+ * This is a channel configuration enum, it is internally sent from Synthetizer via controller change
+ * @enum {number}
+ */
+export const channelConfiguration = {
+    velocityOverride: 128, // overrides velocity for the given channel
+}

package/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -3,6 +3,7 @@
  * purpose: prepares workletvoices from sample and generator data and manages sample dumping
  * note: sample dumping means sending it over to the AudioWorkletGlobalScope
  */
+import { Modulator } from '../../../soundfont/read_sf2/modulators.js'
 
 class WorkletSample
 {
@@ -298,7 +299,7 @@ class WorkletVoice
             currentTime,
             voice.targetKey,
             voice.generators,
-            voice.modulators.slice()
+            voice.modulators.map(m => Modulator.copy(m))
         );
     }
 }
@@ -329,7 +330,7 @@ export function getWorkletVoices(channel,
     const cached = channelObject.cachedVoices[midiNote][velocity];
     if(cached !== undefined)
     {
-        workletVoices = cached.map(v => WorkletVoice.copy(v, currentTime));
+        return cached.map(v => WorkletVoice.copy(v, currentTime));
     }
     else
     {
@@ -368,8 +369,8 @@ export function getWorkletVoices(channel,
             }
 
             // determine looping mode now. if the loop is too small, disable
-            let loopStart = (sampleAndGenerators.sample.sampleLoopStartIndex / 2) + (generators[generatorTypes.startloopAddrsOffset] + (generators[generatorTypes.startloopAddrsCoarseOffset] * 32768));
-            let loopEnd = (sampleAndGenerators.sample.sampleLoopEndIndex / 2) + (generators[generatorTypes.endloopAddrsOffset] + (generators[generatorTypes.endloopAddrsCoarseOffset] * 32768));
+            let loopStart = (sampleAndGenerators.sample.sampleLoopStartIndex / 2);
+            let loopEnd = (sampleAndGenerators.sample.sampleLoopEndIndex / 2);
             let loopingMode = generators[generatorTypes.sampleModes];
             const sampleLength = sampleAndGenerators.sample.getAudioData().length;
             // clamp loop
@@ -381,17 +382,18 @@ export function getWorkletVoices(channel,
                 loopingMode = 0;
             }
             /**
-             * create the worklet sample and calculate offsets
+             * 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
-                generators[generatorTypes.startAddrsOffset] + (generators[generatorTypes.startAddrsCoarseOffset] * 32768),
+                0,
                 rootKey,
                 loopStart,
                 loopEnd,
-                Math.floor( sampleAndGenerators.sample.sampleData.length) - 1 + (generators[generatorTypes.endAddrOffset] + (generators[generatorTypes.endAddrsCoarseOffset] * 32768)),
+                Math.floor( sampleAndGenerators.sample.sampleData.length) - 1,
                 loopingMode
             )
             // velocity override
@@ -424,7 +426,7 @@ export function getWorkletVoices(channel,
                     currentTime,
                     targetKey,
                     generators,
-                    sampleAndGenerators.modulators
+                    sampleAndGenerators.modulators.map(m => Modulator.copy(m))
                 )
             );
             return voices;