/*
- Copyright (C) 2000-2004 Paul Davis
+ Copyright (C) 2000-2006 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
+#ifdef WAF_BUILD
+#include "libardour-config.h"
+#endif
+
+#include <stdint.h>
+
#include <sys/types.h>
#include <cstdio>
#include <lrdf.h>
#include <dlfcn.h>
+#include <cstdlib>
+#include <fstream>
#ifdef VST_SUPPORT
#include <fst.h>
+#include "pbd/basename.h"
+#include <cstring>
+#endif // VST_SUPPORT
+
+#ifdef LXVST_SUPPORT
+#include <ardour/vstfx.h>
#include <pbd/basename.h>
-#include <string.h>
+#include <cstring>
+#endif //LXVST_SUPPORT
+
+#include <glibmm/miscutils.h>
+
+#include "pbd/pathscanner.h"
+#include "pbd/whitespace.h"
+
+#include "ardour/debug.h"
+#include "ardour/filesystem_paths.h"
+#include "ardour/ladspa.h"
+#include "ardour/ladspa_plugin.h"
+#include "ardour/plugin.h"
+#include "ardour/plugin_manager.h"
+#include "ardour/session.h"
+
+#ifdef LV2_SUPPORT
+#include "ardour/lv2_plugin.h"
#endif
-#include <pbd/pathscanner.h>
+#ifdef VST_SUPPORT
+#include "ardour/vst_plugin.h"
+#endif
+
+#ifdef LXVST_SUPPORT
+#include "ardour/lxvst_plugin.h"
+#endif
-#include <ardour/ladspa.h>
-#include <ardour/session.h>
-#include <ardour/plugin_manager.h>
-#include <ardour/plugin.h>
-#include <ardour/ladspa_plugin.h>
-#include <ardour/vst_plugin.h>
+#ifdef AUDIOUNIT_SUPPORT
+#include "ardour/audio_unit.h"
+#include <Carbon/Carbon.h>
+#endif
-#include <pbd/error.h>
-#include <pbd/stl_delete.h>
+#include "pbd/error.h"
+#include "pbd/stl_delete.h"
#include "i18n.h"
using namespace ARDOUR;
using namespace PBD;
+using namespace std;
PluginManager* PluginManager::_manager = 0;
-PluginManager::PluginManager (AudioEngine& e)
- : _engine (e)
+PluginManager::PluginManager ()
+ : _vst_plugin_info(0)
+ , _lxvst_plugin_info(0)
+ , _ladspa_plugin_info(0)
+ , _lv2_plugin_info(0)
+ , _au_plugin_info(0)
{
char* s;
string lrdf_path;
+ load_statuses ();
+
if ((s = getenv ("LADSPA_RDF_PATH"))){
lrdf_path = s;
}
}
#endif /* VST_SUPPORT */
+#ifdef LXVST_SUPPORT
+ if (Config->get_use_lxvst()) {
+ add_lxvst_presets();
+ }
+#endif /* Native LinuxVST support*/
+
if ((s = getenv ("LADSPA_PATH"))) {
ladspa_path = s;
}
vst_path = s;
}
- refresh ();
+ if ((s = getenv ("LXVST_PATH"))) {
+ lxvst_path = s;
+ } else if ((s = getenv ("LXVST_PLUGINS"))) {
+ lxvst_path = s;
+ }
if (_manager == 0) {
_manager = this;
}
+
+ /* the plugin manager is constructed too early to use Profile */
+
+ if (getenv ("ARDOUR_SAE")) {
+ ladspa_plugin_whitelist.push_back (1203); // single band parametric
+ ladspa_plugin_whitelist.push_back (1772); // caps compressor
+ ladspa_plugin_whitelist.push_back (1913); // fast lookahead limiter
+ ladspa_plugin_whitelist.push_back (1075); // simple RMS expander
+ ladspa_plugin_whitelist.push_back (1061); // feedback delay line (max 5s)
+ ladspa_plugin_whitelist.push_back (1216); // gverb
+ ladspa_plugin_whitelist.push_back (2150); // tap pitch shifter
+ }
+
+ BootMessage (_("Discovering Plugins"));
+}
+
+
+PluginManager::~PluginManager()
+{
}
+
void
PluginManager::refresh ()
{
+ DEBUG_TRACE (DEBUG::PluginManager, "PluginManager::refresh\n");
+
ladspa_refresh ();
+#ifdef LV2_SUPPORT
+ lv2_refresh ();
+#endif
#ifdef VST_SUPPORT
if (Config->get_use_vst()) {
vst_refresh ();
}
+#endif // VST_SUPPORT
+
+#ifdef LXVST_SUPPORT
+ if(Config->get_use_lxvst()) {
+ lxvst_refresh();
+ }
+#endif //Native linuxVST SUPPORT
+
+#ifdef AUDIOUNIT_SUPPORT
+ au_refresh ();
#endif
+
+ PluginListChanged (); /* EMIT SIGNAL */
}
void
PluginManager::ladspa_refresh ()
{
- for (std::list<PluginInfo*>::iterator i = _ladspa_plugin_info.begin(); i != _ladspa_plugin_info.end(); ++i) {
- delete *i;
- }
+ if (_ladspa_plugin_info)
+ _ladspa_plugin_info->clear ();
+ else
+ _ladspa_plugin_info = new ARDOUR::PluginInfoList ();
+
+ static const char *standard_paths[] = {
+ "/usr/local/lib64/ladspa",
+ "/usr/local/lib/ladspa",
+ "/usr/lib64/ladspa",
+ "/usr/lib/ladspa",
+ "/Library/Audio/Plug-Ins/LADSPA",
+ ""
+ };
+
+ /* allow LADSPA_PATH to augment, not override standard locations */
+
+ /* Only add standard locations to ladspa_path if it doesn't
+ * already contain them. Check for trailing G_DIR_SEPARATOR too.
+ */
+
+ int i;
+ for (i = 0; standard_paths[i][0]; i++) {
+ size_t found = ladspa_path.find(standard_paths[i]);
+ if (found != ladspa_path.npos) {
+ switch (ladspa_path[found + strlen(standard_paths[i])]) {
+ case ':' :
+ case '\0':
+ continue;
+ case G_DIR_SEPARATOR :
+ if (ladspa_path[found + strlen(standard_paths[i]) + 1] == ':' ||
+ ladspa_path[found + strlen(standard_paths[i]) + 1] == '\0') {
+ continue;
+ }
+ }
+ }
+ if (!ladspa_path.empty())
+ ladspa_path += ":";
- _ladspa_plugin_info.clear ();
+ ladspa_path += standard_paths[i];
- if (ladspa_path.length() == 0) {
- ladspa_path = "/usr/local/lib/ladspa:/usr/lib/ladspa";
}
+ DEBUG_TRACE (DEBUG::PluginManager, string_compose ("LADSPA: search along: [%1]\n", ladspa_path));
+
ladspa_discover_from_path (ladspa_path);
}
+
int
PluginManager::add_ladspa_directory (string path)
{
ladspa_path += ':';
ladspa_path += path;
return 0;
- }
+ }
return -1;
}
-static bool ladspa_filter (const string& str, void *arg)
+static bool ladspa_filter (const string& str, void */*arg*/)
{
/* Not a dotfile, has a prefix before a period, suffix is "so" */
-
+
return str[0] != '.' && (str.length() > 3 && str.find (".so") == (str.length() - 3));
}
int
-PluginManager::ladspa_discover_from_path (string path)
+PluginManager::ladspa_discover_from_path (string /*path*/)
{
PathScanner scanner;
vector<string *> *plugin_objects;
return ret;
}
-static bool rdf_filter (const string &str, void *arg)
+static bool rdf_filter (const string &str, void* /*arg*/)
{
- return str[0] != '.' &&
+ return str[0] != '.' &&
((str.find(".rdf") == (str.length() - 4)) ||
(str.find(".rdfs") == (str.length() - 5)) ||
- (str.find(".n3") == (str.length() - 3)));
+ (str.find(".n3") == (str.length() - 3)) ||
+ (str.find(".ttl") == (str.length() - 4)));
}
void
{
add_presets ("vst");
}
+
+void
+PluginManager::add_lxvst_presets()
+{
+ add_presets ("lxvst");
+}
+
void
PluginManager::add_presets(string domain)
{
PathScanner scanner;
vector<string *>* rdf_files;
vector<string *>::iterator x;
- string uri;
rdf_files = scanner (path, rdf_filter, 0, true, true);
if (rdf_files) {
for (x = rdf_files->begin(); x != rdf_files->end (); ++x) {
- uri = "file://" + **x;
+ const string uri(string("file://") + **x);
if (lrdf_read_file(uri.c_str())) {
warning << "Could not parse rdf file: " << uri << endmsg;
vector_delete (rdf_files);
}
-int
+int
PluginManager::ladspa_discover (string path)
{
- PluginInfo *info;
void *module;
const LADSPA_Descriptor *descriptor;
LADSPA_Descriptor_Function dfunc;
break;
}
- info = new PluginInfo;
+ if (!ladspa_plugin_whitelist.empty()) {
+ if (find (ladspa_plugin_whitelist.begin(), ladspa_plugin_whitelist.end(), descriptor->UniqueID) == ladspa_plugin_whitelist.end()) {
+ continue;
+ }
+ }
+
+ PluginInfoPtr info(new LadspaPluginInfo);
info->name = descriptor->Name;
info->category = get_ladspa_category(descriptor->UniqueID);
+ info->creator = descriptor->Maker;
info->path = path;
info->index = i;
- info->n_inputs = 0;
- info->n_outputs = 0;
- info->type = PluginInfo::LADSPA;
- info->unique_id = descriptor->UniqueID;
-
+ info->n_inputs = ChanCount();
+ info->n_outputs = ChanCount();
+ info->type = ARDOUR::LADSPA;
+
+ char buf[32];
+ snprintf (buf, sizeof (buf), "%lu", descriptor->UniqueID);
+ info->unique_id = buf;
+
for (uint32_t n=0; n < descriptor->PortCount; ++n) {
if ( LADSPA_IS_PORT_AUDIO (descriptor->PortDescriptors[n]) ) {
if ( LADSPA_IS_PORT_INPUT (descriptor->PortDescriptors[n]) ) {
- info->n_inputs++;
+ info->n_inputs.set_audio(info->n_inputs.n_audio() + 1);
}
else if ( LADSPA_IS_PORT_OUTPUT (descriptor->PortDescriptors[n]) ) {
- info->n_outputs++;
+ info->n_outputs.set_audio(info->n_outputs.n_audio() + 1);
}
}
}
- _ladspa_plugin_info.push_back (info);
- }
-
-// GDB WILL NOT LIKE YOU IF YOU DO THIS
-// dlclose (module);
+ if(_ladspa_plugin_info->empty()){
+ _ladspa_plugin_info->push_back (info);
+ }
- return 0;
-}
+ //Ensure that the plugin is not already in the plugin list.
-Plugin *
-PluginManager::load (Session& session, PluginInfo *info)
-{
- void *module;
- Plugin *plugin = 0;
-
- try {
- if (info->type == PluginInfo::VST) {
-
-#ifdef VST_SUPPORT
- if (Config->get_use_vst()) {
- FSTHandle* handle;
-
- if ((handle = fst_load (info->path.c_str())) == 0) {
- error << string_compose(_("VST: cannot load module from \"%1\""), info->path) << endmsg;
- } else {
- plugin = new VSTPlugin (_engine, session, handle);
- }
- } else {
- error << _("You asked ardour to not use any VST plugins") << endmsg;
- }
-#else
- error << _("This version of ardour has no support for VST plugins") << endmsg;
- return 0;
-#endif
-
- } else {
+ bool found = false;
- if ((module = dlopen (info->path.c_str(), RTLD_NOW)) == 0) {
- error << string_compose(_("LADSPA: cannot load module from \"%1\""), info->path) << endmsg;
- error << dlerror() << endmsg;
- } else {
- plugin = new LadspaPlugin (module, _engine, session, info->index, session.frame_rate());
+ for (PluginInfoList::const_iterator i = _ladspa_plugin_info->begin(); i != _ladspa_plugin_info->end(); ++i) {
+ if(0 == info->unique_id.compare((*i)->unique_id)){
+ found = true;
}
}
- plugin->set_info(*info);
+ if(!found){
+ _ladspa_plugin_info->push_back (info);
+ }
}
- catch (failed_constructor &err) {
- plugin = 0;
- }
-
- return plugin;
-}
-
-Plugin *
-ARDOUR::find_plugin(Session& session, string name, long unique_id, PluginInfo::Type type)
-{
- PluginManager *mgr = PluginManager::the_manager();
- list<PluginInfo *>::iterator i;
- list<PluginInfo *>* plugs = 0;
-
- switch (type) {
- case PluginInfo::LADSPA:
- plugs = &mgr->ladspa_plugin_info();
- break;
- case PluginInfo::VST:
- plugs = &mgr->vst_plugin_info();
- unique_id = 0; // VST plugins don't have a unique id.
- break;
- case PluginInfo::AudioUnit:
- default:
- return 0;
- }
+// GDB WILL NOT LIKE YOU IF YOU DO THIS
+// dlclose (module);
- for (i = plugs->begin(); i != plugs->end(); ++i) {
- if ((name == "" || (*i)->name == name) &&
- (unique_id == 0 || (*i)->unique_id == unique_id)) {
- return mgr->load (session, *i);
- }
- }
-
return 0;
}
snprintf(buf, sizeof(buf), "%s%" PRIu32, LADSPA_BASE, plugin_id);
pattern.subject = buf;
- pattern.predicate = RDF_TYPE;
+ pattern.predicate = (char*)RDF_TYPE;
pattern.object = 0;
pattern.object_type = lrdf_uri;
lrdf_statement* matches1 = lrdf_matches (&pattern);
if (!matches1) {
- return _("Unknown");
+ return "Unknown";
}
pattern.subject = matches1->object;
- pattern.predicate = LADSPA_BASE "hasLabel";
+ pattern.predicate = (char*)(LADSPA_BASE "hasLabel");
pattern.object = 0;
pattern.object_type = lrdf_literal;
lrdf_free_statements(matches1);
if (!matches2) {
- return _("Unknown");
+ return ("Unknown");
}
string label = matches2->object;
lrdf_free_statements(matches2);
- return label;
+ /* Kludge LADSPA class names to be singular and match LV2 class names.
+ This avoids duplicate plugin menus for every class, which is necessary
+ to make the plugin category menu at all usable, but is obviously a
+ filthy kludge.
+
+ In the short term, lrdf could be updated so the labels match and a new
+ release made. To support both specs, we should probably be mapping the
+ URIs to the same category in code and perhaps tweaking that hierarchy
+ dynamically to suit the user. Personally, I (drobilla) think that time
+ is better spent replacing the little-used LRDF.
+
+ In the longer term, we will abandon LRDF entirely in favour of LV2 and
+ use that class hierarchy. Aside from fixing this problem properly, that
+ will also allow for translated labels. SWH plugins have been LV2 for
+ ages; TAP needs porting. I don't know of anything else with LRDF data.
+ */
+ if (label == "Utilities") {
+ return "Utility";
+ } else if (label == "Pitch shifters") {
+ return "Pitch Shifter";
+ } else if (label != "Dynamics" && label != "Chorus"
+ &&label[label.length() - 1] == 's'
+ && label[label.length() - 2] != 's') {
+ return label.substr(0, label.length() - 1);
+ } else {
+ return label;
+ }
+}
+
+#ifdef LV2_SUPPORT
+void
+PluginManager::lv2_refresh ()
+{
+ delete _lv2_plugin_info;
+ _lv2_plugin_info = LV2PluginInfo::discover();
}
+#endif
+
+#ifdef AUDIOUNIT_SUPPORT
+void
+PluginManager::au_refresh ()
+{
+ DEBUG_TRACE (DEBUG::PluginManager, "AU: refresh\n");
+ delete _au_plugin_info;
+ _au_plugin_info = AUPluginInfo::discover();
+}
+
+#endif
#ifdef VST_SUPPORT
void
PluginManager::vst_refresh ()
{
- for (std::list<PluginInfo*>::iterator i = _vst_plugin_info.begin(); i != _vst_plugin_info.end(); ++i) {
- delete *i;
- }
-
- _vst_plugin_info.clear ();
+ if (_vst_plugin_info)
+ _vst_plugin_info->clear ();
+ else
+ _vst_plugin_info = new ARDOUR::PluginInfoList();
if (vst_path.length() == 0) {
vst_path = "/usr/local/lib/vst:/usr/lib/vst";
vst_path += ':';
vst_path += path;
return 0;
- }
+ }
return -1;
}
static bool vst_filter (const string& str, void *arg)
{
/* Not a dotfile, has a prefix before a period, suffix is "dll" */
-
+
return str[0] != '.' && (str.length() > 4 && str.find (".dll") == (str.length() - 4));
}
vector<string *>::iterator x;
int ret = 0;
- info << "detecting VST plugins along " << path << endmsg;
+ DEBUG_TRACE (DEBUG::PluginManager, string_compose ("detecting VST plugins along %1\n", path));
plugin_objects = scanner (vst_path, vst_filter, 0, true, true);
PluginManager::vst_discover (string path)
{
FSTInfo* finfo;
- PluginInfo* info;
+ char buf[32];
if ((finfo = fst_get_info (const_cast<char *> (path.c_str()))) == 0) {
+ warning << "Cannot get VST information from " << path << endmsg;
return -1;
}
finfo->name)
<< endl;
}
-
- info = new PluginInfo;
- /* what a goddam joke freeware VST is */
+ PluginInfoPtr info(new VSTPluginInfo);
+
+ /* what a joke freeware VST is */
if (!strcasecmp ("The Unnamed plugin", finfo->name)) {
info->name = PBD::basename_nosuffix (path);
info->name = finfo->name;
}
+
+ snprintf (buf, sizeof (buf), "%d", finfo->UniqueID);
+ info->unique_id = buf;
info->category = "VST";
info->path = path;
+ info->creator = finfo->creator;
info->index = 0;
- info->n_inputs = finfo->numInputs;
- info->n_outputs = finfo->numOutputs;
- info->type = PluginInfo::VST;
-
- _vst_plugin_info.push_back (info);
+ info->n_inputs.set_audio (finfo->numInputs);
+ info->n_outputs.set_audio (finfo->numOutputs);
+ info->n_inputs.set_midi (finfo->wantMidi ? 1 : 0);
+ info->type = ARDOUR::VST;
+
+ _vst_plugin_info->push_back (info);
fst_free_info (finfo);
return 0;
}
+#endif // VST_SUPPORT
+
+#ifdef LXVST_SUPPORT
+
+void
+PluginManager::lxvst_refresh ()
+{
+ if (_lxvst_plugin_info) {
+ _lxvst_plugin_info->clear ();
+ } else {
+ _lxvst_plugin_info = new ARDOUR::PluginInfoList();
+ }
+
+ if (lxvst_path.length() == 0) {
+ lxvst_path = "/usr/local/lib64/lxvst:/usr/local/lib/lxvst:/usr/lib64/lxvst:/usr/lib/lxvst";
+ }
+
+ lxvst_discover_from_path (lxvst_path);
+}
+
+int
+PluginManager::add_lxvst_directory (string path)
+{
+ if (lxvst_discover_from_path (path) == 0) {
+ lxvst_path += ':';
+ lxvst_path += path;
+ return 0;
+ }
+ return -1;
+}
+
+static bool lxvst_filter (const string& str, void *)
+{
+ /* Not a dotfile, has a prefix before a period, suffix is "so" */
+
+ return str[0] != '.' && (str.length() > 3 && str.find (".so") == (str.length() - 3));
+}
+
+int
+PluginManager::lxvst_discover_from_path (string path)
+{
+ PathScanner scanner;
+ vector<string *> *plugin_objects;
+ vector<string *>::iterator x;
+ int ret = 0;
+
+ DEBUG_TRACE (DEBUG::PluginManager, string_compose ("Discovering linuxVST plugins along %1\n", path));
+
+ plugin_objects = scanner (lxvst_path, lxvst_filter, 0, true, true);
+
+ if (plugin_objects) {
+ for (x = plugin_objects->begin(); x != plugin_objects->end (); ++x) {
+ lxvst_discover (**x);
+ }
+ }
+
+ vector_delete (plugin_objects);
+ return ret;
+}
+
+int
+PluginManager::lxvst_discover (string path)
+{
+ VSTFXInfo* finfo;
+ char buf[32];
+
+ if ((finfo = vstfx_get_info (const_cast<char *> (path.c_str()))) == 0) {
+ warning << "Cannot get linuxVST information from " << path << endmsg;
+ return -1;
+ }
+
+ if (!finfo->canProcessReplacing) {
+ warning << string_compose (_("linuxVST plugin %1 does not support processReplacing, and so cannot be used in ardour at this time"),
+ finfo->name)
+ << endl;
+ }
+
+ PluginInfoPtr info(new LXVSTPluginInfo);
+
+ if (!strcasecmp ("The Unnamed plugin", finfo->name)) {
+ info->name = PBD::basename_nosuffix (path);
+ } else {
+ info->name = finfo->name;
+ }
+
+
+ snprintf (buf, sizeof (buf), "%d", finfo->UniqueID);
+ info->unique_id = buf;
+ info->category = "linuxVSTs";
+ info->path = path;
+ info->creator = finfo->creator;
+ info->index = 0;
+ info->n_inputs.set_audio (finfo->numInputs);
+ info->n_outputs.set_audio (finfo->numOutputs);
+ info->n_inputs.set_midi (finfo->wantMidi ? 1 : 0);
+ info->type = ARDOUR::LXVST;
+
+ /* Make sure we don't find the same plugin in more than one place along
+ the LXVST_PATH We can't use a simple 'find' because the path is included
+ in the PluginInfo, and that is the one thing we can be sure MUST be
+ different if a duplicate instance is found. So we just compare the type
+ and unique ID (which for some VSTs isn't actually unique...)
+ */
+
+ if (!_lxvst_plugin_info->empty()) {
+ for (PluginInfoList::iterator i =_lxvst_plugin_info->begin(); i != _lxvst_plugin_info->end(); ++i) {
+ if ((info->type == (*i)->type)&&(info->unique_id == (*i)->unique_id)) {
+ vstfx_free_info(finfo);
+ return 0;
+ }
+ }
+ }
+
+ _lxvst_plugin_info->push_back (info);
+ vstfx_free_info (finfo);
+
+ return 0;
+}
+
+#endif // LXVST_SUPPORT
+
+
+PluginManager::PluginStatusType
+PluginManager::get_status (const PluginInfoPtr& pi)
+{
+ PluginStatus ps (pi->type, pi->unique_id);
+ PluginStatusList::const_iterator i = find (statuses.begin(), statuses.end(), ps);
+ if (i == statuses.end() ) {
+ return Normal;
+ } else {
+ return i->status;
+ }
+}
+
+void
+PluginManager::save_statuses ()
+{
+ ofstream ofs;
+ sys::path path = user_config_directory();
+ path /= "plugin_statuses";
+
+ ofs.open (path.to_string().c_str(), ios_base::openmode (ios::out|ios::trunc));
+
+ if (!ofs) {
+ return;
+ }
+
+ for (PluginStatusList::iterator i = statuses.begin(); i != statuses.end(); ++i) {
+ switch ((*i).type) {
+ case LADSPA:
+ ofs << "LADSPA";
+ break;
+ case AudioUnit:
+ ofs << "AudioUnit";
+ break;
+ case LV2:
+ ofs << "LV2";
+ break;
+ case VST:
+ ofs << "VST";
+ break;
+ case LXVST:
+ ofs << "LXVST";
+ break;
+ }
+
+ ofs << ' ';
+
+ switch ((*i).status) {
+ case Normal:
+ ofs << "Normal";
+ break;
+ case Favorite:
+ ofs << "Favorite";
+ break;
+ case Hidden:
+ ofs << "Hidden";
+ break;
+ }
+
+ ofs << ' ';
+ ofs << (*i).unique_id;;
+ ofs << endl;
+ }
+
+ ofs.close ();
+}
+
+void
+PluginManager::load_statuses ()
+{
+ sys::path path = user_config_directory();
+ path /= "plugin_statuses";
+ ifstream ifs (path.to_string().c_str());
+
+ if (!ifs) {
+ return;
+ }
+
+ std::string stype;
+ std::string sstatus;
+ std::string id;
+ PluginType type;
+ PluginStatusType status;
+ char buf[1024];
+
+ while (ifs) {
+
+ ifs >> stype;
+ if (!ifs) {
+ break;
+
+ }
+
+ ifs >> sstatus;
+ if (!ifs) {
+ break;
+
+ }
+
+ /* rest of the line is the plugin ID */
+
+ ifs.getline (buf, sizeof (buf), '\n');
+ if (!ifs) {
+ break;
+ }
+
+ if (sstatus == "Normal") {
+ status = Normal;
+ } else if (sstatus == "Favorite") {
+ status = Favorite;
+ } else if (sstatus == "Hidden") {
+ status = Hidden;
+ } else {
+ error << string_compose (_("unknown plugin status type \"%1\" - all entries ignored"), sstatus)
+ << endmsg;
+ statuses.clear ();
+ break;
+ }
+
+ if (stype == "LADSPA") {
+ type = LADSPA;
+ } else if (stype == "AudioUnit") {
+ type = AudioUnit;
+ } else if (stype == "LV2") {
+ type = LV2;
+ } else if (stype == "VST") {
+ type = VST;
+ } else if (stype == "LXVST") {
+ type = LXVST;
+ } else {
+ error << string_compose (_("unknown plugin type \"%1\" - ignored"), stype)
+ << endmsg;
+ continue;
+ }
+
+ id = buf;
+ strip_whitespace_edges (id);
+ set_status (type, id, status);
+ }
+
+ ifs.close ();
+}
+
+void
+PluginManager::set_status (PluginType t, string id, PluginStatusType status)
+{
+ PluginStatus ps (t, id, status);
+ statuses.erase (ps);
+
+ if (status == Normal) {
+ return;
+ }
+
+ statuses.insert (ps);
+}
+
+ARDOUR::PluginInfoList&
+PluginManager::vst_plugin_info ()
+{
+#ifdef VST_SUPPORT
+ if (!_vst_plugin_info)
+ vst_refresh();
+ return *_vst_plugin_info;
+#else
+ return _empty_plugin_info;
+#endif
+}
+
+ARDOUR::PluginInfoList&
+PluginManager::lxvst_plugin_info ()
+{
+#ifdef LXVST_SUPPORT
+ if (!_lxvst_plugin_info)
+ lxvst_refresh();
+ return *_lxvst_plugin_info;
+#else
+ return _empty_plugin_info;
+#endif
+}
+
+ARDOUR::PluginInfoList&
+PluginManager::ladspa_plugin_info ()
+{
+ if (!_ladspa_plugin_info)
+ ladspa_refresh();
+ return *_ladspa_plugin_info;
+}
+
+ARDOUR::PluginInfoList&
+PluginManager::lv2_plugin_info ()
+{
+#ifdef LV2_SUPPORT
+ if (!_lv2_plugin_info)
+ lv2_refresh();
+ return *_lv2_plugin_info;
+#else
+ return _empty_plugin_info;
+#endif
+}
+
+ARDOUR::PluginInfoList&
+PluginManager::au_plugin_info ()
+{
+#ifdef AUDIOUNIT_SUPPORT
+ if (!_au_plugin_info)
+ au_refresh();
+ return *_au_plugin_info;
+#else
+ return _empty_plugin_info;
#endif
+}
projects / ardour.git / blobdiff