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.
11396 Commits
9 Branches
356MB
Tree: 4fd3dfb51b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4fd3dfb51b'
${ noResults }
JUCE/examples/Plugins/DSPModulePluginDemo.h

2038 lines
98KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE examples.

  5.    Copyright (c) 2020 - 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, vs2019, linux_make

  37. 

  38.  moduleFlags:      JUCE_STRICT_REFCOUNTEDPOINTER=1

  39. 

  40.  type:             AudioProcessor

  41.  mainClass:        DspModulePluginDemoAudioProcessor

  42. 

  43.  useLocalCopy:     1

  44. 

  45.  END_JUCE_PIP_METADATA

  46. 

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

  48. 

  49. #pragma once

  50. 

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

  52. 

  53. namespace ID

  54. {

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

  56. 

  57.     PARAMETER_ID (inputGain)

  58.     PARAMETER_ID (outputGain)

  59.     PARAMETER_ID (pan)

  60.     PARAMETER_ID (distortionEnabled)

  61.     PARAMETER_ID (distortionType)

  62.     PARAMETER_ID (distortionOversampler)

  63.     PARAMETER_ID (distortionLowpass)

  64.     PARAMETER_ID (distortionHighpass)

  65.     PARAMETER_ID (distortionInGain)

  66.     PARAMETER_ID (distortionCompGain)

  67.     PARAMETER_ID (distortionMix)

  68.     PARAMETER_ID (convolutionCabEnabled)

  69.     PARAMETER_ID (convolutionReverbEnabled)

  70.     PARAMETER_ID (convolutionReverbMix)

  71.     PARAMETER_ID (multiBandEnabled)

  72.     PARAMETER_ID (multiBandFreq)

  73.     PARAMETER_ID (multiBandLowVolume)

  74.     PARAMETER_ID (multiBandHighVolume)

  75.     PARAMETER_ID (compressorEnabled)

  76.     PARAMETER_ID (compressorThreshold)

  77.     PARAMETER_ID (compressorRatio)

  78.     PARAMETER_ID (compressorAttack)

  79.     PARAMETER_ID (compressorRelease)

  80.     PARAMETER_ID (noiseGateEnabled)

  81.     PARAMETER_ID (noiseGateThreshold)

  82.     PARAMETER_ID (noiseGateRatio)

  83.     PARAMETER_ID (noiseGateAttack)

  84.     PARAMETER_ID (noiseGateRelease)

  85.     PARAMETER_ID (limiterEnabled)

  86.     PARAMETER_ID (limiterThreshold)

  87.     PARAMETER_ID (limiterRelease)

  88.     PARAMETER_ID (directDelayEnabled)

  89.     PARAMETER_ID (directDelayType)

  90.     PARAMETER_ID (directDelayValue)

  91.     PARAMETER_ID (directDelaySmoothing)

  92.     PARAMETER_ID (directDelayMix)

  93.     PARAMETER_ID (delayEffectEnabled)

  94.     PARAMETER_ID (delayEffectType)

  95.     PARAMETER_ID (delayEffectValue)

  96.     PARAMETER_ID (delayEffectSmoothing)

  97.     PARAMETER_ID (delayEffectLowpass)

  98.     PARAMETER_ID (delayEffectFeedback)

  99.     PARAMETER_ID (delayEffectMix)

  100.     PARAMETER_ID (phaserEnabled)

  101.     PARAMETER_ID (phaserRate)

  102.     PARAMETER_ID (phaserDepth)

  103.     PARAMETER_ID (phaserCentreFrequency)

  104.     PARAMETER_ID (phaserFeedback)

  105.     PARAMETER_ID (phaserMix)

  106.     PARAMETER_ID (chorusEnabled)

  107.     PARAMETER_ID (chorusRate)

  108.     PARAMETER_ID (chorusDepth)

  109.     PARAMETER_ID (chorusCentreDelay)

  110.     PARAMETER_ID (chorusFeedback)

  111.     PARAMETER_ID (chorusMix)

  112.     PARAMETER_ID (ladderEnabled)

  113.     PARAMETER_ID (ladderCutoff)

  114.     PARAMETER_ID (ladderResonance)

  115.     PARAMETER_ID (ladderDrive)

  116.     PARAMETER_ID (ladderMode)

  117. 

  118.    #undef PARAMETER_ID

  119. }

  120. 

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

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

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

  124. {

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

  126. }

  127. 

  128. template <typename... Components>

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

  130. {

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

  132. }

  133. 

  134. template <typename... Processors>

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

  136. {

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

  138. }

  139. 

  140. template <typename... Processors>

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

  142. {

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

  144. }

  145. 

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

  147. class DspModulePluginDemo  : public AudioProcessor,

  148.                              private ValueTree::Listener

  149. {

  150. public:

  151.     DspModulePluginDemo()

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

  153. 

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

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

  156.     {

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

  158. 

  159.         if (channels == 0)

  160.             return;

  161. 

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

  163. 

  164.         reset();

  165.     }

  166. 

  167.     void reset() override

  168.     {

  169.         chain.reset();

  170.         update();

  171.     }

  172. 

  173.     void releaseResources() override {}

  174. 

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

  176.     {

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

  178.             return;

  179. 

  180.         ScopedNoDenormals noDenormals;

  181. 

  182.         if (requiresUpdate.load())

  183.             update();

  184. 

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

  186. 

  187.         const auto totalNumInputChannels  = getTotalNumInputChannels();

  188.         const auto totalNumOutputChannels = getTotalNumOutputChannels();

  189. 

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

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

  192. 

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

  194. 

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

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

  197.     }

  198. 

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

  200. 

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

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

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

  204. 

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

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

  207. 

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

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

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

  211. 

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

  213. 

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

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

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

  217.     void setCurrentProgram (int) override {}

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

  219. 

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

  221. 

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

  223.     void getStateInformation (MemoryBlock& destData) override

  224.     {

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

  226.     }

  227. 

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

  229.     {

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

  231.     }

  232. 

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

  234. 

  235.     using Parameter = AudioProcessorValueTreeState::Parameter;

  236. 

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

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

  239.     // changes.

  240.     struct ParameterReferences

  241.     {

  242.         template <typename Param>

  243.         static Param& addToLayout (AudioProcessorValueTreeState::ParameterLayout& layout,

  244.                                    std::unique_ptr<Param> param)

  245.         {

  246.             auto& ref = *param;

  247.             layout.add (std::move (param));

  248.             return ref;

  249.         }

  250. 

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

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

  253. 

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

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

  256. 

  257.         // Creates parameters, adds them to the layout, and stores references to the parameters

  258.         // in this struct.

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

  260.             : inputGain (addToLayout (layout,

  261.                                       std::make_unique<Parameter> (ID::inputGain,

  262.                                                                    "Input",

  263.                                                                    "dB",

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

  265.                                                                    0.0f,

  266.                                                                    valueToTextFunction,

  267.                                                                    textToValueFunction))),

  268.               outputGain (addToLayout (layout,

  269.                                        std::make_unique<Parameter> (ID::outputGain,

  270.                                                                     "Output",

  271.                                                                     "dB",

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

  273.                                                                     0.0f,

  274.                                                                     valueToTextFunction,

  275.                                                                     textToValueFunction))),

  276.               pan (addToLayout (layout,

  277.                                 std::make_unique<Parameter> (ID::pan,

  278.                                                              "Panning",

  279.                                                              "",

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

  281.                                                              0.0f,

  282.                                                              valueToTextPanFunction,

  283.                                                              textToValuePanFunction))),

  284.               distortionEnabled (addToLayout (layout,

  285.                                               std::make_unique<AudioParameterBool> (ID::distortionEnabled,

  286.                                                                                     "Distortion",

  287.                                                                                     true,

  288.                                                                                     ""))),

  289.               distortionType (addToLayout (layout,

  290.                                            std::make_unique<AudioParameterChoice> (ID::distortionType,

  291.                                                                                    "Waveshaper",

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

  293.                                                                                    0))),

  294.               distortionInGain (addToLayout (layout,

  295.                                              std::make_unique<Parameter> (ID::distortionInGain,

  296.                                                                           "Gain",

  297.                                                                           "dB",

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

  299.                                                                           0.0f,

  300.                                                                           valueToTextFunction,

  301.                                                                           textToValueFunction))),

  302.               distortionLowpass (addToLayout (layout,

  303.                                               std::make_unique<Parameter> (ID::distortionLowpass,

  304.                                                                            "Post Low-pass",

  305.                                                                            "Hz",

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

  307.                                                                            22000.0f,

  308.                                                                            valueToTextFunction,

  309.                                                                            textToValueFunction))),

  310.               distortionHighpass (addToLayout (layout,

  311.                                                std::make_unique<Parameter> (ID::distortionHighpass,

  312.                                                                             "Pre High-pass",

  313.                                                                             "Hz",

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

  315.                                                                             20.0f,

  316.                                                                             valueToTextFunction,

  317.                                                                             textToValueFunction))),

  318.               distortionCompGain (addToLayout (layout,

  319.                                                std::make_unique<Parameter> (ID::distortionCompGain,

  320.                                                                             "Compensat.",

  321.                                                                             "dB",

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

  323.                                                                             0.0f,

  324.                                                                             valueToTextFunction,

  325.                                                                             textToValueFunction))),

  326.               distortionMix (addToLayout (layout,

  327.                                           std::make_unique<Parameter> (ID::distortionMix,

  328.                                                                        "Mix",

  329.                                                                        "%",

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

  331.                                                                        100.0f,

  332.                                                                        valueToTextFunction,

  333.                                                                        textToValueFunction))),

  334.               distortionOversampler (addToLayout (layout,

  335.                                                   std::make_unique<AudioParameterChoice> (ID::distortionOversampler,

  336.                                                                                           "Oversampling",

  337.                                                                                           StringArray { "2X", "4X", "8X", "2X compensated", "4X compensated", "8X compensated" },

  338.                                                                                           1))),

  339.               multiBandEnabled (addToLayout (layout,

  340.                                              std::make_unique<AudioParameterBool> (ID::multiBandEnabled,

  341.                                                                                    "Multi-band",

  342.                                                                                    false,

  343.                                                                                    ""))),

  344.               multiBandFreq (addToLayout (layout,

  345.                                           std::make_unique<Parameter> (ID::multiBandFreq,

  346.                                                                        "Sep. Freq.",

  347.                                                                        "Hz",

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

  349.                                                                        2000.0f,

  350.                                                                        valueToTextFunction,

  351.                                                                        textToValueFunction))),

  352.               multiBandLowVolume (addToLayout (layout,

  353.                                                std::make_unique<Parameter> (ID::multiBandLowVolume,

  354.                                                                             "Low volume",

  355.                                                                             "dB",

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

  357.                                                                             0.0f,

  358.                                                                             valueToTextFunction,

  359.                                                                             textToValueFunction))),

  360.               multiBandHighVolume (addToLayout (layout,

  361.                                                 std::make_unique<Parameter> (ID::multiBandHighVolume,

  362.                                                                              "High volume",

  363.                                                                              "dB",

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

  365.                                                                              0.0f,

  366.                                                                              valueToTextFunction,

  367.                                                                              textToValueFunction))),

  368.               convolutionCabEnabled (addToLayout (layout,

  369.                                                   std::make_unique<AudioParameterBool> (ID::convolutionCabEnabled,

  370.                                                                                         "Cabinet",

  371.                                                                                         false,

  372.                                                                                         ""))),

  373.               convolutionReverbEnabled (addToLayout (layout,

  374.                                                      std::make_unique<AudioParameterBool> (ID::convolutionReverbEnabled,

  375.                                                                                            "Reverb",

  376.                                                                                            false,

  377.                                                                                            ""))),

  378.               convolutionReverbMix (addToLayout (layout,

  379.                                                  std::make_unique<Parameter> (ID::convolutionReverbMix,

  380.                                                                               "Reverb Mix",

  381.                                                                               "%",

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

  383.                                                                               50.0f,

  384.                                                                               valueToTextFunction,

  385.                                                                               textToValueFunction))),

  386.               compressorEnabled (addToLayout (layout,

  387.                                               std::make_unique<AudioParameterBool> (ID::compressorEnabled,

  388.                                                                                     "Comp.",

  389.                                                                                     false,

  390.                                                                                     ""))),

  391.               compressorThreshold (addToLayout (layout,

  392.                                                 std::make_unique<Parameter> (ID::compressorThreshold,

  393.                                                                              "Threshold",

  394.                                                                              "dB",

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

  396.                                                                              0.0f,

  397.                                                                              valueToTextFunction,

  398.                                                                              textToValueFunction))),

  399.               compressorRatio (addToLayout (layout,

  400.                                             std::make_unique<Parameter> (ID::compressorRatio,

  401.                                                                          "Ratio",

  402.                                                                          ":1",

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

  404.                                                                          1.0f,

  405.                                                                          valueToTextFunction,

  406.                                                                          textToValueFunction))),

  407.               compressorAttack (addToLayout (layout,

  408.                                              std::make_unique<Parameter> (ID::compressorAttack,

  409.                                                                           "Attack",

  410.                                                                           "ms",

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

  412.                                                                           1.0f,

  413.                                                                           valueToTextFunction,

  414.                                                                           textToValueFunction))),

  415.               compressorRelease (addToLayout (layout,

  416.                                               std::make_unique<Parameter> (ID::compressorRelease,

  417.                                                                            "Release",

  418.                                                                            "ms",

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

  420.                                                                            100.0f,

  421.                                                                            valueToTextFunction,

  422.                                                                            textToValueFunction))),

  423.               noiseGateEnabled (addToLayout (layout,

  424.                                              std::make_unique<AudioParameterBool> (ID::noiseGateEnabled,

  425.                                                                                    "Gate",

  426.                                                                                    false,

  427.                                                                                    ""))),

  428.               noiseGateThreshold (addToLayout (layout,

  429.                                                std::make_unique<Parameter> (ID::noiseGateThreshold,

  430.                                                                             "Threshold",

  431.                                                                             "dB",

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

  433.                                                                             -100.0f,

  434.                                                                             valueToTextFunction,

  435.                                                                             textToValueFunction))),

  436.               noiseGateRatio (addToLayout (layout,

  437.                                            std::make_unique<Parameter> (ID::noiseGateRatio,

  438.                                                                         "Ratio",

  439.                                                                         ":1",

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

  441.                                                                         10.0f,

  442.                                                                         valueToTextFunction,

  443.                                                                         textToValueFunction))),

  444.               noiseGateAttack (addToLayout (layout,

  445.                                             std::make_unique<Parameter> (ID::noiseGateAttack,

  446.                                                                          "Attack",

  447.                                                                          "ms",

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

  449.                                                                          1.0f,

  450.                                                                          valueToTextFunction,

  451.                                                                          textToValueFunction))),

  452.               noiseGateRelease (addToLayout (layout,

  453.                                              std::make_unique<Parameter> (ID::noiseGateRelease,

  454.                                                                           "Release",

  455.                                                                           "ms",

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

  457.                                                                           100.0f,

  458.                                                                           valueToTextFunction,

  459.                                                                           textToValueFunction))),

  460.               limiterEnabled (addToLayout (layout,

  461.                                            std::make_unique<AudioParameterBool> (ID::limiterEnabled,

  462.                                                                                  "Limiter",

  463.                                                                                  false,

  464.                                                                                  ""))),

  465.               limiterThreshold (addToLayout (layout,

  466.                                              std::make_unique<Parameter> (ID::limiterThreshold,

  467.                                                                           "Threshold",

  468.                                                                           "dB",

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

  470.                                                                           0.0f,

  471.                                                                           valueToTextFunction,

  472.                                                                           textToValueFunction))),

  473.               limiterRelease (addToLayout (layout,

  474.                                            std::make_unique<Parameter> (ID::limiterRelease,

  475.                                                                         "Release",

  476.                                                                         "ms",

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

  478.                                                                         100.0f,

  479.                                                                         valueToTextFunction,

  480.                                                                         textToValueFunction))),

  481.               directDelayEnabled (addToLayout (layout,

  482.                                                std::make_unique<AudioParameterBool> (ID::directDelayEnabled,

  483.                                                                                      "DL Dir.",

  484.                                                                                      false,

  485.                                                                                      ""))),

  486.               directDelayType (addToLayout (layout,

  487.                                             std::make_unique<AudioParameterChoice> (ID::directDelayType,

  488.                                                                                     "DL Type",

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

  490.                                                                                     1))),

  491.               directDelayValue (addToLayout (layout,

  492.                                              std::make_unique<Parameter> (ID::directDelayValue,

  493.                                                                           "Delay",

  494.                                                                           "smps",

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

  496.                                                                           0.0f,

  497.                                                                           valueToTextFunction,

  498.                                                                           textToValueFunction))),

  499.               directDelaySmoothing (addToLayout (layout,

  500.                                                  std::make_unique<Parameter> (ID::directDelaySmoothing,

  501.                                                                               "Smooth",

  502.                                                                               "ms",

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

  504.                                                                               200.0f,

  505.                                                                               valueToTextFunction,

  506.                                                                               textToValueFunction))),

  507.               directDelayMix (addToLayout (layout,

  508.                                            std::make_unique<Parameter> (ID::directDelayMix,

  509.                                                                         "Delay Mix",

  510.                                                                         "%",

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

  512.                                                                         50.0f,

  513.                                                                         valueToTextFunction,

  514.                                                                         textToValueFunction))),

  515.               delayEffectEnabled (addToLayout (layout,

  516.                                                std::make_unique<AudioParameterBool> (ID::delayEffectEnabled,

  517.                                                                                      "DL Effect",

  518.                                                                                      false,

  519.                                                                                      ""))),

  520.               delayEffectType (addToLayout (layout,

  521.                                             std::make_unique<AudioParameterChoice> (ID::delayEffectType,

  522.                                                                                     "DL Type",

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

  524.                                                                                     1))),

  525.               delayEffectValue (addToLayout (layout,

  526.                                              std::make_unique<Parameter> (ID::delayEffectValue,

  527.                                                                           "Delay",

  528.                                                                           "ms",

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

  530.                                                                           100.0f,

  531.                                                                           valueToTextFunction,

  532.                                                                           textToValueFunction))),

  533.               delayEffectSmoothing (addToLayout (layout,

  534.                                                  std::make_unique<Parameter> (ID::delayEffectSmoothing,

  535.                                                                               "Smooth",

  536.                                                                               "ms",

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

  538.                                                                               400.0f,

  539.                                                                               valueToTextFunction,

  540.                                                                               textToValueFunction))),

  541.               delayEffectLowpass (addToLayout (layout,

  542.                                                std::make_unique<Parameter> (ID::delayEffectLowpass,

  543.                                                                             "Low-pass",

  544.                                                                             "Hz",

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

  546.                                                                             22000.0f,

  547.                                                                             valueToTextFunction,

  548.                                                                             textToValueFunction))),

  549.               delayEffectMix (addToLayout (layout,

  550.                                            std::make_unique<Parameter> (ID::delayEffectMix,

  551.                                                                         "Delay Mix",

  552.                                                                         "%",

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

  554.                                                                         50.0f,

  555.                                                                         valueToTextFunction,

  556.                                                                         textToValueFunction))),

  557.               delayEffectFeedback (addToLayout (layout,

  558.                                                 std::make_unique<Parameter> (ID::delayEffectFeedback,

  559.                                                                              "Feedback",

  560.                                                                              "dB",

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

  562.                                                                              -100.0f,

  563.                                                                              valueToTextFunction,

  564.                                                                              textToValueFunction))),

  565.               phaserEnabled (addToLayout (layout,

  566.                                           std::make_unique<AudioParameterBool> (ID::phaserEnabled,

  567.                                                                                 "Phaser",

  568.                                                                                 false,

  569.                                                                                 ""))),

  570.               phaserRate (addToLayout (layout,

  571.                                        std::make_unique<Parameter> (ID::phaserRate,

  572.                                                                     "Rate",

  573.                                                                     "Hz",

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

  575.                                                                     1.0f,

  576.                                                                     valueToTextFunction,

  577.                                                                     textToValueFunction))),

  578.               phaserDepth (addToLayout (layout,

  579.                                         std::make_unique<Parameter> (ID::phaserDepth,

  580.                                                                      "Depth",

  581.                                                                      "%",

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

  583.                                                                      50.0f,

  584.                                                                      valueToTextFunction,

  585.                                                                      textToValueFunction))),

  586.               phaserCentreFrequency (addToLayout (layout,

  587.                                                   std::make_unique<Parameter> (ID::phaserCentreFrequency,

  588.                                                                                "Center",

  589.                                                                                "Hz",

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

  591.                                                                                600.0f,

  592.                                                                                valueToTextFunction,

  593.                                                                                textToValueFunction))),

  594.               phaserFeedback (addToLayout (layout,

  595.                                            std::make_unique<Parameter> (ID::phaserFeedback,

  596.                                                                         "Feedback",

  597.                                                                         "%",

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

  599.                                                                         50.0f,

  600.                                                                         valueToTextFunction,

  601.                                                                         textToValueFunction))),

  602.               phaserMix (addToLayout (layout,

  603.                                       std::make_unique<Parameter> (ID::phaserMix,

  604.                                                                    "Mix",

  605.                                                                    "%",

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

  607.                                                                    50.0f,

  608.                                                                    valueToTextFunction,

  609.                                                                    textToValueFunction))),

  610.               chorusEnabled (addToLayout (layout,

  611.                                           std::make_unique<AudioParameterBool> (ID::chorusEnabled,

  612.                                                                                 "Chorus",

  613.                                                                                 false,

  614.                                                                                 ""))),

  615.               chorusRate (addToLayout (layout,

  616.                                        std::make_unique<Parameter> (ID::chorusRate,

  617.                                                                     "Rate",

  618.                                                                     "Hz",

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

  620.                                                                     1.0f,

  621.                                                                     valueToTextFunction,

  622.                                                                     textToValueFunction))),

  623.               chorusDepth (addToLayout (layout,

  624.                                         std::make_unique<Parameter> (ID::chorusDepth,

  625.                                                                      "Depth",

  626.                                                                      "%",

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

  628.                                                                      50.0f,

  629.                                                                      valueToTextFunction,

  630.                                                                      textToValueFunction))),

  631.               chorusCentreDelay (addToLayout (layout,

  632.                                               std::make_unique<Parameter> (ID::chorusCentreDelay,

  633.                                                                            "Center",

  634.                                                                            "ms",

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

  636.                                                                            7.0f,

  637.                                                                            valueToTextFunction,

  638.                                                                            textToValueFunction))),

  639.               chorusFeedback (addToLayout (layout,

  640.                                            std::make_unique<Parameter> (ID::chorusFeedback,

  641.                                                                         "Feedback",

  642.                                                                         "%",

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

  644.                                                                         50.0f,

  645.                                                                         valueToTextFunction,

  646.                                                                         textToValueFunction))),

  647.               chorusMix (addToLayout (layout,

  648.                                       std::make_unique<Parameter> (ID::chorusMix,

  649.                                                                    "Mix",

  650.                                                                    "%",

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

  652.                                                                    50.0f,

  653.                                                                    valueToTextFunction,

  654.                                                                    textToValueFunction))),

  655.               ladderEnabled (addToLayout (layout,

  656.                                           std::make_unique<AudioParameterBool> (ID::ladderEnabled,

  657.                                                                                 "Ladder",

  658.                                                                                 false,

  659.                                                                                 ""))),

  660.               ladderMode (addToLayout (layout,

  661.                                        std::make_unique<AudioParameterChoice> (ID::ladderMode,

  662.                                                                                "Mode",

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

  664.                                                                                1))),

  665.               ladderCutoff (addToLayout (layout,

  666.                                          std::make_unique<Parameter> (ID::ladderCutoff,

  667.                                                                       "Frequency",

  668.                                                                       "Hz",

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

  670.                                                                       1000.0f,

  671.                                                                       valueToTextFunction,

  672.                                                                       textToValueFunction))),

  673.               ladderResonance (addToLayout (layout,

  674.                                             std::make_unique<Parameter> (ID::ladderResonance,

  675.                                                                          "Resonance",

  676.                                                                          "%",

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

  678.                                                                          0.0f,

  679.                                                                          valueToTextFunction,

  680.                                                                          textToValueFunction))),

  681.               ladderDrive (addToLayout (layout,

  682.                                         std::make_unique<Parameter> (ID::ladderDrive,

  683.                                                                      "Drive",

  684.                                                                      "dB",

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

  686.                                                                      0.0f,

  687.                                                                      valueToTextFunction,

  688.                                                                      textToValueFunction)))

  689.         {}

  690. 

  691.         Parameter& inputGain;

  692.         Parameter& outputGain;

  693.         Parameter& pan;

  694. 

  695.         AudioParameterBool& distortionEnabled;

  696.         AudioParameterChoice& distortionType;

  697.         Parameter& distortionInGain;

  698.         Parameter& distortionLowpass;

  699.         Parameter& distortionHighpass;

  700.         Parameter& distortionCompGain;

  701.         Parameter& distortionMix;

  702.         AudioParameterChoice& distortionOversampler;

  703. 

  704.         AudioParameterBool& multiBandEnabled;

  705.         Parameter& multiBandFreq;

  706.         Parameter& multiBandLowVolume;

  707.         Parameter& multiBandHighVolume;

  708. 

  709.         AudioParameterBool& convolutionCabEnabled;

  710.         AudioParameterBool& convolutionReverbEnabled;

  711.         Parameter& convolutionReverbMix;

  712. 

  713.         AudioParameterBool& compressorEnabled;

  714.         Parameter& compressorThreshold;

  715.         Parameter& compressorRatio;

  716.         Parameter& compressorAttack;

  717.         Parameter& compressorRelease;

  718. 

  719.         AudioParameterBool& noiseGateEnabled;

  720.         Parameter& noiseGateThreshold;

  721.         Parameter& noiseGateRatio;

  722.         Parameter& noiseGateAttack;

  723.         Parameter& noiseGateRelease;

  724. 

  725.         AudioParameterBool& limiterEnabled;

  726.         Parameter& limiterThreshold;

  727.         Parameter& limiterRelease;

  728. 

  729.         AudioParameterBool& directDelayEnabled;

  730.         AudioParameterChoice& directDelayType;

  731.         Parameter& directDelayValue;

  732.         Parameter& directDelaySmoothing;

  733.         Parameter& directDelayMix;

  734. 

  735.         AudioParameterBool& delayEffectEnabled;

  736.         AudioParameterChoice& delayEffectType;

  737.         Parameter& delayEffectValue;

  738.         Parameter& delayEffectSmoothing;

  739.         Parameter& delayEffectLowpass;

  740.         Parameter& delayEffectMix;

  741.         Parameter& delayEffectFeedback;

  742. 

  743.         AudioParameterBool& phaserEnabled;

  744.         Parameter& phaserRate;

  745.         Parameter& phaserDepth;

  746.         Parameter& phaserCentreFrequency;

  747.         Parameter& phaserFeedback;

  748.         Parameter& phaserMix;

  749. 

  750.         AudioParameterBool& chorusEnabled;

  751.         Parameter& chorusRate;

  752.         Parameter& chorusDepth;

  753.         Parameter& chorusCentreDelay;

  754.         Parameter& chorusFeedback;

  755.         Parameter& chorusMix;

  756. 

  757.         AudioParameterBool& ladderEnabled;

  758.         AudioParameterChoice& ladderMode;

  759.         Parameter& ladderCutoff;

  760.         Parameter& ladderResonance;

  761.         Parameter& ladderDrive;

  762.     };

  763. 

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

  765. 

  766.     //==============================================================================

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

  768.     int indexTab = 0;

  769. 

  770. private:

  771.     struct LayoutAndReferences

  772.     {

  773.         AudioProcessorValueTreeState::ParameterLayout layout;

  774.         ParameterReferences references;

  775.     };

  776. 

  777.     explicit DspModulePluginDemo (AudioProcessorValueTreeState::ParameterLayout layout)

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

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

  780.           parameters { layout },

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

  782.     {

  783.         apvts.state.addListener (this);

  784. 

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

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

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

  788. 

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

  790.     }

  791. 

  792.     //==============================================================================

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

  794.     {

  795.         requiresUpdate.store (true);

  796.     }

  797. 

  798.     //==============================================================================

  799.     void update()

  800.     {

  801.         {

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

  803. 

  804.             if (distortion.currentIndexOversampling != parameters.distortionOversampler.getIndex())

  805.             {

  806.                 distortion.currentIndexOversampling = parameters.distortionOversampler.getIndex();

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

  808.                 return;

  809.             }

  810. 

  811.             distortion.currentIndexWaveshaper = parameters.distortionType.getIndex();

  812.             distortion.lowpass .setCutoffFrequency (parameters.distortionLowpass.get());

  813.             distortion.highpass.setCutoffFrequency (parameters.distortionHighpass.get());

  814.             distortion.distGain.setGainDecibels (parameters.distortionInGain.get());

  815.             distortion.compGain.setGainDecibels (parameters.distortionCompGain.get());

  816.             distortion.mixer.setWetMixProportion (parameters.distortionMix.get() / 100.0f);

  817.             dsp::setBypassed<distortionIndex> (chain, ! parameters.distortionEnabled);

  818.         }

  819. 

  820.         {

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

  822.             convolution.cabEnabled    = parameters.convolutionCabEnabled;

  823.             convolution.reverbEnabled = parameters.convolutionReverbEnabled;

  824.             convolution.mixer.setWetMixProportion (parameters.convolutionReverbMix.get() / 100.0f);

  825.         }

  826. 

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

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

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

  830. 

  831.         {

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

  833.             const auto multibandFreq = parameters.multiBandFreq.get();

  834.             multiband.lowpass .setCutoffFrequency (multibandFreq);

  835.             multiband.highpass.setCutoffFrequency (multibandFreq);

  836.             const bool enabled = parameters.multiBandEnabled;

  837.             multiband.lowVolume .setGainDecibels (enabled ? parameters.multiBandLowVolume .get() : 0.0f);

  838.             multiband.highVolume.setGainDecibels (enabled ? parameters.multiBandHighVolume.get() : 0.0f);

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

  840.         }

  841. 

  842.         {

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

  844.             compressor.setThreshold (parameters.compressorThreshold.get());

  845.             compressor.setRatio     (parameters.compressorRatio.get());

  846.             compressor.setAttack    (parameters.compressorAttack.get());

  847.             compressor.setRelease   (parameters.compressorRelease.get());

  848.             dsp::setBypassed<compressorIndex> (chain, ! parameters.compressorEnabled);

  849.         }

  850. 

  851.         {

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

  853.             noiseGate.setThreshold (parameters.noiseGateThreshold.get());

  854.             noiseGate.setRatio     (parameters.noiseGateRatio.get());

  855.             noiseGate.setAttack    (parameters.noiseGateAttack.get());

  856.             noiseGate.setRelease   (parameters.noiseGateRelease.get());

  857.             dsp::setBypassed<noiseGateIndex> (chain, ! parameters.noiseGateEnabled);

  858.         }

  859. 

  860.         {

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

  862.             limiter.setThreshold (parameters.limiterThreshold.get());

  863.             limiter.setRelease   (parameters.limiterRelease.get());

  864.             dsp::setBypassed<limiterIndex> (chain, ! parameters.limiterEnabled);

  865.         }

  866. 

  867.         {

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

  869.             delay.delayLineDirectType = parameters.directDelayType.getIndex();

  870. 

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

  872.                        delay.delayDirectValue.end(),

  873.                        (double) parameters.directDelayValue.get());

  874. 

  875.             delay.smoothFilter.setCutoffFrequency (1000.0 / parameters.directDelaySmoothing.get());

  876.             delay.mixer.setWetMixProportion (parameters.directDelayMix.get() / 100.0f);

  877.             dsp::setBypassed<directDelayIndex> (chain, ! parameters.directDelayEnabled);

  878.         }

  879. 

  880.         {

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

  882.             delay.delayEffectType = parameters.delayEffectType.getIndex();

  883. 

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

  885.                        delay.delayEffectValue.end(),

  886.                        (double) parameters.delayEffectValue.get() / 1000.0 * getSampleRate());

  887. 

  888.             const auto feedbackGain = Decibels::decibelsToGain (parameters.delayEffectFeedback.get(), -100.0f);

  889. 

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

  891.                 volume.setTargetValue (feedbackGain);

  892. 

  893.             delay.smoothFilter.setCutoffFrequency (1000.0 / parameters.delayEffectSmoothing.get());

  894.             delay.lowpass.setCutoffFrequency (parameters.delayEffectLowpass.get());

  895.             delay.mixer.setWetMixProportion (parameters.delayEffectMix.get() / 100.0f);

  896.             dsp::setBypassed<delayEffectIndex> (chain, ! parameters.delayEffectEnabled);

  897.         }

  898. 

  899.         {

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

  901.             phaser.setRate            (parameters.phaserRate.get());

  902.             phaser.setDepth           (parameters.phaserDepth.get() / 100.0f);

  903.             phaser.setCentreFrequency (parameters.phaserCentreFrequency.get());

  904.             phaser.setFeedback        (parameters.phaserFeedback.get() / 100.0f * 0.95f);

  905.             phaser.setMix             (parameters.phaserMix.get() / 100.0f);

  906.             dsp::setBypassed<phaserIndex> (chain, ! parameters.phaserEnabled);

  907.         }

  908. 

  909.         {

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

  911.             chorus.setRate        (parameters.chorusRate.get());

  912.             chorus.setDepth       (parameters.chorusDepth.get() / 100.0f);

  913.             chorus.setCentreDelay (parameters.chorusCentreDelay.get());

  914.             chorus.setFeedback    (parameters.chorusFeedback.get() / 100.0f * 0.95f);

  915.             chorus.setMix         (parameters.chorusMix.get() / 100.0f);

  916.             dsp::setBypassed<chorusIndex> (chain, ! parameters.chorusEnabled);

  917.         }

  918. 

  919.         {

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

  921. 

  922.             ladder.setCutoffFrequencyHz (parameters.ladderCutoff.get());

  923.             ladder.setResonance         (parameters.ladderResonance.get() / 100.0f);

  924.             ladder.setDrive (Decibels::decibelsToGain (parameters.ladderDrive.get()));

  925. 

  926.             ladder.setMode ([&]

  927.             {

  928.                 switch (parameters.ladderMode.getIndex())

  929.                 {

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

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

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

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

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

  935. 

  936.                     default: break;

  937.                 }

  938. 

  939.                 return dsp::LadderFilterMode::BPF24;

  940.             }());

  941. 

  942.             dsp::setBypassed<ladderIndex> (chain, ! parameters.ladderEnabled);

  943.         }

  944. 

  945.         requiresUpdate.store (false);

  946.     }

  947. 

  948.     //==============================================================================

  949.     static String getPanningTextForValue (float value)

  950.     {

  951.         if (value == 0.5f)

  952.             return "center";

  953. 

  954.         if (value < 0.5f)

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

  956. 

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

  958.     }

  959. 

  960.     static float getPanningValueForText (String strText)

  961.     {

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

  963.             return 0.5f;

  964. 

  965.         strText = strText.trim();

  966. 

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

  968.         {

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

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

  971.         }

  972. 

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

  974.         {

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

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

  977.         }

  978. 

  979.         return 0.5f;

  980.     }

  981. 

  982.     //==============================================================================

  983.     struct DistortionProcessor

  984.     {

  985.         DistortionProcessor()

  986.         {

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

  988.                      distGain,

  989.                      compGain);

  990. 

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

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

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

  994.         }

  995. 

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

  997.         {

  998.             for (auto& oversampler : oversamplers)

  999.                 oversampler.initProcessing (spec.maximumBlockSize);

  1000. 

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

  1002.         }

  1003. 

  1004.         void reset()

  1005.         {

  1006.             for (auto& oversampler : oversamplers)

  1007.                 oversampler.reset();

  1008. 

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

  1010.         }

  1011. 

  1012.         float getLatency() const

  1013.         {

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

  1015.         }

  1016. 

  1017.         template <typename Context>

  1018.         void process (Context& context)

  1019.         {

  1020.             if (context.isBypassed)

  1021.                 return;

  1022. 

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

  1024. 

  1025.             mixer.setWetLatency (getLatency());

  1026.             mixer.pushDrySamples (inputBlock);

  1027. 

  1028.             distGain.process (context);

  1029.             highpass.process (context);

  1030. 

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

  1032. 

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

  1034. 

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

  1036.             {

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

  1038. 

  1039.                 if (currentIndexWaveshaper == 1)

  1040.                     clipping.process (waveshaperContext);

  1041. 

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

  1043.             }

  1044. 

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

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

  1047. 

  1048.             lowpass.process (context);

  1049.             compGain.process (context);

  1050.             mixer.mixWetSamples (outputBlock);

  1051.         }

  1052. 

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

  1054.         { {

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

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

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

  1058. 

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

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

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

  1062.         } };

  1063. 

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

  1065. 

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

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

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

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

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

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

  1072.         int currentIndexOversampling = 0;

  1073.         int currentIndexWaveshaper   = 0;

  1074.     };

  1075. 

  1076.     struct ConvolutionProcessor

  1077.     {

  1078.         ConvolutionProcessor()

  1079.         {

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

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

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

  1083.         }

  1084. 

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

  1086.         {

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

  1088.         }

  1089. 

  1090.         void reset()

  1091.         {

  1092.             resetAll (cabinet, reverb, mixer);

  1093.         }

  1094. 

  1095.         template <typename Context>

  1096.         void process (Context& context)

  1097.         {

  1098.             auto contextConv = context;

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

  1100.             cabinet.process (contextConv);

  1101. 

  1102.             if (cabEnabled)

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

  1104. 

  1105.             if (reverbEnabled)

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

  1107. 

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

  1109.             reverb.process (contextConv);

  1110. 

  1111.             if (reverbEnabled)

  1112.             {

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

  1114.                 outputBlock.multiplyBy (4.0f);

  1115.                 mixer.mixWetSamples (outputBlock);

  1116.             }

  1117.         }

  1118. 

  1119.         int getLatency() const

  1120.         {

  1121.             auto latency = 0;

  1122. 

  1123.             if (cabEnabled)

  1124.                 latency += cabinet.getLatency();

  1125. 

  1126.             if (reverbEnabled)

  1127.                 latency += reverb.getLatency();

  1128. 

  1129.             return latency;

  1130.         }

  1131. 

  1132.         dsp::ConvolutionMessageQueue queue;

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

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

  1135.         dsp::DryWetMixer<float> mixer;

  1136.         bool cabEnabled = false, reverbEnabled = false;

  1137. 

  1138.     private:

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

  1140.         {

  1141.             auto stream = createAssetInputStream (filename);

  1142. 

  1143.             if (stream == nullptr)

  1144.             {

  1145.                 jassertfalse;

  1146.                 return;

  1147.             }

  1148. 

  1149.             AudioFormatManager manager;

  1150.             manager.registerBasicFormats();

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

  1152. 

  1153.             if (reader == nullptr)

  1154.             {

  1155.                 jassertfalse;

  1156.                 return;

  1157.             }

  1158. 

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

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

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

  1162. 

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

  1164.                                              reader->sampleRate,

  1165.                                              dsp::Convolution::Stereo::yes,

  1166.                                              dsp::Convolution::Trim::yes,

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

  1168.         }

  1169.     };

  1170. 

  1171.     struct MultiBandProcessor

  1172.     {

  1173.         MultiBandProcessor()

  1174.         {

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

  1176.                      lowVolume,

  1177.                      highVolume);

  1178. 

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

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

  1181.         }

  1182. 

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

  1184.         {

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

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

  1187.         }

  1188. 

  1189.         void reset()

  1190.         {

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

  1192.         }

  1193. 

  1194.         template <typename Context>

  1195.         void process (Context& context)

  1196.         {

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

  1198. 

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

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

  1201. 

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

  1203. 

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

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

  1206. 

  1207.             sepLowBlock .copyFrom (inputBlock);

  1208.             sepHighBlock.copyFrom (inputBlock);

  1209. 

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

  1211.             contextLow.isBypassed = context.isBypassed;

  1212.             lowpass  .process (contextLow);

  1213.             lowVolume.process (contextLow);

  1214. 

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

  1216.             contextHigh.isBypassed = context.isBypassed;

  1217.             highpass  .process (contextHigh);

  1218.             highVolume.process (contextHigh);

  1219. 

  1220.             if (! context.isBypassed)

  1221.             {

  1222.                 sepLowBlock.add (sepHighBlock);

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

  1224.             }

  1225.         }

  1226. 

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

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

  1229.         AudioBuffer<float> bufferSeparation;

  1230.     };

  1231. 

  1232.     struct DirectDelayProcessor

  1233.     {

  1234.         DirectDelayProcessor()

  1235.         {

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

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

  1238.         }

  1239. 

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

  1241.         {

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

  1243.         }

  1244. 

  1245.         void reset()

  1246.         {

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

  1248.         }

  1249. 

  1250.         template <typename Context>

  1251.         void process (Context& context)

  1252.         {

  1253.             if (context.isBypassed)

  1254.                 return;

  1255. 

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

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

  1258. 

  1259.             mixer.pushDrySamples (inputBlock);

  1260. 

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

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

  1263. 

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

  1265.             {

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

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

  1268. 

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

  1270.                 {

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

  1272. 

  1273.                     samplesOut[i] = [&]

  1274.                     {

  1275.                         switch (delayLineDirectType)

  1276.                         {

  1277.                             case 0:

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

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

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

  1281. 

  1282.                             case 1:

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

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

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

  1286. 

  1287.                             case 2:

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

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

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

  1291. 

  1292.                             case 3:

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

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

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

  1296. 

  1297.                             default:

  1298.                                 break;

  1299.                         }

  1300. 

  1301.                         jassertfalse;

  1302.                         return 0.0f;

  1303.                     }();

  1304.                 }

  1305.             }

  1306. 

  1307.             mixer.mixWetSamples (outputBlock);

  1308.         }

  1309. 

  1310.         static constexpr auto directDelayBufferSize = 44100;

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

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

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

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

  1315. 

  1316.         // Double precision to avoid some approximation issues

  1317.         dsp::FirstOrderTPTFilter<double> smoothFilter;

  1318. 

  1319.         dsp::DryWetMixer<float> mixer;

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

  1321. 

  1322.         int delayLineDirectType = 1;

  1323.     };

  1324. 

  1325.     struct DelayEffectProcessor

  1326.     {

  1327.         DelayEffectProcessor()

  1328.         {

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

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

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

  1332.         }

  1333. 

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

  1335.         {

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

  1337. 

  1338.             for (auto& volume : delayFeedbackVolume)

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

  1340.         }

  1341. 

  1342.         void reset()

  1343.         {

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

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

  1346.         }

  1347. 

  1348.         template <typename Context>

  1349.         void process (Context& context)

  1350.         {

  1351.             if (context.isBypassed)

  1352.                 return;

  1353. 

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

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

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

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

  1358. 

  1359.             mixer.pushDrySamples (inputBlock);

  1360. 

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

  1362.             {

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

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

  1365. 

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

  1367.                 {

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

  1369. 

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

  1371. 

  1372.                     const auto output = [&]

  1373.                     {

  1374.                         switch (delayEffectType)

  1375.                         {

  1376.                             case 0:

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

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

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

  1380. 

  1381.                             case 1:

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

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

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

  1385. 

  1386.                             case 2:

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

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

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

  1390. 

  1391.                             case 3:

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

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

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

  1395. 

  1396.                             default:

  1397.                                 break;

  1398.                         }

  1399. 

  1400.                         jassertfalse;

  1401.                         return 0.0f;

  1402.                     }();

  1403. 

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

  1405. 

  1406.                     samplesOut[i] = processed;

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

  1408.                 }

  1409.             }

  1410. 

  1411.             mixer.mixWetSamples (outputBlock);

  1412.         }

  1413. 

  1414.         static constexpr auto effectDelaySamples = 192000;

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

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

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

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

  1419. 

  1420.         // Double precision to avoid some approximation issues

  1421.         dsp::FirstOrderTPTFilter<double> smoothFilter;

  1422. 

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

  1424. 

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

  1426.         dsp::FirstOrderTPTFilter<float> lowpass;

  1427.         dsp::DryWetMixer<float> mixer;

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

  1429. 

  1430.         int delayEffectType = 1;

  1431.     };

  1432. 

  1433.     ParameterReferences parameters;

  1434.     AudioProcessorValueTreeState apvts;

  1435. 

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

  1437.                                       dsp::Gain<float>,

  1438.                                       DirectDelayProcessor,

  1439.                                       MultiBandProcessor,

  1440.                                       dsp::Compressor<float>,

  1441.                                       dsp::Phaser<float>,

  1442.                                       dsp::Chorus<float>,

  1443.                                       DistortionProcessor,

  1444.                                       dsp::LadderFilter<float>,

  1445.                                       DelayEffectProcessor,

  1446.                                       ConvolutionProcessor,

  1447.                                       dsp::Limiter<float>,

  1448.                                       dsp::Gain<float>,

  1449.                                       dsp::Panner<float>>;

  1450.     Chain chain;

  1451. 

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

  1453.     enum ProcessorIndices

  1454.     {

  1455.         noiseGateIndex,

  1456.         inputGainIndex,

  1457.         directDelayIndex,

  1458.         multiBandIndex,

  1459.         compressorIndex,

  1460.         phaserIndex,

  1461.         chorusIndex,

  1462.         distortionIndex,

  1463.         ladderIndex,

  1464.         delayEffectIndex,

  1465.         convolutionIndex,

  1466.         limiterIndex,

  1467.         outputGainIndex,

  1468.         pannerIndex

  1469.     };

  1470. 

  1471.     //==============================================================================

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

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

  1474. 

  1475.     //==============================================================================

  1476.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (DspModulePluginDemo)

  1477. };

  1478. 

  1479. //==============================================================================

  1480. class DspModulePluginDemoEditor  : public AudioProcessorEditor

  1481. {

  1482. public:

  1483.     explicit DspModulePluginDemoEditor (DspModulePluginDemo& p)

  1484.         : AudioProcessorEditor (&p),

  1485.           proc (p)

  1486.     {

  1487.         comboEffect.addSectionHeading ("Main");

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

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

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

  1491. 

  1492.         comboEffect.addSectionHeading ("Dynamics");

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

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

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

  1496. 

  1497.         comboEffect.addSectionHeading ("Delay");

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

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

  1500. 

  1501.         comboEffect.addSectionHeading ("Others");

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

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

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

  1505. 

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

  1507.         comboEffect.onChange = [this]

  1508.         {

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

  1510.             updateVisibility();

  1511.         };

  1512. 

  1513.         addAllAndMakeVisible (*this,

  1514.                               comboEffect,

  1515.                               labelEffect,

  1516.                               basicControls,

  1517.                               distortionControls,

  1518.                               convolutionControls,

  1519.                               multibandControls,

  1520.                               compressorControls,

  1521.                               noiseGateControls,

  1522.                               limiterControls,

  1523.                               directDelayControls,

  1524.                               delayEffectControls,

  1525.                               phaserControls,

  1526.                               chorusControls,

  1527.                               ladderControls);

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

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

  1530. 

  1531.         updateVisibility();

  1532. 

  1533.         setSize (800, 430);

  1534.     }

  1535. 

  1536.     //==============================================================================

  1537.     void paint (Graphics& g) override

  1538.     {

  1539.         auto rect = getLocalBounds();

  1540. 

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

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

  1543. 

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

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

  1546. 

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

  1548.         g.fillRect (rect);

  1549. 

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

  1551.         g.fillRect (rectEffects);

  1552. 

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

  1554.         g.fillRect (rectTop);

  1555.         g.fillRect (rectBottom);

  1556.         g.fillRect (rectChoice);

  1557. 

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

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

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

  1561. 

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

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

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

  1565.     }

  1566. 

  1567.     void resized() override

  1568.     {

  1569.         auto rect = getLocalBounds();

  1570.         rect.removeFromTop (topSize);

  1571.         rect.removeFromBottom (bottomSize);

  1572. 

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

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

  1575. 

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

  1577. 

  1578.         rect.reduce (80, 0);

  1579.         rectEffects.reduce (20, 0);

  1580. 

  1581.         basicControls.setBounds (rect);

  1582. 

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

  1584.                  distortionControls,

  1585.                  convolutionControls,

  1586.                  multibandControls,

  1587.                  compressorControls,

  1588.                  noiseGateControls,

  1589.                  limiterControls,

  1590.                  directDelayControls,

  1591.                  delayEffectControls,

  1592.                  phaserControls,

  1593.                  chorusControls,

  1594.                  ladderControls);

  1595.     }

  1596. 

  1597. private:

  1598.     class AttachedSlider  : public Component

  1599.     {

  1600.     public:

  1601.         explicit AttachedSlider (RangedAudioParameter& param)

  1602.             : label ("", param.name),

  1603.               attachment (param, slider)

  1604.         {

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

  1606. 

  1607.             slider.setTextValueSuffix (" " + param.label);

  1608. 

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

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

  1611.         }

  1612. 

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

  1614. 

  1615.     private:

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

  1617.         Label label;

  1618.         SliderParameterAttachment attachment;

  1619.     };

  1620. 

  1621.     class AttachedToggle  : public Component

  1622.     {

  1623.     public:

  1624.         explicit AttachedToggle (RangedAudioParameter& param)

  1625.             : toggle (param.name),

  1626.               attachment (param, toggle)

  1627.         {

  1628.             addAndMakeVisible (toggle);

  1629.         }

  1630. 

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

  1632. 

  1633.     private:

  1634.         ToggleButton toggle;

  1635.         ButtonParameterAttachment attachment;

  1636.     };

  1637. 

  1638.     class AttachedCombo  : public Component

  1639.     {

  1640.     public:

  1641.         explicit AttachedCombo (RangedAudioParameter& param)

  1642.             : combo (param),

  1643.               label ("", param.name),

  1644.               attachment (param, combo)

  1645.         {

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

  1647. 

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

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

  1650.         }

  1651. 

  1652.         void resized() override

  1653.         {

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

  1655.         }

  1656. 

  1657.     private:

  1658.         struct ComboWithItems : public ComboBox

  1659.         {

  1660.             explicit ComboWithItems (RangedAudioParameter& param)

  1661.             {

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

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

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

  1665.             }

  1666.         };

  1667. 

  1668.         ComboWithItems combo;

  1669.         Label label;

  1670.         ComboBoxParameterAttachment attachment;

  1671.     };

  1672. 

  1673.     //==============================================================================

  1674.     void updateVisibility()

  1675.     {

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

  1677. 

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

  1679.         {

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

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

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

  1683.         };

  1684. 

  1685.         forEach (op,

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

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

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

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

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

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

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

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

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

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

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

  1697.     }

  1698. 

  1699.     enum EffectsTabs

  1700.     {

  1701.         TabDistortion = 1,

  1702.         TabConvolution,

  1703.         TabMultiBand,

  1704.         TabCompressor,

  1705.         TabNoiseGate,

  1706.         TabLimiter,

  1707.         TabDelayLineDirect,

  1708.         TabDelayLineEffect,

  1709.         TabPhaser,

  1710.         TabChorus,

  1711.         TabLadder

  1712.     };

  1713. 

  1714.     //==============================================================================

  1715.     ComboBox comboEffect;

  1716.     Label labelEffect { "Audio effect: " };

  1717. 

  1718.     struct GetTrackInfo

  1719.     {

  1720.         // Combo boxes need a lot of room

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

  1722. 

  1723.         // Toggles are a bit smaller

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

  1725. 

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

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

  1728.     };

  1729. 

  1730.     template <typename... Components>

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

  1732.     {

  1733.         Grid grid;

  1734.         using Track = Grid::TrackInfo;

  1735. 

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

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

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

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

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

  1741. 

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

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

  1744. 

  1745.         grid.performLayout (bounds);

  1746.     }

  1747. 

  1748.     struct BasicControls : public Component

  1749.     {

  1750.         explicit BasicControls (const DspModulePluginDemo::ParameterReferences& state)

  1751.             : pan       (state.pan),

  1752.               input     (state.inputGain),

  1753.               output    (state.outputGain)

  1754.         {

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

  1756.         }

  1757. 

  1758.         void resized() override

  1759.         {

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

  1761.         }

  1762. 

  1763.         AttachedSlider pan, input, output;

  1764.     };

  1765. 

  1766.     struct DistortionControls : public Component

  1767.     {

  1768.         explicit DistortionControls (const DspModulePluginDemo::ParameterReferences& state)

  1769.             : toggle       (state.distortionEnabled),

  1770.               lowpass      (state.distortionLowpass),

  1771.               highpass     (state.distortionHighpass),

  1772.               mix          (state.distortionMix),

  1773.               gain         (state.distortionInGain),

  1774.               compv        (state.distortionCompGain),

  1775.               type         (state.distortionType),

  1776.               oversampling (state.distortionOversampler)

  1777.         {

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

  1779.         }

  1780. 

  1781.         void resized() override

  1782.         {

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

  1784.         }

  1785. 

  1786.         AttachedToggle toggle;

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

  1788.         AttachedCombo type, oversampling;

  1789.     };

  1790. 

  1791.     struct ConvolutionControls : public Component

  1792.     {

  1793.         explicit ConvolutionControls (const DspModulePluginDemo::ParameterReferences& state)

  1794.             : cab    (state.convolutionCabEnabled),

  1795.               reverb (state.convolutionReverbEnabled),

  1796.               mix    (state.convolutionReverbMix)

  1797.         {

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

  1799.         }

  1800. 

  1801.         void resized() override

  1802.         {

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

  1804.         }

  1805. 

  1806.         AttachedToggle cab, reverb;

  1807.         AttachedSlider mix;

  1808.     };

  1809. 

  1810.     struct MultiBandControls : public Component

  1811.     {

  1812.         explicit MultiBandControls (const DspModulePluginDemo::ParameterReferences& state)

  1813.             : toggle (state.multiBandEnabled),

  1814.               low    (state.multiBandLowVolume),

  1815.               high   (state.multiBandHighVolume),

  1816.               lRFreq (state.multiBandFreq)

  1817.         {

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

  1819.         }

  1820. 

  1821.         void resized() override

  1822.         {

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

  1824.         }

  1825. 

  1826.         AttachedToggle toggle;

  1827.         AttachedSlider low, high, lRFreq;

  1828.     };

  1829. 

  1830.     struct CompressorControls : public Component

  1831.     {

  1832.         explicit CompressorControls (const DspModulePluginDemo::ParameterReferences& state)

  1833.             : toggle    (state.compressorEnabled),

  1834.               threshold (state.compressorThreshold),

  1835.               ratio     (state.compressorRatio),

  1836.               attack    (state.compressorAttack),

  1837.               release   (state.compressorRelease)

  1838.         {

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

  1840.         }

  1841. 

  1842.         void resized() override

  1843.         {

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

  1845.         }

  1846. 

  1847.         AttachedToggle toggle;

  1848.         AttachedSlider threshold, ratio, attack, release;

  1849.     };

  1850. 

  1851.     struct NoiseGateControls : public Component

  1852.     {

  1853.         explicit NoiseGateControls (const DspModulePluginDemo::ParameterReferences& state)

  1854.             : toggle    (state.noiseGateEnabled),

  1855.               threshold (state.noiseGateThreshold),

  1856.               ratio     (state.noiseGateRatio),

  1857.               attack    (state.noiseGateAttack),

  1858.               release   (state.noiseGateRelease)

  1859.         {

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

  1861.         }

  1862. 

  1863.         void resized() override

  1864.         {

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

  1866.         }

  1867. 

  1868.         AttachedToggle toggle;

  1869.         AttachedSlider threshold, ratio, attack, release;

  1870.     };

  1871. 

  1872.     struct LimiterControls : public Component

  1873.     {

  1874.         explicit LimiterControls (const DspModulePluginDemo::ParameterReferences& state)

  1875.             : toggle    (state.limiterEnabled),

  1876.               threshold (state.limiterThreshold),

  1877.               release   (state.limiterRelease)

  1878.         {

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

  1880.         }

  1881. 

  1882.         void resized() override

  1883.         {

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

  1885.         }

  1886. 

  1887.         AttachedToggle toggle;

  1888.         AttachedSlider threshold, release;

  1889.     };

  1890. 

  1891.     struct DirectDelayControls : public Component

  1892.     {

  1893.         explicit DirectDelayControls (const DspModulePluginDemo::ParameterReferences& state)

  1894.             : toggle (state.directDelayEnabled),

  1895.               type   (state.directDelayType),

  1896.               delay  (state.directDelayValue),

  1897.               smooth (state.directDelaySmoothing),

  1898.               mix    (state.directDelayMix)

  1899.         {

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

  1901.         }

  1902. 

  1903.         void resized() override

  1904.         {

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

  1906.         }

  1907. 

  1908.         AttachedToggle toggle;

  1909.         AttachedCombo type;

  1910.         AttachedSlider delay, smooth, mix;

  1911.     };

  1912. 

  1913.     struct DelayEffectControls : public Component

  1914.     {

  1915.         explicit DelayEffectControls (const DspModulePluginDemo::ParameterReferences& state)

  1916.             : toggle   (state.delayEffectEnabled),

  1917.               type     (state.delayEffectType),

  1918.               value    (state.delayEffectValue),

  1919.               smooth   (state.delayEffectSmoothing),

  1920.               lowpass  (state.delayEffectLowpass),

  1921.               feedback (state.delayEffectFeedback),

  1922.               mix      (state.delayEffectMix)

  1923.         {

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

  1925.         }

  1926. 

  1927.         void resized() override

  1928.         {

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

  1930.         }

  1931. 

  1932.         AttachedToggle toggle;

  1933.         AttachedCombo type;

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

  1935.     };

  1936. 

  1937.     struct PhaserControls : public Component

  1938.     {

  1939.         explicit PhaserControls (const DspModulePluginDemo::ParameterReferences& state)

  1940.             : toggle   (state.phaserEnabled),

  1941.               rate     (state.phaserRate),

  1942.               depth    (state.phaserDepth),

  1943.               centre   (state.phaserCentreFrequency),

  1944.               feedback (state.phaserFeedback),

  1945.               mix      (state.phaserMix)

  1946.         {

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

  1948.         }

  1949. 

  1950.         void resized() override

  1951.         {

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

  1953.         }

  1954. 

  1955.         AttachedToggle toggle;

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

  1957.     };

  1958. 

  1959.     struct ChorusControls : public Component

  1960.     {

  1961.         explicit ChorusControls (const DspModulePluginDemo::ParameterReferences& state)

  1962.             : toggle   (state.chorusEnabled),

  1963.               rate     (state.chorusRate),

  1964.               depth    (state.chorusDepth),

  1965.               centre   (state.chorusCentreDelay),

  1966.               feedback (state.chorusFeedback),

  1967.               mix      (state.chorusMix)

  1968.         {

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

  1970.         }

  1971. 

  1972.         void resized() override

  1973.         {

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

  1975.         }

  1976. 

  1977.         AttachedToggle toggle;

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

  1979.     };

  1980. 

  1981.     struct LadderControls : public Component

  1982.     {

  1983.         explicit LadderControls (const DspModulePluginDemo::ParameterReferences& state)

  1984.             : toggle    (state.ladderEnabled),

  1985.               mode      (state.ladderMode),

  1986.               freq      (state.ladderCutoff),

  1987.               resonance (state.ladderResonance),

  1988.               drive     (state.ladderDrive)

  1989.         {

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

  1991.         }

  1992. 

  1993.         void resized() override

  1994.         {

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

  1996.         }

  1997. 

  1998.         AttachedToggle toggle;

  1999.         AttachedCombo mode;

  2000.         AttachedSlider freq, resonance, drive;

  2001.     };

  2002. 

  2003.     //==============================================================================

  2004.     static constexpr auto topSize    = 40,

  2005.                           bottomSize = 40,

  2006.                           midSize    = 40,

  2007.                           tabSize    = 155;

  2008. 

  2009.     //==============================================================================

  2010.     DspModulePluginDemo& proc;

  2011. 

  2012.     BasicControls       basicControls       { proc.getParameterValues() };

  2013.     DistortionControls  distortionControls  { proc.getParameterValues() };

  2014.     ConvolutionControls convolutionControls { proc.getParameterValues() };

  2015.     MultiBandControls   multibandControls   { proc.getParameterValues() };

  2016.     CompressorControls  compressorControls  { proc.getParameterValues() };

  2017.     NoiseGateControls   noiseGateControls   { proc.getParameterValues() };

  2018.     LimiterControls     limiterControls     { proc.getParameterValues() };

  2019.     DirectDelayControls directDelayControls { proc.getParameterValues() };

  2020.     DelayEffectControls delayEffectControls { proc.getParameterValues() };

  2021.     PhaserControls      phaserControls      { proc.getParameterValues() };

  2022.     ChorusControls      chorusControls      { proc.getParameterValues() };

  2023.     LadderControls      ladderControls      { proc.getParameterValues() };

  2024. 

  2025.     //==============================================================================

  2026.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (DspModulePluginDemoEditor)

  2027. };

  2028. 

  2029. struct DspModulePluginDemoAudioProcessor  : public DspModulePluginDemo

  2030. {

  2031.     AudioProcessorEditor* createEditor() override

  2032.     {

  2033.         return new DspModulePluginDemoEditor (*this);

  2034.     }

  2035. 

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

  2037. };