spessasynth_lib 3.20.6 → 3.20.9

package/synthetizer/worklet_system/main_processor.js

@@ -38,6 +38,7 @@ import {
 } from './worklet_methods/program_control.js'
 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'
 
 
 /**
@@ -45,6 +46,8 @@ import { WorkletSoundfontManager } from './worklet_methods/worklet_soundfont_man
  * purpose: manages the synthesizer (and worklet sequencer) from the AudioWorkletGlobalScope and renders the audio data
  */
 
+const WORKLET_PROCESSOR_VERSION = "3.20.9";
+
 export const MIN_NOTE_LENGTH = 0.07; // if the note is released faster than that, it forced to last that long
 
 export const SYNTHESIZER_GAIN = 1.0;
@@ -79,6 +82,12 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
          */
         this.deviceID = ALL_CHANNELS_OR_DIFFERENT_ACTION;
 
+        /**
+         * Interpolation type used
+         * @type {interpolationTypes}
+         */
+        this.interpolationType = interpolationTypes.linear;
+
         /**
          * @type {function}
          */
@@ -218,6 +227,10 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
 
         stbvorbis.isInitialized.then(() => {
             this.postReady();
+            this.post({
+                messageType: returnMessageType.identify,
+                messageData: WORKLET_PROCESSOR_VERSION
+            });
             SpessaSynthInfo("%cSpessaSynth is ready!", consoleColors.recognized);
         });
     }

package/synthetizer/worklet_system/message_protocol/handle_message.js

@@ -141,6 +141,10 @@ export function handleMessage(message)
                 case masterParameterType.voicesCap:
                     this.voiceCap = value;
                     break;
+
+                case masterParameterType.interpolationType:
+                    this.interpolationType = value;
+                    break;
             }
             break;
 

package/synthetizer/worklet_system/message_protocol/worklet_message.js

@@ -64,6 +64,7 @@ export const masterParameterType = {
     mainVolume: 0,
     masterPan: 1,
     voicesCap: 2,
+    interpolationType: 3
 }
 
 
@@ -106,6 +107,7 @@ export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
  * 4 - synthesizer snapshot         -> snapshot<SynthesizerSnapshot> note: refer to snapshot.js
  * 5 - ready                        -> (no data)
  * 6 - soundfontError               -> errorMessage<string>
+ * 7 - idenfity                     -> version<string>
  */
 
 /**
@@ -119,4 +121,5 @@ export const returnMessageType = {
     synthesizerSnapshot: 4,
     ready: 5,
     soundfontError: 6,
+    identify: 7,
 }

package/synthetizer/worklet_system/worklet_methods/voice_control.js

@@ -3,7 +3,7 @@ import { absCentsToHz, timecentsToSeconds } from '../worklet_utilities/unit_conv
 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 { getOscillatorData } from '../worklet_utilities/wavetable_oscillator.js'
+import { getSampleLinear, getSampleNearest, interpolationTypes } from '../worklet_utilities/wavetable_oscillator.js'
 import { panVoice } from '../worklet_utilities/stereo_panner.js'
 import { applyLowpassFilter } from '../worklet_utilities/lowpass_filter.js'
 import { MIN_NOTE_LENGTH } from '../main_processor.js'
@@ -108,7 +108,8 @@ export function renderVoice(
         // use modulation multiplier (RPN modulation depth)
         cents += modLfoValue * (modPitchDepth * channel.customControllers[customControllers.modulationMultiplier]);
         // volenv volume offset
-        modLfoCentibels = modLfoValue * modVolDepth;
+        // the lfo returns from -1 to 1, we change it to 0-1 here because the volume excursion is only positive
+        modLfoCentibels = (modLfoValue / 2 + 0.5) * modVolDepth;
         // lowpass frequency
         lowpassCents += modLfoValue * modFilterDepth;
     }
@@ -147,7 +148,14 @@ export function renderVoice(
     const bufferOut = new Float32Array(outputLeft.length);
 
     // wavetable oscillator
-    getOscillatorData(voice, this.workletDumpedSamplesList[voice.sample.sampleID], bufferOut);
+    if(this.interpolationType === interpolationTypes.linear)
+    {
+        getSampleLinear(voice, this.workletDumpedSamplesList[voice.sample.sampleID], bufferOut);
+    }
+    else
+    {
+        getSampleNearest(voice, this.workletDumpedSamplesList[voice.sample.sampleID], bufferOut);
+    }
 
     // lowpass filter
     applyLowpassFilter(voice, bufferOut, lowpassCents);

package/synthetizer/worklet_system/worklet_utilities/volume_envelope.js

@@ -145,7 +145,7 @@ export class WorkletVolumeEnvelope
         }
         // calculate absolute times (they can change so we have to recalculate every time
         env.attenuation = voice.modulatedGenerators[generatorTypes.initialAttenuation] / 10; // divide by ten to get decibelts
-        env.sustainDb = voice.volumeEnvelope.attenuation + voice.modulatedGenerators[generatorTypes.sustainVolEnv] / 10;
+        env.sustainDb = Math.min(100, voice.volumeEnvelope.attenuation + voice.modulatedGenerators[generatorTypes.sustainVolEnv] / 10);
 
         // calculate durations
         env.attackDuration = timecentsToSamples(voice.modulatedGenerators[generatorTypes.attackVolEnv]);
@@ -154,8 +154,8 @@ export class WorkletVolumeEnvelope
         // therefore we need to calculate the real time
         // (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 = (env.sustainDb - env.attenuation) / (100 - env.attenuation);
+        const keyNumAddition = (60 - voice.targetKey) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvDecay];
+        const fraction = (env.sustainDb - env.attenuation) / 100;
         env.decayDuration = timecentsToSamples(fullChange + keyNumAddition) * fraction;
 
         env.releaseDuration = timecentsToSamples(voice.modulatedGenerators[generatorTypes.releaseVolEnv]);
@@ -334,7 +334,7 @@ export class WorkletVolumeEnvelope
             case 3:
                 // decay phase: linear ramp from attenuation to sustain
                 const dbDifference = env.sustainDb - env.attenuation;
-                while(env.currentSampleTime++ < env.decayEnd)
+                while(env.currentSampleTime < env.decayEnd)
                 {
                     const newAttenuation = (1 - (env.decayEnd - env.currentSampleTime) / env.decayDuration) * dbDifference + env.attenuation;
                     audioBuffer[filledBuffer] *= WorkletVolumeEnvelope.getInterpolatedGain(env, newAttenuation + decibelOffset, smoothingFactor);
@@ -350,6 +350,15 @@ export class WorkletVolumeEnvelope
     
             case 4:
                 // sustain phase: stay at sustain
+                if(env.sustainDb > PERCEIVED_DB_SILENCE)
+                {
+                    voice.finished = true;
+                    while(filledBuffer < audioBuffer.length)
+                    {
+                        audioBuffer[filledBuffer++] = 0;
+                    }
+                    return;
+                }
                 while(true)
                 {
                     audioBuffer[filledBuffer] *= WorkletVolumeEnvelope.getInterpolatedGain(env, env.sustainDb + decibelOffset, smoothingFactor);

package/synthetizer/worklet_system/worklet_utilities/wavetable_oscillator.js

@@ -3,14 +3,23 @@
  * purpose: plays back raw audio data at an arbitrary playback rate
  */
 
+/**
+ *
+ * @enum {number}
+ */
+export const interpolationTypes = {
+    linear: 0,
+    nearestNeighbor: 1
+}
+
 
 /**
- * Fills the output buffer with raw sample data
+ * Fills the output buffer with raw sample data using linear interpolation
  * @param voice {WorkletVoice} the voice we're working on
  * @param sampleData {Float32Array} the sample data to write with
  * @param outputBuffer {Float32Array} the output buffer to write to
  */
-export function getOscillatorData(voice, sampleData, outputBuffer)
+export function getSampleLinear(voice, sampleData, outputBuffer)
 {
     let cur = voice.sample.cursor;
     const loop = (voice.sample.loopingMode === 1) || (voice.sample.loopingMode === 3 && !voice.isInRelease);
@@ -93,4 +102,66 @@ export function getOscillatorData(voice, sampleData, outputBuffer)
         }
     }
     voice.sample.cursor = cur;
+}
+
+/**
+ * Fills the output buffer with raw sample data using no interpolation (nearest neighbor)
+ * @param voice {WorkletVoice} the voice we're working on
+ * @param sampleData {Float32Array} the sample data to write with
+ * @param outputBuffer {Float32Array} the output buffer to write to
+ */
+export function getSampleNearest(voice, sampleData, outputBuffer)
+{
+    let cur = voice.sample.cursor;
+    const loop = (voice.sample.loopingMode === 1) || (voice.sample.loopingMode === 3 && !voice.isInRelease);
+    const loopLength = voice.sample.loopEnd - voice.sample.loopStart;
+
+    if(loop)
+    {
+        for (let i = 0; i < outputBuffer.length; i++)
+        {
+            // check for loop
+            while(cur >= voice.sample.loopEnd)
+            {
+                cur -= loopLength;
+            }
+
+            // grab the nearest neighbor
+            let ceil = ~~cur + 1;
+
+            while(ceil >= voice.sample.loopEnd)
+            {
+                ceil -= loopLength;
+            }
+
+            outputBuffer[i] = sampleData[ceil];
+            cur += voice.sample.playbackStep * voice.currentTuningCalculated;
+        }
+    }
+    else
+    {
+        // check and correct end errors
+        if(voice.sample.end >= sampleData.length)
+        {
+            voice.sample.end = sampleData.length - 1;
+        }
+        for (let i = 0; i < outputBuffer.length; i++)
+        {
+
+            // nearest neighbor
+            const ceil = ~~cur + 1;
+
+            // flag the voice as finished if needed
+            if(ceil >= voice.sample.end)
+            {
+                voice.finished = true;
+                return;
+            }
+
+            //nearest neighbor (uncomment to use)
+            outputBuffer[i] = sampleData[ceil];
+            cur += voice.sample.playbackStep * voice.currentTuningCalculated;
+        }
+    }
+    voice.sample.cursor = cur;
 }