SquidgeDSP/plugins/SquidgeDistortion/SquidgeDistortion.cpp

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

#include "../../core/Clipper.hpp"
#include "../../core/Gain.hpp"

START_NAMESPACE_DISTRHO

class SquidgeDistortion : public Plugin {

public:
  enum Parameters {
    kParamGain,
    kParamClipMode,
    kParameterCount // must be last
  };
  SquidgeDistortion() : Plugin(kParameterCount, 0, 0), gain_(2.0f) {}

protected:
  const char *getLabel() const override { return "SquidgeDistortion"; }
  const char *getDescription() const override {
    return "Simple distortion plugin.";
  }
  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', 'D', 'T'); }

  void initParameter(uint32_t index, Parameter &parameter) override {
    switch (index) {
    case kParamGain:
      parameter.name = "Gain";
      parameter.symbol = "gain";
      parameter.ranges.min = 1.0f;
      parameter.ranges.def = 2.0f;
      parameter.ranges.max = 10.0f;
      parameter.hints = kParameterIsAutomatable;
      break;
    case kParamClipMode:
      parameter.name = "Clip Mode";
      parameter.symbol = "clipmode";
      parameter.ranges.min = 0.0f;
      parameter.ranges.def = 0.0f;
      parameter.ranges.max = Clipper::kClipperModeCount - 1;
      parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
      parameter.enumValues.count = Clipper::kClipperModeCount;
      parameter.enumValues.restrictedMode = true;

      static const ParameterEnumerationValue
          sClipModes[Clipper::kClipperModeCount] = {
              {0.0f, "Soft"}, {1.0f, "Hard"}, {2.0f, "Fold"}};
      parameter.enumValues.values =
          const_cast<ParameterEnumerationValue *>(sClipModes);
      break;
    }
  }

  float getParameterValue(uint32_t index) const override {
    switch (index) {
    case kParamGain:
      return gain_.getGain();
    case kParamClipMode:
      return (float)clipper_.getMode();
    }
    return 0.0f;
  }

  void setParameterValue(uint32_t index, float value) override {
    switch (index) {
    case kParamGain:
      gain_.setGain(value);
      break;
    case kParamClipMode:
      clipper_.setMode((Clipper::ClipperMode)value);
      break;
    }
  }

  void run(const float **inputs, float **outputs, uint32_t frames) override {
    gain_.processStereo(inputs[0], inputs[1], outputs[0], outputs[1], frames);
    clipper_.processStereo(outputs[0], outputs[1], outputs[0], outputs[1],
                           frames);
  }

private:
  Gain gain_;
  Clipper clipper_;

  DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SquidgeDistortion);
};

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

END_NAMESPACE_DISTRHO