How do I write my own linear interpolation function for removing frequency and volume slider artifacts?

Nidnogg · November 19, 2017, 6:20pm

Hey everyone! I’m currently studying computer science and I’m enrolled in a numeric analysis class, and my peers and I got plenty of freedom to do a final assignment involving one of the numeric methods taught in the lectures.

I started studying JUCE’s tutorials and figuring out the basics of DSP, and I eventually found out that interpolation is used in removing the artifacting that you get when move sliders over non-continuous intervals to alter parameters, so I thought I could use it in my project. As it stands, I spent the better part of this month desperately attempting to code my own interpolation function for a simple sine generator - and failed miserably. The results are always something in the lines of incredibly garbled audio, infinitely growing frequency values and whatnot.

I have a sine wave generator, where the user controls the frequency of each wave and the volume in db, cobbled together from a tutorial that didn’t illustrate how to smoothly interpolate values between slider changes. I added an interpolate button that toggles my attempts at smoothing out the value transitions.

It’s from the basic Audio Application template, standard MainComponent.cpp and MainComponent.cpp files.

I have four possible options here:
(1) Fix my crappy interpolation attempt - I can’t for the life of me figure out what exactly to use as input for the function.
(2) Understand the SmoothedValue or the LinearSmoothedValue JUCE class - I lifted the former from the kvraudio forums (https://www.kvraudio.com/forum/viewtopic.php?p=6548432) in hopes of finding something that worked so that I could create my own solution based on it, but I couldn’t find out how to get it to work. Same goes for the LinearSmoothedValue. Couldn’t get it to work.
(3) Attempt spline interpolating, but I’m really more clueless about that than I already am with simple interpolation.
(4) Give up and cry really hard in a corner somewhere.

I added plenty of commentary in my code to possibly guide to the root of my problems. Right now I am currently very desperate and I have pretty much given up hope of ever removing the artifacting, and I would greatly appreciate any help given. (the main issues are around line 156.)
Codeshare for non-download option:
https://codeshare.io/aVjRRb
MainComponent.cpp (12.1 KB)
Main.cpp (3.9 KB)

matkatmusic · November 19, 2017, 6:49pm

start here for learning how to use LinearSmoothedValue:

fefanto · November 19, 2017, 7:05pm

…and you can also use a low pass filter to smooth parameter changes , here’s the class I use, interchangeable with LinearSmoothedValue

gist.github.com

https://gist.github.com/fefanto/3057474c020c2cdfab5c462c50b1cc48

juce_LowPassSmoothedValue.h

/*
  ==============================================================================
 
    Utility class for exponentially smoothed values like volume etc. that should
    not change abruptly to avoid audio glitches.

    This Class is based on juce::LinearSmoothedValue,
    part of the JUCE Library (https://github.com/julianstorer/JUCE).
 
    Smoothing algorithm is based on a 1 pole IIR lowpass:

This file has been truncated. show original

Nidnogg · November 19, 2017, 8:34pm

I’ve looked over those files extensively, and unfortunately, I couldn’t think of a way to use them in my code. I would like not to rewrite everything from the ground up. Do I call LinearSmoothedValue for every sample I get? How exactly do I instantiate it in the getNextAudioBlock() function and compute the actual smoothed values?

Nidnogg · November 19, 2017, 8:35pm

I appreciate the swift answers, but I’m limited to linear/spline interpolation as the project is intended as an experiment to showcase numeric method applications

matkatmusic · November 19, 2017, 8:44pm

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/examples/DSP%20module%20plugin%20demo/Source/PluginProcessor.cpp#L120


void DspModulePluginDemoAudioProcessor::releaseResources()

{



}



void DspModulePluginDemoAudioProcessor::process (dsp::ProcessContextReplacing<float> context) noexcept

{

ScopedNoDenormals noDenormals;



// Input volume applied with a LinearSmoothedValue

inputVolume.process (context);



// Pre-highpass filtering, very useful for distortion audio effects

// Note : try frequencies around 700 Hz

highPassFilter.process (context);



// Upsampling

dsp::AudioBlock<float> oversampledBlock;



setLatencySamples (audioCurrentlyOversampled ? roundFloatToInt (oversampling->getLatencyInSamples()) : 0);

what is a inputVolume?

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/examples/DSP%20module%20plugin%20demo/Source/PluginProcessor.h#L105


void process (dsp::ProcessContextReplacing<float>) noexcept;



//==============================================================================

dsp::ProcessorDuplicator<dsp::IIR::Filter<float>, dsp::IIR::Coefficients<float>> lowPassFilter, highPassFilter;

dsp::Convolution convolution;



static constexpr size_t numWaveShapers = 2;

dsp::WaveShaper<float> waveShapers[numWaveShapers];

dsp::WaveShaper<float> clipping;



dsp::Gain<float> inputVolume, outputVolume;



ScopedPointer<dsp::Oversampling<float>> oversampling;

bool audioCurrentlyOversampled = false;



Atomic<int> cabinetType;

bool cabinetIsBypassed = false;



//==============================================================================

JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (DspModulePluginDemoAudioProcessor)

};

what is a dsp::Gain ?

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/modules/juce_dsp/processors/juce_Gain.h#L36




namespace juce

{

namespace dsp

{



/**

Applies a gain to audio samples as single samples or AudioBlocks.

*/

template <typename FloatType>

class Gain

{

public:

Gain() noexcept {}



//==============================================================================

/** Applies a new gain as a linear value. */

void setGainLinear (FloatType newGain) noexcept             { gain.setValue (newGain); }



/** Applies a new gain as a decibel value. */

void setGainDecibels (FloatType newGainDecibels) noexcept   { setGainLinear (Decibels::decibelsToGain<FloatType> (newGainDecibels)); }

and what is dsp::Gain::process()?

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/modules/juce_dsp/processors/juce_Gain.h#L95


//==============================================================================

/** Returns the result of processing a single sample. */

template <typename SampleType>

SampleType JUCE_VECTOR_CALLTYPE processSample (SampleType s) noexcept

{

    return s * gain.getNextValue();

}



/** Processes the input and output buffers supplied in the processing context. */

template <typename ProcessContext>

void process (const ProcessContext& context) noexcept

{

    auto&& inBlock  = context.getInputBlock();

    auto&& outBlock = context.getOutputBlock();



    jassert (inBlock.getNumChannels() == outBlock.getNumChannels());

    jassert (inBlock.getNumSamples() == outBlock.getNumSamples());



    auto len         = inBlock.getNumSamples();

    auto numChannels = inBlock.getNumChannels();

where is the LinearSmoothedValue?

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/modules/juce_dsp/processors/juce_Gain.h#L130




        for (size_t chan = 0; chan < numChannels; ++chan)

            FloatVectorOperations::multiply (outBlock.getChannelPointer (chan),

                                             inBlock.getChannelPointer (chan),

                                             gains, static_cast<int> (len));

    }

}



private:

//==============================================================================

LinearSmoothedValue<FloatType> gain;

double sampleRate = 0, rampDurationSeconds = 0;

};



} // namespace dsp

} // namespace juce

How is that LinearSmoothedValue used so linear interpolation is applied to a sample buffer?
First the ramp duration property is set for the LSV:

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/examples/DSP%20module%20plugin%20demo/Source/PluginProcessor.cpp#L90


}



void DspModulePluginDemoAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)

{

auto channels = static_cast<uint32> (jmin (getMainBusNumInputChannels(), getMainBusNumOutputChannels()));

dsp::ProcessSpec spec { sampleRate, static_cast<uint32> (samplesPerBlock), channels };



lowPassFilter.prepare (spec);

highPassFilter.prepare (spec);



inputVolume.prepare (spec);

outputVolume.prepare (spec);



convolution.prepare (spec);

cabinetType.set (-1);



oversampling->initProcessing (static_cast<size_t> (samplesPerBlock));



updateParameters();

reset();

}

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/modules/juce_dsp/processors/juce_Gain.h#L72


}



/** Returns the ramp duration in seconds. */

double getRampDurationSeconds() const noexcept              { return rampDurationSeconds; }



/** Returns true if the current value is currently being interpolated. */

bool isSmoothing() const noexcept                           { return gain.isSmoothing(); }



//==============================================================================

/** Called before processing starts. */

void prepare (const ProcessSpec& spec) noexcept

{

    sampleRate = spec.sampleRate;

    reset();

}



/** Resets the internal state of the gain */

void reset() noexcept

{

    if (sampleRate > 0)

        gain.reset (sampleRate, rampDurationSeconds);

then the samples are processed:

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/examples/DSP%20module%20plugin%20demo/Source/PluginProcessor.cpp#L120


void DspModulePluginDemoAudioProcessor::releaseResources()

{



}



void DspModulePluginDemoAudioProcessor::process (dsp::ProcessContextReplacing<float> context) noexcept

{

ScopedNoDenormals noDenormals;



// Input volume applied with a LinearSmoothedValue

inputVolume.process (context);



// Pre-highpass filtering, very useful for distortion audio effects

// Note : try frequencies around 700 Hz

highPassFilter.process (context);



// Upsampling

dsp::AudioBlock<float> oversampledBlock;



setLatencySamples (audioCurrentlyOversampled ? roundFloatToInt (oversampling->getLatencyInSamples()) : 0);

specifically, here, for mono audio channels:

github.com

WeAreROLI/JUCE/blob/eb0293a285b2725ca4e90137d26d0ab616df6f9e/modules/juce_dsp/processors/juce_Gain.h#L111


jassert (inBlock.getNumSamples() == outBlock.getNumSamples());



auto len         = inBlock.getNumSamples();

auto numChannels = inBlock.getNumChannels();



if (numChannels == 1)

{

    auto* src = inBlock.getChannelPointer (0);

    auto* dst = outBlock.getChannelPointer (0);



    for (size_t i = 0; i < len; ++i)

        dst[i] = src[i] * gain.getNextValue();

}

else

{

    auto* gains = static_cast<FloatType*> (alloca (sizeof (FloatType) * len));



    for (size_t i = 0; i < len; ++i)

        gains[i] = gain.getNextValue();



    for (size_t chan = 0; chan < numChannels; ++chan)

Nidnogg · November 20, 2017, 6:20am

Hey, thanks again for taking the time to help. I just had another look at those and tried my hand at it again - there is one parameter that I still didn’t figure out.

I implemented it this way:

A LinearSmoothedValue freqSmooth object as a member variable
In the prepareToPlay() function, I call its setValue() method and set it to frequency (the current frequency, that is) and call reset(sampleRate).
In the slider, I call setValue(targetFrequency) whenever it is dragged to a value targetFrequency.
In the getNextAudioBlock(), for the monoBuffer, each new frequency value for the current sample is updated with frequency = freqSmooth.getNextValue()

But what is that rampDurationInSeconds? I tried setting my time variable as it, but I’m still getting the exact same artifacting - even though I am getting the values from the LinearSmoothedValue. The frequency changes appear smooth when printed in the terminal but the output is still garbled.

Updated codeshare link:
https://codeshare.io/ayP0Je

Topic		Replies	Views
LinearSmoothedValue not smoothing Slider Value for Sine Generator	10	3137	August 2, 2016
What's wrong with my simple Parameter Smoothing? [SOLVED]	4	776	May 13, 2019
Non-linear slider values Audio Plugins	2	758	January 30, 2017
The quest for better Sampler Interpolation General JUCE discussion	9	3190	July 19, 2021
Samples and linear interpolation	2	530	January 7, 2023

How do I write my own linear interpolation function for removing frequency and volume slider artifacts?

Purchase

Discover

Learn

Support

About

Events

Related Topics

Purchase

Discover

Learn

Support

About

Events