diff options
Diffstat (limited to 'attic/muse2-oom/muse2/muse/dssihost.cpp')
| -rw-r--r-- | attic/muse2-oom/muse2/muse/dssihost.cpp | 3059 |
1 files changed, 3059 insertions, 0 deletions
diff --git a/attic/muse2-oom/muse2/muse/dssihost.cpp b/attic/muse2-oom/muse2/muse/dssihost.cpp new file mode 100644 index 00000000..986abea1 --- /dev/null +++ b/attic/muse2-oom/muse2/muse/dssihost.cpp @@ -0,0 +1,3059 @@ +//============================================================================= +// MusE +// Linux Music Editor +// $Id: dssihost.cpp,v 1.15.2.16 2009/12/15 03:39:58 terminator356 Exp $ +// +// Copyright (C) 2002-2006 by Werner Schweer and others +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License version 2. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +//============================================================================= + +#include "config.h" +#ifdef DSSI_SUPPORT + +// Turn on debugging messages +//#define DSSI_DEBUG + +// Support vst state saving/loading with vst chunks. Requires patches to DSSI and DSSI-vst! +//#define DSSI_VST_CHUNK_SUPPORT + +#include <string.h> +#include <signal.h> +#include <dlfcn.h> +#include <stdlib.h> +#include <sys/stat.h> +//#include <dssi.h> +//#include <alsa/asoundlib.h> + +#include <QDir> +#include <QFileInfo> +#include <QMenu> + +#include "dssihost.h" +#include "synth.h" +#include "audio.h" +#include "jackaudio.h" +//#include "../driver/jackaudio.h" // p4.0.2 +#include "midi.h" +#include "midiport.h" +#include "stringparam.h" +#include "plugin.h" +//#include "al/al.h" +//#include "al/xml.h" +#include "xml.h" +#include "song.h" +//#include "midictrl.h" +//#include "ladspaplugin.h" + +#include "app.h" +#include "globals.h" +#include "globaldefs.h" +//#include "al/dsp.h" +#include "gconfig.h" + +/* +static lo_server_thread serverThread; +static char osc_path_tmp[1024]; +static char* url; + +//--------------------------------------------------------- +// oscError +//--------------------------------------------------------- + +static void oscError(int num, const char *msg, const char *path) + { + fprintf(stderr, "MusE: liblo server error %d in path %s: %s\n", + num, path, msg); + } + +//--------------------------------------------------------- +// oscDebugHandler +//--------------------------------------------------------- + +static int oscDebugHandler(const char* path, const char* types, lo_arg** argv, + int argc, void*, void*) + { + printf("MusE: got unhandled OSC message:\n path: <%s>\n", path); + for (int i = 0; i < argc; i++) { + printf(" arg %d '%c' ", i, types[i]); + lo_arg_pp(lo_type(types[i]), argv[i]); + printf("\n"); + } + return 1; + } + +//--------------------------------------------------------- +// oscUpdate +//--------------------------------------------------------- + +int DssiSynthIF::oscUpdate(lo_arg **argv) + { + const char *url = (char *)&argv[0]->s; + + if (uiTarget) + lo_address_free(uiTarget); + char* host = lo_url_get_hostname(url); + char* port = lo_url_get_port(url); + uiTarget = lo_address_new(host, port); + free(host); + free(port); + + if (uiOscPath) + free(uiOscPath); + uiOscPath = lo_url_get_path(url); + int pl = strlen(uiOscPath); + + if (uiOscControlPath) + free(uiOscControlPath); + uiOscControlPath = (char *)malloc(pl + 10); + sprintf(uiOscControlPath, "%s/control", uiOscPath); + + if (uiOscConfigurePath) + free(uiOscConfigurePath); + uiOscConfigurePath = (char *)malloc(pl + 12); + sprintf(uiOscConfigurePath, "%s/configure", uiOscPath); + + if (uiOscProgramPath) + free(uiOscProgramPath); + uiOscProgramPath = (char *)malloc(pl + 10); + sprintf(uiOscProgramPath, "%s/program", uiOscPath); + + if (uiOscShowPath) + free(uiOscShowPath); + uiOscShowPath = (char *)malloc(pl + 10); + sprintf(uiOscShowPath, "%s/show", uiOscPath); + + // At this point a more substantial host might also call + // configure() on the UI to set any state that it had remembered + // for the plugin instance. But we don't remember state for + // plugin instances (see our own configure() implementation in + // osc_configure_handler), and so we have nothing to send except + // the optional project directory. + + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::oscUpdate synth name:%s url:%s uiTarget:%p uiOscPath:%s uiOscConfigurePath:%s museProject:%s\n", synti->name().ascii(), url, uiTarget, uiOscPath, uiOscConfigurePath, museProject.ascii()); + #endif + + //lo_send(uiTarget, uiOscConfigurePath, "ss", + //DSSI_PROJECT_DIRECTORY_KEY, song->projectPath().toAscii().data()); + lo_send(uiTarget, uiOscConfigurePath, "ss", + DSSI_PROJECT_DIRECTORY_KEY, museProject.ascii()); + +#if 0 + // Send current bank/program (-FIX- another race...) + if (instance->pendingProgramChange < 0) { + unsigned long bank = instance->currentBank; + unsigned long program = instance->currentProgram; + instance->uiNeedsProgramUpdate = 0; + if (instance->uiTarget) { + lo_send(instance->uiTarget, instance->ui_osc_program_path, "ii", bank, program); + } + } + + // Send control ports + for (i = 0; i < instance->plugin->controlIns; i++) { + int in = i + instance->firstControlIn; + int port = pluginControlInPortNumbers[in]; + lo_send(instance->uiTarget, instance->ui_osc_control_path, "if", port, + pluginControlIns[in]); + // Avoid overloading the GUI if there are lots and lots of ports + if ((i+1) % 50 == 0) + usleep(300000); + } +#endif + return 0; + } + +//--------------------------------------------------------- +// oscMessageHandler +//--------------------------------------------------------- + +int oscMessageHandler(const char* path, const char* types, lo_arg** argv, + int argc, void* data, void* user_data) + { + const char* p = path; + + #ifdef DSSI_DEBUG + if(argc) + { + printf("oscMessageHandler: path:%s argc:%d\n", path, argc); + for(int i = 0; i < argc; ++i) + { + printf(" "); + lo_arg_pp((lo_type)types[i], argv[i]); + } + printf("\n"); + } + else + { + printf("%s\n", path); + printf("oscMessageHandler: no args, path:%s\n", path); + } + #endif + + if (strncmp(p, "/dssi/", 6)) + return oscDebugHandler(path, types, argv, argc, data, user_data); + + p += 6; + //p = strrchr(p, "/"); + + SynthIList* sl = song->syntis(); + DssiSynthIF* instance = 0; + SynthI* synti = 0; + + #ifdef DSSI_DEBUG + fprintf(stderr, "oscMessageHandler: song->syntis() size:%d\n", sl->size()); + #endif + + for(int retry = 0; retry < 5; ++retry) + { + #ifdef DSSI_DEBUG + fprintf(stderr, "oscMessageHandler: search retry number:%d ...\n", retry); + #endif + + //if(uiOscPath) + // break; + + for(iSynthI si = sl->begin(); si != sl->end(); ++si) + { + #ifdef DSSI_DEBUG + fprintf(stderr, "oscMessageHandler: searching for synth p:%s: checking instances:%s\n", p, (*si)->name().ascii()); + #endif + + //int l = strlen((*si)->name().toAscii().data()); + //if (!strncmp(p, (*si)->name().toAscii().data(), l)) { + //int l = strlen((*si)->name().ascii()); + const char* sub = strstr(p, (*si)->name().ascii()); + + //if(!strncmp(p, (*si)->name().ascii(), l)) + if(sub != NULL) + { + synti = *si; + instance = (DssiSynthIF*)(synti->sif()); + + //p += l; + p = sub + strlen((*si)->name().ascii()); + + break; + } + } + if(instance) + break; + + sleep(1); + } + + if(!instance) + { + fprintf(stderr, "oscMessageHandler: error: no instance\n"); + return oscDebugHandler(path, types, argv, argc, data, user_data); + } + + if (*p != '/' || *(p + 1) == 0) + { + fprintf(stderr, "oscMessageHandler: error: end or no /\n"); + return oscDebugHandler(path, types, argv, argc, data, user_data); + } + + ++p; + + #ifdef DSSI_DEBUG + fprintf(stderr, "oscMessageHandler: method:%s\n", p); + #endif + + if (!strcmp(p, "configure") && argc == 2 && !strcmp(types, "ss")) + return instance->oscConfigure(argv); + else if (!strcmp(p, "control") && argc == 2 && !strcmp(types, "if")) + return instance->oscControl(argv); + else if (!strcmp(p, "midi") && argc == 1 && !strcmp(types, "m")) + return instance->oscMidi(argv); + else if (!strcmp(p, "program") && argc == 2 && !strcmp(types, "ii")) + return instance->oscProgram(argv); + else if (!strcmp(p, "update") && argc == 1 && !strcmp(types, "s")) + return instance->oscUpdate(argv); + else if (!strcmp(p, "exiting") && argc == 0) + return instance->oscExiting(argv); + return oscDebugHandler(path, types, argv, argc, data, user_data); + } +*/ + +//--------------------------------------------------------- +// scanDSSILib +//--------------------------------------------------------- + +static void scanDSSILib(QFileInfo& fi) // ddskrjo removed const for argument + { + //void* handle = dlopen(fi.filePath().toAscii().data(), RTLD_NOW); + void* handle = dlopen(fi.filePath().toLatin1().constData(), RTLD_NOW); + //void* handle = dlopen(fi.absFilePath().toLatin1().constData(), RTLD_NOW); + + if (handle == 0) { + fprintf(stderr, "scanDSSILib: dlopen(%s) failed: %s\n", + //fi.filePath().toAscii().data(), dlerror()); + fi.filePath().toLatin1().constData(), dlerror()); + //fi.absFilePath().toLatin1().constData(), dlerror()); + + return; + } + DSSI_Descriptor_Function dssi = (DSSI_Descriptor_Function)dlsym(handle, "dssi_descriptor"); + + if (!dssi) + { + /* + const char *txt = dlerror(); + if (txt) + { + fprintf(stderr, + "Unable to find dssi_descriptor() function in plugin " + "library file \"%s\": %s.\n" + "Are you sure this is a DSSI plugin file?\n", + //fi.filePath().toAscii().data(), + fi.filePath().ascii(), + //fi.absFilePath().toLatin1().constData(), + + txt); + dlclose(handle); + exit(1); + } + */ + dlclose(handle); + return; + } + else + { + //const DSSI_Descriptor* descr; + for (int i = 0;; ++i) + { + const DSSI_Descriptor* descr; + + // CRAPPY PLUGIN ALERT: + // Out of many plugins, with several, Valgrind says something in here is allocated with new. + descr = dssi(i); + if (descr == 0) + break; + + #ifdef DSSI_DEBUG + fprintf(stderr, "scanDSSILib: name:%s inPlaceBroken:%d\n", descr->LADSPA_Plugin->Name, LADSPA_IS_INPLACE_BROKEN(descr->LADSPA_Plugin->Properties)); + #endif + + // Listing synths only while excluding effect plugins: + // Do the exact opposite of what dssi-vst.cpp does for listing ladspa plugins. + // That way we cover all bases - effect plugins and synths. + // Non-synths will show up in the ladspa effect dialog, while synths will show up here... + // There should be nothing left out... + if(descr->run_synth || + descr->run_synth_adding || + descr->run_multiple_synths || + descr->run_multiple_synths_adding) + + { + const QString label(descr->LADSPA_Plugin->Label); + + // Make sure it doesn't already exist. + std::vector<Synth*>::iterator is; + for(is = synthis.begin(); is != synthis.end(); ++is) + { + Synth* s = *is; + //#ifdef DSSI_DEBUG + // fprintf(stderr, "scanDSSILib: name:%s listname:%s lib:%s listlib:%s\n", + // label.toLatin1().constData(), s->name().toLatin1().constData(), fi.baseName(true).toLatin1().constData(), s->baseName().toLatin1().constData()); + //#endif + + if(s->name() == label && s->baseName() == fi.completeBaseName()) + break; + } + if(is != synthis.end()) + continue; + + DssiSynth* s = new DssiSynth(fi, descr); + + if(debugMsg) + { + fprintf(stderr, "scanDSSILib: name:%s listname:%s lib:%s listlib:%s\n", + label.toLatin1().constData(), s->name().toLatin1().constData(), fi.completeBaseName().toLatin1().constData(), s->baseName().toLatin1().constData()); + int ai = 0, ao = 0, ci = 0, co = 0; + for(unsigned long pt = 0; pt < descr->LADSPA_Plugin->PortCount; ++pt) + { + LADSPA_PortDescriptor pd = descr->LADSPA_Plugin->PortDescriptors[pt]; + if(LADSPA_IS_PORT_INPUT(pd) && LADSPA_IS_PORT_AUDIO(pd)) + ai++; + else + if(LADSPA_IS_PORT_OUTPUT(pd) && LADSPA_IS_PORT_AUDIO(pd)) + ao++; + else + if(LADSPA_IS_PORT_INPUT(pd) && LADSPA_IS_PORT_CONTROL(pd)) + ci++; + else + if(LADSPA_IS_PORT_OUTPUT(pd) && LADSPA_IS_PORT_CONTROL(pd)) + co++; + } + fprintf(stderr, "audio ins:%d outs:%d control ins:%d outs:%d\n", ai, ao, ci, co); + } + + synthis.push_back(s); + } + else + { + // NOTE: Just a test + //QFileInfo ffi(fi); + //plugins.add(&ffi, LADSPA_Descriptor_Function(NULL), descr->LADSPA_Plugin, false); + //plugins.add(&ffi, descr, false); + } + } + } + dlclose(handle); + } + +//--------------------------------------------------------- +// scanVstDir +//--------------------------------------------------------- + +static void scanDSSIDir(QString& s) // ddskrjo removed const for argument +{ + if(debugMsg) + //printf("scan DSSI plugin dir <%s>\n", s.toAscii().data()); + printf("scanDSSIDir: scan DSSI plugin dir <%s>\n", s.toLatin1().constData()); + +#ifdef __APPLE__ + QDir pluginDir(s, QString("*.dylib"), QDir::Unsorted, QDir::Files); +#else + QDir pluginDir(s, QString("*.so"), QDir::Unsorted, QDir::Files); +#endif + if(!pluginDir.exists()) + return; + + //const QFileInfoList list = pluginDir.entryInfoList(); + //for (int i = 0; i < list.size(); ++i) { + //QFileInfo fi = list.at(i); + //scanDSSILib(fi); + //} + + QStringList list = pluginDir.entryList(); + for(int i = 0; i < list.count(); ++i) + { + if(debugMsg) + printf("scanDSSIDir: found %s\n", (s + QString("/") + list[i]).toLatin1().constData()); + + QFileInfo fi(s + QString("/") + list[i]); + scanDSSILib(fi); + } +} + +//--------------------------------------------------------- +// initDSSI +//--------------------------------------------------------- + +void initDSSI() + { + const char* dssiPath = getenv("DSSI_PATH"); + if (dssiPath == 0) + dssiPath = "/usr/local/lib64/dssi:/usr/lib64/dssi:/usr/local/lib/dssi:/usr/lib/dssi"; + + //const char* ladspaPath = getenv("LADSPA_PATH"); + //if (ladspaPath == 0) + // ladspaPath = "/usr/local/lib64/ladspa:/usr/lib64/ladspa:/usr/local/lib/ladspa:/usr/lib/ladspa"; + + const char* p = dssiPath; + //QString pth = QString(dssiPath) + QString(":") + QString(ladspaPath); + //const char* p = pth.toLatin1().constData(); + while (*p != '\0') { + const char* pe = p; + while (*pe != ':' && *pe != '\0') + pe++; + + int n = pe - p; + if (n) { + char* buffer = new char[n + 1]; + strncpy(buffer, p, n); + buffer[n] = '\0'; + QString tmpStr(buffer); + scanDSSIDir(tmpStr); + delete[] buffer; + } + p = pe; + if (*p == ':') + p++; + } + + // Create OSC thread + //serverThread = lo_server_thread_new(0, oscError); + //snprintf(osc_path_tmp, 31, "/dssi"); + //char* tmp = lo_server_thread_get_url(serverThread); + //url = (char *)malloc(strlen(tmp) + strlen(osc_path_tmp)); + //sprintf(url, "%s%s", tmp, osc_path_tmp + 1); + //free(tmp); + //lo_server_thread_add_method(serverThread, 0, 0, oscMessageHandler, 0); + //lo_server_thread_start(serverThread); + } + +//--------------------------------------------------------- +// DssiSynth +// Synth.label = plug.Label +// Synth.descr = plug.Name +// Synth.maker = plug.maker +// Synth.version = nil (no such field in ladspa, maybe try copyright instead) +//--------------------------------------------------------- + +DssiSynth::DssiSynth(QFileInfo& fi, const DSSI_Descriptor* d) : // ddskrjo removed const from QFileInfo + //Synth(fi, label, descr, maker, ver) + Synth(fi, QString(d->LADSPA_Plugin->Label), QString(d->LADSPA_Plugin->Name), QString(d->LADSPA_Plugin->Maker), QString()) +{ + df = 0; + handle = 0; + dssi = 0; + _hasGui = false; + + const LADSPA_Descriptor* descr = d->LADSPA_Plugin; + + _portCount = descr->PortCount; + //_portDescriptors = 0; + //if(_portCount) + // _portDescriptors = new LADSPA_PortDescriptor[_portCount]; + + _inports = 0; + _outports = 0; + _controlInPorts = 0; + _controlOutPorts = 0; + for(unsigned long k = 0; k < _portCount; ++k) + { + LADSPA_PortDescriptor pd = descr->PortDescriptors[k]; + //_portDescriptors[k] = pd; + if(pd & LADSPA_PORT_AUDIO) + { + if(pd & LADSPA_PORT_INPUT) + ++_inports; + else + if(pd & LADSPA_PORT_OUTPUT) + ++_outports; + } + else + if(pd & LADSPA_PORT_CONTROL) + { + if(pd & LADSPA_PORT_INPUT) + ++_controlInPorts; + else + if(pd & LADSPA_PORT_OUTPUT) + ++_controlOutPorts; + } + } + + _inPlaceCapable = !LADSPA_IS_INPLACE_BROKEN(descr->Properties); + + // Blacklist vst plugins in-place configurable for now. + if ((_inports != _outports) || (fi.completeBaseName() == QString("dssi-vst") && !config.vstInPlace)) + _inPlaceCapable = false; +} + +DssiSynth::~DssiSynth() +{ + +} + +//--------------------------------------------------------- +// createSIF +//--------------------------------------------------------- + +SynthIF* DssiSynth::createSIF(SynthI* synti) +{ + if (_instances == 0) + { + //handle = dlopen(info.filePath().toAscii().data(), RTLD_NOW); + handle = dlopen(info.filePath().toLatin1().constData(), RTLD_NOW); + //handle = dlopen(info.absFilePath().toLatin1().constData(), RTLD_NOW); + + if (handle == 0) + { + fprintf(stderr, "DssiSynth::createSIF dlopen(%s) failed: %s\n", + //info.filePath().toAscii().data(), dlerror()); + info.filePath().toLatin1().constData(), dlerror()); + //info.absFilePath().toLatin1().constData(), dlerror()); + + return 0; + } + df = (DSSI_Descriptor_Function)dlsym(handle, "dssi_descriptor"); + + if (!df) { + const char *txt = dlerror(); + fprintf(stderr, + "Unable to find dssi_descriptor() function in plugin " + "library file \"%s\": %s.\n" + "Are you sure this is a DSSI plugin file?\n", + //info.filePath().toAscii().data(), + info.filePath().toLatin1().constData(), + //info.absFilePath().toLatin1().constData(), + + txt ? txt : "?"); + dlclose(handle); + handle = 0; + return 0; + } + for (int i = 0;; ++i) + { + dssi = df(i); + if (dssi == 0) + break; + QString label(dssi->LADSPA_Plugin->Label); + if (label == _name) + break; + } + + if(dssi != 0) + { + _inports = 0; + _outports = 0; + _controlInPorts = 0; + _controlOutPorts = 0; + + pIdx.clear(); + opIdx.clear(); + iIdx.clear(); + oIdx.clear(); + rpIdx.clear(); + iUsedIdx.clear(); + midiCtl2PortMap.clear(); + port2MidiCtlMap.clear(); + //synti->_guiUpdateControls.clear(); + + const LADSPA_Descriptor* descr = dssi->LADSPA_Plugin; + //#ifdef DSSI_DEBUG + // printf("DssiSynth::createSIF ladspa plugin PortCount:%lu\n", d->PortCount); + //#endif + + _portCount = descr->PortCount; + + for (unsigned long k = 0; k < _portCount; ++k) + { + LADSPA_PortDescriptor pd = descr->PortDescriptors[k]; + + #ifdef DSSI_DEBUG + printf("DssiSynth::createSIF ladspa plugin Port:%ld Name:%s descriptor:%x\n", k, descr->PortNames[k], pd); + #endif + + if (LADSPA_IS_PORT_AUDIO(pd)) + { + if (LADSPA_IS_PORT_INPUT(pd)) + { + ++_inports; + iIdx.push_back(k); + iUsedIdx.push_back(false); // Start out with all false. + } + else if (LADSPA_IS_PORT_OUTPUT(pd)) + { + ++_outports; + oIdx.push_back(k); + } + + rpIdx.push_back((unsigned long)-1); + } + else if (LADSPA_IS_PORT_CONTROL(pd)) + { + if (LADSPA_IS_PORT_INPUT(pd)) + { + rpIdx.push_back(_controlInPorts); + ++_controlInPorts; + pIdx.push_back(k); + // Set to false at first. + //synti->_guiUpdateControls.push_back(false); + } + else if (LADSPA_IS_PORT_OUTPUT(pd)) + { + rpIdx.push_back((unsigned long)-1); + ++_controlOutPorts; + opIdx.push_back(k); + } + } + } + + _inPlaceCapable = !LADSPA_IS_INPLACE_BROKEN(descr->Properties); + // Blacklist vst plugins in-place configurable for now. + if((_inports != _outports) || (info.completeBaseName() == QString("dssi-vst") && !config.vstInPlace)) + _inPlaceCapable = false; + } + } + + if (dssi == 0) + { + //fprintf(stderr, "cannot found DSSI synti %s\n", _name.toAscii().data()); + fprintf(stderr, "cannot find DSSI synti %s\n", _name.toLatin1().constData()); + dlclose(handle); + handle = 0; + df = 0; + return 0; + } + + DssiSynthIF* sif = new DssiSynthIF(synti); + ++_instances; + sif->init(this); + + //_plugin->incInstances(1); + + + +// static char oscUrl[1024]; + //snprintf(oscUrl, 1024, "%s/%s", url, synti->name().toAscii().data()); + //snprintf(oscUrl, 1024, "%s/%s", url, synti->name().toLatin1().constData()); +// snprintf(oscUrl, 1024, "%s/%s/%s", url, info.baseName().toLatin1().constData(), synti->name().toLatin1().constData()); + //QString guiPath(info.path() + "/" + info.baseName()); + QString guiPath(info.path() + "/" + info.baseName()); + QDir guiDir(guiPath, "*", QDir::Unsorted, QDir::Files); + _hasGui = guiDir.exists(); + + //sif->initGui(); + + return sif; +} + +//--------------------------------------------------------- +// guiVisible +//--------------------------------------------------------- + +bool DssiSynthIF::guiVisible() const + { + //return _guiVisible; + #ifdef OSC_SUPPORT + return _oscif.oscGuiVisible(); + #endif + return false; + } + +//--------------------------------------------------------- +// showGui +//--------------------------------------------------------- + +void DssiSynthIF::showGui(bool v) + { + #ifdef OSC_SUPPORT + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::showGui(): v:%d visible:%d\n", v, guiVisible()); + #endif + + _oscif.oscShowGui(v); + + #endif // OSC_SUPPORT + + /* + if (v == guiVisible()) + return; + + //if(guiPid == -1) + if((guiQProc == 0) || (!guiQProc->isRunning())) + { + // We need an indicator that update was called - update must have been called to get new path etc... + // If the process is not running this path is invalid, right? + if(uiOscPath) + free(uiOscPath); + uiOscPath = 0; + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::showGui(): No QProcess or process not running. Starting gui...\n"); + #endif + + initGui(); + } + + //for (int i = 0; i < 5; ++i) { + for (int i = 0; i < 10; ++i) { // Give it a wee bit more time? + if (uiOscPath) + break; + sleep(1); + } + if (uiOscPath == 0) { + printf("DssiSynthIF::showGui(): no uiOscPath. Error: Timeout - synth gui did not start within 10 seconds.\n"); + return; + } + + char uiOscGuiPath[strlen(uiOscPath)+6]; + sprintf(uiOscGuiPath, "%s/%s", uiOscPath, v ? "show" : "hide"); + #ifdef DSSI_DEBUG + printf("DssiSynthIF::showGui(): Sending show/hide uiOscGuiPath:%s\n", uiOscGuiPath); + #endif + + lo_send(uiTarget, uiOscGuiPath, ""); + _guiVisible = v; + */ + } + +//--------------------------------------------------------- +// receiveEvent +//--------------------------------------------------------- + +//MidiEvent DssiSynthIF::receiveEvent() +// { +// return MidiEvent(); +// } +MidiPlayEvent DssiSynthIF::receiveEvent() + { + return MidiPlayEvent(); + } + +//--------------------------------------------------------- +// init +//--------------------------------------------------------- + +bool DssiSynthIF::init(DssiSynth* s) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init\n"); + #endif + + synth = s; + const DSSI_Descriptor* dssi = synth->dssi; + const LADSPA_Descriptor* ld = dssi->LADSPA_Plugin; + handle = ld->instantiate(ld, sampleRate); + + #ifdef OSC_SUPPORT + _oscif.oscSetSynthIF(this); + #endif + + queryPrograms(); + + int inports = synth->_inports; + if(inports != 0) + { + audioInBuffers = new float*[inports]; + for(int k = 0; k < inports; ++k) + { + //audioInBuffers[k] = new LADSPA_Data[segmentSize]; + //posix_memalign((void**)(audioInBuffers + k), 16, sizeof(float) * segmentSize); + posix_memalign((void**)&audioInBuffers[k], 16, sizeof(float) * segmentSize); + memset(audioInBuffers[k], 0, sizeof(float) * segmentSize); + ld->connect_port(handle, synth->iIdx[k], audioInBuffers[k]); + } + } + + int outports = synth->_outports; + if(outports != 0) + { + audioOutBuffers = new float*[outports]; + for(int k = 0; k < outports; ++k) + { + //audioOutBuffers[k] = new LADSPA_Data[segmentSize]; + //posix_memalign((void**)(audioOutBuffers + k), 16, sizeof(float) * segmentSize); + posix_memalign((void**)&audioOutBuffers[k], 16, sizeof(float) * segmentSize); + memset(audioOutBuffers[k], 0, sizeof(float) * segmentSize); + ld->connect_port(handle, synth->oIdx[k], audioOutBuffers[k]); + //printf("DssiSynthIF::init output port name: %s\n", ld->PortNames[synth->oIdx[k]]); // out1, out2, out3 etc + } + } + + int controlPorts = synth->_controlInPorts; + int controlOutPorts = synth->_controlOutPorts; + + if(controlPorts != 0) + controls = new Port[controlPorts]; + else + controls = 0; + + if(controlOutPorts != 0) + controlsOut = new Port[controlOutPorts]; + else + controlsOut = 0; + + synth->midiCtl2PortMap.clear(); + synth->port2MidiCtlMap.clear(); + synti->_guiUpdateControls.clear(); + synti->_guiUpdateProgram = false; + + for (int k = 0; k < controlPorts; ++k) { + int i = synth->pIdx[k]; + //controls[k].val = ladspaDefaultValue(ld, i); + ladspaDefaultValue(ld, i, &controls[k].val); + + // Set to false at first. + synti->_guiUpdateControls.push_back(false); + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init control port:%d port idx:%d name:%s\n", k, i, ld->PortNames[i]); + #endif + + // This code is duplicated in ::getControllerInfo() + // + + int ctlnum = DSSI_NONE; + if(dssi->get_midi_controller_for_port) + ctlnum = dssi->get_midi_controller_for_port(handle, i); + + // No controller number? Try to give it a unique one... + if(ctlnum == DSSI_NONE) + { + // FIXME: Be more careful. Must make sure to pick numbers not already chosen or which WILL BE chosen. + // Simple but flawed solution: Start them at 0x60000 + 0x2000 = 0x62000. Max NRPN number is 0x3fff. + // TODO: Update: Actually we want to try to use CC Controller7 controllers if possible (or a choice) because what if + // the user's controller hardware doesn't support RPN? + // If CC Controller7 is chosen we must make sure to use only non-common numbers. An already limited range + // of 127 now becomes narrower. See the cool document midi-controllers.txt in the DSSI source for a + // nice roundup of numbers and how to choose them and how they relate to synths and DSSI synths etc. ! + ctlnum = CTRL_NRPN14_OFFSET + 0x2000 + k; + } + else + { + int c = ctlnum; + // Can be both CC and NRPN! Prefer CC over NRPN. + if(DSSI_IS_CC(ctlnum)) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init is CC control\n"); + #endif + + ctlnum = DSSI_CC_NUMBER(c); + #ifdef DSSI_DEBUG + if(DSSI_IS_NRPN(ctlnum)) + printf("DssiSynthIF::init is also NRPN control. Using CC.\n"); + #endif + } + else + if(DSSI_IS_NRPN(ctlnum)) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init is NRPN control\n"); + #endif + + ctlnum = DSSI_NRPN_NUMBER(c) + CTRL_NRPN14_OFFSET; + } + + } + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init inserting to midiCtl2PortMap: ctlnum:%d k:%d\n", ctlnum, k); + #endif + + // We have a controller number! Insert it and the DSSI port number into both maps. + synth->midiCtl2PortMap.insert(std::pair<int, int>(ctlnum, k)); + synth->port2MidiCtlMap.insert(std::pair<int, int>(k, ctlnum)); + ld->connect_port(handle, i, &controls[k].val); + } + + for (int k = 0; k < controlOutPorts; ++k) { + int i = synth->opIdx[k]; + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init control output port:%d port idx:%d name:%s\n", k, i, ld->PortNames[i]); + #endif + + // p3.3.39 Removed. + /* + + //controls[k].val = ladspaDefaultValue(ld, i); + ladspaDefaultValue(ld, i, &controlsOut[k].val); + + // This code is duplicated in ::getControllerInfo() + // + + int ctlnum = DSSI_NONE; + if(dssi->get_midi_controller_for_port) + ctlnum = dssi->get_midi_controller_for_port(handle, i); + + // No controller number? Try to give it a unique one... + if(ctlnum == DSSI_NONE) + { + // FIXME: Be more careful. Must make sure to pick numbers not already chosen or which WILL BE chosen. + // Simple but flawed solution: Start them at 0x60000 + 0x3000 = 0x63000. Max NRPN number is 0x3fff. + // TODO: CC etc. etc. + ctlnum = CTRL_NRPN14_OFFSET + 0x3000 + k; + } + else + { + int c = ctlnum; + // Can be both CC and NRPN! Prefer CC over NRPN. + if(DSSI_IS_CC(ctlnum)) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init is CC control\n"); + #endif + + ctlnum = DSSI_CC_NUMBER(c); + + #ifdef DSSI_DEBUG + if(DSSI_IS_NRPN(ctlnum)) + printf("DssiSynthIF::init is also NRPN control. Using CC.\n"); + #endif + } + else + if(DSSI_IS_NRPN(ctlnum)) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init is NRPN control\n"); + #endif + + ctlnum = DSSI_NRPN_NUMBER(c) + CTRL_NRPN14_OFFSET; + } + + } + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::init inserting to midiCtl2PortMap: ctlnum:%d k:%d\n", ctlnum, k); + #endif + + // We have a controller number! Insert it and the DSSI port number into the map. + // p3.3.39 Removed. Doesn't say whether it's in or out! Don't need this for now. + //synth->midiCtl2PortMap.insert(std::pair<int, int>(ctlnum, k)); + + */ + + // - Control outs are not handled but still must be connected to something. + ld->connect_port(handle, i, &controlsOut[k].val); + } + + // Set the latency to zero. + //controls[controlPorts].val = 0.0; + // Insert a controller for latency and the DSSI port number into the map. + //synth->midiCtl2PortMap.insert(std::pair<int, int>(CTRL_NRPN14_OFFSET + 0x2000, controlPorts)); + // Connect the port. + //ld->connect_port(handle, controlPorts, &controls[controlPorts].val); + + // Just a test. It works! We can instantiate a ladspa plugin for the synth. But it needs more work... + //plugins.add(&synth->info, LADSPA_Descriptor_Function(NULL), ld, false); + + if (ld->activate) + ld->activate(handle); + + // Set current configuration values. + if(dssi->configure) + { + char *rv = dssi->configure(handle, DSSI_PROJECT_DIRECTORY_KEY, + museProject.toLatin1().constData()); //song->projectPath() + + if(rv) + { + fprintf(stderr, "MusE: Warning: plugin doesn't like project directory: \"%s\"\n", rv); + free(rv); + } + + for(ciStringParamMap r = synti->_stringParamMap.begin(); r != synti->_stringParamMap.end(); ++r) + { + rv = 0; + rv = dssi->configure(handle, r->first.c_str(), r->second.c_str()); + if(rv) + { + fprintf(stderr, "MusE: Warning: plugin config key: %s value: %s \"%s\"\n", r->first.c_str(), r->second.c_str(), rv); + free(rv); + } + } + } + + // Set current program. + if(dssi->select_program) + dssi->select_program(handle, synti->_curBankL, synti->_curProgram); + + // + // For stored initial control values, let SynthI::initInstance() take care of that via ::setParameter(). + // + + return true; + } + +//--------------------------------------------------------- +// DssiSynthIF +//--------------------------------------------------------- + +DssiSynthIF::DssiSynthIF(SynthI* s) + : SynthIF(s) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::DssiSynthIF\n"); + #endif + + synth = 0; + handle = NULL; + controls = 0; + controlsOut = 0; + + //_curBank = 0; + //_curProgram = 0; + + //#ifdef OSC_SUPPORT + //_oscif.setSynthIF(this); + //#endif + + //_guiVisible = false; + //uiTarget = 0; + //uiOscShowPath = 0; + //uiOscControlPath = 0; + //uiOscConfigurePath = 0; + //uiOscProgramPath = 0; + //uiOscPath = 0; + //guiPid = -1; + //guiQProc = 0; + + audioInBuffers = 0; + audioOutBuffers = 0; + } + +//--------------------------------------------------------- +// ~DssiSynthIF +//--------------------------------------------------------- + +DssiSynthIF::~DssiSynthIF() +{ + #ifdef DSSI_DEBUG + printf("DssiSynthIF::~DssiSynthIF\n"); + #endif + + if(synth) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::~DssiSynthIF synth:%p\n", synth); + #endif + + if(synth->dssi) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::~DssiSynthIF synth->dssi:%p\n", synth->dssi); + #endif + + if(synth->dssi->LADSPA_Plugin) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::~DssiSynthIFsynth->dssi->LADSPA_Plugin:%p\n", synth->dssi->LADSPA_Plugin); + #endif + } + } + } + + if(synth && synth->dssi && synth->dssi->LADSPA_Plugin) + { + const DSSI_Descriptor* dssi = synth->dssi; + const LADSPA_Descriptor* descr = dssi->LADSPA_Plugin; + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::~DssiSynthIF checking cleanup function exists\n"); + #endif + + if(descr->cleanup) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::~DssiSynthIF calling cleanup function\n"); + #endif + + descr->cleanup(handle); + } + } + + /* + //if (guiPid != -1) + // kill(guiPid, SIGHUP); + if(guiQProc) + { + if(guiQProc->isRunning()) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::~DssiSynthIF killing guiQProc\n"); + #endif + + guiQProc->kill(); + } + + //delete guiQProc; + } + + if(uiOscShowPath) + free(uiOscShowPath); + if(uiOscControlPath) + free(uiOscControlPath); + if(uiOscConfigurePath) + free(uiOscConfigurePath); + if(uiOscProgramPath) + free(uiOscProgramPath); + if(uiOscPath) + free(uiOscPath); + if(uiTarget) + lo_address_free(uiTarget); + */ + + if(audioInBuffers) + { + //for(int i = 0; i < synth->_inports; ++i) + //{ + // if(audioInBuffers[i]) + // delete[] audioInBuffers[i]; + //} + for(unsigned long i = 0; i < synth->_inports; ++i) + { + if(audioInBuffers[i]) + free(audioInBuffers[i]); + } + delete[] audioInBuffers; + } + + if(audioOutBuffers) + { + //for(int i = 0; i < synth->_outports; ++i) + //{ + // if(audioOutBuffers[i]) + // delete[] audioOutBuffers[i]; + //} + for(unsigned long i = 0; i < synth->_outports; ++i) + { + if(audioOutBuffers[i]) + free(audioOutBuffers[i]); + } + delete[] audioOutBuffers; + } + + if(controls) + delete[] controls; + + if(controlsOut) + delete[] controlsOut; +} + +//--------------------------------------------------------- +// getParameter +//--------------------------------------------------------- + +float DssiSynthIF::getParameter(unsigned long n) const +{ + if(n >= synth->_controlInPorts) + { + printf("DssiSynthIF::getParameter param number %ld out of range of ports:%ld\n", n, synth->_controlInPorts); + return 0.0; + } + + if(!controls) + return 0.0; + + return controls[n].val; +} + +//--------------------------------------------------------- +// setParameter +//--------------------------------------------------------- + +void DssiSynthIF::setParameter(unsigned long n, float v) +{ + if(n >= synth->_controlInPorts) + { + printf("DssiSynthIF::setParameter param number %ld out of range of ports:%ld\n", n, synth->_controlInPorts); + return; + } + + if(!controls) + return; + + controls[n].val = v; + + // Notify that changes are to be sent upon heartbeat. + // TODO: No, at least not for now. So far, setParameter is only called during loading of stored params, + // and we don't want this interfering with oscUpdate which also sends the values. + //synti->_guiUpdateControls[n] = true; +} + +//--------------------------------------------------------- +// write +//--------------------------------------------------------- + +//void DssiSynthIF::write(Xml&) const +void DssiSynthIF::write(int level, Xml& xml) const +{ + //bool vstsaved = false; + +#ifdef DSSI_VST_CHUNK_SUPPORT + //--------------------------------------------- + // dump current state of synth + //--------------------------------------------- + printf("dumping DSSI custom data! %d\n", synth->dssi->getCustomData); + + // this is only needed and supported if + // we are talking to a VST plugin at the other end. + std::string name = synth->dssi->LADSPA_Plugin->Name; + if ((name.length()> 4) && name.substr(name.length() - 4) == " VST") + { + printf("is vst plugin, commencing data dump, apiversion=%d!\n", synth->dssi->DSSI_API_Version); + unsigned long len = 0; + void* p = 0; + synth->dssi->getCustomData(handle,&p, &len); + if (len) { + xml.tag(level++, "midistate"); + xml.nput(level++, "<event type=\"%d\"", Sysex); + xml.nput(" datalen=\"%d\">\n", len+7 /*VSTSAVE*/); + xml.nput(level, ""); + xml.nput("56 53 54 53 41 56 45 "); // embed a save marker "string 'VSTSAVE' + for (long unsigned int i = 0; i < len; ++i) { + if (i && (((i+7) % 16) == 0)) { + xml.nput("\n"); + xml.nput(level, ""); + } + xml.nput("%02x ", ((char*)(p))[i] & 0xff); + } + xml.nput("\n"); + xml.tag(level--, "/event"); + xml.etag(level--, "midistate"); + //vstsaved = true; + } + } +#else + printf("support for vst chunks not compiled in!\n"); +#endif + + /* + // p3.3.39 Store the state of current program and bank and all input control values, but only if VSTSAVE above didn't do it already! + // TODO: Not quite good enough, we would want to store all controls for EACH program, not just the current one. + // Need to modify controls array to be inside a program array and act as a cache when the user changes a control on a particular program. + if(!vstsaved) + { + if(synth->_controlInPorts) + { + // TODO: Hmm, what if these sizes change (platform etc.)? Hard code? Not good - need to store complete value. + const int fs = sizeof(float); + const int uls = sizeof(unsigned long); + + // Data length: Version major and minor bytes, bank + program, and controllers. + const unsigned long len = 2 + 2 * uls + synth->_controlInPorts * fs; + + unsigned long prog = _curBank; + unsigned long bnk = _curProgram; + + xml.tag(level++, "midistate"); + xml.nput(level++, "<event type=\"%d\"", Sysex); + xml.nput(" datalen=\"%d\">\n", len+9); // "PARAMSAVE" length + data length. + xml.nput(level, ""); + xml.nput("50 41 52 41 4d 53 41 56 45 "); // Embed a save marker string "PARAMSAVE". + + unsigned long i = 9; + + // Store PARAMSAVE version major... + char uc = DSSI_PARAMSAVE_VERSION_MAJOR; + if(i && ((i % 16) == 0)) + { + xml.nput("\n"); + xml.nput(level, ""); + } + xml.nput("%02x ", uc & 0xff); + ++i; + + // Store PARAMSAVE version minor... + uc = DSSI_PARAMSAVE_VERSION_MINOR; + if(i && ((i % 16) == 0)) + { + xml.nput("\n"); + xml.nput(level, ""); + } + xml.nput("%02x ", uc & 0xff); + ++i; + + // Store bank... + void* p = &bnk; + for(int j = 0; j < uls; ++j) + { + if(i && ((i % 16) == 0)) + { + xml.nput("\n"); + xml.nput(level, ""); + } + xml.nput("%02x ", ((char*)(p))[j] & 0xff); + ++i; + } + + // Store program... + p = &prog; + for(int j = 0; j < uls; ++j) + { + if(i && ((i % 16) == 0)) + { + xml.nput("\n"); + xml.nput(level, ""); + } + xml.nput("%02x ", ((char*)(p))[j] & 0xff); + ++i; + } + + // Store controls... + for(unsigned long c = 0; c < synth->_controlInPorts; ++c) + { + float v = controls[c].val; + p = &v; + for(int j = 0; j < fs; ++j) + { + if(i && ((i % 16) == 0)) + { + xml.nput("\n"); + xml.nput(level, ""); + } + xml.nput("%02x ", ((char*)(p))[j] & 0xff); + ++i; + } + } + xml.nput("\n"); + xml.tag(level--, "/event"); + xml.etag(level--, "midistate"); + } + } + */ + + // Store controls as parameters... + for(unsigned long c = 0; c < synth->_controlInPorts; ++c) + { + float f = controls[c].val; + xml.floatTag(level, "param", f); + //xml.tag(level, "param name=\"%s\" val=\"%s\"/", name, r->first.c_str(), r->second.c_str()); + } +} + +//--------------------------------------------------------- +// preProcessAlways +//--------------------------------------------------------- + +void DssiSynthIF::preProcessAlways() +{ + +} + +//--------------------------------------------------------- +// processEvent +// Return true if event pointer filled. +//-------------------------------------------------------- + +bool DssiSynthIF::processEvent(const MidiPlayEvent& e, snd_seq_event_t* event) +{ + const DSSI_Descriptor* dssi = synth->dssi; + + int chn = e.channel(); + int a = e.dataA(); + int b = e.dataB(); + //for sysex + //QByteArray ba = QByteArray((const char*)e.data(), e.len()); + //we must had 0xF0 at the beginning and 0xF7 at the end of e.data() + //ba.push_front(0xF0); + //ba.push_back(0xF7); + + //QByteArray ba(); + ////ba.assign((const char*)e.data(), e.len()); + ////ba.duplicate((const char*)e.data(), e.len()); + ////ba.setRawData((const char*)e.data(), e.len()); + //int len = e.len() + 2; + + int len = e.len(); + char ca[len + 2]; + + ca[0] = 0xF0; + memcpy(ca + 1, (const char*)e.data(), len); + ca[len + 1] = 0xF7; + + len += 2; + + //snd_seq_event_t* event = &events[nevents]; + event->queue = SND_SEQ_QUEUE_DIRECT; + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event type:%d chn:%d a:%d b:%d\n", e.type(), chn, a, b); + #endif + + switch(e.type()) + { + case ME_NOTEON: + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is ME_NOTEON\n"); + #endif + + if(b) + snd_seq_ev_set_noteon(event, chn, a, b); + else + snd_seq_ev_set_noteoff(event, chn, a, 0); + break; + case ME_NOTEOFF: + snd_seq_ev_set_noteoff(event, chn, a, 0); + break; + case ME_PROGRAM: + { + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is ME_PROGRAM\n"); + #endif + + int bank = (a >> 8) & 0xff; + int prog = a & 0xff; + //_curBank = bank; + //_curProgram = prog; + synti->_curBankH = 0; + synti->_curBankL = bank; + synti->_curProgram = prog; + + if(dssi->select_program) + { + dssi->select_program(handle, bank, prog); + // Notify that changes are to be sent upon heartbeat. + synti->_guiUpdateProgram = true; + } + // Event pointer not filled. Return false. + return false; + } + break; + case ME_CONTROLLER: + { + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is ME_CONTROLLER\n"); + #endif + + if((a == 0) || (a == 32)) + return false; + + if(a == CTRL_PROGRAM) + { + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is ME_CONTROLLER, dataA is CTRL_PROGRAM\n"); + #endif + + int bank = (b >> 8) & 0xff; + int prog = b & 0xff; + + //_curBank = bank; + //_curProgram = prog; + synti->_curBankH = 0; + synti->_curBankL = bank; + synti->_curProgram = prog; + + if(dssi->select_program) + { + dssi->select_program(handle, bank, prog); + // Notify that changes are to be sent upon heartbeat. + synti->_guiUpdateProgram = true; + } + // Event pointer not filled. Return false. + return false; + } + + if(a == CTRL_PITCH) + { + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is ME_CONTROLLER, dataA is CTRL_PITCH\n"); + #endif + + b &= 0x3fff; + snd_seq_ev_set_pitchbend(event, chn, b); + // Event pointer filled. Return true. + return true; + } + + const LADSPA_Descriptor* ld = dssi->LADSPA_Plugin; + + ciMidiCtl2LadspaPort ip = synth->midiCtl2PortMap.find(a); + // Is it just a regular midi controller, not mapped to a LADSPA port (either by the plugin or by us)? + // NOTE: There's no way to tell which of these controllers is supported by the plugin. + // For example sustain footpedal or pitch bend may be supported, but not mapped to any LADSPA port. + if(ip == synth->midiCtl2PortMap.end()) + { + // p3.3.39 Changed to return false because of crashes with unknown controllers when switching a midi track + // among different dssi synths and regular synths etc. For example high RPN offset numbers (set by another + // device selected into the midi port before selecting this synth) were passing through here when in fact + // the particular synth had no such midi controllers. + // ========================== No, that leaves out regular controllers like footpedal + //#ifdef DSSI_DEBUG + //fprintf(stderr, "DssiSynthIF::processEvent dataA:%d not found in map (not a ladspa controller). Ignoring.\n", a); + //#endif + //return false; + + //#ifdef DSSI_DEBUG + //fprintf(stderr, "DssiSynthIF::processEvent dataA:%d not found in map (not a ladspa controller). Filling event as regular controller.\n", a); + //#endif + //snd_seq_ev_set_controller(event, chn, a, b); + //return true; + + int ctlnum = a; + //switch(midiControllerType(a)) + if(midiControllerType(a) != MidiController::Controller7) + return false; + else + { + /* + case MidiController::NRPN14: + case MidiController::Controller14: + case MidiController::Pitch: + case MidiController::Program: + case MidiController::RPN: + case MidiController::RPN14: + case MidiController::NRPN: + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent non-ladspa midi event controller unsupported. DataA:%d\n", a); + #endif + return false; + */ + + //case MidiController::Controller7: + #ifdef DSSI_DEBUG + //fprintf(stderr, "DssiSynthIF::processEvent midi event is Controller7. Changing to DSSI_CC type. Current dataA:%d\n", a); + fprintf(stderr, "DssiSynthIF::processEvent non-ladspa midi event is Controller7. Current dataA:%d\n", a); + #endif + //a = DSSI_CC(a); + a &= 0x7f; + ctlnum = DSSI_CC_NUMBER(ctlnum); + // break; + + /* + case MidiController::NRPN14: + #ifdef DSSI_DEBUG + // fprintf(stderr, "DssiSynthIF::processEvent midi event is NRPN. Changing to DSSI_NRPN type. Current dataA:%d\n", a); + fprintf(stderr, "DssiSynthIF::processEvent non-ladspa midi event is NRPN. Current dataA:%d\n", a); + #endif + //a = DSSI_NRPN(a - CTRL_NRPN14_OFFSET); + a &= 0x3fff; + ctlnum = DSSI_NRPN_NUMBER(ctlnum); + break; + case MidiController::Controller14: + a &= 0x7f; + break; + case MidiController::Pitch: + // Should be caught above! + #ifdef DSSI_DEBUG + //fprintf(stderr, "DssiSynthIF::processEvent non-ladspa midi event is Pitch. DataA:%d\n", a); + fprintf(stderr, "DssiSynthIF::processEvent Error! non-ladspa midi event is Pitch. Should have been caught already! DataA:%d\n", a); + #endif + //a &= 0x3fff; + //snd_seq_ev_set_pitchbend(event, chn, b); + // Event pointer filled. Return true. + //return true; + // Event pointer not filled. Return false. + return false; + case MidiController::Program: + // Should be caught above! + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent Error! non-ladspa midi event is Program. Should have been caught already! DataA:%d\n", a); + #endif + return false; + case MidiController::RPN: + case MidiController::RPN14: + case MidiController::NRPN: + default: + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent non-ladspa midi event is RPN, RPN14, or NRPN type. DataA:%d\n", a); + #endif + break; + */ + } + + // Verify it's the same number. + //if(ctlnum != a) + //{ + // #ifdef DSSI_DEBUG + // printf("DssiSynthIF::processEvent Error! non-ladspa midi ctlnum:%d != event dataA:%d\n", ctlnum, a); + // #endif + // Event not filled. Return false. + + // TEMP: TODO: Turn on later + //return false; + //} + + // Fill the event. + #ifdef DSSI_DEBUG + printf("DssiSynthIF::processEvent non-ladspa filling midi event chn:%d dataA:%d dataB:%d\n", chn, a, b); + #endif + snd_seq_ev_set_controller(event, chn, a, b); + return true; + } + + //int num = ip->first; + unsigned long k = ip->second; + + unsigned long i = synth->pIdx[k]; + + int ctlnum = DSSI_NONE; + if(dssi->get_midi_controller_for_port) + ctlnum = dssi->get_midi_controller_for_port(handle, i); + + // No midi controller for the ladspa port? Send to ladspa control. + if(ctlnum == DSSI_NONE) + { + // Sanity check. + if(k > synth->_controlInPorts) + return false; + + // TODO: If necessary... choose non-existing numbers... + //for(int k = 0; k < controlPorts; ++k) + //{ + // int i = synth->pIdx[k]; + //} + + // Simple but flawed solution: Start them at 0x60000 + 0x2000 = 0x62000. Max NRPN number is 0x3fff. + ctlnum = k + (CTRL_NRPN14_OFFSET + 0x2000); + } + // p3.3.39 + else + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::processEvent plugin requests DSSI-style ctlnum:%x(h) %d(d) be mapped to control port:%ld...\n", ctlnum, ctlnum, i); + #endif + + int c = ctlnum; + // Can be both CC and NRPN! Prefer CC over NRPN. + if(DSSI_IS_CC(ctlnum)) + { + ctlnum = DSSI_CC_NUMBER(c); + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::processEvent is CC ctlnum:%d\n", ctlnum); + #endif + + #ifdef DSSI_DEBUG + if(DSSI_IS_NRPN(ctlnum)) + printf("DssiSynthIF::processEvent is also NRPN control. Using CC.\n"); + #endif + } + else + if(DSSI_IS_NRPN(ctlnum)) + { + ctlnum = DSSI_NRPN_NUMBER(c) + CTRL_NRPN14_OFFSET; + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::processEvent is NRPN ctlnum:%x(h) %d(d)\n", ctlnum, ctlnum); + #endif + } + + } + + //{ + float val = midi2LadspaValue(ld, i, ctlnum, b); + + #ifdef DSSI_DEBUG + //fprintf(stderr, "DssiSynthIF::processEvent No midi controller for control port:%d port:%d dataA:%d Converting val from:%d to ladspa:%f\n", i, k, a, b, val); + fprintf(stderr, "DssiSynthIF::processEvent control port:%ld port:%ld dataA:%d Converting val from:%d to ladspa:%f\n", i, k, a, b, val); + #endif + + // Set the ladspa port value. + controls[k].val = val; + // FIXME: Testing - Works but is this safe in a RT process callback? Try hooking into gui heartbeat timer instead... + //lo_send(uiTarget, uiOscControlPath, "if", i, val); + // Notify that changes are to be sent upon heartbeat. + synti->_guiUpdateControls[k] = true; + + // Since we absorbed the message as a ladspa control change, return false - the event is not filled. + return false; + //} + + // p3.3.39 Removed. + // "Hosts should not deliver through run_synth any MIDI controller events that have already + // been mapped to control port values." + // D'oh! My mistake, did not understand that the mapping is only a *request* that the app map MIDI + // controller events to a LADSPA port, and must do the conversion, not to actually *send* them via MIDI... + /* + else + { + switch(midiControllerType(a)) + { + case MidiController::Controller7: + #ifdef DSSI_DEBUG + //fprintf(stderr, "DssiSynthIF::processEvent midi event is Controller7. Changing to DSSI_CC type. Current dataA:%d\n", a); + fprintf(stderr, "DssiSynthIF::processEvent midi event is Controller7. Current dataA:%d\n", a); + #endif + //a = DSSI_CC(a); + a &= 0x7f; + ctlnum = DSSI_CC_NUMBER(ctlnum); + break; + case MidiController::NRPN14: + #ifdef DSSI_DEBUG + // fprintf(stderr, "DssiSynthIF::processEvent midi event is NRPN. Changing to DSSI_NRPN type. Current dataA:%d\n", a); + fprintf(stderr, "DssiSynthIF::processEvent midi event is NRPN. Current dataA:%d\n", a); + #endif + //a = DSSI_NRPN(a - CTRL_NRPN14_OFFSET); + a &= 0x3fff; + ctlnum = DSSI_NRPN_NUMBER(ctlnum); + break; + case MidiController::Controller14: + a &= 0x7f; + break; + case MidiController::Pitch: + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is Pitch. DataA:%d\n", a); + #endif + a &= 0x3fff; + break; + case MidiController::Program: + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is Program. DataA:%d\n", a); + #endif + a &= 0x3fff; + break; + case MidiController::RPN: + case MidiController::RPN14: + case MidiController::NRPN: + default: + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is RPN, RPN14, or NRPN type. DataA:%d\n", a); + #endif + break; + } + + // Verify it's the same number. + if(ctlnum != a) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::processEvent Error! ctlnum:%d != event dataA:%d\n", ctlnum, a); + #endif + // Event not filled. Return false. + + // TEMP: TODO: Turn on later + //return false; + } + + // Fill the event. + // FIXME: Darn! We get to this point, but no change in sound (later). Nothing happens, at least with LTS - + // which is the only one I found so far with midi controllers. + // Tried with/without converting to DSSI_CC and DSSI_NRPN. What could be wrong here? + #ifdef DSSI_DEBUG + printf("DssiSynthIF::processEvent filling event chn:%d dataA:%d dataB:%d\n", chn, a, b); + #endif + snd_seq_ev_set_controller(event, chn, a, b); + } + */ + + } + break; + case ME_PITCHBEND: + snd_seq_ev_set_pitchbend(event, chn, a); + break; + case ME_AFTERTOUCH: + snd_seq_ev_set_chanpress(event, chn, a); + break; + case ME_SYSEX: + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is ME_SYSEX\n"); + #endif + + if (QString((const char*)e.data()).startsWith("VSTSAVE")) { +#ifdef DSSI_VST_CHUNK_SUPPORT + printf("loading chunk from sysex %s!\n", e.data()+7); + dssi->setCustomData(handle, e.data()+7 /* len of str*/,e.len()-7); +#else + printf("support for vst chunks not compiled in!\n"); +#endif + // Event not filled. + return false; + } + /* + // p3.3.39 Read the state of current bank and program and all input control values. + // TODO: Needs to be better. See write(). + else + if (QString((const char*)e.data()).startsWith("PARAMSAVE")) + { + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::processEvent midi event is ME_SYSEX PARAMSAVE\n"); + #endif + + unsigned long dlen = e.len() - 9; // Minus "PARAMSAVE" + if(dlen > 0) + { + //if(dlen < 2 * sizeof(unsigned long)) + if(dlen < (2 + 2 * sizeof(unsigned long))) // Version major and minor bytes, bank and program. + printf("DssiSynthIF::processEvent Error: PARAMSAVE data length does not include at least version major and minor, bank and program!\n"); + else + { + // Not required, yet. + //char vmaj = *((char*)(e.data() + 9)); // After "PARAMSAVE" + //char vmin = *((char*)(e.data() + 10)); + + unsigned long* const ulp = (unsigned long*)(e.data() + 11); // After "PARAMSAVE" + version major and minor. + // TODO: TODO: Set plugin bank and program. + _curBank = ulp[0]; + _curProgram = ulp[1]; + + dlen -= (2 + 2 * sizeof(unsigned long)); // After the version major and minor, bank and program. + + if(dlen > 0) + { + if((dlen % sizeof(float)) != 0) + printf("DssiSynthIF::processEvent Error: PARAMSAVE float data length not integral multiple of float size!\n"); + else + { + const unsigned long n = dlen / sizeof(float); + if(n != synth->_controlInPorts) + printf("DssiSynthIF::processEvent Warning: PARAMSAVE number of floats:%ld != number of controls:%ld\n", n, synth->_controlInPorts); + + // Point to location after "PARAMSAVE", version major and minor, bank and progam. + float* const fp = (float*)(e.data() + 9 + 2 + 2 * sizeof(unsigned long)); + + for(unsigned long i = 0; i < synth->_controlInPorts && i < n; ++i) + { + const float v = fp[i]; + controls[i].val = v; + } + } + } + } + } + // Event not filled. + return false; + } + */ + else + { + // NOTE: There is a limit on the size of a sysex. Got this: + // "DssiSynthIF::processEvent midi event is ME_SYSEX" + // "WARNING: MIDI event of type ? decoded to 367 bytes, discarding" + // That might be ALSA doing that. + snd_seq_ev_set_sysex(event, len, + //(unsigned char*)ba.data()); + (unsigned char*)ca); + } + break; + default: + if(debugMsg) + fprintf(stderr, "DssiSynthIF::processEvent midi event unknown type:%d\n", e.type()); + // Event not filled. + return false; + break; + } + + return true; +} + +//--------------------------------------------------------- +// getData +//--------------------------------------------------------- + +//void DssiSynthIF::getData(MidiEventList* el, unsigned pos, int ch, unsigned samples, float** data) +iMPEvent DssiSynthIF::getData(MidiPort* /*mp*/, MPEventList* el, iMPEvent /*i*/, unsigned pos, int ports, unsigned n, float** buffer) +{ + //#ifdef DSSI_DEBUG + // fprintf(stderr, "DssiSynthIF::getData elsize:%d pos:%d ports:%d samples:%d processed already?:%d\n", el->size(), pos, ports, n, synti->processed()); + //#endif + + //BEGIN: Process midi events + + // FIXME: Add 10(?) for good luck in case volatile size changes (increments) while we're processing. + //unsigned long nevents = el->size(); + unsigned long nevents = el->size() + synti->putFifo.getSize() + 10; + + /* + while (!synti->putFifo.isEmpty()) { + MidiEvent event = synti->putFifo.get(); + printf("Dssi: FIFO\n"); + } + */ + + snd_seq_event_t events[nevents]; + memset(events, 0, sizeof(events)); + nevents = 0; + + //int curPos = pos; + //unsigned endPos = pos + samples; + unsigned endPos = pos + n; + //int off = pos; + int frameOffset = audio->getFrameOffset(); + + //iMidiEvent i = el->begin(); + iMPEvent i = el->begin(); + + // Process event list events... + for(; i != el->end(); ++i) + { + //if(i->time() >= endPos) // Doesn't work, at least here in muse-1. The event times are all + // just slightly after the endPos, EVEN IF transport is stopped. + // So it misses all the notes. + if(i->time() >= (endPos + frameOffset)) // NOTE: frameOffset? Tested, examined printouts of times: Seems OK for playback. + break; + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::getData eventlist event time:%d\n", i->time()); + #endif + + // p3.3.39 Update hardware state so knobs and boxes are updated. Optimize to avoid re-setting existing values. + // Same code as in MidiPort::sendEvent() + if(synti->midiPort() != -1) + { + MidiPort* mp = &midiPorts[synti->midiPort()]; + if(i->type() == ME_CONTROLLER) + { + int da = i->dataA(); + int db = i->dataB(); + db = mp->limitValToInstrCtlRange(da, db); + if(!mp->setHwCtrlState(i->channel(), da, db)) + continue; + //mp->setHwCtrlState(i->channel(), da, db); + } + else + if(i->type() == ME_PITCHBEND) + { + int da = mp->limitValToInstrCtlRange(CTRL_PITCH, i->dataA()); + if(!mp->setHwCtrlState(i->channel(), CTRL_PITCH, da)) + continue; + //mp->setHwCtrlState(i->channel(), CTRL_PITCH, da); + } + else + if(i->type() == ME_PROGRAM) + { + if(!mp->setHwCtrlState(i->channel(), CTRL_PROGRAM, i->dataA())) + continue; + //mp->setHwCtrlState(i->channel(), CTRL_PROGRAM, i->dataA()); + } + } + + if(processEvent(*i, &events[nevents])) + ++nevents; + } + + // Now process putEvent events... + while(!synti->putFifo.isEmpty()) + { + MidiPlayEvent e = synti->putFifo.get(); + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::getData putFifo event time:%d\n", e.time()); + #endif + + // Set to the current time. + // FIXME: FIXME: Wrong - we should be setting some kind of linear realtime wallclock here, not song pos. + e.setTime(pos); + if(processEvent(e, &events[nevents])) + ++nevents; + } + + // Now process OSC gui input control fifo events. + // It is probably more important that these are processed last so that they take precedence over all other + // events because OSC + DSSI/DSSI-VST are fussy about receiving feedback via these control ports, from GUI changes. + #ifdef OSC_SUPPORT + unsigned long ctls = synth->_controlInPorts; + for(unsigned long k = 0; k < ctls; ++k) + { + OscControlFifo* cfifo = _oscif.oscFifo(k); + if(!cfifo) + continue; + + // If there are 'events' in the fifo, get exactly one 'event' per control per process cycle... + if(!cfifo->isEmpty()) + { + OscControlValue v = cfifo->get(); + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::getData OscControlFifo event input control number:%ld value:%f\n", k, v.value); + #endif + + // Set the ladspa control port value. + controls[k].val = v.value; + + // TODO: (From plugin module, adapt for synth if/when our own plugin gui is added to synths). + // Need to update the automation value, otherwise the block above overwrites with the last automation value. + ///if(_track) + ///{ + // Since we are now in the audio thread context, there's no need to send a message, + // just modify directly. + //audio->msgSetPluginCtrlVal(this, genACnum(_id, i), controls[i].val); + /// _track->setPluginCtrlVal(k, v.value) + ///} + } + } + #endif + +/* // This is from MESS... Tried this here, didn't work, need to re-adapt, try again. + int evTime = i->time(); + if(evTime == 0) + { + printf("DssiSynthIF::getData - time is 0!\n"); + //continue; + evTime=frameOffset; // will cause frame to be zero, problem? + } + + int frame = evTime - frameOffset; + + if(frame >= endPos) + { + printf("DssiSynthIF::getData frame > endPos!! frame = %d >= endPos %d, i->time() %d, frameOffset %d curPos=%d\n", frame, endPos, i->time(), frameOffset,curPos); + continue; + } + + if(frame > curPos) + { + if(frame < pos) + printf("DssiSynthIF::getData should not happen: missed event %d\n", pos -frame); + else + { +*/ + +/* + } + curPos = frame; + } +*/ +// } + + el->erase(el->begin(), i); + //END: Process midi events + + //BEGIN: Run the synth + // All ports must be connected to something! + + // First, copy the given input buffers to our local input buffers. + unsigned long np, k; + //np = portsin > synth->_inports ? synth->_inports : portsin; + //for(k = 0; k < np; ++k) + // memcpy(audioInBuffers[k], inbuffer[k], sizeof(float) * n); + //for(; k < portsin; ++k) + // memset(audioInBuffers[k], 0, sizeof(float) * n); + + // Watch our limits. + np = ports > synth->_outports ? synth->_outports : ports; + + const DSSI_Descriptor* dssi = synth->dssi; + const LADSPA_Descriptor* descr = dssi->LADSPA_Plugin; + k = 0; + // Connect the given buffers directly to the ports, up to a max of synth ports. + for(; k < np; ++k) + descr->connect_port(handle, synth->oIdx[k], buffer[k]); + // Connect the remaining ports to some local buffers (not used yet). + for(; k < synth->_outports; ++k) + descr->connect_port(handle, synth->oIdx[k], audioOutBuffers[k]); + + /* + // + // p3.3.39 Handle inputs... + // + //if((song->bounceTrack != this) && !noInRoute()) + if(!((AudioTrack*)synti)->noInRoute()) + { + RouteList* irl = ((AudioTrack*)synti)->inRoutes(); + iRoute i = irl->begin(); + if(!i->track->isMidiTrack()) + { + //if(debugMsg) + printf("DssiSynthIF::getData: Error: First route is a midi track route!\n"); + } + else + { + int ch = i->channel == -1 ? 0 : i->channel; + int remch = i->remoteChannel == -1 ? 0 : i->remoteChannel; + int chs = i->channels == -1 ? 0 : i->channels; + + // TODO: + //if(ch >= synth->_inports) + //iUsedIdx[ch] = true; + //if(chs == 2) + // iUsedIdx[ch + 1] = true; + + //((AudioTrack*)i->track)->copyData(framePos, channels, nframe, bp); + ((AudioTrack*)i->track)->copyData(pos, ports, + //(i->track->type() == Track::AUDIO_SOFTSYNTH && i->channel != -1) ? i->channel : 0, + i->channel, + i->channels, + n, bp); + } + + //unsigned pos, int ports, unsigned n, float** buffer + + ++i; + for(; i != irl->end(); ++i) + { + if(i->track->isMidiTrack()) + { + //if(debugMsg) + printf("DssiSynthIF::getData: Error: Route is a midi track route!\n"); + continue; + } + //((AudioTrack*)i->track)->addData(framePos, channels, nframe, bp); + ((AudioTrack*)i->track)->addData(framePos, channels, + //(i->track->type() == Track::AUDIO_SOFTSYNTH && i->channel != -1) ? i->channel : 0, + i->channel, + i->channels, + nframe, bp); + } + } + */ + + //#ifdef DSSI_DEBUG + //if(nevents) + // fprintf(stderr, "DssiSynthIF::getData run nevents:%d\n", nevents); + //#endif + + // Run the synth for one segment. This processes events and gets/fills our local buffers... + if(synth->dssi->run_synth) + { + synth->dssi->run_synth(handle, n, events, nevents); + + // NOTE: Just a test + //for(int m = 0; m < n; ++m) + //{ + // synth->dssi->run_synth(handle, 1, events, nevents); + //} + + } + else if (synth->dssi->run_multiple_synths) + { + snd_seq_event_t* ev = events; + synth->dssi->run_multiple_synths(1, &handle, n, &ev, &nevents); + } + //END: Run the synth + + return i; +} + +//--------------------------------------------------------- +// putEvent +//--------------------------------------------------------- + +//bool DssiSynthIF::putEvent(const MidiEvent& ev) +bool DssiSynthIF::putEvent(const MidiPlayEvent& ev) + { + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::putEvent midi event time:%d chn:%d a:%d b:%d\n", ev.time(), ev.channel(), ev.dataA(), ev.dataB()); + #endif + + if (midiOutputTrace) + ev.dump(); + + return synti->putFifo.put(ev); + + //return false; + } + + +//--------------------------------------------------------- +// incInstances +//--------------------------------------------------------- + +void DssiSynth::incInstances(int val) +{ + _instances += val; + if (_instances == 0) + { + if (handle) + { + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynth::incInstances no more instances, closing library\n"); + #endif + + dlclose(handle); + } + handle = 0; + dssi = NULL; + df = NULL; + pIdx.clear(); + opIdx.clear(); + iIdx.clear(); + oIdx.clear(); + rpIdx.clear(); + iUsedIdx.clear(); + midiCtl2PortMap.clear(); + port2MidiCtlMap.clear(); + //synti->_guiUpdateControls.clear(); + } +} + +//--------------------------------------------------------- +// initGui +//--------------------------------------------------------- +bool DssiSynthIF::initGui() +{ + #ifdef OSC_SUPPORT + return _oscif.oscInitGui(); + #endif + + return true; + + /* + // Are we already running? We don't want to allow another process do we... + if((guiQProc != 0) && (guiQProc->isRunning())) + return true; + + // + // start gui + // + static char oscUrl[1024]; + //snprintf(oscUrl, 1024, "%s/%s", url, synti->name().toAscii().data()); + //snprintf(oscUrl, 1024, "%s/%s", url, synti->name().toLatin1().constData()); + snprintf(oscUrl, 1024, "%s/%s/%s", url, synth->info.baseName().toLatin1().constData(), synti->name().toLatin1().constData()); + + //QString guiPath(info.path() + "/" + info.baseName()); + QString guiPath(synth->info.dirPath() + "/" + synth->info.baseName()); + + QDir guiDir(guiPath, "*", QDir::Unsorted, QDir::Files); + if (guiDir.exists()) + { + //const QFileInfoList list = guiDir.entryInfoList(); + QStringList list = guiDir.entryList(); + + //for (int i = 0; i < list.size(); ++i) { + for (unsigned int i = 0; i < list.count(); ++i) + { + + //QFileInfo fi = list.at(i); + QFileInfo fi(guiPath + QString("/") + list[i]); + + QString gui(fi.filePath()); + if (gui.contains('_') == 0) + continue; + struct stat buf; + + //if (stat(gui.toAscii().data(), &buf)) { + if (stat(gui.toLatin1().constData(), &buf)) { + + perror("stat failed"); + continue; + } + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::initGui %s %s %s %s\n", + //fi.filePath().toAscii().data(), + //fi.fileName().toAscii().data(), + fi.filePath().toLatin1().constData(), + //fi.fileName().toLatin1().constData(), + + oscUrl, + + synth->info.filePath().toLatin1().constData(), + + //name().toAscii().data(), + synth->name().toLatin1().constData()); + #endif + + if ((S_ISREG(buf.st_mode) || S_ISLNK(buf.st_mode)) && + (buf.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) + { + // Changed by T356. + // fork + execlp were causing the processes to remain after closing gui, requiring manual kill. + // Changed to QProcess, works OK now. + //if((guiPid = fork()) == 0) + { + // No QProcess created yet? Do it now. Only once per SynthIF instance. Exists until parent destroyed. + if(guiQProc == 0) + guiQProc = new QProcess(muse); + + // Don't forget this, he he... + guiQProc->clearArguments(); + + guiQProc->addArgument(fi.filePath()); + //guiQProc->addArgument(fi.fileName()); // No conventional 'Arg0' here. + guiQProc->addArgument(QString(oscUrl)); + guiQProc->addArgument(synth->info.filePath()); + guiQProc->addArgument(synth->name()); + guiQProc->addArgument(QString("channel 1")); + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::initGui starting QProcess\n"); + #endif + + if(guiQProc->start() == TRUE) + { + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::initGui started QProcess\n"); + #endif + + //guiPid = guiQProc->processIdentifier(); + } + else + { + + // execlp( + // fi.filePath().toAscii().data(), + // fi.fileName().toAscii().data(), + // fi.filePath().toLatin1().constData(), + // fi.fileName().toLatin1().constData(), + + // oscUrl, + + // info.filePath().toAscii().data(), + // name().toAscii().data(), + // synth->info.filePath().toLatin1().constData(), + // synth->name().toLatin1().constData(), + + // "channel 1", (void*)0); + + fprintf(stderr, "exec %s %s %s %s failed: %s\n", + // fi.filePath().toAscii().data(), + // fi.fileName().toAscii().data(), + fi.filePath().toLatin1().constData(), + fi.fileName().toLatin1().constData(), + oscUrl, + // name().toAscii().data(), + synth->name().toLatin1().constData(), + strerror(errno)); + + // It's Ok, Keep going. So nothing happens. So what. The timeout in showGui will just leave. + // Maybe it's a 'busy' issue somewhere - allow to try again later + save work now. + // exit(1); + + } + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::initGui after QProcess\n"); + #endif + } + } + } + //synth->_hasGui = true; + } + else { + printf("%s: no dir for dssi gui found: %s\n", + //name().toAscii().data(), guiPath.toAscii().data()); + synth->name().toLatin1().constData(), guiPath.toLatin1().constData()); + + //synth->_hasGui = false; + } + + return true; + */ +} + +//--------------------------------------------------------- +// guiHeartBeat +//--------------------------------------------------------- + +void DssiSynthIF::guiHeartBeat() +{ + #ifdef OSC_SUPPORT + // Update the gui's program if needed. + if(synti->_guiUpdateProgram) + { + _oscif.oscSendProgram(synti->_curProgram, synti->_curBankL); + synti->_guiUpdateProgram = false; + } + + // Update the gui's controls if needed. + unsigned long ports = synth->_controlInPorts; + if(ports > synti->_guiUpdateControls.size()) + return; + for(unsigned long i = 0; i < ports; ++i) + { + if(synti->_guiUpdateControls[i]) + { + unsigned long k = synth->pIdx[i]; + _oscif.oscSendControl(k, controls[i].val); + + // Reset. + synti->_guiUpdateControls[i] = false; + } + } + #endif +} + +#ifdef OSC_SUPPORT +//--------------------------------------------------------- +// oscUpdate +//--------------------------------------------------------- + +int DssiSynthIF::oscUpdate() +{ + // Send project directory. + _oscif.oscSendConfigure(DSSI_PROJECT_DIRECTORY_KEY, museProject.toLatin1().constData()); // song->projectPath() + + // Send current string configuration parameters. + //StringParamMap& map = synti->_stringParamMap; + int i = 0; + for(ciStringParamMap r = synti->_stringParamMap.begin(); r != synti->_stringParamMap.end(); ++r) + { + _oscif.oscSendConfigure(r->first.c_str(), r->second.c_str()); + // Avoid overloading the GUI if there are lots and lots of params. + if((i+1) % 50 == 0) + usleep(300000); + ++i; + } + + // Send current bank and program. + //unsigned long bank, prog; + //synti->currentProg(&prog, &bank, 0); + //_oscif.oscSendProgram(prog, bank); + _oscif.oscSendProgram(synti->_curProgram, synti->_curBankL); + + // Send current control values. + unsigned long ports = synth->_controlInPorts; + for(unsigned long i = 0; i < ports; ++i) + { + unsigned long k = synth->pIdx[i]; + _oscif.oscSendControl(k, controls[i].val); + // Avoid overloading the GUI if there are lots and lots of ports. + if((i+1) % 50 == 0) + usleep(300000); + } + + +#if 0 + /* Send current bank/program (-FIX- another race...) */ + if (instance->pendingProgramChange < 0) { + unsigned long bank = instance->currentBank; + unsigned long program = instance->currentProgram; + instance->uiNeedsProgramUpdate = 0; + if (instance->uiTarget) { + lo_send(instance->uiTarget, instance->ui_osc_program_path, "ii", bank, program); + } + } + + /* Send control ports */ + for (i = 0; i < instance->plugin->controlIns; i++) { + int in = i + instance->firstControlIn; + int port = pluginControlInPortNumbers[in]; + lo_send(instance->uiTarget, instance->ui_osc_control_path, "if", port, + pluginControlIns[in]); + /* Avoid overloading the GUI if there are lots and lots of ports */ + if ((i+1) % 50 == 0) + usleep(300000); + } +#endif + return 0; +} + +//--------------------------------------------------------- +// oscProgram +//--------------------------------------------------------- + +int DssiSynthIF::oscProgram(unsigned long program, unsigned long bank) + { + //int bank = argv[0]->i; + //int program = argv[1]->i; + + int ch = 0; // TODO: ?? + + int port = synti->midiPort(); + + //_curBank = bank; + //_curProgram = program; + synti->_curBankH = 0; + synti->_curBankL = bank; + synti->_curProgram = program; + + bank &= 0xff; + program &= 0xff; + + //MidiEvent event(0, ch, ME_CONTROLLER, CTRL_PROGRAM, (bank << 8) + program); + + if(port != -1) + { + //MidiPlayEvent event(0, port, ch, ME_CONTROLLER, CTRL_PROGRAM, (bank << 8) + program); + MidiPlayEvent event(0, port, ch, ME_PROGRAM, (bank << 8) + program, 0); + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::oscProgram midi event chn:%d a:%d b:%d\n", event.channel(), event.dataA(), event.dataB()); + #endif + + midiPorts[port].sendEvent(event); + } + + + + //synti->playMidiEvent(&event); // TODO + // + //MidiDevice* md = dynamic_cast<MidiDevice*>(synti); + //if(md) + // md->putEvent(event); + // + //synti->putEvent(event); + + return 0; + } + +//--------------------------------------------------------- +// oscControl +//--------------------------------------------------------- + +int DssiSynthIF::oscControl(unsigned long port, float value) + { + //int port = argv[0]->i; + //LADSPA_Data value = argv[1]->f; + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::oscControl received oscControl port:%ld val:%f\n", port, value); + #endif + + //int controlPorts = synth->_controlInPorts; + + //if(port >= controlPorts) + //if(port < 0 || port >= synth->rpIdx.size()) + if(port >= synth->rpIdx.size()) + { + //fprintf(stderr, "DssiSynthIF::oscControl: port number:%d is out of range of number of ports:%d\n", port, controlPorts); + fprintf(stderr, "DssiSynthIF::oscControl: port number:%ld is out of range of index list size:%zd\n", port, synth->rpIdx.size()); + return 0; + } + + // Convert from DSSI port number to control input port index. + unsigned long cport = synth->rpIdx[port]; + + if((int)cport == -1) + { + fprintf(stderr, "DssiSynthIF::oscControl: port number:%ld is not a control input\n", port); + return 0; + } + + // p3.3.39 Set the DSSI control input port's value. + // Observations: With a native DSSI synth like LessTrivialSynth, the native GUI's controls do not change the sound at all + // ie. they don't update the DSSI control port values themselves. + // Hence in response to the call to this oscControl, sent by the native GUI, it is required to that here. +/// controls[cport].val = value; + // DSSI-VST synths however, unlike DSSI synths, DO change their OWN sound in response to their gui controls. + // AND this function is called. + // Despite the descrepency we are STILL required to update the DSSI control port values here + // because dssi-vst is WAITING FOR A RESPONSE. (A CHANGE in the control port value). + // It will output something like "...4 events expected..." and count that number down as 4 actual control port value CHANGES + // are done here in response. Normally it says "...0 events expected..." when MusE is the one doing the DSSI control changes. + // TODO: (Done) May need FIFOs on each control(!) so that the control changes get sent one per process cycle. + // Observed countdown not actually going to zero upon string of changes. + // + // NOTE: NOTE: This line in RemoteVSTServer::setParameter(int p, float v) in dssi-vst-server.cpp : + // + // " if (tv.tv_sec > m_lastGuiComms.tv_sec + 10) " + // + // explains an observation that after ten seconds, the server automatically clears the expected number to 0. + // TODO: Now MusE should forget about all the VST fifo events past ten+ (?) seconds. Add event timestamps... + // You can't send any 'new' values until either you a): send all the expected events or b): wait ten seconds. + // (Because the server simply ignores the 'expected' messages.) + // + // Well, at least here are the fifos. Try this ... + OscControlFifo* cfifo = _oscif.oscFifo(cport); + if(cfifo) + { + OscControlValue cv; + //cv.idx = cport; + cv.value = value; + if(cfifo->put(cv)) + { + fprintf(stderr, "DssiSynthIF::oscControl: fifo overflow: in control number:%ld\n", cport); + } + } + + //const DSSI_Descriptor* dssi = synth->dssi; + //const LADSPA_Descriptor* ld = dssi->LADSPA_Plugin; + + ciMidiCtl2LadspaPort ip = synth->port2MidiCtlMap.find(cport); + if(ip != synth->port2MidiCtlMap.end()) + { + // TODO: TODO: Update midi MusE's midi controller knobs, sliders, boxes etc with a call to the midi port's setHwCtrlState() etc. + // But first we need a ladspa2MidiValue() function! ... + // + // + //float val = ladspa2MidiValue(ld, i, ?, ?); + + } + +#if 0 + int port = argv[0]->i; + LADSPA_Data value = argv[1]->f; + + if (port < 0 || port > instance->plugin->descriptor->LADSPA_Plugin->PortCount) { + fprintf(stderr, "MusE: OSC: %s port number (%d) is out of range\n", + instance->friendly_name, port); + return 0; + } + if (instance->pluginPortControlInNumbers[port] == -1) { + fprintf(stderr, "MusE: OSC: %s port %d is not a control in\n", + instance->friendly_name, port); + return 0; + } + pluginControlIns[instance->pluginPortControlInNumbers[port]] = value; + if (verbose) { + printf("MusE: OSC: %s port %d = %f\n", + instance->friendly_name, port, value); + } +#endif + return 0; + } + +/* +//--------------------------------------------------------- +// oscExiting +//--------------------------------------------------------- + +int DssiSynthIF::oscExiting(lo_arg**) + { + //printf("not impl.: oscExiting\n"); + + // The gui is gone now, right? + _guiVisible = false; + + //const DSSI_Descriptor* dssi = synth->dssi; + //const LADSPA_Descriptor* ld = dssi->LADSPA_Plugin; + //if(ld->deactivate) + // ld->deactivate(handle); + + if (uiOscPath == 0) { + printf("DssiSynthIF::oscExiting(): no uiOscPath\n"); + return 1; + } + char uiOscGuiPath[strlen(uiOscPath)+6]; + + sprintf(uiOscGuiPath, "%s/%s", uiOscPath, "quit"); + #ifdef DSSI_DEBUG + printf("DssiSynthIF::oscExiting(): sending quit to uiOscGuiPath:%s\n", uiOscGuiPath); + #endif + + lo_send(uiTarget, uiOscGuiPath, ""); + +#if 0 + int i; + + if (verbose) { + printf("MusE: OSC: got exiting notification for instance %d\n", + instance->number); + } + + if (instance->plugin) { + + // !!! No, this isn't safe -- plugins deactivated in this way + // would still be included in a run_multiple_synths call unless + // we re-jigged the instance array at the same time -- leave it + // for now + //if (instance->plugin->descriptor->LADSPA_Plugin->deactivate) { + // instance->plugin->descriptor->LADSPA_Plugin->deactivate + // (instanceHandles[instance->number]); + // } + // Leave this flag though, as we need it to determine when to exit + instance->inactive = 1; + } + + // Do we have any plugins left running? + + for (i = 0; i < instance_count; ++i) { + if (!instances[i].inactive) + return 0; + } + + if (verbose) { + printf("MusE: That was the last remaining plugin, exiting...\n"); + } + exiting = 1; +#endif + return 0; + } +*/ + +//--------------------------------------------------------- +// oscMidi +//--------------------------------------------------------- + +int DssiSynthIF::oscMidi(int a, int b, int c) + { + //int a = argv[0]->m[1]; + //int b = argv[0]->m[2]; + //int c = argv[0]->m[3]; + + if (a == ME_NOTEOFF) { + a = ME_NOTEON; + c = 0; + } + int channel = 0; // TODO: ?? + + int port = synti->midiPort(); + + //MidiEvent event(0, channel, a, b, c); + + if(port != -1) + { + MidiPlayEvent event(0, port, channel, a, b, c); + + #ifdef DSSI_DEBUG + fprintf(stderr, "DssiSynthIF::oscMidi midi event chn:%d a:%d b:%d\n", event.channel(), event.dataA(), event.dataB()); + #endif + + midiPorts[port].sendEvent(event); + } + + //synti->playMidiEvent(&event); // TODO + // + //MidiDevice* md = dynamic_cast<MidiDevice*>(synti); + //if(md) + // md->putEvent(event); + // + //synti->putEvent(event); + // + + return 0; + } + +//--------------------------------------------------------- +// oscConfigure +//--------------------------------------------------------- + +int DssiSynthIF::oscConfigure(const char *key, const char *value) + { + //const char *key = (const char *)&argv[0]->s; + //const char *value = (const char *)&argv[1]->s; + + // This is pretty much the simplest legal implementation of + // configure in a DSSI host. + + // The host has the option to remember the set of (key,value) + // pairs associated with a particular instance, so that if it + // wants to restore the "same" instance on another occasion it can + // just call configure() on it for each of those pairs and so + // restore state without any input from a GUI. Any real-world GUI + // host will probably want to do that. This host doesn't have any + // concept of restoring an instance from one run to the next, so + // we don't bother remembering these at all. + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::oscConfigure synth name:%s key:%s value:%s\n", synti->name().toLatin1().constData(), key, value); + #endif + + // Add or modify the configuration map item. + synti->_stringParamMap.set(key, value); + + if (!strncmp(key, DSSI_RESERVED_CONFIGURE_PREFIX, + strlen(DSSI_RESERVED_CONFIGURE_PREFIX))) { + fprintf(stderr, "MusE: OSC: UI for plugin '%s' attempted to use reserved configure key \"%s\", ignoring\n", + //synti->name().toAscii().data(), key); + synti->name().toLatin1().constData(), key); + + return 0; + } + + if (!synth->dssi->configure) + return 0; + + char* message = synth->dssi->configure(handle, key, value); + if (message) { + printf("MusE: on configure '%s' '%s', plugin '%s' returned error '%s'\n", + //key, value, synti->name().toAscii().data(), message); + key, value, synti->name().toLatin1().constData(), message); + + free(message); + } + + // also call back on UIs for plugins other than the one + // that requested this: + // if (n != instance->number && instances[n].uiTarget) { + // lo_send(instances[n].uiTarget, + // instances[n].ui_osc_configure_path, "ss", key, value); + // } + + // configure invalidates bank and program information, so + // we should do this again now: + queryPrograms(); + return 0; + } +#endif // OSC_SUPPORT + +//--------------------------------------------------------- +// queryPrograms +//--------------------------------------------------------- + +void DssiSynthIF::queryPrograms() + { + for (std::vector<DSSI_Program_Descriptor>::const_iterator i = programs.begin(); + i != programs.end(); ++i) { + free((void*)(i->Name)); + } + programs.clear(); + + //if (!(synth->dssi->get_program && synth->dssi->select_program)) + if (!synth->dssi->get_program) + return; + + for (int i = 0;; ++i) { + const DSSI_Program_Descriptor* pd = synth->dssi->get_program(handle, i); + if (pd == 0) + break; + DSSI_Program_Descriptor d; + d.Name = strdup(pd->Name); + d.Program = pd->Program; + d.Bank = pd->Bank; + programs.push_back(d); + } + } + +//--------------------------------------------------------- +// getPatchName +//--------------------------------------------------------- + +//QString DssiSynthIF::getPatchName(int, int prog) +const char* DssiSynthIF::getPatchName(int /*chan*/, int prog, MType /*type*/, bool /*drum*/) + { + unsigned program = prog & 0x7f; + int lbank = (prog >> 8) & 0xff; + int hbank = (prog >> 16) & 0xff; + + if (lbank == 0xff) + lbank = 0; + if (hbank == 0xff) + hbank = 0; + unsigned bank = (hbank << 8) + lbank; + + for (std::vector<DSSI_Program_Descriptor>::const_iterator i = programs.begin(); + i != programs.end(); ++i) { + if (i->Bank == bank && i->Program ==program) + return i->Name; + } + return "?"; + } + +//--------------------------------------------------------- +// populatePatchPopup +//--------------------------------------------------------- + +//void DssiSynthIF::populatePatchPopup(QMenu* menu, int) +void DssiSynthIF::populatePatchPopup(QMenu* menu, int /*ch*/, MType /*type*/, bool /*drum*/) + { + // The plugin can change the programs, patches etc. + // So make sure we're up to date by calling queryPrograms. + queryPrograms(); + + menu->clear(); + + for (std::vector<DSSI_Program_Descriptor>::const_iterator i = programs.begin(); + i != programs.end(); ++i) { + int bank = i->Bank; + int prog = i->Program; + int id = (bank << 16) + prog; + + QAction *act = menu->addAction(QString(i->Name)); + act->setData(id); + } + } + +int DssiSynthIF::getControllerInfo(int id, const char** name, int* ctrl, int* min, int* max, int* initval) +{ + int controlPorts = synth->_controlInPorts; + if(id >= controlPorts) + //if(id >= midiCtl2PortMap.size()) + return 0; + + const DSSI_Descriptor* dssi = synth->dssi; + const LADSPA_Descriptor* ld = dssi->LADSPA_Plugin; + + // Hmm, <map> has a weird [] operator. Would it work? + // For now just use duplicate code found in ::init() + //iMidiCtl2LadspaPort ip = midiCtl2PortMap[id]; + //int ctlnum = ip->first; + //int k = ip->second; + + int i = synth->pIdx[id]; + //int i = synth->pIdx[k]; + + //ladspaDefaultValue(ld, i, &controls[id].val); + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::getControllerInfo control port:%d port idx:%d name:%s\n", id, i, ld->PortNames[i]); + #endif + + int ctlnum = DSSI_NONE; + if(dssi->get_midi_controller_for_port) + ctlnum = dssi->get_midi_controller_for_port(handle, i); + + + // No controller number? Give it one. + if(ctlnum == DSSI_NONE) + { + // TODO: If neccesary... choose non-existing numbers... + //for(int k = 0; k < controlPorts; ++k) + //{ + // int i = synth->pIdx[k]; + //} + + // Simple but flawed solution: Start them at 0x60000 + 0x2000 = 0x62000. Max NRPN number is 0x3fff. + ctlnum = CTRL_NRPN14_OFFSET + 0x2000 + id; + } + else + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::getControllerInfo ctlnum:%d\n", ctlnum); + #endif + + int c = ctlnum; + // Can be both CC and NRPN! Prefer CC over NRPN. + if(DSSI_IS_CC(ctlnum)) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::getControllerInfo is CC control\n"); + #endif + + ctlnum = DSSI_CC_NUMBER(c); + + #ifdef DSSI_DEBUG + if(DSSI_IS_NRPN(ctlnum)) + printf("DssiSynthIF::getControllerInfo is also NRPN control. Using CC.\n"); + #endif + } + else + if(DSSI_IS_NRPN(ctlnum)) + { + #ifdef DSSI_DEBUG + printf("DssiSynthIF::getControllerInfo is NRPN control\n"); + #endif + + ctlnum = DSSI_NRPN_NUMBER(c) + CTRL_NRPN14_OFFSET; + } + } + + int def = CTRL_VAL_UNKNOWN; + if(ladspa2MidiControlValues(ld, i, ctlnum, min, max, &def)) + *initval = def; + else + *initval = CTRL_VAL_UNKNOWN; + + #ifdef DSSI_DEBUG + printf("DssiSynthIF::getControllerInfo passed ctlnum:%d min:%d max:%d initval:%d\n", ctlnum, *min, *max, *initval); + #endif + + *ctrl = ctlnum; + *name = ld->PortNames[i]; + return ++id; + + /* + // ...now create midi controllers for ports which did not define them ... + for(int k = 0; k < controlPorts; ++k) + { + int i = synth->pIdx[k]; + //controls[k].val = ladspaDefaultValue(ld, i); + ladspaDefaultValue(ld, i, &controls[k].val); + + printf("DssiSynthIF::getControllerInfo #2 control port:%d port idx:%d name:%s\n", k, i, ld->PortNames[i]); + + if(!dssi->get_midi_controller_for_port || (dssi->get_midi_controller_for_port(handle, i) == DSSI_NONE)) + { + int ctlnum; + //printf("DssiSynthIF::getControllerInfo #2 midi controller number:%d\n", ctlnum); + printf("DssiSynthIF::getControllerInfo #2 creating MidiController number:%d\n", ctlnum); + MidiController* mc = ladspa2MidiController(ld, i, ctlnum); + // Add to MidiInstrument controller list. + if(mc) + { + printf("DssiSynthIF::getControllerInfo #2 adding MidiController to instrument\n"); + ((MidiInstrument*)synti)->controller()->add(mc); + } + } + else + { + + } + } + */ + +} + +int DssiSynthIF::channels() const +{ + return synth->_outports > MAX_CHANNELS ? MAX_CHANNELS : synth->_outports; +} + +int DssiSynthIF::totalOutChannels() const +{ + return synth->_outports; +} + +int DssiSynthIF::totalInChannels() const +{ + return synth->_inports; +} + +//-------------------------------- +// Methods for PluginIBase: +//-------------------------------- + +bool DssiSynthIF::on() const { return true; } // Synth is not part of a rack plugin chain. Always on. +void DssiSynthIF::setOn(bool /*val*/) { } +int DssiSynthIF::pluginID() { return (synth && synth->dssi) ? synth->dssi->LADSPA_Plugin->UniqueID : 0; } +int DssiSynthIF::id() { return 0; } // Synth is not part of a rack plugin chain. Always 0. +QString DssiSynthIF::pluginLabel() const { return (synth && synth->dssi) ? QString(synth->dssi->LADSPA_Plugin->Label) : QString(); } +QString DssiSynthIF::name() const { return synti->name(); } +AudioTrack* DssiSynthIF::track() { return (AudioTrack*)synti; } +void DssiSynthIF::enableController(int i, bool v) { controls[i].enCtrl = v; } +bool DssiSynthIF::controllerEnabled(int i) const { return controls[i].enCtrl; } +bool DssiSynthIF::controllerEnabled2(int i) const { return controls[i].en2Ctrl; } +void DssiSynthIF::updateControllers() { } +void DssiSynthIF::writeConfiguration(int /*level*/, Xml& /*xml*/) { } +bool DssiSynthIF::readConfiguration(Xml& /*xml*/, bool /*readPreset*/) { return false; } +int DssiSynthIF::parameters() const { return synth ? synth->_controlInPorts : 0; } +void DssiSynthIF::setParam(int i, double val) { setParameter(i, val); } +double DssiSynthIF::param(int i) const { return getParameter(i); } +const char* DssiSynthIF::paramName(int i) { return (synth && synth->dssi) ? synth->dssi->LADSPA_Plugin->PortNames[i] : 0; } +//LADSPA_PortRangeHint DssiSynthIF::range(int i) { return (synth && synth->dssi) ? synth->dssi->LADSPA_Plugin->PortRangeHints[i] : 0; } +LADSPA_PortRangeHint DssiSynthIF::range(int i) { return synth->dssi->LADSPA_Plugin->PortRangeHints[i]; } + + +#else //DSSI_SUPPORT +void initDSSI() {} +#endif + |