From 04c67e4397800b34abb64a8e0a66902f20f842e3 Mon Sep 17 00:00:00 2001
From: Peter Rudenko <peter.rudenko@gmail.com>
Date: Sun, 30 Oct 2022 13:36:16 +0400
Subject: [PATCH] Add built-in SoundFont player instrument (#236)

---
 .../BuiltIn/BuiltInSynthsPluginFormat.cpp     |  14 +
 .../Audio/BuiltIn/BuiltInSynthsPluginFormat.h |   1 +
 .../BuiltIn/SoundFont/SoundFontSynth.cpp      |  95 +++++
 .../Audio/BuiltIn/SoundFont/SoundFontSynth.h  |  20 ++
 .../BuiltIn/SoundFontSynthAudioPlugin.cpp     | 339 ++++++++++++++++++
 .../Audio/BuiltIn/SoundFontSynthAudioPlugin.h |  90 +++++
 .../Core/Audio/Instruments/PluginScanner.cpp  |   6 +-
 Source/Core/Audio/Instruments/PluginScanner.h |   2 +-
 Source/Core/Serialization/SerializationKeys.h |   9 +-
 Source/UI/Common/CommandIDs.cpp               |   2 +
 Source/UI/Common/CommandIDs.h                 |   6 +-
 Source/UI/Common/ModeIndicatorComponent.cpp   |  66 ++--
 Source/UI/Common/ModeIndicatorComponent.h     |  13 +-
 .../Sidebars/SequencerSidebarLeft.cpp         |   3 +-
 14 files changed, 634 insertions(+), 32 deletions(-)
 create mode 100644 Source/Core/Audio/BuiltIn/SoundFontSynthAudioPlugin.cpp
 create mode 100644 Source/Core/Audio/BuiltIn/SoundFontSynthAudioPlugin.h

diff --git a/Source/Core/Audio/BuiltIn/BuiltInSynthsPluginFormat.cpp b/Source/Core/Audio/BuiltIn/BuiltInSynthsPluginFormat.cpp
index 21efcc33b..bbe3b0d42 100644
--- a/Source/Core/Audio/BuiltIn/BuiltInSynthsPluginFormat.cpp
+++ b/Source/Core/Audio/BuiltIn/BuiltInSynthsPluginFormat.cpp
@@ -19,6 +19,7 @@
 #include "BuiltInSynthsPluginFormat.h"
 #include "DefaultSynthAudioPlugin.h"
 #include "MetronomeSynthAudioPlugin.h"
+#include "SoundFontSynthAudioPlugin.h"
 
 const String BuiltInSynthsPluginFormat::formatName = "BuiltIn";
 const String BuiltInSynthsPluginFormat::formatIdentifier = "BuiltIn";
@@ -30,6 +31,9 @@ BuiltInSynthsPluginFormat::BuiltInSynthsPluginFormat()
 
     MetronomeSynthAudioPlugin metronomeAudioPlugin;
     metronomeAudioPlugin.fillInPluginDescription(this->metronomeInstrument);
+
+    SoundFontSynthAudioPlugin soundFontSynthAudioPlugin;
+    soundFontSynthAudioPlugin.fillInPluginDescription(this->soundFontPlayerInstrument);
 }
 
 String BuiltInSynthsPluginFormat::getName() const
@@ -47,6 +51,10 @@ void BuiltInSynthsPluginFormat::findAllTypesForFile(OwnedArray<PluginDescription
     {
         description.add(new PluginDescription(this->metronomeInstrument));
     }
+    else if (id == SoundFontSynthAudioPlugin::instrumentId)
+    {
+        description.add(new PluginDescription(this->soundFontPlayerInstrument));
+    }
 }
 
 bool BuiltInSynthsPluginFormat::fileMightContainThisPluginType(const String &fileOrIdentifier)
@@ -70,5 +78,11 @@ void BuiltInSynthsPluginFormat::createPluginInstance(const PluginDescription &de
         return;
     }
 
+    if (desc.name == this->soundFontPlayerInstrument.name)
+    {
+        callback(make<SoundFontSynthAudioPlugin>(), {});
+        return;
+    }
+
     callback(nullptr, {});
 }
diff --git a/Source/Core/Audio/BuiltIn/BuiltInSynthsPluginFormat.h b/Source/Core/Audio/BuiltIn/BuiltInSynthsPluginFormat.h
index f16806775..e6feb615b 100644
--- a/Source/Core/Audio/BuiltIn/BuiltInSynthsPluginFormat.h
+++ b/Source/Core/Audio/BuiltIn/BuiltInSynthsPluginFormat.h
@@ -79,5 +79,6 @@ class BuiltInSynthsPluginFormat final : public AudioPluginFormat
 
     PluginDescription defaultInstrument;
     PluginDescription metronomeInstrument;
+    PluginDescription soundFontPlayerInstrument;
 
 };
diff --git a/Source/Core/Audio/BuiltIn/SoundFont/SoundFontSynth.cpp b/Source/Core/Audio/BuiltIn/SoundFont/SoundFontSynth.cpp
index 7b749aa94..bdd0ae4ee 100644
--- a/Source/Core/Audio/BuiltIn/SoundFont/SoundFontSynth.cpp
+++ b/Source/Core/Audio/BuiltIn/SoundFont/SoundFontSynth.cpp
@@ -690,6 +690,49 @@ void SoundFontVoice::killNote()
 // SoundFontSynth
 //===----------------------------------------------------------------------===//
 
+void SoundFontSynth::initSynth(const Parameters &parameters)
+{
+    const File file(parameters.filePath);
+    if (!file.existsAsFile())
+    {
+        return;
+    }
+
+    ScopedLock locker(this->lock);
+
+    this->allNotesOff(0, false);
+
+    this->clearVoices();
+    for (int i = SoundFontSynth::numVoices; i --> 0 ;)
+    {
+        this->addVoice(new SoundFontVoice());
+    }
+
+    this->clearSounds();
+
+    AudioFormatManager audioFormatManager;
+    audioFormatManager.registerBasicFormats();
+
+    if (file.getFullPathName().endsWithIgnoreCase("sf2"))
+    {
+        auto sound = make<SoundFont2Sound>(file);
+        sound->loadRegions();
+        sound->loadSamples(audioFormatManager);
+        this->sounds.add(sound.release());
+    }
+    else if (file.getFullPathName().endsWithIgnoreCase("sbk"))
+    {
+        auto sound = make<SoundFontSound>(file);
+        sound->loadRegions();
+        sound->loadSamples(audioFormatManager);
+        this->sounds.add(sound.release());
+    }
+
+    // new file has been loaded so we need to set the program anyway
+    jassert(parameters.programIndex < this->getNumPrograms());
+    this->setCurrentProgram(parameters.programIndex);
+}
+
 void SoundFontSynth::noteOn(int midiChannel, int midiNoteNumber, float velocity)
 {
     int i;
@@ -837,3 +880,55 @@ void SoundFontSynth::changeProgramName(int index, const String &newName)
 {
     jassertfalse;
 }
+
+//===----------------------------------------------------------------------===//
+// Synth parameters
+//===----------------------------------------------------------------------===//
+
+SoundFontSynth::Parameters SoundFontSynth::Parameters::withSoundFontFile(const String &newFilePath) const noexcept
+{
+    Parameters other(*this);
+    other.filePath = newFilePath;
+    return other;
+}
+
+SoundFontSynth::Parameters SoundFontSynth::Parameters::withProgramIndex(int newProgramIndex) const noexcept
+{
+    Parameters other(*this);
+    other.programIndex = newProgramIndex;
+    return other;
+}
+
+SerializedData SoundFontSynth::Parameters::serialize() const
+{
+    using namespace Serialization::Audio;
+
+    SerializedData data(SoundFont::soundFontConfig);
+    data.setProperty(SoundFont::filePath, this->filePath);
+    data.setProperty(SoundFont::programIndex, this->programIndex);
+
+    return data;
+}
+
+void SoundFontSynth::Parameters::deserialize(const SerializedData &data)
+{
+    this->reset();
+    using namespace Serialization::Audio;
+
+    const auto root = data.hasType(SoundFont::soundFontConfig) ?
+        data : data.getChildWithName(SoundFont::soundFontConfig);
+
+    if (!root.isValid())
+    {
+        return;
+    }
+
+    this->filePath = root.getProperty(SoundFont::filePath);
+    this->programIndex = root.getProperty(SoundFont::programIndex);
+}
+
+void SoundFontSynth::Parameters::reset()
+{
+    this->filePath.clear();
+    this->programIndex = 0;
+}
diff --git a/Source/Core/Audio/BuiltIn/SoundFont/SoundFontSynth.h b/Source/Core/Audio/BuiltIn/SoundFont/SoundFontSynth.h
index 9cd7ed7ae..e54274705 100644
--- a/Source/Core/Audio/BuiltIn/SoundFont/SoundFontSynth.h
+++ b/Source/Core/Audio/BuiltIn/SoundFont/SoundFontSynth.h
@@ -30,6 +30,24 @@ class SoundFontSynth final : public Synthesiser
     void noteOn(int midiChannel, int midiNoteNumber, float velocity) override;
     void noteOff(int midiChannel, int midiNoteNumber, float velocity, bool allowTailOff) override;
 
+    //===------------------------------------------------------------------===//
+    // Synth parameters
+    //===------------------------------------------------------------------===//
+
+    struct Parameters final : Serializable
+    {
+        String filePath;
+        int programIndex = 0;
+
+        Parameters withSoundFontFile(const String &newFilePath) const noexcept;
+        Parameters withProgramIndex(int newProgramIndex) const noexcept;
+
+        SerializedData serialize() const override;
+        void deserialize(const SerializedData &data) override;
+        void reset() override;
+    };
+
+    void initSynth(const Parameters &parameters);
 
     //===------------------------------------------------------------------===//
     // Presets
@@ -43,6 +61,8 @@ class SoundFontSynth final : public Synthesiser
 
 private:
 
+    static constexpr auto numVoices = 16;
+
     int noteVelocities[128];
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SoundFontSynth)
diff --git a/Source/Core/Audio/BuiltIn/SoundFontSynthAudioPlugin.cpp b/Source/Core/Audio/BuiltIn/SoundFontSynthAudioPlugin.cpp
new file mode 100644
index 000000000..da64528e7
--- /dev/null
+++ b/Source/Core/Audio/BuiltIn/SoundFontSynthAudioPlugin.cpp
@@ -0,0 +1,339 @@
+/*
+    This file is part of Helio Workstation.
+
+    Helio is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Helio is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Helio. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "Common.h"
+#include "SoundFontSynthAudioPlugin.h"
+#include "BuiltInSynthsPluginFormat.h"
+#include "DocumentHelpers.h"
+#include "ModeIndicatorComponent.h"
+#include "PlayButton.h"
+#include "IconButton.h"
+#include "SerializationKeys.h"
+#include "ColourIDs.h"
+
+const String SoundFontSynthAudioPlugin::instrumentId = "<soundfont-player>";
+const String SoundFontSynthAudioPlugin::instrumentName = "SoundFont Player";
+
+//===----------------------------------------------------------------------===//
+// A simple UI allowing to pick a file and switch between presets, if any
+//===----------------------------------------------------------------------===//
+
+class SoundFontSynthEditor final : public AudioProcessorEditor
+{
+public:
+
+    explicit SoundFontSynthEditor(WeakReference<SoundFontSynthAudioPlugin> soundFontPlugin) :
+        AudioProcessorEditor(soundFontPlugin),
+        audioPlugin(soundFontPlugin)
+    {
+        this->filePath = make<TextEditor>();
+        this->filePath->setReadOnly(true);
+        this->filePath->setFont(Globals::UI::Fonts::M);
+        this->filePath->setJustification(Justification::centredLeft);
+        this->addAndMakeVisible(this->filePath.get());
+
+        this->browseButton = make<IconButton>(Icons::browse, CommandIDs::Browse);
+        this->browseButton->setMouseCursor(MouseCursor::PointingHandCursor);
+        this->addAndMakeVisible(this->browseButton.get());
+
+        this->leftArrow = make<IconButton>(Icons::stretchLeft, CommandIDs::SelectPreviousPreset);
+        this->addAndMakeVisible(this->leftArrow.get());
+
+        this->rightArrow = make<IconButton>(Icons::stretchRight, CommandIDs::SelectNextPreset);
+        this->addAndMakeVisible(this->rightArrow.get());
+
+        this->programIndexIndicator = make<ModeIndicatorComponent>();
+        this->addAndMakeVisible(this->programIndexIndicator.get());
+
+        this->programNameLabel = make<Label>();
+        this->programNameLabel->setFont(Globals::UI::Fonts::M);
+        this->programNameLabel->setJustificationType(Justification::centred);
+        this->addAndMakeVisible(this->programNameLabel.get());
+
+        this->syncDataWithAudioPlugin();
+        this->setSize(640, 120);
+    }
+
+    void syncDataWithAudioPlugin()
+    {
+        const auto numPrograms = this->audioPlugin->getNumPrograms();
+        const auto currentProgram = this->audioPlugin->getCurrentProgram();
+        const bool hasPresetSelection = numPrograms > 1;
+
+        this->leftArrow->setVisible(hasPresetSelection);
+        this->leftArrow->setEnabled(currentProgram > 0);
+
+        this->rightArrow->setVisible(hasPresetSelection);
+        this->rightArrow->setEnabled(currentProgram < numPrograms - 1);
+
+        this->programIndexIndicator->setVisible(hasPresetSelection);
+        this->programIndexIndicator->setNumModes(numPrograms);
+        this->programIndexIndicator->setCurrentMode(currentProgram);
+
+        this->programNameLabel->setText(this->audioPlugin->getCurrentProgramName(), dontSendNotification);
+
+        const auto synthParams = this->audioPlugin->getSynthParameters();
+        if (synthParams.filePath.isNotEmpty())
+        {
+            this->filePath->setAlpha(1.f);
+            this->filePath->setInterceptsMouseClicks(true, true);
+            this->filePath->setText(synthParams.filePath);
+        }
+        else
+        {
+            this->filePath->setAlpha(0.75f);
+            this->filePath->setInterceptsMouseClicks(false, false);
+            this->filePath->setText({}); // todo placeholder?
+        }
+    }
+
+    void resized() override
+    {
+        const auto getRowArea = [this](float proportionOfHeight, int height, int padding = 30)
+        {
+            const auto area = this->getLocalBounds().reduced(padding);
+            const auto y = area.proportionOfHeight(proportionOfHeight);
+            return area.withHeight(height).translated(0, y - height / 2);
+        };
+
+        constexpr auto rowHeight = 32;
+        constexpr auto iconWidth = 30;
+        constexpr auto iconMarginX = 8;
+        constexpr auto paddingX = 6;
+
+        auto browseFileArea = getRowArea(0.15f, rowHeight);
+        this->browseButton->setBounds(browseFileArea.removeFromRight(iconWidth).reduced(paddingX, 2).translated(iconMarginX, 0));
+        this->filePath->setBounds(browseFileArea.reduced(paddingX, 0));
+
+        auto selectProgramArea = getRowArea(0.7f, rowHeight).reduced(iconWidth + paddingX, 0);
+        this->leftArrow->setBounds(selectProgramArea.removeFromLeft(iconWidth).reduced(paddingX, 2).translated(-iconMarginX, 0));
+        this->rightArrow->setBounds(selectProgramArea.removeFromRight(iconWidth).reduced(paddingX, 2).translated(iconMarginX, 0));
+        this->programNameLabel->setBounds(selectProgramArea.reduced(paddingX, 0));
+        this->programIndexIndicator->setBounds(selectProgramArea.translated(0, rowHeight));
+    }
+
+    void paint(Graphics &g) override
+    {
+        g.setColour(this->fillColour);
+        g.fillRect(this->getLocalBounds());
+    }
+
+    void handleCommandMessage(int commandId)
+    {
+        const auto synthParams = this->audioPlugin->getSynthParameters();
+
+        if (commandId == CommandIDs::Browse)
+        {
+            this->fileChooser = make<FileChooser>(TRANS(I18n::Dialog::documentLoad),
+                this->lastUsedDirectory, ("*.sf2;*.sbk"), true);
+
+            DocumentHelpers::showFileChooser(this->fileChooser,
+                Globals::UI::FileChooser::forFileToOpen,
+                [this](URL &url)
+                {
+                    if (!url.isLocalFile() || !url.getLocalFile().exists())
+                    {
+                        return; // or reset?
+                    }
+
+                    const auto file = url.getLocalFile();
+                    this->lastUsedDirectory = file.getParentDirectory().getFullPathName();
+
+                    const auto newParams = this->audioPlugin->getSynthParameters()
+                        .withSoundFontFile(file.getFullPathName());
+
+                    this->audioPlugin->applySynthParameters(newParams);
+                    this->syncDataWithAudioPlugin();
+                });
+        }
+        else if (commandId == CommandIDs::SelectNextPreset)
+        {
+            const auto nextPreset = jmin(synthParams.programIndex + 1, this->audioPlugin->getNumPrograms() - 1);
+            const auto newParams = this->audioPlugin->getSynthParameters().withProgramIndex(nextPreset);
+            this->audioPlugin->applySynthParameters(newParams);
+            this->syncDataWithAudioPlugin();
+        }
+        else if (commandId == CommandIDs::SelectPreviousPreset)
+        {
+            const auto prevPreset = jmax(synthParams.programIndex - 1, 0);
+            const auto newParams = this->audioPlugin->getSynthParameters().withProgramIndex(prevPreset);
+            this->audioPlugin->applySynthParameters(newParams);
+            this->syncDataWithAudioPlugin();
+        }
+    }
+
+private:
+
+    WeakReference<SoundFontSynthAudioPlugin> audioPlugin;
+
+    // soundfont file picker
+    UniquePointer<TextEditor> filePath;
+    UniquePointer<IconButton> browseButton;
+
+    UniquePointer<FileChooser> fileChooser;
+    String lastUsedDirectory = File::getCurrentWorkingDirectory().getFullPathName();
+
+    // preset selection
+    UniquePointer<IconButton> leftArrow;
+    UniquePointer<IconButton> rightArrow;
+    UniquePointer<Label> programNameLabel;
+    UniquePointer<ModeIndicatorComponent> programIndexIndicator;
+
+    const Colour fillColour = findDefaultColour(ColourIDs::BackgroundA::fill);
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SoundFontSynthEditor)
+};
+
+//===----------------------------------------------------------------------===//
+// SoundFontSynthAudioPlugin
+//===----------------------------------------------------------------------===//
+
+SoundFontSynthAudioPlugin::SoundFontSynthAudioPlugin()
+{
+    this->setPlayConfigDetails(0, 2, this->getSampleRate(), this->getBlockSize());
+}
+
+void SoundFontSynthAudioPlugin::fillInPluginDescription(PluginDescription &description) const
+{
+    description.name = this->getName();
+    description.descriptiveName = description.name;
+    description.uniqueId = description.name.hashCode();
+    description.category = "Synth";
+    description.pluginFormatName = BuiltInSynthsPluginFormat::formatName;
+    description.fileOrIdentifier = BuiltInSynthsPluginFormat::formatIdentifier;
+    description.manufacturerName = "Helio Workstation";
+    description.version = "1.0";
+    description.isInstrument = true;
+    description.numInputChannels = this->getTotalNumInputChannels();
+    description.numOutputChannels = this->getTotalNumOutputChannels();
+}
+
+const String SoundFontSynthAudioPlugin::getName() const
+{
+    return SoundFontSynthAudioPlugin::instrumentName;
+}
+
+void SoundFontSynthAudioPlugin::processBlock(AudioSampleBuffer &buffer, MidiBuffer &midiMessages)
+{
+    buffer.clear(0, buffer.getNumSamples());
+    this->synth.renderNextBlock(buffer, midiMessages, 0, buffer.getNumSamples());
+}
+
+void SoundFontSynthAudioPlugin::prepareToPlay(double sampleRate, int estimatedSamplesPerBlock)
+{
+    this->synth.setCurrentPlaybackSampleRate(sampleRate);
+}
+
+void SoundFontSynthAudioPlugin::reset()
+{
+    this->synth.allNotesOff(0, true);
+}
+
+void SoundFontSynthAudioPlugin::releaseResources() {}
+double SoundFontSynthAudioPlugin::getTailLengthSeconds() const { return 3.0; } // hopefully enough?
+
+bool SoundFontSynthAudioPlugin::acceptsMidi() const { return true; }
+bool SoundFontSynthAudioPlugin::producesMidi() const { return false; }
+
+bool SoundFontSynthAudioPlugin::hasEditor() const { return true; }
+AudioProcessorEditor *SoundFontSynthAudioPlugin::createEditor()
+{
+    return new SoundFontSynthEditor(this);
+}
+
+//===----------------------------------------------------------------------===//
+// Presets
+//===----------------------------------------------------------------------===//
+
+int SoundFontSynthAudioPlugin::getNumPrograms()
+{
+    return this->synth.getNumPrograms();
+}
+
+int SoundFontSynthAudioPlugin::getCurrentProgram()
+{
+    return this->synth.getCurrentProgram();
+}
+
+void SoundFontSynthAudioPlugin::setCurrentProgram(int index) 
+{
+    this->synth.setCurrentProgram(index);
+}
+
+const String SoundFontSynthAudioPlugin::getProgramName(int index)
+{
+    return this->synth.getProgramName(index);
+}
+
+const String SoundFontSynthAudioPlugin::getCurrentProgramName()
+{
+    return this->getProgramName(this->getCurrentProgram());
+}
+
+void SoundFontSynthAudioPlugin::changeProgramName(int index, const String &newName)
+{
+    return this->synth.changeProgramName(index, newName);
+}
+
+//===----------------------------------------------------------------------===//
+// Parameters
+//===----------------------------------------------------------------------===//
+
+void SoundFontSynthAudioPlugin::getStateInformation(MemoryBlock &destData)
+{
+    const auto state = this->synthParameters.serialize();
+
+    String stateAsString;
+    if (this->serializer.saveToString(stateAsString, state).ok())
+    {
+        MemoryOutputStream outStream(destData, false);
+        outStream.writeString(stateAsString);
+    }
+}
+
+void SoundFontSynthAudioPlugin::setStateInformation(const void *data, int sizeInBytes)
+{
+    MemoryInputStream inStream(data, sizeInBytes, false);
+    const auto stateAsString = inStream.readString();
+    const auto state = this->serializer.loadFromString(stateAsString);
+
+    SoundFontSynth::Parameters newParameters;
+    newParameters.deserialize(state);
+
+    this->applySynthParameters(newParameters);
+}
+
+void SoundFontSynthAudioPlugin::applySynthParameters(const SoundFontSynth::Parameters &newParameters)
+{
+    if (this->synthParameters.filePath != newParameters.filePath)
+    {
+        this->synth.initSynth(newParameters);
+    }
+    else if (this->synthParameters.programIndex != newParameters.programIndex)
+    {
+        // just the program # changed
+        jassert(newParameters.programIndex < this->getNumPrograms());
+        this->setCurrentProgram(newParameters.programIndex);
+    }
+
+    this->synthParameters = newParameters;
+}
+
+const SoundFontSynth::Parameters &SoundFontSynthAudioPlugin::getSynthParameters() const noexcept
+{
+    return this->synthParameters;
+}
diff --git a/Source/Core/Audio/BuiltIn/SoundFontSynthAudioPlugin.h b/Source/Core/Audio/BuiltIn/SoundFontSynthAudioPlugin.h
new file mode 100644
index 000000000..b913d45f1
--- /dev/null
+++ b/Source/Core/Audio/BuiltIn/SoundFontSynthAudioPlugin.h
@@ -0,0 +1,90 @@
+/*
+    This file is part of Helio Workstation.
+
+    Helio is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Helio is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Helio. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "SoundFontSynth.h"
+#include "JsonSerializer.h"
+
+class SoundFontSynthAudioPlugin final : public AudioPluginInstance
+{
+public:
+
+    SoundFontSynthAudioPlugin();
+
+    static const String instrumentId;
+
+    //===------------------------------------------------------------------===//
+    // AudioPluginInstance
+    //===------------------------------------------------------------------===//
+
+    const String getName() const override;
+    void fillInPluginDescription(PluginDescription &description) const override;
+
+    void processBlock(AudioSampleBuffer &buffer, MidiBuffer &midiMessages) override;
+    void prepareToPlay(double sampleRate, int estimatedSamplesPerBlock) override;
+    void reset() override;
+
+    //===------------------------------------------------------------------===//
+    // AudioProcessor
+    //===------------------------------------------------------------------===//
+
+    void releaseResources() override;
+    double getTailLengthSeconds() const override;
+    bool acceptsMidi() const override;
+    bool producesMidi() const override;
+
+    //===------------------------------------------------------------------===//
+    // Editor
+    //===------------------------------------------------------------------===//
+
+    AudioProcessorEditor *createEditor() override;
+    bool hasEditor() const override;
+
+    //===------------------------------------------------------------------===//
+    // Programs
+    //===------------------------------------------------------------------===//
+
+    int getNumPrograms() override;
+    int getCurrentProgram() override;
+    void setCurrentProgram(int index) override;
+    const String getProgramName(int index) override;
+    const String getCurrentProgramName();
+    void changeProgramName(int index, const String &newName) override;
+
+    //===------------------------------------------------------------------===//
+    // State
+    //===------------------------------------------------------------------===//
+
+    void getStateInformation(MemoryBlock &destData) override;
+    void setStateInformation(const void *data, int sizeInBytes) override;
+
+    void applySynthParameters(const SoundFontSynth::Parameters &params);
+    const SoundFontSynth::Parameters &getSynthParameters() const noexcept;
+
+private:
+
+    static const String instrumentName;
+
+    SoundFontSynth synth;
+    SoundFontSynth::Parameters synthParameters;
+
+    JsonSerializer serializer;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SoundFontSynthAudioPlugin)
+    JUCE_DECLARE_WEAK_REFERENCEABLE(SoundFontSynthAudioPlugin)
+};
diff --git a/Source/Core/Audio/Instruments/PluginScanner.cpp b/Source/Core/Audio/Instruments/PluginScanner.cpp
index 0a296b3e2..062e9d8eb 100644
--- a/Source/Core/Audio/Instruments/PluginScanner.cpp
+++ b/Source/Core/Audio/Instruments/PluginScanner.cpp
@@ -25,6 +25,7 @@
 #include "SerializationKeys.h"
 #include "DefaultSynthAudioPlugin.h"
 #include "MetronomeSynthAudioPlugin.h"
+#include "SoundFontSynthAudioPlugin.h"
 #include "SerializablePluginDescription.h"
 
 #if PLATFORM_DESKTOP
@@ -116,11 +117,12 @@ void PluginScanner::runInitialScan()
     // clear the existing list and resume search thread
 
     this->filesToScan.clearQuick();
-    this->searchPath = this->getTypicalFolders();
+    this->searchPath = this->getCommonFolders();
 
     // built-in synths to be added first:
     this->filesToScan.addIfNotAlreadyThere(DefaultSynthAudioPlugin::instrumentId);
     this->filesToScan.addIfNotAlreadyThere(MetronomeSynthAudioPlugin::instrumentId);
+    this->filesToScan.addIfNotAlreadyThere(SoundFontSynthAudioPlugin::instrumentId);
 
     // known synths to be re-checked first as well:
     for (const auto &it : this->getPlugins())
@@ -318,7 +320,7 @@ void PluginScanner::run()
     }
 }
 
-FileSearchPath PluginScanner::getTypicalFolders()
+FileSearchPath PluginScanner::getCommonFolders()
 {
     FileSearchPath folders;
 
diff --git a/Source/Core/Audio/Instruments/PluginScanner.h b/Source/Core/Audio/Instruments/PluginScanner.h
index ad441fdc1..72b54e15b 100644
--- a/Source/Core/Audio/Instruments/PluginScanner.h
+++ b/Source/Core/Audio/Instruments/PluginScanner.h
@@ -74,7 +74,7 @@ class PluginScanner final :
     FileSearchPath searchPath;
     StringArray filesToScan;
 
-    FileSearchPath getTypicalFolders();
+    FileSearchPath getCommonFolders();
     void scanPossibleSubfolders(const StringArray &possibleSubfolders,
         const File &currentSystemFolder, FileSearchPath &foldersOut);
 };
diff --git a/Source/Core/Serialization/SerializationKeys.h b/Source/Core/Serialization/SerializationKeys.h
index 923cad57c..494e85860 100644
--- a/Source/Core/Serialization/SerializationKeys.h
+++ b/Source/Core/Serialization/SerializationKeys.h
@@ -201,7 +201,14 @@ namespace Serialization
             static const Identifier customSample = "sample";
             static const Identifier syllableName = "name";
             static const Identifier filePath = "filePath";
-        } // namespace CustomMetronome
+        } // namespace Metronome
+
+        namespace SoundFont
+        {
+            static const Identifier soundFontConfig = "soundFontPlayer";
+            static const Identifier filePath = "filePath";
+            static const Identifier programIndex = "programIndex";
+        } // namespace SoundFont
     } // namespace Audio
 
     namespace Config
diff --git a/Source/UI/Common/CommandIDs.cpp b/Source/UI/Common/CommandIDs.cpp
index 0e0c08e4a..064130441 100644
--- a/Source/UI/Common/CommandIDs.cpp
+++ b/Source/UI/Common/CommandIDs.cpp
@@ -192,6 +192,8 @@ CommandIDs::Id CommandIDs::getIdForName(const String &command)
         CASE_FOR(KeyMapCopyToClipboard)
         CASE_FOR(KeyMapPasteFromClipboard)
         CASE_FOR(SavePreset)
+        CASE_FOR(SelectNextPreset)
+        CASE_FOR(SelectPreviousPreset)
         CASE_FOR(SelectPreset)
         CASE_FOR(OpenMetronomeSample)
         CASE_FOR(ResetMetronomeSample)
diff --git a/Source/UI/Common/CommandIDs.h b/Source/UI/Common/CommandIDs.h
index 80bb2ad78..de99e1d5c 100644
--- a/Source/UI/Common/CommandIDs.h
+++ b/Source/UI/Common/CommandIDs.h
@@ -222,12 +222,14 @@ namespace CommandIDs
         KeyMapPasteFromClipboard        = 0x4215,
 
         SavePreset                      = 0x4300,
-        SelectPreset                    = 0x4301, // more ids reserved for sub-items
+        SelectNextPreset                = 0x4301,
+        SelectPreviousPreset            = 0x4302,
+        SelectPreset                    = 0x4303, // more ids reserved for sub-items
 
         OpenMetronomeSample             = 0x4500, // more ids reserved for sub-items
         ResetMetronomeSample            = 0x4550, // more ids reserved for sub-items
 
-        YourNextCommandId = 0x4600
+        YourNextCommandId               = 0x4600
     };
 
     CommandIDs::Id getIdForName(const String &command);
diff --git a/Source/UI/Common/ModeIndicatorComponent.cpp b/Source/UI/Common/ModeIndicatorComponent.cpp
index 5dab423de..d50675b46 100644
--- a/Source/UI/Common/ModeIndicatorComponent.cpp
+++ b/Source/UI/Common/ModeIndicatorComponent.cpp
@@ -72,15 +72,24 @@ class ModeIndicatorBar final : public Component, private Timer
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(ModeIndicatorBar)
 };
 
-ModeIndicatorComponent::ModeIndicatorComponent(int numModes) : activeMode(0)
+ModeIndicatorComponent::ModeIndicatorComponent(int numModes)
 {
     this->setInterceptsMouseClicks(false, false);
     this->setPaintingIsUnclipped(true);
 
     this->setComponentID(ComponentIDs::modeIndicatorComponentId);
 
-    // The normal default state is invisible
-    this->setAlpha(0.f);
+    this->setNumModes(numModes);
+}
+
+ModeIndicatorComponent::~ModeIndicatorComponent()
+{
+    this->bars.clear(true);
+}
+
+void ModeIndicatorComponent::setNumModes(int numModes)
+{
+    this->bars.clear(true);
 
     for (int i = 0; i < numModes; ++i)
     {
@@ -88,11 +97,23 @@ ModeIndicatorComponent::ModeIndicatorComponent(int numModes) : activeMode(0)
         this->bars.getLast()->setHighlighted(i == 0);
         this->addAndMakeVisible(this->bars.getLast());
     }
+
+    // also place the bars correctly, if needed
+    if (this->getParentComponent() != nullptr)
+    {
+        this->resized();
+    }
 }
 
-ModeIndicatorComponent::~ModeIndicatorComponent()
+ModeIndicatorComponent::Mode ModeIndicatorComponent::setCurrentMode(Mode mode)
 {
-    this->bars.clear(true);
+    if (!this->bars.isEmpty())
+    {
+        this->activeMode = mode % this->bars.size();
+        this->updateBarsHighlighting();
+    }
+
+    return this->activeMode;
 }
 
 ModeIndicatorComponent::Mode ModeIndicatorComponent::scrollToNextMode()
@@ -100,11 +121,7 @@ ModeIndicatorComponent::Mode ModeIndicatorComponent::scrollToNextMode()
     if (!this->bars.isEmpty())
     {
         this->activeMode = (this->activeMode + 1) % this->bars.size();
-        for (int i = 0; i < this->bars.size(); ++i)
-        {
-            this->bars[i]->setHighlighted(i == this->activeMode);
-        }
-
+        this->updateBarsHighlighting();
     }
 
     return this->activeMode;
@@ -112,17 +129,27 @@ ModeIndicatorComponent::Mode ModeIndicatorComponent::scrollToNextMode()
 
 void ModeIndicatorComponent::resized()
 {
-    const int spacing = 4;
+    constexpr auto barSize = 6;
+    constexpr auto barSpacing = 4;
+
     const int h = this->getHeight();
     const int w = this->getWidth();
     const int length = this->bars.size();
-    const int cw = (h + spacing) * length;
+    const int cw = (barSize + barSpacing) * length - barSpacing;
     const int cx = w / 2 - cw / 2;
 
     for (int i = 0; i < length; ++i)
     {
-        const int x = cx + (h + spacing) * i;
-        this->bars[i]->setBounds(x, 0, h, h);
+        const int x = cx + (barSize + barSpacing) * i;
+        this->bars[i]->setBounds(x, h / 2 - barSize / 2, barSize, barSize);
+    }
+}
+
+void ModeIndicatorComponent::updateBarsHighlighting()
+{
+    for (int i = 0; i < this->bars.size(); ++i)
+    {
+        this->bars.getUnchecked(i)->setHighlighted(i == this->activeMode);
     }
 }
 
@@ -149,10 +176,9 @@ ModeIndicatorTrigger::ModeIndicatorTrigger()
     this->setPaintingIsUnclipped(true);
 }
 
-void ModeIndicatorTrigger::mouseUp(const MouseEvent& event)
+void ModeIndicatorTrigger::mouseUp(const MouseEvent &event)
 {
-    if (ModeIndicatorOwnerComponent *owner =
-        dynamic_cast<ModeIndicatorOwnerComponent *>(this->getParentComponent()))
+    if (auto *owner = dynamic_cast<ModeIndicatorOwnerComponent *>(this->getParentComponent()))
     {
         owner->handleChangeMode();
     }
@@ -160,8 +186,7 @@ void ModeIndicatorTrigger::mouseUp(const MouseEvent& event)
 
 void ModeIndicatorTrigger::mouseEnter(const MouseEvent &event)
 {
-    if (ModeIndicatorOwnerComponent *owner =
-        dynamic_cast<ModeIndicatorOwnerComponent *>(this->getParentComponent()))
+    if (auto *owner = dynamic_cast<ModeIndicatorOwnerComponent *>(this->getParentComponent()))
     {
         owner->showModeIndicator();
     }
@@ -169,8 +194,7 @@ void ModeIndicatorTrigger::mouseEnter(const MouseEvent &event)
 
 void ModeIndicatorTrigger::mouseExit(const MouseEvent &event)
 {
-    if (ModeIndicatorOwnerComponent *owner =
-        dynamic_cast<ModeIndicatorOwnerComponent *>(this->getParentComponent()))
+    if (auto *owner = dynamic_cast<ModeIndicatorOwnerComponent *>(this->getParentComponent()))
     {
         owner->hideModeIndicator();
     }
diff --git a/Source/UI/Common/ModeIndicatorComponent.h b/Source/UI/Common/ModeIndicatorComponent.h
index 333ffe2d6..949b82d36 100644
--- a/Source/UI/Common/ModeIndicatorComponent.h
+++ b/Source/UI/Common/ModeIndicatorComponent.h
@@ -25,20 +25,25 @@ class ModeIndicatorComponent final : public Component
 {
 public:
     
-    explicit ModeIndicatorComponent(int numModes);
+    explicit ModeIndicatorComponent(int numModes = 0);
     ~ModeIndicatorComponent();
 
-    typedef int Mode;
+    void setNumModes(int numModes);
+
+    using Mode = int;
     Mode scrollToNextMode();
+    Mode setCurrentMode(Mode mode);
 
     void resized() override;
 
 private:
 
-    Mode activeMode;
+    Mode activeMode = 0;
     OwnedArray<ModeIndicatorBar> bars;
     ComponentFader fader;
 
+    void updateBarsHighlighting();
+
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ModeIndicatorComponent)
 };
 
@@ -56,7 +61,7 @@ class ModeIndicatorOwnerComponent : public Component
 
 };
 
-class ModeIndicatorTrigger : public Component
+class ModeIndicatorTrigger final : public Component
 {
 public:
 
diff --git a/Source/UI/Sequencer/Sidebars/SequencerSidebarLeft.cpp b/Source/UI/Sequencer/Sidebars/SequencerSidebarLeft.cpp
index c7afa464f..f8a5d9757 100644
--- a/Source/UI/Sequencer/Sidebars/SequencerSidebarLeft.cpp
+++ b/Source/UI/Sequencer/Sidebars/SequencerSidebarLeft.cpp
@@ -57,6 +57,7 @@ SequencerSidebarLeft::SequencerSidebarLeft()
 
     this->modeIndicator = make<ModeIndicatorComponent>(2);
     this->addAndMakeVisible(this->modeIndicator.get());
+    this->modeIndicator->setAlpha(0.f);
 
     this->switchPatternModeButton = make<MenuItemComponent>(this, nullptr,
         MenuItem::item(Icons::patterns, CommandIDs::SwitchBetweenRolls)->
@@ -149,7 +150,7 @@ void SequencerSidebarLeft::resized()
         this->getHeight() - audioMonitorHeight,
         this->getWidth(), audioMonitorHeight);
 
-    constexpr auto modeIndicatorSize = 5;
+    constexpr auto modeIndicatorSize = 6;
     this->modeIndicator->setBounds(0,
         this->getHeight() - modeIndicatorSize * 2,
         this->getWidth(), modeIndicatorSize);