cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/dsp/poly-dsp.h

@@ -0,0 +1,1079 @@
+/************************** BEGIN poly-dsp.h *************************
+FAUST Architecture File
+Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+---------------------------------------------------------------------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+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.
+*********************************************************************/
+
+#ifndef __poly_dsp__
+#define __poly_dsp__
+
+#include <stdio.h>
+#include <string>
+#include <cmath>
+#include <algorithm>
+#include <functional>
+#include <ostream>
+#include <sstream>
+#include <vector>
+#include <limits.h>
+#include <float.h>
+#include <assert.h>
+
+#include "faust/midi/midi.h"
+#include "faust/dsp/dsp-combiner.h"
+#include "faust/dsp/dsp-adapter.h"
+#include "faust/dsp/proxy-dsp.h"
+
+#include "faust/gui/DecoratorUI.h"
+#include "faust/gui/GUI.h"
+#include "faust/gui/MapUI.h"
+#include "faust/gui/JSONControl.h"
+
+#define kActiveVoice    0
+#define kFreeVoice     -1
+#define kReleaseVoice  -2
+#define kLegatoVoice   -3
+#define kNoVoice       -4
+
+#define VOICE_STOP_LEVEL  0.0005    // -70 db
+#define MIX_BUFFER_SIZE   4096
+
+/**
+ * Allows to control zones in a grouped manner.
+ */
+class GroupUI : public GUI, public PathBuilder {
+
+    private:
+
+        // Map to associate labels with UI group items
+        std::map<std::string, uiGroupItem*> fLabelZoneMap;
+
+        // Insert a zone into the map based on the label folloing the freq/gain/gate polyphonic convention
+        void insertMap(std::string label, FAUSTFLOAT* zone)
+        {
+            if (!MapUI::endsWith(label, "/gate")
+                && !MapUI::endsWith(label, "/freq")
+                && !MapUI::endsWith(label, "/key")
+                && !MapUI::endsWith(label, "/gain")
+                && !MapUI::endsWith(label, "/vel")
+                && !MapUI::endsWith(label, "/velocity")) {
+
+                // Groups all controllers except 'freq/key', 'gate', and 'gain/vel|velocity'
+                if (fLabelZoneMap.find(label) != fLabelZoneMap.end()) {
+                    fLabelZoneMap[label]->addZone(zone);
+                } else {
+                    fLabelZoneMap[label] = new uiGroupItem(this, zone);
+                }
+            }
+        }
+
+        uiCallbackItem* fPanic;
+
+    public:
+
+        GroupUI(FAUSTFLOAT* zone, uiCallback cb, void* arg)
+        {
+            fPanic = new uiCallbackItem(this, zone, cb, arg);
+        }
+    
+        virtual ~GroupUI()
+        {
+            // 'fPanic' is kept and deleted in GUI, so do not delete here
+        }
+
+        // -- widget's layouts
+        void openTabBox(const char* label)
+        {
+            pushLabel(label);
+        }
+        void openHorizontalBox(const char* label)
+        {
+            pushLabel(label);
+        }
+        void openVerticalBox(const char* label)
+        {
+            pushLabel(label);
+        }
+        void closeBox()
+        {
+            popLabel();
+        }
+
+        // -- active widgets
+        void addButton(const char* label, FAUSTFLOAT* zone)
+        {
+            insertMap(buildPath(label), zone);
+        }
+        void addCheckButton(const char* label, FAUSTFLOAT* zone)
+        {
+            insertMap(buildPath(label), zone);
+        }
+        void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT fmin, FAUSTFLOAT fmax, FAUSTFLOAT step)
+        {
+            insertMap(buildPath(label), zone);
+        }
+        void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT fmin, FAUSTFLOAT fmax, FAUSTFLOAT step)
+        {
+            insertMap(buildPath(label), zone);
+        }
+        void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT fmin, FAUSTFLOAT fmax, FAUSTFLOAT step)
+        {
+            insertMap(buildPath(label), zone);
+        }
+
+        // -- passive widgets
+        void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT fmin, FAUSTFLOAT fmax)
+        {
+            insertMap(buildPath(label), zone);
+        }
+        void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT fmin, FAUSTFLOAT fmax)
+        {
+            insertMap(buildPath(label), zone);
+        }
+
+};
+
+/**
+ * One voice of polyphony.
+ */
+struct dsp_voice : public MapUI, public decorator_dsp {
+    
+    typedef std::function<double(int)> TransformFunction;
+  
+    // Convert MIDI note to frequency
+    static double midiToFreq(double note)
+    {
+        return 440.0 * std::pow(2.0, (note-69.0)/12.0);
+    }
+    
+    // Voice state and properties
+    int fCurNote;                       // Current playing note pitch
+    int fNextNote;                      // In kLegatoVoice state, next note to play
+    int fNextVel;                       // In kLegatoVoice state, next velocity to play
+    int fDate;                          // KeyOn date
+    int fRelease;                       // Current number of samples used in release mode to detect end of note
+    FAUSTFLOAT fLevel;                  // Last audio block level
+    double fReleaseLengthSec;           // Maximum release length in seconds (estimated time to silence after note release)
+    std::vector<std::string> fGatePath; // Paths of 'gate' control
+    std::vector<std::string> fGainPath; // Paths of 'gain/vel|velocity' control
+    std::vector<std::string> fFreqPath; // Paths of 'freq/key' control
+    TransformFunction        fKeyFun;   // MIDI key to freq conversion function
+    TransformFunction        fVelFun;   // MIDI velocity to gain conversion function
+    
+    FAUSTFLOAT** fInputsSlice;
+    FAUSTFLOAT** fOutputsSlice;
+ 
+    dsp_voice(dsp* dsp):decorator_dsp(dsp)
+    {
+        // Default conversion functions
+        fVelFun = [](int velocity) { return double(velocity)/127.0; };
+        fKeyFun = [](int pitch) { return midiToFreq(pitch); };
+        dsp->buildUserInterface(this);
+        fCurNote = kFreeVoice;
+        fNextNote = fNextVel = -1;
+        fLevel = FAUSTFLOAT(0);
+        fDate = fRelease = 0;
+        fReleaseLengthSec = 0.5;  // A half second is a reasonable default maximum release length.
+        extractPaths(fGatePath, fFreqPath, fGainPath);
+    }
+    virtual ~dsp_voice()
+    {}
+    
+    // Compute a slice of audio
+    void computeSlice(int offset, int slice, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+    {
+        FAUSTFLOAT** inputsSlice = static_cast<FAUSTFLOAT**>(alloca(sizeof(FAUSTFLOAT*) * getNumInputs()));
+        for (int chan = 0; chan < getNumInputs(); chan++) {
+            inputsSlice[chan] = &(inputs[chan][offset]);
+        }
+        FAUSTFLOAT** outputsSlice = static_cast<FAUSTFLOAT**>(alloca(sizeof(FAUSTFLOAT*) * getNumOutputs()));
+        for (int chan = 0; chan < getNumOutputs(); chan++) {
+            outputsSlice[chan] = &(outputs[chan][offset]);
+        }
+        compute(slice, inputsSlice, outputsSlice);
+    }
+    
+    // Compute audio in legato mode
+    void computeLegato(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+    {
+        int slice = count/2;
+        
+        // Reset envelops
+        for (size_t i = 0; i < fGatePath.size(); i++) {
+            setParamValue(fGatePath[i], FAUSTFLOAT(0));
+        }
+        
+        // Compute current voice on half buffer
+        computeSlice(0, slice, inputs, outputs);
+         
+        // Start next keyOn
+        keyOn(fNextNote, fNextVel);
+        
+        // Compute on second half buffer
+        computeSlice(slice, slice, inputs, outputs);
+    }
+
+    // Extract control paths from fullpath map
+    void extractPaths(std::vector<std::string>& gate, std::vector<std::string>& freq, std::vector<std::string>& gain)
+    {
+        // Keep gain/vel|velocity, freq/key and gate labels
+        for (const auto& it : getFullpathMap()) {
+            std::string path = it.first;
+            if (endsWith(path, "/gate")) {
+                gate.push_back(path);
+            } else if (endsWith(path, "/freq")) {
+                fKeyFun = [](int pitch) { return midiToFreq(pitch); };
+                freq.push_back(path);
+            } else if (endsWith(path, "/key")) {
+                fKeyFun = [](int pitch) { return pitch; };
+                freq.push_back(path);
+            } else if (endsWith(path, "/gain")) {
+                fVelFun = [](int velocity) { return double(velocity)/127.0; };
+                gain.push_back(path);
+            } else if (endsWith(path, "/vel") || endsWith(path, "/velocity")) {
+                fVelFun = [](int velocity) { return double(velocity); };
+                gain.push_back(path);
+            }
+        }
+    }
+    
+    // Reset voice
+    void reset()
+    {
+        init(getSampleRate());
+    }
+ 
+    // Clear instance state
+    void instanceClear()
+    {
+        decorator_dsp::instanceClear();
+        fCurNote = kFreeVoice;
+        fNextNote = fNextVel = -1;
+        fLevel = FAUSTFLOAT(0);
+        fDate = fRelease = 0;
+    }
+    
+    // Keep 'pitch' and 'velocity' to fadeOut the current voice and start next one in the next buffer
+    void keyOn(int pitch, int velocity, bool legato = false)
+    {
+        if (legato) {
+            fNextNote = pitch;
+            fNextVel = velocity;
+        } else {
+            keyOn(pitch, fVelFun(velocity));
+        }
+    }
+
+    // KeyOn with normalized MIDI velocity [0..1]
+    void keyOn(int pitch, double velocity)
+    {
+        for (size_t i = 0; i < fFreqPath.size(); i++) {
+            setParamValue(fFreqPath[i], fKeyFun(pitch));
+        }
+        for (size_t i = 0; i < fGatePath.size(); i++) {
+            setParamValue(fGatePath[i], FAUSTFLOAT(1));
+        }
+        for (size_t i = 0; i < fGainPath.size(); i++) {
+            setParamValue(fGainPath[i], velocity);
+        }
+        
+        fCurNote = pitch;
+    }
+
+    void keyOff(bool hard = false)
+    {
+        // No use of velocity for now...
+        for (size_t i = 0; i < fGatePath.size(); i++) {
+            setParamValue(fGatePath[i], FAUSTFLOAT(0));
+        }
+        
+        if (hard) {
+            // Immediately stop voice
+            fCurNote = kFreeVoice;
+        } else {
+            // Release voice
+            fRelease = fReleaseLengthSec * fDSP->getSampleRate();
+            fCurNote = kReleaseVoice;
+        }
+    }
+ 
+    // Change the voice release
+    void setReleaseLength(double sec)
+    {
+        fReleaseLengthSec = sec;
+    }
+
+};
+
+/**
+ * A group of voices.
+ */
+struct dsp_voice_group {
+
+    // GUI group for controlling voice parameters
+    GroupUI fGroups;
+
+    std::vector<dsp_voice*> fVoiceTable; // Individual voices
+    dsp* fVoiceGroup;                    // Voices group to be used for GUI grouped control
+
+    FAUSTFLOAT fPanic;  // Panic button value
+
+    bool fVoiceControl; // Voice control mode
+    bool fGroupControl; // Group control mode
+
+    dsp_voice_group(uiCallback cb, void* arg, bool control, bool group)
+        :fGroups(&fPanic, cb, arg),
+        fVoiceGroup(0), fPanic(FAUSTFLOAT(0)),
+        fVoiceControl(control), fGroupControl(group)
+    {}
+
+    virtual ~dsp_voice_group()
+    {
+        for (size_t i = 0; i < fVoiceTable.size(); i++) {
+            delete fVoiceTable[i];
+        }
+        delete fVoiceGroup;
+    }
+
+    // Add a voice to the group
+    void addVoice(dsp_voice* voice)
+    {
+        fVoiceTable.push_back(voice);
+    }
+        
+    // Clear all voices from the group
+    void clearVoices()
+    {
+        fVoiceTable.clear();
+    }
+
+    // Initialize the voice group
+    void init()
+    {
+        // Groups all uiItem for a given path
+        fVoiceGroup = new proxy_dsp(fVoiceTable[0]);
+        fVoiceGroup->buildUserInterface(&fGroups);
+        for (size_t i = 0; i < fVoiceTable.size(); i++) {
+            fVoiceTable[i]->buildUserInterface(&fGroups);
+        }
+    }
+    
+    // Reset the user interface for each voice instance
+    void instanceResetUserInterface()
+    {
+        for (size_t i = 0; i < fVoiceTable.size(); i++) {
+            fVoiceTable[i]->instanceResetUserInterface();
+        }
+    }
+
+    // Build the user interface for the voice group
+    void buildUserInterface(UI* ui_interface)
+    {
+        if (fVoiceTable.size() > 1) {
+            ui_interface->openTabBox("Polyphonic");
+
+            // Grouped voices UI
+            ui_interface->openVerticalBox("Voices");
+            ui_interface->addButton("Panic", &fPanic);
+            fVoiceGroup->buildUserInterface(ui_interface);
+            ui_interface->closeBox();
+
+            // If not grouped, also add individual voices UI
+            if (!fGroupControl || dynamic_cast<SoundUIInterface*>(ui_interface)) {
+                for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                    char buffer[32];
+                    snprintf(buffer, 32, ((fVoiceTable.size() < 8) ? "Voice%ld" : "V%ld"), long(i+1));
+                    ui_interface->openHorizontalBox(buffer);
+                    fVoiceTable[i]->buildUserInterface(ui_interface);
+                    ui_interface->closeBox();
+                }
+            }
+
+            ui_interface->closeBox();
+        } else {
+            fVoiceTable[0]->buildUserInterface(ui_interface);
+        }
+    }
+
+};
+
+/**
+ * Base class for MIDI controllable polyphonic DSP.
+ */
+#ifdef EMCC
+#include "faust/gui/JSONUI.h"
+#include "faust/gui/MidiUI.h"
+#endif
+
+class dsp_poly : public decorator_dsp, public midi, public JSONControl {
+
+    protected:
+    
+    #ifdef EMCC
+        MapUI fMapUI;               // Map for UI control
+        std::string fJSON;          // JSON representation of the UI
+        midi_handler fMidiHandler;  // MIDI handler for the UI
+        MidiUI fMIDIUI;             // MIDI UI for the DSP
+    #endif
+    
+    public:
+    
+    #ifdef EMCC
+        dsp_poly(dsp* dsp):decorator_dsp(dsp), fMIDIUI(&fMidiHandler)
+        {
+            JSONUI jsonui(getNumInputs(), getNumOutputs());
+            buildUserInterface(&jsonui);
+            fJSON = jsonui.JSON(true);
+            buildUserInterface(&fMapUI);
+            buildUserInterface(&fMIDIUI);
+        }
+    #else
+        dsp_poly(dsp* dsp):decorator_dsp(dsp)
+        {}
+    #endif
+    
+        virtual ~dsp_poly() {}
+    
+        // Reimplemented for EMCC
+    #ifdef EMCC
+        virtual int getNumInputs() { return decorator_dsp::getNumInputs(); }
+        virtual int getNumOutputs() { return decorator_dsp::getNumOutputs(); }
+        virtual void buildUserInterface(UI* ui_interface) { decorator_dsp::buildUserInterface(ui_interface); }
+        virtual int getSampleRate() { return decorator_dsp::getSampleRate(); }
+        virtual void init(int sample_rate) { decorator_dsp::init(sample_rate); }
+        virtual void instanceInit(int sample_rate) { decorator_dsp::instanceInit(sample_rate); }
+        virtual void instanceConstants(int sample_rate) { decorator_dsp::instanceConstants(sample_rate); }
+        virtual void instanceResetUserInterface() { decorator_dsp::instanceResetUserInterface(); }
+        virtual void instanceClear() { decorator_dsp::instanceClear(); }
+        virtual dsp_poly* clone() { return new dsp_poly(fDSP->clone()); }
+        virtual void metadata(Meta* m) { decorator_dsp::metadata(m); }
+    
+        // Additional API
+        std::string getJSON()
+        {
+            return fJSON;
+        }
+    
+        virtual void setParamValue(const std::string& path, FAUSTFLOAT value)
+        {
+            fMapUI.setParamValue(path, value);
+            GUI::updateAllGuis();
+        }
+        
+        virtual FAUSTFLOAT getParamValue(const std::string& path) { return fMapUI.getParamValue(path); }
+
+        virtual void computeJS(int count, uintptr_t inputs, uintptr_t outputs)
+        {
+            decorator_dsp::compute(count, reinterpret_cast<FAUSTFLOAT**>(inputs),reinterpret_cast<FAUSTFLOAT**>(outputs));
+        }
+    #endif
+    
+        virtual MapUI* keyOn(int channel, int pitch, int velocity)
+        {
+            return midi::keyOn(channel, pitch, velocity);
+        }
+        virtual void keyOff(int channel, int pitch, int velocity)
+        {
+            midi::keyOff(channel, pitch, velocity);
+        }
+        virtual void keyPress(int channel, int pitch, int press)
+        {
+            midi::keyPress(channel, pitch, press);
+        }
+        virtual void chanPress(int channel, int press)
+        {
+            midi::chanPress(channel, press);
+        }
+        virtual void ctrlChange(int channel, int ctrl, int value)
+        {
+            midi::ctrlChange(channel, ctrl, value);
+        }
+        virtual void ctrlChange14bits(int channel, int ctrl, int value)
+        {
+            midi::ctrlChange14bits(channel, ctrl, value);
+        }
+        virtual void pitchWheel(int channel, int wheel)
+        {
+        #ifdef EMCC
+            fMIDIUI.pitchWheel(0., channel, wheel);
+            GUI::updateAllGuis();
+        #else
+            midi::pitchWheel(channel, wheel);
+        #endif
+        }
+        virtual void progChange(int channel, int pgm)
+        {
+            midi::progChange(channel, pgm);
+        }
+    
+        // Change the voice release
+        virtual void setReleaseLength(double seconds)
+        {}
+    
+};
+
+/**
+ * Polyphonic DSP: groups a set of DSP to be played together or triggered by MIDI.
+ *
+ * All voices are preallocated by cloning the single DSP voice given at creation time.
+ * Dynamic voice allocation is done in 'getFreeVoice'
+ */
+class mydsp_poly : public dsp_voice_group, public dsp_poly {
+
+    private:
+
+        FAUSTFLOAT** fMixBuffer;        // Intermediate buffer for mixing voices
+        FAUSTFLOAT** fOutBuffer;        // Intermediate buffer for output
+        midi_interface* fMidiHandler;   // The midi_interface the DSP is connected to
+        int fDate;                      // Current date for managing voices
+    
+        // Fade out the audio in the buffer
+        void fadeOut(int count, FAUSTFLOAT** outBuffer)
+        {
+            // FadeOut on half buffer
+            for (int chan = 0; chan < getNumOutputs(); chan++) {
+                double factor = 1., step = 1./double(count);
+                for (int frame = 0; frame < count; frame++) {
+                    outBuffer[chan][frame] *= factor;
+                    factor -= step;
+                }
+            }
+        }
+    
+        // Mix the audio from the mix buffer to the output buffer, and also calculate the maximum level on the buffer
+        FAUSTFLOAT mixCheckVoice(int count, FAUSTFLOAT** mixBuffer, FAUSTFLOAT** outBuffer)
+        {
+            FAUSTFLOAT level = 0;
+            for (int chan = 0; chan < getNumOutputs(); chan++) {
+                FAUSTFLOAT* mixChannel = mixBuffer[chan];
+                FAUSTFLOAT* outChannel = outBuffer[chan];
+                for (int frame = 0; frame < count; frame++) {
+                    level = std::max<FAUSTFLOAT>(level, (FAUSTFLOAT)fabs(mixChannel[frame]));
+                    outChannel[frame] += mixChannel[frame];
+                }
+            }
+            return level;
+        }
+    
+        // Mix the audio from the mix buffer to the output buffer
+        void mixVoice(int count, FAUSTFLOAT** mixBuffer, FAUSTFLOAT** outBuffer)
+        {
+            for (int chan = 0; chan < getNumOutputs(); chan++) {
+                FAUSTFLOAT* mixChannel = mixBuffer[chan];
+                FAUSTFLOAT* outChannel = outBuffer[chan];
+                for (int frame = 0; frame < count; frame++) {
+                    outChannel[frame] += mixChannel[frame];
+                }
+            }
+        }
+    
+        // Copy the audio from one buffer to another
+        void copy(int count, FAUSTFLOAT** mixBuffer, FAUSTFLOAT** outBuffer)
+        {
+            for (int chan = 0; chan < getNumOutputs(); chan++) {
+                memcpy(outBuffer[chan], mixBuffer[chan], count * sizeof(FAUSTFLOAT));
+            }
+        }
+
+        // Clear the audio buffer
+        void clear(int count, FAUSTFLOAT** outBuffer)
+        {
+            for (int chan = 0; chan < getNumOutputs(); chan++) {
+                memset(outBuffer[chan], 0, count * sizeof(FAUSTFLOAT));
+            }
+        }
+    
+        // Get the index of a voice currently playing a specific pitch
+        int getPlayingVoice(int pitch)
+        {
+            int voice_playing = kNoVoice;
+            int oldest_date_playing = INT_MAX;
+            
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                if (fVoiceTable[i]->fCurNote == pitch) {
+                    // Keeps oldest playing voice
+                    if (fVoiceTable[i]->fDate < oldest_date_playing) {
+                        oldest_date_playing = fVoiceTable[i]->fDate;
+                        voice_playing = int(i);
+                    }
+                }
+            }
+            
+            return voice_playing;
+        }
+    
+        // Allocate a voice with a given type
+        int allocVoice(int voice, int type)
+        {
+            fVoiceTable[voice]->fDate++;
+            fVoiceTable[voice]->fCurNote = type;
+            return voice;
+        }
+    
+        // Get a free voice for allocation, always returns a voice
+        int getFreeVoice()
+        {
+            // Looks for the first available voice
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                if (fVoiceTable[i]->fCurNote == kFreeVoice) {
+                    return allocVoice(i, kActiveVoice);
+                }
+            }
+
+            // Otherwise steal one
+            int voice_release = kNoVoice;
+            int voice_playing = kNoVoice;
+            int oldest_date_release = INT_MAX;
+            int oldest_date_playing = INT_MAX;
+
+            // Scan all voices
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                if (fVoiceTable[i]->fCurNote == kReleaseVoice) {
+                    // Keeps oldest release voice
+                    if (fVoiceTable[i]->fDate < oldest_date_release) {
+                        oldest_date_release = fVoiceTable[i]->fDate;
+                        voice_release = int(i);
+                    }
+                } else {
+                    // Otherwise keeps oldest playing voice
+                    if (fVoiceTable[i]->fDate < oldest_date_playing) {
+                        oldest_date_playing = fVoiceTable[i]->fDate;
+                        voice_playing = int(i);
+                    }
+                }
+            }
+        
+            // Then decide which one to steal
+            if (oldest_date_release != INT_MAX) {
+                fprintf(stderr, "Steal release voice : voice_date = %d cur_date = %d voice = %d \n",
+                        fVoiceTable[voice_release]->fDate,
+                        fDate,
+                        voice_release);
+                return allocVoice(voice_release, kLegatoVoice);
+            } else if (oldest_date_playing != INT_MAX) {
+                fprintf(stderr, "Steal playing voice : voice_date = %d cur_date = %d voice = %d \n",
+                        fVoiceTable[voice_playing]->fDate,
+                        fDate,
+                        voice_release);
+                return allocVoice(voice_playing, kLegatoVoice);
+            } else {
+                assert(false);
+                return kNoVoice;
+            }
+        }
+
+        // Callback for panic button
+        static void panic(FAUSTFLOAT val, void* arg)
+        {
+            if (val == FAUSTFLOAT(1)) {
+                static_cast<mydsp_poly*>(arg)->allNotesOff(true);
+            }
+        }
+
+        // Check if the DSP is polyphonic
+        bool checkPolyphony()
+        {
+            if (fVoiceTable.size() > 0) {
+                return true;
+            } else {
+                fprintf(stderr, "DSP is not polyphonic...\n");
+                return false;
+            }
+        }
+
+    public:
+    
+        /**
+         * Constructor.
+         *
+         * @param dsp - the dsp to be used for one voice. Beware: mydsp_poly will use and finally delete the pointer.
+         * @param nvoices - number of polyphony voices, should be at least 1
+         * @param control - whether voices will be dynamically allocated and controlled (typically by a MIDI controler).
+         *                If false all voices are always running.
+         * @param group - if true, voices are not individually accessible, a global "Voices" tab will automatically dispatch
+         *                a given control on all voices, assuming GUI::updateAllGuis() is called.
+         *                If false, all voices can be individually controlled.
+         *
+         */
+        mydsp_poly(dsp* dsp,
+                   int nvoices,
+                   bool control = false,
+                   bool group = true)
+        : dsp_voice_group(panic, this, control, group), dsp_poly(dsp) // dsp parameter is deallocated by ~dsp_poly
+        {
+            fDate = 0;
+            fMidiHandler = nullptr;
+
+            // Create voices
+            assert(nvoices > 0);
+            for (int i = 0; i < nvoices; i++) {
+                addVoice(new dsp_voice(dsp->clone()));
+            }
+
+            // Init audio output buffers
+            fMixBuffer = new FAUSTFLOAT*[getNumOutputs()];
+            fOutBuffer = new FAUSTFLOAT*[getNumOutputs()];
+            for (int chan = 0; chan < getNumOutputs(); chan++) {
+                fMixBuffer[chan] = new FAUSTFLOAT[MIX_BUFFER_SIZE];
+                fOutBuffer[chan] = new FAUSTFLOAT[MIX_BUFFER_SIZE];
+            }
+
+            dsp_voice_group::init();
+        }
+
+        virtual ~mydsp_poly()
+        {
+            // Remove from fMidiHandler
+            if (fMidiHandler) fMidiHandler->removeMidiIn(this);
+            for (int chan = 0; chan < getNumOutputs(); chan++) {
+                delete[] fMixBuffer[chan];
+                delete[] fOutBuffer[chan];
+            }
+            delete[] fMixBuffer;
+            delete[] fOutBuffer;
+            
+        }
+
+        // DSP API
+        void buildUserInterface(UI* ui_interface)
+        {
+            // MidiUI ui_interface contains the midi_handler connected to the MIDI driver
+            if (dynamic_cast<midi_interface*>(ui_interface)) {
+                fMidiHandler = dynamic_cast<midi_interface*>(ui_interface);
+                fMidiHandler->addMidiIn(this);
+            }
+            dsp_voice_group::buildUserInterface(ui_interface);
+        }
+
+        void init(int sample_rate)
+        {
+            decorator_dsp::init(sample_rate);
+            fVoiceGroup->init(sample_rate);
+            fPanic = FAUSTFLOAT(0);
+            
+            // Init voices
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                fVoiceTable[i]->init(sample_rate);
+            }
+        }
+    
+        void instanceInit(int samplingFreq)
+        {
+            instanceConstants(samplingFreq);
+            instanceResetUserInterface();
+            instanceClear();
+        }
+
+        void instanceConstants(int sample_rate)
+        {
+            decorator_dsp::instanceConstants(sample_rate);
+            fVoiceGroup->instanceConstants(sample_rate);
+            
+            // Init voices
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                fVoiceTable[i]->instanceConstants(sample_rate);
+            }
+        }
+
+        void instanceResetUserInterface()
+        {
+            decorator_dsp::instanceResetUserInterface();
+            fVoiceGroup->instanceResetUserInterface();
+            fPanic = FAUSTFLOAT(0);
+            
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                fVoiceTable[i]->instanceResetUserInterface();
+            }
+        }
+
+        void instanceClear()
+        {
+            decorator_dsp::instanceClear();
+            fVoiceGroup->instanceClear();
+            
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                fVoiceTable[i]->instanceClear();
+            }
+        }
+
+        virtual mydsp_poly* clone()
+        {
+            return new mydsp_poly(fDSP->clone(), int(fVoiceTable.size()), fVoiceControl, fGroupControl);
+        }
+
+        void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            assert(count <= MIX_BUFFER_SIZE);
+
+            // First clear the intermediate fOutBuffer
+            clear(count, fOutBuffer);
+
+            if (fVoiceControl) {
+                // Mix all playing voices
+                for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                    dsp_voice* voice = fVoiceTable[i];
+                    if (voice->fCurNote == kLegatoVoice) {
+                        // Play from current note and next note
+                        voice->computeLegato(count, inputs, fMixBuffer);
+                        // FadeOut on first half buffer
+                        fadeOut(count/2, fMixBuffer);
+                        // Mix it in result
+                        voice->fLevel = mixCheckVoice(count, fMixBuffer, fOutBuffer);
+                    } else if (voice->fCurNote != kFreeVoice) {
+                        // Compute current note
+                        voice->compute(count, inputs, fMixBuffer);
+                        // Mix it in result
+                        voice->fLevel = mixCheckVoice(count, fMixBuffer, fOutBuffer);
+                        // Check the level to possibly set the voice in kFreeVoice again
+                        voice->fRelease -= count;
+                        if ((voice->fCurNote == kReleaseVoice)
+                            && (voice->fRelease < 0)
+                            && (voice->fLevel < VOICE_STOP_LEVEL)) {
+                            voice->fCurNote = kFreeVoice;
+                        }
+                    }
+                }
+            } else {
+                // Mix all voices
+                for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                    fVoiceTable[i]->compute(count, inputs, fMixBuffer);
+                    mixVoice(count, fMixBuffer, fOutBuffer);
+                }
+            }
+            
+            // Finally copy intermediate buffer to outputs
+            copy(count, fOutBuffer, outputs);
+        }
+
+        void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs)
+        {
+            compute(count, inputs, outputs);
+        }
+    
+        // Terminate all active voices, gently or immediately (depending of 'hard' value)
+        void allNotesOff(bool hard = false)
+        {
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                fVoiceTable[i]->keyOff(hard);
+            }
+        }
+ 
+        // Additional polyphonic API
+        MapUI* newVoice()
+        {
+            return fVoiceTable[getFreeVoice()];
+        }
+
+        void deleteVoice(MapUI* voice)
+        {
+            auto it = find(fVoiceTable.begin(), fVoiceTable.end(), reinterpret_cast<dsp_voice*>(voice));
+            if (it != fVoiceTable.end()) {
+                dsp_voice* voice = *it;
+                voice->keyOff();
+                voice->reset();
+            } else {
+                fprintf(stderr, "Voice not found\n");
+            }
+        }
+
+        // MIDI API
+        MapUI* keyOn(int channel, int pitch, int velocity)
+        {
+            if (checkPolyphony()) {
+                int voice = getFreeVoice();
+                fVoiceTable[voice]->keyOn(pitch, velocity, fVoiceTable[voice]->fCurNote == kLegatoVoice);
+                return fVoiceTable[voice];
+            } else {
+                return 0;
+            }
+        }
+
+        void keyOff(int channel, int pitch, int velocity = 127)
+        {
+            if (checkPolyphony()) {
+                int voice = getPlayingVoice(pitch);
+                if (voice != kNoVoice) {
+                    fVoiceTable[voice]->keyOff();
+                } else {
+                    fprintf(stderr, "Playing pitch = %d not found\n", pitch);
+                }
+            }
+        }
+
+        void ctrlChange(int channel, int ctrl, int value)
+        {
+            if (ctrl == ALL_NOTES_OFF || ctrl == ALL_SOUND_OFF) {
+                allNotesOff();
+            }
+        }
+
+        // Change the voice release
+        void setReleaseLength(double seconds)
+        {
+            for (size_t i = 0; i < fVoiceTable.size(); i++) {
+                fVoiceTable[i]->setReleaseLength(seconds);
+            }
+        }
+
+};
+
+/**
+ * Polyphonic DSP with an integrated effect.
+ */
+class dsp_poly_effect : public dsp_poly {
+    
+    private:
+    
+        // fPolyDSP will respond to MIDI messages.
+        dsp_poly* fPolyDSP;
+        
+    public:
+        
+        dsp_poly_effect(dsp_poly* voice, dsp* combined)
+        :dsp_poly(combined), fPolyDSP(voice)
+        {}
+        
+        virtual ~dsp_poly_effect()
+        {
+            // dsp_poly_effect is also a decorator_dsp, which will free fPolyDSP
+        }
+    
+        // MIDI API
+        MapUI* keyOn(int channel, int pitch, int velocity)
+        {
+            return fPolyDSP->keyOn(channel, pitch, velocity);
+        }
+        void keyOff(int channel, int pitch, int velocity)
+        {
+            fPolyDSP->keyOff(channel, pitch, velocity);
+        }
+        void keyPress(int channel, int pitch, int press)
+        {
+            fPolyDSP->keyPress(channel, pitch, press);
+        }
+        void chanPress(int channel, int press)
+        {
+            fPolyDSP->chanPress(channel, press);
+        }
+        void ctrlChange(int channel, int ctrl, int value)
+        {
+            fPolyDSP->ctrlChange(channel, ctrl, value);
+        }
+        void ctrlChange14bits(int channel, int ctrl, int value)
+        {
+            fPolyDSP->ctrlChange14bits(channel, ctrl, value);
+        }
+        void pitchWheel(int channel, int wheel)
+        {
+            fPolyDSP->pitchWheel(channel, wheel);
+        }
+        void progChange(int channel, int pgm)
+        {
+            fPolyDSP->progChange(channel, pgm);
+        }
+    
+        // Change the voice release
+        void setReleaseLength(double sec)
+        {
+            fPolyDSP->setReleaseLength(sec);
+        }
+    
+};
+
+/**
+ * Polyphonic DSP factory class. Helper code to support polyphonic DSP source with an integrated effect.
+ */
+struct dsp_poly_factory : public dsp_factory {
+    
+    dsp_factory* fProcessFactory;
+    dsp_factory* fEffectFactory;
+    
+    dsp* adaptDSP(dsp* dsp, bool is_double)
+    {
+        return (is_double) ? new dsp_sample_adapter<double, float>(dsp) : dsp;
+    }
+
+    dsp_poly_factory(dsp_factory* process_factory = nullptr,
+                     dsp_factory* effect_factory = nullptr):
+    fProcessFactory(process_factory)
+    ,fEffectFactory(effect_factory)
+    {}
+
+    virtual ~dsp_poly_factory()
+    {}
+
+    std::string getName() { return fProcessFactory->getName(); }
+    std::string getSHAKey() { return fProcessFactory->getSHAKey(); }
+    std::string getDSPCode() { return fProcessFactory->getDSPCode(); }
+    std::string getCompileOptions() { return fProcessFactory->getCompileOptions(); }
+    std::vector<std::string> getLibraryList() { return fProcessFactory->getLibraryList(); }
+    std::vector<std::string> getIncludePathnames() { return fProcessFactory->getIncludePathnames(); }
+    std::vector<std::string> getWarningMessages() { return fProcessFactory->getWarningMessages(); }
+   
+    std::string getEffectCode(const std::string& dsp_content)
+    {
+        std::stringstream effect_code;
+        effect_code << "adapt(1,1) = _; adapt(2,2) = _,_; adapt(1,2) = _ <: _,_; adapt(2,1) = _,_ :> _;";
+        effect_code << "adaptor(F,G) = adapt(outputs(F),inputs(G)); dsp_code = environment{ " << dsp_content << " };";
+        effect_code << "process = adaptor(dsp_code.process, dsp_code.effect) : dsp_code.effect;";
+        return effect_code.str();
+    }
+
+    virtual void setMemoryManager(dsp_memory_manager* manager)
+    {
+        fProcessFactory->setMemoryManager(manager);
+        if (fEffectFactory) {
+            fEffectFactory->setMemoryManager(manager);
+        }
+    }
+    virtual dsp_memory_manager* getMemoryManager() { return fProcessFactory->getMemoryManager(); }
+
+    /* Create a new polyphonic DSP instance with global effect, to be deleted with C++ 'delete'
+     *
+     * @param nvoices - number of polyphony voices, should be at least 1
+     * @param control - whether voices will be dynamically allocated and controlled (typically by a MIDI controler).
+     *                If false all voices are always running.
+     * @param group - if true, voices are not individually accessible, a global "Voices" tab will automatically dispatch
+     *                a given control on all voices, assuming GUI::updateAllGuis() is called.
+     *                If false, all voices can be individually controlled.
+     * @param is_double - if true, internally allocated DSPs will be adapted to receive 'double' samples.
+     */
+    dsp_poly* createPolyDSPInstance(int nvoices, bool control, bool group, bool is_double = false)
+    {
+        dsp_poly* dsp_poly = new mydsp_poly(adaptDSP(fProcessFactory->createDSPInstance(), is_double), nvoices, control, group);
+        if (fEffectFactory) {
+            // the 'dsp_poly' object has to be controlled with MIDI, so kept separated from new dsp_sequencer(...) object
+            return new dsp_poly_effect(dsp_poly, new dsp_sequencer(dsp_poly, adaptDSP(fEffectFactory->createDSPInstance(), is_double)));
+        } else {
+            return new dsp_poly_effect(dsp_poly, dsp_poly);
+        }
+    }
+
+    /* Create a new DSP instance, to be deleted with C++ 'delete' */
+    dsp* createDSPInstance()
+    {
+        return fProcessFactory->createDSPInstance();
+    }
+
+};
+
+#endif // __poly_dsp__
+/************************** END poly-dsp.h **************************/