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.
13607 Commits
9 Branches
4.0GB
Tree: 76589ee800
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '76589ee800'
${ noResults }
JUCE/examples/Plugins/DSPModulePluginDemo.h

2100 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. {

  124.     (func (std::forward<Items> (items)), ...);

  125. }

  126. 

  127. template <typename... Components>

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

  129. {

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

  131. }

  132. 

  133. template <typename... Processors>

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

  135. {

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

  137. }

  138. 

  139. template <typename... Processors>

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

  141. {

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

  143. }

  144. 

  145. //==============================================================================

  146. class DspModulePluginDemo  : public AudioProcessor,

  147.                              private ValueTree::Listener

  148. {

  149. public:

  150.     DspModulePluginDemo()

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

  152. 

  153.     //==============================================================================

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

  155.     {

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

  157. 

  158.         if (channels == 0)

  159.             return;

  160. 

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

  162. 

  163.         reset();

  164.     }

  165. 

  166.     void reset() override

  167.     {

  168.         chain.reset();

  169.         update();

  170.     }

  171. 

  172.     void releaseResources() override {}

  173. 

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

  175.     {

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

  177.             return;

  178. 

  179.         ScopedNoDenormals noDenormals;

  180. 

  181.         if (requiresUpdate.load())

  182.             update();

  183. 

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

  185. 

  186.         const auto totalNumInputChannels  = getTotalNumInputChannels();

  187.         const auto totalNumOutputChannels = getTotalNumOutputChannels();

  188. 

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

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

  191. 

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

  193. 

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

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

  196.     }

  197. 

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

  199. 

  200.     //==============================================================================

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

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

  203. 

  204.     //==============================================================================

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

  206. 

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

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

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

  210. 

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

  212. 

  213.     //==============================================================================

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

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

  216.     void setCurrentProgram (int) override {}

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

  218. 

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

  220. 

  221.     //==============================================================================

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

  223.     {

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

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

  226.     }

  227. 

  228.     //==============================================================================

  229.     void getStateInformation (MemoryBlock& destData) override

  230.     {

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

  232.     }

  233. 

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

  235.     {

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

  237.     }

  238. 

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

  240. 

  241.     using Parameter = AudioProcessorValueTreeState::Parameter;

  242.     using Attributes = AudioProcessorValueTreeStateParameterAttributes;

  243. 

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

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

  246.     // changes.

  247.     struct ParameterReferences

  248.     {

  249.         template <typename Param>

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

  251.         {

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

  253.         }

  254. 

  255.         template <typename Param>

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

  257.         {

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

  259.         }

  260. 

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

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

  263.         {

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

  265.             auto& ref = *param;

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

  267.             return ref;

  268.         }

  269. 

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

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

  272. 

  273.         static auto getBasicAttributes()

  274.         {

  275.             return Attributes().withStringFromValueFunction (valueToTextFunction)

  276.                                .withValueFromStringFunction (textToValueFunction);

  277.         }

  278. 

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

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

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

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

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

  284. 

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

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

  287. 

  288.         struct MainGroup

  289.         {

  290.             explicit MainGroup (AudioProcessorParameterGroup& layout)

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

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

  293.                                                      "Input",

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

  295.                                                      0.0f,

  296.                                                      getDbAttributes())),

  297.                   outputGain (addToLayout<Parameter> (layout,

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

  299.                                                       "Output",

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

  301.                                                       0.0f,

  302.                                                       getDbAttributes())),

  303.                   pan (addToLayout<Parameter> (layout,

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

  305.                                                "Panning",

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

  307.                                                0.0f,

  308.                                                Attributes().withStringFromValueFunction (valueToTextPanFunction)

  309.                                                            .withValueFromStringFunction (textToValuePanFunction))) {}

  310. 

  311.             Parameter& inputGain;

  312.             Parameter& outputGain;

  313.             Parameter& pan;

  314.         };

  315. 

  316.         struct DistortionGroup

  317.         {

  318.             explicit DistortionGroup (AudioProcessorParameterGroup& layout)

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

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

  321.                                                             "Distortion",

  322.                                                             true)),

  323.                   type (addToLayout<AudioParameterChoice> (layout,

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

  325.                                                            "Waveshaper",

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

  327.                                                            0)),

  328.                   inGain (addToLayout<Parameter> (layout,

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

  330.                                                   "Gain",

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

  332.                                                   0.0f,

  333.                                                   getDbAttributes())),

  334.                   lowpass (addToLayout<Parameter> (layout,

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

  336.                                                    "Post Low-pass",

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

  338.                                                    22000.0f,

  339.                                                    getHzAttributes())),

  340.                   highpass (addToLayout<Parameter> (layout,

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

  342.                                                     "Pre High-pass",

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

  344.                                                     20.0f,

  345.                                                     getHzAttributes())),

  346.                   compGain (addToLayout<Parameter> (layout,

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

  348.                                                     "Compensat.",

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

  350.                                                     0.0f,

  351.                                                     getDbAttributes())),

  352.                   mix (addToLayout<Parameter> (layout,

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

  354.                                                "Mix",

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

  356.                                                100.0f,

  357.                                                getPercentageAttributes())),

  358.                   oversampler (addToLayout<AudioParameterChoice> (layout,

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

  360.                                                                   "Oversampling",

  361.                                                                   StringArray { "2X",

  362.                                                                                 "4X",

  363.                                                                                 "8X",

  364.                                                                                 "2X compensated",

  365.                                                                                 "4X compensated",

  366.                                                                                 "8X compensated" },

  367.                                                                   1)) {}

  368. 

  369.             AudioParameterBool& enabled;

  370.             AudioParameterChoice& type;

  371.             Parameter& inGain;

  372.             Parameter& lowpass;

  373.             Parameter& highpass;

  374.             Parameter& compGain;

  375.             Parameter& mix;

  376.             AudioParameterChoice& oversampler;

  377.         };

  378. 

  379.         struct MultiBandGroup

  380.         {

  381.             explicit MultiBandGroup (AudioProcessorParameterGroup& layout)

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

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

  384.                                                             "Multi-band",

  385.                                                             false)),

  386.                   freq (addToLayout<Parameter> (layout,

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

  388.                                                 "Sep. Freq.",

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

  390.                                                 2000.0f,

  391.                                                 getHzAttributes())),

  392.                   lowVolume (addToLayout<Parameter> (layout,

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

  394.                                                      "Low volume",

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

  396.                                                      0.0f,

  397.                                                      getDbAttributes())),

  398.                   highVolume (addToLayout<Parameter> (layout,

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

  400.                                                       "High volume",

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

  402.                                                       0.0f,

  403.                                                       getDbAttributes())) {}

  404. 

  405.             AudioParameterBool& enabled;

  406.             Parameter& freq;

  407.             Parameter& lowVolume;

  408.             Parameter& highVolume;

  409.         };

  410. 

  411.         struct ConvolutionGroup

  412.         {

  413.             explicit ConvolutionGroup (AudioProcessorParameterGroup& layout)

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

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

  416.                                                                "Cabinet",

  417.                                                                false)),

  418.                   reverbEnabled (addToLayout<AudioParameterBool> (layout,

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

  420.                                                                   "Reverb",

  421.                                                                   false)),

  422.                   reverbMix (addToLayout<Parameter> (layout,

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

  424.                                                      "Reverb Mix",

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

  426.                                                      50.0f,

  427.                                                      getPercentageAttributes())) {}

  428. 

  429.             AudioParameterBool& cabEnabled;

  430.             AudioParameterBool& reverbEnabled;

  431.             Parameter& reverbMix;

  432.         };

  433. 

  434.         struct CompressorGroup

  435.         {

  436.             explicit CompressorGroup (AudioProcessorParameterGroup& layout)

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

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

  439.                                                             "Comp.",

  440.                                                             false)),

  441.                   threshold (addToLayout<Parameter> (layout,

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

  443.                                                      "Threshold",

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

  445.                                                      0.0f,

  446.                                                      getDbAttributes())),

  447.                   ratio (addToLayout<Parameter> (layout,

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

  449.                                                  "Ratio",

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

  451.                                                  1.0f,

  452.                                                  getRatioAttributes())),

  453.                   attack (addToLayout<Parameter> (layout,

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

  455.                                                   "Attack",

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

  457.                                                   1.0f,

  458.                                                   getMsAttributes())),

  459.                   release (addToLayout<Parameter> (layout,

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

  461.                                                    "Release",

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

  463.                                                    100.0f,

  464.                                                    getMsAttributes())) {}

  465. 

  466.             AudioParameterBool& enabled;

  467.             Parameter& threshold;

  468.             Parameter& ratio;

  469.             Parameter& attack;

  470.             Parameter& release;

  471.         };

  472. 

  473.         struct NoiseGateGroup

  474.         {

  475.             explicit NoiseGateGroup (AudioProcessorParameterGroup& layout)

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

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

  478.                                                             "Gate",

  479.                                                             false)),

  480.                   threshold (addToLayout<Parameter> (layout,

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

  482.                                                      "Threshold",

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

  484.                                                      -100.0f,

  485.                                                      getDbAttributes())),

  486.                   ratio (addToLayout<Parameter> (layout,

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

  488.                                                  "Ratio",

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

  490.                                                  10.0f,

  491.                                                  getRatioAttributes())),

  492.                   attack (addToLayout<Parameter> (layout,

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

  494.                                                   "Attack",

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

  496.                                                   1.0f,

  497.                                                   getMsAttributes())),

  498.                   release (addToLayout<Parameter> (layout,

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

  500.                                                    "Release",

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

  502.                                                    100.0f,

  503.                                                    getMsAttributes())) {}

  504. 

  505.             AudioParameterBool& enabled;

  506.             Parameter& threshold;

  507.             Parameter& ratio;

  508.             Parameter& attack;

  509.             Parameter& release;

  510.         };

  511. 

  512.         struct LimiterGroup

  513.         {

  514.             explicit LimiterGroup (AudioProcessorParameterGroup& layout)

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

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

  517.                                                             "Limiter",

  518.                                                             false)),

  519.                   threshold (addToLayout<Parameter> (layout,

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

  521.                                                      "Threshold",

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

  523.                                                      0.0f,

  524.                                                      getDbAttributes())),

  525.                   release (addToLayout<Parameter> (layout,

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

  527.                                                    "Release",

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

  529.                                                    100.0f,

  530.                                                    getMsAttributes())) {}

  531. 

  532.             AudioParameterBool& enabled;

  533.             Parameter& threshold;

  534.             Parameter& release;

  535.         };

  536. 

  537.         struct DirectDelayGroup

  538.         {

  539.             explicit DirectDelayGroup (AudioProcessorParameterGroup& layout)

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

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

  542.                                                             "DL Dir.",

  543.                                                             false)),

  544.                   type (addToLayout<AudioParameterChoice> (layout,

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

  546.                                                            "DL Type",

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

  548.                                                            1)),

  549.                   value (addToLayout<Parameter> (layout,

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

  551.                                                  "Delay",

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

  553.                                                  0.0f,

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

  555.                   smoothing (addToLayout<Parameter> (layout,

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

  557.                                                      "Smooth",

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

  559.                                                      200.0f,

  560.                                                      getMsAttributes())),

  561.                   mix (addToLayout<Parameter> (layout,

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

  563.                                                "Delay Mix",

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

  565.                                                50.0f,

  566.                                                getPercentageAttributes())) {}

  567. 

  568.             AudioParameterBool& enabled;

  569.             AudioParameterChoice& type;

  570.             Parameter& value;

  571.             Parameter& smoothing;

  572.             Parameter& mix;

  573.         };

  574. 

  575.         struct DelayEffectGroup

  576.         {

  577.             explicit DelayEffectGroup (AudioProcessorParameterGroup& layout)

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

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

  580.                                                             "DL Effect",

  581.                                                             false)),

  582.                   type (addToLayout<AudioParameterChoice> (layout,

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

  584.                                                            "DL Type",

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

  586.                                                            1)),

  587.                   value (addToLayout<Parameter> (layout,

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

  589.                                                  "Delay",

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

  591.                                                  100.0f,

  592.                                                  getMsAttributes())),

  593.                   smoothing (addToLayout<Parameter> (layout,

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

  595.                                                      "Smooth",

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

  597.                                                      400.0f,

  598.                                                      getMsAttributes())),

  599.                   lowpass (addToLayout<Parameter> (layout,

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

  601.                                                    "Low-pass",

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

  603.                                                    22000.0f,

  604.                                                    getHzAttributes())),

  605.                   mix (addToLayout<Parameter> (layout,

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

  607.                                                "Delay Mix",

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

  609.                                                50.0f,

  610.                                                getPercentageAttributes())),

  611.                   feedback (addToLayout<Parameter> (layout,

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

  613.                                                     "Feedback",

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

  615.                                                     -100.0f,

  616.                                                     getDbAttributes())) {}

  617. 

  618.             AudioParameterBool& enabled;

  619.             AudioParameterChoice& type;

  620.             Parameter& value;

  621.             Parameter& smoothing;

  622.             Parameter& lowpass;

  623.             Parameter& mix;

  624.             Parameter& feedback;

  625.         };

  626. 

  627.         struct PhaserGroup

  628.         {

  629.             explicit PhaserGroup (AudioProcessorParameterGroup& layout)

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

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

  632.                                                             "Phaser",

  633.                                                             false)),

  634.                   rate (addToLayout<Parameter> (layout,

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

  636.                                                 "Rate",

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

  638.                                                 1.0f,

  639.                                                 getHzAttributes())),

  640.                   depth (addToLayout<Parameter> (layout,

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

  642.                                                  "Depth",

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

  644.                                                  50.0f,

  645.                                                  getPercentageAttributes())),

  646.                   centreFrequency (addToLayout<Parameter> (layout,

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

  648.                                                            "Center",

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

  650.                                                            600.0f,

  651.                                                            getHzAttributes())),

  652.                   feedback (addToLayout<Parameter> (layout,

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

  654.                                                     "Feedback",

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

  656.                                                     50.0f,

  657.                                                     getPercentageAttributes())),

  658.                   mix (addToLayout<Parameter> (layout,

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

  660.                                                "Mix",

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

  662.                                                50.0f,

  663.                                                getPercentageAttributes())) {}

  664. 

  665.             AudioParameterBool& enabled;

  666.             Parameter& rate;

  667.             Parameter& depth;

  668.             Parameter& centreFrequency;

  669.             Parameter& feedback;

  670.             Parameter& mix;

  671.         };

  672. 

  673.         struct ChorusGroup

  674.         {

  675.             explicit ChorusGroup (AudioProcessorParameterGroup& layout)

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

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

  678.                                                             "Chorus",

  679.                                                             false)),

  680.                   rate (addToLayout<Parameter> (layout,

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

  682.                                                 "Rate",

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

  684.                                                 1.0f,

  685.                                                 getHzAttributes())),

  686.                   depth (addToLayout<Parameter> (layout,

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

  688.                                                  "Depth",

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

  690.                                                  50.0f,

  691.                                                  getPercentageAttributes())),

  692.                   centreDelay (addToLayout<Parameter> (layout,

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

  694.                                                        "Center",

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

  696.                                                        7.0f,

  697.                                                        getMsAttributes())),

  698.                   feedback (addToLayout<Parameter> (layout,

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

  700.                                                     "Feedback",

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

  702.                                                     50.0f,

  703.                                                     getPercentageAttributes())),

  704.                   mix (addToLayout<Parameter> (layout,

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

  706.                                                "Mix",

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

  708.                                                50.0f,

  709.                                                getPercentageAttributes())) {}

  710. 

  711.             AudioParameterBool& enabled;

  712.             Parameter& rate;

  713.             Parameter& depth;

  714.             Parameter& centreDelay;

  715.             Parameter& feedback;

  716.             Parameter& mix;

  717.         };

  718. 

  719.         struct LadderGroup

  720.         {

  721.             explicit LadderGroup (AudioProcessorParameterGroup& layout)

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

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

  724.                                                             "Ladder",

  725.                                                             false)),

  726.                   mode (addToLayout<AudioParameterChoice> (layout,

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

  728.                                                            "Mode",

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

  730.                                                            1)),

  731.                   cutoff (addToLayout<Parameter> (layout,

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

  733.                                                   "Frequency",

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

  735.                                                   1000.0f,

  736.                                                   getHzAttributes())),

  737.                   resonance (addToLayout<Parameter> (layout,

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

  739.                                                      "Resonance",

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

  741.                                                      0.0f,

  742.                                                      getPercentageAttributes())),

  743.                   drive (addToLayout<Parameter> (layout,

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

  745.                                                  "Drive",

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

  747.                                                  0.0f,

  748.                                                  getDbAttributes())) {}

  749. 

  750.             AudioParameterBool& enabled;

  751.             AudioParameterChoice& mode;

  752.             Parameter& cutoff;

  753.             Parameter& resonance;

  754.             Parameter& drive;

  755.         };

  756. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  770. 

  771.         MainGroup main;

  772.         DistortionGroup distortion;

  773.         MultiBandGroup multiBand;

  774.         ConvolutionGroup convolution;

  775.         CompressorGroup compressor;

  776.         NoiseGateGroup noiseGate;

  777.         LimiterGroup limiter;

  778.         DirectDelayGroup directDelay;

  779.         DelayEffectGroup delayEffect;

  780.         PhaserGroup phaser;

  781.         ChorusGroup chorus;

  782.         LadderGroup ladder;

  783.     };

  784. 

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

  786. 

  787.     //==============================================================================

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

  789.     int indexTab = 0;

  790. 

  791. private:

  792.     struct LayoutAndReferences

  793.     {

  794.         AudioProcessorValueTreeState::ParameterLayout layout;

  795.         ParameterReferences references;

  796.     };

  797. 

  798.     explicit DspModulePluginDemo (AudioProcessorValueTreeState::ParameterLayout layout)

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

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

  801.           parameters { layout },

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

  803.     {

  804.         apvts.state.addListener (this);

  805. 

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

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

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

  809. 

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

  811.     }

  812. 

  813.     //==============================================================================

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

  815.     {

  816.         requiresUpdate.store (true);

  817.     }

  818. 

  819.     //==============================================================================

  820.     void update()

  821.     {

  822.         {

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

  824. 

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

  826.             {

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

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

  829.                 return;

  830.             }

  831. 

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

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

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

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

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

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

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

  839.         }

  840. 

  841.         {

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

  843.             convolution.cabEnabled    = parameters.convolution.cabEnabled;

  844.             convolution.reverbEnabled = parameters.convolution.reverbEnabled;

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

  846.         }

  847. 

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

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

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

  851. 

  852.         {

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

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

  855.             multiband.lowpass .setCutoffFrequency (multibandFreq);

  856.             multiband.highpass.setCutoffFrequency (multibandFreq);

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

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

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

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

  861.         }

  862. 

  863.         {

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

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

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

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

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

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

  870.         }

  871. 

  872.         {

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

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

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

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

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

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

  879.         }

  880. 

  881.         {

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

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

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

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

  886.         }

  887. 

  888.         {

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

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

  891. 

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

  893.                        delay.delayDirectValue.end(),

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

  895. 

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

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

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

  899.         }

  900. 

  901.         {

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

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

  904. 

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

  906.                        delay.delayEffectValue.end(),

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

  908. 

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

  910. 

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

  912.                 volume.setTargetValue (feedbackGain);

  913. 

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

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

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

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

  918.         }

  919. 

  920.         {

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

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

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

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

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

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

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

  928.         }

  929. 

  930.         {

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

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

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

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

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

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

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

  938.         }

  939. 

  940.         {

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

  942. 

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

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

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

  946. 

  947.             ladder.setMode ([&]

  948.             {

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

  950.                 {

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

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

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

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

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

  956. 

  957.                     default: break;

  958.                 }

  959. 

  960.                 return dsp::LadderFilterMode::BPF24;

  961.             }());

  962. 

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

  964.         }

  965. 

  966.         requiresUpdate.store (false);

  967.     }

  968. 

  969.     //==============================================================================

  970.     static String getPanningTextForValue (float value)

  971.     {

  972.         if (value == 0.5f)

  973.             return "center";

  974. 

  975.         if (value < 0.5f)

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

  977. 

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

  979.     }

  980. 

  981.     static float getPanningValueForText (String strText)

  982.     {

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

  984.             return 0.5f;

  985. 

  986.         strText = strText.trim();

  987. 

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

  989.         {

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

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

  992.         }

  993. 

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

  995.         {

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

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

  998.         }

  999. 

  1000.         return 0.5f;

  1001.     }

  1002. 

  1003.     //==============================================================================

  1004.     struct DistortionProcessor

  1005.     {

  1006.         DistortionProcessor()

  1007.         {

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

  1009.                      distGain,

  1010.                      compGain);

  1011. 

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

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

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

  1015.         }

  1016. 

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

  1018.         {

  1019.             for (auto& oversampler : oversamplers)

  1020.                 oversampler.initProcessing (spec.maximumBlockSize);

  1021. 

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

  1023.         }

  1024. 

  1025.         void reset()

  1026.         {

  1027.             for (auto& oversampler : oversamplers)

  1028.                 oversampler.reset();

  1029. 

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

  1031.         }

  1032. 

  1033.         float getLatency() const

  1034.         {

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

  1036.         }

  1037. 

  1038.         template <typename Context>

  1039.         void process (Context& context)

  1040.         {

  1041.             if (context.isBypassed)

  1042.                 return;

  1043. 

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

  1045. 

  1046.             mixer.setWetLatency (getLatency());

  1047.             mixer.pushDrySamples (inputBlock);

  1048. 

  1049.             distGain.process (context);

  1050.             highpass.process (context);

  1051. 

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

  1053. 

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

  1055. 

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

  1057.             {

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

  1059. 

  1060.                 if (currentIndexWaveshaper == 1)

  1061.                     clipping.process (waveshaperContext);

  1062. 

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

  1064.             }

  1065. 

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

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

  1068. 

  1069.             lowpass.process (context);

  1070.             compGain.process (context);

  1071.             mixer.mixWetSamples (outputBlock);

  1072.         }

  1073. 

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

  1075.         { {

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

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

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

  1079. 

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

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

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

  1083.         } };

  1084. 

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

  1086. 

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

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

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

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

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

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

  1093.         int currentIndexOversampling = 0;

  1094.         int currentIndexWaveshaper   = 0;

  1095.     };

  1096. 

  1097.     struct ConvolutionProcessor

  1098.     {

  1099.         ConvolutionProcessor()

  1100.         {

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

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

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

  1104.         }

  1105. 

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

  1107.         {

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

  1109.         }

  1110. 

  1111.         void reset()

  1112.         {

  1113.             resetAll (cabinet, reverb, mixer);

  1114.         }

  1115. 

  1116.         template <typename Context>

  1117.         void process (Context& context)

  1118.         {

  1119.             auto contextConv = context;

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

  1121.             cabinet.process (contextConv);

  1122. 

  1123.             if (cabEnabled)

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

  1125. 

  1126.             if (reverbEnabled)

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

  1128. 

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

  1130.             reverb.process (contextConv);

  1131. 

  1132.             if (reverbEnabled)

  1133.             {

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

  1135.                 outputBlock.multiplyBy (4.0f);

  1136.                 mixer.mixWetSamples (outputBlock);

  1137.             }

  1138.         }

  1139. 

  1140.         int getLatency() const

  1141.         {

  1142.             auto latency = 0;

  1143. 

  1144.             if (cabEnabled)

  1145.                 latency += cabinet.getLatency();

  1146. 

  1147.             if (reverbEnabled)

  1148.                 latency += reverb.getLatency();

  1149. 

  1150.             return latency;

  1151.         }

  1152. 

  1153.         dsp::ConvolutionMessageQueue queue;

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

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

  1156.         dsp::DryWetMixer<float> mixer;

  1157.         bool cabEnabled = false, reverbEnabled = false;

  1158. 

  1159.     private:

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

  1161.         {

  1162.             auto stream = createAssetInputStream (filename);

  1163. 

  1164.             if (stream == nullptr)

  1165.             {

  1166.                 jassertfalse;

  1167.                 return;

  1168.             }

  1169. 

  1170.             AudioFormatManager manager;

  1171.             manager.registerBasicFormats();

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

  1173. 

  1174.             if (reader == nullptr)

  1175.             {

  1176.                 jassertfalse;

  1177.                 return;

  1178.             }

  1179. 

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

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

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

  1183. 

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

  1185.                                              reader->sampleRate,

  1186.                                              dsp::Convolution::Stereo::yes,

  1187.                                              dsp::Convolution::Trim::yes,

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

  1189.         }

  1190.     };

  1191. 

  1192.     struct MultiBandProcessor

  1193.     {

  1194.         MultiBandProcessor()

  1195.         {

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

  1197.                      lowVolume,

  1198.                      highVolume);

  1199. 

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

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

  1202.         }

  1203. 

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

  1205.         {

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

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

  1208.         }

  1209. 

  1210.         void reset()

  1211.         {

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

  1213.         }

  1214. 

  1215.         template <typename Context>

  1216.         void process (Context& context)

  1217.         {

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

  1219. 

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

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

  1222. 

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

  1224. 

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

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

  1227. 

  1228.             sepLowBlock .copyFrom (inputBlock);

  1229.             sepHighBlock.copyFrom (inputBlock);

  1230. 

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

  1232.             contextLow.isBypassed = context.isBypassed;

  1233.             lowpass  .process (contextLow);

  1234.             lowVolume.process (contextLow);

  1235. 

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

  1237.             contextHigh.isBypassed = context.isBypassed;

  1238.             highpass  .process (contextHigh);

  1239.             highVolume.process (contextHigh);

  1240. 

  1241.             if (! context.isBypassed)

  1242.             {

  1243.                 sepLowBlock.add (sepHighBlock);

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

  1245.             }

  1246.         }

  1247. 

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

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

  1250.         AudioBuffer<float> bufferSeparation;

  1251.     };

  1252. 

  1253.     struct DirectDelayProcessor

  1254.     {

  1255.         DirectDelayProcessor()

  1256.         {

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

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

  1259.         }

  1260. 

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

  1262.         {

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

  1264.         }

  1265. 

  1266.         void reset()

  1267.         {

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

  1269.         }

  1270. 

  1271.         template <typename Context>

  1272.         void process (Context& context)

  1273.         {

  1274.             if (context.isBypassed)

  1275.                 return;

  1276. 

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

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

  1279. 

  1280.             mixer.pushDrySamples (inputBlock);

  1281. 

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

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

  1284. 

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

  1286.             {

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

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

  1289. 

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

  1291.                 {

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

  1293. 

  1294.                     samplesOut[i] = [&]

  1295.                     {

  1296.                         switch (delayLineDirectType)

  1297.                         {

  1298.                             case 0:

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

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

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

  1302. 

  1303.                             case 1:

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

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

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

  1307. 

  1308.                             case 2:

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

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

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

  1312. 

  1313.                             case 3:

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

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

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

  1317. 

  1318.                             default:

  1319.                                 break;

  1320.                         }

  1321. 

  1322.                         jassertfalse;

  1323.                         return 0.0f;

  1324.                     }();

  1325.                 }

  1326.             }

  1327. 

  1328.             mixer.mixWetSamples (outputBlock);

  1329.         }

  1330. 

  1331.         static constexpr auto directDelayBufferSize = 44100;

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

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

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

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

  1336. 

  1337.         // Double precision to avoid some approximation issues

  1338.         dsp::FirstOrderTPTFilter<double> smoothFilter;

  1339. 

  1340.         dsp::DryWetMixer<float> mixer;

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

  1342. 

  1343.         int delayLineDirectType = 1;

  1344.     };

  1345. 

  1346.     struct DelayEffectProcessor

  1347.     {

  1348.         DelayEffectProcessor()

  1349.         {

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

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

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

  1353.         }

  1354. 

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

  1356.         {

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

  1358. 

  1359.             for (auto& volume : delayFeedbackVolume)

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

  1361.         }

  1362. 

  1363.         void reset()

  1364.         {

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

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

  1367.         }

  1368. 

  1369.         template <typename Context>

  1370.         void process (Context& context)

  1371.         {

  1372.             if (context.isBypassed)

  1373.                 return;

  1374. 

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

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

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

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

  1379. 

  1380.             mixer.pushDrySamples (inputBlock);

  1381. 

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

  1383.             {

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

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

  1386. 

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

  1388.                 {

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

  1390. 

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

  1392. 

  1393.                     const auto output = [&]

  1394.                     {

  1395.                         switch (delayEffectType)

  1396.                         {

  1397.                             case 0:

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

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

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

  1401. 

  1402.                             case 1:

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

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

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

  1406. 

  1407.                             case 2:

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

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

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

  1411. 

  1412.                             case 3:

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

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

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

  1416. 

  1417.                             default:

  1418.                                 break;

  1419.                         }

  1420. 

  1421.                         jassertfalse;

  1422.                         return 0.0f;

  1423.                     }();

  1424. 

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

  1426. 

  1427.                     samplesOut[i] = processed;

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

  1429.                 }

  1430.             }

  1431. 

  1432.             mixer.mixWetSamples (outputBlock);

  1433.         }

  1434. 

  1435.         static constexpr auto effectDelaySamples = 192000;

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

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

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

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

  1440. 

  1441.         // Double precision to avoid some approximation issues

  1442.         dsp::FirstOrderTPTFilter<double> smoothFilter;

  1443. 

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

  1445. 

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

  1447.         dsp::FirstOrderTPTFilter<float> lowpass;

  1448.         dsp::DryWetMixer<float> mixer;

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

  1450. 

  1451.         int delayEffectType = 1;

  1452.     };

  1453. 

  1454.     ParameterReferences parameters;

  1455.     AudioProcessorValueTreeState apvts;

  1456. 

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

  1458.                                       dsp::Gain<float>,

  1459.                                       DirectDelayProcessor,

  1460.                                       MultiBandProcessor,

  1461.                                       dsp::Compressor<float>,

  1462.                                       dsp::Phaser<float>,

  1463.                                       dsp::Chorus<float>,

  1464.                                       DistortionProcessor,

  1465.                                       dsp::LadderFilter<float>,

  1466.                                       DelayEffectProcessor,

  1467.                                       ConvolutionProcessor,

  1468.                                       dsp::Limiter<float>,

  1469.                                       dsp::Gain<float>,

  1470.                                       dsp::Panner<float>>;

  1471.     Chain chain;

  1472. 

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

  1474.     enum ProcessorIndices

  1475.     {

  1476.         noiseGateIndex,

  1477.         inputGainIndex,

  1478.         directDelayIndex,

  1479.         multiBandIndex,

  1480.         compressorIndex,

  1481.         phaserIndex,

  1482.         chorusIndex,

  1483.         distortionIndex,

  1484.         ladderIndex,

  1485.         delayEffectIndex,

  1486.         convolutionIndex,

  1487.         limiterIndex,

  1488.         outputGainIndex,

  1489.         pannerIndex

  1490.     };

  1491. 

  1492.     //==============================================================================

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

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

  1495. 

  1496.     //==============================================================================

  1497.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (DspModulePluginDemo)

  1498. };

  1499. 

  1500. //==============================================================================

  1501. class DspModulePluginDemoEditor  : public AudioProcessorEditor

  1502. {

  1503. public:

  1504.     explicit DspModulePluginDemoEditor (DspModulePluginDemo& p)

  1505.         : AudioProcessorEditor (&p),

  1506.           proc (p)

  1507.     {

  1508.         comboEffect.addSectionHeading ("Main");

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

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

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

  1512. 

  1513.         comboEffect.addSectionHeading ("Dynamics");

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

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

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

  1517. 

  1518.         comboEffect.addSectionHeading ("Delay");

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

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

  1521. 

  1522.         comboEffect.addSectionHeading ("Others");

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

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

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

  1526. 

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

  1528.         comboEffect.onChange = [this]

  1529.         {

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

  1531.             updateVisibility();

  1532.         };

  1533. 

  1534.         addAllAndMakeVisible (*this,

  1535.                               comboEffect,

  1536.                               labelEffect,

  1537.                               basicControls,

  1538.                               distortionControls,

  1539.                               convolutionControls,

  1540.                               multibandControls,

  1541.                               compressorControls,

  1542.                               noiseGateControls,

  1543.                               limiterControls,

  1544.                               directDelayControls,

  1545.                               delayEffectControls,

  1546.                               phaserControls,

  1547.                               chorusControls,

  1548.                               ladderControls);

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

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

  1551. 

  1552.         updateVisibility();

  1553. 

  1554.         setSize (800, 430);

  1555.         setResizable (false, false);

  1556.     }

  1557. 

  1558.     //==============================================================================

  1559.     void paint (Graphics& g) override

  1560.     {

  1561.         auto rect = getLocalBounds();

  1562. 

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

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

  1565. 

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

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

  1568. 

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

  1570.         g.fillRect (rect);

  1571. 

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

  1573.         g.fillRect (rectEffects);

  1574. 

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

  1576.         g.fillRect (rectTop);

  1577.         g.fillRect (rectBottom);

  1578.         g.fillRect (rectChoice);

  1579. 

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

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

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

  1583. 

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

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

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

  1587.     }

  1588. 

  1589.     void resized() override

  1590.     {

  1591.         auto rect = getLocalBounds();

  1592.         rect.removeFromTop (topSize);

  1593.         rect.removeFromBottom (bottomSize);

  1594. 

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

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

  1597. 

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

  1599. 

  1600.         rect.reduce (80, 0);

  1601.         rectEffects.reduce (20, 0);

  1602. 

  1603.         basicControls.setBounds (rect);

  1604. 

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

  1606.                  distortionControls,

  1607.                  convolutionControls,

  1608.                  multibandControls,

  1609.                  compressorControls,

  1610.                  noiseGateControls,

  1611.                  limiterControls,

  1612.                  directDelayControls,

  1613.                  delayEffectControls,

  1614.                  phaserControls,

  1615.                  chorusControls,

  1616.                  ladderControls);

  1617.     }

  1618. 

  1619. private:

  1620.     class ComponentWithParamMenu : public Component

  1621.     {

  1622.     public:

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

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

  1625. 

  1626.         void mouseUp (const MouseEvent& e) override

  1627.         {

  1628.             if (e.mods.isRightButtonDown())

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

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

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

  1632.                                                                                               .withMousePosition());

  1633.         }

  1634. 

  1635.     private:

  1636.         AudioProcessorEditor& editor;

  1637.         RangedAudioParameter& param;

  1638.     };

  1639. 

  1640.     class AttachedSlider  : public ComponentWithParamMenu

  1641.     {

  1642.     public:

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

  1644.             : ComponentWithParamMenu (editorIn, paramIn),

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

  1646.               attachment (paramIn, slider)

  1647.         {

  1648.             slider.addMouseListener (this, true);

  1649. 

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

  1651. 

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

  1653. 

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

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

  1656.         }

  1657. 

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

  1659. 

  1660.     private:

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

  1662.         Label label;

  1663.         SliderParameterAttachment attachment;

  1664.     };

  1665. 

  1666.     class AttachedToggle  : public ComponentWithParamMenu

  1667.     {

  1668.     public:

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

  1670.             : ComponentWithParamMenu (editorIn, paramIn),

  1671.               toggle (paramIn.name),

  1672.               attachment (paramIn, toggle)

  1673.         {

  1674.             toggle.addMouseListener (this, true);

  1675.             addAndMakeVisible (toggle);

  1676.         }

  1677. 

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

  1679. 

  1680.     private:

  1681.         ToggleButton toggle;

  1682.         ButtonParameterAttachment attachment;

  1683.     };

  1684. 

  1685.     class AttachedCombo  : public ComponentWithParamMenu

  1686.     {

  1687.     public:

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

  1689.             : ComponentWithParamMenu (editorIn, paramIn),

  1690.               combo (paramIn),

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

  1692.               attachment (paramIn, combo)

  1693.         {

  1694.             combo.addMouseListener (this, true);

  1695. 

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

  1697. 

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

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

  1700.         }

  1701. 

  1702.         void resized() override

  1703.         {

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

  1705.         }

  1706. 

  1707.     private:

  1708.         struct ComboWithItems : public ComboBox

  1709.         {

  1710.             explicit ComboWithItems (RangedAudioParameter& param)

  1711.             {

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

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

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

  1715.             }

  1716.         };

  1717. 

  1718.         ComboWithItems combo;

  1719.         Label label;

  1720.         ComboBoxParameterAttachment attachment;

  1721.     };

  1722. 

  1723.     //==============================================================================

  1724.     void updateVisibility()

  1725.     {

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

  1727. 

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

  1729.         {

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

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

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

  1733.         };

  1734. 

  1735.         forEach (op,

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

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

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

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

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

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

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

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

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

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

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

  1747.     }

  1748. 

  1749.     enum EffectsTabs

  1750.     {

  1751.         TabDistortion = 1,

  1752.         TabConvolution,

  1753.         TabMultiBand,

  1754.         TabCompressor,

  1755.         TabNoiseGate,

  1756.         TabLimiter,

  1757.         TabDelayLineDirect,

  1758.         TabDelayLineEffect,

  1759.         TabPhaser,

  1760.         TabChorus,

  1761.         TabLadder

  1762.     };

  1763. 

  1764.     //==============================================================================

  1765.     ComboBox comboEffect;

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

  1767. 

  1768.     struct GetTrackInfo

  1769.     {

  1770.         // Combo boxes need a lot of room

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

  1772. 

  1773.         // Toggles are a bit smaller

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

  1775. 

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

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

  1778.     };

  1779. 

  1780.     template <typename... Components>

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

  1782.     {

  1783.         Grid grid;

  1784.         using Track = Grid::TrackInfo;

  1785. 

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

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

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

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

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

  1791. 

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

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

  1794. 

  1795.         grid.performLayout (bounds);

  1796.     }

  1797. 

  1798.     struct BasicControls : public Component

  1799.     {

  1800.         explicit BasicControls (AudioProcessorEditor& editor,

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

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

  1803.               input     (editor, state.inputGain),

  1804.               output    (editor, state.outputGain)

  1805.         {

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

  1807.         }

  1808. 

  1809.         void resized() override

  1810.         {

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

  1812.         }

  1813. 

  1814.         AttachedSlider pan, input, output;

  1815.     };

  1816. 

  1817.     struct DistortionControls : public Component

  1818.     {

  1819.         explicit DistortionControls (AudioProcessorEditor& editor,

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

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

  1822.               lowpass      (editor, state.lowpass),

  1823.               highpass     (editor, state.highpass),

  1824.               mix          (editor, state.mix),

  1825.               gain         (editor, state.inGain),

  1826.               compv        (editor, state.compGain),

  1827.               type         (editor, state.type),

  1828.               oversampling (editor, state.oversampler)

  1829.         {

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

  1831.         }

  1832. 

  1833.         void resized() override

  1834.         {

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

  1836.         }

  1837. 

  1838.         AttachedToggle toggle;

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

  1840.         AttachedCombo type, oversampling;

  1841.     };

  1842. 

  1843.     struct ConvolutionControls : public Component

  1844.     {

  1845.         explicit ConvolutionControls (AudioProcessorEditor& editor,

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

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

  1848.               reverb (editor, state.reverbEnabled),

  1849.               mix    (editor, state.reverbMix)

  1850.         {

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

  1852.         }

  1853. 

  1854.         void resized() override

  1855.         {

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

  1857.         }

  1858. 

  1859.         AttachedToggle cab, reverb;

  1860.         AttachedSlider mix;

  1861.     };

  1862. 

  1863.     struct MultiBandControls : public Component

  1864.     {

  1865.         explicit MultiBandControls (AudioProcessorEditor& editor,

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

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

  1868.               low    (editor, state.lowVolume),

  1869.               high   (editor, state.highVolume),

  1870.               lRFreq (editor, state.freq)

  1871.         {

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

  1873.         }

  1874. 

  1875.         void resized() override

  1876.         {

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

  1878.         }

  1879. 

  1880.         AttachedToggle toggle;

  1881.         AttachedSlider low, high, lRFreq;

  1882.     };

  1883. 

  1884.     struct CompressorControls : public Component

  1885.     {

  1886.         explicit CompressorControls (AudioProcessorEditor& editor,

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

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

  1889.               threshold (editor, state.threshold),

  1890.               ratio     (editor, state.ratio),

  1891.               attack    (editor, state.attack),

  1892.               release   (editor, state.release)

  1893.         {

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

  1895.         }

  1896. 

  1897.         void resized() override

  1898.         {

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

  1900.         }

  1901. 

  1902.         AttachedToggle toggle;

  1903.         AttachedSlider threshold, ratio, attack, release;

  1904.     };

  1905. 

  1906.     struct NoiseGateControls : public Component

  1907.     {

  1908.         explicit NoiseGateControls (AudioProcessorEditor& editor,

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

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

  1911.               threshold (editor, state.threshold),

  1912.               ratio     (editor, state.ratio),

  1913.               attack    (editor, state.attack),

  1914.               release   (editor, state.release)

  1915.         {

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

  1917.         }

  1918. 

  1919.         void resized() override

  1920.         {

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

  1922.         }

  1923. 

  1924.         AttachedToggle toggle;

  1925.         AttachedSlider threshold, ratio, attack, release;

  1926.     };

  1927. 

  1928.     struct LimiterControls : public Component

  1929.     {

  1930.         explicit LimiterControls (AudioProcessorEditor& editor,

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

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

  1933.               threshold (editor, state.threshold),

  1934.               release   (editor, state.release)

  1935.         {

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

  1937.         }

  1938. 

  1939.         void resized() override

  1940.         {

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

  1942.         }

  1943. 

  1944.         AttachedToggle toggle;

  1945.         AttachedSlider threshold, release;

  1946.     };

  1947. 

  1948.     struct DirectDelayControls : public Component

  1949.     {

  1950.         explicit DirectDelayControls (AudioProcessorEditor& editor,

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

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

  1953.               type   (editor, state.type),

  1954.               delay  (editor, state.value),

  1955.               smooth (editor, state.smoothing),

  1956.               mix    (editor, state.mix)

  1957.         {

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

  1959.         }

  1960. 

  1961.         void resized() override

  1962.         {

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

  1964.         }

  1965. 

  1966.         AttachedToggle toggle;

  1967.         AttachedCombo type;

  1968.         AttachedSlider delay, smooth, mix;

  1969.     };

  1970. 

  1971.     struct DelayEffectControls : public Component

  1972.     {

  1973.         explicit DelayEffectControls (AudioProcessorEditor& editor,

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

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

  1976.               type     (editor, state.type),

  1977.               value    (editor, state.value),

  1978.               smooth   (editor, state.smoothing),

  1979.               lowpass  (editor, state.lowpass),

  1980.               feedback (editor, state.feedback),

  1981.               mix      (editor, state.mix)

  1982.         {

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

  1984.         }

  1985. 

  1986.         void resized() override

  1987.         {

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

  1989.         }

  1990. 

  1991.         AttachedToggle toggle;

  1992.         AttachedCombo type;

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

  1994.     };

  1995. 

  1996.     struct PhaserControls : public Component

  1997.     {

  1998.         explicit PhaserControls (AudioProcessorEditor& editor,

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

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

  2001.               rate     (editor, state.rate),

  2002.               depth    (editor, state.depth),

  2003.               centre   (editor, state.centreFrequency),

  2004.               feedback (editor, state.feedback),

  2005.               mix      (editor, state.mix)

  2006.         {

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

  2008.         }

  2009. 

  2010.         void resized() override

  2011.         {

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

  2013.         }

  2014. 

  2015.         AttachedToggle toggle;

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

  2017.     };

  2018. 

  2019.     struct ChorusControls : public Component

  2020.     {

  2021.         explicit ChorusControls (AudioProcessorEditor& editor,

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

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

  2024.               rate     (editor, state.rate),

  2025.               depth    (editor, state.depth),

  2026.               centre   (editor, state.centreDelay),

  2027.               feedback (editor, state.feedback),

  2028.               mix      (editor, state.mix)

  2029.         {

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

  2031.         }

  2032. 

  2033.         void resized() override

  2034.         {

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

  2036.         }

  2037. 

  2038.         AttachedToggle toggle;

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

  2040.     };

  2041. 

  2042.     struct LadderControls : public Component

  2043.     {

  2044.         explicit LadderControls (AudioProcessorEditor& editor,

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

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

  2047.               mode      (editor, state.mode),

  2048.               freq      (editor, state.cutoff),

  2049.               resonance (editor, state.resonance),

  2050.               drive     (editor, state.drive)

  2051.         {

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

  2053.         }

  2054. 

  2055.         void resized() override

  2056.         {

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

  2058.         }

  2059. 

  2060.         AttachedToggle toggle;

  2061.         AttachedCombo mode;

  2062.         AttachedSlider freq, resonance, drive;

  2063.     };

  2064. 

  2065.     //==============================================================================

  2066.     static constexpr auto topSize    = 40,

  2067.                           bottomSize = 40,

  2068.                           midSize    = 40,

  2069.                           tabSize    = 155;

  2070. 

  2071.     //==============================================================================

  2072.     DspModulePluginDemo& proc;

  2073. 

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

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

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

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

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

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

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

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

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

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

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

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

  2086. 

  2087.     //==============================================================================

  2088.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (DspModulePluginDemoEditor)

  2089. };

  2090. 

  2091. struct DspModulePluginDemoAudioProcessor  : public DspModulePluginDemo

  2092. {

  2093.     AudioProcessorEditor* createEditor() override

  2094.     {

  2095.         return new DspModulePluginDemoEditor (*this);

  2096.     }

  2097. 

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

  2099. };