Code cleanup

modules/juce_audio_plugin_client/Standalone/juce_StandaloneFilterWindow.h

@@ -35,9 +35,9 @@
     computer's audio/MIDI devices using AudioDeviceManager and AudioProcessorPlayer.
 */
 class StandalonePluginHolder
-   #if JUCE_IOS || JUCE_ANDROID
-    : private Timer
-   #endif
+                               #if JUCE_IOS || JUCE_ANDROID
+                                : private Timer
+                               #endif
 {
 public:
     /** Creates an instance of the default plugin.
@@ -95,7 +95,7 @@ public:
         jassert (processor != nullptr); // Your createPluginFilter() function must return a valid object!
 
         processor->disableNonMainBuses();
-        processor->setRateAndBufferSizeDetails(44100, 512);
+        processor->setRateAndBufferSizeDetails (44100, 512);
     }
 
     virtual void deletePlugin()
@@ -188,7 +188,7 @@ public:
        #if JucePlugin_Enable_IAA && JUCE_IOS
         if (auto device = dynamic_cast<iOSAudioIODevice*> (deviceManager.getCurrentAudioDevice()))
         {
-            processor->setPlayHead                (device->getAudioPlayHead());
+            processor->setPlayHead (device->getAudioPlayHead());
             device->setMidiMessageCollector (&player.getMidiMessageCollector());
         }
        #endif
@@ -299,7 +299,7 @@ public:
         ignoreUnused (size);
        #endif
 
-        return Image();
+        return {};
     }
    #endif
 
@@ -320,7 +320,7 @@ private:
                             const AudioDeviceManager::AudioDeviceSetup* preferredSetupOptions)
     {
         deviceManager.addAudioCallback (&player);
-        deviceManager.addMidiInputCallback (String(), &player);
+        deviceManager.addMidiInputCallback ({}, &player);
 
         reloadAudioDeviceState (preferredDefaultDeviceName, preferredSetupOptions);
     }
@@ -329,41 +329,32 @@ private:
     {
         saveAudioDeviceState();
 
-        deviceManager.removeMidiInputCallback (String(), &player);
+        deviceManager.removeMidiInputCallback ({}, &player);
         deviceManager.removeAudioCallback (&player);
     }
 
    #if JUCE_IOS || JUCE_ANDROID
     void timerCallback() override
     {
-        StringArray midiInputDevices = MidiInput::getDevices();
-        if (midiInputDevices != lastMidiDevices)
+        auto newMidiDevices = MidiInput::getDevices();
+
+        if (newMidiDevices != lastMidiDevices)
         {
+            for (auto& oldDevice : lastMidiDevices)
             {
-                const int n = lastMidiDevices.size();
-                for (int i = 0; i < n; ++i)
+                if (! newMidiDevices.contains (oldDevice))
                 {
-                    const String& oldDevice = lastMidiDevices[i];
-
-                    if (! midiInputDevices.contains (oldDevice))
-                    {
-                        deviceManager.setMidiInputEnabled (oldDevice, false);
-                        deviceManager.removeMidiInputCallback (oldDevice, &player);
-                    }
+                    deviceManager.setMidiInputEnabled (oldDevice, false);
+                    deviceManager.removeMidiInputCallback (oldDevice, &player);
                 }
             }
 
+            for (auto& newDevice : newMidiDevices)
             {
-                const int n = midiInputDevices.size();
-                for (int i = 0; i < n; ++i)
+                if (! lastMidiDevices.contains (newDevice))
                 {
-                    const String& newDevice = midiInputDevices[i];
-
-                    if (! lastMidiDevices.contains (newDevice))
-                    {
-                        deviceManager.addMidiInputCallback (newDevice, &player);
-                        deviceManager.setMidiInputEnabled (newDevice, true);
-                    }
+                    deviceManager.addMidiInputCallback (newDevice, &player);
+                    deviceManager.setMidiInputEnabled (newDevice, true);
                 }
             }
         }
@@ -416,13 +407,13 @@ public:
         Desktop::getInstance().setKioskModeComponent (this, false);
        #else
 
-        if (PropertySet* props = pluginHolder->settings)
+        if (auto* props = pluginHolder->settings.get())
         {
             const int x = props->getIntValue ("windowX", -100);
             const int y = props->getIntValue ("windowY", -100);
 
             if (x != -100 && y != -100)
-                setBoundsConstrained (juce::Rectangle<int> (x, y, getWidth(), getHeight()));
+                setBoundsConstrained ({ x, y, getWidth(), getHeight() });
             else
                 centreWithSize (getWidth(), getHeight());
         }
@@ -436,7 +427,7 @@ public:
     ~StandaloneFilterWindow()
     {
        #if (! JUCE_IOS) && (! JUCE_ANDROID)
-        if (PropertySet* props = pluginHolder->settings)
+        if (auto* props = pluginHolder->settings.get())
         {
             props->setValue ("windowX", getX());
             props->setValue ("windowY", getY());
@@ -459,7 +450,7 @@ public:
 
     void deleteEditorComp()
     {
-        if (AudioProcessorEditor* ed = dynamic_cast<AudioProcessorEditor*> (getContentComponent()))
+        if (auto* ed = dynamic_cast<AudioProcessorEditor*> (getContentComponent()))
         {
             pluginHolder->processor->editorBeingDeleted (ed);
             clearContentComponent();
@@ -473,7 +464,7 @@ public:
         deleteEditorComp();
         pluginHolder->deletePlugin();
 
-        if (PropertySet* props = pluginHolder->settings)
+        if (auto* props = pluginHolder->settings.get())
             props->removeValue ("filterState");
 
         pluginHolder->createPlugin();
@@ -541,7 +532,7 @@ StandalonePluginHolder* StandalonePluginHolder::getInstance()
    #if JucePlugin_Enable_IAA || JucePlugin_Build_STANDALONE
     if (PluginHostType::getPluginLoadedAs() == AudioProcessor::wrapperType_Standalone)
     {
-        Desktop& desktop (Desktop::getInstance());
+        auto& desktop = Desktop::getInstance();
         const int numTopLevelWindows = desktop.getNumComponents();
 
         for (int i = 0; i < numTopLevelWindows; ++i)

modules/juce_audio_utils/players/juce_AudioProcessorPlayer.cpp

@@ -24,14 +24,8 @@
   ==============================================================================
 */
 
-AudioProcessorPlayer::AudioProcessorPlayer(bool doDoublePrecisionProcessing)
-    : processor (nullptr),
-      sampleRate (0),
-      blockSize (0),
-      isPrepared (false),
-      isDoublePrecision (doDoublePrecisionProcessing),
-      numInputChans (0),
-      numOutputChans (0)
+AudioProcessorPlayer::AudioProcessorPlayer (bool doDoublePrecisionProcessing)
+    : isDoublePrecision (doDoublePrecisionProcessing)
 {
 }
 
@@ -48,11 +42,11 @@ void AudioProcessorPlayer::setProcessor (AudioProcessor* const processorToPlay)
         if (processorToPlay != nullptr && sampleRate > 0 && blockSize > 0)
         {
             processorToPlay->setPlayConfigDetails(numInputChans, numOutputChans, sampleRate, blockSize);
-            const bool supportsDouble = processorToPlay->supportsDoublePrecisionProcessing() && isDoublePrecision;
-            AudioProcessor::ProcessingPrecision precision = supportsDouble ? AudioProcessor::doublePrecision
-                                                                           : AudioProcessor::singlePrecision;
 
-            processorToPlay->setProcessingPrecision (precision);
+            bool supportsDouble = processorToPlay->supportsDoublePrecisionProcessing() && isDoublePrecision;
+
+            processorToPlay->setProcessingPrecision (supportsDouble ? AudioProcessor::doublePrecision
+                                                                    : AudioProcessor::singlePrecision);
             processorToPlay->prepareToPlay (sampleRate, blockSize);
         }
 
@@ -80,11 +74,10 @@ void AudioProcessorPlayer::setDoublePrecisionProcessing (bool doublePrecision)
         {
             processor->releaseResources();
 
-            const bool supportsDouble = processor->supportsDoublePrecisionProcessing() && doublePrecision;
-            AudioProcessor::ProcessingPrecision precision = supportsDouble ? AudioProcessor::doublePrecision
-                                                                           : AudioProcessor::singlePrecision;
+            bool supportsDouble = processor->supportsDoublePrecisionProcessing() && doublePrecision;
 
-            processor->setProcessingPrecision (precision);
+            processor->setProcessingPrecision (supportsDouble ? AudioProcessor::doublePrecision
+                                                              : AudioProcessor::singlePrecision);
             processor->prepareToPlay (sampleRate, blockSize);
         }
 
@@ -178,10 +171,10 @@ void AudioProcessorPlayer::audioDeviceIOCallback (const float** const inputChann
 
 void AudioProcessorPlayer::audioDeviceAboutToStart (AudioIODevice* const device)
 {
-    const double newSampleRate = device->getCurrentSampleRate();
-    const int newBlockSize     = device->getCurrentBufferSizeSamples();
-    const int numChansIn       = device->getActiveInputChannels().countNumberOfSetBits();
-    const int numChansOut      = device->getActiveOutputChannels().countNumberOfSetBits();
+    auto newSampleRate = device->getCurrentSampleRate();
+    auto newBlockSize  = device->getCurrentBufferSizeSamples();
+    auto numChansIn    = device->getActiveInputChannels().countNumberOfSetBits();
+    auto numChansOut   = device->getActiveOutputChannels().countNumberOfSetBits();
 
     const ScopedLock sl (lock);
 
@@ -198,7 +191,7 @@ void AudioProcessorPlayer::audioDeviceAboutToStart (AudioIODevice* const device)
         if (isPrepared)
             processor->releaseResources();
 
-        AudioProcessor* const oldProcessor = processor;
+        auto* oldProcessor = processor;
         setProcessor (nullptr);
         setProcessor (oldProcessor);
     }

modules/juce_audio_utils/players/juce_AudioProcessorPlayer.h

@@ -43,7 +43,7 @@ class JUCE_API  AudioProcessorPlayer    : public AudioIODeviceCallback,
 {
 public:
     //==============================================================================
-    AudioProcessorPlayer(bool doDoublePrecisionProcessing = false);
+    AudioProcessorPlayer (bool doDoublePrecisionProcessing = false);
 
     /** Destructor. */
     virtual ~AudioProcessorPlayer();
@@ -91,13 +91,13 @@ public:
 
 private:
     //==============================================================================
-    AudioProcessor* processor;
+    AudioProcessor* processor = nullptr;
     CriticalSection lock;
-    double sampleRate;
-    int blockSize;
-    bool isPrepared, isDoublePrecision;
+    double sampleRate = 0;
+    int blockSize = 0;
+    bool isPrepared = false, isDoublePrecision = false;
 
-    int numInputChans, numOutputChans;
+    int numInputChans = 0, numOutputChans = 0;
     HeapBlock<float*> channels;
     AudioBuffer<float> tempBuffer;
     AudioBuffer<double> conversionBuffer;