cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faustvst.cpp

@@ -0,0 +1,3435 @@
+/************************************************************************
+ ************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2014-2016 Albert Graef <aggraef@gmail.com>
+ ---------------------------------------------------------------------
+ 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 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 Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA.
+ ************************************************************************
+ ************************************************************************/
+
+/* VST architecture for Faust synths. */
+
+/* NOTE: This requires one of the Boost headers (boost/circular_buffer.hpp),
+ so to compile Faust programs created with this architecture you need to
+ have at least the Boost headers installed somewhere on your include path
+ (the Boost libraries aren't needed). */
+
+#include <cstdlib>
+#include <cstdint>
+#include <cmath>
+#include <list>
+#include <map>
+#include <set>
+
+// Generic Faust dsp and UI classes
+#include <faust/dsp/dsp.h>
+#include <faust/gui/UI.h>
+#include <faust/gui/MidiUI.h>
+
+using namespace std;
+
+typedef pair<const char*,const char*> strpair;
+
+struct MyMeta : Meta, std::map<const char*, const char*>
+{
+    void declare(const char *key, const char *value)
+    {
+        (*this)[key] = value;
+    }
+    
+    const char* get(const char *key, const char *def)
+    {
+        if (this->find(key) != this->end()) {
+            return (*this)[key];
+        } else {
+            return def;
+        }
+    }
+};
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/***************************************************************************
+ VST UI interface
+ ***************************************************************************/
+
+#include <string.h>
+
+enum ui_elem_type_t {
+    UI_BUTTON, UI_CHECK_BUTTON,
+    UI_V_SLIDER, UI_H_SLIDER, UI_NUM_ENTRY,
+    UI_V_BARGRAPH, UI_H_BARGRAPH,
+    UI_END_GROUP, UI_V_GROUP, UI_H_GROUP, UI_T_GROUP
+};
+
+struct ui_elem_t {
+    ui_elem_type_t type;
+    const char *label;
+    int port;
+    float *zone;
+    void *ref;
+    float init, min, max, step;
+};
+
+class VSTUI : public UI
+{
+public:
+    bool is_instr;
+    int nelems, nports;
+    ui_elem_t *elems;
+    map< int, list<strpair> > metadata;
+    
+    VSTUI(int maxvoices = 0);
+    virtual ~VSTUI();
+    
+protected:
+    void add_elem(ui_elem_type_t type, const char *label = NULL);
+    void add_elem(ui_elem_type_t type, const char *label, float *zone);
+    void add_elem(ui_elem_type_t type, const char *label, float *zone,
+                  float init, float min, float max, float step);
+    void add_elem(ui_elem_type_t type, const char *label, float *zone,
+                  float min, float max);
+    
+    bool have_freq, have_gain, have_gate;
+    bool is_voice_ctrl(const char *label);
+    
+public:
+    virtual void addButton(const char* label, float* zone);
+    virtual void addCheckButton(const char* label, float* zone);
+    virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step);
+    virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step);
+    virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step);
+    
+    virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max);
+    virtual void addVerticalBargraph(const char* label, float* zone, float min, float max);
+    virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
+    
+    virtual void openTabBox(const char* label);
+    virtual void openHorizontalBox(const char* label);
+    virtual void openVerticalBox(const char* label);
+    virtual void closeBox();
+    
+    virtual void run();
+    
+    virtual void declare(float* zone, const char* key, const char* value);
+};
+
+VSTUI::VSTUI(int maxvoices)
+{
+    is_instr = maxvoices>0;
+    have_freq = have_gain = have_gate = false;
+    nelems = nports = 0;
+    elems = NULL;
+}
+
+VSTUI::~VSTUI()
+{
+    if (elems) free(elems);
+}
+
+void VSTUI::declare(float* zone, const char* key, const char* value)
+{
+    map< int, list<strpair> >::iterator it = metadata.find(nelems);
+    if (it != metadata.end())
+        it->second.push_back(strpair(key, value));
+    else
+        metadata[nelems] = list<strpair>(1, strpair(key, value));
+}
+
+inline void VSTUI::add_elem(ui_elem_type_t type, const char *label)
+{
+    ui_elem_t *elems1 = (ui_elem_t*)realloc(elems, (nelems+1)*sizeof(ui_elem_t));
+    if (elems1)
+        elems = elems1;
+    else
+        return;
+    elems[nelems].type = type;
+    elems[nelems].label = label;
+    elems[nelems].port = -1;
+    elems[nelems].zone = NULL;
+    elems[nelems].ref = NULL;
+    elems[nelems].init = 0.0;
+    elems[nelems].min = 0.0;
+    elems[nelems].max = 0.0;
+    elems[nelems].step = 0.0;
+    nelems++;
+}
+
+#define portno(label) (is_voice_ctrl(label)?-1:nports++)
+
+inline void VSTUI::add_elem(ui_elem_type_t type, const char *label, float *zone)
+{
+    ui_elem_t *elems1 = (ui_elem_t*)realloc(elems, (nelems+1)*sizeof(ui_elem_t));
+    if (elems1)
+        elems = elems1;
+    else
+        return;
+    elems[nelems].type = type;
+    elems[nelems].label = label;
+    elems[nelems].port = portno(label);
+    elems[nelems].zone = zone;
+    elems[nelems].ref = NULL;
+    elems[nelems].init = 0.0;
+    elems[nelems].min = 0.0;
+    elems[nelems].max = 1.0;
+    elems[nelems].step = 1.0;
+    nelems++;
+}
+
+inline void VSTUI::add_elem(ui_elem_type_t type, const char *label, float *zone, float init, float min, float max, float step)
+{
+    ui_elem_t *elems1 = (ui_elem_t*)realloc(elems, (nelems+1)*sizeof(ui_elem_t));
+    if (elems1)
+        elems = elems1;
+    else
+        return;
+    elems[nelems].type = type;
+    elems[nelems].label = label;
+    elems[nelems].port = portno(label);
+    elems[nelems].zone = zone;
+    elems[nelems].ref = NULL;
+    elems[nelems].init = init;
+    elems[nelems].min = min;
+    elems[nelems].max = max;
+    elems[nelems].step = step;
+    nelems++;
+}
+
+inline void VSTUI::add_elem(ui_elem_type_t type, const char *label, float *zone, float min, float max)
+{
+    ui_elem_t *elems1 = (ui_elem_t*)realloc(elems, (nelems+1)*sizeof(ui_elem_t));
+    if (elems1)
+        elems = elems1;
+    else
+        return;
+    elems[nelems].type = type;
+    elems[nelems].label = label;
+    elems[nelems].port = portno(label);
+    elems[nelems].zone = zone;
+    elems[nelems].ref = NULL;
+    elems[nelems].init = 0.0;
+    elems[nelems].min = min;
+    elems[nelems].max = max;
+    elems[nelems].step = 0.0;
+    nelems++;
+}
+
+inline bool VSTUI::is_voice_ctrl(const char *label)
+{
+    if (!is_instr)
+        return false;
+    else if (!have_freq && !strcmp(label, "freq"))
+        return (have_freq = true);
+    else if (!have_gain && !strcmp(label, "gain"))
+        return (have_gain = true);
+    else if (!have_gate && !strcmp(label, "gate"))
+        return (have_gate = true);
+    else
+        return false;
+}
+
+void VSTUI::addButton(const char* label, float* zone)
+{ add_elem(UI_BUTTON, label, zone); }
+void VSTUI::addCheckButton(const char* label, float* zone)
+{ add_elem(UI_CHECK_BUTTON, label, zone); }
+void VSTUI::addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step)
+{ add_elem(UI_V_SLIDER, label, zone, init, min, max, step); }
+void VSTUI::addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step)
+{ add_elem(UI_H_SLIDER, label, zone, init, min, max, step); }
+void VSTUI::addNumEntry(const char* label, float* zone, float init, float min, float max, float step)
+{ add_elem(UI_NUM_ENTRY, label, zone, init, min, max, step); }
+
+void VSTUI::addHorizontalBargraph(const char* label, float* zone, float min, float max)
+{ add_elem(UI_H_BARGRAPH, label, zone, min, max); }
+void VSTUI::addVerticalBargraph(const char* label, float* zone, float min, float max)
+{ add_elem(UI_V_BARGRAPH, label, zone, min, max); }
+
+void VSTUI::openTabBox(const char* label)
+{ add_elem(UI_T_GROUP, label); }
+void VSTUI::openHorizontalBox(const char* label)
+{ add_elem(UI_H_GROUP, label); }
+void VSTUI::openVerticalBox(const char* label)
+{ add_elem(UI_V_GROUP, label); }
+void VSTUI::closeBox()
+{ add_elem(UI_END_GROUP); }
+
+void VSTUI::run() {}
+
+//----------------------------------------------------------------------------
+//  FAUST generated signal processor
+//----------------------------------------------------------------------------
+
+<<includeclass>>
+
+//----------------------------------------------------------------------------
+//  VST interface
+//----------------------------------------------------------------------------
+
+#line 286 "faustvst.cpp"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <boost/circular_buffer.hpp>
+
+// Some boilerplate code pilfered from the mda Linux vst source code.
+#include "pluginterfaces/vst2.x/aeffectx.h"
+extern "C" {
+#define VST_EXPORT   __attribute__ ((visibility ("default")))
+    extern VST_EXPORT AEffect * VSTPluginMain(audioMasterCallback audioMaster);
+    // This is for legacy (<2.4) VST hosts which look for the 'main' entry point.
+    AEffect *main_plugin (audioMasterCallback audioMaster) asm ("main");
+#define main main_plugin
+    VST_EXPORT AEffect * main(audioMasterCallback audioMaster)
+    {
+        return VSTPluginMain(audioMaster);
+    }
+}
+
+/* Setting NVOICES at compile time overrides meta data in the Faust source. If
+ set, this must be an integer value >= 0. A nonzero value indicates an
+ instrument (VSTi) plugin with the given maximum number of voices. Use 1 for
+ a monophonic synthesizer, and 0 for a simple effect plugin. If NVOICES
+ isn't defined at compile time then the number of voices of an instrument
+ plugin can also be set with the global "nvoices" meta data key in the Faust
+ source. This setting also adds a special "polyphony" control to the plugin
+ which can be used to dynamically adjust the actual number of voices in the
+ range 1..NVOICES. */
+//#define NVOICES 16
+
+/* This enables special polyphony/tuning controls on the GUI (VSTi only). */
+#ifndef VOICE_CTRLS
+#define VOICE_CTRLS 1
+#endif
+
+/* This enables a special "tuning" control in a VSTi plugin which lets you
+ select the MTS tuning to be used for the synth. In order to use this, you
+ just drop some sysex (.syx) files with MTS octave-based tunings in 1- or
+ 2-byte format into the ~/.fautvst/tuning directory (these can be generated
+ with the author's sclsyx program, https://bitbucket.org/agraef/sclsyx).
+ The control will only be shown if any .syx files were found at startup. 0
+ selects the default tuning (standard 12-tone equal temperament), i>0 the
+ tuning in the ith sysex file (in alphabetic order). */
+#ifndef FAUST_MTS
+#define FAUST_MTS 1
+#endif
+
+/* This allows various manifest data to be generated from the corresponding
+ metadata (author, name, description, license) in the Faust source. */
+#ifndef FAUST_META
+#define FAUST_META 1
+#endif
+
+/* This enables automatic MIDI controller mapping based on the midi:ctrl
+ attributes in the Faust source. We have this enabled by default, but you
+ may have to disable it if the custom controller mapping gets in the way of
+ the automation facilities that the host provides. (But then again if the
+ host wants to do its own controller mapping then it probably won't, or at
+ least shouldn't, send us the MIDI controllers in the first place.) */
+#ifndef FAUST_MIDICC
+#define FAUST_MIDICC 1
+#endif
+
+/* This enables or disables the plugin's custom Qt GUI (see the Qt-specific
+ part at the end of this module). This is disabled by default, but enabled
+ with gui=1 in the Makefile or the -gui option of the faust2vst script. */
+#ifndef FAUST_UI
+#define FAUST_UI 0
+#endif
+
+// You can define these for various debugging output items.
+//#define DEBUG_META 1 // recognized MIDI controller metadata
+//#define DEBUG_VOICES 1 // triggering of synth voices
+//#define DEBUG_VOICE_ALLOC 1 // voice allocation
+//#define DEBUG_MIDI 1 // incoming MIDI messages
+//#define DEBUG_NOTES 1 // note messages
+//#define DEBUG_MIDICC 1 // controller messages
+//#define DEBUG_RPN 1 // RPN messages (pitch bend range, master tuning)
+//#define DEBUG_MTS 1 // MTS messages (octave/scale tuning)
+
+// Note and voice data structures.
+
+struct NoteInfo {
+    uint8_t ch;
+    int8_t note;
+};
+
+struct VoiceData {
+    // Octave tunings (offsets in semitones) per MIDI channel.
+    float tuning[16][12];
+    // Allocated voices per MIDI channel and note.
+    int8_t notes[16][128];
+    // Free and used voices.
+    int n_free, n_used;
+    boost::circular_buffer<int> free_voices;
+    boost::circular_buffer<int> used_voices;
+    NoteInfo *note_info;
+    // Voices queued for note-offs (zero-length notes).
+    set<int> queued;
+    // Last gate value during run() for each voice. We need to keep track of
+    // these so that we can force the Faust synth to retrigger a note when
+    // needed.
+    float *lastgate;
+    // Current pitch bend and pitch bend range on each MIDI channel, in semitones.
+    float bend[16], range[16];
+    // Current coarse, fine and total master tuning on each MIDI channel (tuning
+    // offset relative to A4 = 440 Hz, in semitones).
+    float coarse[16], fine[16], tune[16];
+    VoiceData(int n) : free_voices(n), used_voices(n) { }
+};
+
+#if FAUST_MTS
+
+// Helper classes to read and store MTS tunings.
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+
+#include <string>
+#include <vector>
+
+struct MTSTuning {
+    char *name; // name of the tuning
+    int len; // length of sysex data in bytes
+    unsigned char *data; // sysex data
+    MTSTuning() : name(0), len(0), data(0) {}
+    MTSTuning& operator=(const MTSTuning &t)
+    {
+        if (this == &t) return *this;
+        if (name) free(name); if (data) free(data);
+        name = 0; data = 0; len = t.len;
+        if (t.name) {
+            name = strdup(t.name); assert(name);
+        }
+        if (t.data) {
+            data = (unsigned char*)malloc(len); assert(data);
+            memcpy(data, t.data, len);
+        }
+        return *this;
+    }
+    MTSTuning(const MTSTuning& t) : name(0), len(0), data(0)
+    { *this = t; }
+    MTSTuning(const char *filename);
+    ~MTSTuning()
+    { if (name) free(name); if (data) free(data); }
+};
+
+MTSTuning::MTSTuning(const char *filename)
+{
+    FILE *fp = fopen(filename, "rb");
+    name = 0; len = 0; data = 0;
+    if (!fp) return;
+    struct stat st;
+    if (fstat(fileno(fp), &st)) return;
+    len = st.st_size;
+    data = (unsigned char*)calloc(len, 1);
+    if (!data) {
+        len = 0; fclose(fp);
+        return;
+    }
+    assert(len > 0);
+    if (fread(data, 1, len, fp) < len) {
+        free(data); len = 0; data = 0; fclose(fp);
+        return;
+    }
+    fclose(fp);
+    // Do some basic sanity checks.
+    if (data[0] != 0xf0 || data[len-1] != 0xf7 || // not a sysex message
+        (data[1] != 0x7e && data[1] != 0x7f) || data[3] != 8 || // not MTS
+        !((len == 21 && data[4] == 8) ||
+          (len == 33 && data[4] == 9))) { // no 1- or 2-byte tuning
+            free(data); len = 0; data = 0;
+            return;
+        }
+    // Name of the tuning is the basename of the file, without the trailing .syx
+    // suffix.
+    string nm = filename;
+    size_t p = nm.rfind(".syx");
+    if (p != string::npos) nm.erase(p);
+    p = nm.rfind('/');
+    if (p != string::npos) nm.erase(0, p+1);
+    name = strdup(nm.c_str());
+    assert(name);
+}
+
+struct MTSTunings {
+    vector<MTSTuning> tuning;
+    MTSTunings() {}
+    MTSTunings(const char *path);
+};
+
+static bool compareByName(const MTSTuning &a, const MTSTuning &b)
+{
+    return strcmp(a.name, b.name) < 0;
+}
+
+MTSTunings::MTSTunings(const char *path)
+{
+    DIR *dp = opendir(path);
+    if (!dp) return;
+    struct dirent *d;
+    while ((d = readdir(dp))) {
+        string nm = d->d_name;
+        if (nm.length() > 4 && nm.substr(nm.length()-4) == ".syx") {
+            string pathname = path;
+            pathname += "/";
+            pathname += nm;
+            MTSTuning t(pathname.c_str());
+            if (t.data) tuning.push_back(t);
+        }
+    }
+    closedir(dp);
+    // sort found tunings by name
+    sort(tuning.begin(), tuning.end(), compareByName);
+}
+
+#endif
+
+#if FAUST_MIDICC
+static float ctrlval(const ui_elem_t &el, uint8_t v)
+{
+    // Translate the given MIDI controller value to the range and stepsize
+    // indicated by the Faust control.
+    switch (el.type) {
+        case UI_BUTTON: case UI_CHECK_BUTTON:
+            return (float)(v>=64);
+        default:
+            /* Continuous controllers. The problem here is that the range 0..127 is
+             not symmetric. We'd like to map 64 to the center of the range
+             (max-min)/2 and at the same time retain the full control range
+             min..max. So let's just pretend that there are 128 controller values
+             and map value 127 to the max value anyway. */
+            if (v==127)
+                return el.max;
+            else
+                // XXXFIXME: We might want to add proper quantization according to
+                // el.step here.
+                return el.min+(el.max-el.min)*v/128;
+    }
+}
+#endif
+
+/***************************************************************************/
+
+/* Polyphonic Faust plugin data structure. XXXTODO: At present this is just a
+ big struct which exposes all requisite data. Some more work is needed to
+ make the interface a bit more abstract and properly encapsulate the
+ internal data structures, so that implementation details can be changed
+ more easily. */
+
+struct VSTPlugin {
+    const int maxvoices;        // maximum number of voices (zero if not an instrument)
+    const int ndsps;            // number of dsp instances (1 if maxvoices==0)
+    int nvoices;                // current number of voices (<= maxvoices)
+    bool active;                // activation status
+    bool modified;              // keep track of modified controls
+    int rate;                   // sampling rate
+    mydsp **dsp;                // the dsps
+    VSTUI **ui;                 // their Faust interface descriptions
+    int n_in, n_out;            // number of input and output control ports
+    int poly, tuning;           // polyphony and tuning ports
+    int *ctrls;                 // Faust ui elements (indices into ui->elems)
+    float *ports;               // port data (plugin-side control values)
+    float *portvals;            // cached port data from the last run
+    float *midivals[16];        // per-channel midi data
+    int *inctrls, *outctrls;    // indices for active and passive controls
+    int freq, gain, gate;       // indices of voice controls
+    const char **units;         // unit names (control meta data)
+    unsigned n_samples;         // current block size
+    float **outbuf;             // audio buffers for mixing down the voices
+    float **inbuf;              // dummy input buffer used for retriggering notes
+    std::map<uint8_t,int> ctrlmap; // MIDI controller map (control meta data)
+    // Current RPN MSB and LSB numbers, as set with controllers 101 and 100.
+    uint8_t rpn_msb[16], rpn_lsb[16];
+    // Current data entry MSB and LSB numbers, as set with controllers 6 and 38.
+    uint8_t data_msb[16], data_lsb[16];
+    // Synth voice data (instruments only).
+    VoiceData *vd;
+    
+    // Static methods. These all use static data so they can be invoked before
+    // instantiating a plugin.
+    
+    // Global meta data (dsp name, author, etc.).
+    static MyMeta *meta;
+    static void init_meta()
+    {
+        if (!meta && (meta = new MyMeta)) {
+            // We allocate the temporary dsp object on the heap here, to prevent
+            // large dsp objects from running out of stack in environments where
+            // stack space is precious (e.g., Reaper). Note that if any of these
+            // allocations fail then no meta data will be available, but at least we
+            // won't make the host crash and burn.
+            mydsp* tmp_dsp = new mydsp();
+            if (tmp_dsp) {
+                tmp_dsp->metadata(meta);
+                delete tmp_dsp;
+            }
+        }
+    }
+    static const char *meta_get(const char *key, const char *deflt)
+    {
+        init_meta();
+        return meta?meta->get(key, deflt):deflt;
+    }
+    
+    static const char *pluginName()
+    {
+        return meta_get("name", "mydsp");
+    }
+    
+    static const char *pluginAuthor()
+    {
+        return meta_get("author", "");
+    }
+    
+    static const char *pluginDescription()
+    {
+        return meta_get("description", "");
+    }
+    
+    static const char *pluginVersion()
+    {
+        return meta_get("version", "0.0");
+    }
+    
+    // Load a collection of sysex files with MTS tunings in ~/.faust/tuning.
+    static int n_tunings;
+#if FAUST_MTS
+    static MTSTunings *mts;
+    
+    static MTSTunings *load_sysex_data()
+    {
+        if (!mts) {
+            string mts_path;
+            // Look for FAUST_HOME. If that isn't set, try $HOME/.faust. If HOME
+            // isn't set either, just assume a .faust subdir of the cwd.
+            const char *home = getenv("FAUST_HOME");
+            if (home)
+                mts_path = home;
+            else {
+                home = getenv("HOME");
+                if (home) {
+                    mts_path = home;
+                    mts_path += "/.faust";
+                } else
+                    mts_path = ".faust";
+            }
+            // MTS tunings are looked for in this subdir.
+            mts_path += "/tuning";
+            mts = new MTSTunings(mts_path.c_str());
+#ifdef __APPLE__
+            if (!mts || mts->tuning.size() == 0) {
+                // Also check ~/Library/Faust/Tuning on the Mac.
+                home = getenv("HOME");
+                if (home) {
+                    if (mts) delete mts;
+                    mts_path = home;
+                    mts_path += "/Library/Faust/Tuning";
+                    mts = new MTSTunings(mts_path.c_str());
+                }
+            }
+#endif
+            n_tunings = mts->tuning.size();
+        }
+        return mts;
+    }
+#endif
+    
+    // The number of voices of an instrument plugin. We get this information
+    // from the global meta data (nvoices key) of the dsp module if present, and
+    // you can also override this setting at compile time by defining the
+    // NVOICES macro. If neither is defined or the value is zero then the plugin
+    // becomes a simple audio effect instead.
+    static int numVoices()
+    {
+        bool midi_sync = false;
+        int nvoices = 0;
+        mydsp* tmp_dsp = new mydsp();
+        MidiMeta::analyse(tmp_dsp, midi_sync, nvoices);
+        delete tmp_dsp;
+        return nvoices;
+    }
+    
+    // The number of controls of the dsp. Some plugin interfaces need that
+    // information beforehand, so we create a dummy instance of the UI data to
+    // retrieve it. For instrument plugins, we also reserve extra ports for the
+    // polyphony and tuning controls, if applicable.
+    static int numControls()
+    {
+        const int num_voices = numVoices();
+        // Allocate temporary dsp object on the heap (see comments under init_meta
+        // for explanation).
+        mydsp *dsp = new mydsp();
+        if (!dsp) return 0;
+        VSTUI ui(num_voices);
+        dsp->buildUserInterface(&ui);
+        delete dsp;
+        // reserve one extra port for the polyphony control (instruments only)
+        int num_extra = (num_voices>0);
+#if FAUST_MTS
+        // likewise for the tuning control
+        if (num_voices>0 && load_sysex_data())
+            num_extra += (mts->tuning.size()>0);
+#endif
+        return ui.nports+num_extra;
+    }
+    
+    // Instance methods.
+    
+    VSTPlugin(const int num_voices, const int sr)
+    : maxvoices(num_voices), ndsps(num_voices<=0?1:num_voices),
+    vd(num_voices>0?new VoiceData(num_voices):0)
+    {
+        // Initialize static data.
+        init_meta();
+#if FAUST_MTS
+        // Synth: load tuning sysex data if present.
+        if (num_voices>0) load_sysex_data();
+#endif
+        // Allocate data structures and set some reasonable defaults.
+        dsp = (mydsp**)calloc(ndsps, sizeof(mydsp*));
+        ui = (VSTUI**)calloc(ndsps, sizeof(VSTUI*));
+        assert(dsp && ui);
+        if (vd) {
+            vd->note_info = (NoteInfo*)calloc(ndsps, sizeof(NoteInfo));
+            vd->lastgate = (float*)calloc(ndsps, sizeof(float));
+            assert(vd->note_info && vd->lastgate);
+        }
+        active = modified = false;
+        rate = sr;
+        nvoices = maxvoices;
+        n_in = n_out = 0;
+        poly = maxvoices/2;
+        tuning = 0;
+        freq = gain = gate = -1;
+        for (int i = 0; i < 16; i++) {
+            rpn_msb[i] = rpn_lsb[i] = 0x7f;
+            data_msb[i] = data_lsb[i] = 0;
+        }
+        if (vd) {
+            vd->n_free = maxvoices;
+            for (int i = 0; i < maxvoices; i++) {
+                vd->free_voices.push_back(i);
+                vd->lastgate[i] = 0.0f;
+            }
+            for (int i = 0; i < 16; i++) {
+                vd->bend[i] = 0.0f;
+                vd->range[i] = 2.0f;
+                vd->coarse[i] = vd->fine[i] = vd->tune[i] = 0.0f;
+                for (int j = 0; j < 12; j++)
+                    vd->tuning[i][j] = 0.0f;
+            }
+            vd->n_used = 0;
+            memset(vd->notes, 0xff, sizeof(vd->notes));
+        }
+        n_samples = 0;
+        ctrls = inctrls = outctrls = NULL;
+        inbuf = outbuf = NULL;
+        ports = portvals = NULL;
+        units = NULL;
+        memset(midivals, 0, sizeof(midivals));
+        // Initialize the Faust DSPs.
+        for (int i = 0; i < ndsps; i++) {
+            dsp[i] = new mydsp();
+            ui[i] = new VSTUI(num_voices);
+            dsp[i]->init(rate);
+            dsp[i]->buildUserInterface(ui[i]);
+        }
+        // The ports are numbered as follows: 0..k-1 are the control ports, then
+        // come the n audio input ports, then the m audio output ports, and
+        // finally the midi input port and the polyphony and tuning controls. This
+        // mimics the port layout of faust-lv2, but should work fine with other
+        // kinds of plugin architectures as well.
+        int k = ui[0]->nports, p = 0, q = 0;
+        int n = dsp[0]->getNumInputs(), m = dsp[0]->getNumOutputs();
+        // Allocate tables for the built-in control elements and their ports.
+        ctrls = (int*)calloc(k, sizeof(int));
+        inctrls = (int*)calloc(k, sizeof(int));
+        outctrls = (int*)calloc(k, sizeof(int));
+        ports = (float*)calloc(k, sizeof(float));
+        portvals = (float*)calloc(k, sizeof(float));
+        units = (const char**)calloc(k, sizeof(const char*));
+        assert(k == 0 || (ctrls && inctrls && outctrls &&
+                          ports && portvals && units));
+        for (int ch = 0; ch < 16; ch++) {
+            midivals[ch] = (float*)calloc(k, sizeof(float));
+            assert(k == 0 || midivals[ch]);
+        }
+        // Scan the Faust UI for active and passive controls which become the
+        // input and output control ports of the plugin, respectively.
+        for (int i = 0, j = 0; i < ui[0]->nelems; i++) {
+            const char *unit = NULL;
+            switch (ui[0]->elems[i].type) {
+                case UI_T_GROUP: case UI_H_GROUP: case UI_V_GROUP: case UI_END_GROUP:
+                    // control groups (ignored right now)
+                    break;
+                case UI_H_BARGRAPH: case UI_V_BARGRAPH:
+                    // passive controls (output ports)
+                    ctrls[j++] = i;
+                    outctrls[q++] = i;
+                {
+                    std::map< int, list<strpair> >::iterator it =
+                    ui[0]->metadata.find(i);
+                    if (it != ui[0]->metadata.end()) {
+                        for (std::list<strpair>::iterator jt = it->second.begin();
+                             jt != it->second.end(); jt++) {
+                            const char *key = jt->first, *val = jt->second;
+#if DEBUG_META
+                            fprintf(stderr, "ctrl '%s' meta: '%s' -> '%s'\n",
+                                    ui[0]->elems[i].label, key, val);
+#endif
+                            if (strcmp(key, "unit") == 0)
+                                unit = val;
+                        }
+                    }
+                    int p = ui[0]->elems[i].port;
+                    units[p] = unit;
+                }
+                    break;
+                default:
+                    // active controls (input ports)
+                    if (maxvoices == 0)
+                        goto noinstr;
+                    else if (freq == -1 &&
+                             !strcmp(ui[0]->elems[i].label, "freq"))
+                        freq = i;
+                    else if (gain == -1 &&
+                             !strcmp(ui[0]->elems[i].label, "gain"))
+                        gain = i;
+                    else if (gate == -1 &&
+                             !strcmp(ui[0]->elems[i].label, "gate"))
+                        gate = i;
+                    else {
+                    noinstr:
+                        std::map< int, list<strpair> >::iterator it =
+                        ui[0]->metadata.find(i);
+                        if (it != ui[0]->metadata.end()) {
+                            // Scan for controller mappings and other control meta data.
+                            for (std::list<strpair>::iterator jt = it->second.begin();
+                                 jt != it->second.end(); jt++) {
+                                const char *key = jt->first, *val = jt->second;
+#if DEBUG_META
+                                fprintf(stderr, "ctrl '%s' meta: '%s' -> '%s'\n",
+                                        ui[0]->elems[i].label, key, val);
+#endif
+                                if (strcmp(key, "unit") == 0) {
+                                    unit = val;
+#if FAUST_MIDICC
+                                } else if (strcmp(key, "midi") == 0) {
+                                    unsigned num;
+                                    if (sscanf(val, "ctrl %u", &num) < 1) continue;
+#if 0 // enable this to get feedback about controller assignments
+                                    const char *dsp_name = pluginName();
+                                    fprintf(stderr, "%s: cc %d -> %s\n", dsp_name, num,
+                                            ui[0]->elems[i].label);
+#endif
+                                    ctrlmap.insert(std::pair<uint8_t,int>(num, p));
+#endif
+                                }
+                            }
+                        }
+                        ctrls[j++] = i;
+                        inctrls[p++] = i;
+                        int p = ui[0]->elems[i].port;
+                        float val = ui[0]->elems[i].init;
+                        assert(p>=0);
+                        portvals[p] = ports[p] = val;
+                        units[p] = unit;
+                        for (int ch = 0; ch < 16; ch++)
+                            midivals[ch][p] = val;
+                    }
+                    break;
+            }
+        }
+        // Realloc the inctrls and outctrls vectors to their appropriate sizes.
+        inctrls = (int*)realloc(inctrls, p*sizeof(int));
+        assert(p == 0 || inctrls);
+        outctrls = (int*)realloc(outctrls, q*sizeof(int));
+        assert(q == 0 || outctrls);
+        n_in = p; n_out = q;
+        if (maxvoices > 0) {
+            // Initialize the mixdown buffer.
+            outbuf = (float**)calloc(m, sizeof(float*));
+            assert(m == 0 || outbuf);
+            // We start out with a blocksize of 512 samples here. Hopefully this is
+            // enough for most realtime hosts so that we can avoid reallocations
+            // later when we know what the actual blocksize is.
+            n_samples = 512;
+            for (int i = 0; i < m; i++) {
+                outbuf[i] = (float*)malloc(n_samples*sizeof(float));
+                assert(outbuf[i]);
+            }
+            // Initialize a 1-sample dummy input buffer used for retriggering notes.
+            inbuf = (float**)calloc(n, sizeof(float*));
+            assert(n == 0 || inbuf);
+            for (int i = 0; i < m; i++) {
+                inbuf[i] = (float*)malloc(sizeof(float));
+                assert(inbuf[i]);
+                *inbuf[i] = 0.0f;
+            }
+        }
+    }
+    
+    ~VSTPlugin()
+    {
+        const int n = dsp[0]->getNumInputs();
+        const int m = dsp[0]->getNumOutputs();
+        for (int i = 0; i < ndsps; i++) {
+            delete dsp[i];
+            delete ui[i];
+        }
+        free(ctrls);
+        free(inctrls);
+        free(outctrls);
+        free(ports);
+        free(portvals);
+        free(units);
+        for (int ch = 0; ch < 16; ch++)
+            free(midivals[ch]);
+        if (inbuf) {
+            for (int i = 0; i < n; i++)
+                free(inbuf[i]);
+            free(inbuf);
+        }
+        if (outbuf) {
+            for (int i = 0; i < m; i++)
+                free(outbuf[i]);
+            free(outbuf);
+        }
+        free(dsp);
+        free(ui);
+        if (vd) {
+            free(vd->note_info);
+            free(vd->lastgate);
+            delete vd;
+        }
+    }
+    
+    // Voice allocation.
+    
+#if DEBUG_VOICE_ALLOC
+    void print_voices(const char *msg)
+    {
+        fprintf(stderr, "%s: notes =", msg);
+        for (uint8_t ch = 0; ch < 16; ch++)
+            for (int note = 0; note < 128; note++)
+                if (vd->notes[ch][note] >= 0)
+                    fprintf(stderr, " [%d] %d(#%d)", ch, note, vd->notes[ch][note]);
+        fprintf(stderr, "\nqueued (%d):", vd->queued.size());
+        for (int i = 0; i < nvoices; i++)
+            if (vd->queued.find(i) != vd->queued.end()) fprintf(stderr, " #%d", i);
+        fprintf(stderr, "\nused (%d):", vd->n_used);
+        for (boost::circular_buffer<int>::iterator it = vd->used_voices.begin();
+             it != vd->used_voices.end(); it++)
+            fprintf(stderr, " #%d->%d", *it, vd->note_info[*it].note);
+        fprintf(stderr, "\nfree (%d):", vd->n_free);
+        for (boost::circular_buffer<int>::iterator it = vd->free_voices.begin();
+             it != vd->free_voices.end(); it++)
+            fprintf(stderr, " #%d", *it);
+        fprintf(stderr, "\n");
+    }
+#endif
+    
+    int alloc_voice(uint8_t ch, int8_t note, int8_t vel)
+    {
+        int i = vd->notes[ch][note];
+        if (i >= 0) {
+            // note already playing on same channel, retrigger it
+            voice_off(i);
+            voice_on(i, note, vel, ch);
+            // move this voice to the end of the used list
+            for (boost::circular_buffer<int>::iterator it =
+                 vd->used_voices.begin();
+                 it != vd->used_voices.end(); it++) {
+                if (*it == i) {
+                    vd->used_voices.erase(it);
+                    vd->used_voices.push_back(i);
+                    break;
+                }
+            }
+#if DEBUG_VOICE_ALLOC
+            print_voices("retrigger");
+#endif
+            return i;
+        } else if (vd->n_free > 0) {
+            // take voice from free list
+            int i = vd->free_voices.front();
+            vd->free_voices.pop_front();
+            vd->n_free--;
+            vd->used_voices.push_back(i);
+            vd->note_info[i].ch = ch;
+            vd->note_info[i].note = note;
+            vd->n_used++;
+            voice_on(i, note, vel, ch);
+            vd->notes[ch][note] = i;
+#if DEBUG_VOICE_ALLOC
+            print_voices("alloc");
+#endif
+            return i;
+        } else {
+            // steal a voice
+            assert(vd->n_used > 0);
+            // FIXME: Maybe we should look for the oldest note on the *current*
+            // channel here, but this is faster.
+            int i = vd->used_voices.front();
+            int oldch = vd->note_info[i].ch;
+            int oldnote = vd->note_info[i].note;
+            voice_off(i);
+            vd->notes[oldch][oldnote] = -1;
+            vd->queued.erase(i);
+            vd->used_voices.pop_front();
+            vd->used_voices.push_back(i);
+            vd->note_info[i].ch = ch;
+            vd->note_info[i].note = note;
+            voice_on(i, note, vel, ch);
+            vd->notes[ch][note] = i;
+#if DEBUG_VOICE_ALLOC
+            print_voices("steal");
+#endif
+            return i;
+        }
+    }
+    
+    int dealloc_voice(uint8_t ch, int8_t note, int8_t vel)
+    {
+        int i = vd->notes[ch][note];
+        if (i >= 0) {
+            if (vd->lastgate[i] == 0.0f && gate >= 0) {
+                // zero-length note, queued for later
+                vd->queued.insert(i);
+                vd->notes[ch][note] = -1;
+#if DEBUG_VOICE_ALLOC
+                print_voices("dealloc (queued)");
+#endif
+                return i;
+            }
+            assert(vd->n_free < nvoices);
+            vd->free_voices.push_back(i);
+            vd->n_free++;
+            voice_off(i);
+            vd->notes[ch][note] = -1;
+            // erase this voice from the used list
+            for (boost::circular_buffer<int>::iterator it =
+                 vd->used_voices.begin();
+                 it != vd->used_voices.end(); it++) {
+                if (*it == i) {
+                    vd->used_voices.erase(it);
+                    vd->n_used--;
+                    break;
+                }
+            }
+#if DEBUG_VOICE_ALLOC
+            print_voices("dealloc");
+#endif
+            return i;
+        }
+        return -1;
+    }
+    
+    
+    float midicps(int8_t note, uint8_t chan)
+    {
+        float pitch = note + vd->tune[chan] +
+        vd->tuning[chan][note%12] + vd->bend[chan];
+        return 440.0*pow(2, (pitch-69.0)/12.0);
+    }
+    
+    void voice_on(int i, int8_t note, int8_t vel, uint8_t ch)
+    {
+        if (vd->lastgate[i] == 1.0f && gate >= 0) {
+            // Make sure that the synth sees the 0.0f gate so that the voice is
+            // properly retriggered.
+            *ui[i]->elems[gate].zone = 0.0f;
+            dsp[i]->compute(1, inbuf, outbuf);
+        }
+#if DEBUG_VOICES
+        fprintf(stderr, "voice on: %d %d (%g Hz) %d (%g)\n", i,
+                note, midicps(note, ch), vel, vel/127.0);
+#endif
+        if (freq >= 0)
+            *ui[i]->elems[freq].zone = midicps(note, ch);
+        if (gate >= 0)
+            *ui[i]->elems[gate].zone = 1.0f;
+        if (gain >= 0)
+            *ui[i]->elems[gain].zone = vel/127.0;
+        // reinitialize the per-channel control data for this voice
+        for (int idx = 0; idx < n_in; idx++) {
+            int j = inctrls[idx], k = ui[0]->elems[j].port;
+            *ui[i]->elems[j].zone = midivals[ch][k];
+        }
+    }
+    
+    void voice_off(int i)
+    {
+#if DEBUG_VOICES
+        fprintf(stderr, "voice off: %d\n", i);
+#endif
+        if (gate >= 0)
+            *ui[i]->elems[gate].zone = 0.0f;
+    }
+    
+    void update_voices(uint8_t chan)
+    {
+        // update running voices on the given channel after tuning or pitch bend
+        // changes
+        for (boost::circular_buffer<int>::iterator it =
+             vd->used_voices.begin();
+             it != vd->used_voices.end(); it++) {
+            int i = *it;
+            if (vd->note_info[i].ch == chan && freq >= 0) {
+                int note = vd->note_info[i].note;
+                *ui[i]->elems[freq].zone = midicps(note, chan);
+            }
+        }
+    }
+    
+    void all_notes_off()
+    {
+        for (int i = 0; i < nvoices; i++)
+            voice_off(i);
+        for (int i = 0; i < 16; i++)
+            vd->bend[i] = 0.0f;
+        memset(vd->notes, 0xff, sizeof(vd->notes));
+        vd->free_voices.clear();
+        vd->n_free = nvoices;
+        for (int i = 0; i < nvoices; i++)
+            vd->free_voices.push_back(i);
+        vd->queued.clear();
+        vd->used_voices.clear();
+        vd->n_used = 0;
+    }
+    
+    void all_notes_off(uint8_t chan)
+    {
+        for (boost::circular_buffer<int>::iterator it =
+             vd->used_voices.begin();
+             it != vd->used_voices.end(); ) {
+            int i = *it;
+            if (vd->note_info[i].ch == chan) {
+                assert(vd->n_free < nvoices);
+                vd->free_voices.push_back(i);
+                vd->n_free++;
+                voice_off(i);
+                vd->notes[vd->note_info[i].ch][vd->note_info[i].note] = -1;
+                vd->queued.erase(i);
+                // erase this voice from the used list
+                it = vd->used_voices.erase(it);
+                vd->n_used--;
+#if DEBUG_VOICE_ALLOC
+                print_voices("dealloc (all-notes-off)");
+#endif
+            } else
+                it++;
+        }
+        vd->bend[chan] = 0.0f;
+    }
+    
+    void queued_notes_off()
+    {
+        if (vd->queued.empty()) return;
+        for (int i = 0; i < nvoices; i++)
+            if (vd->queued.find(i) != vd->queued.end()) {
+                assert(vd->n_free < nvoices);
+                vd->free_voices.push_back(i);
+                vd->n_free++;
+                voice_off(i);
+                vd->notes[vd->note_info[i].ch][vd->note_info[i].note] = -1;
+                vd->queued.erase(i);
+                // erase this voice from the used list
+                for (boost::circular_buffer<int>::iterator it =
+                     vd->used_voices.begin();
+                     it != vd->used_voices.end(); it++) {
+                    if (*it == i) {
+                        vd->used_voices.erase(it);
+                        vd->n_used--;
+                        break;
+                    }
+                }
+#if DEBUG_VOICE_ALLOC
+                print_voices("dealloc (unqueued)");
+#endif
+            }
+    }
+    
+    // Plugin activation status. suspend() deactivates a plugin (disables audio
+    // processing), resume() reactivates it. Also, set_rate() changes the sample
+    // rate. Note that the audio and MIDI process functions (see below) can
+    // still be called in deactivated state, but this is optional. The plugin
+    // tries to do some reasonable processing in either case, no matter whether
+    // the host plugin architecture actually executes callbacks in suspended
+    // state or not.
+    
+    void suspend()
+    {
+        active = false;
+        if (maxvoices > 0) all_notes_off();
+    }
+    
+    void resume()
+    {
+        for (int i = 0; i < ndsps; i++)
+            dsp[i]->init(rate);
+        for (int i = 0, j = 0; i < ui[0]->nelems; i++) {
+            int p = ui[0]->elems[i].port;
+            if (p >= 0) {
+                float val = ui[0]->elems[i].init;
+                portvals[p] = val;
+            }
+        }
+        active = true;
+    }
+    
+    void set_rate(int sr)
+    {
+        rate = sr;
+        for (int i = 0; i < ndsps; i++)
+            dsp[i]->init(rate);
+    }
+    
+    // Audio and MIDI process functions. The plugin should run these in the
+    // appropriate real-time callbacks.
+    
+    void process_audio(int blocksz, float **inputs, float **outputs)
+    {
+        int n = dsp[0]->getNumInputs(), m = dsp[0]->getNumOutputs();
+        AVOIDDENORMALS;
+        modified = false;
+        if (maxvoices > 0) queued_notes_off();
+        if (!active) {
+            // Depending on the plugin architecture, this code might never be
+            // invoked, since the plugin is deactivitated at this point. But let's
+            // do something reasonable here anyway.
+            if (n == m) {
+                // copy inputs to outputs
+                for (int i = 0; i < m; i++)
+                    for (unsigned j = 0; j < blocksz; j++)
+                        outputs[i][j] = inputs[i][j];
+            } else {
+                // silence
+                for (int i = 0; i < m; i++)
+                    for (unsigned j = 0; j < blocksz; j++)
+                        outputs[i][j] = 0.0f;
+            }
+            return;
+        }
+        // Handle changes in the polyphony control.
+        if (nvoices != poly && poly > 0 && poly <= maxvoices) {
+            modified = true;
+            for (int i = 0; i < nvoices; i++)
+                voice_off(i);
+            nvoices = poly;
+            // Reset the voice allocation.
+            memset(vd->notes, 0xff, sizeof(vd->notes));
+            vd->free_voices.clear();
+            vd->n_free = nvoices;
+            for (int i = 0; i < nvoices; i++)
+                vd->free_voices.push_back(i);
+            vd->used_voices.clear();
+            vd->n_used = 0;
+        } else
+            poly = nvoices;
+        // Only update the controls (of all voices simultaneously) if a port value
+        // actually changed. This is necessary to allow MIDI controllers to modify
+        // the values for individual MIDI channels (see processEvents below). Also
+        // note that this will be done *after* processing the MIDI controller data
+        // for the current audio block, so manual inputs can still override these.
+        bool is_instr = maxvoices > 0;
+        for (int i = 0; i < n_in; i++) {
+            int j = inctrls[i], k = ui[0]->elems[j].port;
+            float &oldval = portvals[k], newval = ports[k];
+            if (newval != oldval) {
+                modified = true;
+                if (is_instr) {
+                    // instrument: update running voices
+                    for (boost::circular_buffer<int>::iterator it =
+                         vd->used_voices.begin();
+                         it != vd->used_voices.end(); it++) {
+                        int i = *it;
+                        *ui[i]->elems[j].zone = newval;
+                    }
+                } else {
+                    // simple effect: here we only have a single dsp instance
+                    *ui[0]->elems[j].zone = newval;
+                }
+                // also update the MIDI controller data for all channels (manual
+                // control input is always omni)
+                for (int ch = 0; ch < 16; ch++)
+                    midivals[ch][k] = newval;
+                // record the new value
+                oldval = newval;
+            }
+        }
+        // Initialize the output buffers.
+        if (n_samples < blocksz) {
+            // We need to enlarge the buffers. We're not officially allowed to do
+            // this here (presumably in the realtime thread), but since we usually
+            // don't know the hosts's block size beforehand, there's really nothing
+            // else that we can do. Let's just hope that doing this once suffices,
+            // then hopefully noone will notice.
+            if (outbuf) {
+                for (int i = 0; i < m; i++) {
+                    outbuf[i] = (float*)realloc(outbuf[i],
+                                                blocksz*sizeof(float));
+                    assert(outbuf[i]);
+                }
+            }
+            n_samples = blocksz;
+        }
+        if (outbuf) {
+            // Polyphonic instrument: Mix the voices down to one signal.
+            for (int i = 0; i < m; i++)
+                for (unsigned j = 0; j < blocksz; j++)
+                    outputs[i][j] = 0.0f;
+            for (int l = 0; l < nvoices; l++) {
+                // Let Faust do all the hard work.
+                dsp[l]->compute(blocksz, inputs, outbuf);
+                for (int i = 0; i < m; i++)
+                    for (unsigned j = 0; j < blocksz; j++)
+                        outputs[i][j] += outbuf[i][j];
+            }
+        } else {
+            // Simple effect: We can write directly to the output buffer.
+            dsp[0]->compute(blocksz, inputs, outputs);
+        }
+        // Finally grab the passive controls and write them back to the
+        // corresponding control ports. NOTE: Depending on the plugin
+        // architecture, this might require a host call to get the control GUI
+        // updated in real-time (if the host supports this at all).
+        // FIXME: It's not clear how to aggregate the data of the different
+        // voices. We compute the maximum of each control for now.
+        if (n_out > 0) modified = true;
+        for (int i = 0; i < n_out; i++) {
+            int j = outctrls[i], k = ui[0]->elems[j].port;
+            float *z = ui[0]->elems[j].zone;
+            ports[k] = *z;
+            for (int l = 1; l < nvoices; l++) {
+                float *z = ui[l]->elems[j].zone;
+                if (ports[k] < *z)
+                    ports[k] = *z;
+            }
+        }
+        // Keep track of the last gates set for each voice, so that voices can be
+        // forcibly retriggered if needed.
+        if (gate >= 0)
+            for (int i = 0; i < nvoices; i++)
+                vd->lastgate[i] =
+                *ui[i]->elems[gate].zone;
+    }
+    
+    // This processes just a single MIDI message, so to process an entire series
+    // of MIDI events you'll have to loop over the event data in the plugin's
+    // MIDI callback. XXXTODO: Sample-accurate processing of MIDI events.
+    
+    void process_midi(unsigned char *data, int sz)
+    {
+#if DEBUG_MIDI
+        fprintf(stderr, "midi ev (%d bytes):", sz);
+        for (int i = 0; i < sz; i++)
+            fprintf(stderr, " 0x%0x", data[i]);
+        fprintf(stderr, "\n");
+#endif
+        uint8_t status = data[0] & 0xf0, chan = data[0] & 0x0f;
+        bool is_instr = maxvoices > 0;
+        switch (status) {
+            case 0x90: {
+                if (!is_instr) break;
+                // note on
+#if DEBUG_NOTES
+                fprintf(stderr, "note-on  chan %d, note %d, vel %d\n", chan+1,
+                        data[1], data[2]);
+#endif
+                if (data[2] == 0) goto note_off;
+                alloc_voice(chan, data[1], data[2]);
+                break;
+            }
+            case 0x80: {
+                if (!is_instr) break;
+                // note off
+#if DEBUG_NOTES
+                fprintf(stderr, "note-off chan %d, note %d, vel %d\n", chan+1,
+                        data[1], data[2]);
+#endif
+            note_off:
+                dealloc_voice(chan, data[1], data[2]);
+                break;
+            }
+            case 0xe0: {
+                if (!is_instr) break;
+                // pitch bend
+                // data[1] is LSB, data[2] MSB, range is 0..0x3fff (which maps to
+                // -2..+2 semitones by default), center point is 0x2000 = 8192
+                int val = data[1] | (data[2]<<7);
+                vd->bend[chan] =
+                (val-0x2000)/8192.0f*vd->range[chan];
+#if DEBUG_MIDICC
+                fprintf(stderr, "pitch-bend (chan %d): %g cent\n", chan+1,
+                        vd->bend[chan]*100.0);
+#endif
+                update_voices(chan);
+                break;
+            }
+            case 0xb0: {
+                // controller change
+                switch (data[1]) {
+                    case 120: case 123:
+                        if (!is_instr) break;
+                        // all-sound-off and all-notes-off controllers (these are treated
+                        // the same in the current implementation)
+                        all_notes_off(chan);
+#if DEBUG_MIDICC
+                        fprintf(stderr, "all-notes-off (chan %d)\n", chan+1);
+#endif
+                        break;
+                    case 121:
+                        // all-controllers-off (in the current implementation, this just
+                        // resets the RPN-related controllers)
+                        data_msb[chan] = data_lsb[chan] = 0;
+                        rpn_msb[chan] = rpn_lsb[chan] = 0x7f;
+#if DEBUG_MIDICC
+                        fprintf(stderr, "all-controllers-off (chan %d)\n", chan+1);
+#endif
+                        break;
+                    case 101: case 100:
+                        // RPN MSB/LSB
+                        if (data[1] == 101)
+                            rpn_msb[chan] = data[2];
+                        else
+                            rpn_lsb[chan] = data[2];
+                        break;
+                    case 6: case 38:
+                        // data entry coarse/fine
+                        if (data[1] == 6)
+                            data_msb[chan] = data[2];
+                        else
+                            data_lsb[chan] = data[2];
+                        goto rpn;
+                    case 96: case 97:
+                        // data increment/decrement
+                        /* NOTE: The specification of these controllers is a complete
+                         mess. Originally, the MIDI specification didn't have anything
+                         to say about their exact behaviour at all. Nowadays, the
+                         behaviour depends on which RPN or NRPN is being modified, which
+                         is also rather confusing. Fortunately, as we only handle RPNs
+                         0..2 here anyway, it's sufficient to assume the MSB for RPN #2
+                         (channel coarse tuning) and the LSB otherwise. */
+                        if (rpn_msb[chan] == 0 && rpn_lsb[chan] == 2) {
+                            // modify the MSB
+                            if (data[1] == 96 && data_msb[chan] < 0x7f)
+                                data_msb[chan]++;
+                            else if (data[1] == 97 && data_msb[chan] > 0)
+                                data_msb[chan]--;
+                        } else {
+                            // modify the LSB
+                            if (data[1] == 96 && data_lsb[chan] < 0x7f)
+                                data_lsb[chan]++;
+                            else if (data[1] == 97 && data_lsb[chan] > 0)
+                                data_lsb[chan]--;
+                        }
+                    rpn:
+                        if (!is_instr) break;
+                        if (rpn_msb[chan] == 0) {
+                            switch (rpn_lsb[chan]) {
+                                case 0:
+                                    // pitch bend range, coarse value is in semitones, fine value
+                                    // in cents
+                                    vd->range[chan] = data_msb[chan]+
+                                    data_lsb[chan]/100.0;
+#if DEBUG_RPN
+                                    fprintf(stderr, "pitch-bend-range (chan %d): %g cent\n", chan+1,
+                                            vd->range[chan]*100.0);
+#endif
+                                    break;
+                                case 1:
+                                {
+                                    // channel fine tuning (14 bit value, range -100..+100 cents)
+                                    int value = (data_msb[chan]<<7) |
+                                    data_lsb[chan];
+                                    vd->fine[chan] = (value-8192)/8192.0f;
+                                }
+                                    goto master_tune;
+                                case 2:
+                                    // channel coarse tuning (only msb is used, range -64..+63
+                                    // semitones)
+                                    vd->coarse[chan] = data_msb[chan]-64;
+                                master_tune:
+                                    vd->tune[chan] = vd->coarse[chan]+
+                                    vd->fine[chan];
+#if DEBUG_RPN
+                                    fprintf(stderr, "master-tuning (chan %d): %g cent\n", chan+1,
+                                            vd->tune[chan]*100.0);
+#endif
+                                    update_voices(chan);
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                        break;
+                    default: {
+#if FAUST_MIDICC
+                        // interpret all other controller changes according to the MIDI
+                        // controller map defined in the Faust plugin itself
+                        std::map<uint8_t,int>::iterator it = ctrlmap.find(data[1]);
+                        if (it != ctrlmap.end()) {
+                            // defined MIDI controller
+                            int j = inctrls[it->second],
+                            k = ui[0]->elems[j].port;
+                            float val = ctrlval(ui[0]->elems[j], data[2]);
+                            midivals[chan][k] = val;
+                            if (is_instr) {
+                                // instrument: update running voices on this channel
+                                for (boost::circular_buffer<int>::iterator it =
+                                     vd->used_voices.begin();
+                                     it != vd->used_voices.end(); it++) {
+                                    int i = *it;
+                                    if (vd->note_info[i].ch == chan)
+                                        *ui[i]->elems[j].zone = val;
+                                }
+                            } else {
+                                // simple effect: here we only have a single dsp instance and
+                                // we're operating in omni mode, so we just update the control no
+                                // matter what the midi channel is
+                                *ui[0]->elems[j].zone = val;
+                            }
+#if DEBUG_MIDICC
+                            fprintf(stderr, "ctrl-change chan %d, ctrl %d, val %d\n", chan+1,
+                                    data[1], data[2]);
+#endif
+                        }
+#endif
+                        break;
+                    }
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    
+    // Process an MTS sysex message and update the control values accordingly.
+    
+    void process_sysex(uint8_t *data, int sz)
+    {
+        if (!data || sz < 2) return;
+#if DEBUG_MIDI
+        fprintf(stderr, "midi sysex (%d bytes):", sz);
+        for (int i = 0; i < sz; i++)
+            fprintf(stderr, " 0x%0x", data[i]);
+        fprintf(stderr, "\n");
+#endif
+        if (data[0] == 0xf0) {
+            // Skip over the f0 and f7 status bytes in case they are included in the
+            // dump.
+            data++; sz--;
+            if (data[sz-1] == 0xf7) sz--;
+        }
+        if ((data[0] == 0x7e || data[0] == 0x7f) && data[2] == 8) {
+            // MIDI tuning standard
+            bool realtime = data[0] == 0x7f;
+            if ((sz == 19 && data[3] == 8) ||
+                (sz == 31 && data[3] == 9)) {
+                // MTS scale/octave tuning 1- or 2-byte form
+                bool onebyte = data[3] == 8;
+                unsigned chanmsk = (data[4]<<14) | (data[5]<<7) | data[6];
+                for (int i = 0; i < 12; i++) {
+                    float t;
+                    if (onebyte)
+                        t = (data[i+7]-64)/100.0;
+                    else
+                        t = (((data[2*i+7]<<7)|data[2*i+8])-8192)/8192.0;
+                    for (uint8_t ch = 0; ch < 16; ch++)
+                        if (chanmsk & (1<<ch))
+                            vd->tuning[ch][i] = t;
+                }
+                if (realtime) {
+                    for (uint8_t ch = 0; ch < 16; ch++)
+                        if (chanmsk & (1<<ch)) {
+                            // update running voices on this channel
+                            update_voices(ch);
+                        }
+                }
+#if DEBUG_MTS
+                fprintf(stderr, "octave-tuning-%s (chan ",
+                        realtime?"realtime":"non-realtime");
+                bool first = true;
+                for (uint8_t i = 0; i < 16; )
+                    if (chanmsk & (1<<i)) {
+                        uint8_t j;
+                        for (j = i+1; j < 16 && (chanmsk&(1<<j)); )
+                            j++;
+                        if (first)
+                            first = false;
+                        else
+                            fprintf(stderr, ",");
+                        if (j > i+1)
+                            fprintf(stderr, "%u-%u", i+1, j);
+                        else
+                            fprintf(stderr, "%u", i+1);
+                        i = j;
+                    } else
+                        i++;
+                fprintf(stderr, "):");
+                if (onebyte) {
+                    for (int i = 7; i < 19; i++) {
+                        int val = data[i];
+                        fprintf(stderr, " %d", val-64);
+                    }
+                } else {
+                    for (int i = 7; i < 31; i++) {
+                        int val = data[i++] << 7;
+                        val |= data[i];
+                        fprintf(stderr, " %g", ((double)val-8192.0)/8192.0*100.0);
+                    }
+                }
+                fprintf(stderr, "\n");
+#endif
+            }
+        }
+    }
+    
+    // Change to a given preloaded tuning. The given tuning number may be in the
+    // range 1..VSTPlugin::n_tunings, zero denotes the default tuning (equal
+    // temperament). This is only supported if FAUST_MTS is defined at compile
+    // time.
+    
+    void change_tuning(int num)
+    {
+#if FAUST_MTS
+        if (!mts || num == tuning) return;
+        modified = true;
+        if (num < 0) num = 0;
+        if (num > mts->tuning.size())
+            num = mts->tuning.size();
+        tuning = num;
+        if (tuning > 0) {
+            process_sysex(mts->tuning[tuning-1].data,
+                          mts->tuning[tuning-1].len);
+        } else {
+            memset(vd->tuning, 0, sizeof(vd->tuning));
+#if DEBUG_MTS
+            fprintf(stderr,
+                    "octave-tuning-default (chan 1-16): equal temperament\n");
+#endif
+#endif
+        }
+    }
+    
+};
+
+MyMeta *VSTPlugin::meta = 0;
+int VSTPlugin::n_tunings = 0;
+#if FAUST_MTS
+MTSTunings *VSTPlugin::mts = 0;
+#endif
+
+/* VST-specific part starts here. ********************************************/
+
+#include "audioeffectx.h"
+#if FAUST_UI
+#include "faustvstqt.h"
+#endif
+
+/* NOTE: Some hosts are blacklisted here due to incompatibilities with the
+ optional Qt GUI code. We include Ardour by default, but you may want to put
+ other hosts on this list if they give you random crashes. You can also
+ comment out the following define to enable the GUI in all hosts for testing
+ purposes. Note that in any case the VST plugins *will* run in the
+ blacklisted hosts, just without a custom GUI. */
+#define HOST_BLACKLIST { "Ardour", "REAPER", NULL }
+//#define HOST_BLACKLIST { "Ardour", "Tracktion", NULL }
+
+class VSTWrapper : public AudioEffectX
+{
+public:
+    VSTWrapper(audioMasterCallback audioMaster);
+    ~VSTWrapper();
+    
+    virtual void processReplacing(float **inputs, float **outputs,
+                                  VstInt32 sampleframes);
+    virtual VstInt32 processEvents(VstEvents* events);
+    
+    virtual void suspend();
+    virtual void resume();
+    virtual void setSampleRate(float sampleRate);
+    
+    virtual void setProgram(VstInt32 program);
+    virtual void setProgramName(const char *name);
+    virtual void getProgramName(char *name);
+    virtual bool getProgramNameIndexed(VstInt32 category,
+                                       VstInt32 index, char* text);
+    
+    virtual void setParameter(VstInt32 index, float value);
+    virtual float getParameter(VstInt32 index);
+    virtual bool string2parameter(VstInt32 index, char *text);
+    virtual void getParameterLabel(VstInt32 index, char *label);
+    virtual void getParameterDisplay(VstInt32 index, char *text);
+    virtual void getParameterName(VstInt32 index, char *text);
+    
+    virtual VstInt32 getChunk(void** data,
+                              bool isPreset = false);
+    virtual VstInt32 setChunk(void* data, VstInt32 byteSize,
+                              bool isPreset = false);
+    
+    virtual bool getInputProperties(VstInt32 index,
+                                    VstPinProperties *properties);
+    virtual bool getOutputProperties(VstInt32 index,
+                                     VstPinProperties* properties);
+    
+    virtual bool getEffectName(char* name);
+    virtual bool getVendorString(char* text);
+    virtual bool getProductString(char* text);
+    virtual VstInt32 getVendorVersion();
+    virtual VstInt32 canDo(char* text);
+    
+    // We process all MIDI channels on input.
+    virtual VstInt32 getNumMidiInputChannels()  { return 16; }
+    // No MIDI output for now. XXXTODO: We might want to do MIDI controller
+    // output for passive Faust controls in the future.
+    virtual VstInt32 getNumMidiOutputChannels()  { return 0; }
+    
+#if FAUST_UI
+    // AG: Note that we have to map the GUI parameter numbers to the actual
+    // Faust control indices here. This extra level of indirection is necessary
+    // because in some cases Qt may enumerate the child widgets in a different
+    // order than what we have in the Faust program. The mapping is computed in
+    // the QTGUIWrapper class below, please see the comments there for details.
+    
+    int n_params;      // number of param mapping entries
+    int *param_no;     // map Qt -> Faust control numbers
+    int *control_no;   // map Faust -> Qt control numbers
+    
+    int map_param(int i)
+    {
+        return (i < 0 || i >= n_params) ? i : param_no[i];
+    }
+    
+    int map_control(int i)
+    {
+        return (i < 0 || i >= n_params) ? i : control_no[i];
+    }
+    
+    // GUI-specific methods
+    float getMinimum(VstInt32 index);
+    float getMaximum(VstInt32 index);
+    float getStep(VstInt32 index);
+    int isPassiveControl(VstInt32 index);
+    int getMaxVoices();
+    int getNumTunings();
+    int getNumControls();
+    const char *getHostName();
+#else
+    // Dummy versions to be used if the GUI is not included.
+    int map_param(int i) { return i; }
+    int map_control(int i) { return i; }
+#endif
+    
+private:
+    VSTPlugin *plugin;
+    char progname[kVstMaxProgNameLen+1];
+#if FAUST_UI
+    char host[65];
+#endif
+    float *progdata;
+};
+
+// Create a "unique" VST plugin ID using Murmur2 hashes. This can't possibly
+// avoid all collisions, but will hopefully be good enough.
+
+// Code pilfered from http://code.google.com/p/smhasher/.
+static uint32_t MurmurHash2(const void *key, int len, uint32_t seed)
+{
+    // 'm' and 'r' are mixing constants generated offline.
+    // They're not really 'magic', they just happen to work well.
+    
+    const uint32_t m = 0x5bd1e995;
+    const int r = 24;
+    
+    // Initialize the hash to a 'random' value
+    
+    uint32_t h = seed ^ len;
+    
+    // Mix 4 bytes at a time into the hash
+    
+    const unsigned char * data = (const unsigned char *)key;
+    
+    while(len >= 4)
+    {
+        uint32_t k = *(uint32_t*)data;
+        
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+        
+        h *= m;
+        h ^= k;
+        
+        data += 4;
+        len -= 4;
+    }
+    
+    // Handle the last few bytes of the input array
+    
+    switch(len)
+    {
+        case 3: h ^= data[2] << 16;
+        case 2: h ^= data[1] << 8;
+        case 1: h ^= data[0];
+            h *= m;
+    };
+    
+    // Do a few final mixes of the hash to ensure the last few
+    // bytes are well-incorporated.
+    
+    h ^= h >> 13;
+    h *= m;
+    h ^= h >> 15;
+    
+    return h;
+}
+
+static uint32_t idhash(const char *s)
+{
+    // Arbitrary seed value (should be the same for all instances).
+    const uint32_t seed = 4711;
+    // XXXFIXME: The rules for valid-formed VST ids don't seem to be very
+    // clear. Can it be just any 32 bit number? But it looks like at least the
+    // most significant bit should be 0 here, so we enforce that. (Some VST
+    // hosts such as Carla display the id as zero otherwise.)
+    return MurmurHash2(s, strlen(s), seed) & 0x7fffffff;
+}
+
+// initialization and finalization
+
+// This interface function is used by the code in vstplugmain.cpp to create an
+// instance of the plugin. It simply invokes the constructor of our VSTWrapper
+// class here.
+AudioEffect *createEffectInstance(audioMasterCallback audioMaster)
+{
+    return new VSTWrapper(audioMaster);
+}
+
+VSTWrapper::VSTWrapper(audioMasterCallback audioMaster)
+: AudioEffectX(audioMaster, 1, VSTPlugin::numControls())
+{
+    const char *dsp_name = VSTPlugin::pluginName();
+    const int num_voices = VSTPlugin::numVoices();
+    // Get the initial sample rate from the VST host.
+    const int rate = getSampleRate();
+    plugin = new VSTPlugin(num_voices, rate);
+#if FAUST_UI
+    // Get the name of the host (product string).
+    strcpy(host, "Unknown");
+    // Some hosts like Ardour properly report the product string even though
+    // getHostProductString() returns false, so we just ignore the return value.
+    getHostProductString(host);
+    // Map of GUI parameter numbers to the actual control indices. This is
+    // initialized later by VSTQtGUI::open() below.
+    n_params = 0;
+    param_no = control_no = 0;
+#endif
+    // VST-specific initialization:
+    if (audioMaster) {
+        setNumInputs(plugin->dsp[0]->getNumInputs());
+        setNumOutputs(plugin->dsp[0]->getNumOutputs());
+        canProcessReplacing();
+        programsAreChunks();
+        if (plugin->maxvoices > 0) isSynth();
+        // XXXFIXME: Maybe do something more clever for the unique id.
+        setUniqueID((VstInt32)idhash(dsp_name));
+        
+#if FAUST_UI
+#ifdef HOST_BLACKLIST
+        char *blacklist[] = HOST_BLACKLIST, **b = blacklist;
+        while (*b && strcmp(host, *b)) ++b;
+        //fprintf(stderr, "host '%s' is %s blacklist\n", host, *b?"on":"not on");
+        if (!*b)
+#endif
+            setEditor(new VSTQtGUI(this));
+#endif
+    }
+    // We only provide one "program" (a.k.a. built-in control preset), which
+    // corresponds to the initial input control values in the Faust UI. Faust
+    // has no built-in support for presets and we don't try to emulate that here
+    // either. Most VST hosts will provide you with a way to save and restore
+    // presets in a number of different formats, such as fxb and fxp files.
+    curProgram = 0;
+    setProgramName("Default");
+    // Initialize the program storage. This is also used with getChunk/setChunk.
+    // We reserve two extra entries for the instrument poly and tuning controls
+    // here if needed.
+    int k = plugin->ui[0]->nports;
+#if FAUST_MTS
+    int m = (plugin->maxvoices > 0)?2:0;
+#else
+    int m = (plugin->maxvoices > 0)?1:0;
+#endif
+    progdata = (float*)calloc(k+m, sizeof(float));
+    assert(k+m == 0 || progdata);
+    // At this point, plugin->ports should already be filled with the initial
+    // control values, use getChunk to copy them over to the program storage.
+    void *data;
+    (void)getChunk(&data);
+}
+
+VSTWrapper::~VSTWrapper()
+{
+    delete plugin;
+    if (progdata) free(progdata);
+#if FAUST_UI
+    if (param_no) delete[] param_no;
+    if (control_no) delete[] control_no;
+#endif
+}
+
+// plugin activation and deactivation
+
+void VSTWrapper::suspend()
+{
+    plugin->suspend();
+}
+
+void VSTWrapper::resume()
+{
+    plugin->rate = getSampleRate();
+    plugin->resume();
+}
+
+void VSTWrapper::setSampleRate(float sampleRate)
+{
+    AudioEffect::setSampleRate(sampleRate);
+    plugin->set_rate(sampleRate);
+}
+
+// programs a.k.a. built-in presets (see above)
+
+void VSTWrapper::setProgram(VstInt32 prog)
+{
+    if (prog < 0 || prog >= 1) return;
+    curProgram = prog;
+    int k = plugin->ui[0]->nports;
+    // instrument data size
+#if FAUST_MTS
+    int m = (plugin->maxvoices > 0)?2:0;
+#else
+    int m = (plugin->maxvoices > 0)?1:0;
+#endif
+    (void)setChunk(progdata, (k+m)*sizeof(float));
+    // Some hosts may require this to force a GUI update of the parameters.
+    updateDisplay();
+}
+
+void VSTWrapper::setProgramName(const char* name)
+{
+    vst_strncpy(progname, name, kVstMaxProgNameLen);
+}
+
+void VSTWrapper::getProgramName(char *name)
+{
+    vst_strncpy(name, progname, kVstMaxProgNameLen);
+}
+
+bool VSTWrapper::getProgramNameIndexed(VstInt32 category, VstInt32 index,
+                                       char* text)
+{
+    if (index < 1) {
+        vst_strncpy(text, progname, kVstMaxProgNameLen);
+        return true;
+    } else
+        return false;
+}
+
+// control values (setters, getters, meta data)
+
+VstInt32 VSTWrapper::getChunk(void** data, bool isPreset)
+{
+    int k = plugin->ui[0]->nports;
+    // data for the k ports is already in plugin->ports, for instruments we also
+    // add the values of the polyphony and (if enabled) the tuning control
+    memcpy(progdata, plugin->ports, k*sizeof(float));
+    if (plugin->maxvoices > 0) {
+        progdata[k++] = plugin->poly;
+#if FAUST_MTS
+        progdata[k++] = plugin->tuning;
+#endif
+    }
+    *data = progdata;
+    return k*sizeof(float);
+}
+
+VstInt32 VSTWrapper::setChunk(void* data, VstInt32 byteSize, bool isPreset)
+{
+    int k = plugin->ui[0]->nports, l = byteSize/sizeof(float);
+    // instrument data size
+#if FAUST_MTS
+    int m = (plugin->maxvoices > 0)?2:0;
+#else
+    int m = (plugin->maxvoices > 0)?1:0;
+#endif
+    if (byteSize != (k+m)*sizeof(float)) return 0; // data size mismatch
+    // copy the data over to the program storage
+    if (progdata != data) memcpy(progdata, data, (k+m)*sizeof(float));
+    // set the control data
+    memcpy(plugin->ports, progdata, k*sizeof(float));
+    if (plugin->maxvoices > 0) {
+        plugin->poly = min(plugin->maxvoices, max(1, (int)progdata[k]));
+#if FAUST_MTS
+        plugin->change_tuning((int)progdata[k+1]);
+#endif
+    }
+    // Noone seems to know what the return value is good for. Just always
+    // returning zero reportedly works with existing hosts.
+    return 0;
+}
+
+void VSTWrapper::getParameterName(VstInt32 index, char *label)
+{
+    index = map_param(index);
+    int k = plugin->ui[0]->nports;
+    strcpy(label, "");
+    if (index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        // Note that the VST spec mandates a maximum size of kVstMaxParamStrLen
+        // for the label string, which is a rather small constant. This seems
+        // overly restrictive, however, given that virtually all VST hosts provide
+        // for much longer names. We allow 32 characters here which is hopefully
+        // on the safe side.
+        vst_strncpy(label, plugin->ui[0]->elems[j].label, 32);
+    } else if (index == k && plugin->maxvoices > 0) {
+        strcpy(label, "polyphony");
+#if FAUST_MTS
+    } else if (index == k+1 && plugin->n_tunings > 0) {
+        strcpy(label, "tuning");
+#endif
+    }
+}
+
+void VSTWrapper::getParameterLabel(VstInt32 index, char *label)
+{
+    index = map_param(index);
+    int k = plugin->ui[0]->nports;
+    strcpy(label, "");
+    if (index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        if (plugin->units[index])
+            // Allow for up to 32 characters; see the remarks concerning
+            // kVstMaxParamStrLen above.
+            vst_strncpy(label, plugin->units[index], 32);
+    }
+}
+
+// NOTE: VST parameters are always floats with unit range (0..1). So we need
+// to convert between Faust control values with given range/stepsize and the
+// VST range here. We use the following quantization algorithm for mapping VST
+// to Faust control values.
+
+static double quantize(double x, double d)
+{
+    if (d == 0.0) return x;
+    // Round off x to the nearest increment of d. Note that this may produce
+    // rounding artifacts if d is some power of 10 less than 0, since these
+    // can't be represented exactly in binary.
+    double i;
+    if (x*d < 0.0)
+        modf(x/d-0.5, &i);
+    else
+        modf(x/d+0.5, &i);
+    return i*d;
+}
+
+void VSTWrapper::getParameterDisplay(VstInt32 index, char *text)
+{
+    index = map_param(index);
+    int k = plugin->ui[0]->nports;
+    strcpy(text, "");
+    if (index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        sprintf(text, "%0.5g", plugin->ports[index]);
+    } else if (index == k && plugin->maxvoices > 0) {
+        sprintf(text, "%d voices", plugin->poly);
+#if FAUST_MTS
+    } else if (index == k+1 && plugin->n_tunings > 0) {
+        sprintf(text, "%d %s", plugin->tuning,
+                plugin->tuning>0?plugin->mts->tuning[plugin->tuning-1].name:
+                "default");
+#endif
+    }
+}
+
+static inline float clamp(float min, float max, float val)
+{
+    if (min<=max) {
+        if (val < min) val = min;
+        if (val > max) val = max;
+    } else {
+        if (val > min) val = min;
+        if (val < max) val = max;
+    }
+    return val;
+}
+
+float VSTWrapper::getParameter(VstInt32 index)
+{
+    index = map_param(index);
+    int k = plugin->ui[0]->nports;
+    if (index >= 0 && index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        float min = plugin->ui[0]->elems[j].min;
+        float max = plugin->ui[0]->elems[j].max;
+        if (min == max)
+            return 0.0f;
+        else
+            // Clamp the value to the 0..1 VST range. Some VST hosts (e.g., Carla)
+            // don't like values falling outside that range.
+            return clamp(0.0, 1.0, (plugin->ports[index]-min)/(max-min));
+    } else if (index == k && plugin->maxvoices > 0) {
+        return (float)plugin->poly/(float)plugin->maxvoices;
+#if FAUST_MTS
+    } else if (index == k+1 && plugin->n_tunings > 0) {
+        return (float)plugin->tuning/(float)plugin->mts->tuning.size();
+#endif
+    } else
+        return 0.0f;
+}
+
+void VSTWrapper::setParameter(VstInt32 index, float value)
+{
+    index = map_param(index);
+    const double eps = 1e-5;
+    int k = plugin->ui[0]->nports;
+    if (index >= 0 && index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        // XXXTODO: We use a rather simple-minded quantization algorithm here, do
+        // something more comprehensive in the future.
+        float min = plugin->ui[0]->elems[j].min;
+        float max = plugin->ui[0]->elems[j].max;
+        float step = plugin->ui[0]->elems[j].step;
+        float val = (min == max)?min:min+quantize(value*(max-min), step);
+        if (fabs(val) < fabs(step) || fabs(val)/fabs(max-min) < eps)
+            val = 0.0;
+        // We only need to update the port value here, the ui values are then
+        // updated automatically as needed in the process_audio() callback.
+        plugin->ports[index] = val;
+    } else if (index == k && plugin->maxvoices > 0) {
+        plugin->poly = (int)quantize((value*plugin->maxvoices), 1);
+        if (plugin->poly <= 0) plugin->poly = 1;
+#if FAUST_MTS
+    } else if (index == k+1 && plugin->n_tunings > 0) {
+        int tuning = (int)quantize((value*plugin->mts->tuning.size()), 1);
+        plugin->change_tuning(tuning);
+#endif
+    }
+}
+
+bool VSTWrapper::string2parameter(VstInt32 index, char *text)
+{
+    if (!text) return true;
+    int k = plugin->ui[0]->nports;
+    if (index >= 0 && index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        float min = plugin->ui[0]->elems[j].min;
+        float max = plugin->ui[0]->elems[j].max;
+        float step = plugin->ui[0]->elems[j].step;
+        double val = atof(text);
+        if (min == max)
+            val = min;
+        else
+            val = min+quantize(val-min, step);
+        if (min > max) {
+            float m = max;
+            max = min; min = m;
+        }
+        if (val < min)
+            val = min;
+        else if (val > max)
+            val = max;
+        plugin->ports[index] = val;
+    } else if (index == k && plugin->maxvoices > 0) {
+        int val = atoi(text);
+        if (val <= 0) val = 1;
+        if (val > plugin->maxvoices) val = plugin->maxvoices;
+        plugin->poly = val;
+#if FAUST_MTS
+    } else if (index == k+1 && plugin->mts &&
+               plugin->mts->tuning.size() > 0) {
+        plugin->change_tuning(atoi(text));
+#endif
+    } else
+        return false;
+    return true;
+}
+
+// audio inputs and outputs
+
+bool VSTWrapper::getInputProperties(VstInt32 index,
+                                    VstPinProperties* properties)
+{
+    const char *dsp_name = VSTPlugin::pluginName();
+    const int n = plugin->dsp[0]->getNumInputs();
+    if (index < 0 || index >= n)
+        return false;
+    snprintf(properties->label, kVstMaxLabelLen,
+             "%s input #%d", dsp_name, index);
+    sprintf(properties->shortLabel, "In%d", index);
+    properties->flags = kVstPinIsActive;
+    // XXXTODO: deal with multi-channel setups (>2) here
+    if (n == 2)
+        properties->flags |= kVstPinIsStereo;
+    return true;
+}
+
+bool VSTWrapper::getOutputProperties(VstInt32 index,
+                                     VstPinProperties* properties)
+{
+    const char *dsp_name = VSTPlugin::pluginName();
+    const int n = plugin->dsp[0]->getNumOutputs();
+    if (index < 0 || index >= n)
+        return false;
+    snprintf(properties->label, kVstMaxLabelLen,
+             "%s output #%d", dsp_name, index);
+    sprintf(properties->shortLabel, "Out%d", index);
+    properties->flags = kVstPinIsActive;
+    // XXXTODO: deal with multi-channel setups (>2) here
+    if (n == 2)
+        properties->flags |= kVstPinIsStereo;
+    return true;
+}
+
+// global meta data
+
+bool VSTWrapper::getEffectName(char *name)
+{
+    const char *dsp_name = VSTPlugin::pluginName();
+    vst_strncpy(name, dsp_name, kVstMaxEffectNameLen);
+    return true;
+}
+
+bool VSTWrapper::getVendorString(char *text)
+{
+    const char *vendorString = VSTPlugin::pluginAuthor();
+    vst_strncpy(text, vendorString, kVstMaxVendorStrLen);
+    return true;
+}
+
+bool VSTWrapper::getProductString(char *text)
+{
+    const char *productString = VSTPlugin::pluginDescription();
+    vst_strncpy(text, productString, kVstMaxProductStrLen);
+    return true;
+}
+
+VstInt32 VSTWrapper::getVendorVersion()
+{
+    const char *versionString = VSTPlugin::pluginVersion();
+    return (VstInt32)(atof(versionString)*1000.0);
+}
+
+VstInt32 VSTWrapper::canDo(char *text)
+{
+    if (strcmp(text, "receiveVstEvents") == 0) return 1;
+    if (strcmp(text, "receiveVstMidiEvent") == 0) return 1;
+    // This may convince some VST hosts to send us sysex events (seems to be
+    // supported by some Bitwig versions at least).
+    if (strcmp(text, "receiveVstSysexEvent") == 0) return 1;
+    return -1;
+}
+
+// audio and MIDI process functions
+
+void VSTWrapper::processReplacing(float **inputs, float **outputs,
+                                  VstInt32 n_samples)
+{
+    plugin->process_audio(n_samples, inputs, outputs);
+    // Some hosts may require this to force a GUI update of the controls.
+    // XXXFIXME: Alas, some hosts don't seem to handle this at all (e.g.,
+    // Tracktion).
+    if (plugin->modified) updateDisplay();
+}
+
+VstInt32 VSTWrapper::processEvents(VstEvents* events)
+{
+    // Process incoming MIDI events.
+    for (VstInt32 i = 0; i < events->numEvents; i++) {
+        if (events->events[i]->type == kVstMidiType) {
+            VstMidiEvent* ev = (VstMidiEvent*)events->events[i];
+            uint8_t *data = (uint8_t*)ev->midiData;
+#if 0
+            // FIXME: Consider doing sample-accurate note onsets here. VST keeps
+            // track of the exact onset in the deltaFrames field, but we can't use
+            // that information at present, since our gate parameter is a control
+            // variable which can only change at block boundaries. In the future,
+            // the gate could be implemented as an audio signal to get
+            // sample-accurate note onsets.
+            VstInt32 frames = ev->deltaFrames;
+#endif
+#if 0
+            fprintf(stderr, "ev length = %d, offset = %d, detune = %d, off velocity = %d\n", ev->noteLength, ev->noteOffset, (int)(signed char)ev->detune, (int)ev->noteOffVelocity);
+#endif
+            plugin->process_midi(data, 4);
+        } else if (events->events[i]->type == kVstSysExType) {
+            VstMidiSysexEvent* ev = (VstMidiSysexEvent*)events->events[i];
+            int sz = ev->dumpBytes;
+            uint8_t *data = (uint8_t*)ev->sysexDump;
+            bool is_instr = plugin->maxvoices > 0;
+            if (!is_instr) continue;
+            plugin->process_sysex(data, sz);
+        } else {
+            fprintf(stderr, "%s: unknown event type %d\n",
+                    VSTPlugin::pluginName(), events->events[i]->type);
+        }
+    }
+    return 1;
+}
+
+#if FAUST_UI
+
+/* Qt-specific part starts here. *********************************************/
+
+/* Copyright (c) 2015-2016 by Roman Svidler (rosvid). Some improvements and
+ HTTPD/OSC support added by Albert Gräf (ag). Distributed under the LGPLv3+.
+ Original code is available at https://github.com/rosvid/faust-vst-qt. */
+
+// special getters needed by the GUI code
+
+float VSTWrapper::getMinimum(VstInt32 index)
+{
+    index = map_param(index);
+    int k = plugin->ui[0]->nports;
+    if (index < 0)
+        return 0.0f;
+    else if (index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        float min = plugin->ui[0]->elems[j].min;
+        return min;
+    } else if (index == k && plugin->maxvoices > 0) {
+        return 0.0f;
+#if FAUST_MTS
+    } else if (index == k+1 && plugin->n_tunings > 0) {
+        return 0.0f;
+#endif
+    } else
+        return 0.0f;
+}
+
+float VSTWrapper::getMaximum(VstInt32 index)
+{
+    index = map_param(index);
+    int k = plugin->ui[0]->nports;
+    if (index < 0)
+        return 0.0f;
+    else if (index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        float max = plugin->ui[0]->elems[j].max;
+        return max;
+    } else if (index == k && plugin->maxvoices > 0) {
+        return (float)plugin->maxvoices;
+#if FAUST_MTS
+    } else if (index == k+1 && plugin->n_tunings > 0) {
+        return (float)plugin->mts->tuning.size();
+#endif
+    } else
+        return 0.0f;
+}
+
+float VSTWrapper::getStep(VstInt32 index)
+{
+    index = map_param(index);
+    int k = plugin->ui[0]->nports;
+    if (index < 0)
+        return 0.0f;
+    else if (index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        float step = plugin->ui[0]->elems[j].step;
+        return step;
+    } else if (index == k && plugin->maxvoices > 0) {
+        return 1.0f;
+#if FAUST_MTS
+    } else if (index == k+1 && plugin->n_tunings > 0) {
+        return 1.0f;
+#endif
+    } else
+        return 0.0f;
+}
+
+int VSTWrapper::isPassiveControl(VstInt32 index)
+{
+    index = map_param(index);
+    int k = plugin->ui[0]->nports;
+    if (index >= 0 && index < k) {
+        int j = plugin->ctrls[index];
+        assert(index == plugin->ui[0]->elems[j].port);
+        switch (plugin->ui[0]->elems[j].type) {
+            case UI_V_BARGRAPH:
+                return 1;         // passive control is of type UI_V_BARGRAPH
+            case UI_H_BARGRAPH:
+                return 2;         // passive control is of type UI_H_BARGRAPH
+            default:
+                return 0;         // not a passive control
+        }
+    } else
+        return 0;
+}
+
+int VSTWrapper::getMaxVoices()
+{
+    return plugin->maxvoices;
+}
+
+int VSTWrapper::getNumTunings()
+{
+#if FAUST_MTS
+    return plugin->n_tunings;
+#else
+    return 0;
+#endif
+}
+
+int VSTWrapper::getNumControls()
+{
+    return plugin->ui[0]->nports;;
+}
+
+const char *VSTWrapper::getHostName()
+{
+    return host;
+}
+
+// OSCUI.h and httpdUI.h pull in their own definition of the Meta struct,
+// prevent name clashes with our version.
+#define Meta FaustMeta
+
+#include <iostream>
+#include <QApplication>
+#include <faust/gui/QTUI.h>
+#ifdef OSCCTRL
+#include <faust/gui/OSCUI.h>
+#endif
+#ifdef HTTPCTRL
+#include <faust/gui/httpdUI.h>
+#endif
+
+#include <QWidget>
+#include <QList>
+#include <QtAlgorithms>
+#include <QX11Info>
+#include <X11/Xlib.h>
+
+#line 2438 "faustvst.cpp"
+
+std::list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+
+/* Define this to get debugging output from the Qt-related code, or add the
+ corresponding option to the qmake project options in the faust2faustvstqt
+ script to achieve the same effect. Setting this to a value >1 will give
+ even more extensive debugging output. Using a zero value or commenting the
+ following line makes sure that no qDebug calls are included in the code at
+ all. -ag */
+//#define FAUSTQT_DEBUG 1
+
+/**
+ * @brief VSTQtGUI::VSTQtGUI
+ * - initializations that need to be done when creating an editor object
+ *   (make sure that the QApplication is initialized if needed)
+ * @param effect
+ */
+VSTQtGUI::VSTQtGUI(VSTWrapper* effect) : effect(effect),
+widget(NULL), uidsp(NULL),
+#ifdef OSCCTRL
+oscinterface(NULL),
+#endif
+#ifdef HTTPCTRL
+httpdinterface(NULL),
+#endif
+qtinterface(NULL)
+{
+    static int argc = 0;
+    static char* argv[1] = {0};
+    if(qApp) {
+#if FAUSTQT_DEBUG
+        qDebug() << "qApp already exists";
+#endif
+    } else {
+#if FAUSTQT_DEBUG
+        qDebug() << "qApp is created!";
+#endif
+        new QApplication(argc, argv);
+    }
+    
+    int n_controls = effect->getNumControls();
+    // instruments can have up to 2 controls more (poly+tuning)
+    if (effect->getMaxVoices()>0) n_controls += 2;
+    // this array is used to keep track of the current status of control values;
+    // GUI controls are only set if the value has changed
+    control_values = (float*)calloc(n_controls, sizeof(float));
+    
+#if FAUSTQT_DEBUG
+    qDebug() << "qApp=" << qApp;
+    static bool first_time = false;
+    if (!first_time) {
+        first_time = true;
+        qDebug() << "VST host: " << effect->getHostName();
+    }
+#endif
+}
+
+/**
+ * @brief VSTQtGUI::~VSTQtGUI
+ * - finalizations that need to be done when destroying an editor object
+ */
+VSTQtGUI::~VSTQtGUI()
+{
+    if (control_values) free(control_values);
+}
+
+// This is a little wrapper class around QTGUI which takes care of eliminating
+// the freq/gain/gate controls of instruments in the user interface when
+// running the dsp's buildUserInterface method. It also adds polyphony and
+// tuning controls to instruments as needed, and does some other extra
+// bookkeeping and on-the-fly modifications that we need. -ag
+
+// AG XXXFIXME: This is more complicated than we'd like it to be, since for
+// some unknown reason, the children of a tab widget are listed in reverse
+// order (https://bitbucket.org/agraef/faust-lv2/issues/10). Since the GUI
+// code assumes that the widgets are in the same order as the Faust control
+// elements, we need to construct a mapping that translates between the two.
+
+struct QTGUIElem {
+    int i;
+    QList<int> p;
+    const char *label;
+    QTGUIElem(int _i, QList<int> _p, const char *_label) :
+    i(_i), p(_p), label(_label)
+    {}
+};
+
+bool qtguielem_less(const QTGUIElem &x, const QTGUIElem &y)
+{
+    // Qt4 doesn't define operator< on QLists, so we need to do the
+    // lexicographic comparison manually.
+    QList<int>::const_iterator i = x.p.begin(), j = y.p.begin();
+    for (; i != x.p.end() && j != y.p.end(); ++i, ++j) {
+        if (*i < *j)
+            return true;
+        else if (*i > *j)
+            return false;
+    }
+    return j != y.p.end();
+}
+
+class QTGUIWrapper : public UI
+{
+protected:
+    bool is_instr;
+    QTGUI *ui;
+    QList<int> path;
+    QList<QTGUIElem> elems;
+    int level, maxvoices, numtunings;
+    float *voices_zone, *tuning_zone;
+    bool have_freq, have_gain, have_gate;
+    bool is_voice_ctrl(const char *label)
+    {
+        if (!is_instr)
+            return false;
+        else if (!have_freq && !strcmp(label, "freq"))
+            return (have_freq = true);
+        else if (!have_gain && !strcmp(label, "gain"))
+            return (have_gain = true);
+        else if (!have_gate && !strcmp(label, "gate"))
+            return (have_gate = true);
+        else
+            return false;
+    }
+public:
+    int *elem_no;
+    int nelems;
+    QTGUIWrapper(QTGUI *_ui, int _maxvoices, int _numtunings,
+                 float *_voices_zone, float *_tuning_zone) :
+    is_instr(_maxvoices>0), ui(_ui), level(0),
+    maxvoices(_maxvoices), numtunings(_numtunings),
+    voices_zone(_voices_zone), tuning_zone(_tuning_zone),
+    have_freq(false), have_gain(false), have_gate(false),
+    elem_no(0), nelems(0)
+    {}
+    virtual ~QTGUIWrapper() {}
+    
+    // -- widget's layouts
+    virtual void openTabBox(const char* label)
+    { ui->openTabBox(label); level++; path.append(-1); }
+    virtual void openHorizontalBox(const char* label)
+    { ui->openHorizontalBox(label); level++; path.append(0); }
+    virtual void openVerticalBox(const char* label)
+    { ui->openVerticalBox(label); level++; path.append(0); }
+    virtual void closeBox()
+    {
+        if (--level == 0) {
+#if VOICE_CTRLS
+            if (is_instr) {
+                // Add polyphony and tuning controls (experimental).
+                ui->addHorizontalSlider("polyphony", voices_zone,
+                                        maxvoices/2, 0, maxvoices, 1);
+                addElem("Polyphony");
+#if FAUST_MTS
+                if (numtunings>0)
+                    ui->addHorizontalSlider("tuning", tuning_zone, 0, 0, numtunings, 1);
+                addElem("Tuning");
+#endif
+            }
+#endif
+            // AG: Create an index of all the GUI elements in the right order.
+            // XXXFIXME: This may need to be revisited if Qt or Faust changes the
+            // order for some reason.
+            qSort(elems.begin(), elems.end(), qtguielem_less);
+            elem_no = new int[nelems];
+            nelems = 0;
+            for (QList<QTGUIElem>::iterator x = elems.begin(); x != elems.end();
+                 ++x, ++nelems) {
+                elem_no[nelems] = x->i;
+#if 0
+                fprintf(stderr, "%s (#%d):", x->label, x->i);
+                for (QList<int>::iterator i = x->p.begin(); i != x->p.end(); ++i) {
+                    fprintf(stderr, " %d", *i);
+                }
+                fprintf(stderr, "\n");
+#endif
+            }
+        }
+        path.pop_back();
+        if (!path.empty()) {
+            if (path.last() < 0)
+                path.last()--;
+            else
+                path.last()++;
+        }
+        ui->closeBox();
+    }
+    
+    void addElem(const char *label)
+    {
+        elems.append(QTGUIElem(nelems++, path, label));
+        assert(!path.empty());
+        if (path.last() < 0)
+            path.last()--;
+        else
+            path.last()++;
+    }
+    
+    // -- active widgets
+    virtual void addButton(const char* label, FAUSTFLOAT* zone)
+    {
+        if (!is_voice_ctrl(label)) {
+            ui->addButton(label, zone);
+            addElem(label);
+        }
+    }
+    virtual void addCheckButton(const char* label, FAUSTFLOAT* zone)
+    {
+        if (!is_voice_ctrl(label)) {
+            ui->addCheckButton(label, zone);
+            addElem(label);
+        }
+    }
+    virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone,
+                                   FAUSTFLOAT init, FAUSTFLOAT min,
+                                   FAUSTFLOAT max, FAUSTFLOAT step)
+    {
+        if (!is_voice_ctrl(label)) {
+            ui->addVerticalSlider(label, zone, init, min, max, step);
+            addElem(label);
+        }
+    }
+    virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone,
+                                     FAUSTFLOAT init, FAUSTFLOAT min,
+                                     FAUSTFLOAT max, FAUSTFLOAT step)
+    {
+        if (!is_voice_ctrl(label)) {
+            ui->addHorizontalSlider(label, zone, init, min, max, step);
+            addElem(label);
+        }
+    }
+    virtual void addNumEntry(const char* label, FAUSTFLOAT* zone,
+                             FAUSTFLOAT init, FAUSTFLOAT min,
+                             FAUSTFLOAT max, FAUSTFLOAT step)
+    {
+        if (!is_voice_ctrl(label)) {
+            ui->addNumEntry(label, zone, init, min, max, step);
+            addElem(label);
+        }
+    }
+    
+    // -- passive widgets
+    virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone,
+                                       FAUSTFLOAT min, FAUSTFLOAT max)
+    {
+        ui->addHorizontalBargraph(label, zone, min, max);
+        addElem(label);
+    }
+    virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone,
+                                     FAUSTFLOAT min, FAUSTFLOAT max)
+    {
+        ui->addVerticalBargraph(label, zone, min, max);
+        addElem(label);
+    }
+    
+    virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
+    
+    virtual void declare(FAUSTFLOAT* zone, const char* key, const char* val)
+    {
+        // XXXFIXME: Faust's Qt GUI implementation handles [scale:log] and similar
+        // meta data affecting the scaling of slider data, but this isn't
+        // supported in the current faust-vst implementation, so we just ignore
+        // this meta data for now.
+        if (strcmp(key, "scale")) ui->declare(zone, key, val);
+    }
+    
+};
+
+/**
+ * @brief VSTQtGUI::open
+ * - method to open the plug-in GUI
+ * - the GUI is generated through QTUI.h (QTGUI() class)
+ * - communication between GUI elements and the corresponding VST parameters
+ *   is realized using Qt's signal-slot mechanism
+ * @param ptr
+ * @return
+ */
+bool VSTQtGUI::open(void *ptr)
+{
+    static int argc = 0;
+    static char* argv[1] = {0};
+#if FAUSTQT_DEBUG
+    qDebug() << "open editor: " << ptr;
+#endif
+    AEffEditor::open(ptr);
+    
+    widget = new QScrollArea();
+    widget->setWidgetResizable(true);
+    qtinterface = new QTGUI(widget);
+    widget->setWidget(qtinterface);
+    
+    mydsp* dsp = new mydsp();
+    
+#if FAUSTQT_DEBUG
+    qDebug() << "open interface: " << qtinterface;
+#endif
+    // We build the QTGUI indirectly through QTGUIWrapper whose sole purpose is
+    // to eliminate the voice controls in case of an instrument plugin.
+    QTGUIWrapper qtwrapper(qtinterface,
+                           effect->getMaxVoices(), effect->getNumTunings(),
+                           &voices_zone, &tuning_zone);
+    dsp->buildUserInterface(&qtwrapper);
+    
+    // AG: Initialize the Qt GUI -> Faust UI mapping (see the explanation under
+    // QTGUIWrapper above).
+    effect->n_params = qtwrapper.nelems;
+    effect->param_no = qtwrapper.elem_no;
+    effect->control_no = new int[qtwrapper.nelems];
+    for (int i = 0; i < qtwrapper.nelems; i++)
+        effect->control_no[effect->param_no[i]] = i;
+#if 0
+    for (int i = 0; i < effect->n_params; i++)
+        fprintf(stderr, "QT->LV2 %d -> %d\n", i, effect->param_no[i]);
+    for (int i = 0; i < effect->n_params; i++)
+        fprintf(stderr, "LV2->QT %d -> %d\n", i, effect->control_no[i]);
+#endif
+    
+    // HTTPD and OSC support (experimental)
+#ifdef HTTPCTRL
+    httpdinterface = new httpdUI(VSTPlugin::pluginName(),
+                                 dsp->getNumInputs(), dsp->getNumOutputs(),
+                                 argc, argv);
+    dsp->buildUserInterface(httpdinterface);
+#if FAUSTQT_DEBUG
+    qDebug() << "HTTPD is on";
+#endif
+#endif
+    
+#ifdef OSCCTRL
+    oscinterface = new OSCUI(VSTPlugin::pluginName(), argc, argv);
+    dsp->buildUserInterface(oscinterface);
+#if FAUSTQT_DEBUG
+    qDebug() << "OSC is on";
+#endif
+#endif
+    
+    // update the size of the QTGUI after creating the GUI elements
+    qtinterface->adjustSize();
+    
+    // the dimensions of the plug-in window must not exceed screenGeometry
+    // (-80 pixel tolerance)
+    int desktopHeight = QApplication::desktop()->screenGeometry().height()-80;
+    int desktopWidth  = QApplication::desktop()->screenGeometry().width()-80;
+    
+#if FAUSTQT_DEBUG>1
+    qDebug() << "desktop-height: " <<
+    QApplication::desktop()->screenGeometry().height();
+    qDebug() << "desktop-width: "  <<
+    QApplication::desktop()->screenGeometry().width();
+#endif
+    
+    // determine the window size
+    rectangle.top    = 0;
+    rectangle.left   = 0;
+    // the height of the plug-in GUI must not exceed the desktop resolution
+    if(qtinterface->height() > desktopHeight)
+        rectangle.bottom = desktopHeight;
+    else // add 20 pixels for scroll bars
+        rectangle.bottom = qtinterface->height()+20;
+    // the width of the plug-in GUI must not exceed the desktop resolution
+    if(qtinterface->width() > desktopWidth)
+        rectangle.right  = desktopWidth;
+    else // add 20 pixels for scroll bars
+        rectangle.right  = qtinterface->width()+20;
+    
+    // adjust the widget size
+    widget->resize(rectangle.right, rectangle.bottom);
+    // some hosts (e.g., Qtractor) need this to properly adjust the window size
+    effect->sizeWindow(rectangle.right, rectangle.bottom);
+    
+    // determine all children of qtinterface of type QObject*
+    QList<QObject*> allObjects = qtinterface->findChildren<QObject*>();
+#if FAUSTQT_DEBUG>1
+    qDebug() << "QObjects total count: " << allObjects.count();
+#endif
+    
+    int vstParamCount = 0;
+    
+    bool vBargraphChecked = true; // used in HorizontalBargraph search
+    QObject* lastObject;          // used in addNumDisplay check
+    
+    for (QList<QObject*>::iterator i = allObjects.begin(); i != allObjects.end();
+         ++i) {
+#if FAUSTQT_DEBUG>1
+        qDebug("");
+        // debugging output: class name of found object
+        qDebug() << "QObject: " << (*i)->metaObject()->className();
+        qDebug() << "VST parameter assigned: " << vstParamCount;
+#endif
+        
+        // Slider
+        QSlider* slider = qobject_cast<QSlider*>(*i);
+        if (slider) {
+#if FAUSTQT_DEBUG>1
+            qDebug("found slider!");
+#endif
+            slider->setProperty("vstParam", vstParamCount);
+            QList<QObject*> c; c.append(slider);
+            controls.append(c);
+            
+            connect(slider, SIGNAL(valueChanged(int)), this, SLOT(updateVST()),
+                    Qt::QueuedConnection);
+            updateQTGUI(slider, effect->getParameter(vstParamCount));
+            
+            vstParamCount++;
+        }
+        
+        // Knob
+        QDial* dial = qobject_cast<QDial*>(*i);
+        if (dial) {
+#if FAUSTQT_DEBUG>1
+            qDebug("found knob!");
+#endif
+            dial->setProperty("vstParam", vstParamCount);
+            QList<QObject*> c; c.append(dial);
+            controls.append(c);
+            
+            connect(dial, SIGNAL(valueChanged(int)), this, SLOT(updateVST()),
+                    Qt::QueuedConnection);
+            updateQTGUI(dial, effect->getParameter(vstParamCount));
+            
+            vstParamCount++;
+        }
+        
+        // Button
+        QPushButton* button = qobject_cast<QPushButton*>(*i);
+        if (button) {
+#if FAUSTQT_DEBUG>1
+            qDebug("found button!");
+#endif
+            button->setProperty("vstParam", vstParamCount);
+            QList<QObject*> c; c.append(button);
+            controls.append(c);
+            
+            connect(button, SIGNAL(pressed()), this,
+                    SLOT(updateVST_buttonPressed()), Qt::QueuedConnection);
+            connect(button, SIGNAL(released()), this,
+                    SLOT(updateVST_buttonReleased()), Qt::QueuedConnection);
+            
+            // button is released when GUI opens
+            effect->setParameter(vstParamCount, 0.0f);
+            control_values[vstParamCount] = 0.0f;
+            
+            vstParamCount++;
+        }
+        
+        // NumDisplay (list) / NumEntry / numerical HorizontalBargraph
+        QDoubleSpinBox* num = qobject_cast<QDoubleSpinBox*>(*i);
+        if (num) {
+            // ignore QDoubleSpinBox with NoButtons, as it's not a list but
+            // a NumDisplay
+            if(num->buttonSymbols() != QAbstractSpinBox::NoButtons) {
+#if FAUSTQT_DEBUG>1
+                qDebug("found list!");
+#endif
+                num->setProperty("vstParam", vstParamCount);
+                QList<QObject*> c; c.append(num);
+                controls.append(c);
+                
+                connect(num, SIGNAL(valueChanged(double)), this, SLOT(updateVST()),
+                        Qt::QueuedConnection);
+                
+                updateQTGUI(num, effect->getParameter(vstParamCount));
+                
+                vstParamCount++;
+                
+                // if previous control is passive and vBargraphChecked==false:
+                // found NumDisplay of VerticalBargraphs
+                // this is always called if we found a vBargraph in the previous
+                // iteration
+            } else if(effect->isPassiveControl(vstParamCount-1)==1
+                      && !vBargraphChecked) {
+#if FAUSTQT_DEBUG>1
+                qDebug("found numDisplay!");
+#endif
+                num->setProperty("vstParam", vstParamCount-1);
+                controls[vstParamCount-1].append(num);
+                passive_controls.append(num);
+                
+                // the corresponding display of the vBargraphs is now set
+                vBargraphChecked = true;
+            } else if(vstParamCount < effect->n_params &&
+                      effect->isPassiveControl(vstParamCount)==2
+                      && vBargraphChecked) {
+                QAbstractSlider* sliderOrKnob =
+                qobject_cast<QAbstractSlider*>(lastObject);
+                // only if the previously found QObject is neither slider nor
+                // knob
+                if(!sliderOrKnob) {
+#if FAUSTQT_DEBUG>1
+                    qDebug("found horizontal bargraph with numerical style!");
+#endif
+                    num->setProperty("vstParam", vstParamCount);
+                    QList<QObject*> c; c.append(num);
+                    controls.append(c);
+                    passive_controls.append(num);
+                    control_values[vstParamCount] = effect->getMinimum(vstParamCount);
+                    
+                    vstParamCount++;
+                }
+            }
+        }
+        
+        // CheckBox
+        QCheckBox* checkBox = qobject_cast<QCheckBox*>(*i);
+        if (checkBox) {
+#if FAUSTQT_DEBUG>1
+            qDebug("found checkbox!");
+#endif
+            checkBox->setProperty("vstParam", vstParamCount);
+            QList<QObject*> c; c.append(checkBox);
+            controls.append(c);
+            
+            connect(checkBox, SIGNAL(stateChanged(int)), this,
+                    SLOT(updateVST_checkBox()), Qt::QueuedConnection);
+            
+            // if the VST parameter of the checkbox is less than 0.5 then the
+            // checkbox is unchecked
+            updateQTGUI(checkBox, effect->getParameter(vstParamCount));
+            
+            vstParamCount++;
+        }
+        
+        // Bargraph
+        AbstractDisplay* bargraph = dynamic_cast<AbstractDisplay*>(*i);
+        if (bargraph) {
+            if(effect->isPassiveControl(vstParamCount)==1) {
+#if FAUSTQT_DEBUG>1
+                qDebug("found vertical bargraph!");
+#endif
+                vBargraphChecked = false;
+            }
+#if FAUSTQT_DEBUG>1
+            else
+                qDebug("found horizontal bargraph!");
+#endif
+            
+            bargraph->setProperty("vstParam", vstParamCount);
+            //led->setProperty("elemType", "led");
+            QList<QObject*> c; c.append(bargraph);
+            controls.append(c);
+            passive_controls.append(bargraph);
+            control_values[vstParamCount] = effect->getMinimum(vstParamCount);
+            
+            vstParamCount++;
+        }
+        
+        // Radiobuttons
+        uiRadioButtons* uiRadio = dynamic_cast<uiRadioButtons*>(*i);
+        if (uiRadio) {
+#if FAUSTQT_DEBUG>1
+            qDebug("found radio buttons!");
+#endif
+            
+            QList<QRadioButton*> radiobuttons =
+            uiRadio->findChildren<QRadioButton*>();
+            
+            int radioCount = 0;
+            QList<QObject*> c;
+            // iterate over all radio buttons in this group
+            for (QList<QRadioButton*>::iterator r = radiobuttons.begin();
+                 r != radiobuttons.end(); ++r) {
+                float minimum = effect->getMinimum(vstParamCount);
+                float maximum = effect->getMaximum(vstParamCount);
+                float step = effect->getStep(vstParamCount);
+                // set all properties needed for updateVST()
+                (*r)->setProperty("value", radioCount);
+                (*r)->setProperty("vstParam", vstParamCount);
+                (*r)->setProperty("minimum", minimum);
+                (*r)->setProperty("maximum", maximum);
+                (*r)->setProperty("singleStep", step);
+                connect((*r), SIGNAL(clicked(bool)), this, SLOT(updateVST()),
+                        Qt::QueuedConnection);
+                
+                // set the proper radio button as "clicked" when the GUI opens
+                updateQTGUI(*r, effect->getParameter(vstParamCount));
+                c.append(*r);
+                radioCount++;
+            }
+            controls.append(c);
+            vstParamCount++;
+        }
+        
+        // Menu
+        uiMenu* menu = dynamic_cast<uiMenu*>(*i);
+        if (menu) {
+#if FAUSTQT_DEBUG>1
+            qDebug("found menu!");
+#endif
+            
+            float minimum = effect->getMinimum(vstParamCount);
+            float maximum = effect->getMaximum(vstParamCount);
+            float step = effect->getStep(vstParamCount);
+            
+            menu->setProperty("vstParam", vstParamCount);
+            menu->setProperty("minimum", minimum);
+            menu->setProperty("maximum", maximum);
+            menu->setProperty("singleStep", step);
+            QList<QObject*> c; c.append(menu);
+            controls.append(c);
+            
+            connect(menu, SIGNAL(activated(int)), this, SLOT(updateVST()),
+                    Qt::QueuedConnection);
+            
+            updateQTGUI(menu, effect->getParameter(vstParamCount));
+            
+            vstParamCount++;
+        }
+        // save the QObject of this iteration
+        lastObject = (*i);
+    }
+    
+    
+#if FAUSTQT_DEBUG>1
+    qDebug() << "VST parameters assigned: " << vstParamCount;
+#endif
+    
+#ifdef HTTPCTRL
+    httpdinterface->run();
+#ifdef QRCODECTRL
+    // FIXME: This will pop up each time the GUI is opened. We should maybe have
+    // a little button in the GUI somewhere so that the user can show the QR
+    // code when needed.
+    qtinterface->displayQRCode(httpdinterface->getTCPPort());
+#endif
+#endif
+    
+#ifdef OSCCTRL
+    oscinterface->run();
+#endif
+    
+    qtinterface->run();
+    
+    // The STYLE symbol is set during compilation when using the -style option
+    // of the faust2faustvst script or the corresponding options in the
+    // Makefile. You can also set this manually if needed, but note that the
+    // corresponding resource needs to be present in the qmake project (this is
+    // taken care of automagically when using the -style option). Otherwise (or
+    // if no style was specified) the default style will be used. -ag
+#ifdef STYLE
+    // set the style sheet for this GUI, if any
+    QString styleSheet("");
+    // C preprocessor stringify magic to insert the style sheet name
+#define __xstr(s) __str(s)
+#define __str(s) #s
+    QFile file(":/" __xstr(STYLE) ".qss");
+    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        styleSheet = QLatin1String(file.readAll());
+        file.close();
+    }
+    widget->setStyleSheet(styleSheet);
+#endif
+    
+    // embed the plug-in widget into the window provided by the host
+    Display* display = QX11Info::display();
+    XReparentWindow(display, widget->winId(), WId(ptr), 0, 0);
+    XMapWindow(display, WId(ptr));
+    XFlush(display);
+    
+    widget->show();
+    
+#if FAUSTQT_DEBUG>1
+    qDebug() << "Number of controls: " << controls.size();
+    qDebug() << "Number of passive controls: " << passive_controls.size();
+#endif
+    
+    uidsp = dsp;
+    return true;
+}
+
+/**
+ * @brief VSTQtGUI::idle
+ * - idle() is called repeatedly at some time interval determined by the host
+ *   to process any pending GUI events
+ * - it also updates control elements in the GUI as needed
+ */
+void VSTQtGUI::idle()
+{
+    if (qApp) {
+        QApplication::processEvents();
+        for (int i = 0; i < controls.size(); ++i) {
+            float val = effect->getParameter(i);
+            if (!controls[i].empty() && control_values[i] != val) {
+                if (effect->isPassiveControl(i)) {
+                    for (QList<QObject*>::iterator it = controls[i].begin();
+                         it != controls[i].end(); ++it)
+                        updatePassiveControl(*it, val);
+                } else {
+                    for (QList<QObject*>::iterator it = controls[i].begin();
+                         it != controls[i].end(); ++it)
+                        updateQTGUI(*it, val, false);
+                }
+                control_values[i] = val;
+            }
+        }
+    }
+#if FAUSTQT_DEBUG
+    else
+        qDebug("qApp ERROR! QApplication doesn't exist!");
+#endif
+}
+
+/**
+ * @brief VSTQtGUI::close
+ * - when closing the plugin GUI, all GUI elements are destroyed and the
+ *   controls and passive_controls vectors are cleared
+ */
+void VSTQtGUI::close()
+{
+#ifdef HTTPCTRL
+    httpdinterface->stop();
+    delete httpdinterface;
+    httpdinterface = NULL;
+#endif
+#ifdef OSCCTRL
+    oscinterface->stop();
+    delete oscinterface;
+    oscinterface = NULL;
+#endif
+    qtinterface->stop();
+    delete qtinterface;
+    qtinterface = NULL;
+    delete widget;
+    widget = NULL;
+    delete uidsp;
+    uidsp = NULL;
+    controls.clear();
+    passive_controls.clear();
+    
+#if FAUSTQT_DEBUG
+    qDebug("close editor");
+#endif
+    AEffEditor::close();
+}
+
+/**
+ * @brief VSTQtGUI::getRect
+ * - required pointer "rect" to determine the size of the plug-in window
+ * @param rect
+ * @return
+ */
+bool VSTQtGUI::getRect (ERect** rect)
+{
+    *rect = &rectangle;
+    return true;
+}
+
+/**
+ * @brief VSTQtGUI::valueToVST
+ * - converts a value from the Faust to the VST representation
+ * @param value
+ * @param minimum
+ * @param maximum
+ * @return
+ */
+float VSTQtGUI::valueToVST(double value, double minimum,
+                           double maximum)
+{
+    float newFloat = 0.f;
+    if(minimum==maximum)
+        return newFloat;
+    else {
+        newFloat = (value-minimum) / (maximum-minimum);
+        return newFloat;
+    }
+}
+
+/**
+ * @brief VSTQtGUI::updateQTGUI
+ * - method to update a GUI element
+ * - called for GUI elements in the open() and idle() methods
+ * - VST values are converted to Faust ranges to determine the position of
+ *   sliders, knobs, etc.
+ * @param object
+ * @param value
+ */
+void VSTQtGUI::updateQTGUI(QObject* object, float value, bool init)
+{
+    const double eps = 1e-5;
+    double minimum, maximum, step, newValue;
+    char* valueChar;
+    
+    if (init) {
+        int vstParam = object->property("vstParam").toInt();
+        control_values[vstParam] = value;
+    }
+    
+    // checkboxes and radio buttons need special treatment
+    QCheckBox* checkBox = qobject_cast<QCheckBox*>(object);
+    if (checkBox) {
+        if (value < 0.5f)
+            checkBox->setChecked(false);
+        else
+            checkBox->setChecked(true);
+        return;
+    }
+    
+    minimum = object->property("minimum").toDouble();
+    maximum = object->property("maximum").toDouble();
+    step    = object->property("singleStep").toDouble();
+    
+    QRadioButton* radioBut = qobject_cast<QRadioButton*>(object);
+    if (radioBut) {
+        int radioVal = radioBut->property("value").toInt();
+        float val = valueToVST(radioVal, minimum, maximum);
+        if (fabs(val-value)/(1+fabs(maximum-minimum)) < eps)
+            radioBut->click();
+        return;
+    }
+    
+    if (QString(object->metaObject()->className())=="uiMenu")
+        valueChar = "currentIndex";
+    else
+        valueChar = "value";
+    
+#if FAUSTQT_DEBUG>1
+    int vstParam = object->property("vstParam").toInt();
+    qDebug() << "QTGUI: vstParam: " << vstParam;
+    qDebug() << "QTGUI: VST value: " << value;
+    qDebug() << "QTGUI: old Qt value: "
+	   << object->property(valueChar).toDouble();
+#endif
+    
+    newValue = (minimum==maximum)?minimum : minimum+quantize(value*
+                                                             (maximum-minimum), step);
+    
+    if (fabs(newValue) < fabs(step) ||
+        fabs(newValue)/fabs(maximum-minimum) < eps)
+        newValue = 0.0;
+    
+    // set new value with setProperty("value",..), as setValue() is not
+    // defined for QObject
+    object->setProperty(valueChar, newValue);
+#if FAUSTQT_DEBUG>1
+    qDebug() << "QTGUI: new Qt value: "
+	   << object->property(valueChar).toDouble();
+#endif
+    uiMenu* menu = dynamic_cast<uiMenu*>(object);
+    if (menu) menu->updateZone(0); // updates the currentIndex
+}
+
+/**
+ * @brief VSTQtGUI::updatePassiveControl
+ * - method to update the passive control elements (bargraphs)
+ * - called in idle()
+ * @param object
+ */
+void VSTQtGUI::updatePassiveControl(QObject* object, float value)
+{
+    int vstParam = object->property("vstParam").toInt();
+    float minimum  = effect->getMinimum(vstParam);
+    float maximum  = effect->getMaximum(vstParam);
+    
+    // convert the VST value back to the corresponding Faust value
+    float fValue = value*maximum - value*minimum + minimum;
+    
+    AbstractDisplay* bargraph  = dynamic_cast<AbstractDisplay*>(object);
+    QDoubleSpinBox* numDisplay = dynamic_cast<QDoubleSpinBox*>(object);
+    
+    if(bargraph)
+        bargraph->setValue(fValue);
+    else if(numDisplay)
+        numDisplay->setValue(fValue);
+}
+
+/***********************
+ *******  Slots ********
+ ***********************/
+
+// The slots are called in response to interactive changes of a GUI element
+// (e.g., slider movements). Here we update the corresponding VST parameters.
+
+/**
+ * @brief VSTQtGUI::updateVST_buttonPressed
+ * - slot for pressing a button object
+ */
+void VSTQtGUI::updateVST_buttonPressed()
+{
+    int vstParam = QObject::sender()->property("vstParam").toInt();
+#if FAUSTQT_DEBUG>1
+    qDebug() << "VST: vstParam: " << vstParam;
+    qDebug() << "VST: button pressed";
+#endif
+    effect->setParameter(vstParam, 1.0f);
+    control_values[vstParam] = 1.0f;
+}
+
+/**
+ * @brief VSTQtGUI::updateVST_buttonReleased
+ * - slot for releasing a button object
+ */
+void VSTQtGUI::updateVST_buttonReleased()
+{
+    int vstParam = QObject::sender()->property("vstParam").toInt();
+#if FAUSTQT_DEBUG>1
+    qDebug() << "VST: vstParam: " << vstParam;
+    qDebug() << "VST: button released";
+#endif
+    effect->setParameter(vstParam, 0.0f);
+    control_values[vstParam] = 0.0f;
+}
+
+/**
+ * @brief VSTQtGUI::updateVST_checkBox
+ * - slot for check boxes
+ */
+void VSTQtGUI::updateVST_checkBox()
+{
+    int vstParam = QObject::sender()->property("vstParam").toInt();
+#if FAUSTQT_DEBUG>1
+    qDebug() << "VST: vstParam: " << vstParam;
+#endif
+    
+    // if CheckBox == checked
+    if(QObject::sender()->property("checked").toBool()) {
+#if FAUSTQT_DEBUG>1
+        qDebug("checkbox checked");
+#endif
+        effect->setParameter(vstParam, 1.0f);
+        control_values[vstParam] = 1.0f;
+    } else {
+#if FAUSTQT_DEBUG>1
+        qDebug("checkbox unchecked");
+#endif
+        effect->setParameter(vstParam, 0.0f);
+        control_values[vstParam] = 0.0f;
+    }
+}
+
+/**
+ * @brief VSTQtGUI::updateVST
+ * - slot for all other active control elements (sliders, knobs, menus, radio
+ *   buttons etc.)
+ */
+void VSTQtGUI::updateVST()
+{
+    double value, minimum, maximum, step;
+    int vstParam;
+    
+    // for uiMenu we have the property "currentIndex" instead of the property
+    // "value"
+    if (QString(QObject::sender()->metaObject()->className())=="uiMenu")
+        value = QObject::sender()->property("currentIndex").toDouble();
+    else
+        value = QObject::sender()->property("value").toDouble();
+    vstParam  = QObject::sender()->property("vstParam").toInt();
+    minimum   = QObject::sender()->property("minimum").toDouble();
+    maximum   = QObject::sender()->property("maximum").toDouble();
+    step      = QObject::sender()->property("singleStep").toDouble();
+    
+#if FAUSTQT_DEBUG>1
+    qDebug() << "VST: vstParam: "       << vstParam;
+    char text[32];
+    effect->getParameterName(vstParam, text);
+    qDebug() << "VST: label: "          << text;
+    qDebug() << "VST: min: "            << minimum;
+    qDebug() << "VST: max: "            << maximum;
+    qDebug() << "VST: step: "           << step;
+    qDebug() << "VST: new Qt value: "   << value;
+    qDebug() << "VST: old VST value: "  << effect->getParameter(vstParam);
+#endif
+    
+    float newFloat = valueToVST(value, minimum, maximum);
+    effect->setParameter(vstParam, newFloat);
+    control_values[vstParam] = newFloat;
+#if FAUSTQT_DEBUG>1
+    qDebug() << "VST: new VST value: " << effect->getParameter(vstParam);
+#endif
+#if VOICE_CTRLS
+    if (vstParam >= effect->getNumControls()) {
+        // Extra polyphony and tuning controls. Generate some informative tooltips
+        // for these so that the user understands the meaning of these values.
+        QWidget *widget = qobject_cast<QWidget*>(QObject::sender());
+        char text[32];
+        effect->getParameterDisplay(vstParam, text);
+        widget->setToolTip(text);
+        // Also make sure that we trigger a host GUI update for changes in the
+        // tuning control here, since this isn't done elsewhere.
+        if (vstParam > effect->getNumControls())
+            effect->updateDisplay();
+    }
+#endif
+}
+
+#endif // FAUST_UI