spessasynth_lib 3.20.34 → 3.20.37

package/synthetizer/worklet_system/main_processor.js

@@ -84,7 +84,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/note_on.js

@@ -59,6 +59,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 +73,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,
@@ -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,11 +162,7 @@ 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 + env.attenuation);
+        const sustainDb = Math.min(DB_SILENCE, env.sustainDbRelative);
 
         // calculate durations
         env.attackDuration = timecentsToSamples(voice.modulatedGenerators[generatorTypes.attackVolEnv]);
@@ -186,7 +172,7 @@ export class WorkletVolumeEnvelope
         // (changing from attenuation to sustain instead of -100dB)
         const fullChange = voice.modulatedGenerators[generatorTypes.decayVolEnv];
         const keyNumAddition = (60 - voice.targetKey) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvDecay];
-        const fraction = (sustainDb - env.attenuation) / DB_SILENCE;
+        const fraction = sustainDb / DB_SILENCE;
         env.decayDuration = timecentsToSamples(fullChange + keyNumAddition) * fraction;
 
         env.releaseDuration = timecentsToSamples(voice.modulatedGenerators[generatorTypes.releaseVolEnv]);
@@ -206,7 +192,7 @@ export class WorkletVolumeEnvelope
         // if this is the first recalculation and the voice has no attack or delay time, set current db to peak
         if(env.state === 0 && env.attackEnd === 0)
         {
-            env.currentAttenuationDb = env.attenuationTarget;
+            // env.currentAttenuationDb = env.attenuationTarget;
             env.state = 2;
         }
 
@@ -214,9 +200,9 @@ export class WorkletVolumeEnvelope
         if(voice.isInRelease)
         {
             // no interpolation this time: force update to actual attenuation and calculate release start from there
-            env.attenuation = Math.min(DB_SILENCE, env.attenuationTarget);
-            const sustainDb = Math.max(0, Math.min(DB_SILENCE, env.sustainDbRelative + env.attenuation));
-            const fraction = (sustainDb - env.attenuation) / DB_SILENCE;
+            //env.attenuation = Math.min(DB_SILENCE, env.attenuationTarget);
+            const sustainDb = Math.max(0, Math.min(DB_SILENCE, env.sustainDbRelative));
+            const fraction = sustainDb / DB_SILENCE;
             env.decayDuration = timecentsToSamples(fullChange + keyNumAddition) * fraction;
 
             switch (env.state)
@@ -232,26 +218,21 @@ export class WorkletVolumeEnvelope
                     // attack is linear (in gain) so we need to do get db from that
                     let elapsed = 1 - ((env.attackEnd - env.releaseStartTimeSamples) / env.attackDuration);
                     // calculate the gain that the attack would have
-                    let attackGain = elapsed * decibelAttenuationToGain(env.attenuation);
-
                     // turn that into db
-                    env.releaseStartDb = 20 * Math.log10(attackGain) * -1;
+                    env.releaseStartDb = 20 * Math.log10(elapsed) * -1;
                     break;
 
                 case 2:
-                    env.releaseStartDb = env.attenuation;
+                    env.releaseStartDb = 0;
                     break;
 
                 case 3:
-                    env.releaseStartDb = (1 - (env.decayEnd - env.releaseStartTimeSamples) / env.decayDuration) * (sustainDb - env.attenuation) + env.attenuation;
+                    env.releaseStartDb = (1 - (env.decayEnd - env.releaseStartTimeSamples) / env.decayDuration) * sustainDb;
                     break;
 
                 case 4:
                     env.releaseStartDb = sustainDb;
                     break;
-
-                default:
-                    env.releaseStartDb = env.currentAttenuationDb;
             }
             env.releaseStartDb = Math.max(0, Math.min(env.releaseStartDb, DB_SILENCE));
             if(env.releaseStartDb >= PERCEIVED_DB_SILENCE)
@@ -268,6 +249,7 @@ export class WorkletVolumeEnvelope
      * @param audioBuffer {Float32Array} the audio buffer to modify
      * @param centibelOffset {number} the centibel offset of volume, for modLFOtoVolume
      * @param smoothingFactor {number} the adjusted smoothing factor for the envelope
+     * @description essentially we use approach of 100dB is silence, 0dB is peak, and always add attenuation to that (which is interpolated)
      */
     static apply(voice, audioBuffer,  centibelOffset, smoothingFactor)
     {
@@ -279,9 +261,6 @@ export class WorkletVolumeEnvelope
         // RELEASE PHASE
         if(voice.isInRelease)
         {
-            // release needs a more aggressive smoothing factor
-            // as the instant notes don't end instantly when they should
-            const releaseSmoothingFactor = smoothingFactor * 10;
             let elapsedRelease = env.currentSampleTime - env.releaseStartTimeSamples;
             if(elapsedRelease >= env.releaseDuration)
             {
@@ -295,9 +274,10 @@ export class WorkletVolumeEnvelope
             let dbDifference = DB_SILENCE - env.releaseStartDb;
             for (let i = 0; i < audioBuffer.length; i++)
             {
+                // attenuation interpolation
+                env.attenuation += (env.attenuationTarget - env.attenuation) * attenuationSmoothing;
                 let db = (elapsedRelease / env.releaseDuration) * dbDifference + env.releaseStartDb;
-                let gain = decibelAttenuationToGain(db + decibelOffset);
-                env.currentReleaseGain += (gain - env.currentReleaseGain) * releaseSmoothingFactor;
+                env.currentReleaseGain = decibelAttenuationToGain(db + decibelOffset + env.attenuation);
                 audioBuffer[i] *= env.currentReleaseGain;
                 env.currentSampleTime++;
                 elapsedRelease++;
@@ -340,7 +320,7 @@ export class WorkletVolumeEnvelope
                     let linearAttenuation = 1 - (env.attackEnd - env.currentSampleTime) / env.attackDuration; // 0 to 1
                     audioBuffer[filledBuffer] *= linearAttenuation * decibelAttenuationToGain(env.attenuation + decibelOffset);
                     // set current attenuation to peak as its invalid during this phase
-                    env.currentAttenuationDb = env.attenuation;
+                    env.currentAttenuationDb = 0;
 
                     env.currentSampleTime++;
                     if(++filledBuffer >= audioBuffer.length)
@@ -359,7 +339,7 @@ export class WorkletVolumeEnvelope
                     env.attenuation += (env.attenuationTarget - env.attenuation) * attenuationSmoothing;
 
                     audioBuffer[filledBuffer] *= decibelAttenuationToGain(env.attenuation + decibelOffset);
-                    env.currentAttenuationDb = env.attenuation;
+                    env.currentAttenuationDb = 0;
     
                     env.currentSampleTime++;
                     if(++filledBuffer >= audioBuffer.length)
@@ -377,9 +357,8 @@ export class WorkletVolumeEnvelope
                     // attenuation interpolation
                     env.attenuation += (env.attenuationTarget - env.attenuation) * attenuationSmoothing;
 
-                    const sustainDb = Math.min(DB_SILENCE, env.sustainDbRelative + env.attenuation);
-                    env.currentAttenuationDb = (1 - (env.decayEnd - env.currentSampleTime) / env.decayDuration) * (sustainDb - env.attenuation) + env.attenuation;
-                    audioBuffer[filledBuffer] *= decibelAttenuationToGain(env.currentAttenuationDb + decibelOffset);
+                    env.currentAttenuationDb = (1 - (env.decayEnd - env.currentSampleTime) / env.decayDuration) * env.sustainDbRelative;
+                    audioBuffer[filledBuffer] *= decibelAttenuationToGain(env.currentAttenuationDb + decibelOffset + env.attenuation);
     
                     env.currentSampleTime++;
                     if(++filledBuffer >= audioBuffer.length)
@@ -400,10 +379,9 @@ export class WorkletVolumeEnvelope
                 {
                     // attenuation interpolation
                     env.attenuation += (env.attenuationTarget - env.attenuation) * attenuationSmoothing;
-                    const sustainDb = Math.min(DB_SILENCE, env.sustainDbRelative + env.attenuation);
 
-                    audioBuffer[filledBuffer] *= decibelAttenuationToGain(sustainDb + decibelOffset);
-                    env.currentAttenuationDb = sustainDb;
+                    audioBuffer[filledBuffer] *= decibelAttenuationToGain(env.sustainDbRelative + decibelOffset + env.attenuation);
+                    env.currentAttenuationDb = env.sustainDbRelative;
                     env.currentSampleTime++;
                     if(++filledBuffer >= audioBuffer.length)
                     {

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

@@ -116,6 +116,8 @@ export function computeModulators(voice, controllerTable, sourceUsesCC = -1, sou
     const { modulators, generators, modulatedGenerators } = voice;
 
     // 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)

package/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -368,8 +368,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 +381,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