spessasynth_core 3.27.2 → 3.27.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_core",
-  "version": "3.27.2",
+  "version": "3.27.4",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "main": "index.js",
   "type": "module",

package/src/soundfont/basic_soundfont/basic_sample.js

@@ -28,7 +28,7 @@ export const sampleTypes = {
  * @async
  * @param audioData {Float32Array}
  * @param sampleRate {number}
- * @returns {Uint8Array}
+ * @returns {Promise<Uint8Array>}
  */
 
 export class BasicSample

package/src/soundfont/basic_soundfont/modulator.js

@@ -73,6 +73,13 @@ export class Modulator
      */
     isEffectModulator = false;
     
+    /**
+     * The default resonant modulator does not affect the filter gain.
+     * Neither XG nor GS responded to cc #74 in that way.
+     * @type {boolean}
+     */
+    isDefaultResonanceModulator = false;
+    
     /**
      * 1 if the source is bipolar (min is -1, max is 1)
      * otherwise min is 0 and max is 1
@@ -198,7 +205,7 @@ export class Modulator
      */
     static copy(modulator)
     {
-        return new Modulator(
+        const m = new Modulator(
             modulator.sourceIndex,
             modulator.sourceCurveType,
             modulator.sourceUsesCC,
@@ -214,6 +221,8 @@ export class Modulator
             modulator.transformType,
             modulator.isEffectModulator
         );
+        m.isDefaultResonanceModulator = modulator.isDefaultResonanceModulator;
+        return m;
     }
     
     /**
@@ -313,7 +322,7 @@ export class Modulator
      */
     sumTransform(modulator)
     {
-        return new Modulator(
+        const m = new Modulator(
             this.sourceIndex,
             this.sourceCurveType,
             this.sourceUsesCC,
@@ -329,6 +338,8 @@ export class Modulator
             this.transformType,
             this.isEffectModulator
         );
+        m.isDefaultResonanceModulator = modulator.isDefaultResonanceModulator;
+        return m;
     }
 }
 
@@ -531,23 +542,26 @@ const customModulators = [
         generatorTypes.initialFilterFc,
         6000,
         0
-    ),
-    
-    // cc 71 (filter Q) to filter Q
-    new DecodedModulator(
-        getModSourceEnum(
-            modulatorCurveTypes.linear,
-            1,
-            0,
-            1,
-            midiControllers.filterResonance
-        ), // linear forwards bipolar cc 74
-        0x0, // no controller
-        generatorTypes.initialFilterQ,
-        250,
-        0
     )
+
 ];
+// cc 71 (filter Q) to filter Q
+const resonanceModulator = new DecodedModulator(
+    getModSourceEnum(
+        modulatorCurveTypes.linear,
+        1,
+        0,
+        1,
+        midiControllers.filterResonance
+    ), // linear forwards bipolar cc 74
+    0x0, // no controller
+    generatorTypes.initialFilterQ,
+    250,
+    0
+);
+
+resonanceModulator.isDefaultResonanceModulator = true;
+customModulators.push(resonanceModulator);
 
 /**
  * @type {Modulator[]}

package/src/synthetizer/audio_engine/engine_components/compute_modulator.js

@@ -113,6 +113,13 @@ export function computeModulator(controllerTable, modulator, voice)
         computedValue = Math.abs(computedValue);
     }
     
+    // resonant modulator: take its value and ensure that it won't change the final gain
+    if (modulator.isDefaultResonanceModulator)
+    {
+        // half the gain, negates the filter
+        voice.resonanceOffset = Math.max(0, computedValue / 2);
+    }
+    
     modulator.currentValue = computedValue;
     return computedValue;
 }

package/src/synthetizer/audio_engine/engine_components/soundfont_manager.js

@@ -116,9 +116,6 @@ export class SoundFontManager
             SpessaSynthInfo(`No soundfont with id of "${id}" found. Aborting!`);
             return;
         }
-        delete this.soundfontList[index].soundfont.presets;
-        delete this.soundfontList[index].soundfont.instruments;
-        delete this.soundfontList[index].soundfont.samples;
         this.soundfontList.splice(index, 1);
         this.generatePresetList();
     }

package/src/synthetizer/audio_engine/engine_components/voice.js

@@ -143,6 +143,12 @@ class Voice
      */
     modulators = [];
     
+    /**
+     * Resonance offset, it is affected by the default resonant modulator
+     * @type {number}
+     */
+    resonanceOffset = 0;
+    
     /**
      * The generators in real-time, affected by modulators.
      * This is used during rendering.
@@ -290,7 +296,6 @@ class Voice
         this.modulatedGenerators = new Int16Array(generators);
         this.modulators = modulators;
         this.filter = new LowpassFilter(sampleRate);
-        
         this.velocity = velocity;
         this.midiNote = midiNote;
         this.startTime = currentTime;
@@ -452,8 +457,6 @@ export function getVoicesForPreset(preset, bank, program, midiNote, velocity, re
             //     MidiNote: midiNote,
             //     AudioSample: audioSample
             // }]);
-            
-            
             voices.push(
                 new Voice(
                     this.sampleRate,

package/src/synthetizer/audio_engine/engine_components/wavetable_oscillator.js

@@ -1,3 +1,5 @@
+import { interpolationTypes } from "./enums.js";
+
 /**
  * wavetable_oscillator.js
  * purpose: plays back raw audio data at an arbitrary playback rate
@@ -6,13 +8,45 @@
 
 export class WavetableOscillator
 {
+    /**
+     * Fills the output buffer with raw sample data using a given interpolation
+     * @param voice {Voice} the voice we're working on
+     * @param outputBuffer {Float32Array} the output buffer to write to
+     * @param interpolation {interpolationTypes} the interpolation type
+     */
+    static getSample(voice, outputBuffer, interpolation)
+    {
+        const step = voice.currentTuningCalculated * voice.sample.playbackStep;
+        // why not?
+        if (step === 1)
+        {
+            WavetableOscillator.getSampleNearest(voice, outputBuffer, step);
+            return;
+        }
+        switch (interpolation)
+        {
+            case interpolationTypes.fourthOrder:
+                this.getSampleHermite(voice, outputBuffer, step);
+                return;
+            
+            case interpolationTypes.linear:
+            default:
+                this.getSampleLinear(voice, outputBuffer, step);
+                return;
+            
+            case interpolationTypes.nearestNeighbor:
+                WavetableOscillator.getSampleNearest(voice, outputBuffer, step);
+                return;
+        }
+    }
     
     /**
      * Fills the output buffer with raw sample data using linear interpolation
      * @param voice {Voice} the voice we're working on
      * @param outputBuffer {Float32Array} the output buffer to write to
+     * @param step {number} the step to advance every sample
      */
-    static getSampleLinear(voice, outputBuffer)
+    static getSampleLinear(voice, outputBuffer, step)
     {
         const sample = voice.sample;
         let cur = sample.cursor;
@@ -45,15 +79,11 @@ export class WavetableOscillator
                 const lower = sampleData[floor];
                 outputBuffer[i] = (lower + (upper - lower) * fraction);
                 
-                cur += sample.playbackStep * voice.currentTuningCalculated;
+                cur += step;
             }
         }
         else
         {
-            if (sample.loopingMode === 2 && !voice.isInRelease)
-            {
-                return;
-            }
             for (let i = 0; i < outputBuffer.length; i++)
             {
                 
@@ -75,7 +105,7 @@ export class WavetableOscillator
                 const lower = sampleData[floor];
                 outputBuffer[i] = (lower + (upper - lower) * fraction);
                 
-                cur += sample.playbackStep * voice.currentTuningCalculated;
+                cur += step;
             }
         }
         voice.sample.cursor = cur;
@@ -85,15 +115,17 @@ export class WavetableOscillator
      * Fills the output buffer with raw sample data using no interpolation (nearest neighbor)
      * @param voice {Voice} the voice we're working on
      * @param outputBuffer {Float32Array} the output buffer to write to
+     * @param step {number} the step to advance every sample
      */
-    static getSampleNearest(voice, outputBuffer)
+    static getSampleNearest(voice, outputBuffer, step)
     {
         const sample = voice.sample;
         let cur = sample.cursor;
-        const loopLength = sample.loopEnd - sample.loopStart;
         const sampleData = sample.sampleData;
-        if (voice.sample.isLooping)
+        
+        if (sample.isLooping)
         {
+            const loopLength = sample.loopEnd - sample.loopStart;
             for (let i = 0; i < outputBuffer.length; i++)
             {
                 // check for loop
@@ -111,15 +143,11 @@ export class WavetableOscillator
                 }
                 
                 outputBuffer[i] = sampleData[ceil];
-                cur += sample.playbackStep * voice.currentTuningCalculated;
+                cur += step;
             }
         }
         else
         {
-            if (sample.loopingMode === 2 && !voice.isInRelease)
-            {
-                return;
-            }
             for (let i = 0; i < outputBuffer.length; i++)
             {
                 
@@ -133,9 +161,8 @@ export class WavetableOscillator
                     return;
                 }
                 
-                //nearest neighbor (uncomment to use)
                 outputBuffer[i] = sampleData[ceil];
-                cur += sample.playbackStep * voice.currentTuningCalculated;
+                cur += step;
             }
         }
         sample.cursor = cur;
@@ -143,11 +170,12 @@ export class WavetableOscillator
     
     
     /**
-     * Fills the output buffer with raw sample data using cubic interpolation
+     * Fills the output buffer with raw sample data using Hermite interpolation
      * @param voice {Voice} the voice we're working on
      * @param outputBuffer {Float32Array} the output buffer to write to
+     * @param step {number} the step to advance every sample
      */
-    static getSampleCubic(voice, outputBuffer)
+    static getSampleHermite(voice, outputBuffer, step)
     {
         const sample = voice.sample;
         let cur = sample.cursor;
@@ -158,21 +186,18 @@ export class WavetableOscillator
             const loopLength = sample.loopEnd - sample.loopStart;
             for (let i = 0; i < outputBuffer.length; i++)
             {
-                // check for loop
+                // check for loop (it can exceed the end point multiple times)
                 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
+                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; // the distance from y0 to cursor
+                let y2 = y0 + 2;    // point 1 after the cursor
+                let y3 = y0 + 3;    // point 2 after the cursor
+                const t = cur - y0; // the distance from y0 to cursor [0;1]
                 // y0 is not handled here
                 // as it's math.floor of cur which is handled above
                 if (y1 >= sample.loopEnd)
@@ -189,40 +214,33 @@ export class WavetableOscillator
                 }
                 
                 // grab the samples
-                const x0 = sampleData[y0];
-                const x1 = sampleData[y1];
-                const x2 = sampleData[y2];
-                const x3 = sampleData[y3];
+                const xm1 = sampleData[y0];
+                const x0 = sampleData[y1];
+                const x1 = sampleData[y2];
+                const x2 = 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;
-                
+                // https://www.musicdsp.org/en/latest/Other/93-hermite-interpollation.html
+                const c = (x1 - xm1) * 0.5;
+                const v = x0 - x1;
+                const w = c + v;
+                const a = w + v + (x2 - x0) * 0.5;
+                const b = w + a;
+                outputBuffer[i] = ((((a * t) - b) * t + c) * t + x0);
                 
-                cur += sample.playbackStep * voice.currentTuningCalculated;
+                cur += step;
             }
         }
         else
         {
-            if (sample.loopingMode === 2 && !voice.isInRelease)
-            {
-                return;
-            }
             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
+                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
+                let y2 = y0 + 2;    // point 1 after the cursor
+                let y3 = y0 + 3;    // point 2 after the cursor
+                const t = cur - y0; // the distance from y0 to cursor [0;1]
                 
                 // flag as finished if needed
                 if (y1 >= sample.end ||
@@ -234,18 +252,21 @@ export class WavetableOscillator
                 }
                 
                 // grab the samples
-                const x0 = sampleData[y0];
-                const x1 = sampleData[y1];
-                const x2 = sampleData[y2];
-                const x3 = sampleData[y3];
+                const xm1 = sampleData[y0];
+                const x0 = sampleData[y1];
+                const x1 = sampleData[y2];
+                const x2 = 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;
+                // https://www.musicdsp.org/en/latest/Other/93-hermite-interpollation.html
+                const c = (x1 - xm1) * 0.5;
+                const v = x0 - x1;
+                const w = c + v;
+                const a = w + v + (x2 - x0) * 0.5;
+                const b = w + a;
+                outputBuffer[i] = ((((a * t) - b) * t + c) * t + x0);
                 
-                cur += sample.playbackStep * voice.currentTuningCalculated;
+                cur += step;
             }
         }
         voice.sample.cursor = cur;

package/src/synthetizer/audio_engine/engine_methods/render_voice.js

@@ -5,7 +5,6 @@ import { absCentsToHz, timecentsToSeconds } from "../engine_components/unit_conv
 import { getLFOValue } from "../engine_components/lfo.js";
 import { WavetableOscillator } from "../engine_components/wavetable_oscillator.js";
 import { LowpassFilter } from "../engine_components/lowpass_filter.js";
-import { interpolationTypes } from "../engine_components/enums.js";
 import { generatorTypes } from "../../../soundfont/basic_soundfont/generator_types.js";
 
 /**
@@ -161,6 +160,9 @@ export function renderVoice(
         cents += modEnv * modEnvPitchDepth;
     }
     
+    // default resonant modulator: it does not affect the filter gain (neither XG nor GS did that)
+    volumeExcursionCentibels -= voice.resonanceOffset;
+    
     // finally, calculate the playback rate
     const centsTotal = ~~(cents + semitones * 100);
     if (centsTotal !== voice.currentTuningCents)
@@ -173,23 +175,22 @@ export function renderVoice(
     // SYNTHESIS
     const bufferOut = new Float32Array(sampleCount);
     
-    // wave table oscillator
-    switch (this.synth.interpolationType)
+    
+    // looping mode 2: start on release. process only volEnv
+    if (voice.sample.loopingMode === 2 && !voice.isInRelease)
     {
-        case interpolationTypes.fourthOrder:
-            WavetableOscillator.getSampleCubic(voice, bufferOut);
-            break;
-        
-        case interpolationTypes.linear:
-        default:
-            WavetableOscillator.getSampleLinear(voice, bufferOut);
-            break;
-        
-        case interpolationTypes.nearestNeighbor:
-            WavetableOscillator.getSampleNearest(voice, bufferOut);
-            break;
+        VolumeEnvelope.apply(
+            voice,
+            bufferOut,
+            volumeExcursionCentibels,
+            this.synth.volumeEnvelopeSmoothingFactor
+        );
+        return voice.finished;
     }
     
+    // wave table oscillator
+    WavetableOscillator.getSample(voice, bufferOut, this.synth.interpolationType);
+    
     // low pass filter
     LowpassFilter.apply(voice, bufferOut, lowpassExcursion, this.synth.filterSmoothingFactor);