SquidgeDSP/plugins/SquidgeFilter/SquidgeFilter.cpp

#include "DistrhoDetails.hpp"
#include "DistrhoPlugin.hpp"
#include "DistrhoPluginInfo.h"

#include "../../core/Filter.hpp"
#include "../../core/Oscillator.hpp"

START_NAMESPACE_DISTRHO

const int BUFFER_SIZE = 16384;

class SquidgeFilter : public Plugin {

public:
  enum Parameters {
    kParamFreq,
    kParamResonance,
    kParamType,
    kParameterCount // must be last
  };

  SquidgeFilter() // Note: Constructor name must match class name
      : Plugin(kParameterCount, 0, 0), filter_(1000.0f, 0.707f, 48000.0f),
        lfo_(4.0f) { // Default: 1kHz, Q=0.707
    filter_.setType(Filter::kLowPass);
  }

protected:
  const char *getLabel() const override { return "SquidgeFilter"; }
  const char *getDescription() const override {
    return "Simple State Variable Filter.";
  }
  const char *getMaker() const override { return "SquidgeSoft"; }
  const char *getLicense() const override { return "GPL3"; }
  uint32_t getVersion() const override { return d_version(0, 1, 0); }
  int64_t getUniqueId() const override { return d_cconst('S', 'Q', 'F', 'T'); }

  void initParameter(uint32_t index, Parameter &parameter) override {
    switch (index) {
    case kParamFreq:
      parameter.name = "Frequency";
      parameter.symbol = "frequency";
      parameter.ranges.min = 20.0f;
      parameter.ranges.def = 1000.0f;
      parameter.ranges.max = 20000.0f;
      parameter.hints = kParameterIsAutomatable | kParameterIsLogarithmic;
      break;

    case kParamResonance:
      parameter.name = "Resonance";
      parameter.symbol = "resonance";
      parameter.ranges.min = 0.1f;
      parameter.ranges.def = 0.707f;
      parameter.ranges.max = 20.0f;
      parameter.hints = kParameterIsAutomatable;
      break;

    case kParamType:
      parameter.name = "Filter Type";
      parameter.symbol = "type";
      parameter.ranges.min = 0.0f;
      parameter.ranges.def = 0.0f;
      parameter.ranges.max = Filter::kFilterTypeCount - 1;
      parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
      parameter.enumValues.count = Filter::kFilterTypeCount;
      parameter.enumValues.restrictedMode = true;

      static const ParameterEnumerationValue sTypes[Filter::kFilterTypeCount] =
          {{0.0f, "Low Pass"},
           {1.0f, "High Pass"},
           {2.0f, "Band Pass"},
           {3.0f, "Notch"}};
      parameter.enumValues.values =
          const_cast<ParameterEnumerationValue *>(sTypes);
      break;
    }
  }

  float getParameterValue(uint32_t index) const override {
    switch (index) {
    case kParamFreq:
      return filter_.getCutOff();
    case kParamResonance:
      return filter_.getQ();
    case kParamType:
      return static_cast<float>(filter_.getType());
    }
    return 0.0f;
  }

  void setParameterValue(uint32_t index, float value) override {
    switch (index) {
    case kParamFreq:
      filter_.setCutOff(value);
      break;
    case kParamResonance:
      filter_.setQ(value);
      break;
    case kParamType:
      int typeIdx = static_cast<int>(std::fmin(std::fmax(value, 0.0f), 3.0f));
      filter_.setType(static_cast<Filter::FilterType>(typeIdx));
      break;
    }
  }

  void run(const float **inputs, float **outputs, uint32_t frames) override {
    lfo_.process(lfoBuffer_, frames);

    filter_.processStereo(inputs[0], inputs[1], outputs[0], outputs[1], frames,
                          lfoBuffer_);
  }

  void sampleRateChanged(double newSr) override {
    filter_.setSampleRate(static_cast<float>(newSr));
    lfo_.setSampleRate(newSr);
  }

private:
  Filter filter_;
  Oscillator lfo_;
  float lfoBuffer_[BUFFER_SIZE];

  DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SquidgeFilter);
};

Plugin *createPlugin() { return new SquidgeFilter(); }

END_NAMESPACE_DISTRHO