cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/gui/MidiUI.h

@@ -0,0 +1,939 @@
+/************************** BEGIN MidiUI.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 FAUST_MIDIUI_H
+#define FAUST_MIDIUI_H
+
+#include <vector>
+#include <string>
+#include <utility>
+#include <cstdlib>
+#include <cmath>
+
+#include "faust/dsp/dsp.h"
+#include "faust/gui/meta.h"
+#include "faust/gui/GUI.h"
+#include "faust/gui/JSONUI.h"
+#include "faust/gui/MapUI.h"
+#include "faust/gui/MetaDataUI.h"
+#include "faust/midi/midi.h"
+#include "faust/gui/ValueConverter.h"
+
+#ifdef _MSC_VER
+#define gsscanf sscanf_s
+#else
+#define gsscanf sscanf
+#endif
+
+/**
+ * Helper code for MIDI meta and polyphonic 'nvoices' parsing.
+ */
+struct MidiMeta : public Meta, public std::map<std::string, std::string> {
+    
+    void declare(const char* key, const char* value)
+    {
+        (*this)[key] = value;
+    }
+    
+    const std::string get(const char* key, const char* def)
+    {
+        return (this->find(key) != this->end()) ? (*this)[key] : def;
+    }
+    
+    static void analyse(dsp* mono_dsp, bool& midi_sync, int& nvoices)
+    {
+        JSONUI jsonui;
+        mono_dsp->buildUserInterface(&jsonui);
+        std::string json = jsonui.JSON();
+        midi_sync = ((json.find("midi") != std::string::npos) &&
+                     ((json.find("start") != std::string::npos) ||
+                      (json.find("stop") != std::string::npos) ||
+                      (json.find("clock") != std::string::npos) ||
+                      (json.find("timestamp") != std::string::npos)));
+    
+    #if defined(NVOICES) && NVOICES!=NUM_VOICES
+        nvoices = NVOICES;
+    #else
+        MidiMeta meta;
+        mono_dsp->metadata(&meta);
+        bool found_voices = false;
+        // If "options" metadata is used
+        std::string options = meta.get("options", "");
+        if (options != "") {
+            std::map<std::string, std::string> metadata;
+            std::string res;
+            MetaDataUI::extractMetadata(options, res, metadata);
+            if (metadata.find("nvoices") != metadata.end()) {
+                nvoices = std::atoi(metadata["nvoices"].c_str());
+                found_voices = true;
+            }
+        }
+        // Otherwise test for "nvoices" metadata
+        if (!found_voices) {
+            std::string numVoices = meta.get("nvoices", "0");
+            nvoices = std::atoi(numVoices.c_str());
+        }
+        nvoices = std::max<int>(0, nvoices);
+    #endif
+    }
+    
+    static bool checkPolyphony(dsp* mono_dsp)
+    {
+        MapUI map_ui;
+        mono_dsp->buildUserInterface(&map_ui);
+        bool has_freq = false;
+        bool has_gate = false;
+        bool has_gain = false;
+        for (int i = 0; i < map_ui.getParamsCount(); i++) {
+            std::string path = map_ui.getParamAddress(i);
+            has_freq |= MapUI::endsWith(path, "/freq");
+            has_freq |= MapUI::endsWith(path, "/key");
+            has_gate |= MapUI::endsWith(path, "/gate");
+            has_gain |= MapUI::endsWith(path, "/gain");
+            has_gain |= MapUI::endsWith(path, "/vel");
+            has_gain |= MapUI::endsWith(path, "/velocity");
+        }
+        return (has_freq && has_gate && has_gain);
+    }
+    
+};
+
+/**
+ * uiMidi : Faust User Interface
+ * This class decodes MIDI meta data and maps incoming MIDI messages to them.
+ * Currently ctrlChange, keyOn/keyOff, keyPress, progChange, chanPress, pitchWheel/pitchBend
+ * start/stop/clock meta data is handled.
+ * MIDI channel is numbered in [1..16] in this layer.
+ * Channel 0 means "all channels" when receiving or sending.
+ */
+class uiMidi {
+    
+    friend class MidiUI;
+    
+    protected:
+        
+        midi* fMidiOut;
+        bool fInputCtrl;
+        int fChan;
+    
+        bool inRange(FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT v) { return (min <= v && v <= max); }
+    
+    public:
+        
+        uiMidi(midi* midi_out, bool input, int chan = 0):fMidiOut(midi_out), fInputCtrl(input), fChan(chan)
+        {}
+        virtual ~uiMidi()
+        {}
+
+};
+
+/**
+ * Base class for MIDI aware UI items.
+ */
+class uiMidiItem : public uiMidi, public uiItem {
+    
+    public:
+        
+        uiMidiItem(midi* midi_out, GUI* ui, FAUSTFLOAT* zone, bool input = true, int chan = 0)
+            :uiMidi(midi_out, input, chan), uiItem(ui, zone)
+        {}
+        virtual ~uiMidiItem()
+        {}
+    
+        virtual void reflectZone() {}
+    
+};
+
+/**
+ * Base class for MIDI aware UI items with timestamp support.
+ */
+class uiMidiTimedItem : public uiMidi, public uiTimedItem {
+    
+    public:
+        
+        uiMidiTimedItem(midi* midi_out, GUI* ui, FAUSTFLOAT* zone, bool input = true, int chan = 0)
+            :uiMidi(midi_out, input, chan), uiTimedItem(ui, zone)
+        {}
+        virtual ~uiMidiTimedItem()
+        {}
+    
+        virtual void reflectZone() {}
+    
+};
+
+/**
+ * MIDI sync.
+ */
+class uiMidiStart : public uiMidiTimedItem
+{
+  
+    public:
+    
+        uiMidiStart(midi* midi_out, GUI* ui, FAUSTFLOAT* zone, bool input = true)
+            :uiMidiTimedItem(midi_out, ui, zone, input)
+        {}
+        virtual ~uiMidiStart()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            if (v != FAUSTFLOAT(0)) {
+                fMidiOut->startSync(0);
+            }
+        }
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiItem::modifyZone(FAUSTFLOAT(v));
+            }
+        }
+        
+};
+
+class uiMidiStop : public uiMidiTimedItem {
+  
+    public:
+    
+        uiMidiStop(midi* midi_out, GUI* ui, FAUSTFLOAT* zone, bool input = true)
+            :uiMidiTimedItem(midi_out, ui, zone, input)
+        {}
+        virtual ~uiMidiStop()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            if (v != FAUSTFLOAT(1)) {
+                fMidiOut->stopSync(0);
+            }
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiItem::modifyZone(FAUSTFLOAT(v));
+            }
+        }
+};
+
+class uiMidiClock : public uiMidiTimedItem {
+
+    private:
+        
+        bool fState;
+  
+    public:
+    
+        uiMidiClock(midi* midi_out, GUI* ui, FAUSTFLOAT* zone, bool input = true)
+            :uiMidiTimedItem(midi_out, ui, zone, input), fState(false)
+        {}
+        virtual ~uiMidiClock()
+        {}
+    
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            fMidiOut->clock(0);
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                fState = !fState;
+                uiMidiTimedItem::modifyZone(date, FAUSTFLOAT(fState));
+            }
+        }
+
+};
+
+/**
+ * Standard MIDI events.
+ */
+
+/**
+ * uiMidiProgChange uses the [min...max] range.
+ */
+class uiMidiProgChange : public uiMidiTimedItem {
+    
+    public:
+    
+        FAUSTFLOAT fMin, fMax;
+    
+        uiMidiProgChange(midi* midi_out, GUI* ui, FAUSTFLOAT* zone,
+                         FAUSTFLOAT min, FAUSTFLOAT max,
+                         bool input = true, int chan = 0)
+            :uiMidiTimedItem(midi_out, ui, zone, input, chan), fMin(min), fMax(max)
+        {}
+        virtual ~uiMidiProgChange()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            if (inRange(fMin, fMax, v)) {
+                if (fChan == 0) {
+                    // Send on [0..15] channels on the MIDI layer
+                    for (int chan = 0; chan < 16; chan++) {
+                        fMidiOut->progChange(chan, v);
+                    }
+                } else {
+                    fMidiOut->progChange(fChan - 1, v);
+                }
+            }
+        }
+    
+        void modifyZone(FAUSTFLOAT v)
+        {
+            if (fInputCtrl && inRange(fMin, fMax, v)) {
+                uiItem::modifyZone(v);
+            }
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl && inRange(fMin, fMax, v)) {
+                uiMidiTimedItem::modifyZone(date, v);
+            }
+        }
+        
+};
+
+/**
+ * uiMidiChanPress.
+ */
+class uiMidiChanPress : public uiMidiTimedItem, public uiConverter {
+    
+    public:
+    
+        uiMidiChanPress(midi* midi_out, GUI* ui,
+                        FAUSTFLOAT* zone,
+                        FAUSTFLOAT min, FAUSTFLOAT max,
+                        bool input = true,
+                        MetaDataUI::Scale scale = MetaDataUI::kLin,
+                        int chan = 0)
+            :uiMidiTimedItem(midi_out, ui, zone, input, chan), uiConverter(scale, 0., 127., min, max)
+        {}
+        virtual ~uiMidiChanPress()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            int conv = std::round(fConverter->faust2ui(v));
+            if (fChan == 0) {
+                // Send on [0..15] channels on the MIDI layer
+                for (int chan = 0; chan < 16; chan++) {
+                    fMidiOut->chanPress(chan, conv);
+                }
+            } else {
+                fMidiOut->chanPress(fChan - 1, conv);
+            }
+        }
+    
+        void modifyZone(FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiItem::modifyZone(FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiMidiTimedItem::modifyZone(date, FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+        
+};
+
+/**
+ * uiMidiCtrlChange does scale (kLin/kLog/kExp) mapping.
+ */
+class uiMidiCtrlChange : public uiMidiTimedItem, public uiConverter {
+    
+    private:
+    
+        int fCtrl;
+ 
+    public:
+
+        uiMidiCtrlChange(midi* midi_out, int ctrl, GUI* ui,
+                     FAUSTFLOAT* zone,
+                     FAUSTFLOAT min, FAUSTFLOAT max,
+                     bool input = true,
+                     MetaDataUI::Scale scale = MetaDataUI::kLin,
+                     int chan = 0)
+            :uiMidiTimedItem(midi_out, ui, zone, input, chan), uiConverter(scale, 0., 127., min, max), fCtrl(ctrl)
+        {}
+        virtual ~uiMidiCtrlChange()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            int conv = std::round(fConverter->faust2ui(v));
+            if (fChan == 0) {
+                // Send on [0..15] channels on the MIDI layer
+                for (int chan = 0; chan < 16; chan++) {
+                    fMidiOut->ctrlChange(chan, fCtrl, conv);
+                }
+            } else {
+                fMidiOut->ctrlChange(fChan - 1, fCtrl, conv);
+            }
+        }
+        
+        void modifyZone(FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiItem::modifyZone(FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiMidiTimedItem::modifyZone(date, FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+};
+
+// Use a two segments linear converter
+class uiMidiPitchWheel : public uiMidiTimedItem {
+
+    private:
+    
+        LinearValueConverter2 fConverter;
+    
+    public:
+    
+        uiMidiPitchWheel(midi* midi_out, GUI* ui, FAUSTFLOAT* zone,
+                         FAUSTFLOAT min, FAUSTFLOAT max,
+                         bool input = true, int chan = 0)
+            :uiMidiTimedItem(midi_out, ui, zone, input, chan)
+        {
+            if (min <= 0 && max >= 0) {
+                fConverter = LinearValueConverter2(0., 8191., 16383., double(min), 0., double(max));
+            } else {
+                // Degenerated case...
+                fConverter = LinearValueConverter2(0., 8191., 16383., double(min),double(min + (max - min)/FAUSTFLOAT(2)), double(max));
+            }
+        }
+    
+        virtual ~uiMidiPitchWheel()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            int conv = std::round(fConverter.faust2ui(v));
+            if (fChan == 0) {
+                // Send on [0..15] channels on the MIDI layer
+                for (int chan = 0; chan < 16; chan++) {
+                    fMidiOut->pitchWheel(chan, conv);
+                }
+            } else {
+                fMidiOut->pitchWheel(fChan - 1, conv);
+            }
+        }
+        
+        void modifyZone(FAUSTFLOAT v)
+        { 
+            if (fInputCtrl) {
+                uiItem::modifyZone(FAUSTFLOAT(fConverter.ui2faust(v)));
+            }
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiMidiTimedItem::modifyZone(FAUSTFLOAT(fConverter.ui2faust(v)));
+            }
+        }
+    
+        void setRange(int val)
+        {
+            double semi = (val / 128) + ((val % 128) / 100.);
+            fConverter.setMappingValues(0., 8191., 16383., -semi, 0., semi);
+        }
+ 
+};
+
+/**
+ * uiMidiKeyOn does scale (kLin/kLog/kExp) mapping for velocity.
+ */
+class uiMidiKeyOn : public uiMidiTimedItem, public uiConverter {
+
+    private:
+        
+        int fKeyOn;
+  
+    public:
+    
+        uiMidiKeyOn(midi* midi_out, int key, GUI* ui,
+                    FAUSTFLOAT* zone,
+                    FAUSTFLOAT min, FAUSTFLOAT max,
+                    bool input = true,
+                    MetaDataUI::Scale scale = MetaDataUI::kLin,
+                    int chan = 0)
+            :uiMidiTimedItem(midi_out, ui, zone, input, chan), uiConverter(scale, 0., 127., min, max), fKeyOn(key)
+        {}
+        virtual ~uiMidiKeyOn()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            int conv = std::round(fConverter->faust2ui(v));
+            if (fChan == 0) {
+                // Send on [0..15] channels on the MIDI layer
+                for (int chan = 0; chan < 16; chan++) {
+                    fMidiOut->keyOn(chan, fKeyOn, conv);
+                }
+            } else {
+                fMidiOut->keyOn(fChan - 1, fKeyOn, conv);
+            }
+        }
+        
+        void modifyZone(FAUSTFLOAT v)
+        { 
+            if (fInputCtrl) {
+                uiItem::modifyZone(FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiMidiTimedItem::modifyZone(date, FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+    
+};
+
+/**
+ * uiMidiKeyOff does scale (kLin/kLog/kExp) mapping for velocity.
+ */
+class uiMidiKeyOff : public uiMidiTimedItem, public uiConverter {
+
+    private:
+        
+        int fKeyOff;
+  
+    public:
+    
+        uiMidiKeyOff(midi* midi_out, int key, GUI* ui,
+                     FAUSTFLOAT* zone,
+                     FAUSTFLOAT min, FAUSTFLOAT max,
+                     bool input = true,
+                     MetaDataUI::Scale scale = MetaDataUI::kLin,
+                     int chan = 0)
+            :uiMidiTimedItem(midi_out, ui, zone, input, chan), uiConverter(scale, 0., 127., min, max), fKeyOff(key)
+        {}
+        virtual ~uiMidiKeyOff()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            int conv = std::round(fConverter->faust2ui(v));
+            if (fChan == 0) {
+                // Send on [0..15] channels on the MIDI layer
+                for (int chan = 0; chan < 16; chan++) {
+                    fMidiOut->keyOff(chan, fKeyOff, conv);
+                }
+            } else {
+                fMidiOut->keyOff(fChan - 1, fKeyOff, conv);
+            }
+        }
+        
+        void modifyZone(FAUSTFLOAT v)
+        { 
+            if (fInputCtrl) {
+                uiItem::modifyZone(FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiMidiTimedItem::modifyZone(date, FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+    
+};
+
+/**
+ * uiMidiKeyPress does scale (kLin/kLog/kExp) mapping for velocity.
+ */
+class uiMidiKeyPress : public uiMidiTimedItem, public uiConverter {
+
+    private:
+    
+        int fKey;
+  
+    public:
+    
+        uiMidiKeyPress(midi* midi_out, int key, GUI* ui,
+                       FAUSTFLOAT* zone,
+                       FAUSTFLOAT min, FAUSTFLOAT max,
+                       bool input = true,
+                       MetaDataUI::Scale scale = MetaDataUI::kLin,
+                       int chan = 0)
+            :uiMidiTimedItem(midi_out, ui, zone, input, chan), uiConverter(scale, 0., 127., min, max), fKey(key)
+        {}
+        virtual ~uiMidiKeyPress()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            int conv = std::round(fConverter->faust2ui(v));
+            if (fChan == 0) {
+                // Send on [0..15] channels on the MIDI layer
+                for (int chan = 0; chan < 16; chan++) {
+                    fMidiOut->keyPress(chan, fKey, conv);
+                }
+            } else {
+                fMidiOut->keyPress(fChan - 1, fKey, conv);
+            }
+        }
+        
+        void modifyZone(FAUSTFLOAT v)
+        { 
+            if (fInputCtrl) {
+                uiItem::modifyZone(FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+    
+        void modifyZone(double date, FAUSTFLOAT v)
+        {
+            if (fInputCtrl) {
+                uiMidiTimedItem::modifyZone(date, FAUSTFLOAT(fConverter->ui2faust(v)));
+            }
+        }
+    
+};
+
+/******************************************************************************************
+ * MidiUI : Faust User Interface
+ * This class decodes MIDI metadata and maps incoming MIDI messages to them.
+ * Currently ctrlChange, keyOn/keyOff, keyPress, progChange, chanPress, pitchWheel/pitchBend
+ * start/stop/clock meta data are handled.
+ *
+ * Maps associating MIDI event ID (like each ctrl number) with all MIDI aware UI items
+ * are defined and progressively filled when decoding MIDI related metadata.
+ * MIDI aware UI items are used in both directions:
+ *  - modifying their internal state when receving MIDI input events
+ *  - sending their internal state as MIDI output events
+ *******************************************************************************************/
+
+class MidiUI : public GUI, public midi, public midi_interface, public MetaDataUI {
+
+    // Add uiItem subclasses objects are deallocated by the inherited GUI class
+    typedef std::map <int, std::vector<uiMidiCtrlChange*> > TCtrlChangeTable;
+    typedef std::vector<uiMidiProgChange*>                  TProgChangeTable;
+    typedef std::vector<uiMidiChanPress*>                   TChanPressTable;
+    typedef std::map <int, std::vector<uiMidiKeyOn*> >      TKeyOnTable;
+    typedef std::map <int, std::vector<uiMidiKeyOff*> >     TKeyOffTable;
+    typedef std::map <int, std::vector<uiMidiKeyPress*> >   TKeyPressTable;
+    typedef std::vector<uiMidiPitchWheel*>                  TPitchWheelTable;
+    
+    protected:
+    
+        TCtrlChangeTable fCtrlChangeTable;
+        TProgChangeTable fProgChangeTable;
+        TChanPressTable  fChanPressTable;
+        TKeyOnTable      fKeyOnTable;
+        TKeyOffTable     fKeyOffTable;
+        TKeyOnTable      fKeyTable;
+        TKeyPressTable   fKeyPressTable;
+        TPitchWheelTable fPitchWheelTable;
+        
+        std::vector<uiMidiStart*> fStartTable;
+        std::vector<uiMidiStop*>  fStopTable;
+        std::vector<uiMidiClock*> fClockTable;
+        
+        std::vector<std::pair <std::string, std::string> > fMetaAux;
+        
+        midi_handler* fMidiHandler;
+        bool fDelete;
+        bool fTimeStamp;
+    
+        void addGenericZone(FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max, bool input = true)
+        {
+            if (fMetaAux.size() > 0) {
+                for (size_t i = 0; i < fMetaAux.size(); i++) {
+                    unsigned num;
+                    unsigned chan;
+                    if (fMetaAux[i].first == "midi") {
+                        if (gsscanf(fMetaAux[i].second.c_str(), "ctrl %u %u", &num, &chan) == 2) {
+                            fCtrlChangeTable[num].push_back(new uiMidiCtrlChange(fMidiHandler, num, this, zone, min, max, input, getScale(zone), chan));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "ctrl %u", &num) == 1) {
+                            fCtrlChangeTable[num].push_back(new uiMidiCtrlChange(fMidiHandler, num, this, zone, min, max, input, getScale(zone)));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "keyon %u %u", &num, &chan) == 2) {
+                            fKeyOnTable[num].push_back(new uiMidiKeyOn(fMidiHandler, num, this, zone, min, max, input, getScale(zone), chan));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "keyon %u", &num) == 1) {
+                            fKeyOnTable[num].push_back(new uiMidiKeyOn(fMidiHandler, num, this, zone, min, max, input, getScale(zone)));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "keyoff %u %u", &num, &chan) == 2) {
+                            fKeyOffTable[num].push_back(new uiMidiKeyOff(fMidiHandler, num, this, zone, min, max, input, getScale(zone), chan));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "keyoff %u", &num) == 1) {
+                            fKeyOffTable[num].push_back(new uiMidiKeyOff(fMidiHandler, num, this, zone, min, max, input, getScale(zone)));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "key %u %u", &num, &chan) == 2) {
+                            fKeyTable[num].push_back(new uiMidiKeyOn(fMidiHandler, num, this, zone, min, max, input, getScale(zone), chan));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "key %u", &num) == 1) {
+                            fKeyTable[num].push_back(new uiMidiKeyOn(fMidiHandler, num, this, zone, min, max, input, getScale(zone)));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "keypress %u %u", &num, &chan) == 2) {
+                            fKeyPressTable[num].push_back(new uiMidiKeyPress(fMidiHandler, num, this, zone, min, max, input, getScale(zone), chan));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "keypress %u", &num) == 1) {
+                            fKeyPressTable[num].push_back(new uiMidiKeyPress(fMidiHandler, num, this, zone, min, max, input, getScale(zone)));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "pgm %u", &chan) == 1) {
+                            fProgChangeTable.push_back(new uiMidiProgChange(fMidiHandler, this, zone, min, max, input, chan));
+                        } else if (strcmp(fMetaAux[i].second.c_str(), "pgm") == 0) {
+                            fProgChangeTable.push_back(new uiMidiProgChange(fMidiHandler, this, zone, min, max, input));
+                        } else if (gsscanf(fMetaAux[i].second.c_str(), "chanpress %u", &chan) == 1) {
+                            fChanPressTable.push_back(new uiMidiChanPress(fMidiHandler, this, zone, min, max, input, getScale(zone), chan));
+                        } else if ((fMetaAux[i].second == "chanpress")) {
+                            fChanPressTable.push_back(new uiMidiChanPress(fMidiHandler, this, zone, min, max, input, getScale(zone)));
+                        } else if ((gsscanf(fMetaAux[i].second.c_str(), "pitchwheel %u", &chan) == 1) || (gsscanf(fMetaAux[i].second.c_str(), "pitchbend %u", &chan) == 1)) {
+                            fPitchWheelTable.push_back(new uiMidiPitchWheel(fMidiHandler, this, zone, min, max, input, chan));
+                        } else if ((fMetaAux[i].second == "pitchwheel") || (fMetaAux[i].second == "pitchbend")) {
+                            fPitchWheelTable.push_back(new uiMidiPitchWheel(fMidiHandler, this, zone, min, max, input));
+                        // MIDI sync
+                        } else if (fMetaAux[i].second == "start") {
+                            fStartTable.push_back(new uiMidiStart(fMidiHandler, this, zone, input));
+                        } else if (fMetaAux[i].second == "stop") {
+                            fStopTable.push_back(new uiMidiStop(fMidiHandler, this, zone, input));
+                        } else if (fMetaAux[i].second == "clock") {
+                            fClockTable.push_back(new uiMidiClock(fMidiHandler, this, zone, input));
+                        // Explicit metadata to activate 'timestamp' mode
+                        } else if (fMetaAux[i].second == "timestamp") {
+                            fTimeStamp = true;
+                        }
+                    }
+                }
+            }
+            fMetaAux.clear();
+        }
+    
+        template <typename TABLE>
+        void updateTable1(TABLE& table, double date, int channel, int val1)
+        {
+            for (size_t i = 0; i < table.size(); i++) {
+                int channel_aux = table[i]->fChan;
+                // channel_aux == 0 means "all channels"
+                if (channel_aux == 0 || channel == channel_aux - 1) {
+                    if (fTimeStamp) {
+                        table[i]->modifyZone(date, FAUSTFLOAT(val1));
+                    } else {
+                        table[i]->modifyZone(FAUSTFLOAT(val1));
+                    }
+                }
+            }
+        }
+        
+        template <typename TABLE>
+        void updateTable2(TABLE& table, double date, int channel, int val1, int val2)
+        {
+            if (table.find(val1) != table.end()) {
+                for (size_t i = 0; i < table[val1].size(); i++) {
+                    int channel_aux = table[val1][i]->fChan;
+                    // channel_aux == 0 means "all channels"
+                    if (channel_aux == 0 || channel == channel_aux - 1) {
+                        if (fTimeStamp) {
+                            table[val1][i]->modifyZone(date, FAUSTFLOAT(val2));
+                        } else {
+                            table[val1][i]->modifyZone(FAUSTFLOAT(val2));
+                        }
+                    }
+                }
+            }
+        }
+    
+    public:
+    
+        MidiUI(midi_handler* midi_handler, bool delete_handler = false)
+        {
+            fMidiHandler = midi_handler;
+            fMidiHandler->addMidiIn(this);
+            // TODO: use shared_ptr based implementation
+            fDelete = delete_handler;
+            fTimeStamp = false;
+        }
+ 
+        virtual ~MidiUI() 
+        {
+            // Remove from fMidiHandler
+            fMidiHandler->removeMidiIn(this);
+            // TODO: use shared_ptr based implementation
+            if (fDelete) delete fMidiHandler;
+        }
+    
+        bool run() { return fMidiHandler->startMidi(); }
+        void stop() { fMidiHandler->stopMidi(); }
+        
+        void addMidiIn(midi* midi_dsp) { fMidiHandler->addMidiIn(midi_dsp); }
+        void removeMidiIn(midi* midi_dsp) { fMidiHandler->removeMidiIn(midi_dsp); }
+      
+        // -- active widgets
+        
+        virtual void addButton(const char* label, FAUSTFLOAT* zone)
+        {
+            addGenericZone(zone, FAUSTFLOAT(0), FAUSTFLOAT(1));
+        }
+        virtual void addCheckButton(const char* label, FAUSTFLOAT* zone)
+        {
+            addGenericZone(zone, FAUSTFLOAT(0), FAUSTFLOAT(1));
+        }
+        
+        virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addGenericZone(zone, min, max);
+        }
+        virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addGenericZone(zone, min, max);
+        }
+        virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addGenericZone(zone, min, max);
+        }
+
+        // -- passive widgets
+
+        virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) 
+        {
+            addGenericZone(zone, min, max, false);
+        }
+        virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
+        {
+            addGenericZone(zone, min, max, false);
+        }
+
+        // -- metadata declarations
+
+        virtual void declare(FAUSTFLOAT* zone, const char* key, const char* val)
+        {
+            MetaDataUI::declare(zone, key, val);
+            fMetaAux.push_back(std::make_pair(key, val));
+        }
+        
+        // -- MIDI API
+    
+        void key(double date, int channel, int note, int velocity)
+        {
+            updateTable2<TKeyOnTable>(fKeyTable, date, channel, note, velocity);
+        }
+    
+        MapUI* keyOn(double date, int channel, int note, int velocity)
+        {
+            updateTable2<TKeyOnTable>(fKeyOnTable, date, channel, note, velocity);
+            // If note is in fKeyTable, handle it as a keyOn
+            key(date, channel, note, velocity);
+            return nullptr;
+        }
+        
+        void keyOff(double date, int channel, int note, int velocity)
+        {
+            updateTable2<TKeyOffTable>(fKeyOffTable, date, channel, note, velocity);
+            // If note is in fKeyTable, handle it as a keyOff with a 0 velocity
+            key(date, channel, note, 0);
+        }
+        
+        void ctrlChange(double date, int channel, int ctrl, int value)
+        {
+            updateTable2<TCtrlChangeTable>(fCtrlChangeTable, date, channel, ctrl, value);
+        }
+    
+        void rpn(double date, int channel, int ctrl, int value)
+        {
+            if (ctrl == midi::PITCH_BEND_RANGE) {
+                for (size_t i = 0; i < fPitchWheelTable.size(); i++) {
+                    // channel_aux == 0 means "all channels"
+                    int channel_aux = fPitchWheelTable[i]->fChan;
+                    if (channel_aux == 0 || channel == channel_aux - 1) {
+                        fPitchWheelTable[i]->setRange(value);
+                    }
+                }
+            }
+        }
+    
+        void progChange(double date, int channel, int pgm)
+        {
+            updateTable1<TProgChangeTable>(fProgChangeTable, date, channel, pgm);
+        }
+        
+        void pitchWheel(double date, int channel, int wheel) 
+        {
+            updateTable1<TPitchWheelTable>(fPitchWheelTable, date, channel, wheel);
+        }
+        
+        void keyPress(double date, int channel, int pitch, int press) 
+        {
+            updateTable2<TKeyPressTable>(fKeyPressTable, date, channel, pitch, press);
+        }
+        
+        void chanPress(double date, int channel, int press)
+        {
+            updateTable1<TChanPressTable>(fChanPressTable, date, channel, press);
+        }
+        
+        void ctrlChange14bits(double date, int channel, int ctrl, int value) {}
+        
+        // MIDI sync
+        
+        void startSync(double date)
+        {
+            for (size_t i = 0; i < fStartTable.size(); i++) {
+                fStartTable[i]->modifyZone(date, FAUSTFLOAT(1));
+            }
+        }
+        
+        void stopSync(double date)
+        {
+            for (size_t i = 0; i < fStopTable.size(); i++) {
+                fStopTable[i]->modifyZone(date, FAUSTFLOAT(0));
+            }
+        }
+        
+        void clock(double date)
+        {
+            for (size_t i = 0; i < fClockTable.size(); i++) {
+                fClockTable[i]->modifyZone(date, FAUSTFLOAT(1));
+            }
+        }
+};
+
+#endif // FAUST_MIDIUI_H
+/**************************  END  MidiUI.h **************************/