PluginProcessor.cpp

#include "PluginProcessor.h"
#include "PluginEditor.h"

FlatLineAudioProcessor::FlatLineAudioProcessor()
#ifndef JucePlugin_PreferredChannelConfigurations
    : AudioProcessor (BusesProperties()
        #if ! JucePlugin_IsMidiEffect
         #if ! JucePlugin_IsSynth
          .withInput  ("Input",  juce::AudioChannelSet::stereo(), true)
         #endif
          .withOutput ("Output", juce::AudioChannelSet::stereo(), true)
        #endif
      ),
      apvts (*this, nullptr, "PARAMETERS", createParameterLayout())
#endif
{
}

juce::AudioProcessorValueTreeState::ParameterLayout FlatLineAudioProcessor::createParameterLayout()
{
    std::vector<std::unique_ptr<juce::RangedAudioParameter>> params;

    params.push_back (std::make_unique<juce::AudioParameterFloat>(
        juce::ParameterID { "input", 1 }, "Input",
        juce::NormalisableRange<float> (0.0f, 4.0f, 0.01f), 1.0f));

    auto driveRange = juce::NormalisableRange<float> (0.000001f, 1.0f, 0.000001f);
    driveRange.setSkewForCentre (0.001f); // exponential-style feel, matching the JSFX :log intent
    params.push_back (std::make_unique<juce::AudioParameterFloat>(
        juce::ParameterID { "drive", 1 }, "Drive", driveRange, 0.001f));

    params.push_back (std::make_unique<juce::AudioParameterFloat>(
        juce::ParameterID { "lookahead", 1 }, "Lookahead",
        juce::NormalisableRange<float> (0.0f, 50.0f, 0.1f), 5.0f));

    params.push_back (std::make_unique<juce::AudioParameterFloat>(
        juce::ParameterID { "output", 1 }, "Output",
        juce::NormalisableRange<float> (0.0f, 4.0f, 0.01f), 1.0f));

    params.push_back (std::make_unique<juce::AudioParameterBool>(
        juce::ParameterID { "delta", 1 }, "Delta", false));

    return { params.begin(), params.end() };
}

void FlatLineAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
{
    currentSampleRate = sampleRate;
    maxLookaheadSamples = juce::jmax (1, (int) std::ceil (sampleRate * 0.050) + samplesPerBlock + 8);

    const int channels = juce::jmax (2, getTotalNumOutputChannels());
    lookaheadBuffer.setSize (channels, maxLookaheadSamples);
    lookaheadBuffer.clear();

    writePos = 0;
    a = 1.0f;
    b = 1.0f;
}

void FlatLineAudioProcessor::releaseResources()
{
}

#ifndef JucePlugin_PreferredChannelConfigurations
bool FlatLineAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) const
{
    const auto& mainOut = layouts.getMainOutputChannelSet();

    if (mainOut != juce::AudioChannelSet::mono()
        && mainOut != juce::AudioChannelSet::stereo())
        return false;

   #if ! JucePlugin_IsSynth
    if (mainOut != layouts.getMainInputChannelSet())
        return false;
   #endif

    return true;
}
#endif

void FlatLineAudioProcessor::processBlock (juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages)
{
    juce::ignoreUnused (midiMessages);
    juce::ScopedNoDenormals noDenormals;

    const int numSamples = buffer.getNumSamples();
    const int numChannels = buffer.getNumChannels();

    for (int ch = getTotalNumInputChannels(); ch < getTotalNumOutputChannels(); ++ch)
        buffer.clear (ch, 0, numSamples);

    const float input     = apvts.getRawParameterValue ("input")->load();
    const float drive     = apvts.getRawParameterValue ("drive")->load();
    const float lookMs    = apvts.getRawParameterValue ("lookahead")->load();
    const float output    = apvts.getRawParameterValue ("output")->load();
    const bool deltaMode  = apvts.getRawParameterValue ("delta")->load() > 0.5f;

    int lookSamples = (int) std::floor (currentSampleRate * lookMs / 1000.0);
    lookSamples = juce::jlimit (0, maxLookaheadSamples - 2, lookSamples);

    auto* left  = buffer.getWritePointer (0);
    auto* right = numChannels > 1 ? buffer.getWritePointer (1) : nullptr;

    for (int i = 0; i < numSamples; ++i)
    {
        const float inL = left[i] * input;
        const float inR = right != nullptr ? right[i] * input : inL;

        lookaheadBuffer.setSample (0, writePos, inL);
        if (lookaheadBuffer.getNumChannels() > 1)
            lookaheadBuffer.setSample (1, writePos, inR);

        // JSFX detector: abs(((l/2) + (r/2))^2)
        const float mid = 0.5f * inL + 0.5f * inR;
        const float det = std::abs (mid * mid);

        a = juce::jmax (a, eps);
        b = juce::jmax (b, eps);

        // Your A/B core, ported directly from the ReaJS version.
        a = 0.99f * b
          + det * drive / a
          + 0.01f * (a - b);

        a = juce::jmax (a, eps);
        b = juce::jmax (b, eps);

        b = 0.99f * juce::jmax (a, juce::jmax (b / a, b))
          + 0.01f * b * std::abs (a / b);

        a = juce::jmax (a, eps);
        b = juce::jmax (b, eps);

        int readPos = writePos - lookSamples;
        if (readPos < 0)
            readPos += maxLookaheadSamples;

        const float dryL = lookaheadBuffer.getSample (0, readPos);
        const float dryR = lookaheadBuffer.getNumChannels() > 1 ? lookaheadBuffer.getSample (1, readPos) : dryL;

        const float procL = dryL / b;
        const float procR = dryR / b;

        const float outL = deltaMode ? (dryL - procL) : procL;
        const float outR = deltaMode ? (dryR - procR) : procR;

        left[i] = outL * output;
        if (right != nullptr)
            right[i] = outR * output;

        ++writePos;
        if (writePos >= maxLookaheadSamples)
            writePos = 0;
    }
}

juce::AudioProcessorEditor* FlatLineAudioProcessor::createEditor()
{
    return new FlatLineAudioProcessorEditor (*this);
}

void FlatLineAudioProcessor::getStateInformation (juce::MemoryBlock& destData)
{
    if (auto xml = apvts.copyState().createXml())
        copyXmlToBinary (*xml, destData);
}

void FlatLineAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
{
    if (auto xmlState = getXmlFromBinary (data, sizeInBytes))
        if (xmlState->hasTagName (apvts.state.getType()))
            apvts.replaceState (juce::ValueTree::fromXml (*xmlState));
}

juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
{
    return new FlatLineAudioProcessor();
}