cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/juce/juce-plugin.cpp

@@ -0,0 +1,809 @@
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2016 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This Architecture section 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.
+ 
+ This program 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 this program; If not, see <http://www.gnu.org/licenses/>.
+ 
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+ 
+ ************************************************************************
+ ************************************************************************/
+
+#include <algorithm>
+#include <assert.h>
+
+#if JUCE_WINDOWS
+#define JUCE_CORE_INCLUDE_NATIVE_HEADERS 1
+#endif
+
+#include "JuceLibraryCode/JuceHeader.h"
+
+#include "faust/gui/MapUI.h"
+#include "faust/dsp/dsp-adapter.h"
+#include "faust/gui/MidiUI.h"
+#include "faust/dsp/poly-dsp.h"
+#ifndef PLUGIN_MAGIC
+#include "faust/gui/JuceGUI.h"
+#endif
+#include "faust/gui/JuceParameterUI.h"
+#include "faust/gui/JuceStateUI.h"
+
+// Always included otherwise -i mode sometimes fails...
+#include "faust/gui/DecoratorUI.h"
+
+#if defined(SOUNDFILE)
+#include "faust/gui/SoundUI.h"
+#endif
+
+#if defined(OSCCTRL)
+#include "faust/gui/JuceOSCUI.h"
+#endif
+
+#if defined(MIDICTRL)
+#include "faust/midi/juce-midi.h"
+#include "faust/dsp/timed-dsp.h"
+#endif
+
+#if defined(POLY2)
+#include "faust/dsp/dsp-combiner.h"
+#include "effect.h"
+#endif 
+
+// we require macro declarations
+#define FAUST_UIMACROS
+
+// but we will ignore most of them
+#define FAUST_ADDBUTTON(l,f)
+#define FAUST_ADDCHECKBOX(l,f)
+#define FAUST_ADDSOUNDFILE(l,s)
+#define FAUST_ADDVERTICALSLIDER(l,f,i,a,b,s)
+#define FAUST_ADDHORIZONTALSLIDER(l,f,i,a,b,s)
+#define FAUST_ADDNUMENTRY(l,f,i,a,b,s)
+#define FAUST_ADDVERTICALBARGRAPH(l,f,a,b)
+#define FAUST_ADDHORIZONTALBARGRAPH(l,f,a,b)
+
+<<includeIntrinsic>>
+
+<<includeclass>>
+
+#if defined(JUCE_POLY)
+
+struct FaustSound : public juce::SynthesiserSound {
+    
+    bool appliesToNote (int /*midiNoteNumber*/) override        { return true; }
+    bool appliesToChannel (int /*midiChannel*/) override        { return true; }
+};
+
+// An hybrid JUCE and Faust voice
+
+class FaustVoice : public juce::SynthesiserVoice, public dsp_voice {
+    
+    private:
+        
+        std::unique_ptr<juce::AudioBuffer<FAUSTFLOAT>> fBuffer;
+        
+    public:
+        
+        FaustVoice(dsp* dsp):dsp_voice(dsp)
+        {
+            // Allocate buffer for mixing
+            fBuffer = std::make_unique<juce::AudioBuffer<FAUSTFLOAT>>(dsp->getNumOutputs(), 8192);
+            fDSP->init(juce::SynthesiserVoice::getSampleRate());
+        }
+        
+        bool canPlaySound (juce::SynthesiserSound* sound) override
+        {
+            return dynamic_cast<FaustSound*> (sound) != nullptr;
+        }
+        
+        void startNote (int midiNoteNumber,
+                        float velocity,
+                        juce::SynthesiserSound* s,
+                        int currentPitchWheelPosition) override
+        {
+            // Note is triggered
+            keyOn(midiNoteNumber, velocity);
+        }
+        
+        void stopNote (float velocity, bool allowTailOff) override
+        {
+            keyOff(!allowTailOff);
+        }
+        
+        void pitchWheelMoved (int newPitchWheelValue) override
+        {
+            // not implemented for now
+        }
+        
+        void controllerMoved (int controllerNumber, int newControllerValue) override
+        {
+            // not implemented for now
+        }
+        
+        void renderNextBlock (juce::AudioBuffer<FAUSTFLOAT>& outputBuffer,
+                              int startSample,
+                              int numSamples) override
+        {
+            // Only plays when the voice is active
+            if (isVoiceActive()) {
+                
+                // Play the voice
+                compute(numSamples, nullptr, (FAUSTFLOAT**)fBuffer->getArrayOfWritePointers());
+                
+                // Mix it in outputs
+                for (int i = 0; i < fDSP->getNumOutputs(); i++) {
+                    outputBuffer.addFrom(i, startSample, *fBuffer, i, 0, numSamples);
+                }
+            }
+        }
+    
+};
+
+// Decorates the JUCE Synthesiser and adds Faust polyphonic code for GUI handling
+
+class FaustSynthesiser : public juce::Synthesiser, public dsp_voice_group {
+    
+    private:
+        
+        juce::Synthesiser fSynth;
+    
+        static void panic(float val, void* arg)
+        {
+            static_cast<FaustSynthesiser*>(arg)->allNotesOff(0, false); // 0 stops all voices
+        }
+  
+    public:
+        
+        FaustSynthesiser():dsp_voice_group(panic, this, true, true)
+        {
+            setNoteStealingEnabled(true);
+        }
+        
+        virtual ~FaustSynthesiser()
+        {
+            // Voices will be deallocated by fSynth
+            dsp_voice_group::clearVoices();
+        }
+        
+        void addVoice(FaustVoice* voice)
+        {
+            fSynth.addVoice(voice);
+            dsp_voice_group::addVoice(voice);
+        }
+        
+        void addSound(juce::SynthesiserSound* sound)
+        {
+            fSynth.addSound(sound);
+        }
+        
+        void allNotesOff(int midiChannel, bool allowTailOff)
+        {
+            fSynth.allNotesOff(midiChannel, allowTailOff);
+        }
+        
+        void setCurrentPlaybackSampleRate (double newRate)
+        {
+            fSynth.setCurrentPlaybackSampleRate(newRate);
+        }
+        
+        void renderNextBlock (juce::AudioBuffer<float>& outputAudio,
+                              const juce::MidiBuffer& inputMidi,
+                              int startSample,
+                              int numSamples)
+        {
+            fSynth.renderNextBlock(outputAudio, inputMidi, startSample, numSamples);
+        }
+        
+        void renderNextBlock (juce::AudioBuffer<double>& outputAudio,
+                              const juce::MidiBuffer& inputMidi,
+                              int startSample,
+                              int numSamples)
+        {
+            fSynth.renderNextBlock(outputAudio, inputMidi, startSample, numSamples);
+        }
+    
+};
+
+#endif
+
+// Using the PluginGuiMagic project (https://foleysfinest.com/developer/pluginguimagic/)
+
+#if defined(PLUGIN_MAGIC)
+
+class FaustPlugInAudioProcessor : public foleys::MagicProcessor, private juce::Timer
+{
+    
+    public:
+        FaustPlugInAudioProcessor();
+        virtual ~FaustPlugInAudioProcessor() {}
+        
+        void prepareToPlay (double sampleRate, int samplesPerBlock) override;
+        
+        bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
+        
+        void processBlock (juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages) override
+        {
+            jassert (! isUsingDoublePrecision());
+            process (buffer, midiMessages);
+    #ifdef MAGIC_LEVEL_SOURCE
+            fOutputMeter->pushSamples(buffer);
+    #endif
+        }
+        
+        void processBlock (juce::AudioBuffer<double>& buffer, juce::MidiBuffer& midiMessages) override
+        {
+            jassert (isUsingDoublePrecision());
+            process (buffer, midiMessages);
+        }
+        
+        const juce::String getName() const override;
+        
+        bool acceptsMidi() const override;
+        bool producesMidi() const override;
+        double getTailLengthSeconds() const override;
+        
+        int getNumPrograms() override;
+        int getCurrentProgram() override;
+        void setCurrentProgram (int index) override;
+        const juce::String getProgramName (int index) override;
+        void changeProgramName (int index, const juce::String& newName) override;
+        
+        void releaseResources() override
+        {}
+        
+        void timerCallback() override;
+        
+        juce::AudioProcessor::BusesProperties getBusesProperties();
+        bool supportsDoublePrecisionProcessing() const override;
+      
+    #ifdef MAGIC_LEVEL_SOURCE
+        foleys::MagicLevelSource* fOutputMeter = nullptr;
+    #endif
+        juce::AudioProcessorValueTreeState treeState{ *this, nullptr };
+    
+    #ifdef JUCE_POLY
+        std::unique_ptr<FaustSynthesiser> fSynth;
+    #else
+    #if defined(MIDICTRL)
+        std::unique_ptr<juce_midi_handler> fMIDIHandler;
+        std::unique_ptr<MidiUI> fMIDIUI;
+    #endif
+        std::unique_ptr<dsp> fDSP;
+    #endif
+        
+    #if defined(OSCCTRL)
+        std::unique_ptr<JuceOSCUI> fOSCUI;
+    #endif
+        
+    #if defined(SOUNDFILE)
+        std::unique_ptr<SoundUI> fSoundUI;
+    #endif
+        
+        JuceStateUI fStateUI;
+        JuceParameterUI fParameterUI;
+        
+        std::atomic<bool> fFirstCall = true;
+        
+    private:
+        
+        template <typename FloatType>
+        void process (juce::AudioBuffer<FloatType>& buffer, juce::MidiBuffer& midiMessages);
+        
+        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FaustPlugInAudioProcessor)
+    
+};
+
+#else
+
+class FaustPlugInAudioProcessor : public juce::AudioProcessor, private juce::Timer
+{
+
+    public:
+        
+        FaustPlugInAudioProcessor();
+        virtual ~FaustPlugInAudioProcessor() {}
+        
+        void prepareToPlay (double sampleRate, int samplesPerBlock) override;
+    
+        bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
+        
+        void processBlock (juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages) override
+        {
+            jassert (! isUsingDoublePrecision());
+            process (buffer, midiMessages);
+        }
+        
+        void processBlock (juce::AudioBuffer<double>& buffer, juce::MidiBuffer& midiMessages) override
+        {
+            jassert (isUsingDoublePrecision());
+            process (buffer, midiMessages);
+        }
+    
+        juce::AudioProcessorEditor* createEditor() override;
+        bool hasEditor() const override;
+        
+        const juce::String getName() const override;
+        
+        bool acceptsMidi() const override;
+        bool producesMidi() const override;
+        double getTailLengthSeconds() const override;
+        
+        int getNumPrograms() override;
+        int getCurrentProgram() override;
+        void setCurrentProgram (int index) override;
+        const juce::String getProgramName (int index) override;
+        void changeProgramName (int index, const juce::String& newName) override;
+        
+        void getStateInformation (juce::MemoryBlock& destData) override;
+        void setStateInformation (const void* data, int sizeInBytes) override;
+    
+        void releaseResources() override
+        {}
+        
+        void timerCallback() override;
+    
+        juce::AudioProcessor::BusesProperties getBusesProperties();
+        bool supportsDoublePrecisionProcessing() const override;
+    
+    #ifdef JUCE_POLY
+        std::unique_ptr<FaustSynthesiser> fSynth;
+    #else
+    #if defined(MIDICTRL)
+        std::unique_ptr<juce_midi_handler> fMIDIHandler;
+        std::unique_ptr<MidiUI> fMIDIUI;
+    #endif
+        std::unique_ptr<dsp> fDSP;
+    #endif
+        
+    #if defined(OSCCTRL)
+        std::unique_ptr<JuceOSCUI> fOSCUI;
+    #endif
+    
+    #if defined(SOUNDFILE)
+        std::unique_ptr<SoundUI> fSoundUI;
+    #endif
+    
+        JuceStateUI fStateUI;
+        JuceParameterUI fParameterUI;
+    
+        std::atomic<bool> fFirstCall = true;
+    
+    private:
+    
+        template <typename FloatType>
+        void process (juce::AudioBuffer<FloatType>& buffer, juce::MidiBuffer& midiMessages);
+    
+        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FaustPlugInAudioProcessor)
+    
+};
+
+#endif
+
+class FaustPlugInAudioProcessorEditor : public juce::AudioProcessorEditor
+{
+    
+    public:
+        
+        FaustPlugInAudioProcessorEditor (FaustPlugInAudioProcessor&);
+        virtual ~FaustPlugInAudioProcessorEditor() {}
+        
+        void paint (juce::Graphics&) override;
+        void resized() override;
+        
+    private:
+        
+        // This reference is provided as a quick way for your editor to
+        // access the processor object that created it.
+        FaustPlugInAudioProcessor& processor;
+        
+        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FaustPlugInAudioProcessorEditor)
+#ifndef PLUGIN_MAGIC        
+        JuceGUI fJuceGUI;
+#endif    
+};
+
+#ifndef PLUGIN_MAGIC
+FaustPlugInAudioProcessor::FaustPlugInAudioProcessor()
+: juce::AudioProcessor (getBusesProperties()), fParameterUI(this)
+#else
+FaustPlugInAudioProcessor::FaustPlugInAudioProcessor()
+: foleys::MagicProcessor (getBusesProperties()), fParameterUI(this)	
+#endif
+{
+    bool midi_sync = false;
+    int nvoices = 0;
+    
+    mydsp* tmp_dsp = new mydsp();
+    MidiMeta::analyse(tmp_dsp, midi_sync, nvoices);
+    delete tmp_dsp;
+	
+#ifdef PLUGIN_MAGIC
+#ifdef MAGIC_LOAD_BINARY
+    // change magic_xml and magic_xmlSize to match the name of your included
+    // XML file from Plugin GUI Magic
+    magicState.setGuiValueTree(BinaryData::magic_xml, BinaryData::magic_xmlSize);
+#endif
+// put other GUI Magic sources here, similar to expression below.
+#ifdef MAGIC_LEVEL_SOURCE
+    fOutputMeter = magicState.createAndAddObject<foleys::MagicLevelSource>("output");
+#endif
+#endif
+   
+#ifdef JUCE_POLY
+    assert(nvoices > 0);
+    fSynth = std::make_unique<FaustSynthesiser>();
+    for (int i = 0; i < nvoices; i++) {
+        fSynth->addVoice(new FaustVoice(new mydsp()));
+    }
+    fSynth->init();
+    fSynth->addSound(new FaustSound());
+#else
+    
+    bool group = true;
+    
+#ifdef POLY2
+    assert(nvoices > 0);
+    std::cout << "Started with " << nvoices << " voices\n";
+    dsp* dsp = new mydsp_poly(new mydsp(), nvoices, true, group);
+    
+#if MIDICTRL
+    if (midi_sync) {
+        fDSP = std::make_unique<timed_dsp>(new dsp_sequencer(dsp, new effect()));
+    } else {
+        fDSP = std::make_unique<dsp_sequencer>(dsp, new effect());
+    }
+#else
+    fDSP = std::make_unique<dsp_sequencer>(dsp, new effects());
+#endif
+    
+#else
+    if (nvoices > 0) {
+        std::cout << "Started with " << nvoices << " voices\n";
+        dsp* dsp = new mydsp_poly(new mydsp(), nvoices, true, group);
+        
+#if MIDICTRL
+        if (midi_sync) {
+            fDSP = std::make_unique<timed_dsp>(dsp);
+        } else {
+            fDSP = std::make_unique<decorator_dsp>(dsp);
+        }
+#else
+        fDSP = std::make_unique<decorator_dsp>(dsp);
+#endif
+    } else {
+#if MIDICTRL
+        if (midi_sync) {
+            fDSP = std::make_unique<timed_dsp>(new mydsp());
+        } else {
+            fDSP = std::make_unique<mydsp>();
+        }
+#else
+        fDSP = std::make_unique<mydsp>();
+#endif
+    }
+    
+#endif
+    
+#if defined(MIDICTRL)
+    fMIDIHandler = std::make_unique<juce_midi_handler>();
+    fMIDIUI = std::make_unique<MidiUI>(fMIDIHandler.get());
+    fDSP->buildUserInterface(fMIDIUI.get());
+    if (!fMIDIUI->run()) {
+        std::cerr << "JUCE MIDI handler cannot be started..." << std::endl;
+    }
+#endif
+    
+#endif
+    
+#if defined(OSCCTRL)
+    fOSCUI = std::make_unique<JuceOSCUI>("127.0.0.1", 5510, 5511);
+#ifdef JUCE_POLY
+    fSynth->buildUserInterface(fOSCUI.get());
+#else
+    fDSP->buildUserInterface(fOSCUI.get());
+#endif
+    if (!fOSCUI->run()) {
+        std::cerr << "JUCE OSC handler cannot be started..." << std::endl;
+    }
+#endif
+    
+#if defined(SOUNDFILE)
+    // Use bundle path
+    auto file = juce::File::getSpecialLocation(juce::File::currentExecutableFile)
+        .getParentDirectory().getParentDirectory().getChildFile("Resources");
+    fSoundUI = std::make_unique<SoundUI>(file.getFullPathName().toStdString());
+    fDSP->buildUserInterface(fSoundUI.get());
+#endif
+    
+#ifdef JUCE_POLY
+    fSynth->buildUserInterface(&fStateUI);
+    fSynth->buildUserInterface(&fParameterUI);
+    // When no previous state was restored, init DSP controllers with their default values
+    if (!fStateUI.fRestored) {
+        fSynth->instanceResetUserInterface();
+    }
+#else
+    fDSP->buildUserInterface(&fStateUI);
+    fDSP->buildUserInterface(&fParameterUI);
+    // When no previous state was restored, init DSP controllers with their default values
+    if (!fStateUI.fRestored) {
+        fDSP->instanceResetUserInterface();
+    }
+#endif
+    
+    startTimerHz(25);
+}
+
+juce::AudioProcessor::BusesProperties FaustPlugInAudioProcessor::getBusesProperties()
+{
+    if (juce::PluginHostType::getPluginLoadedAs() == wrapperType_Standalone) {
+        if (FAUST_INPUTS == 0) {
+            return BusesProperties().withOutput("Output", juce::AudioChannelSet::discreteChannels(std::min<int>(2, FAUST_OUTPUTS)), true);
+        } else {
+            return BusesProperties()
+            .withInput("Input", juce::AudioChannelSet::discreteChannels(std::min<int>(2, FAUST_INPUTS)), true)
+            .withOutput("Output", juce::AudioChannelSet::discreteChannels(std::min<int>(2, FAUST_OUTPUTS)), true);
+        }
+    } else {
+        if (FAUST_INPUTS == 0) {
+            return BusesProperties().withOutput("Output", juce::AudioChannelSet::discreteChannels(FAUST_OUTPUTS), true);
+        } else {
+            return BusesProperties()
+            .withInput("Input", juce::AudioChannelSet::discreteChannels(FAUST_INPUTS), true)
+            .withOutput("Output", juce::AudioChannelSet::discreteChannels(FAUST_OUTPUTS), true);
+        }
+    }
+}
+
+void FaustPlugInAudioProcessor::timerCallback()
+{
+    GUI::updateAllGuis();
+}
+
+//==============================================================================
+const juce::String FaustPlugInAudioProcessor::getName() const
+{
+    return JucePlugin_Name;
+}
+
+bool FaustPlugInAudioProcessor::acceptsMidi() const
+{
+#if JucePlugin_WantsMidiInput
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool FaustPlugInAudioProcessor::producesMidi() const
+{
+#if JucePlugin_ProducesMidiOutput
+    return true;
+#else
+    return false;
+#endif
+}
+
+double FaustPlugInAudioProcessor::getTailLengthSeconds() const
+{
+    return 0.0;
+}
+
+int FaustPlugInAudioProcessor::getNumPrograms()
+{
+    return 1;   // NB: some hosts don't cope very well if you tell them there are 0 programs,
+    // so this should be at least 1, even if you're not really implementing programs.
+}
+
+int FaustPlugInAudioProcessor::getCurrentProgram()
+{
+    return 0;
+}
+
+void FaustPlugInAudioProcessor::setCurrentProgram (int index)
+{}
+
+const juce::String FaustPlugInAudioProcessor::getProgramName (int index)
+{
+    return juce::String();
+}
+
+void FaustPlugInAudioProcessor::changeProgramName (int index, const juce::String& newName)
+{}
+
+bool FaustPlugInAudioProcessor::supportsDoublePrecisionProcessing() const
+{
+    return sizeof(FAUSTFLOAT) == 8;
+}
+
+//==============================================================================
+void FaustPlugInAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
+{
+    // Reset DSP adaptation
+    fFirstCall = true;
+    
+#ifdef JUCE_POLY
+    fSynth->setCurrentPlaybackSampleRate (sampleRate);
+#else
+    
+    // Setting the DSP control values has already been done
+    // by 'buildUserInterface(&fStateUI)', using the saved values or the default ones.
+    // What has to be done to finish the DSP initialization is done now.
+    mydsp::classInit(int(sampleRate));
+    fDSP->instanceConstants(int(sampleRate));
+    fDSP->instanceClear();
+    
+    // Get latency metadata
+    struct LatencyMeta : public Meta {
+        
+        float fLatencyFrames = -1.f;
+        float fLatencySec = -1.f;
+        
+        void declare(const char* key, const char* value)
+        {
+            if (std::string(key) == "latency_frames" || std::string(key) == "latency_samples") {
+                fLatencyFrames = std::atof(value);
+            } else if (std::string(key) == "latency_sec") {
+                fLatencySec = std::atof(value);
+            }
+        }
+    };
+    
+    LatencyMeta meta;
+    fDSP->metadata(&meta);
+    if (meta.fLatencyFrames > 0) {
+        setLatencySamples(meta.fLatencyFrames);
+    } else if (meta.fLatencySec > 0) {
+        setLatencySamples(meta.fLatencySec * sampleRate);
+    }
+    
+#endif
+#ifdef MAGIC_LEVEL_SOURCE
+    magicState.prepareToPlay(sampleRate, samplesPerBlock);
+    fOutputMeter->setupSource(getMainBusNumOutputChannels(), sampleRate, 500, 200);
+#endif
+}
+
+bool FaustPlugInAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) const
+{
+    // Always return true and have the DSP adapts its buffer layout with a dsp_adapter (see 'prepareToPlay' and 'process')
+    return true;
+}
+
+template <typename FloatType>
+void FaustPlugInAudioProcessor::process (juce::AudioBuffer<FloatType>& buffer, juce::MidiBuffer& midiMessages)
+{
+    juce::ScopedNoDenormals noDenormals;
+    
+    /*
+        prepareToPlay is possibly called several times with different values for sampleRate
+        and isUsingDoublePrecision() state (this has been seen in particular with VTS3),
+        making proper sample format (float/double) and the inputs/outputs layout adaptation
+        more complex at this stage.
+        
+        So adapting the sample format (float/double) and the inputs/outputs layout is done
+        once at first process call even if this possibly allocates memory, which is not RT safe.
+    */
+    if (fFirstCall) {
+        fFirstCall = false;
+        
+        // Possible sample size adaptation
+        if (supportsDoublePrecisionProcessing()) {
+            if (isUsingDoublePrecision()) {
+                // Nothing to do
+            } else {
+                fDSP = std::make_unique<dsp_sample_adapter<double, float>>(fDSP.release());
+            }
+        } else {
+            if (isUsingDoublePrecision()) {
+                fDSP = std::make_unique<dsp_sample_adapter<float, double>>(fDSP.release());
+            } else {
+                // Nothing to do
+            }
+        }
+        
+        // Possibly adapt DSP inputs/outputs number
+        if (fDSP->getNumInputs() > getTotalNumInputChannels() || fDSP->getNumOutputs() > getTotalNumOutputChannels()) {
+            fDSP = std::make_unique<dsp_adapter>(fDSP.release(), getTotalNumInputChannels(), getTotalNumOutputChannels(), 4096);
+        }
+    }
+    
+#ifdef JUCE_POLY
+    fSynth->renderNextBlock(buffer, midiMessages, 0, buffer.getNumSamples());
+#else
+#if defined(MIDICTRL)
+    // Read MIDI input events from midiMessages
+    fMIDIHandler->decodeBuffer(midiMessages);
+    // Then write MIDI output events to midiMessages
+    fMIDIHandler->encodeBuffer(midiMessages);
+#endif
+    // MIDI timestamp is expressed in frames
+    fDSP->compute(-1, buffer.getNumSamples(),
+                  (FAUSTFLOAT**)buffer.getArrayOfReadPointers(),
+                  (FAUSTFLOAT**)buffer.getArrayOfWritePointers());
+#endif
+}
+
+//==============================================================================
+#ifndef PLUGIN_MAGIC
+bool FaustPlugInAudioProcessor::hasEditor() const
+{
+    return true;
+}
+
+juce::AudioProcessorEditor* FaustPlugInAudioProcessor::createEditor()
+{
+    return new FaustPlugInAudioProcessorEditor (*this);
+}
+
+//==============================================================================
+void FaustPlugInAudioProcessor::getStateInformation (juce::MemoryBlock& destData)
+{
+    // You should use this method to store your parameters in the memory block.
+    // You could do that either as raw data, or use the XML or ValueTree classes
+    // as intermediaries to make it easy to save and load complex data.
+    
+    fStateUI.getStateInformation(destData);
+}
+
+void FaustPlugInAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
+{
+    // You should use this method to restore your parameters from this memory block,
+    // whose contents will have been created by the getStateInformation() call.
+    
+    fStateUI.setStateInformation(data, sizeInBytes);
+}
+#endif
+//==============================================================================
+// This creates new instances of the plugin..
+juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
+{
+    return new FaustPlugInAudioProcessor();
+}
+
+//==============================================================================
+#ifndef PLUGIN_MAGIC
+FaustPlugInAudioProcessorEditor::FaustPlugInAudioProcessorEditor (FaustPlugInAudioProcessor& p)
+: juce::AudioProcessorEditor (&p), processor (p)
+{
+#ifdef JUCE_POLY
+    p.fSynth->buildUserInterface(&fJuceGUI);
+#else
+    p.fDSP->buildUserInterface(&fJuceGUI);
+#endif
+    
+    addAndMakeVisible(fJuceGUI);
+    
+    juce::Rectangle<int> recommendedSize = fJuceGUI.getSize();
+    setSize (recommendedSize.getWidth(), recommendedSize.getHeight());
+}
+
+//==============================================================================
+void FaustPlugInAudioProcessorEditor::paint (juce::Graphics& g)
+{
+    g.fillAll (juce::Colours::white);
+}
+
+void FaustPlugInAudioProcessorEditor::resized()
+{
+    fJuceGUI.setBounds(getLocalBounds());
+}
+
+#endif
+// Globals
+std::list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;