spessasynth_core 1.0.0

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/lowpass_filter.js

@@ -0,0 +1,95 @@
+import { generatorTypes } from '../../../soundfont/chunk/generators.js'
+import { absCentsToHz, decibelAttenuationToGain } from './unit_converter.js'
+
+/**
+ * lowpass_filter.js
+ * purpose: applies a low pass filter to a voice
+ * note to self: most of this is code is just javascript version of the C code from fluidsynth,
+ * they are the real smart guys.
+ * Shoutout to them!
+ */
+
+
+/**
+ * Applies a low-pass filter to the given buffer
+ * @param voice {WorkletVoice} the voice we're working on
+ * @param outputBuffer {Float32Array} the buffer to apply the filter to
+ * @param cutoffCents {number} cutoff frequency in cents
+ * @param sampleRate {number} in hertz
+ * @this {Synthesizer}
+ */
+export function applyLowpassFilter(voice, outputBuffer, cutoffCents, sampleRate)
+{
+    if(cutoffCents > 13499)
+    {
+        return; // filter is open
+    }
+
+    // check if the frequency has changed. if so, calculate new coefficients
+    if(voice.filter.cutoffCents !== cutoffCents || voice.filter.reasonanceCb !== voice.modulatedGenerators[generatorTypes.initialFilterQ])
+    {
+        voice.filter.cutoffCents = cutoffCents;
+        voice.filter.reasonanceCb = voice.modulatedGenerators[generatorTypes.initialFilterQ];
+        calculateCoefficients(voice, sampleRate);
+    }
+
+    // filter the input
+    for (let i = 0; i < outputBuffer.length; i++) {
+        let input = outputBuffer[i];
+        let filtered = voice.filter.a0 * input
+            + voice.filter.a1 * voice.filter.x1
+            + voice.filter.a2 * voice.filter.x2
+            - voice.filter.a3 * voice.filter.y1
+            - voice.filter.a4 * voice.filter.y2;
+
+        // set buffer
+        voice.filter.x2 = voice.filter.x1;
+        voice.filter.x1 = input;
+        voice.filter.y2 = voice.filter.y1;
+        voice.filter.y1 = filtered;
+
+        outputBuffer[i] = filtered;
+    }
+}
+
+/**
+ * @param voice {WorkletVoice}
+ * @param sampleRate {number}
+ */
+function calculateCoefficients(voice, sampleRate)
+{
+    voice.filter.cutoffHz = absCentsToHz(voice.filter.cutoffCents);
+
+    // fix cutoff on low frequencies (fluid_iir_filter.c line 392)
+    if(voice.filter.cutoffHz > 0.45 * sampleRate)
+    {
+        voice.filter.cutoffHz = 0.45 * sampleRate;
+    }
+
+    // adjust the filterQ (fluid_iir_filter.c line 204)
+    const qDb = (voice.filter.reasonanceCb / 10) - 3.01;
+    voice.filter.reasonanceGain = decibelAttenuationToGain(-1 * qDb); // -1 because it's attenuation, and we don't want attenuation
+
+    // reduce the gain by the Q factor (fluid_iir_filter.c line 250)
+    const qGain = 1 / Math.sqrt(voice.filter.reasonanceGain);
+
+
+    // code is ported from https://github.com/sinshu/meltysynth/ to work with js. I'm too dumb to understand the math behind this...
+    let w = 2 * Math.PI * voice.filter.cutoffHz / sampleRate;
+    let cosw = Math.cos(w);
+    let alpha = Math.sin(w) / (2 * voice.filter.reasonanceGain);
+
+    let b1 = (1 - cosw) * qGain;
+    let b0 = b1 / 2;
+    let b2 = b0;
+    let a0 = 1 + alpha;
+    let a1 = -2 * cosw;
+    let a2 = 1 - alpha;
+
+    // set coefficients
+    voice.filter.a0 = b0 / a0;
+    voice.filter.a1 = b1 / a0;
+    voice.filter.a2 = b2 / a0;
+    voice.filter.a3 = a1 / a0;
+    voice.filter.a4 = a2 / a0;
+}

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/modulation_envelope.js

@@ -0,0 +1,73 @@
+import { timecentsToSeconds } from './unit_converter.js'
+import { generatorTypes } from '../../../soundfont/chunk/generators.js'
+import { getModulatorCurveValue } from './modulator_curves.js'
+import { modulatorCurveTypes } from '../../../soundfont/chunk/modulators.js'
+
+/**
+ * modulation_envelope.js
+ * purpose: calculates the modulation envelope for the given voice
+ */
+const PEAK = 1;
+
+// 1000 should be precise enough
+const CONVEX_ATTACK = new Float32Array(1000);
+for (let i = 0; i < CONVEX_ATTACK.length; i++) {
+    // this makes the db linear ( i think
+    CONVEX_ATTACK[i] = getModulatorCurveValue(0, modulatorCurveTypes.convex, i / 1000, 0);
+}
+
+/**
+ * Calculates the current modulation envelope value for the given time and voice
+ * @param voice {WorkletVoice} the voice we're working on
+ * @param currentTime {number} in seconds
+ * @returns {number} modenv value, from 0 to 1
+ */
+export function getModEnvValue(voice, currentTime)
+{
+    // calculate env times
+    let attack = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.attackModEnv]);
+    let decay = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.decayModEnv] + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvDecay]));
+    let hold = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.holdModEnv] + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvHold]));
+
+    // calculate absolute times
+    if(voice.isInRelease && voice.releaseStartTime < currentTime)
+    {
+        let release = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.releaseModEnv]);
+        if(voice.modulatedGenerators[generatorTypes.releaseModEnv] < -7199)
+        {
+            // prevent lowpass bugs if release is instant
+            return voice.releaseStartModEnv;
+        }
+        return (1 - (currentTime - voice.releaseStartTime) / release) * voice.releaseStartModEnv;
+    }
+
+    let sustain = 1 - (voice.modulatedGenerators[generatorTypes.sustainModEnv] / 1000);
+    let delayEnd  = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayModEnv]) + voice.startTime;
+    let attackEnd = attack + delayEnd;
+    let holdEnd = hold + attackEnd;
+    let decayEnd = decay + holdEnd;
+
+    let modEnvVal
+    if(currentTime < delayEnd)
+    {
+        modEnvVal = 0; // delay
+    }
+    else if(currentTime < attackEnd)
+    {
+        modEnvVal = CONVEX_ATTACK[~~((1 - (attackEnd - currentTime) / attack) * 1000)]; // convex attack
+    }
+    else if(currentTime < holdEnd)
+    {
+        modEnvVal = PEAK; // peak
+    }
+    else if(currentTime < decayEnd)
+    {
+        modEnvVal = (1 - (decayEnd - currentTime) / decay) * (sustain - PEAK) + PEAK; // decay
+    }
+    else
+    {
+        modEnvVal = sustain; // sustain
+    }
+    voice.currentModEnvValue = modEnvVal;
+    return modEnvVal;
+}

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/modulator_curves.js

@@ -0,0 +1,86 @@
+import { modulatorCurveTypes } from '../../../soundfont/chunk/modulators.js'
+
+/**
+ * modulator_curves.js
+ * precomputes modulator concave and conves curves and calculates a curve value for a given polarity, direction and type
+ */
+
+// the length of the precomputed curve tables
+export const MOD_PRECOMPUTED_LENGTH = 16384;
+
+// Precalculate lookup tables for concave and convers
+const concave = new Float32Array(MOD_PRECOMPUTED_LENGTH);
+const convex = new Float32Array(MOD_PRECOMPUTED_LENGTH);
+// the equation is taken from FluidSynth as it's the standard for soundFonts
+// more precisely, this:
+// https://github.com/FluidSynth/fluidsynth/blob/cb8da1e1e2c0a5cff2bab6a419755b598b793384/src/gentables/gen_conv.c#L55
+concave[0] = 0;
+concave[MOD_PRECOMPUTED_LENGTH - 1] = 1;
+
+convex[0] = 0;
+convex[MOD_PRECOMPUTED_LENGTH - 1] = 1;
+for(let i = 1; i < MOD_PRECOMPUTED_LENGTH - 1; i++)
+{
+    let x = (-200 * 2 / 960) * Math.log(i / (MOD_PRECOMPUTED_LENGTH - 1)) / Math.LN10;
+    convex[i] = 1 - x;
+    concave[MOD_PRECOMPUTED_LENGTH - 1 - i] = x;
+}
+
+/**
+ * Transforms a value with a given curve type
+ * @param polarity {number} 0 or 1
+ * @param direction {number} 0 or 1
+ * @param curveType {number} see modulatorCurveTypes in modulators.js
+ * @param value {number} the linear value, 0 to 1
+ * @returns {number} the transformed value, 0 to 1 or -1 to 1
+ */
+export function getModulatorCurveValue(direction, curveType, value, polarity) {
+    // inverse the value if needed
+    if(direction)
+    {
+        value = 1 - value
+    }
+    switch (curveType) {
+        case modulatorCurveTypes.linear:
+            if (polarity) {
+                // bipolar
+                return value * 2 - 1;
+            }
+            return value;
+
+        case modulatorCurveTypes.switch:
+            // switch
+            value = value > 0.5 ? 1 : 0;
+            if (polarity) {
+                // multiply
+                return value * 2 - 1;
+            }
+            return value;
+
+        case modulatorCurveTypes.concave:
+            // look up the value
+            if(polarity)
+            {
+                value = value * 2 - 1;
+                if(value < 0)
+                {
+                    return 1 - concave[~~(value * -MOD_PRECOMPUTED_LENGTH)] - 1;
+                }
+                return concave[~~value * MOD_PRECOMPUTED_LENGTH];
+            }
+            return concave[~~(value * MOD_PRECOMPUTED_LENGTH)]
+
+        case modulatorCurveTypes.convex:
+            // look up the value
+            if(polarity)
+            {
+                value = value * 2 - 1;
+                if(value < 0)
+                {
+                    return 1 - convex[~~(value * -MOD_PRECOMPUTED_LENGTH)] - 1;
+                }
+                return convex[~~(value * MOD_PRECOMPUTED_LENGTH)];
+            }
+            return convex[~~(value * MOD_PRECOMPUTED_LENGTH)];
+    }
+}

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/stereo_panner.js

@@ -0,0 +1,76 @@
+export const WORKLET_SYSTEM_REVERB_DIVIDER = 200;
+export const WORKLET_SYSTEM_CHORUS_DIVIDER = 500;
+/**
+ * stereo_panner.js
+ * purpose: pans a given voice out to the stereo output and to the effects' outputs
+ */
+
+/**
+ * Pans the voice to the given output buffers
+ * @param gainLeft {number} the left channel gain
+ * @param gainRight {number} the right channel gain
+ * @param inputBuffer {Float32Array} the input buffer in mono
+ * @param output {Float32Array[]} stereo output buffer
+ * @param reverb {Float32Array[]} stereo reverb input
+ * @param reverbLevel {number} 0 to 1000, the level of reverb to send
+ * @param chorus {Float32Array[]} stereo chorus buttfer
+ * @param chorusLevel {number} 0 to 1000, the level of chorus to send
+ */
+export function panVoice(gainLeft,
+                         gainRight,
+                         inputBuffer,
+                         output,
+                         reverb,
+                         reverbLevel,
+                         chorus,
+                         chorusLevel)
+{
+    if(isNaN(inputBuffer[0]))
+    {
+        return;
+    }
+
+    if(reverbLevel > 0 && reverb !== undefined)
+    {
+        const reverbLeft = reverb[0];
+        const reverbRight = reverb[1];
+        // cap reverb
+        reverbLevel = Math.min(reverbLevel, 1000);
+        const reverbGain = reverbLevel / WORKLET_SYSTEM_REVERB_DIVIDER;
+        const reverbLeftGain = gainLeft * reverbGain;
+        const reverbRightGain = gainRight * reverbGain;
+        for (let i = 0; i < inputBuffer.length; i++) {
+            reverbLeft[i] += reverbLeftGain * inputBuffer[i];
+            reverbRight[i] += reverbRightGain * inputBuffer[i];
+        }
+    }
+
+    if(chorusLevel > 0 && chorus !== undefined)
+    {
+        const chorusLeft = chorus[0];
+        const chorusRight = chorus[1];
+        // cap chorus
+        chorusLevel = Math.min(chorusLevel, 1000);
+        const chorusGain = chorusLevel / WORKLET_SYSTEM_CHORUS_DIVIDER;
+        const chorusLeftGain = gainLeft * chorusGain;
+        const chorusRightGain = gainRight * chorusGain;
+        for (let i = 0; i < inputBuffer.length; i++) {
+            chorusLeft[i] += chorusLeftGain * inputBuffer[i];
+            chorusRight[i] += chorusRightGain * inputBuffer[i];
+        }
+    }
+
+    const leftChannel = output[0];
+    const rightChannel = output[1];
+    if(gainLeft > 0)
+    {
+        for (let i = 0; i < inputBuffer.length; i++) {
+            leftChannel[i] += gainLeft * inputBuffer[i];
+        }
+    }
+    if(gainRight > 0) {
+        for (let i = 0; i < inputBuffer.length; i++) {
+            rightChannel[i] += gainRight * inputBuffer[i];
+        }
+    }
+}

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/unit_converter.js

@@ -0,0 +1,66 @@
+/**
+ * unit_converter.js
+ * purpose: converts soundfont units into more useable values with the use of lookup tables to improve performance
+ */
+
+
+// timecent lookup table
+const MIN_TIMECENT = -15000;
+const MAX_TIMECENT = 15000;
+const timecentLookupTable = new Float32Array(MAX_TIMECENT - MIN_TIMECENT + 1);
+for (let i = 0; i < timecentLookupTable.length; i++) {
+    const timecents = MIN_TIMECENT + i;
+    timecentLookupTable[i] = Math.pow(2, timecents / 1200);
+}
+
+/**
+ * Converts timecents to seconds
+ * @param timecents {number} timecents
+ * @returns {number} seconds
+ */
+export function timecentsToSeconds(timecents)
+{
+    return timecentLookupTable[timecents - MIN_TIMECENT];
+}
+
+// abs cent lookup table
+const MIN_ABS_CENT = -20000; // freqVibLfo
+const MAX_ABS_CENT = 16500; // filterFc
+const absoluteCentLookupTable = new Float32Array(MAX_ABS_CENT - MIN_ABS_CENT + 1);
+for (let i = 0; i < absoluteCentLookupTable.length; i++) {
+    const absoluteCents = MIN_ABS_CENT + i;
+    absoluteCentLookupTable[i] = 440 * Math.pow(2, (absoluteCents - 6900) / 1200);
+}
+
+/**
+ * Converts absolute cents to hertz
+ * @param cents {number} absolute cents
+ * @returns {number} hertz
+ */
+export function absCentsToHz(cents)
+{
+    if(cents < MIN_ABS_CENT || cents > MAX_ABS_CENT)
+    {
+        return 440 * Math.pow(2, (cents - 6900) / 1200);
+    }
+    return absoluteCentLookupTable[~~(cents) - MIN_ABS_CENT];
+}
+
+// decibel lookup table (2 points of precision)
+const MIN_DECIBELS = -1660;
+const MAX_DECIBELS = 1600;
+const decibelLookUpTable = new Float32Array((MAX_DECIBELS - MIN_DECIBELS) * 100 + 1);
+for (let i = 0; i < decibelLookUpTable.length; i++) {
+    const decibels = (MIN_DECIBELS * 100 + i) / 100;
+    decibelLookUpTable[i] = Math.pow(10, -decibels / 20);
+}
+
+/**
+ * convers decibel attenuation to gain
+ * @param decibels {number} the decibel attenuation
+ * @returns {number} gain
+ */
+export function decibelAttenuationToGain(decibels)
+{
+    return decibelLookUpTable[Math.floor((decibels - MIN_DECIBELS) * 100)];
+}

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/volume_envelope.js

@@ -0,0 +1,194 @@
+import { decibelAttenuationToGain, timecentsToSeconds } from './unit_converter.js'
+import { generatorTypes } from '../../../soundfont/chunk/generators.js'
+
+/**
+ * volume_envelope.js
+ * purpose: applies a volume envelope for a given voice
+ */
+
+const DB_SILENCE = 100;
+const GAIN_SILENCE = 0.005;
+
+/**
+ * VOL ENV STATES:
+ * 0 - delay
+ * 1 - attack
+ * 2 - hold/peak
+ * 3 - decay
+ * 4 - sustain
+ * release is indicated by isInRelease property
+ */
+
+/**
+ * Applies volume envelope gain to the given output buffer
+ * @param voice {WorkletVoice} the voice we're working on
+ * @param audioBuffer {Float32Array} the audio buffer to modify
+ * @param currentTime {number} the current audio time
+ * @param centibelOffset {number} the centibel offset of volume, for modLFOtoVolume
+ * @param sampleTime {number} single sample time in seconds, usually 1 / 44100 of a second
+ */
+
+export function applyVolumeEnvelope(voice, audioBuffer, currentTime, centibelOffset, sampleTime)
+{
+    // calculate values
+    let decibelOffset = centibelOffset / 10;
+
+    // calculate env times
+    let attack = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.attackVolEnv]);
+    let decay = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.decayVolEnv] + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvDecay]));
+
+    // calculate absolute times
+    let attenuation = voice.modulatedGenerators[generatorTypes.initialAttenuation] / 10; // divide by ten to get decibelts
+    let release = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.releaseVolEnv]);
+    let sustain = attenuation + voice.modulatedGenerators[generatorTypes.sustainVolEnv] / 10;
+    let delayEnd  = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayVolEnv]) + voice.startTime;
+    let attackEnd = attack + delayEnd;
+    let holdEnd = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.holdVolEnv] + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvHold])) + attackEnd;
+    let decayEnd = decay + holdEnd;
+
+    // check if voice is in release
+    if(voice.isInRelease)
+    {
+        // calculate the db attenuation at the time of release (not a constant because it can change (ex, volume set to 0, the sound should cut off)
+        let releaseStartDb;
+        switch (voice.volumeEnvelopeState)
+        {
+            case 0:
+                // no sound: fill with zero and skip!
+                for (let i = 0; i < audioBuffer.length; i++) {
+                    audioBuffer[i] = 0;
+                }
+                return;
+
+            case 1:
+                // attack phase
+                // attack is linear (in gain) so we need to do get db from that
+                let elapsed = 1 - ((attackEnd - voice.releaseStartTime) / attack);
+                // calculate the gain that the attack would have
+                let attackGain = elapsed * decibelAttenuationToGain(attenuation + decibelOffset);
+
+                // turn that into db
+                releaseStartDb = 20 * Math.log10(attackGain) * -1;
+                break;
+
+            case 2:
+                // hold
+                releaseStartDb = attenuation;
+                break;
+
+            case 3:
+                // decay
+                releaseStartDb = (1 - (decayEnd - voice.releaseStartTime) / decay) * (sustain - attenuation) + attenuation;
+                break;
+
+            case 4:
+                // sustain
+                releaseStartDb = sustain;
+                break;
+
+        }
+
+        // uncommented because doesn't seem to be needed but just in case
+        // // if the voice is not released, but state set to true (due to min note length, simply use the release db)
+        // if(voice.releaseStartTime > currentTime)
+        // {
+        //     const gain = decibelAttenuationToGain(releaseStartDb + decibelOffset);
+        //     for (let i = 0; i < audioBuffer.length; i++) {
+        //         audioBuffer[i] = gain * audioBuffer[i];
+        //     }
+        //     return;
+        // }
+
+        let elapsedRelease = currentTime - voice.releaseStartTime;
+        let dbDifference = DB_SILENCE - releaseStartDb;
+        let gain;
+        for (let i = 0; i < audioBuffer.length; i++) {
+            let db = (elapsedRelease / release) * dbDifference + releaseStartDb;
+            gain = decibelAttenuationToGain(db + decibelOffset);
+            audioBuffer[i] = gain * audioBuffer[i];
+            elapsedRelease += sampleTime;
+        }
+
+        if(gain <= GAIN_SILENCE)
+        {
+            voice.finished = true;
+        }
+        return;
+    }
+    let currentFrameTime = currentTime;
+    let dbAttenuation;
+    for (let i = 0; i < audioBuffer.length; i++) {
+        switch(voice.volumeEnvelopeState)
+        {
+            case 0:
+                // delay phase, no sound is produced
+                if(currentFrameTime >= delayEnd)
+                {
+                    voice.volumeEnvelopeState++;
+                }
+                else
+                {
+                    dbAttenuation = DB_SILENCE;
+                    audioBuffer[i] = 0;
+
+                    // no need to go through the hassle of converting. Skip
+                    currentFrameTime += sampleTime;
+                    continue;
+                }
+            // fallthrough
+
+            case 1:
+                // attack phase: ramp from 0 to attenuation
+                if(currentFrameTime >= attackEnd)
+                {
+                    voice.volumeEnvelopeState++;
+                }
+                else {
+                    // Special case: linear gain ramp instead of linear db ramp
+                    const elapsed = (attackEnd - currentFrameTime) / attack;
+                    dbAttenuation = 10 * Math.log10((elapsed * (attenuation - DB_SILENCE) + DB_SILENCE) * -1);
+                    audioBuffer[i] = audioBuffer[i] * (1 - elapsed) * decibelAttenuationToGain(attenuation + decibelOffset);
+                    currentFrameTime += sampleTime;
+                    continue
+
+                }
+            // fallthrough
+
+            case 2:
+                // hold/peak phase: stay at attenuation
+                if(currentFrameTime >= holdEnd)
+                {
+                    voice.volumeEnvelopeState++;
+                }
+                else
+                {
+                    dbAttenuation = attenuation;
+                    break;
+                }
+            // fallthrough
+
+            case 3:
+                // decay phase: linear ramp from attenuation to sustain
+                if(currentFrameTime >= decayEnd)
+                {
+                    voice.volumeEnvelopeState++;
+                }
+                else
+                {
+                    dbAttenuation = (1 - (decayEnd - currentFrameTime) / decay) * (sustain - attenuation) + attenuation;
+                    break
+                }
+            // fallthrough
+
+            case 4:
+                // sustain phase: stay at sustain
+                dbAttenuation = sustain;
+
+        }
+        // apply gain and advance the time
+        const gain = decibelAttenuationToGain(dbAttenuation + decibelOffset);
+        audioBuffer[i] = audioBuffer[i] * gain;
+        currentFrameTime += sampleTime;
+    }
+    voice.currentAttenuationDb = dbAttenuation;
+}

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/wavetable_oscillator.js

@@ -0,0 +1,83 @@
+/**
+ * wavetable_oscillator.js
+ * purpose: plays back raw audio data at an arbitrary playback rate
+ */
+
+
+/**
+ * Fills the output buffer with raw sample data
+ * @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)
+{
+    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 2 nearest points
+            const floor = ~~cur;
+            let ceil = floor + 1;
+
+            while(ceil >= voice.sample.loopEnd) {
+                ceil -= loopLength;
+            }
+
+            const fraction = cur - floor;
+
+            // grab the samples and interpolate
+            const upper = sampleData[ceil];
+            const lower = sampleData[floor];
+            outputBuffer[i] = (lower + (upper - lower) * fraction);
+
+            // commented code because it's probably gonna come handy... (it did like 6 times already :/)
+            // if(isNaN(outputBuffer[i]))
+            // {
+            //     console.error(voice, upper, lower, floor, ceil, cur)
+            //     throw "NAN ALERT";
+            // }
+
+            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++) {
+
+            // linear interpolation
+            const floor = ~~cur;
+            const ceil = floor + 1;
+
+            // flag the voice as finished if needed
+            if(ceil >= voice.sample.end)
+            {
+                voice.finished = true;
+                return;
+            }
+
+            const fraction = cur - floor;
+
+            // grab the samples and interpolate
+            const upper = sampleData[ceil];
+            const lower = sampleData[floor];
+            outputBuffer[i] = (lower + (upper - lower) * fraction);
+
+            cur += voice.sample.playbackStep * voice.currentTuningCalculated;
+        }
+    }
+    voice.sample.cursor = cur;
+}