initial spectrum analyser implementation (#29)

* initial spectrum analyser commit

* Apply clang-format

* windowing, scaling and smoothing modified for magnitude response

* Apply clang-format

* accidentally removed the changes to PluginEditor.cpp via merge, restoring changes

* Apply clang-format

* Stuff

* Apply clang-format

* Scaling Adjusted to Cover a Wider Dynamic Range

* Apply clang-format

* Jatin tweaks

* Apply clang-format

* Spectrum Analyser Task Refactor and Checks for UI Instance

* Apply clang-format

* pre/post eq tasks configured

* Apply clang-format

* Tweaks for spectrum analyzer stuff and add right-click options to disable analyzers

* Apply clang-format

* comments and unused methods removed

* PR Feedback Addressed

* Apply clang-format

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: jatin <[email protected]>

src/CMakeLists.txt

@@ -74,6 +74,8 @@ target_sources(ChowMultiTool PRIVATE
     gui/Shared/TextSlider.cpp
     gui/Shared/LookAndFeels.cpp
     gui/Shared/VerticalSlider.cpp
+    gui/Shared/SpectrumAnalyser.cpp
+    gui/Shared/SpectrumAnalyserTask.cpp
 )
 
-target_precompile_headers(ChowMultiTool PRIVATE pch.h)
+target_precompile_headers(ChowMultiTool PRIVATE pch.h)

src/ChowMultiTool.h

@@ -15,6 +15,7 @@ class ChowMultiTool : public chowdsp::PluginBase<State>
     void processAudioBlock (juce::AudioBuffer<float>&) override {}
     bool isBusesLayoutSupported (const BusesLayout& layout) const override;
     bool acceptsMidi() const override { return true; }
+    dsp::MultiToolProcessor& getProcessor() { return processor; }
 
     juce::AudioProcessorEditor* createEditor() override;
 

src/dsp/EQ/EQProcessor.cpp

@@ -2,6 +2,12 @@
 
 namespace dsp::eq
 {
+EQProcessor::EQProcessor (const EQToolParams& eqParams, const ExtraState& es)
+    : params (eqParams),
+      extraState (es)
+{
+}
+
 void EQProcessor::prepare (const juce::dsp::ProcessSpec& spec)
 {
     linPhaseEQ.updatePrototypeEQParameters = [] (auto& pEQ, auto& eqParams)
@@ -14,10 +20,16 @@ void EQProcessor::prepare (const juce::dsp::ProcessSpec& spec)
     EQToolParams::EQParams::setEQParameters (eq, eqParams);
     eq.prepare (spec);
     linPhaseEQ.prepare (spec, getEQParams());
+
+    preSpectrumAnalyserTask.prepareToPlay (spec.sampleRate, (int) spec.maximumBlockSize, (int) spec.numChannels);
+    postSpectrumAnalyserTask.prepareToPlay (spec.sampleRate, (int) spec.maximumBlockSize, (int) spec.numChannels);
 }
 
 void EQProcessor::processBlock (const chowdsp::BufferView<float>& buffer)
 {
+    if (extraState.isEditorOpen.load() && extraState.showPreSpectrum.get())
+        preSpectrumAnalyserTask.processBlockInput (buffer.toAudioBuffer());
+
     const auto&& eqParams = getEQParams();
     EQToolParams::EQParams::setEQParameters (eq, eqParams);
     linPhaseEQ.setParameters (eqParams);
@@ -37,6 +49,9 @@ void EQProcessor::processBlock (const chowdsp::BufferView<float>& buffer)
 
         chowdsp::BufferMath::copyBufferData (doubleBuffer, buffer);
     }
+
+    if (extraState.isEditorOpen.load() && extraState.showPostSpectrum.get())
+        postSpectrumAnalyserTask.processBlockInput (buffer.toAudioBuffer());
 }
 
 int EQProcessor::getLatencySamples() const

src/dsp/EQ/EQProcessor.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "gui/Shared/SpectrumAnalyserTask.h"
 #include <pch.h>
 
 namespace dsp::eq
@@ -105,18 +106,27 @@ struct EQToolParams : chowdsp::ParamHolder
                                                   false };
 };
 
+struct ExtraState
+{
+    std::atomic<bool> isEditorOpen { false };
+    chowdsp::StateValue<std::atomic_bool, bool> showPreSpectrum { "eq_show_pre_spectrum", true };
+    chowdsp::StateValue<std::atomic_bool, bool> showPostSpectrum { "eq_show_post_spectrum", true };
+};
+
 class EQProcessor
 {
 public:
-    explicit EQProcessor (const EQToolParams& eqParams) : params (eqParams) {}
+    EQProcessor (const EQToolParams& eqParams, const ExtraState& extraState);
 
     void prepare (const juce::dsp::ProcessSpec& spec);
     void processBlock (const chowdsp::BufferView<float>& buffer);
 
     int getLatencySamples() const;
+    std::pair<gui::SpectrumAnalyserTask&, gui::SpectrumAnalyserTask&> getSpectrumAnalyserTasks() { return { preSpectrumAnalyserTask, postSpectrumAnalyserTask }; }
 
 private:
     const EQToolParams& params;
+    const ExtraState& extraState;
 
     auto getEQParams()
     {
@@ -148,6 +158,8 @@ class EQProcessor
 
     using LinearPhaseProtoEQ = chowdsp::EQ::LinearPhasePrototypeEQ<double, EQToolParams::EQParams::Params, EQToolParams::EQParams::EQNumBands, EQBand<double>>;
     chowdsp::EQ::LinearPhaseEQ<LinearPhaseProtoEQ> linPhaseEQ;
+    gui::SpectrumAnalyserTask preSpectrumAnalyserTask;
+    gui::SpectrumAnalyserTask postSpectrumAnalyserTask;
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EQProcessor)
 };

src/dsp/MultiToolProcessor.cpp

@@ -24,8 +24,8 @@ namespace detail
     {
         const auto& params = pluginState.params;
         return {
-            tool_maker<eq::EQProcessor> ([&params]
-                                         { return eq::EQProcessor { *params.eqParams }; }),
+            tool_maker<eq::EQProcessor> ([&params, &pluginState]
+                                         { return eq::EQProcessor { *params.eqParams, *pluginState.nonParams.eqExtraState }; }),
             tool_maker<waveshaper::WaveshaperProcessor> ([&pluginState]
                                                          { return waveshaper::WaveshaperProcessor {
                                                                pluginState,
@@ -112,7 +112,6 @@ void MultiToolProcessor::processBlock (juce::AudioBuffer<float>& buffer, const j
             buffer.clear (ch, 0, buffer.getNumSamples());
     };
 
-
     const auto isOn = ! params.bypassParam->get();
     if (! bypass.processBlockIn (mainBusBuffer, isOn))
     {

src/dsp/MultiToolProcessor.h

@@ -28,6 +28,7 @@ class MultiToolProcessor
 
     void prepare (const juce::dsp::ProcessSpec& spec);
     void processBlock (juce::AudioBuffer<float>& buffer, const juce::MidiBuffer& midiBuffer);
+    ToolTypes::Types& getTools() { return tools; }
 
 private:
     void recalculateLatency();

src/dsp/SVF/SVFProcessor.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "gui/Shared/SpectrumAnalyserTask.h"
 #include <pch.h>
 
 namespace dsp::svf

src/gui/Brickwall/BrickwallChyron.h

@@ -10,8 +10,8 @@ class BrickwallChyron : public juce::Component
 {
 public:
     BrickwallChyron (chowdsp::PluginState& pluginState,
-                      dsp::brickwall::Params& params,
-                      const chowdsp::HostContextProvider& hcp);
+                     dsp::brickwall::Params& params,
+                     const chowdsp::HostContextProvider& hcp);
 
     void resized() override;
     void paint (juce::Graphics& g) override;
@@ -25,4 +25,4 @@ class BrickwallChyron : public juce::Component
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (BrickwallChyron)
 };
-}
+} // namespace gui::brickwall

src/gui/Brickwall/BrickwallPlot.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include "BrickwallChyron.h"
 #include "dsp/Brickwall/BrickwallProcessor.h"
 #include "state/PluginState.h"
-#include "BrickwallChyron.h"
 
 namespace gui::brickwall
 {

src/gui/EQ/EQChyron.cpp

@@ -16,19 +16,26 @@ EQChyron::EQChyron (chowdsp::PluginState& pluginState,
 
 void EQChyron::setSelectedBand (int newSelectedBand)
 {
-    setVisible (newSelectedBand >= 0);
+    if (! selectedBand.has_value() && newSelectedBand < 0)
+        return; // no band selected -> no band selected
 
-    if (newSelectedBand < 0)
-        return;
+    if (selectedBand.has_value() && newSelectedBand == *selectedBand)
+    {
+        const auto& activeParams = eqParams.eqParams[(size_t) *selectedBand];
+        const auto newFilterType = helpers::getFilterType (activeParams.typeParam->getIndex());
 
-    auto& activeParams = eqParams.eqParams[(size_t) selectedBand];
-    const auto newFilterType = helpers::getFilterType (activeParams.typeParam->getIndex());
+        if (filterType == newFilterType)
+            return;
+    }
 
-    if (selectedBand == newSelectedBand && filterType == newFilterType)
-        return;
+    if (newSelectedBand >= 0)
+        selectedBand.emplace (newSelectedBand);
+    else
+        selectedBand.reset();
 
-    selectedBand = newSelectedBand;
     updateValues();
+
+    setVisible (selectedBand.has_value());
 }
 
 void EQChyron::updateValues()
@@ -40,13 +47,13 @@ void EQChyron::updateValues()
         gainSlider.reset();
     };
 
-    if (selectedBand < 0)
+    if (! selectedBand.has_value())
     {
         reset();
         return;
     }
 
-    auto& activeParams = eqParams.eqParams[(size_t) selectedBand];
+    auto& activeParams = eqParams.eqParams[(size_t) *selectedBand];
     if (! activeParams.onOffParam->get())
     {
         reset();

src/gui/EQ/EQChyron.h

@@ -22,7 +22,7 @@ class EQChyron : public juce::Component
 private:
     void updateValues();
 
-    int selectedBand = -1;
+    std::optional<int> selectedBand { std::nullopt };
     chowdsp::EQ::EQPlotFilterType filterType = chowdsp::EQ::EQPlotFilterType::LPF1;
 
     chowdsp::PluginState& state;

src/gui/EQ/EQEditor.cpp

@@ -1,23 +1,48 @@
 #include "EQEditor.h"
 #include "BottomBar.h"
 #include "gui/Shared/Colours.h"
+#include "gui/Shared/LookAndFeels.h"
 
 namespace gui::eq
 {
-EQEditor::EQEditor (State& pluginState, dsp::eq::EQToolParams& eqParams, const chowdsp::HostContextProvider& hcp)
-    : plot (pluginState, eqParams.eqParams, hcp),
+EQEditor::EQEditor (State& pluginState,
+                    dsp::eq::EQToolParams& eqParams,
+                    dsp::eq::ExtraState& eqExtraState,
+                    const chowdsp::HostContextProvider& hcp,
+                    std::pair<SpectrumAnalyserTask&, SpectrumAnalyserTask&> spectrumAnalyserTasks)
+    : params (eqParams),
+      extraState (eqExtraState),
+      plot (pluginState, eqParams.eqParams, hcp),
       paramsView (pluginState, eqParams),
       linearPhaseButton ("Vector/arrow-right-arrow-left-solid.svg", colours::thumbColours[0], colours::linesColour),
       linearPhaseAttach (eqParams.linearPhaseMode, pluginState, linearPhaseButton),
+      spectrumAnalyser (plot, spectrumAnalyserTasks),
       drawButton ("Vector/pencil-solid.svg", colours::linesColour, colours::linesColour),
       drawCheckButton ("Vector/square-check-regular.svg", colours::linesColour, colours::linesColour),
       drawXButton ("Vector/rectangle-xmark-regular.svg", colours::linesColour, colours::linesColour)
 {
+    addMouseListener (this, true);
+    extraState.isEditorOpen.store (true);
+    spectrumAnalyser.setShowPreEQ (extraState.showPreSpectrum.get());
+    spectrumAnalyser.setShowPostEQ (extraState.showPostSpectrum.get());
+    callbacks += {
+        extraState.showPreSpectrum.changeBroadcaster.connect ([this]
+                                                              {
+            spectrumAnalyser.setShowPreEQ(extraState.showPreSpectrum.get());
+            spectrumAnalyser.repaint(); }),
+        extraState.showPostSpectrum.changeBroadcaster.connect ([this]
+                                                               {
+            spectrumAnalyser.setShowPostEQ(extraState.showPostSpectrum.get());
+            spectrumAnalyser.repaint(); }),
+    };
+
     bottomBar = std::make_unique<BottomBar> (pluginState, eqParams);
 
     addAndMakeVisible (plot);
     addAndMakeVisible (bottomBar.get());
     addAndMakeVisible (linearPhaseButton);
+    addAndMakeVisible (spectrumAnalyser);
+    spectrumAnalyser.toBack();
 
     linearPhaseButton.setTooltip ("Linear Phase");
 
@@ -50,6 +75,43 @@ EQEditor::EQEditor (State& pluginState, dsp::eq::EQToolParams& eqParams, const c
     };
 }
 
+EQEditor::~EQEditor()
+{
+    removeMouseListener (this);
+    extraState.isEditorOpen.store (false);
+}
+
+void EQEditor::mouseDown (const juce::MouseEvent& event)
+{
+    if (event.mods.isPopupMenu())
+    {
+        chowdsp::SharedLNFAllocator lnfAllocator;
+        juce::PopupMenu menu;
+
+        juce::PopupMenu::Item preSpectrumItem;
+        preSpectrumItem.itemID = 100;
+        preSpectrumItem.text = extraState.showPreSpectrum.get() ? "Disable Pre-EQ Visualizer" : "Enable Pre-EQ Visualizer";
+        preSpectrumItem.action = [this]
+        {
+            extraState.showPreSpectrum.set (! extraState.showPreSpectrum.get());
+        };
+        menu.addItem (preSpectrumItem);
+
+        juce::PopupMenu::Item postSpectrumItem;
+        postSpectrumItem.itemID = 101;
+        postSpectrumItem.text = extraState.showPostSpectrum.get() ? "Disable Post-EQ Visualizer" : "Enable Post-EQ Visualizer";
+        postSpectrumItem.action = [this]
+        {
+            extraState.showPostSpectrum.set (! extraState.showPostSpectrum.get());
+        };
+        menu.addItem (postSpectrumItem);
+
+        menu.setLookAndFeel (lnfAllocator->getLookAndFeel<lnf::MenuLNF>());
+        menu.showMenuAsync (juce::PopupMenu::Options {}
+                                .withParentComponent (getParentComponent()));
+    }
+}
+
 void EQEditor::paint (juce::Graphics& g)
 {
     g.setGradientFill (juce::ColourGradient { colours::backgroundLight,
@@ -74,5 +136,6 @@ void EQEditor::resized()
     drawButton.setBounds (linearPhaseButton.getBoundsInParent().translated (-pad - buttonDim, 0));
     drawCheckButton.setBounds (drawButton.getBoundsInParent());
     drawXButton.setBounds (linearPhaseButton.getBoundsInParent());
+    spectrumAnalyser.setBounds (getLocalBounds());
 }
 } // namespace gui::eq

src/gui/EQ/EQEditor.h

@@ -2,6 +2,7 @@
 
 #include "EQPlot.h"
 #include "gui/Shared/IconButton.h"
+#include "gui/Shared/SpectrumAnalyser.h"
 
 // @TODO:
 // - Figure out type-in values for chyron
@@ -12,18 +13,30 @@ namespace gui::eq
 class EQEditor : public juce::Component
 {
 public:
-    EQEditor (State& pluginState, dsp::eq::EQToolParams& eqParams, const chowdsp::HostContextProvider& hcp);
+    EQEditor (State& pluginState,
+              dsp::eq::EQToolParams& eqParams,
+              dsp::eq::ExtraState& extraState,
+              const chowdsp::HostContextProvider& hcp,
+              std::pair<SpectrumAnalyserTask&, SpectrumAnalyserTask&> spectrumAnalyserTasks);
+    ~EQEditor() override;
 
     void paint (juce::Graphics& g) override;
     void resized() override;
 
+    void mouseDown (const juce::MouseEvent& event) override;
+
 private:
+    dsp::eq::EQToolParams& params;
+    dsp::eq::ExtraState& extraState;
+    chowdsp::ScopedCallbackList callbacks;
+
     EQPlot plot;
     std::unique_ptr<juce::Component> bottomBar;
     chowdsp::ParametersView paramsView;
 
     IconButton linearPhaseButton;
     chowdsp::ButtonAttachment linearPhaseAttach;
+    SpectrumAnalyser spectrumAnalyser;
 
     IconButton drawButton;
     IconButton drawCheckButton;

src/gui/PluginEditor.cpp

@@ -110,7 +110,11 @@ void PluginEditor::refreshEditor()
                 auto& pluginState = plugin.getState();
 
                 if constexpr (std::is_same_v<ToolType, dsp::eq::EQProcessor>)
-                    editorComponent = std::make_unique<eq::EQEditor> (pluginState, *pluginState.params.eqParams, hostContextProvider);
+                    editorComponent = std::make_unique<eq::EQEditor> (pluginState,
+                                                                      *pluginState.params.eqParams,
+                                                                      *pluginState.nonParams.eqExtraState,
+                                                                      hostContextProvider,
+                                                                      std::get<dsp::eq::EQProcessor> (plugin.getProcessor().getTools()).getSpectrumAnalyserTasks());
                 else if constexpr (std::is_same_v<ToolType, dsp::waveshaper::WaveshaperProcessor>)
                     editorComponent = std::make_unique<waveshaper::WaveshaperEditor> (pluginState, *pluginState.params.waveshaperParams, hostContextProvider);
                 else if constexpr (std::is_same_v<ToolType, dsp::signal_gen::SignalGeneratorProcessor>)

src/gui/PluginEditor.h

@@ -2,6 +2,8 @@
 
 #include "Toolbar/Toolbar.h"
 #include "gui/Shared/ErrorMessageView.h"
+#include "gui/Shared/SpectrumAnalyserTask.h"
+#include <pch.h>
 
 class ChowMultiTool;
 

src/gui/SVF/SVFPlot.h

@@ -3,6 +3,7 @@
 #include "SVFChyron.h"
 #include "dsp/SVF/SVFProcessor.h"
 #include "gui/Shared/DotSlider.h"
+#include "gui/Shared/SpectrumAnalyser.h"
 #include "state/PluginState.h"
 
 namespace gui::svf