DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13197 Commits
9 Branches
4.0GB
Tree: 61fd8827e1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '61fd8827e1'
${ noResults }
JUCE/examples/Plugins/DSPModulePluginDemo.h

2101 lines
93KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE examples.

  5.    Copyright (c) 2022 - Raw Material Software Limited

  6. 

  7.    The code included in this file is provided under the terms of the ISC license

  8.    http://www.isc.org/downloads/software-support-policy/isc-license. Permission

  9.    To use, copy, modify, and/or distribute this software for any purpose with or

  10.    without fee is hereby granted provided that the above copyright notice and

  11.    this permission notice appear in all copies.

  12. 

  13.    THE SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES,

  14.    WHETHER EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR

  15.    PURPOSE, ARE DISCLAIMED.

  16. 

  17.   ==============================================================================

  18. */

  19. 

  20. /*******************************************************************************

  21.  The block below describes the properties of this PIP. A PIP is a short snippet

  22.  of code that can be read by the Projucer and used to generate a JUCE project.

  23. 

  24.  BEGIN_JUCE_PIP_METADATA

  25. 

  26.  name:             DSPModulePluginDemo

  27.  version:          1.0.0

  28.  vendor:           JUCE

  29.  website:          http://juce.com

  30.  description:      An audio plugin using the DSP module.

  31. 

  32.  dependencies:     juce_audio_basics, juce_audio_devices, juce_audio_formats,

  33.                    juce_audio_plugin_client, juce_audio_processors,

  34.                    juce_audio_utils, juce_core, juce_data_structures, juce_dsp,

  35.                    juce_events, juce_graphics, juce_gui_basics, juce_gui_extra

  36.  exporters:        xcode_mac, vs2022, linux_make

  37. 

  38.  moduleFlags:      JUCE_STRICT_REFCOUNTEDPOINTER=1

  39. 

  40.  type:             AudioProcessor

  41.  mainClass:        DspModulePluginDemoAudioProcessor

  42. 

  43.  useLocalCopy:     1

  44. 

  45.  END_JUCE_PIP_METADATA

  46. 

  47. *******************************************************************************/

  48. 

  49. #pragma once

  50. 

  51. #include "../Assets/DemoUtilities.h"

  52. 

  53. namespace ID

  54. {

  55.    #define PARAMETER_ID(str) constexpr const char* str { #str };

  56. 

  57.     PARAMETER_ID (inputGain)

  58.     PARAMETER_ID (outputGain)

  59.     PARAMETER_ID (pan)

  60.     PARAMETER_ID (distortionEnabled)

  61.     PARAMETER_ID (distortionType)

  62.     PARAMETER_ID (distortionOversampler)

  63.     PARAMETER_ID (distortionLowpass)

  64.     PARAMETER_ID (distortionHighpass)

  65.     PARAMETER_ID (distortionInGain)

  66.     PARAMETER_ID (distortionCompGain)

  67.     PARAMETER_ID (distortionMix)

  68.     PARAMETER_ID (convolutionCabEnabled)

  69.     PARAMETER_ID (convolutionReverbEnabled)

  70.     PARAMETER_ID (convolutionReverbMix)

  71.     PARAMETER_ID (multiBandEnabled)

  72.     PARAMETER_ID (multiBandFreq)

  73.     PARAMETER_ID (multiBandLowVolume)

  74.     PARAMETER_ID (multiBandHighVolume)

  75.     PARAMETER_ID (compressorEnabled)

  76.     PARAMETER_ID (compressorThreshold)

  77.     PARAMETER_ID (compressorRatio)

  78.     PARAMETER_ID (compressorAttack)

  79.     PARAMETER_ID (compressorRelease)

  80.     PARAMETER_ID (noiseGateEnabled)

  81.     PARAMETER_ID (noiseGateThreshold)

  82.     PARAMETER_ID (noiseGateRatio)

  83.     PARAMETER_ID (noiseGateAttack)

  84.     PARAMETER_ID (noiseGateRelease)

  85.     PARAMETER_ID (limiterEnabled)

  86.     PARAMETER_ID (limiterThreshold)

  87.     PARAMETER_ID (limiterRelease)

  88.     PARAMETER_ID (directDelayEnabled)

  89.     PARAMETER_ID (directDelayType)

  90.     PARAMETER_ID (directDelayValue)

  91.     PARAMETER_ID (directDelaySmoothing)

  92.     PARAMETER_ID (directDelayMix)

  93.     PARAMETER_ID (delayEffectEnabled)

  94.     PARAMETER_ID (delayEffectType)

  95.     PARAMETER_ID (delayEffectValue)

  96.     PARAMETER_ID (delayEffectSmoothing)

  97.     PARAMETER_ID (delayEffectLowpass)

  98.     PARAMETER_ID (delayEffectFeedback)

  99.     PARAMETER_ID (delayEffectMix)

  100.     PARAMETER_ID (phaserEnabled)

  101.     PARAMETER_ID (phaserRate)

  102.     PARAMETER_ID (phaserDepth)

  103.     PARAMETER_ID (phaserCentreFrequency)

  104.     PARAMETER_ID (phaserFeedback)

  105.     PARAMETER_ID (phaserMix)

  106.     PARAMETER_ID (chorusEnabled)

  107.     PARAMETER_ID (chorusRate)

  108.     PARAMETER_ID (chorusDepth)

  109.     PARAMETER_ID (chorusCentreDelay)

  110.     PARAMETER_ID (chorusFeedback)

  111.     PARAMETER_ID (chorusMix)

  112.     PARAMETER_ID (ladderEnabled)

  113.     PARAMETER_ID (ladderCutoff)

  114.     PARAMETER_ID (ladderResonance)

  115.     PARAMETER_ID (ladderDrive)

  116.     PARAMETER_ID (ladderMode)

  117. 

  118.    #undef PARAMETER_ID

  119. }

  120. 

  121. template <typename Func, typename... Items>

  122. constexpr void forEach (Func&& func, Items&&... items)

  123.     noexcept (noexcept (std::initializer_list<int> { (func (std::forward<Items> (items)), 0)... }))

  124. {

  125.     (void) std::initializer_list<int> { ((void) func (std::forward<Items> (items)), 0)... };

  126. }

  127. 

  128. template <typename... Components>

  129. void addAllAndMakeVisible (Component& target, Components&... children)

  130. {

  131.     forEach ([&] (Component& child) { target.addAndMakeVisible (child); }, children...);

  132. }

  133. 

  134. template <typename... Processors>

  135. void prepareAll (const dsp::ProcessSpec& spec, Processors&... processors)

  136. {

  137.     forEach ([&] (auto& proc) { proc.prepare (spec); }, processors...);

  138. }

  139. 

  140. template <typename... Processors>

  141. void resetAll (Processors&... processors)

  142. {

  143.     forEach ([] (auto& proc) { proc.reset(); }, processors...);

  144. }

  145. 

  146. //==============================================================================

  147. class DspModulePluginDemo  : public AudioProcessor,

  148.                              private ValueTree::Listener

  149. {

  150. public:

  151.     DspModulePluginDemo()

  152.         : DspModulePluginDemo (AudioProcessorValueTreeState::ParameterLayout{}) {}

  153. 

  154.     //==============================================================================

  155.     void prepareToPlay (double sampleRate, int samplesPerBlock) override

  156.     {

  157.         const auto channels = jmax (getTotalNumInputChannels(), getTotalNumOutputChannels());

  158. 

  159.         if (channels == 0)

  160.             return;

  161. 

  162.         chain.prepare ({ sampleRate, (uint32) samplesPerBlock, (uint32) channels });

  163. 

  164.         reset();

  165.     }

  166. 

  167.     void reset() override

  168.     {

  169.         chain.reset();

  170.         update();

  171.     }

  172. 

  173.     void releaseResources() override {}

  174. 

  175.     void processBlock (AudioBuffer<float>& buffer, MidiBuffer&) override

  176.     {

  177.         if (jmax (getTotalNumInputChannels(), getTotalNumOutputChannels()) == 0)

  178.             return;

  179. 

  180.         ScopedNoDenormals noDenormals;

  181. 

  182.         if (requiresUpdate.load())

  183.             update();

  184. 

  185.         irSize = dsp::get<convolutionIndex> (chain).reverb.getCurrentIRSize();

  186. 

  187.         const auto totalNumInputChannels  = getTotalNumInputChannels();

  188.         const auto totalNumOutputChannels = getTotalNumOutputChannels();

  189. 

  190.         setLatencySamples (dsp::get<convolutionIndex> (chain).getLatency()

  191.                            + (dsp::isBypassed<distortionIndex> (chain) ? 0 : roundToInt (dsp::get<distortionIndex> (chain).getLatency())));

  192. 

  193.         const auto numChannels = jmax (totalNumInputChannels, totalNumOutputChannels);

  194. 

  195.         auto inoutBlock = dsp::AudioBlock<float> (buffer).getSubsetChannelBlock (0, (size_t) numChannels);

  196.         chain.process (dsp::ProcessContextReplacing<float> (inoutBlock));

  197.     }

  198. 

  199.     void processBlock (AudioBuffer<double>&, MidiBuffer&) override {}

  200. 

  201.     //==============================================================================

  202.     AudioProcessorEditor* createEditor() override { return nullptr; }

  203.     bool hasEditor() const override { return false; }

  204. 

  205.     //==============================================================================

  206.     const String getName() const override { return "DSPModulePluginDemo"; }

  207. 

  208.     bool acceptsMidi()  const override { return false; }

  209.     bool producesMidi() const override { return false; }

  210.     bool isMidiEffect() const override { return false; }

  211. 

  212.     double getTailLengthSeconds() const override { return 0.0; }

  213. 

  214.     //==============================================================================

  215.     int getNumPrograms()    override { return 1; }

  216.     int getCurrentProgram() override { return 0; }

  217.     void setCurrentProgram (int) override {}

  218.     const String getProgramName (int) override { return "None"; }

  219. 

  220.     void changeProgramName (int, const String&) override {}

  221. 

  222.     //==============================================================================

  223.     bool isBusesLayoutSupported (const BusesLayout& layout) const override

  224.     {

  225.         return layout == BusesLayout { { AudioChannelSet::stereo() },

  226.                                        { AudioChannelSet::stereo() } };

  227.     }

  228. 

  229.     //==============================================================================

  230.     void getStateInformation (MemoryBlock& destData) override

  231.     {

  232.         copyXmlToBinary (*apvts.copyState().createXml(), destData);

  233.     }

  234. 

  235.     void setStateInformation (const void* data, int sizeInBytes) override

  236.     {

  237.         apvts.replaceState (ValueTree::fromXml (*getXmlFromBinary (data, sizeInBytes)));

  238.     }

  239. 

  240.     int getCurrentIRSize() const { return irSize; }

  241. 

  242.     using Parameter = AudioProcessorValueTreeState::Parameter;

  243.     using Attributes = AudioProcessorValueTreeStateParameterAttributes;

  244. 

  245.     // This struct holds references to the raw parameters, so that we don't have to search

  246.     // the APVTS (involving string comparisons and map lookups!) every time a parameter

  247.     // changes.

  248.     struct ParameterReferences

  249.     {

  250.         template <typename Param>

  251.         static void add (AudioProcessorParameterGroup& group, std::unique_ptr<Param> param)

  252.         {

  253.             group.addChild (std::move (param));

  254.         }

  255. 

  256.         template <typename Param>

  257.         static void add (AudioProcessorValueTreeState::ParameterLayout& group, std::unique_ptr<Param> param)

  258.         {

  259.             group.add (std::move (param));

  260.         }

  261. 

  262.         template <typename Param, typename Group, typename... Ts>

  263.         static Param& addToLayout (Group& layout, Ts&&... ts)

  264.         {

  265.             auto param = new Param (std::forward<Ts> (ts)...);

  266.             auto& ref = *param;

  267.             add (layout, rawToUniquePtr (param));

  268.             return ref;

  269.         }

  270. 

  271.         static String valueToTextFunction (float x, int) { return String (x, 2); }

  272.         static float textToValueFunction (const String& str) { return str.getFloatValue(); }

  273. 

  274.         static auto getBasicAttributes()

  275.         {

  276.             return Attributes().withStringFromValueFunction (valueToTextFunction)

  277.                                .withValueFromStringFunction (textToValueFunction);

  278.         }

  279. 

  280.         static auto getDbAttributes()           { return getBasicAttributes().withLabel ("dB"); }

  281.         static auto getMsAttributes()           { return getBasicAttributes().withLabel ("ms"); }

  282.         static auto getHzAttributes()           { return getBasicAttributes().withLabel ("Hz"); }

  283.         static auto getPercentageAttributes()   { return getBasicAttributes().withLabel ("%"); }

  284.         static auto getRatioAttributes()        { return getBasicAttributes().withLabel (":1"); }

  285. 

  286.         static String valueToTextPanFunction (float x, int) { return getPanningTextForValue ((x + 100.0f) / 200.0f); }

  287.         static float textToValuePanFunction (const String& str) { return getPanningValueForText (str) * 200.0f - 100.0f; }

  288. 

  289.         struct MainGroup

  290.         {

  291.             explicit MainGroup (AudioProcessorParameterGroup& layout)

  292.                 : inputGain (addToLayout<Parameter> (layout,

  293.                                                      ParameterID { ID::inputGain, 1 },

  294.                                                      "Input",

  295.                                                      NormalisableRange<float> (-40.0f, 40.0f),

  296.                                                      0.0f,

  297.                                                      getDbAttributes())),

  298.                   outputGain (addToLayout<Parameter> (layout,

  299.                                                       ParameterID { ID::outputGain, 1 },

  300.                                                       "Output",

  301.                                                       NormalisableRange<float> (-40.0f, 40.0f),

  302.                                                       0.0f,

  303.                                                       getDbAttributes())),

  304.                   pan (addToLayout<Parameter> (layout,

  305.                                                ParameterID { ID::pan, 1 },

  306.                                                "Panning",

  307.                                                NormalisableRange<float> (-100.0f, 100.0f),

  308.                                                0.0f,

  309.                                                Attributes().withStringFromValueFunction (valueToTextPanFunction)

  310.                                                            .withValueFromStringFunction (textToValuePanFunction))) {}

  311. 

  312.             Parameter& inputGain;

  313.             Parameter& outputGain;

  314.             Parameter& pan;

  315.         };

  316. 

  317.         struct DistortionGroup

  318.         {

  319.             explicit DistortionGroup (AudioProcessorParameterGroup& layout)

  320.                 : enabled (addToLayout<AudioParameterBool> (layout,

  321.                                                             ParameterID { ID::distortionEnabled, 1 },

  322.                                                             "Distortion",

  323.                                                             true)),

  324.                   type (addToLayout<AudioParameterChoice> (layout,

  325.                                                            ParameterID { ID::distortionType, 1 },

  326.                                                            "Waveshaper",

  327.                                                            StringArray { "std::tanh", "Approx. tanh" },

  328.                                                            0)),

  329.                   inGain (addToLayout<Parameter> (layout,

  330.                                                   ParameterID { ID::distortionInGain, 1 },

  331.                                                   "Gain",

  332.                                                   NormalisableRange<float> (-40.0f, 40.0f),

  333.                                                   0.0f,

  334.                                                   getDbAttributes())),

  335.                   lowpass (addToLayout<Parameter> (layout,

  336.                                                    ParameterID { ID::distortionLowpass, 1 },

  337.                                                    "Post Low-pass",

  338.                                                    NormalisableRange<float> (20.0f, 22000.0f, 0.0f, 0.25f),

  339.                                                    22000.0f,

  340.                                                    getHzAttributes())),

  341.                   highpass (addToLayout<Parameter> (layout,

  342.                                                     ParameterID { ID::distortionHighpass, 1 },

  343.                                                     "Pre High-pass",

  344.                                                     NormalisableRange<float> (20.0f, 22000.0f, 0.0f, 0.25f),

  345.                                                     20.0f,

  346.                                                     getHzAttributes())),

  347.                   compGain (addToLayout<Parameter> (layout,

  348.                                                     ParameterID { ID::distortionCompGain, 1 },

  349.                                                     "Compensat.",

  350.                                                     NormalisableRange<float> (-40.0f, 40.0f),

  351.                                                     0.0f,

  352.                                                     getDbAttributes())),

  353.                   mix (addToLayout<Parameter> (layout,

  354.                                                ParameterID { ID::distortionMix, 1 },

  355.                                                "Mix",

  356.                                                NormalisableRange<float> (0.0f, 100.0f),

  357.                                                100.0f,

  358.                                                getPercentageAttributes())),

  359.                   oversampler (addToLayout<AudioParameterChoice> (layout,

  360.                                                                   ParameterID { ID::distortionOversampler, 1 },

  361.                                                                   "Oversampling",

  362.                                                                   StringArray { "2X",

  363.                                                                                 "4X",

  364.                                                                                 "8X",

  365.                                                                                 "2X compensated",

  366.                                                                                 "4X compensated",

  367.                                                                                 "8X compensated" },

  368.                                                                   1)) {}

  369. 

  370.             AudioParameterBool& enabled;

  371.             AudioParameterChoice& type;

  372.             Parameter& inGain;

  373.             Parameter& lowpass;

  374.             Parameter& highpass;

  375.             Parameter& compGain;

  376.             Parameter& mix;

  377.             AudioParameterChoice& oversampler;

  378.         };

  379. 

  380.         struct MultiBandGroup

  381.         {

  382.             explicit MultiBandGroup (AudioProcessorParameterGroup& layout)

  383.                 : enabled (addToLayout<AudioParameterBool> (layout,

  384.                                                             ParameterID { ID::multiBandEnabled, 1 },

  385.                                                             "Multi-band",

  386.                                                             false)),

  387.                   freq (addToLayout<Parameter> (layout,

  388.                                                 ParameterID { ID::multiBandFreq, 1 },

  389.                                                 "Sep. Freq.",

  390.                                                 NormalisableRange<float> (20.0f, 22000.0f, 0.0f, 0.25f),

  391.                                                 2000.0f,

  392.                                                 getHzAttributes())),

  393.                   lowVolume (addToLayout<Parameter> (layout,

  394.                                                      ParameterID { ID::multiBandLowVolume, 1 },

  395.                                                      "Low volume",

  396.                                                      NormalisableRange<float> (-40.0f, 40.0f),

  397.                                                      0.0f,

  398.                                                      getDbAttributes())),

  399.                   highVolume (addToLayout<Parameter> (layout,

  400.                                                       ParameterID { ID::multiBandHighVolume, 1 },

  401.                                                       "High volume",

  402.                                                       NormalisableRange<float> (-40.0f, 40.0f),

  403.                                                       0.0f,

  404.                                                       getDbAttributes())) {}

  405. 

  406.             AudioParameterBool& enabled;

  407.             Parameter& freq;

  408.             Parameter& lowVolume;

  409.             Parameter& highVolume;

  410.         };

  411. 

  412.         struct ConvolutionGroup

  413.         {

  414.             explicit ConvolutionGroup (AudioProcessorParameterGroup& layout)

  415.                 : cabEnabled (addToLayout<AudioParameterBool> (layout,

  416.                                                                ParameterID { ID::convolutionCabEnabled, 1 },

  417.                                                                "Cabinet",

  418.                                                                false)),

  419.                   reverbEnabled (addToLayout<AudioParameterBool> (layout,

  420.                                                                   ParameterID { ID::convolutionReverbEnabled, 1 },

  421.                                                                   "Reverb",

  422.                                                                   false)),

  423.                   reverbMix (addToLayout<Parameter> (layout,

  424.                                                      ParameterID { ID::convolutionReverbMix, 1 },

  425.                                                      "Reverb Mix",

  426.                                                      NormalisableRange<float> (0.0f, 100.0f),

  427.                                                      50.0f,

  428.                                                      getPercentageAttributes())) {}

  429. 

  430.             AudioParameterBool& cabEnabled;

  431.             AudioParameterBool& reverbEnabled;

  432.             Parameter& reverbMix;

  433.         };

  434. 

  435.         struct CompressorGroup

  436.         {

  437.             explicit CompressorGroup (AudioProcessorParameterGroup& layout)

  438.                 : enabled (addToLayout<AudioParameterBool> (layout,

  439.                                                             ParameterID { ID::compressorEnabled, 1 },

  440.                                                             "Comp.",

  441.                                                             false)),

  442.                   threshold (addToLayout<Parameter> (layout,

  443.                                                      ParameterID { ID::compressorThreshold, 1 },

  444.                                                      "Threshold",

  445.                                                      NormalisableRange<float> (-100.0f, 0.0f),

  446.                                                      0.0f,

  447.                                                      getDbAttributes())),

  448.                   ratio (addToLayout<Parameter> (layout,

  449.                                                  ParameterID { ID::compressorRatio, 1 },

  450.                                                  "Ratio",

  451.                                                  NormalisableRange<float> (1.0f, 100.0f, 0.0f, 0.25f),

  452.                                                  1.0f,

  453.                                                  getRatioAttributes())),

  454.                   attack (addToLayout<Parameter> (layout,

  455.                                                   ParameterID { ID::compressorAttack, 1 },

  456.                                                   "Attack",

  457.                                                   NormalisableRange<float> (0.01f, 1000.0f, 0.0f, 0.25f),

  458.                                                   1.0f,

  459.                                                   getMsAttributes())),

  460.                   release (addToLayout<Parameter> (layout,

  461.                                                    ParameterID { ID::compressorRelease, 1 },

  462.                                                    "Release",

  463.                                                    NormalisableRange<float> (10.0f, 10000.0f, 0.0f, 0.25f),

  464.                                                    100.0f,

  465.                                                    getMsAttributes())) {}

  466. 

  467.             AudioParameterBool& enabled;

  468.             Parameter& threshold;

  469.             Parameter& ratio;

  470.             Parameter& attack;

  471.             Parameter& release;

  472.         };

  473. 

  474.         struct NoiseGateGroup

  475.         {

  476.             explicit NoiseGateGroup (AudioProcessorParameterGroup& layout)

  477.                 : enabled (addToLayout<AudioParameterBool> (layout,

  478.                                                             ParameterID { ID::noiseGateEnabled, 1 },

  479.                                                             "Gate",

  480.                                                             false)),

  481.                   threshold (addToLayout<Parameter> (layout,

  482.                                                      ParameterID { ID::noiseGateThreshold, 1 },

  483.                                                      "Threshold",

  484.                                                      NormalisableRange<float> (-100.0f, 0.0f),

  485.                                                      -100.0f,

  486.                                                      getDbAttributes())),

  487.                   ratio (addToLayout<Parameter> (layout,

  488.                                                  ParameterID { ID::noiseGateRatio, 1 },

  489.                                                  "Ratio",

  490.                                                  NormalisableRange<float> (1.0f, 100.0f, 0.0f, 0.25f),

  491.                                                  10.0f,

  492.                                                  getRatioAttributes())),

  493.                   attack (addToLayout<Parameter> (layout,

  494.                                                   ParameterID { ID::noiseGateAttack, 1 },

  495.                                                   "Attack",

  496.                                                   NormalisableRange<float> (0.01f, 1000.0f, 0.0f, 0.25f),

  497.                                                   1.0f,

  498.                                                   getMsAttributes())),

  499.                   release (addToLayout<Parameter> (layout,

  500.                                                    ParameterID { ID::noiseGateRelease, 1 },

  501.                                                    "Release",

  502.                                                    NormalisableRange<float> (10.0f, 10000.0f, 0.0f, 0.25f),

  503.                                                    100.0f,

  504.                                                    getMsAttributes())) {}

  505. 

  506.             AudioParameterBool& enabled;

  507.             Parameter& threshold;

  508.             Parameter& ratio;

  509.             Parameter& attack;

  510.             Parameter& release;

  511.         };

  512. 

  513.         struct LimiterGroup

  514.         {

  515.             explicit LimiterGroup (AudioProcessorParameterGroup& layout)

  516.                 : enabled (addToLayout<AudioParameterBool> (layout,

  517.                                                             ParameterID { ID::limiterEnabled, 1 },

  518.                                                             "Limiter",

  519.                                                             false)),

  520.                   threshold (addToLayout<Parameter> (layout,

  521.                                                      ParameterID { ID::limiterThreshold, 1 },

  522.                                                      "Threshold",

  523.                                                      NormalisableRange<float> (-40.0f, 0.0f),

  524.                                                      0.0f,

  525.                                                      getDbAttributes())),

  526.                   release (addToLayout<Parameter> (layout,

  527.                                                    ParameterID { ID::limiterRelease, 1 },

  528.                                                    "Release",

  529.                                                    NormalisableRange<float> (10.0f, 10000.0f, 0.0f, 0.25f),

  530.                                                    100.0f,

  531.                                                    getMsAttributes())) {}

  532. 

  533.             AudioParameterBool& enabled;

  534.             Parameter& threshold;

  535.             Parameter& release;

  536.         };

  537. 

  538.         struct DirectDelayGroup

  539.         {

  540.             explicit DirectDelayGroup (AudioProcessorParameterGroup& layout)

  541.                 : enabled (addToLayout<AudioParameterBool> (layout,

  542.                                                             ParameterID { ID::directDelayEnabled, 1 },

  543.                                                             "DL Dir.",

  544.                                                             false)),

  545.                   type (addToLayout<AudioParameterChoice> (layout,

  546.                                                            ParameterID { ID::directDelayType, 1 },

  547.                                                            "DL Type",

  548.                                                            StringArray { "None", "Linear", "Lagrange", "Thiran" },

  549.                                                            1)),

  550.                   value (addToLayout<Parameter> (layout,

  551.                                                  ParameterID { ID::directDelayValue, 1 },

  552.                                                  "Delay",

  553.                                                  NormalisableRange<float> (0.0f, 44100.0f),

  554.                                                  0.0f,

  555.                                                  getBasicAttributes().withLabel ("smps"))),

  556.                   smoothing (addToLayout<Parameter> (layout,

  557.                                                      ParameterID { ID::directDelaySmoothing, 1 },

  558.                                                      "Smooth",

  559.                                                      NormalisableRange<float> (20.0f, 10000.0f, 0.0f, 0.25f),

  560.                                                      200.0f,

  561.                                                      getMsAttributes())),

  562.                   mix (addToLayout<Parameter> (layout,

  563.                                                ParameterID { ID::directDelayMix, 1 },

  564.                                                "Delay Mix",

  565.                                                NormalisableRange<float> (0.0f, 100.0f),

  566.                                                50.0f,

  567.                                                getPercentageAttributes())) {}

  568. 

  569.             AudioParameterBool& enabled;

  570.             AudioParameterChoice& type;

  571.             Parameter& value;

  572.             Parameter& smoothing;

  573.             Parameter& mix;

  574.         };

  575. 

  576.         struct DelayEffectGroup

  577.         {

  578.             explicit DelayEffectGroup (AudioProcessorParameterGroup& layout)

  579.                 : enabled (addToLayout<AudioParameterBool> (layout,

  580.                                                             ParameterID { ID::delayEffectEnabled, 1 },

  581.                                                             "DL Effect",

  582.                                                             false)),

  583.                   type (addToLayout<AudioParameterChoice> (layout,

  584.                                                            ParameterID { ID::delayEffectType, 1 },

  585.                                                            "DL Type",

  586.                                                            StringArray { "None", "Linear", "Lagrange", "Thiran" },

  587.                                                            1)),

  588.                   value (addToLayout<Parameter> (layout,

  589.                                                  ParameterID { ID::delayEffectValue, 1 },

  590.                                                  "Delay",

  591.                                                  NormalisableRange<float> (0.01f, 1000.0f),

  592.                                                  100.0f,

  593.                                                  getMsAttributes())),

  594.                   smoothing (addToLayout<Parameter> (layout,

  595.                                                      ParameterID { ID::delayEffectSmoothing, 1 },

  596.                                                      "Smooth",

  597.                                                      NormalisableRange<float> (20.0f, 10000.0f, 0.0f, 0.25f),

  598.                                                      400.0f,

  599.                                                      getMsAttributes())),

  600.                   lowpass (addToLayout<Parameter> (layout,

  601.                                                    ParameterID { ID::delayEffectLowpass, 1 },

  602.                                                    "Low-pass",

  603.                                                    NormalisableRange<float> (20.0f, 22000.0f, 0.0f, 0.25f),

  604.                                                    22000.0f,

  605.                                                    getHzAttributes())),

  606.                   mix (addToLayout<Parameter> (layout,

  607.                                                ParameterID { ID::delayEffectMix, 1 },

  608.                                                "Delay Mix",

  609.                                                NormalisableRange<float> (0.0f, 100.0f),

  610.                                                50.0f,

  611.                                                getPercentageAttributes())),

  612.                   feedback (addToLayout<Parameter> (layout,

  613.                                                     ParameterID { ID::delayEffectFeedback, 1 },

  614.                                                     "Feedback",

  615.                                                     NormalisableRange<float> (-100.0f, 0.0f),

  616.                                                     -100.0f,

  617.                                                     getDbAttributes())) {}

  618. 

  619.             AudioParameterBool& enabled;

  620.             AudioParameterChoice& type;

  621.             Parameter& value;

  622.             Parameter& smoothing;

  623.             Parameter& lowpass;

  624.             Parameter& mix;

  625.             Parameter& feedback;

  626.         };

  627. 

  628.         struct PhaserGroup

  629.         {

  630.             explicit PhaserGroup (AudioProcessorParameterGroup& layout)

  631.                 : enabled (addToLayout<AudioParameterBool> (layout,

  632.                                                             ParameterID { ID::phaserEnabled, 1 },

  633.                                                             "Phaser",

  634.                                                             false)),

  635.                   rate (addToLayout<Parameter> (layout,

  636.                                                 ParameterID { ID::phaserRate, 1 },

  637.                                                 "Rate",

  638.                                                 NormalisableRange<float> (0.05f, 20.0f, 0.0f, 0.25f),

  639.                                                 1.0f,

  640.                                                 getHzAttributes())),

  641.                   depth (addToLayout<Parameter> (layout,

  642.                                                  ParameterID { ID::phaserDepth, 1 },

  643.                                                  "Depth",

  644.                                                  NormalisableRange<float> (0.0f, 100.0f),

  645.                                                  50.0f,

  646.                                                  getPercentageAttributes())),

  647.                   centreFrequency (addToLayout<Parameter> (layout,

  648.                                                            ParameterID { ID::phaserCentreFrequency, 1 },

  649.                                                            "Center",

  650.                                                            NormalisableRange<float> (20.0f, 20000.0f, 0.0f, 0.25f),

  651.                                                            600.0f,

  652.                                                            getHzAttributes())),

  653.                   feedback (addToLayout<Parameter> (layout,

  654.                                                     ParameterID { ID::phaserFeedback, 1 },

  655.                                                     "Feedback",

  656.                                                     NormalisableRange<float> (0.0f, 100.0f),

  657.                                                     50.0f,

  658.                                                     getPercentageAttributes())),

  659.                   mix (addToLayout<Parameter> (layout,

  660.                                                ParameterID { ID::phaserMix, 1 },

  661.                                                "Mix",

  662.                                                NormalisableRange<float> (0.0f, 100.0f),

  663.                                                50.0f,

  664.                                                getPercentageAttributes())) {}

  665. 

  666.             AudioParameterBool& enabled;

  667.             Parameter& rate;

  668.             Parameter& depth;

  669.             Parameter& centreFrequency;

  670.             Parameter& feedback;

  671.             Parameter& mix;

  672.         };

  673. 

  674.         struct ChorusGroup

  675.         {

  676.             explicit ChorusGroup (AudioProcessorParameterGroup& layout)

  677.                 : enabled (addToLayout<AudioParameterBool> (layout,

  678.                                                             ParameterID { ID::chorusEnabled, 1 },

  679.                                                             "Chorus",

  680.                                                             false)),

  681.                   rate (addToLayout<Parameter> (layout,

  682.                                                 ParameterID { ID::chorusRate, 1 },

  683.                                                 "Rate",

  684.                                                 NormalisableRange<float> (0.05f, 20.0f, 0.0f, 0.25f),

  685.                                                 1.0f,

  686.                                                 getHzAttributes())),

  687.                   depth (addToLayout<Parameter> (layout,

  688.                                                  ParameterID { ID::chorusDepth, 1 },

  689.                                                  "Depth",

  690.                                                  NormalisableRange<float> (0.0f, 100.0f),

  691.                                                  50.0f,

  692.                                                  getPercentageAttributes())),

  693.                   centreDelay (addToLayout<Parameter> (layout,

  694.                                                        ParameterID { ID::chorusCentreDelay, 1 },

  695.                                                        "Center",

  696.                                                        NormalisableRange<float> (1.0f, 100.0f, 0.0f, 0.25f),

  697.                                                        7.0f,

  698.                                                        getMsAttributes())),

  699.                   feedback (addToLayout<Parameter> (layout,

  700.                                                     ParameterID { ID::chorusFeedback, 1 },

  701.                                                     "Feedback",

  702.                                                     NormalisableRange<float> (0.0f, 100.0f),

  703.                                                     50.0f,

  704.                                                     getPercentageAttributes())),

  705.                   mix (addToLayout<Parameter> (layout,

  706.                                                ParameterID { ID::chorusMix, 1 },

  707.                                                "Mix",

  708.                                                NormalisableRange<float> (0.0f, 100.0f),

  709.                                                50.0f,

  710.                                                getPercentageAttributes())) {}

  711. 

  712.             AudioParameterBool& enabled;

  713.             Parameter& rate;

  714.             Parameter& depth;

  715.             Parameter& centreDelay;

  716.             Parameter& feedback;

  717.             Parameter& mix;

  718.         };

  719. 

  720.         struct LadderGroup

  721.         {

  722.             explicit LadderGroup (AudioProcessorParameterGroup& layout)

  723.                 : enabled (addToLayout<AudioParameterBool> (layout,

  724.                                                             ParameterID { ID::ladderEnabled, 1 },

  725.                                                             "Ladder",

  726.                                                             false)),

  727.                   mode (addToLayout<AudioParameterChoice> (layout,

  728.                                                            ParameterID { ID::ladderMode, 1 },

  729.                                                            "Mode",

  730.                                                            StringArray { "LP12", "LP24", "HP12", "HP24", "BP12", "BP24" },

  731.                                                            1)),

  732.                   cutoff (addToLayout<Parameter> (layout,

  733.                                                   ParameterID { ID::ladderCutoff, 1 },

  734.                                                   "Frequency",

  735.                                                   NormalisableRange<float> (10.0f, 22000.0f, 0.0f, 0.25f),

  736.                                                   1000.0f,

  737.                                                   getHzAttributes())),

  738.                   resonance (addToLayout<Parameter> (layout,

  739.                                                      ParameterID { ID::ladderResonance, 1 },

  740.                                                      "Resonance",

  741.                                                      NormalisableRange<float> (0.0f, 100.0f),

  742.                                                      0.0f,

  743.                                                      getPercentageAttributes())),

  744.                   drive (addToLayout<Parameter> (layout,

  745.                                                  ParameterID { ID::ladderDrive, 1 },

  746.                                                  "Drive",

  747.                                                  NormalisableRange<float> (0.0f, 40.0f),

  748.                                                  0.0f,

  749.                                                  getDbAttributes())) {}

  750. 

  751.             AudioParameterBool& enabled;

  752.             AudioParameterChoice& mode;

  753.             Parameter& cutoff;

  754.             Parameter& resonance;

  755.             Parameter& drive;

  756.         };

  757. 

  758.         explicit ParameterReferences (AudioProcessorValueTreeState::ParameterLayout& layout)

  759.             : main          (addToLayout<AudioProcessorParameterGroup> (layout, "main",          "Main",          "|")),

  760.               distortion    (addToLayout<AudioProcessorParameterGroup> (layout, "distortion",    "Distortion",    "|")),

  761.               multiBand     (addToLayout<AudioProcessorParameterGroup> (layout, "multiband",     "Multi Band",    "|")),

  762.               convolution   (addToLayout<AudioProcessorParameterGroup> (layout, "convolution",   "Convolution",   "|")),

  763.               compressor    (addToLayout<AudioProcessorParameterGroup> (layout, "compressor",    "Compressor",    "|")),

  764.               noiseGate     (addToLayout<AudioProcessorParameterGroup> (layout, "noisegate",     "Noise Gate",    "|")),

  765.               limiter       (addToLayout<AudioProcessorParameterGroup> (layout, "limiter",       "Limiter",       "|")),

  766.               directDelay   (addToLayout<AudioProcessorParameterGroup> (layout, "directdelay",   "Direct Delay",  "|")),

  767.               delayEffect   (addToLayout<AudioProcessorParameterGroup> (layout, "delayeffect",   "Delay Effect",  "|")),

  768.               phaser        (addToLayout<AudioProcessorParameterGroup> (layout, "phaser",        "Phaser",        "|")),

  769.               chorus        (addToLayout<AudioProcessorParameterGroup> (layout, "chorus",        "Chorus",        "|")),

  770.               ladder        (addToLayout<AudioProcessorParameterGroup> (layout, "ladder",        "Ladder",        "|")) {}

  771. 

  772.         MainGroup main;

  773.         DistortionGroup distortion;

  774.         MultiBandGroup multiBand;

  775.         ConvolutionGroup convolution;

  776.         CompressorGroup compressor;

  777.         NoiseGateGroup noiseGate;

  778.         LimiterGroup limiter;

  779.         DirectDelayGroup directDelay;

  780.         DelayEffectGroup delayEffect;

  781.         PhaserGroup phaser;

  782.         ChorusGroup chorus;

  783.         LadderGroup ladder;

  784.     };

  785. 

  786.     const ParameterReferences& getParameterValues() const noexcept { return parameters; }

  787. 

  788.     //==============================================================================

  789.     // We store this here so that the editor retains its state if it is closed and reopened

  790.     int indexTab = 0;

  791. 

  792. private:

  793.     struct LayoutAndReferences

  794.     {

  795.         AudioProcessorValueTreeState::ParameterLayout layout;

  796.         ParameterReferences references;

  797.     };

  798. 

  799.     explicit DspModulePluginDemo (AudioProcessorValueTreeState::ParameterLayout layout)

  800.         : AudioProcessor (BusesProperties().withInput ("In",   AudioChannelSet::stereo())

  801.                                            .withOutput ("Out", AudioChannelSet::stereo())),

  802.           parameters { layout },

  803.           apvts { *this, nullptr, "state", std::move (layout) }

  804.     {

  805.         apvts.state.addListener (this);

  806. 

  807.         forEach ([] (dsp::Gain<float>& gain) { gain.setRampDurationSeconds (0.05); },

  808.                  dsp::get<inputGainIndex>  (chain),

  809.                  dsp::get<outputGainIndex> (chain));

  810. 

  811.         dsp::get<pannerIndex> (chain).setRule (dsp::PannerRule::linear);

  812.     }

  813. 

  814.     //==============================================================================

  815.     void valueTreePropertyChanged (ValueTree&, const Identifier&) override

  816.     {

  817.         requiresUpdate.store (true);

  818.     }

  819. 

  820.     //==============================================================================

  821.     void update()

  822.     {

  823.         {

  824.             DistortionProcessor& distortion = dsp::get<distortionIndex> (chain);

  825. 

  826.             if (distortion.currentIndexOversampling != parameters.distortion.oversampler.getIndex())

  827.             {

  828.                 distortion.currentIndexOversampling = parameters.distortion.oversampler.getIndex();

  829.                 prepareToPlay (getSampleRate(), getBlockSize());

  830.                 return;

  831.             }

  832. 

  833.             distortion.currentIndexWaveshaper = parameters.distortion.type.getIndex();

  834.             distortion.lowpass .setCutoffFrequency (parameters.distortion.lowpass.get());

  835.             distortion.highpass.setCutoffFrequency (parameters.distortion.highpass.get());

  836.             distortion.distGain.setGainDecibels (parameters.distortion.inGain.get());

  837.             distortion.compGain.setGainDecibels (parameters.distortion.compGain.get());

  838.             distortion.mixer.setWetMixProportion (parameters.distortion.mix.get() / 100.0f);

  839.             dsp::setBypassed<distortionIndex> (chain, ! parameters.distortion.enabled);

  840.         }

  841. 

  842.         {

  843.             ConvolutionProcessor& convolution = dsp::get<convolutionIndex> (chain);

  844.             convolution.cabEnabled    = parameters.convolution.cabEnabled;

  845.             convolution.reverbEnabled = parameters.convolution.reverbEnabled;

  846.             convolution.mixer.setWetMixProportion (parameters.convolution.reverbMix.get() / 100.0f);

  847.         }

  848. 

  849.         dsp::get<inputGainIndex>  (chain).setGainDecibels (parameters.main.inputGain.get());

  850.         dsp::get<outputGainIndex> (chain).setGainDecibels (parameters.main.outputGain.get());

  851.         dsp::get<pannerIndex> (chain).setPan (parameters.main.pan.get() / 100.0f);

  852. 

  853.         {

  854.             MultiBandProcessor& multiband = dsp::get<multiBandIndex> (chain);

  855.             const auto multibandFreq = parameters.multiBand.freq.get();

  856.             multiband.lowpass .setCutoffFrequency (multibandFreq);

  857.             multiband.highpass.setCutoffFrequency (multibandFreq);

  858.             const bool enabled = parameters.multiBand.enabled;

  859.             multiband.lowVolume .setGainDecibels (enabled ? parameters.multiBand.lowVolume .get() : 0.0f);

  860.             multiband.highVolume.setGainDecibels (enabled ? parameters.multiBand.highVolume.get() : 0.0f);

  861.             dsp::setBypassed<multiBandIndex> (chain, ! enabled);

  862.         }

  863. 

  864.         {

  865.             dsp::Compressor<float>& compressor = dsp::get<compressorIndex> (chain);

  866.             compressor.setThreshold (parameters.compressor.threshold.get());

  867.             compressor.setRatio     (parameters.compressor.ratio.get());

  868.             compressor.setAttack    (parameters.compressor.attack.get());

  869.             compressor.setRelease   (parameters.compressor.release.get());

  870.             dsp::setBypassed<compressorIndex> (chain, ! parameters.compressor.enabled);

  871.         }

  872. 

  873.         {

  874.             dsp::NoiseGate<float>& noiseGate = dsp::get<noiseGateIndex> (chain);

  875.             noiseGate.setThreshold (parameters.noiseGate.threshold.get());

  876.             noiseGate.setRatio     (parameters.noiseGate.ratio.get());

  877.             noiseGate.setAttack    (parameters.noiseGate.attack.get());

  878.             noiseGate.setRelease   (parameters.noiseGate.release.get());

  879.             dsp::setBypassed<noiseGateIndex> (chain, ! parameters.noiseGate.enabled);

  880.         }

  881. 

  882.         {

  883.             dsp::Limiter<float>& limiter = dsp::get<limiterIndex> (chain);

  884.             limiter.setThreshold (parameters.limiter.threshold.get());

  885.             limiter.setRelease   (parameters.limiter.release.get());

  886.             dsp::setBypassed<limiterIndex> (chain, ! parameters.limiter.enabled);

  887.         }

  888. 

  889.         {

  890.             DirectDelayProcessor& delay = dsp::get<directDelayIndex> (chain);

  891.             delay.delayLineDirectType = parameters.directDelay.type.getIndex();

  892. 

  893.             std::fill (delay.delayDirectValue.begin(),

  894.                        delay.delayDirectValue.end(),

  895.                        (double) parameters.directDelay.value.get());

  896. 

  897.             delay.smoothFilter.setCutoffFrequency (1000.0 / parameters.directDelay.smoothing.get());

  898.             delay.mixer.setWetMixProportion (parameters.directDelay.mix.get() / 100.0f);

  899.             dsp::setBypassed<directDelayIndex> (chain, ! parameters.directDelay.enabled);

  900.         }

  901. 

  902.         {

  903.             DelayEffectProcessor& delay = dsp::get<delayEffectIndex> (chain);

  904.             delay.delayEffectType = parameters.delayEffect.type.getIndex();

  905. 

  906.             std::fill (delay.delayEffectValue.begin(),

  907.                        delay.delayEffectValue.end(),

  908.                        (double) parameters.delayEffect.value.get() / 1000.0 * getSampleRate());

  909. 

  910.             const auto feedbackGain = Decibels::decibelsToGain (parameters.delayEffect.feedback.get(), -100.0f);

  911. 

  912.             for (auto& volume : delay.delayFeedbackVolume)

  913.                 volume.setTargetValue (feedbackGain);

  914. 

  915.             delay.smoothFilter.setCutoffFrequency (1000.0 / parameters.delayEffect.smoothing.get());

  916.             delay.lowpass.setCutoffFrequency (parameters.delayEffect.lowpass.get());

  917.             delay.mixer.setWetMixProportion (parameters.delayEffect.mix.get() / 100.0f);

  918.             dsp::setBypassed<delayEffectIndex> (chain, ! parameters.delayEffect.enabled);

  919.         }

  920. 

  921.         {

  922.             dsp::Phaser<float>& phaser = dsp::get<phaserIndex> (chain);

  923.             phaser.setRate            (parameters.phaser.rate.get());

  924.             phaser.setDepth           (parameters.phaser.depth.get() / 100.0f);

  925.             phaser.setCentreFrequency (parameters.phaser.centreFrequency.get());

  926.             phaser.setFeedback        (parameters.phaser.feedback.get() / 100.0f * 0.95f);

  927.             phaser.setMix             (parameters.phaser.mix.get() / 100.0f);

  928.             dsp::setBypassed<phaserIndex> (chain, ! parameters.phaser.enabled);

  929.         }

  930. 

  931.         {

  932.             dsp::Chorus<float>& chorus = dsp::get<chorusIndex> (chain);

  933.             chorus.setRate        (parameters.chorus.rate.get());

  934.             chorus.setDepth       (parameters.chorus.depth.get() / 100.0f);

  935.             chorus.setCentreDelay (parameters.chorus.centreDelay.get());

  936.             chorus.setFeedback    (parameters.chorus.feedback.get() / 100.0f * 0.95f);

  937.             chorus.setMix         (parameters.chorus.mix.get() / 100.0f);

  938.             dsp::setBypassed<chorusIndex> (chain, ! parameters.chorus.enabled);

  939.         }

  940. 

  941.         {

  942.             dsp::LadderFilter<float>& ladder = dsp::get<ladderIndex> (chain);

  943. 

  944.             ladder.setCutoffFrequencyHz (parameters.ladder.cutoff.get());

  945.             ladder.setResonance         (parameters.ladder.resonance.get() / 100.0f);

  946.             ladder.setDrive (Decibels::decibelsToGain (parameters.ladder.drive.get()));

  947. 

  948.             ladder.setMode ([&]

  949.             {

  950.                 switch (parameters.ladder.mode.getIndex())

  951.                 {

  952.                     case 0: return dsp::LadderFilterMode::LPF12;

  953.                     case 1: return dsp::LadderFilterMode::LPF24;

  954.                     case 2: return dsp::LadderFilterMode::HPF12;

  955.                     case 3: return dsp::LadderFilterMode::HPF24;

  956.                     case 4: return dsp::LadderFilterMode::BPF12;

  957. 

  958.                     default: break;

  959.                 }

  960. 

  961.                 return dsp::LadderFilterMode::BPF24;

  962.             }());

  963. 

  964.             dsp::setBypassed<ladderIndex> (chain, ! parameters.ladder.enabled);

  965.         }

  966. 

  967.         requiresUpdate.store (false);

  968.     }

  969. 

  970.     //==============================================================================

  971.     static String getPanningTextForValue (float value)

  972.     {

  973.         if (value == 0.5f)

  974.             return "center";

  975. 

  976.         if (value < 0.5f)

  977.             return String (roundToInt ((0.5f - value) * 200.0f)) + "%L";

  978. 

  979.         return String (roundToInt ((value - 0.5f) * 200.0f)) + "%R";

  980.     }

  981. 

  982.     static float getPanningValueForText (String strText)

  983.     {

  984.         if (strText.compareIgnoreCase ("center") == 0 || strText.compareIgnoreCase ("c") == 0)

  985.             return 0.5f;

  986. 

  987.         strText = strText.trim();

  988. 

  989.         if (strText.indexOfIgnoreCase ("%L") != -1)

  990.         {

  991.             auto percentage = (float) strText.substring (0, strText.indexOf ("%")).getDoubleValue();

  992.             return (100.0f - percentage) / 100.0f * 0.5f;

  993.         }

  994. 

  995.         if (strText.indexOfIgnoreCase ("%R") != -1)

  996.         {

  997.             auto percentage = (float) strText.substring (0, strText.indexOf ("%")).getDoubleValue();

  998.             return percentage / 100.0f * 0.5f + 0.5f;

  999.         }

  1000. 

  1001.         return 0.5f;

  1002.     }

  1003. 

  1004.     //==============================================================================

  1005.     struct DistortionProcessor

  1006.     {

  1007.         DistortionProcessor()

  1008.         {

  1009.             forEach ([] (dsp::Gain<float>& gain) { gain.setRampDurationSeconds (0.05); },

  1010.                      distGain,

  1011.                      compGain);

  1012. 

  1013.             lowpass.setType  (dsp::FirstOrderTPTFilterType::lowpass);

  1014.             highpass.setType (dsp::FirstOrderTPTFilterType::highpass);

  1015.             mixer.setMixingRule (dsp::DryWetMixingRule::linear);

  1016.         }

  1017. 

  1018.         void prepare (const dsp::ProcessSpec& spec)

  1019.         {

  1020.             for (auto& oversampler : oversamplers)

  1021.                 oversampler.initProcessing (spec.maximumBlockSize);

  1022. 

  1023.             prepareAll (spec, lowpass, highpass, distGain, compGain, mixer);

  1024.         }

  1025. 

  1026.         void reset()

  1027.         {

  1028.             for (auto& oversampler : oversamplers)

  1029.                 oversampler.reset();

  1030. 

  1031.             resetAll (lowpass, highpass, distGain, compGain, mixer);

  1032.         }

  1033. 

  1034.         float getLatency() const

  1035.         {

  1036.             return oversamplers[size_t (currentIndexOversampling)].getLatencyInSamples();

  1037.         }

  1038. 

  1039.         template <typename Context>

  1040.         void process (Context& context)

  1041.         {

  1042.             if (context.isBypassed)

  1043.                 return;

  1044. 

  1045.             const auto& inputBlock = context.getInputBlock();

  1046. 

  1047.             mixer.setWetLatency (getLatency());

  1048.             mixer.pushDrySamples (inputBlock);

  1049. 

  1050.             distGain.process (context);

  1051.             highpass.process (context);

  1052. 

  1053.             auto ovBlock = oversamplers[size_t (currentIndexOversampling)].processSamplesUp (inputBlock);

  1054. 

  1055.             dsp::ProcessContextReplacing<float> waveshaperContext (ovBlock);

  1056. 

  1057.             if (isPositiveAndBelow (currentIndexWaveshaper, waveShapers.size()))

  1058.             {

  1059.                 waveShapers[size_t (currentIndexWaveshaper)].process (waveshaperContext);

  1060. 

  1061.                 if (currentIndexWaveshaper == 1)

  1062.                     clipping.process (waveshaperContext);

  1063. 

  1064.                 waveshaperContext.getOutputBlock() *= 0.7f;

  1065.             }

  1066. 

  1067.             auto& outputBlock = context.getOutputBlock();

  1068.             oversamplers[size_t (currentIndexOversampling)].processSamplesDown (outputBlock);

  1069. 

  1070.             lowpass.process (context);

  1071.             compGain.process (context);

  1072.             mixer.mixWetSamples (outputBlock);

  1073.         }

  1074. 

  1075.         std::array<dsp::Oversampling<float>, 6> oversamplers

  1076.         { {

  1077.             { 2, 1, dsp::Oversampling<float>::filterHalfBandPolyphaseIIR, true, false },

  1078.             { 2, 2, dsp::Oversampling<float>::filterHalfBandPolyphaseIIR, true, false },

  1079.             { 2, 3, dsp::Oversampling<float>::filterHalfBandPolyphaseIIR, true, false },

  1080. 

  1081.             { 2, 1, dsp::Oversampling<float>::filterHalfBandPolyphaseIIR, true, true },

  1082.             { 2, 2, dsp::Oversampling<float>::filterHalfBandPolyphaseIIR, true, true },

  1083.             { 2, 3, dsp::Oversampling<float>::filterHalfBandPolyphaseIIR, true, true },

  1084.         } };

  1085. 

  1086.         static float clip (float in) { return juce::jlimit (-1.0f, 1.0f, in); }

  1087. 

  1088.         dsp::FirstOrderTPTFilter<float> lowpass, highpass;

  1089.         dsp::Gain<float> distGain, compGain;

  1090.         dsp::DryWetMixer<float> mixer { 10 };

  1091.         std::array<dsp::WaveShaper<float>, 2> waveShapers { { { std::tanh },

  1092.                                                               { dsp::FastMathApproximations::tanh } } };

  1093.         dsp::WaveShaper<float> clipping { clip };

  1094.         int currentIndexOversampling = 0;

  1095.         int currentIndexWaveshaper   = 0;

  1096.     };

  1097. 

  1098.     struct ConvolutionProcessor

  1099.     {

  1100.         ConvolutionProcessor()

  1101.         {

  1102.             loadImpulseResponse (cabinet, "guitar_amp.wav");

  1103.             loadImpulseResponse (reverb,  "reverb_ir.wav");

  1104.             mixer.setMixingRule (dsp::DryWetMixingRule::balanced);

  1105.         }

  1106. 

  1107.         void prepare (const dsp::ProcessSpec& spec)

  1108.         {

  1109.             prepareAll (spec, cabinet, reverb, mixer);

  1110.         }

  1111. 

  1112.         void reset()

  1113.         {

  1114.             resetAll (cabinet, reverb, mixer);

  1115.         }

  1116. 

  1117.         template <typename Context>

  1118.         void process (Context& context)

  1119.         {

  1120.             auto contextConv = context;

  1121.             contextConv.isBypassed = (! cabEnabled) || context.isBypassed;

  1122.             cabinet.process (contextConv);

  1123. 

  1124.             if (cabEnabled)

  1125.                 context.getOutputBlock().multiplyBy (4.0f);

  1126. 

  1127.             if (reverbEnabled)

  1128.                 mixer.pushDrySamples (context.getInputBlock());

  1129. 

  1130.             contextConv.isBypassed = (! reverbEnabled) || context.isBypassed;

  1131.             reverb.process (contextConv);

  1132. 

  1133.             if (reverbEnabled)

  1134.             {

  1135.                 const auto& outputBlock = context.getOutputBlock();

  1136.                 outputBlock.multiplyBy (4.0f);

  1137.                 mixer.mixWetSamples (outputBlock);

  1138.             }

  1139.         }

  1140. 

  1141.         int getLatency() const

  1142.         {

  1143.             auto latency = 0;

  1144. 

  1145.             if (cabEnabled)

  1146.                 latency += cabinet.getLatency();

  1147. 

  1148.             if (reverbEnabled)

  1149.                 latency += reverb.getLatency();

  1150. 

  1151.             return latency;

  1152.         }

  1153. 

  1154.         dsp::ConvolutionMessageQueue queue;

  1155.         dsp::Convolution cabinet { dsp::Convolution::NonUniform { 512 }, queue };

  1156.         dsp::Convolution reverb { dsp::Convolution::NonUniform { 512 }, queue };

  1157.         dsp::DryWetMixer<float> mixer;

  1158.         bool cabEnabled = false, reverbEnabled = false;

  1159. 

  1160.     private:

  1161.         static void loadImpulseResponse (dsp::Convolution& convolution, const char* filename)

  1162.         {

  1163.             auto stream = createAssetInputStream (filename);

  1164. 

  1165.             if (stream == nullptr)

  1166.             {

  1167.                 jassertfalse;

  1168.                 return;

  1169.             }

  1170. 

  1171.             AudioFormatManager manager;

  1172.             manager.registerBasicFormats();

  1173.             std::unique_ptr<AudioFormatReader> reader { manager.createReaderFor (std::move (stream)) };

  1174. 

  1175.             if (reader == nullptr)

  1176.             {

  1177.                 jassertfalse;

  1178.                 return;

  1179.             }

  1180. 

  1181.             AudioBuffer<float> buffer (static_cast<int> (reader->numChannels),

  1182.                                        static_cast<int> (reader->lengthInSamples));

  1183.             reader->read (buffer.getArrayOfWritePointers(), buffer.getNumChannels(), 0, buffer.getNumSamples());

  1184. 

  1185.             convolution.loadImpulseResponse (std::move (buffer),

  1186.                                              reader->sampleRate,

  1187.                                              dsp::Convolution::Stereo::yes,

  1188.                                              dsp::Convolution::Trim::yes,

  1189.                                              dsp::Convolution::Normalise::yes);

  1190.         }

  1191.     };

  1192. 

  1193.     struct MultiBandProcessor

  1194.     {

  1195.         MultiBandProcessor()

  1196.         {

  1197.             forEach ([] (dsp::Gain<float>& gain) { gain.setRampDurationSeconds (0.05); },

  1198.                      lowVolume,

  1199.                      highVolume);

  1200. 

  1201.             lowpass .setType (dsp::LinkwitzRileyFilterType::lowpass);

  1202.             highpass.setType (dsp::LinkwitzRileyFilterType::highpass);

  1203.         }

  1204. 

  1205.         void prepare (const dsp::ProcessSpec& spec)

  1206.         {

  1207.             prepareAll (spec, lowpass, highpass, lowVolume, highVolume);

  1208.             bufferSeparation.setSize (4, int (spec.maximumBlockSize), false, false, true);

  1209.         }

  1210. 

  1211.         void reset()

  1212.         {

  1213.             resetAll (lowpass, highpass, lowVolume, highVolume);

  1214.         }

  1215. 

  1216.         template <typename Context>

  1217.         void process (Context& context)

  1218.         {

  1219.             const auto& inputBlock = context.getInputBlock();

  1220. 

  1221.             const auto numSamples  = inputBlock.getNumSamples();

  1222.             const auto numChannels = inputBlock.getNumChannels();

  1223. 

  1224.             auto sepBlock = dsp::AudioBlock<float> (bufferSeparation).getSubBlock (0, (size_t) numSamples);

  1225. 

  1226.             auto sepLowBlock  = sepBlock.getSubsetChannelBlock (0, (size_t) numChannels);

  1227.             auto sepHighBlock = sepBlock.getSubsetChannelBlock (2, (size_t) numChannels);

  1228. 

  1229.             sepLowBlock .copyFrom (inputBlock);

  1230.             sepHighBlock.copyFrom (inputBlock);

  1231. 

  1232.             auto contextLow = dsp::ProcessContextReplacing<float> (sepLowBlock);

  1233.             contextLow.isBypassed = context.isBypassed;

  1234.             lowpass  .process (contextLow);

  1235.             lowVolume.process (contextLow);

  1236. 

  1237.             auto contextHigh = dsp::ProcessContextReplacing<float> (sepHighBlock);

  1238.             contextHigh.isBypassed = context.isBypassed;

  1239.             highpass  .process (contextHigh);

  1240.             highVolume.process (contextHigh);

  1241. 

  1242.             if (! context.isBypassed)

  1243.             {

  1244.                 sepLowBlock.add (sepHighBlock);

  1245.                 context.getOutputBlock().copyFrom (sepLowBlock);

  1246.             }

  1247.         }

  1248. 

  1249.         dsp::LinkwitzRileyFilter<float> lowpass, highpass;

  1250.         dsp::Gain<float> lowVolume, highVolume;

  1251.         AudioBuffer<float> bufferSeparation;

  1252.     };

  1253. 

  1254.     struct DirectDelayProcessor

  1255.     {

  1256.         DirectDelayProcessor()

  1257.         {

  1258.             smoothFilter.setType (dsp::FirstOrderTPTFilterType::lowpass);

  1259.             mixer.setMixingRule (dsp::DryWetMixingRule::linear);

  1260.         }

  1261. 

  1262.         void prepare (const dsp::ProcessSpec& spec)

  1263.         {

  1264.             prepareAll (spec, noInterpolation, linear, lagrange, thiran, smoothFilter, mixer);

  1265.         }

  1266. 

  1267.         void reset()

  1268.         {

  1269.             resetAll (noInterpolation, linear, lagrange, thiran, smoothFilter, mixer);

  1270.         }

  1271. 

  1272.         template <typename Context>

  1273.         void process (Context& context)

  1274.         {

  1275.             if (context.isBypassed)

  1276.                 return;

  1277. 

  1278.             const auto& inputBlock  = context.getInputBlock();

  1279.             const auto& outputBlock = context.getOutputBlock();

  1280. 

  1281.             mixer.pushDrySamples (inputBlock);

  1282. 

  1283.             const auto numChannels = inputBlock.getNumChannels();

  1284.             const auto numSamples  = inputBlock.getNumSamples();

  1285. 

  1286.             for (size_t channel = 0; channel < numChannels; ++channel)

  1287.             {

  1288.                 auto* samplesIn  = inputBlock .getChannelPointer (channel);

  1289.                 auto* samplesOut = outputBlock.getChannelPointer (channel);

  1290. 

  1291.                 for (size_t i = 0; i < numSamples; ++i)

  1292.                 {

  1293.                     const auto delay = smoothFilter.processSample (int (channel), delayDirectValue[channel]);

  1294. 

  1295.                     samplesOut[i] = [&]

  1296.                     {

  1297.                         switch (delayLineDirectType)

  1298.                         {

  1299.                             case 0:

  1300.                                 noInterpolation.pushSample (int (channel), samplesIn[i]);

  1301.                                 noInterpolation.setDelay ((float) delay);

  1302.                                 return noInterpolation.popSample (int (channel));

  1303. 

  1304.                             case 1:

  1305.                                 linear.pushSample (int (channel), samplesIn[i]);

  1306.                                 linear.setDelay ((float) delay);

  1307.                                 return linear.popSample (int (channel));

  1308. 

  1309.                             case 2:

  1310.                                 lagrange.pushSample (int (channel), samplesIn[i]);

  1311.                                 lagrange.setDelay ((float) delay);

  1312.                                 return lagrange.popSample (int (channel));

  1313. 

  1314.                             case 3:

  1315.                                 thiran.pushSample (int (channel), samplesIn[i]);

  1316.                                 thiran.setDelay ((float) delay);

  1317.                                 return thiran.popSample (int (channel));

  1318. 

  1319.                             default:

  1320.                                 break;

  1321.                         }

  1322. 

  1323.                         jassertfalse;

  1324.                         return 0.0f;

  1325.                     }();

  1326.                 }

  1327.             }

  1328. 

  1329.             mixer.mixWetSamples (outputBlock);

  1330.         }

  1331. 

  1332.         static constexpr auto directDelayBufferSize = 44100;

  1333.         dsp::DelayLine<float, dsp::DelayLineInterpolationTypes::None>        noInterpolation { directDelayBufferSize };

  1334.         dsp::DelayLine<float, dsp::DelayLineInterpolationTypes::Linear>      linear          { directDelayBufferSize };

  1335.         dsp::DelayLine<float, dsp::DelayLineInterpolationTypes::Lagrange3rd> lagrange        { directDelayBufferSize };

  1336.         dsp::DelayLine<float, dsp::DelayLineInterpolationTypes::Thiran>      thiran          { directDelayBufferSize };

  1337. 

  1338.         // Double precision to avoid some approximation issues

  1339.         dsp::FirstOrderTPTFilter<double> smoothFilter;

  1340. 

  1341.         dsp::DryWetMixer<float> mixer;

  1342.         std::array<double, 2> delayDirectValue { {} };

  1343. 

  1344.         int delayLineDirectType = 1;

  1345.     };

  1346. 

  1347.     struct DelayEffectProcessor

  1348.     {

  1349.         DelayEffectProcessor()

  1350.         {

  1351.             smoothFilter.setType (dsp::FirstOrderTPTFilterType::lowpass);

  1352.             lowpass.setType      (dsp::FirstOrderTPTFilterType::lowpass);

  1353.             mixer.setMixingRule (dsp::DryWetMixingRule::linear);

  1354.         }

  1355. 

  1356.         void prepare (const dsp::ProcessSpec& spec)

  1357.         {

  1358.             prepareAll (spec, noInterpolation, linear, lagrange, thiran, smoothFilter, lowpass, mixer);

  1359. 

  1360.             for (auto& volume : delayFeedbackVolume)

  1361.                 volume.reset (spec.sampleRate, 0.05);

  1362.         }

  1363. 

  1364.         void reset()

  1365.         {

  1366.             resetAll (noInterpolation, linear, lagrange, thiran, smoothFilter, lowpass, mixer);

  1367.             std::fill (lastDelayEffectOutput.begin(), lastDelayEffectOutput.end(), 0.0f);

  1368.         }

  1369. 

  1370.         template <typename Context>

  1371.         void process (Context& context)

  1372.         {

  1373.             if (context.isBypassed)

  1374.                 return;

  1375. 

  1376.             const auto& inputBlock  = context.getInputBlock();

  1377.             const auto& outputBlock = context.getOutputBlock();

  1378.             const auto numSamples  = inputBlock.getNumSamples();

  1379.             const auto numChannels = inputBlock.getNumChannels();

  1380. 

  1381.             mixer.pushDrySamples (inputBlock);

  1382. 

  1383.             for (size_t channel = 0; channel < numChannels; ++channel)

  1384.             {

  1385.                 auto* samplesIn  = inputBlock .getChannelPointer (channel);

  1386.                 auto* samplesOut = outputBlock.getChannelPointer (channel);

  1387. 

  1388.                 for (size_t i = 0; i < numSamples; ++i)

  1389.                 {

  1390.                     auto input = samplesIn[i] - lastDelayEffectOutput[channel];

  1391. 

  1392.                     auto delay = smoothFilter.processSample (int (channel), delayEffectValue[channel]);

  1393. 

  1394.                     const auto output = [&]

  1395.                     {

  1396.                         switch (delayEffectType)

  1397.                         {

  1398.                             case 0:

  1399.                                 noInterpolation.pushSample (int (channel), input);

  1400.                                 noInterpolation.setDelay ((float) delay);

  1401.                                 return noInterpolation.popSample (int (channel));

  1402. 

  1403.                             case 1:

  1404.                                 linear.pushSample (int (channel), input);

  1405.                                 linear.setDelay ((float) delay);

  1406.                                 return linear.popSample (int (channel));

  1407. 

  1408.                             case 2:

  1409.                                 lagrange.pushSample (int (channel), input);

  1410.                                 lagrange.setDelay ((float) delay);

  1411.                                 return lagrange.popSample (int (channel));

  1412. 

  1413.                             case 3:

  1414.                                 thiran.pushSample (int (channel), input);

  1415.                                 thiran.setDelay ((float) delay);

  1416.                                 return thiran.popSample (int (channel));

  1417. 

  1418.                             default:

  1419.                                 break;

  1420.                         }

  1421. 

  1422.                         jassertfalse;

  1423.                         return 0.0f;

  1424.                     }();

  1425. 

  1426.                     const auto processed = lowpass.processSample (int (channel), output);

  1427. 

  1428.                     samplesOut[i] = processed;

  1429.                     lastDelayEffectOutput[channel] = processed * delayFeedbackVolume[channel].getNextValue();

  1430.                 }

  1431.             }

  1432. 

  1433.             mixer.mixWetSamples (outputBlock);

  1434.         }

  1435. 

  1436.         static constexpr auto effectDelaySamples = 192000;

  1437.         dsp::DelayLine<float, dsp::DelayLineInterpolationTypes::None>        noInterpolation { effectDelaySamples };

  1438.         dsp::DelayLine<float, dsp::DelayLineInterpolationTypes::Linear>      linear          { effectDelaySamples };

  1439.         dsp::DelayLine<float, dsp::DelayLineInterpolationTypes::Lagrange3rd> lagrange        { effectDelaySamples };

  1440.         dsp::DelayLine<float, dsp::DelayLineInterpolationTypes::Thiran>      thiran          { effectDelaySamples };

  1441. 

  1442.         // Double precision to avoid some approximation issues

  1443.         dsp::FirstOrderTPTFilter<double> smoothFilter;

  1444. 

  1445.         std::array<double, 2> delayEffectValue;

  1446. 

  1447.         std::array<LinearSmoothedValue<float>, 2> delayFeedbackVolume;

  1448.         dsp::FirstOrderTPTFilter<float> lowpass;

  1449.         dsp::DryWetMixer<float> mixer;

  1450.         std::array<float, 2> lastDelayEffectOutput;

  1451. 

  1452.         int delayEffectType = 1;

  1453.     };

  1454. 

  1455.     ParameterReferences parameters;

  1456.     AudioProcessorValueTreeState apvts;

  1457. 

  1458.     using Chain = dsp::ProcessorChain<dsp::NoiseGate<float>,

  1459.                                       dsp::Gain<float>,

  1460.                                       DirectDelayProcessor,

  1461.                                       MultiBandProcessor,

  1462.                                       dsp::Compressor<float>,

  1463.                                       dsp::Phaser<float>,

  1464.                                       dsp::Chorus<float>,

  1465.                                       DistortionProcessor,

  1466.                                       dsp::LadderFilter<float>,

  1467.                                       DelayEffectProcessor,

  1468.                                       ConvolutionProcessor,

  1469.                                       dsp::Limiter<float>,

  1470.                                       dsp::Gain<float>,

  1471.                                       dsp::Panner<float>>;

  1472.     Chain chain;

  1473. 

  1474.     // We use this enum to index into the chain above

  1475.     enum ProcessorIndices

  1476.     {

  1477.         noiseGateIndex,

  1478.         inputGainIndex,

  1479.         directDelayIndex,

  1480.         multiBandIndex,

  1481.         compressorIndex,

  1482.         phaserIndex,

  1483.         chorusIndex,

  1484.         distortionIndex,

  1485.         ladderIndex,

  1486.         delayEffectIndex,

  1487.         convolutionIndex,

  1488.         limiterIndex,

  1489.         outputGainIndex,

  1490.         pannerIndex

  1491.     };

  1492. 

  1493.     //==============================================================================

  1494.     std::atomic<bool> requiresUpdate { true };

  1495.     std::atomic<int> irSize { 0 };

  1496. 

  1497.     //==============================================================================

  1498.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (DspModulePluginDemo)

  1499. };

  1500. 

  1501. //==============================================================================

  1502. class DspModulePluginDemoEditor  : public AudioProcessorEditor

  1503. {

  1504. public:

  1505.     explicit DspModulePluginDemoEditor (DspModulePluginDemo& p)

  1506.         : AudioProcessorEditor (&p),

  1507.           proc (p)

  1508.     {

  1509.         comboEffect.addSectionHeading ("Main");

  1510.         comboEffect.addItem ("Distortion", TabDistortion);

  1511.         comboEffect.addItem ("Convolution", TabConvolution);

  1512.         comboEffect.addItem ("Multi-band", TabMultiBand);

  1513. 

  1514.         comboEffect.addSectionHeading ("Dynamics");

  1515.         comboEffect.addItem ("Compressor", TabCompressor);

  1516.         comboEffect.addItem ("Noise gate", TabNoiseGate);

  1517.         comboEffect.addItem ("Limiter", TabLimiter);

  1518. 

  1519.         comboEffect.addSectionHeading ("Delay");

  1520.         comboEffect.addItem ("Delay line direct", TabDelayLineDirect);

  1521.         comboEffect.addItem ("Delay line effect", TabDelayLineEffect);

  1522. 

  1523.         comboEffect.addSectionHeading ("Others");

  1524.         comboEffect.addItem ("Phaser", TabPhaser);

  1525.         comboEffect.addItem ("Chorus", TabChorus);

  1526.         comboEffect.addItem ("Ladder filter", TabLadder);

  1527. 

  1528.         comboEffect.setSelectedId (proc.indexTab + 1, dontSendNotification);

  1529.         comboEffect.onChange = [this]

  1530.         {

  1531.             proc.indexTab = comboEffect.getSelectedId() - 1;

  1532.             updateVisibility();

  1533.         };

  1534. 

  1535.         addAllAndMakeVisible (*this,

  1536.                               comboEffect,

  1537.                               labelEffect,

  1538.                               basicControls,

  1539.                               distortionControls,

  1540.                               convolutionControls,

  1541.                               multibandControls,

  1542.                               compressorControls,

  1543.                               noiseGateControls,

  1544.                               limiterControls,

  1545.                               directDelayControls,

  1546.                               delayEffectControls,

  1547.                               phaserControls,

  1548.                               chorusControls,

  1549.                               ladderControls);

  1550.         labelEffect.setJustificationType (Justification::centredRight);

  1551.         labelEffect.attachToComponent (&comboEffect, true);

  1552. 

  1553.         updateVisibility();

  1554. 

  1555.         setSize (800, 430);

  1556.         setResizable (false, false);

  1557.     }

  1558. 

  1559.     //==============================================================================

  1560.     void paint (Graphics& g) override

  1561.     {

  1562.         auto rect = getLocalBounds();

  1563. 

  1564.         auto rectTop    = rect.removeFromTop (topSize);

  1565.         auto rectBottom = rect.removeFromBottom (bottomSize);

  1566. 

  1567.         auto rectEffects = rect.removeFromBottom (tabSize);

  1568.         auto rectChoice  = rect.removeFromBottom (midSize);

  1569. 

  1570.         g.setColour (getLookAndFeel().findColour (ResizableWindow::backgroundColourId));

  1571.         g.fillRect (rect);

  1572. 

  1573.         g.setColour (getLookAndFeel().findColour (ResizableWindow::backgroundColourId).brighter (0.2f));

  1574.         g.fillRect (rectEffects);

  1575. 

  1576.         g.setColour (getLookAndFeel().findColour (ResizableWindow::backgroundColourId).darker (0.2f));

  1577.         g.fillRect (rectTop);

  1578.         g.fillRect (rectBottom);

  1579.         g.fillRect (rectChoice);

  1580. 

  1581.         g.setColour (Colours::white);

  1582.         g.setFont (Font (20.0f).italicised().withExtraKerningFactor (0.1f));

  1583.         g.drawFittedText ("DSP MODULE DEMO", rectTop.reduced (10, 0), Justification::centredLeft, 1);

  1584. 

  1585.         g.setFont (Font (14.0f));

  1586.         String strText = "IR length (reverb): " + String (proc.getCurrentIRSize()) + " samples";

  1587.         g.drawFittedText (strText, rectBottom.reduced (10, 0), Justification::centredRight, 1);

  1588.     }

  1589. 

  1590.     void resized() override

  1591.     {

  1592.         auto rect = getLocalBounds();

  1593.         rect.removeFromTop (topSize);

  1594.         rect.removeFromBottom (bottomSize);

  1595. 

  1596.         auto rectEffects = rect.removeFromBottom (tabSize);

  1597.         auto rectChoice  = rect.removeFromBottom (midSize);

  1598. 

  1599.         comboEffect.setBounds (rectChoice.withSizeKeepingCentre (200, 24));

  1600. 

  1601.         rect.reduce (80, 0);

  1602.         rectEffects.reduce (20, 0);

  1603. 

  1604.         basicControls.setBounds (rect);

  1605. 

  1606.         forEach ([&] (Component& comp) { comp.setBounds (rectEffects); },

  1607.                  distortionControls,

  1608.                  convolutionControls,

  1609.                  multibandControls,

  1610.                  compressorControls,

  1611.                  noiseGateControls,

  1612.                  limiterControls,

  1613.                  directDelayControls,

  1614.                  delayEffectControls,

  1615.                  phaserControls,

  1616.                  chorusControls,

  1617.                  ladderControls);

  1618.     }

  1619. 

  1620. private:

  1621.     class ComponentWithParamMenu : public Component

  1622.     {

  1623.     public:

  1624.         ComponentWithParamMenu (AudioProcessorEditor& editorIn, RangedAudioParameter& paramIn)

  1625.             : editor (editorIn), param (paramIn) {}

  1626. 

  1627.         void mouseUp (const MouseEvent& e) override

  1628.         {

  1629.             if (e.mods.isRightButtonDown())

  1630.                 if (auto* c = editor.getHostContext())

  1631.                     if (auto menuInfo = c->getContextMenuForParameter (&param))

  1632.                         menuInfo->getEquivalentPopupMenu().showMenuAsync (PopupMenu::Options{}.withTargetComponent (this)

  1633.                                                                                               .withMousePosition());

  1634.         }

  1635. 

  1636.     private:

  1637.         AudioProcessorEditor& editor;

  1638.         RangedAudioParameter& param;

  1639.     };

  1640. 

  1641.     class AttachedSlider  : public ComponentWithParamMenu

  1642.     {

  1643.     public:

  1644.         AttachedSlider (AudioProcessorEditor& editorIn, RangedAudioParameter& paramIn)

  1645.             : ComponentWithParamMenu (editorIn, paramIn),

  1646.               label ("", paramIn.name),

  1647.               attachment (paramIn, slider)

  1648.         {

  1649.             slider.addMouseListener (this, true);

  1650. 

  1651.             addAllAndMakeVisible (*this, slider, label);

  1652. 

  1653.             slider.setTextValueSuffix (" " + paramIn.label);

  1654. 

  1655.             label.attachToComponent (&slider, false);

  1656.             label.setJustificationType (Justification::centred);

  1657.         }

  1658. 

  1659.         void resized() override { slider.setBounds (getLocalBounds().reduced (0, 40)); }

  1660. 

  1661.     private:

  1662.         Slider slider { Slider::RotaryVerticalDrag, Slider::TextBoxBelow };

  1663.         Label label;

  1664.         SliderParameterAttachment attachment;

  1665.     };

  1666. 

  1667.     class AttachedToggle  : public ComponentWithParamMenu

  1668.     {

  1669.     public:

  1670.         AttachedToggle (AudioProcessorEditor& editorIn, RangedAudioParameter& paramIn)

  1671.             : ComponentWithParamMenu (editorIn, paramIn),

  1672.               toggle (paramIn.name),

  1673.               attachment (paramIn, toggle)

  1674.         {

  1675.             toggle.addMouseListener (this, true);

  1676.             addAndMakeVisible (toggle);

  1677.         }

  1678. 

  1679.         void resized() override { toggle.setBounds (getLocalBounds()); }

  1680. 

  1681.     private:

  1682.         ToggleButton toggle;

  1683.         ButtonParameterAttachment attachment;

  1684.     };

  1685. 

  1686.     class AttachedCombo  : public ComponentWithParamMenu

  1687.     {

  1688.     public:

  1689.         AttachedCombo (AudioProcessorEditor& editorIn, RangedAudioParameter& paramIn)

  1690.             : ComponentWithParamMenu (editorIn, paramIn),

  1691.               combo (paramIn),

  1692.               label ("", paramIn.name),

  1693.               attachment (paramIn, combo)

  1694.         {

  1695.             combo.addMouseListener (this, true);

  1696. 

  1697.             addAllAndMakeVisible (*this, combo, label);

  1698. 

  1699.             label.attachToComponent (&combo, false);

  1700.             label.setJustificationType (Justification::centred);

  1701.         }

  1702. 

  1703.         void resized() override

  1704.         {

  1705.             combo.setBounds (getLocalBounds().withSizeKeepingCentre (jmin (getWidth(), 150), 24));

  1706.         }

  1707. 

  1708.     private:

  1709.         struct ComboWithItems : public ComboBox

  1710.         {

  1711.             explicit ComboWithItems (RangedAudioParameter& param)

  1712.             {

  1713.                 // Adding the list here in the constructor means that the combo

  1714.                 // is already populated when we construct the attachment below

  1715.                 addItemList (dynamic_cast<AudioParameterChoice&> (param).choices, 1);

  1716.             }

  1717.         };

  1718. 

  1719.         ComboWithItems combo;

  1720.         Label label;

  1721.         ComboBoxParameterAttachment attachment;

  1722.     };

  1723. 

  1724.     //==============================================================================

  1725.     void updateVisibility()

  1726.     {

  1727.         const auto indexEffect = comboEffect.getSelectedId();

  1728. 

  1729.         const auto op = [&] (const std::tuple<Component&, int>& tup)

  1730.         {

  1731.             Component& comp    = std::get<0> (tup);

  1732.             const int tabIndex = std::get<1> (tup);

  1733.             comp.setVisible (tabIndex == indexEffect);

  1734.         };

  1735. 

  1736.         forEach (op,

  1737.                  std::forward_as_tuple (distortionControls,  TabDistortion),

  1738.                  std::forward_as_tuple (convolutionControls, TabConvolution),

  1739.                  std::forward_as_tuple (multibandControls,   TabMultiBand),

  1740.                  std::forward_as_tuple (compressorControls,  TabCompressor),

  1741.                  std::forward_as_tuple (noiseGateControls,   TabNoiseGate),

  1742.                  std::forward_as_tuple (limiterControls,     TabLimiter),

  1743.                  std::forward_as_tuple (directDelayControls, TabDelayLineDirect),

  1744.                  std::forward_as_tuple (delayEffectControls, TabDelayLineEffect),

  1745.                  std::forward_as_tuple (phaserControls,      TabPhaser),

  1746.                  std::forward_as_tuple (chorusControls,      TabChorus),

  1747.                  std::forward_as_tuple (ladderControls,      TabLadder));

  1748.     }

  1749. 

  1750.     enum EffectsTabs

  1751.     {

  1752.         TabDistortion = 1,

  1753.         TabConvolution,

  1754.         TabMultiBand,

  1755.         TabCompressor,

  1756.         TabNoiseGate,

  1757.         TabLimiter,

  1758.         TabDelayLineDirect,

  1759.         TabDelayLineEffect,

  1760.         TabPhaser,

  1761.         TabChorus,

  1762.         TabLadder

  1763.     };

  1764. 

  1765.     //==============================================================================

  1766.     ComboBox comboEffect;

  1767.     Label labelEffect { {}, "Audio effect: " };

  1768. 

  1769.     struct GetTrackInfo

  1770.     {

  1771.         // Combo boxes need a lot of room

  1772.         Grid::TrackInfo operator() (AttachedCombo&)             const { return 120_px; }

  1773. 

  1774.         // Toggles are a bit smaller

  1775.         Grid::TrackInfo operator() (AttachedToggle&)            const { return 80_px; }

  1776. 

  1777.         // Sliders take up as much room as they can

  1778.         Grid::TrackInfo operator() (AttachedSlider&)            const { return 1_fr; }

  1779.     };

  1780. 

  1781.     template <typename... Components>

  1782.     static void performLayout (const Rectangle<int>& bounds, Components&... components)

  1783.     {

  1784.         Grid grid;

  1785.         using Track = Grid::TrackInfo;

  1786. 

  1787.         grid.autoColumns     = Track (1_fr);

  1788.         grid.autoRows        = Track (1_fr);

  1789.         grid.columnGap       = Grid::Px (10);

  1790.         grid.rowGap          = Grid::Px (0);

  1791.         grid.autoFlow        = Grid::AutoFlow::column;

  1792. 

  1793.         grid.templateColumns = { GetTrackInfo{} (components)... };

  1794.         grid.items           = { GridItem (components)... };

  1795. 

  1796.         grid.performLayout (bounds);

  1797.     }

  1798. 

  1799.     struct BasicControls : public Component

  1800.     {

  1801.         explicit BasicControls (AudioProcessorEditor& editor,

  1802.                                 const DspModulePluginDemo::ParameterReferences::MainGroup& state)

  1803.             : pan       (editor, state.pan),

  1804.               input     (editor, state.inputGain),

  1805.               output    (editor, state.outputGain)

  1806.         {

  1807.             addAllAndMakeVisible (*this, pan, input, output);

  1808.         }

  1809. 

  1810.         void resized() override

  1811.         {

  1812.             performLayout (getLocalBounds(), input, output, pan);

  1813.         }

  1814. 

  1815.         AttachedSlider pan, input, output;

  1816.     };

  1817. 

  1818.     struct DistortionControls : public Component

  1819.     {

  1820.         explicit DistortionControls (AudioProcessorEditor& editor,

  1821.                                      const DspModulePluginDemo::ParameterReferences::DistortionGroup& state)

  1822.             : toggle       (editor, state.enabled),

  1823.               lowpass      (editor, state.lowpass),

  1824.               highpass     (editor, state.highpass),

  1825.               mix          (editor, state.mix),

  1826.               gain         (editor, state.inGain),

  1827.               compv        (editor, state.compGain),

  1828.               type         (editor, state.type),

  1829.               oversampling (editor, state.oversampler)

  1830.         {

  1831.             addAllAndMakeVisible (*this, toggle, type, lowpass, highpass, mix, gain, compv, oversampling);

  1832.         }

  1833. 

  1834.         void resized() override

  1835.         {

  1836.             performLayout (getLocalBounds(), toggle, type, gain, highpass, lowpass, compv, mix, oversampling);

  1837.         }

  1838. 

  1839.         AttachedToggle toggle;

  1840.         AttachedSlider lowpass, highpass, mix, gain, compv;

  1841.         AttachedCombo type, oversampling;

  1842.     };

  1843. 

  1844.     struct ConvolutionControls : public Component

  1845.     {

  1846.         explicit ConvolutionControls (AudioProcessorEditor& editor,

  1847.                                       const DspModulePluginDemo::ParameterReferences::ConvolutionGroup& state)

  1848.             : cab    (editor, state.cabEnabled),

  1849.               reverb (editor, state.reverbEnabled),

  1850.               mix    (editor, state.reverbMix)

  1851.         {

  1852.             addAllAndMakeVisible (*this, cab, reverb, mix);

  1853.         }

  1854. 

  1855.         void resized() override

  1856.         {

  1857.             performLayout (getLocalBounds(), cab, reverb, mix);

  1858.         }

  1859. 

  1860.         AttachedToggle cab, reverb;

  1861.         AttachedSlider mix;

  1862.     };

  1863. 

  1864.     struct MultiBandControls : public Component

  1865.     {

  1866.         explicit MultiBandControls (AudioProcessorEditor& editor,

  1867.                                     const DspModulePluginDemo::ParameterReferences::MultiBandGroup& state)

  1868.             : toggle (editor, state.enabled),

  1869.               low    (editor, state.lowVolume),

  1870.               high   (editor, state.highVolume),

  1871.               lRFreq (editor, state.freq)

  1872.         {

  1873.             addAllAndMakeVisible (*this, toggle, low, high, lRFreq);

  1874.         }

  1875. 

  1876.         void resized() override

  1877.         {

  1878.             performLayout (getLocalBounds(), toggle, lRFreq, low, high);

  1879.         }

  1880. 

  1881.         AttachedToggle toggle;

  1882.         AttachedSlider low, high, lRFreq;

  1883.     };

  1884. 

  1885.     struct CompressorControls : public Component

  1886.     {

  1887.         explicit CompressorControls (AudioProcessorEditor& editor,

  1888.                                      const DspModulePluginDemo::ParameterReferences::CompressorGroup& state)

  1889.             : toggle    (editor, state.enabled),

  1890.               threshold (editor, state.threshold),

  1891.               ratio     (editor, state.ratio),

  1892.               attack    (editor, state.attack),

  1893.               release   (editor, state.release)

  1894.         {

  1895.             addAllAndMakeVisible (*this, toggle, threshold, ratio, attack, release);

  1896.         }

  1897. 

  1898.         void resized() override

  1899.         {

  1900.             performLayout (getLocalBounds(), toggle, threshold, ratio, attack, release);

  1901.         }

  1902. 

  1903.         AttachedToggle toggle;

  1904.         AttachedSlider threshold, ratio, attack, release;

  1905.     };

  1906. 

  1907.     struct NoiseGateControls : public Component

  1908.     {

  1909.         explicit NoiseGateControls (AudioProcessorEditor& editor,

  1910.                                     const DspModulePluginDemo::ParameterReferences::NoiseGateGroup& state)

  1911.             : toggle    (editor, state.enabled),

  1912.               threshold (editor, state.threshold),

  1913.               ratio     (editor, state.ratio),

  1914.               attack    (editor, state.attack),

  1915.               release   (editor, state.release)

  1916.         {

  1917.             addAllAndMakeVisible (*this, toggle, threshold, ratio, attack, release);

  1918.         }

  1919. 

  1920.         void resized() override

  1921.         {

  1922.             performLayout (getLocalBounds(), toggle, threshold, ratio, attack, release);

  1923.         }

  1924. 

  1925.         AttachedToggle toggle;

  1926.         AttachedSlider threshold, ratio, attack, release;

  1927.     };

  1928. 

  1929.     struct LimiterControls : public Component

  1930.     {

  1931.         explicit LimiterControls (AudioProcessorEditor& editor,

  1932.                                   const DspModulePluginDemo::ParameterReferences::LimiterGroup& state)

  1933.             : toggle    (editor, state.enabled),

  1934.               threshold (editor, state.threshold),

  1935.               release   (editor, state.release)

  1936.         {

  1937.             addAllAndMakeVisible (*this, toggle, threshold, release);

  1938.         }

  1939. 

  1940.         void resized() override

  1941.         {

  1942.             performLayout (getLocalBounds(), toggle, threshold, release);

  1943.         }

  1944. 

  1945.         AttachedToggle toggle;

  1946.         AttachedSlider threshold, release;

  1947.     };

  1948. 

  1949.     struct DirectDelayControls : public Component

  1950.     {

  1951.         explicit DirectDelayControls (AudioProcessorEditor& editor,

  1952.                                       const DspModulePluginDemo::ParameterReferences::DirectDelayGroup& state)

  1953.             : toggle (editor, state.enabled),

  1954.               type   (editor, state.type),

  1955.               delay  (editor, state.value),

  1956.               smooth (editor, state.smoothing),

  1957.               mix    (editor, state.mix)

  1958.         {

  1959.             addAllAndMakeVisible (*this, toggle, type, delay, smooth, mix);

  1960.         }

  1961. 

  1962.         void resized() override

  1963.         {

  1964.             performLayout (getLocalBounds(), toggle, type, delay, smooth, mix);

  1965.         }

  1966. 

  1967.         AttachedToggle toggle;

  1968.         AttachedCombo type;

  1969.         AttachedSlider delay, smooth, mix;

  1970.     };

  1971. 

  1972.     struct DelayEffectControls : public Component

  1973.     {

  1974.         explicit DelayEffectControls (AudioProcessorEditor& editor,

  1975.                                       const DspModulePluginDemo::ParameterReferences::DelayEffectGroup& state)

  1976.             : toggle   (editor, state.enabled),

  1977.               type     (editor, state.type),

  1978.               value    (editor, state.value),

  1979.               smooth   (editor, state.smoothing),

  1980.               lowpass  (editor, state.lowpass),

  1981.               feedback (editor, state.feedback),

  1982.               mix      (editor, state.mix)

  1983.         {

  1984.             addAllAndMakeVisible (*this, toggle, type, value, smooth, lowpass, feedback, mix);

  1985.         }

  1986. 

  1987.         void resized() override

  1988.         {

  1989.             performLayout (getLocalBounds(), toggle, type, value, smooth, lowpass, feedback, mix);

  1990.         }

  1991. 

  1992.         AttachedToggle toggle;

  1993.         AttachedCombo type;

  1994.         AttachedSlider value, smooth, lowpass, feedback, mix;

  1995.     };

  1996. 

  1997.     struct PhaserControls : public Component

  1998.     {

  1999.         explicit PhaserControls (AudioProcessorEditor& editor,

  2000.                                  const DspModulePluginDemo::ParameterReferences::PhaserGroup& state)

  2001.             : toggle   (editor, state.enabled),

  2002.               rate     (editor, state.rate),

  2003.               depth    (editor, state.depth),

  2004.               centre   (editor, state.centreFrequency),

  2005.               feedback (editor, state.feedback),

  2006.               mix      (editor, state.mix)

  2007.         {

  2008.             addAllAndMakeVisible (*this, toggle, rate, depth, centre, feedback, mix);

  2009.         }

  2010. 

  2011.         void resized() override

  2012.         {

  2013.             performLayout (getLocalBounds(), toggle, rate, depth, centre, feedback, mix);

  2014.         }

  2015. 

  2016.         AttachedToggle toggle;

  2017.         AttachedSlider rate, depth, centre, feedback, mix;

  2018.     };

  2019. 

  2020.     struct ChorusControls : public Component

  2021.     {

  2022.         explicit ChorusControls (AudioProcessorEditor& editor,

  2023.                                  const DspModulePluginDemo::ParameterReferences::ChorusGroup& state)

  2024.             : toggle   (editor, state.enabled),

  2025.               rate     (editor, state.rate),

  2026.               depth    (editor, state.depth),

  2027.               centre   (editor, state.centreDelay),

  2028.               feedback (editor, state.feedback),

  2029.               mix      (editor, state.mix)

  2030.         {

  2031.             addAllAndMakeVisible (*this, toggle, rate, depth, centre, feedback, mix);

  2032.         }

  2033. 

  2034.         void resized() override

  2035.         {

  2036.             performLayout (getLocalBounds(), toggle, rate, depth, centre, feedback, mix);

  2037.         }

  2038. 

  2039.         AttachedToggle toggle;

  2040.         AttachedSlider rate, depth, centre, feedback, mix;

  2041.     };

  2042. 

  2043.     struct LadderControls : public Component

  2044.     {

  2045.         explicit LadderControls (AudioProcessorEditor& editor,

  2046.                                  const DspModulePluginDemo::ParameterReferences::LadderGroup& state)

  2047.             : toggle    (editor, state.enabled),

  2048.               mode      (editor, state.mode),

  2049.               freq      (editor, state.cutoff),

  2050.               resonance (editor, state.resonance),

  2051.               drive     (editor, state.drive)

  2052.         {

  2053.             addAllAndMakeVisible (*this, toggle, mode, freq, resonance, drive);

  2054.         }

  2055. 

  2056.         void resized() override

  2057.         {

  2058.             performLayout (getLocalBounds(), toggle, mode, freq, resonance, drive);

  2059.         }

  2060. 

  2061.         AttachedToggle toggle;

  2062.         AttachedCombo mode;

  2063.         AttachedSlider freq, resonance, drive;

  2064.     };

  2065. 

  2066.     //==============================================================================

  2067.     static constexpr auto topSize    = 40,

  2068.                           bottomSize = 40,

  2069.                           midSize    = 40,

  2070.                           tabSize    = 155;

  2071. 

  2072.     //==============================================================================

  2073.     DspModulePluginDemo& proc;

  2074. 

  2075.     BasicControls       basicControls       { *this, proc.getParameterValues().main };

  2076.     DistortionControls  distortionControls  { *this, proc.getParameterValues().distortion };

  2077.     ConvolutionControls convolutionControls { *this, proc.getParameterValues().convolution };

  2078.     MultiBandControls   multibandControls   { *this, proc.getParameterValues().multiBand };

  2079.     CompressorControls  compressorControls  { *this, proc.getParameterValues().compressor };

  2080.     NoiseGateControls   noiseGateControls   { *this, proc.getParameterValues().noiseGate };

  2081.     LimiterControls     limiterControls     { *this, proc.getParameterValues().limiter };

  2082.     DirectDelayControls directDelayControls { *this, proc.getParameterValues().directDelay };

  2083.     DelayEffectControls delayEffectControls { *this, proc.getParameterValues().delayEffect };

  2084.     PhaserControls      phaserControls      { *this, proc.getParameterValues().phaser };

  2085.     ChorusControls      chorusControls      { *this, proc.getParameterValues().chorus };

  2086.     LadderControls      ladderControls      { *this, proc.getParameterValues().ladder };

  2087. 

  2088.     //==============================================================================

  2089.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (DspModulePluginDemoEditor)

  2090. };

  2091. 

  2092. struct DspModulePluginDemoAudioProcessor  : public DspModulePluginDemo

  2093. {

  2094.     AudioProcessorEditor* createEditor() override

  2095.     {

  2096.         return new DspModulePluginDemoEditor (*this);

  2097.     }

  2098. 

  2099.     bool hasEditor() const override { return true; }

  2100. };