spessasynth_lib 3.20.35 → 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,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

@@ -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