spessasynth_core 3.27.1 → 3.27.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_core",
-  "version": "3.27.1",
+  "version": "3.27.3",
   "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/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/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";
 
 /**
@@ -173,23 +172,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);