justasample/Source/Sampler/CustomSamplerVoice.cpp

/*
  ==============================================================================

    CustomSamplerVoice.cpp
    Created: 5 Sep 2023 3:35:03pm
    Author:  binya

  ==============================================================================
*/

#include "CustomSamplerVoice.h"

#include "../Utilities/BufferUtils.h"
#include "Effects/BandEQ.h"
#include "Effects/Chorus.h"
#include "Effects/Distortion.h"
#include "Effects/Reverb.h"

CustomSamplerVoice::CustomSamplerVoice(const SamplerParameters& samplerSound, MTSClient* client, double applicationSampleRate, int expectedBlockSize, bool initSample) :
    expectedBlockSize(expectedBlockSize), sampleSound(samplerSound),
    mainStretcher(samplerSound.sample, samplerSound.sampleRate),
    loopStretcher(samplerSound.sample, samplerSound.sampleRate),
    endStretcher(samplerSound.sample, samplerSound.sampleRate),
    mtsClient(client)
{
    SynthesiserVoice::setCurrentPlaybackSampleRate(applicationSampleRate);

    if (expectedBlockSize <= 0)
        this->expectedBlockSize = 512;  // In case a DAW reports this incorrectly at the time of prepareToPlay

    if (initSample)
        initializeSample();
}

void CustomSamplerVoice::initializeSample()
{
    if (sampleSound.sample.getNumChannels() <= 0)
        return;

    mainStretcher = BungeeStretcher(sampleSound.sample, sampleSound.sampleRate);
    loopStretcher = BungeeStretcher(sampleSound.sample, sampleSound.sampleRate);
    endStretcher = BungeeStretcher(sampleSound.sample, sampleSound.sampleRate);

    const int sampleRate = int(getSampleRate());
    if (sampleRate > 0)
    {
        mainStretcher.preallocateStretcher(sampleRate);
        loopStretcher.preallocateStretcher(sampleRate);
        endStretcher.preallocateStretcher(sampleRate);
    }

    tempOutputBuffer.setSize(sampleSound.sample.getNumChannels(), expectedBlockSize * 2);
    envelopeBuffer.setSize(sampleSound.sample.getNumChannels(), expectedBlockSize * 2);

    tailOffBuffer.setSize(2, TAIL_OFF, false, true);
    mainStretcherBuffer.setSize(sampleSound.sample.getNumChannels(), expectedBlockSize * 2);
    loopStretcherBuffer.setSize(sampleSound.sample.getNumChannels() - 1, expectedBlockSize * 2);
    endStretcherBuffer.setSize(sampleSound.sample.getNumChannels() - 1, expectedBlockSize * 2);

    mainLowpass.clear();
    loopLowpass.clear();
    endLowpass.clear();
    for (int i = 0; i < sampleSound.sample.getNumChannels(); i++)
    {
        mainLowpass.emplace_back(std::make_unique<LowpassStream>(2 * LANCZOS_WINDOW_SIZE));
        loopLowpass.emplace_back(std::make_unique<LowpassStream>(2 * LANCZOS_WINDOW_SIZE));
        endLowpass.emplace_back(std::make_unique<LowpassStream>(2 * LANCZOS_WINDOW_SIZE));
    }
}

void CustomSamplerVoice::startNote(int midiNoteNumber, float velocity, juce::SynthesiserSound* sound, int currentPitchWheelPosition)
{
    if (midiNoteNumber < sampleSound.midiStart->get() || midiNoteNumber > sampleSound.midiEnd->get() || MTS_ShouldFilterNote(mtsClient, char(midiNoteNumber), -1))
        return;

    if (!sampleSound.disableVelocity->get())
        noteVelocity = velocity;
    else
        noteVelocity = 1.f;

    if (sound)
    {
        sampleRateConversion = float(sampleSound.sampleRate / getSampleRate());

        sampleStart = sampleSound.sampleStart;  // Note this implicitly loads the atomic value
        sampleEnd = sampleSound.sampleEnd;

        wavetableMode = isWavetableModeAvailable(float(sampleSound.sampleRate), sampleStart, sampleEnd) && !sampleSound.disableWavetableMode->get();

        playbackMode = wavetableMode ? PluginParameters::BASIC : sampleSound.getPlaybackMode();

        playUntilEnd = sampleSound.playUntilEnd->get();
        isLooping = sampleSound.isLooping->get() || wavetableMode;
        loopingHasStart = isLooping && sampleSound.loopingHasStart->get() && sampleSound.loopStart < sampleSound.sampleStart && !wavetableMode;
        loopStart = sampleSound.loopStart;
        loopingHasEnd = isLooping && sampleSound.loopingHasEnd->get() && sampleSound.loopEnd > sampleSound.sampleEnd && !wavetableMode;
        loopEnd = sampleSound.loopEnd;

        effectiveStart = loopingHasStart ? loopStart : sampleStart;
        effectiveEnd = loopingHasEnd ? loopEnd : sampleEnd;

        // While release can be applied before or after the FX, a minimum number of attack smoothing always needs to be applied to the sample before FX
        attackSmoothing = sampleSound.attack->get() * float(getSampleRate()) / 1000.f;
        releaseSmoothing = sampleSound.release->get() * float(getSampleRate()) / 1000.f;
        attackShape = sampleSound.attackShape->get();
        releaseShape = sampleSound.releaseShape->get();
        if (loopingHasEnd)  // Keep release smoothing within end portion
            releaseSmoothing = juce::jmin<float>(releaseSmoothing, float(loopEnd - sampleEnd));
        crossfade = juce::jmin<float>(float(sampleSound.crossfadeSamples->get()), (sampleEnd - sampleStart + 1) / 2.f + 1);

        vc = VoiceContext();
        midiReleased = false;

        doLowpass = false;
        vc.currentPosition = effectiveStart;
        updateSpeedAndPitch(midiNoteNumber, currentPitchWheelPosition);

        if (playbackMode == PluginParameters::BUNGEE)
            mainStretcher.initialize(effectiveStart, tuning, speedFactor);

        effects.clear();
        initializeFx();
        for (auto& effect : effects)
        {
            effect.fx->initialize(sampleSound.sample.getNumChannels(), int(getSampleRate()));
            effect.fx->updateParams(sampleSound);
        }
     
        updateFXParamsTimer = 0;

        // Set the initial state (vc.currentPosition is set before updateSpeedAndPitch)
        vc.state = PLAYING;
        vc.isSmoothingAttack = attackSmoothing > 0;
    }
}

void CustomSamplerVoice::stopNote(float /*velocity*/, bool allowTailOff)
{
    if (allowTailOff)
    {
        if (!playUntilEnd || isLooping)
            midiReleased = true;
    }
    else
    {
        // We render a quick tail-off to avoid clicks
        juce::AudioBuffer<float> temp{ tailOffBuffer.getNumChannels(), tailOffBuffer.getNumSamples() };
        temp.clear();
        renderNextBlock(temp, 0, TAIL_OFF);
        tailOffBuffer = temp;
        tailOff = 0;

        vc.state = STOPPED;
        clearCurrentNote();
    }
}

void CustomSamplerVoice::immediateHalt()
{
    vc.state = STOPPED;
    clearCurrentNote();
}

void CustomSamplerVoice::pitchWheelMoved(int newPitchWheelValue)
{
    updateSpeedAndPitch(getCurrentlyPlayingNote(), newPitchWheelValue);
}

void CustomSamplerVoice::updateSpeedAndPitch(int currentNote, int pitchWheelPosition)
{
    pitchWheel = pitchWheelPosition;

    // Account for tuning adjustments
    float tuningRatio = 1.f;

    if (playbackMode == PluginParameters::BASIC && wavetableMode)
        tuningRatio *= std::pow(2.f, (sampleSound.waveformSemitoneTuning->get() + sampleSound.waveformCentTuning->get() / 100.f) / 12.f);
    else
        tuningRatio *= std::pow(2.f, (sampleSound.semitoneTuning->get() + sampleSound.centTuning->get() / 100.f) / 12.f);

    float wheelRange = sampleSound.pitchWheelRange->get();
    tuningRatio *= std::pow(2.f, juce::jmap<float>(float(pitchWheelPosition), 0.f, 16383.f, -wheelRange, wheelRange) / 12.f);

    tuningRatio *= std::pow(2.f, sampleSound.wideTuningControl->get() / 12.f);

    // Account for MIDI note
    if (sampleSound.followMidiPitch->get())
    {
        int rootNote = sampleSound.midiRoot->get();
        tuningRatio *= std::pow(2.f, (currentNote - rootNote) / 12.f);
        tuningRatio *= float(MTS_RetuningAsRatio(mtsClient, char(currentNote), -1));
    }

    tuning = tuningRatio;
    speedFactor = sampleSound.speedFactor->get();
    speedFactor *= 1.f + (tuning - 1.f) * sampleSound.octaveSpeedFactor->get();

    if (playbackMode == PluginParameters::BASIC)
    {
        // In wavetable mode, the sample is treated as a single cycle
        // Otherwise, the sample is simply sped up according to the tuning
        float a4_hz = sampleSound.a4_freq->get();
        speed = wavetableMode ? (tuning * a4_hz) * (sampleEnd - sampleStart + 1 - crossfade) / float(getSampleRate()) / 2.f
                              : tuning * sampleRateConversion;

        // Configure the filters
        auto frequency = sampleSound.sampleRate / 2.f / speed;
        auto filterLimit = sampleSound.sampleRate / 2.f - 10.f;  // We've run into some issues when the filter is too close to the Nyquist frequency

        bool wasLowpass = doLowpass;
        doLowpass = speed > 1.f && frequency < filterLimit;

        if (!wasLowpass && doLowpass)
        {
            for (int ch = 0; ch < sampleSound.sample.getNumChannels(); ch++)
                mainLowpass[ch]->resetProcessing(int(vc.currentPosition));
        }

        if (doLowpass)
        {
            for (int ch = 0; ch < sampleSound.sample.getNumChannels(); ch++)
            {
                mainLowpass[ch]->setCoefficients(sampleSound.sampleRate, frequency);
                loopLowpass[ch]->setCoefficients(sampleSound.sampleRate, frequency);
                endLowpass[ch]->setCoefficients(sampleSound.sampleRate, frequency);
            }
        }
    }
    else
    {
        // Update the stretchers
        mainStretcher.setPitchAndSpeed(tuning, speedFactor);
        loopStretcher.setPitchAndSpeed(tuning, speedFactor);
        endStretcher.setPitchAndSpeed(tuning, speedFactor);

        speed = speedFactor * sampleRateConversion;
    }
}

//==============================================================================
void CustomSamplerVoice::renderNextBlock(juce::AudioBuffer<float>& outputBuffer, int startSample, int numSamples)
{
    if (vc.state == STOPPED && (!doFxTailOff || !getCurrentlyPlayingSound()))
    {
        clearCurrentNote();
        return;
    }

    // These resizes will happen rarely, if at all
    if (tempOutputBuffer.getNumSamples() < numSamples)
    {
        tempOutputBuffer.setSize(tempOutputBuffer.getNumChannels(), numSamples);
        envelopeBuffer.setSize(envelopeBuffer.getNumChannels(), numSamples);
    }
    tempOutputBuffer.clear();
    envelopeBuffer.clear();

    if (playbackMode == PluginParameters::BUNGEE && loopStretcherBuffer.getNumSamples() < numSamples)
    {
        mainStretcherBuffer.setSize(mainStretcherBuffer.getNumChannels(), numSamples);
        loopStretcherBuffer.setSize(loopStretcherBuffer.getNumChannels(), numSamples);
        endStretcherBuffer.setSize(endStretcherBuffer.getNumChannels(), numSamples);
    }
    
    updateSpeedAndPitch(getCurrentlyPlayingNote(), pitchWheel);

    bool someFXEnabled{ false };
    for (const auto& effect : effects)
    {
        someFXEnabled = someFXEnabled || effect.enablementSource->get();
    }

    // Main processing loop
    VoiceContext con;
    for (auto ch = 0; ch < sampleSound.sample.getNumChannels(); ch++)
    {
        // This struct is used to easily process channel by channel 
        con = vc;
        for (auto i = 0; i < numSamples; i++)
        {
            if (con.state == STOPPED)
            {
                con.samplesSinceStopped++;
                continue;
            }

            // Fetch the sample according to the playback mode
            float sample = playbackMode == PluginParameters::BASIC ? 
                fetchSample(ch, con.currentPosition, mainLowpass) :
                nextSample(ch, &mainStretcher, mainStretcherBuffer, i);

            // Crossfading
            if (con.isCrossfadingLoop)
            {
                double crossfadePosition = con.currentPosition - sampleStart;
                if (crossfadePosition >= crossfade)
                {
                    con.isCrossfadingLoop = false;
                }
                else
                {
                    // Power preserving crossfade (https://www.youtube.com/watch?v=-5cB3rec2T0)
                    float crossfadeIncrease = float(std::sqrt(0.5f + 0.5f * std::cos(juce::MathConstants<float>::pi * crossfadePosition / crossfade + juce::MathConstants<float>::pi)));
                    float crossfadeDecrease = float(std::sqrt(0.5f + 0.5f * std::cos(juce::MathConstants<float>::pi * crossfadePosition / crossfade)));
                    float next = playbackMode == PluginParameters::BASIC ? 
                        fetchSample(ch, con.currentPosition + sampleEnd - sampleStart - crossfade, loopLowpass) :
                        nextSample(ch, &loopStretcher, loopStretcherBuffer, i);
                    sample = sample * crossfadeIncrease + next * crossfadeDecrease;
                }
            }

            if (con.isCrossfadingEnd)
            {
                double crossfadePosition = con.currentPosition - sampleEnd;
                if (crossfadePosition >= crossfade)
                {
                    con.isCrossfadingEnd = false;
                }
                else
                {
                    float crossfadeIncrease = float(std::sqrt(0.5f + 0.5f * std::cos(juce::MathConstants<float>::pi * crossfadePosition / crossfade + juce::MathConstants<float>::pi)));
                    float crossfadeDecrease = float(std::sqrt(0.5f + 0.5f * std::cos(juce::MathConstants<float>::pi * crossfadePosition / crossfade)));
                    float next = playbackMode == PluginParameters::BASIC ? 
                        fetchSample(ch, con.crossfadeEndPosition, endLowpass) :
                        nextSample(ch, &endStretcher, endStretcherBuffer, i);
                    sample = sample * crossfadeIncrease + next * crossfadeDecrease;
                    con.crossfadeEndPosition += speed;
                }
            }

            // Attack and release envelopes
            envelopeBuffer.setSample(ch, i, 1.f);

            if (con.isSmoothingAttack)
            {
                if (con.speedMovedSinceStart >= attackSmoothing)
                    con.isSmoothingAttack = false;
                else
                    envelopeBuffer.setSample(ch, i, exponentialCurve(attackShape, con.speedMovedSinceStart / attackSmoothing));

            }
             
            if (con.isReleasing)
                envelopeBuffer.setSample(ch, i, envelopeBuffer.getSample(ch, i) * exponentialCurve(releaseShape, 1 - con.speedMovedSinceRelease / releaseSmoothing));

            // Update the position 
            con.currentPosition += speed;
            con.speedMovedSinceStart += 1;
            if (con.isReleasing)
                con.speedMovedSinceRelease += 1;

            // Handle transitions
            if (con.state == PLAYING && isLooping && con.currentPosition >= sampleEnd - crossfade)  // Loop crossfade
            {
                con.currentPosition -= (sampleEnd - sampleStart + 1) - crossfade;
                con.isCrossfadingLoop = true;

                if (playbackMode == PluginParameters::BUNGEE && ch == 0)
                {
                    std::swap(mainStretcher, loopStretcher);
                    mainStretcher.initialize(con.currentPosition, tuning, speedFactor);  // This could also be done at note start
                }
                else
                {
                    std::swap(mainLowpass[ch], loopLowpass[ch]);
                    mainLowpass[ch]->resetProcessing(int(con.currentPosition));
                }
            }

            if (midiReleased && !con.isReleasing && con.state == PLAYING)  // Midi release, end crossfade
            {
                if (loopingHasEnd)
                {
                    con.crossfadeEndPosition = con.currentPosition;
                    con.currentPosition = sampleEnd + 1;
                    con.state = PLAYING_END;
                    con.isCrossfadingEnd = true;

                    if (playbackMode == PluginParameters::BUNGEE && ch == 0)
                    {
                        std::swap(mainStretcher, endStretcher);
                        mainStretcher.initialize(con.currentPosition, tuning, speedFactor);  // This could also be done at note start
                    }
                    else
                    {
                        std::swap(mainLowpass[ch], endLowpass[ch]);
                        mainLowpass[ch]->resetProcessing(int(con.currentPosition));
                    }
                }
                else
                {
                    con.isReleasing = true;
                }
            }

            if (((con.state == PLAYING && !isLooping) || con.state == PLAYING_END) && !con.isReleasing &&
                con.currentPosition > effectiveEnd - releaseSmoothing * speed)  // Release smoothing
            {
                con.isReleasing = true;
            }

            if (con.currentPosition > effectiveEnd || (con.isReleasing && con.speedMovedSinceRelease >= releaseSmoothing))  // End of playback reached
                con.state = STOPPED;

            // Scale with standard velocity curve
            sample *= juce::Decibels::decibelsToGain(40 * log10(noteVelocity));
            sample *= juce::Decibels::decibelsToGain(float(sampleSound.gain->get()));

            tempOutputBuffer.setSample(ch, i, sample);
        }
    }
    vc = con;

    // Check for updated FX order
    if (updateFXParamsTimer == UPDATE_PARAMS_LENGTH)
        initializeFx();

    // Apply envelope here or after FX if PRE_FX is enabled
    if (!sampleSound.applyFXPre->get())
        for (int ch = 0; ch < tempOutputBuffer.getNumChannels(); ch++)
            juce::FloatVectorOperations::multiply(tempOutputBuffer.getWritePointer(ch), tempOutputBuffer.getReadPointer(ch), envelopeBuffer.getReadPointer(ch), numSamples);

    // Apply FX
    int reverbSampleDelay = int(1000.f + sampleSound.reverbPredelay->get() * float(getSampleRate()) / 1000.f);  // the 1000.f is approximate
    someFXEnabled = false;
    for (auto& effect : effects)
    {
        // Check for updated enablement
        bool enablement = effect.enablementSource->get();
        if (!effect.enabled && enablement)
        {
            effect.fx->initialize(sampleSound.sample.getNumChannels(), int(getSampleRate()));
            effect.fx->updateParams(sampleSound, false);
        }
        effect.enabled = enablement;
        someFXEnabled = someFXEnabled || effect.enabled;

        if (effect.enabled && !effect.locallyDisabled)
        {
            // Update params every UPDATE_PARAMS_LENGTH calls to process
            if (updateFXParamsTimer == UPDATE_PARAMS_LENGTH)
                effect.fx->updateParams(sampleSound, true);
            effect.fx->process(tempOutputBuffer, numSamples);

            // Check if an effect should be locally disabled. Note that reverb can only be disabled after a certain delay
            if (con.state == STOPPED && numSamples > 10 && !(effect.fxType == PluginParameters::REVERB && con.samplesSinceStopped <= reverbSampleDelay)) 
            {
                bool disable{ true };
                for (int ch = 0; ch < tempOutputBuffer.getNumChannels(); ch++)
                {
                    float level = tempOutputBuffer.getRMSLevel(ch, 0, numSamples);
                    if (level > 0)
                    {
                        disable = false;
                        break;
                    }
                }
                if (disable)
                    effect.locallyDisabled = true;
            }
        }
    }

    if (sampleSound.applyFXPre->get())
        for (int ch = 0; ch < tempOutputBuffer.getNumChannels(); ch++)
            juce::FloatVectorOperations::multiply(tempOutputBuffer.getWritePointer(ch), tempOutputBuffer.getReadPointer(ch), envelopeBuffer.getReadPointer(ch), numSamples);

    updateFXParamsTimer--;
    if (updateFXParamsTimer <= 0)
        updateFXParamsTimer = UPDATE_PARAMS_LENGTH;
    doFxTailOff = !sampleSound.applyFXPre->get() && someFXEnabled && !effects.empty();

    // Check RMS level to see if a voice should be ended despite tailing off effects
    if (con.state == STOPPED && someFXEnabled && numSamples > 10 && con.samplesSinceStopped > reverbSampleDelay)
    {
        bool end{ true };  // Whether all channels are below the threshold
        for (int ch = 0; ch < tempOutputBuffer.getNumChannels(); ch++)
        {
            float level = tempOutputBuffer.getRMSLevel(ch, 0, numSamples);
            if (level >= PluginParameters::FX_TAIL_OFF_MAX)
            {
                end = false;
                break;
            }
        }
        if (end)
        {
            clearCurrentNote();
            return;
        }
    }

    mixToBuffer(tempOutputBuffer, outputBuffer, startSample, numSamples, sampleSound.monoOutput->get());

    // Add the previous tail-off samples to the output buffer
    tailOffBuffer.setSize(tempOutputBuffer.getNumChannels(), tailOffBuffer.getNumSamples(), true, true);
    int i = 0;
    for (; tailOff < TAIL_OFF; tailOff++)
    {
        if (i >= numSamples)
            break;

        for (int ch = 0; ch < tailOffBuffer.getNumChannels(); ch++)
        {
            float sample = tailOffBuffer.getSample(ch, tailOff) * (TAIL_OFF - tailOff) / TAIL_OFF;
            outputBuffer.addSample(ch, startSample + i, sample);
        }

        i++;
    }

}

float CustomSamplerVoice::fetchSample(int channel, double position, std::vector<std::unique_ptr<LowpassStream>>& lowpassStreams) const
{
    if (0 > position || position >= float(sampleSound.sample.getNumSamples()))
        return 0.f;

    if (sampleSound.skipAntialiasing->get())
    {
        return sampleSound.sample.getSample(channel, int(position));
    }
    else
    {
        return lanczosInterpolate(channel, position, lowpassStreams);
    }
}

float CustomSamplerVoice::nextSample(int channel, BungeeStretcher* stretcher, juce::AudioBuffer<float>& channelBuffer, int i) const
{
    if (channel == 0)
    {
        for (int ch = 1; ch < sampleSound.sample.getNumChannels(); ch++)
            channelBuffer.setSample(ch - 1, i, stretcher->nextSample(ch, false));
        return stretcher->nextSample(0);
    }
    else
    {
        return channelBuffer.getSample(channel - 1, i);
    }
}

float CustomSamplerVoice::getEnvelopeGain() const
{
    float gain = 1.f;
    if (vc.isSmoothingAttack)
        gain *= exponentialCurve(attackShape, vc.speedMovedSinceStart / attackSmoothing);
    if (vc.isReleasing)
        gain *= exponentialCurve(releaseShape, 1 - vc.speedMovedSinceRelease / releaseSmoothing);
    return gain;
}

//==============================================================================
void CustomSamplerVoice::initializeFx()
{
    auto fxOrder = sampleSound.getFxOrder();
    bool changed = false;
    for (size_t i = 0; i < fxOrder.size(); i++)
    {
        if (effects.size() <= i || effects[i].fxType != fxOrder[i])
        {
            changed = true;
            break;
        }
    }
    if (changed)
    {
        effects.clear();
        for (auto& fxType : fxOrder)
        {
            switch (fxType)
            {
            case PluginParameters::DISTORTION:
                effects.emplace_back(PluginParameters::DISTORTION, std::make_unique<Distortion>(), sampleSound.distortionEnabled);
                break;
            case PluginParameters::REVERB:
                effects.emplace_back(PluginParameters::REVERB, std::make_unique<Reverb>(), sampleSound.reverbEnabled);
                break;
            case PluginParameters::CHORUS:
                effects.emplace_back(PluginParameters::CHORUS, std::make_unique<Chorus>(expectedBlockSize), sampleSound.chorusEnabled);
                break;
            case PluginParameters::EQ:
                effects.emplace_back(PluginParameters::EQ, std::make_unique<BandEQ>(), sampleSound.eqEnabled);
                break;
            }
        }
    }
}

//==============================================================================
/** Thank god for Wikipedia, I don't really know why this works. https://en.wikipedia.org/wiki/Lanczos_resampling
    The technical details of resampling elude me, but JUCE's filters seem to work well enough for this... 
 */
float CustomSamplerVoice::lanczosInterpolate(int channel, double position, std::vector<std::unique_ptr<LowpassStream>>& lowpassStreams) const
{
    // First, process the lowpass filter
    auto& lowpassStream = *lowpassStreams[channel];
    if (doLowpass && lowpassStream.getNextSample() < sampleSound.sample.getNumSamples())
    {
        int lastWindowSample = juce::jmin(int(std::floor(position)) + LANCZOS_WINDOW_SIZE, sampleSound.sample.getNumSamples() - 1);
        lowpassStream.processSamples(sampleSound.sample.getReadPointer(channel, lowpassStream.getNextSample()), lastWindowSample - lowpassStream.getNextSample() + 1);
    }

    // Then, interpolate
    int floorIndex = int(std::floor(position));

    float result = 0.f;
    for (int i = -LANCZOS_WINDOW_SIZE + 1; i <= LANCZOS_WINDOW_SIZE; i++)
    {
        int iPlus = i + floorIndex;

        float sample = 0.f;
        if (0 <= iPlus && iPlus < sampleSound.sample.getNumSamples())  // Bounds checking is a bit awkward here but handles some edge cases
        { 
            if (doLowpass)
            {
                if (iPlus >= lowpassStream.getStartSample())
                    sample = lowpassStream.getProcessedSample(iPlus);
            }
            else
            {
                sample = sampleSound.sample.getSample(channel, iPlus);
            }
        }

        float window = lanczosWindow(position - floorIndex - i);
        result += sample * window;
    }
    return result;
}

float CustomSamplerVoice::lanczosWindow(double x)
{
    return x == 0.f ? 1.f : float(LANCZOS_WINDOW_SIZE * std::sin(juce::MathConstants<float>::pi * x) * std::sin(juce::MathConstants<float>::pi * x / LANCZOS_WINDOW_SIZE) * INVERSE_SIN_SQUARED / (x * x));
}