Add global tuning settings.

Author: Archie3d

Aeolus.jucer

@@ -72,6 +72,10 @@
         <FILE id="ABDlK8" name="DivisionView.cpp" compile="1" resource="0"
               file="Source/ui/DivisionView.cpp"/>
         <FILE id="oWzSbD" name="DivisionView.h" compile="0" resource="0" file="Source/ui/DivisionView.h"/>
+        <FILE id="uSLj0t" name="GlobalTuningComponent.cpp" compile="1" resource="0"
+              file="Source/ui/GlobalTuningComponent.cpp"/>
+        <FILE id="LrvnWd" name="GlobalTuningComponent.h" compile="0" resource="0"
+              file="Source/ui/GlobalTuningComponent.h"/>
         <FILE id="si86HY" name="LevelIndicator.cpp" compile="1" resource="0"
               file="Source/ui/LevelIndicator.cpp"/>
         <FILE id="neJNeV" name="LevelIndicator.h" compile="0" resource="0"

Source/PluginEditor.cpp

@@ -19,6 +19,7 @@
 
 #include "aeolus/engine.h"
 #include "ui/CustomLookAndFeel.h"
+#include "ui/GlobalTuningComponent.h"
 
 #include "PluginProcessor.h"
 #include "PluginEditor.h"
@@ -47,6 +48,7 @@ AeolusAudioProcessorEditor::AeolusAudioProcessorEditor (AeolusAudioProcessor& p)
     , _volumeSlider{*p.getParametersContainer().volume, juce::Slider::LinearHorizontal}
     , _volumeLevelL{p.getEngine().getVolumeLevel().left, ui::LevelIndicator::Orientation::Horizontal}
     , _volumeLevelR{p.getEngine().getVolumeLevel().right, ui::LevelIndicator::Orientation::Horizontal}
+    , _tuningButton{"Tune"}
     , _panicButton{"PANIC"}
     , _cancelButton{"Cancel"}
     , _midiControlChannelLabel{{}, {"Control channel"}}
@@ -106,6 +108,31 @@ AeolusAudioProcessorEditor::AeolusAudioProcessorEditor (AeolusAudioProcessor& p)
     _volumeSlider.setSkewFactor(0.5f);
     _volumeSlider.setLookAndFeel(&ui::CustomLookAndFeel::getInstance());
 
+    addAndMakeVisible(_tuningButton);
+    _tuningButton.onClick = [this] {
+        auto content = std::make_unique<ui::GlobalTuningComponent>();
+        content->setSize(240, 140);
+        auto* contentPtr = content.get();
+
+        auto& box = CallOutBox::launchAsynchronously(std::move(content), _tuningButton.getBounds(), this);
+        contentPtr->onCancel = [&box] { box.dismiss(); };
+        contentPtr->onOk = [&box, contentPtr] {
+            const float freq = contentPtr->getTuningFrequency();
+            const auto scaleType = contentPtr->getTuningScaleType();
+
+            auto* g = aeolus::EngineGlobal::getInstance();
+            const bool changed = (g->getTuningFrequency() != freq) || (g->getScale().getType() != scaleType);
+
+            if (changed) {
+                g->setTuningFrequency(freq);
+                g->setScaleType(scaleType);
+                g->rebuildRankwaves();
+            }
+
+            box.dismiss();
+        };
+    };
+
     _panicButton.setColour(TextButton::textColourOffId, Colour(0xFF, 0xFF, 0xFF));
     _panicButton.setColour(TextButton::buttonColourId, Colour(0xCC, 0x33, 0x00));
     addAndMakeVisible(_panicButton);
@@ -185,7 +212,7 @@ void AeolusAudioProcessorEditor::resized()
 
     constexpr int margin = 5;
 
-    _versionLabel.setBounds(getWidth() - 60, margin, 60 - margin, 20);
+    _versionLabel.setBounds(getWidth() - 60, getHeight() - 20, 60 - margin, 20);
 
     _cpuLoadLabel.setBounds(margin, margin, 70, 20);
     _cpuLoadValueLabel.setBounds(_cpuLoadLabel.getRight() + margin, margin, 36, 20);
@@ -202,7 +229,9 @@ void AeolusAudioProcessorEditor::resized()
     _volumeLevelL.setBounds(_volumeSlider.getX() + 5, _volumeSlider.getY() + 2, _volumeSlider.getWidth() - 10, 2);
     _volumeLevelR.setBounds(_volumeSlider.getX() + 5, _volumeSlider.getY() + _volumeSlider.getHeight() - 4, _volumeSlider.getWidth() - 10, 2);
 
-    _panicButton.setBounds(_volumeSlider.getRight() + 40, margin, 50, 20);
+    _tuningButton.setBounds(_volumeSlider.getRight() + 40, margin, 60, 20);
+
+    _panicButton.setBounds(getWidth() - 90, margin, 50, 20);
 
     constexpr int T = margin * 2 + 20;
     constexpr int sequencerHeight = 26;

Source/PluginEditor.h

@@ -89,6 +89,8 @@ class AeolusAudioProcessorEditor  : public juce::AudioProcessorEditor,
     ui::LevelIndicator _volumeLevelL;
     ui::LevelIndicator _volumeLevelR;
 
+    juce::TextButton _tuningButton;
+
     /// Kill all active voices button
     juce::TextButton _panicButton;
 

Source/PluginProcessor.cpp

@@ -33,12 +33,16 @@ AeolusAudioProcessor::AeolusAudioProcessor()
     , _panicRequest{false}
 {
     _engine.getMidiKeyboardState().addListener(this);
+
+    aeolus::EngineGlobal::getInstance()->registerProcessorProxy(this);
 }
 
 AeolusAudioProcessor::~AeolusAudioProcessor()
 {
     // If we don't do this there is a leaked AccessibilityHandler instance detected.
     _engine.getMidiKeyboardState().removeListener(this);
+
+    aeolus::EngineGlobal::getInstance()->unregisterProcessorProxy(this);
 }
 
 //==============================================================================

Source/PluginProcessor.h

@@ -29,19 +29,25 @@
 /**
 */
 class AeolusAudioProcessor : public juce::AudioProcessor,
-                                    juce::MidiKeyboardState::Listener
+                                    juce::MidiKeyboardState::Listener,
+                                    aeolus::EngineGlobal::ProcessorProxy
 {
 public:
     //==============================================================================
     AeolusAudioProcessor();
     ~AeolusAudioProcessor() override;
 
-    aeolus::Engine& getEngine() noexcept { return _engine; }
-
     Parameters& getParametersContainer() noexcept { return _parameters; }
 
     void panic() noexcept { _panicRequest = true; }
 
+    //==============================================================================
+    // aeolus::EngineGlobal::ProcessorProxy
+    juce::AudioProcessor* getAudioProcessor() override { return this; }
+    aeolus::Engine& getEngine() override { return _engine; }
+    void killAllVoices() override { panic(); }
+    int getNumberOfActiveVoices() override { return _engine.getVoiceCount(); }
+
     //==============================================================================
     void prepareToPlay (double sampleRate, int samplesPerBlock) override;
     void releaseResources() override;

Source/aeolus/engine.cpp

@@ -60,6 +60,19 @@ EngineGlobal::EngineGlobal()
     loadIRs();
 }
 
+void EngineGlobal::registerProcessorProxy(ProcessorProxy* proxy)
+{
+    jassert(proxy != nullptr);
+    _processors.addIfNotAlreadyThere(proxy);
+}
+
+void EngineGlobal::unregisterProcessorProxy(ProcessorProxy* proxy)
+{
+    jassert(proxy != nullptr);
+    _processors.removeAllInstancesOf(proxy);
+}
+
+
 StringArray EngineGlobal::getAllStopNames() const
 {
     StringArray names;
@@ -80,6 +93,8 @@ Rankwave* EngineGlobal::getStopByName(const String& name)
 
 void EngineGlobal::updateStops(float sampleRate)
 {
+    _sampleRate = sampleRate;
+
     ThreadPool threadPool;
     std::atomic<int> done((int)_rankwaves.size());
     WaitableEvent wait;
@@ -102,6 +117,35 @@ void EngineGlobal::updateStops(float sampleRate)
 */
 }
 
+void EngineGlobal::rebuildRankwaves()
+{
+    // Prepare all the rankwaves to be retuned
+    for (auto* rw : _rankwaves) {
+        rw->retunePipes(_scale, _tuningFrequency);
+    }
+
+    // Kill all the active voices
+    int numActiveVoices = 0;
+
+    for (auto* processor : _processors) {
+        processor->killAllVoices();
+        numActiveVoices += processor->getNumberOfActiveVoices();
+    }
+
+    Thread::sleep(10);
+
+    // Wait for the voices to stop
+    while (numActiveVoices > 0) {
+        numActiveVoices = 0;
+        for (auto* processor : _processors) {
+            numActiveVoices += processor->getNumberOfActiveVoices();
+            Thread::sleep(100);
+        }
+    }
+
+    updateStops(_sampleRate);
+}
+
 void EngineGlobal::loadRankwaves()
 {
     auto& model = *Model::getInstance();

Source/aeolus/engine.h

@@ -36,6 +36,8 @@
 
 AEOLUS_NAMESPACE_BEGIN
 
+class Engine;
+
 /**
  * @brief A global shared instance of the organ engine.
  * 
@@ -45,6 +47,18 @@ class EngineGlobal : public juce::DeletedAtShutdown
 {
 public:
 
+    class ProcessorProxy
+    {
+    public:
+        virtual juce::AudioProcessor* getAudioProcessor() = 0;
+        virtual Engine& getEngine() = 0;
+        virtual void killAllVoices() = 0;
+        virtual int getNumberOfActiveVoices() = 0;
+    };
+
+    void registerProcessorProxy(ProcessorProxy* proxy);
+    void unregisterProcessorProxy(ProcessorProxy* proxy);
+
     /**
      * Impulse response descriptor for IRs embedded as binary resources.
      */
@@ -72,11 +86,13 @@ class EngineGlobal : public juce::DeletedAtShutdown
     void updateStops(float sampleRate);
 
     float getTuningFrequency() const noexcept { return _tuningFrequency; }
-    void setTuningFrequenct(float f) noexcept { _tuningFrequency = f; }
+    void setTuningFrequency(float f) noexcept { _tuningFrequency = f; }
 
     const Scale& getScale() const noexcept { return _scale; }
     void setScaleType(Scale::Type type) noexcept { _scale.setType(type); }
 
+    void rebuildRankwaves();
+
     JUCE_DECLARE_SINGLETON (EngineGlobal, false)
 
 private:
@@ -86,12 +102,15 @@ class EngineGlobal : public juce::DeletedAtShutdown
     void loadRankwaves();
     void loadIRs();
 
+    juce::Array<ProcessorProxy*> _processors;
+
     juce::OwnedArray<Rankwave> _rankwaves;
     juce::HashMap<juce::String, Rankwave*> _rankwavesByName;
 
     std::vector<IR> _irs;
     int _longestIRLength;   ///< Longest IR length in samples
 
+    float _sampleRate;
     Scale _scale;
     float _tuningFrequency;
 };

Source/aeolus/globals.h

@@ -82,6 +82,12 @@ constexpr static float TREMULANT_LEVEL = 1.0f;
 /// Number of steps in the sequencer.
 constexpr static int SEQUENCER_N_STEPS = 16;
 
+/// mid-A tuning frequency.
+constexpr static float TUNING_FREQUENCY_MIN = 350.0f;
+constexpr static float TUNING_FREQUENCY_MAX = 550.0f;
+constexpr static float TUNING_FREQUENCY_STEP = 1.0f;
+constexpr static float TUNING_FREQUENCY_DEFAULT = 440.0f;
+
 //==============================================================================
 
 // MIDI controls

Source/aeolus/rankwave.cpp

@@ -30,6 +30,7 @@ Pipewave::Pipewave(Addsynth& model, int note, float freq)
     : _model(model)
     , _note(note)
     , _freq(freq)
+    , _needsToBeRebuilt{true}
 {
 
 }
@@ -41,7 +42,7 @@ float Pipewave::getPipeFrequency() const noexcept
 
 void Pipewave::prepateToPlay(float sampleRate)
 {
-    if (_wavetable.size() == 0 || _sampleRate != sampleRate) {
+    if (_wavetable.size() == 0 || _sampleRate != sampleRate || _needsToBeRebuilt.load()) {
         _sampleRate = sampleRate;
 
         genwave();
@@ -51,8 +52,12 @@ void Pipewave::prepateToPlay(float sampleRate)
 Pipewave::State Pipewave::trigger()
 {
     Pipewave::State state = {};
-    state.pipewave = this;
-    state.env = Pipewave::Attack;
+
+    if (!_needsToBeRebuilt.load()) {
+        state.pipewave = this;
+        state.env = Pipewave::Attack;
+    }
+
     return state;
 }
 
@@ -312,6 +317,8 @@ void Pipewave::genwave()
 
     for (int i = 0; i < _sampleStep * (SUB_FRAME_LENGTH + 4); ++i)
         _attackStartPtr[i + _attackLength + _loopLength] = _attackStartPtr[i + _attackLength];
+
+    _needsToBeRebuilt = false;
 }
 
 void Pipewave::looplen(float f, float sampleRate, int lmax, int& aa, int& bb)
@@ -424,7 +431,7 @@ void Rankwave::retunePipes(const Scale& scale, float tuningFrequency)
     for (int i = _noteMin; i <= _noteMax; ++i) {
         Pipewave* pipe = _pipes[i - _noteMin];
         pipe->setFrequency(ldexpf(fbase * s[i % 12], i/12 - 5));
-
+        pipe->setNeedsToBeRebuilt(true);
     }
 }
 

Source/aeolus/rankwave.h

@@ -77,6 +77,8 @@ class Pipewave
     // After changing the frequency of the pipe, the wavetable must be regenerated
     // by calling prepareToPlay() method.
     void setFrequency(float f) noexcept { _freq = f; }
+    void setNeedsToBeRebuilt(bool v) noexcept { _needsToBeRebuilt = v; }
+    bool doesNeedToBeRebuilt() const noexcept { return _needsToBeRebuilt.load(); }
 
     int getNote() const noexcept { return _note + _model.getNoteMin(); }
     float getFreqency() const noexcept { return _freq; }
@@ -100,6 +102,10 @@ class Pipewave
     float _freq;
     float _sampleRate;
 
+    // Tells whether this pipewave needs to be re-generated.
+    // This is required for example when changing the tuninig.
+    std::atomic<bool> _needsToBeRebuilt;
+
     int _attackLength;          // _l0
     int _loopLength;            // _l1
     int _sampleStep;            // _k_s