#include <sys/types.h>
#include <cstdio>
#include <cstdlib>
-#include <fstream>
+
+#include <glib.h>
+#include "pbd/gstdio_compat.h"
#ifdef HAVE_LRDF
#include <lrdf.h>
#include "fst.h"
#include "pbd/basename.h"
#include <cstring>
+
+// dll-info
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdint.h>
+
#endif // WINDOWS_VST_SUPPORT
#ifdef LXVST_SUPPORT
#include <cstring>
#endif //LXVST_SUPPORT
-#include <glib/gstdio.h>
+#ifdef MACVST_SUPPORT
+#include "ardour/vst_info_file.h"
+#include "ardour/mac_vst_support.h"
+#include "ardour/mac_vst_plugin.h"
+#include "pbd/basename.h"
+#include <cstring>
+#endif //MACVST_SUPPORT
+
#include <glibmm/miscutils.h>
#include <glibmm/pattern.h>
+#include <glibmm/fileutils.h>
+#include <glibmm/miscutils.h>
#include "pbd/whitespace.h"
#include "pbd/file_utils.h"
#include "ardour/filesystem_paths.h"
#include "ardour/ladspa.h"
#include "ardour/ladspa_plugin.h"
+#include "ardour/luascripting.h"
+#include "ardour/luaproc.h"
#include "ardour/plugin.h"
#include "ardour/plugin_manager.h"
#include "ardour/rc_configuration.h"
#include "pbd/error.h"
#include "pbd/stl_delete.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
#include "ardour/debug.h"
PluginManager::PluginManager ()
: _windows_vst_plugin_info(0)
, _lxvst_plugin_info(0)
+ , _mac_vst_plugin_info(0)
, _ladspa_plugin_info(0)
, _lv2_plugin_info(0)
, _au_plugin_info(0)
+ , _lua_plugin_info(0)
, _cancel_scan(false)
, _cancel_timeout(false)
{
char* s;
string lrdf_path;
- string scan_p = Glib::build_filename(ARDOUR::ardour_dll_directory(), "fst");
- if (!PBD::find_file ( PBD::Searchpath(scan_p), "ardour-vst-scanner", scanner_bin_path)) {
- PBD::warning << "VST scanner app (ardour-vst-scanner) not found in path " << scan_p << endmsg;
+#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT
+ // source-tree (ardev, etc)
+ PBD::Searchpath vstsp(Glib::build_filename(ARDOUR::ardour_dll_directory(), "fst"));
+
+#ifdef PLATFORM_WINDOWS
+ // on windows the .exe needs to be in the same folder with libardour.dll
+ vstsp += Glib::build_filename(windows_package_directory_path(), "bin");
+#else
+ // on Unices additional internal-use binaries are deployed to $libdir
+ vstsp += ARDOUR::ardour_dll_directory();
+#endif
+
+ if (!PBD::find_file (vstsp,
+#ifdef PLATFORM_WINDOWS
+ #ifdef DEBUGGABLE_SCANNER_APP
+ #if defined(DEBUG) || defined(_DEBUG)
+ "ardour-vst-scannerD.exe"
+ #else
+ "ardour-vst-scannerRDC.exe"
+ #endif
+ #else
+ "ardour-vst-scanner.exe"
+ #endif
+#else
+ "ardour-vst-scanner"
+#endif
+ , scanner_bin_path)) {
+ PBD::warning << "VST scanner app (ardour-vst-scanner) not found in path " << vstsp.to_string() << endmsg;
}
+#endif
load_statuses ();
}
#endif /* Native LinuxVST support*/
+#ifdef MACVST_SUPPORT
+ if (Config->get_use_macvst ()) {
+ add_mac_vst_presets ();
+ }
+#endif
+
if ((s = getenv ("VST_PATH"))) {
windows_vst_path = s;
} else if ((s = getenv ("VST_PLUGINS"))) {
}
BootMessage (_("Discovering Plugins"));
+
+ LuaScripting::instance().scripts_changed.connect_same_thread (lua_refresh_connection, boost::bind (&PluginManager::lua_refresh_cb, this));
}
PluginManager::~PluginManager()
{
+ if (getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
+ // don't bother, just exit quickly.
+ delete _windows_vst_plugin_info;
+ delete _lxvst_plugin_info;
+ delete _mac_vst_plugin_info;
+ delete _ladspa_plugin_info;
+ delete _lv2_plugin_info;
+ delete _au_plugin_info;
+ delete _lua_plugin_info;
+ }
}
void
PluginManager::refresh (bool cache_only)
{
+ Glib::Threads::Mutex::Lock lm (_lock, Glib::Threads::TRY_LOCK);
+
+ if (!lm.locked()) {
+ return;
+ }
+
DEBUG_TRACE (DEBUG::PluginManager, "PluginManager::refresh\n");
_cancel_scan = false;
BootMessage (_("Scanning LADSPA Plugins"));
ladspa_refresh ();
+ BootMessage (_("Scanning Lua DSP Processors"));
+ lua_refresh ();
#ifdef LV2_SUPPORT
BootMessage (_("Scanning LV2 Plugins"));
lv2_refresh ();
#endif
#ifdef WINDOWS_VST_SUPPORT
if (Config->get_use_windows_vst()) {
- BootMessage (_("Scanning Windows VST Plugins"));
+ if (cache_only) {
+ BootMessage (_("Scanning Windows VST Plugins"));
+ } else {
+ BootMessage (_("Discovering Windows VST Plugins"));
+ }
windows_vst_refresh (cache_only);
}
#endif // WINDOWS_VST_SUPPORT
#ifdef LXVST_SUPPORT
if(Config->get_use_lxvst()) {
- BootMessage (_("Scanning Linux VST Plugins"));
+ if (cache_only) {
+ BootMessage (_("Scanning Linux VST Plugins"));
+ } else {
+ BootMessage (_("Discovering Linux VST Plugins"));
+ }
lxvst_refresh(cache_only);
}
#endif //Native linuxVST SUPPORT
+#ifdef MACVST_SUPPORT
+ if(Config->get_use_macvst ()) {
+ if (cache_only) {
+ BootMessage (_("Scanning Mac VST Plugins"));
+ } else {
+ BootMessage (_("Discovering Mac VST Plugins"));
+ }
+ mac_vst_refresh (cache_only);
+ } else if (_mac_vst_plugin_info) {
+ _mac_vst_plugin_info->clear ();
+ } else {
+ _mac_vst_plugin_info = new ARDOUR::PluginInfoList();
+ }
+#endif //Native Mac VST SUPPORT
+
+#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT)
+ if (!cache_only) {
+ string fn = Glib::build_filename (ARDOUR::user_cache_directory(), VST_BLACKLIST);
+ if (Glib::file_test (fn, Glib::FILE_TEST_EXISTS)) {
+ gchar *bl = NULL;
+ if (g_file_get_contents(fn.c_str (), &bl, NULL, NULL)) {
+ if (Config->get_verbose_plugin_scan()) {
+ PBD::info << _("VST Blacklist: ") << fn << "\n" << bl << "-----" << endmsg;
+ } else {
+ PBD::info << _("VST Blacklist:") << "\n" << bl << "-----" << endmsg;
+ }
+ g_free (bl);
+ }
+ }
+ }
+#endif
+
#ifdef AUDIOUNIT_SUPPORT
- BootMessage (_("Scanning AU Plugins"));
- au_refresh ();
+ if (cache_only) {
+ BootMessage (_("Scanning AU Plugins"));
+ } else {
+ BootMessage (_("Discovering AU Plugins"));
+ }
+ au_refresh (cache_only);
#endif
BootMessage (_("Plugin Scan Complete..."));
void
PluginManager::clear_vst_cache ()
{
- // see also libs/ardour/vst_info_file.cc - vstfx_infofile_path()
+#if 1 // clean old cache and error files. (remove this code after 4.3 or 5.0)
#ifdef WINDOWS_VST_SUPPORT
{
vector<string> fsi_files;
- find_files_matching_regex (fsi_files, Config->get_plugin_path_vst(), "\\.fsi$");
+ find_files_matching_regex (fsi_files, Config->get_plugin_path_vst(), "\\" VST_EXT_INFOFILE "$", true);
+ for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
+ ::g_unlink(i->c_str());
+ }
+ }
+ {
+ vector<string> fsi_files;
+ find_files_matching_regex (fsi_files, Config->get_plugin_path_vst(), "\\.fsi$", true);
+ for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
+ ::g_unlink(i->c_str());
+ }
+ }
+ {
+ vector<string> fsi_files;
+ find_files_matching_regex (fsi_files, Config->get_plugin_path_vst(), "\\.err$", true);
for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
::g_unlink(i->c_str());
}
#ifdef LXVST_SUPPORT
{
vector<string> fsi_files;
- find_files_matching_regex (fsi_files, Config->get_plugin_path_lxvst(), "\\.fsi$");
+ find_files_matching_regex (fsi_files, Config->get_plugin_path_lxvst(), "\\" VST_EXT_INFOFILE "$", true);
+ for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
+ ::g_unlink(i->c_str());
+ }
+ }
+ {
+ vector<string> fsi_files;
+ find_files_matching_regex (fsi_files, Config->get_plugin_path_lxvst(), "\\.fsi$", true);
+ for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
+ ::g_unlink(i->c_str());
+ }
+ }
+ {
+ vector<string> fsi_files;
+ find_files_matching_regex (fsi_files, Config->get_plugin_path_lxvst(), "\\.err$", true);
for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
::g_unlink(i->c_str());
}
}
#endif
-
#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
{
- string personal = get_personal_vst_info_cache_dir();
+ string dir = Glib::build_filename (ARDOUR::user_cache_directory(), "fst_info");
+ if (Glib::file_test (dir, Glib::FILE_TEST_IS_DIR)) {
+ PBD::remove_directory (dir);
+ }
+ }
+#endif
+#endif // old cache cleanup
+
+#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT)
+ {
+ string dn = Glib::build_filename (ARDOUR::user_cache_directory(), "vst");
vector<string> fsi_files;
- find_files_matching_regex (fsi_files, personal, "\\.fsi$");
+ find_files_matching_regex (fsi_files, dn, "\\" VST_EXT_INFOFILE "$", /* user cache is flat, no recursion */ false);
for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
::g_unlink(i->c_str());
}
void
PluginManager::clear_vst_blacklist ()
{
+#if 1 // remove old blacklist files. (remove this code after 4.3 or 5.0)
+
#ifdef WINDOWS_VST_SUPPORT
{
vector<string> fsi_files;
- find_files_matching_regex (fsi_files, Config->get_plugin_path_vst(), "\\.fsb$");
+ find_files_matching_regex (fsi_files, Config->get_plugin_path_vst(), "\\" VST_EXT_BLACKLIST "$", true);
for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
::g_unlink(i->c_str());
}
#ifdef LXVST_SUPPORT
{
vector<string> fsi_files;
- find_files_matching_regex (fsi_files, Config->get_plugin_path_lxvst(), "\\.fsb$");
+ find_files_matching_regex (fsi_files, Config->get_plugin_path_lxvst(), "\\" VST_EXT_BLACKLIST "$", true);
for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
::g_unlink(i->c_str());
}
}
#endif
-
#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
{
- string personal = get_personal_vst_blacklist_dir();
+ string dir = Glib::build_filename (ARDOUR::user_cache_directory(), "fst_blacklist");
+ if (Glib::file_test (dir, Glib::FILE_TEST_IS_DIR)) {
+ PBD::remove_directory (dir);
+ }
+ }
+#endif
- vector<string> fsi_files;
- find_files_matching_regex (fsi_files, personal, "\\.fsb$");
- for (vector<string>::iterator i = fsi_files.begin(); i != fsi_files.end (); ++i) {
- ::g_unlink(i->c_str());
+#endif // old blacklist cleanup
+
+#if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT)
+ {
+ string fn = Glib::build_filename (ARDOUR::user_cache_directory(), VST_BLACKLIST);
+ if (Glib::file_test (fn, Glib::FILE_TEST_EXISTS)) {
+ ::g_unlink (fn.c_str());
}
}
#endif
+
+}
+
+void
+PluginManager::clear_au_cache ()
+{
+#ifdef AUDIOUNIT_SUPPORT
+ AUPluginInfo::clear_cache ();
+#endif
+}
+
+void
+PluginManager::clear_au_blacklist ()
+{
+#ifdef AUDIOUNIT_SUPPORT
+ string fn = Glib::build_filename (ARDOUR::user_cache_directory(), "au_blacklist.txt");
+ if (Glib::file_test (fn, Glib::FILE_TEST_EXISTS)) {
+ ::g_unlink(fn.c_str());
+ }
+#endif
+}
+
+void
+PluginManager::lua_refresh ()
+{
+ if (_lua_plugin_info) {
+ _lua_plugin_info->clear ();
+ } else {
+ _lua_plugin_info = new ARDOUR::PluginInfoList ();
+ }
+ ARDOUR::LuaScriptList & _scripts (LuaScripting::instance ().scripts (LuaScriptInfo::DSP));
+ for (LuaScriptList::const_iterator s = _scripts.begin(); s != _scripts.end(); ++s) {
+ LuaPluginInfoPtr lpi (new LuaPluginInfo(*s));
+ _lua_plugin_info->push_back (lpi);
+ }
+}
+
+void
+PluginManager::lua_refresh_cb ()
+{
+ Glib::Threads::Mutex::Lock lm (_lock, Glib::Threads::TRY_LOCK);
+ if (!lm.locked()) {
+ return;
+ }
+ lua_refresh ();
+ PluginListChanged (); /* EMIT SIGNAL */
}
void
}
}
+#ifdef HAVE_LRDF
static bool rdf_filter (const string &str, void* /*arg*/)
{
return str[0] != '.' &&
(str.find(".n3") == (str.length() - 3)) ||
(str.find(".ttl") == (str.length() - 4)));
}
+#endif
void
PluginManager::add_ladspa_presets()
add_presets ("windows-vst");
}
+void
+PluginManager::add_mac_vst_presets()
+{
+ add_presets ("mac-vst");
+}
+
void
PluginManager::add_lxvst_presets()
{
DEBUG_TRACE (DEBUG::PluginManager, string_compose ("LADSPA plugin found at %1\n", path));
for (uint32_t i = 0; ; ++i) {
+ /* if a ladspa plugin allocates memory here
+ * it is never free()ed (or plugin-dependent only when unloading).
+ * For some plugins memory allocated is incremental, we should
+ * avoid re-scanning plugins and file bug reports.
+ */
if ((descriptor = dfunc (i)) == 0) {
break;
}
#ifdef AUDIOUNIT_SUPPORT
void
-PluginManager::au_refresh ()
+PluginManager::au_refresh (bool cache_only)
{
DEBUG_TRACE (DEBUG::PluginManager, "AU: refresh\n");
+
+ // disable automatic discovery in case we crash
+ bool discover_at_start = Config->get_discover_audio_units ();
+ Config->set_discover_audio_units (false);
+ Config->save_state();
+
delete _au_plugin_info;
- _au_plugin_info = AUPluginInfo::discover();
+ _au_plugin_info = AUPluginInfo::discover(cache_only && !discover_at_start);
+
+ // successful scan re-enabled automatic discovery if it was set
+ Config->set_discover_audio_units (discover_at_start);
+ Config->save_state();
}
#endif
static bool windows_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));
+ return str[0] != '.' && str.length() > 4 && strings_equal_ignore_case (".dll", str.substr(str.length() - 4));
}
int
vector<string>::iterator x;
int ret = 0;
- DEBUG_TRACE (DEBUG::PluginManager, string_compose ("detecting Windows VST plugins along %1\n", path));
+ DEBUG_TRACE (DEBUG::PluginManager, string_compose ("Discovering Windows VST plugins along %1\n", path));
+
+ if (Session::get_disable_all_loaded_plugins ()) {
+ info << _("Disabled WindowsVST scan (safe mode)") << endmsg;
+ return -1;
+ }
+
+ if (Config->get_verbose_plugin_scan()) {
+ info << string_compose (_("--- Windows VST plugins Scan: %1"), path) << endmsg;
+ }
- find_files_matching_filter (plugin_objects, Config->get_plugin_path_vst(), windows_vst_filter, 0, false, true);
+ find_files_matching_filter (plugin_objects, path, windows_vst_filter, 0, false, true, true);
for (x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
ARDOUR::PluginScanMessage(_("VST"), *x, !cache_only && !cancelled());
windows_vst_discover (*x, cache_only || cancelled());
}
+ if (Config->get_verbose_plugin_scan()) {
+ info << _("--- Windows VST plugins Scan Done") << endmsg;
+ }
+
return ret;
}
+static std::string dll_info (std::string path) {
+ std::string rv;
+ uint8_t buf[68];
+ uint16_t type = 0;
+ off_t pe_hdr_off = 0;
+
+ int fd = g_open(path.c_str(), O_RDONLY, 0444);
+
+ if (fd < 0) {
+ return _("cannot open dll"); // TODO strerror()
+ }
+
+ if (68 != read (fd, buf, 68)) {
+ rv = _("invalid dll, file too small");
+ goto errorout;
+ }
+ if (buf[0] != 'M' && buf[1] != 'Z') {
+ rv = _("not a dll");
+ goto errorout;
+ }
+
+ pe_hdr_off = *((int32_t*) &buf[60]);
+ if (pe_hdr_off !=lseek (fd, pe_hdr_off, SEEK_SET)) {
+ rv = _("cannot determine dll type");
+ goto errorout;
+ }
+ if (6 != read (fd, buf, 6)) {
+ rv = _("cannot read dll PE header");
+ goto errorout;
+ }
+
+ if (buf[0] != 'P' && buf[1] != 'E') {
+ rv = _("invalid dll PE header");
+ goto errorout;
+ }
+
+ type = *((uint16_t*) &buf[4]);
+ switch (type) {
+ case 0x014c:
+ rv = _("i386 (32-bit)");
+ break;
+ case 0x0200:
+ rv = _("Itanium");
+ break;
+ case 0x8664:
+ rv = _("x64 (64-bit)");
+ break;
+ case 0:
+ rv = _("Native Architecture");
+ break;
+ default:
+ rv = _("Unknown Architecture");
+ break;
+ }
+errorout:
+ assert (rv.length() > 0);
+ close (fd);
+ return rv;
+}
+
int
PluginManager::windows_vst_discover (string path, bool cache_only)
{
DEBUG_TRACE (DEBUG::PluginManager, string_compose ("windows_vst_discover '%1'\n", path));
+ if (Config->get_verbose_plugin_scan()) {
+ if (cache_only) {
+ info << string_compose (_(" * %1 (cache only)"), path) << endmsg;
+ } else {
+ info << string_compose (_(" * %1 - %2"), path, dll_info (path)) << endmsg;
+ }
+ }
+
_cancel_timeout = false;
vector<VSTInfo*> * finfos = vstfx_get_info_fst (const_cast<char *> (path.c_str()),
cache_only ? VST_SCAN_CACHE_ONLY : VST_SCAN_USE_APP);
+ // TODO get extended error messae from vstfx_get_info_fst() e.g blacklisted, 32/64bit compat,
+ // .err file scanner output etc.
+
if (finfos->empty()) {
DEBUG_TRACE (DEBUG::PluginManager, string_compose ("Cannot get Windows VST information from '%1'\n", path));
+ if (Config->get_verbose_plugin_scan()) {
+ info << _(" -> Cannot get Windows VST information, plugin ignored.") << endmsg;
+ }
return -1;
}
char buf[32];
if (!finfo->canProcessReplacing) {
- warning << string_compose (_("VST plugin %1 does not support processReplacing, and so cannot be used in %2 at this time"),
+ warning << string_compose (_("VST plugin %1 does not support processReplacing, and cannot be used in %2 at this time"),
finfo->name, PROGRAM_NAME)
<< endl;
continue;
if (!_windows_vst_plugin_info->empty()) {
for (PluginInfoList::iterator i =_windows_vst_plugin_info->begin(); i != _windows_vst_plugin_info->end(); ++i) {
- if ((info->type == (*i)->type)&&(info->unique_id == (*i)->unique_id)) {
- warning << "Ignoring duplicate Windows VST plugin " << info->name << "\n";
+ if ((info->type == (*i)->type) && (info->unique_id == (*i)->unique_id)) {
+ warning << string_compose (_("Ignoring duplicate Windows VST plugin \"%1\""), info->name) << endmsg;
duplicate = true;
break;
}
DEBUG_TRACE (DEBUG::PluginManager, string_compose ("Windows VST plugin ID '%1'\n", info->unique_id));
_windows_vst_plugin_info->push_back (info);
discovered++;
+ if (Config->get_verbose_plugin_scan()) {
+ PBD::info << string_compose (_(" -> OK (VST Plugin \"%1\" was added)."), info->name) << endmsg;
+ }
}
}
#endif // WINDOWS_VST_SUPPORT
+#ifdef MACVST_SUPPORT
+void
+PluginManager::mac_vst_refresh (bool cache_only)
+{
+ if (_mac_vst_plugin_info) {
+ _mac_vst_plugin_info->clear ();
+ } else {
+ _mac_vst_plugin_info = new ARDOUR::PluginInfoList();
+ }
+
+ mac_vst_discover_from_path ("~/Library/Audio/Plug-Ins/VST:/Library/Audio/Plug-Ins/VST", cache_only);
+}
+
+static bool mac_vst_filter (const string& str, void *)
+{
+ if (!Glib::file_test (str, Glib::FILE_TEST_IS_DIR)) {
+ return false;
+ }
+ string plist = Glib::build_filename (str, "Contents", "Info.plist");
+ if (!Glib::file_test (plist, Glib::FILE_TEST_IS_REGULAR)) {
+ return false;
+ }
+ return str[0] != '.' && str.length() > 4 && strings_equal_ignore_case (".vst", str.substr(str.length() - 4));
+}
+
+int
+PluginManager::mac_vst_discover_from_path (string path, bool cache_only)
+{
+ vector<string> plugin_objects;
+ vector<string>::iterator x;
+
+ if (Session::get_disable_all_loaded_plugins ()) {
+ info << _("Disabled MacVST scan (safe mode)") << endmsg;
+ return -1;
+ }
+
+ find_paths_matching_filter (plugin_objects, path, mac_vst_filter, 0, true, true, true);
+
+ for (x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
+ ARDOUR::PluginScanMessage(_("MacVST"), *x, !cache_only && !cancelled());
+ mac_vst_discover (*x, cache_only || cancelled());
+ }
+ return 0;
+}
+
+int
+PluginManager::mac_vst_discover (string path, bool cache_only)
+{
+ DEBUG_TRACE (DEBUG::PluginManager, string_compose ("checking apparent MacVST plugin at %1\n", path));
+
+ _cancel_timeout = false;
+
+ vector<VSTInfo*>* finfos = vstfx_get_info_mac (const_cast<char *> (path.c_str()),
+ cache_only ? VST_SCAN_CACHE_ONLY : VST_SCAN_USE_APP);
+
+ if (finfos->empty()) {
+ DEBUG_TRACE (DEBUG::PluginManager, string_compose ("Cannot get Mac VST information from '%1'\n", path));
+ return -1;
+ }
+
+ uint32_t discovered = 0;
+ for (vector<VSTInfo *>::iterator x = finfos->begin(); x != finfos->end(); ++x) {
+ VSTInfo* finfo = *x;
+ char buf[32];
+
+ if (!finfo->canProcessReplacing) {
+ warning << string_compose (_("Mac VST plugin %1 does not support processReplacing, and so cannot be used in %2 at this time"),
+ finfo->name, PROGRAM_NAME)
+ << endl;
+ continue;
+ }
+
+ PluginInfoPtr info (new MacVSTPluginInfo);
+
+ info->name = finfo->name;
+
+ snprintf (buf, sizeof (buf), "%d", finfo->UniqueID);
+ info->unique_id = buf;
+ info->category = "MacVST";
+ 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) ? 1 : 0);
+ info->n_outputs.set_midi ((finfo->wantMidi&2) ? 1 : 0);
+ info->type = ARDOUR::MacVST;
+
+ bool duplicate = false;
+ if (!_mac_vst_plugin_info->empty()) {
+ for (PluginInfoList::iterator i =_mac_vst_plugin_info->begin(); i != _mac_vst_plugin_info->end(); ++i) {
+ if ((info->type == (*i)->type)&&(info->unique_id == (*i)->unique_id)) {
+ warning << "Ignoring duplicate Mac VST plugin " << info->name << "\n";
+ duplicate = true;
+ break;
+ }
+ }
+ }
+
+ if (!duplicate) {
+ _mac_vst_plugin_info->push_back (info);
+ discovered++;
+ }
+ }
+
+ vstfx_free_info_list (finfos);
+ return discovered > 0 ? 0 : -1;
+}
+
+#endif // MAC_VST_SUPPORT
+
#ifdef LXVST_SUPPORT
void
vector<string>::iterator x;
int ret = 0;
+ if (Session::get_disable_all_loaded_plugins ()) {
+ info << _("Disabled LinuxVST scan (safe mode)") << endmsg;
+ return -1;
+ }
+
#ifndef NDEBUG
(void) path;
#endif
DEBUG_TRACE (DEBUG::PluginManager, string_compose ("Discovering linuxVST plugins along %1\n", path));
- find_files_matching_filter (plugin_objects, Config->get_plugin_path_lxvst(), lxvst_filter, 0, false, true);
+ find_files_matching_filter (plugin_objects, Config->get_plugin_path_lxvst(), lxvst_filter, 0, false, true, true);
for (x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
ARDOUR::PluginScanMessage(_("LXVST"), *x, !cache_only && !cancelled());
PluginManager::PluginStatusType
-PluginManager::get_status (const PluginInfoPtr& pi)
+PluginManager::get_status (const PluginInfoPtr& pi) const
{
PluginStatus ps (pi->type, pi->unique_id);
PluginStatusList::const_iterator i = find (statuses.begin(), statuses.end(), ps);
void
PluginManager::save_statuses ()
{
- ofstream ofs;
std::string path = Glib::build_filename (user_config_directory(), "plugin_statuses");
-
- ofs.open (path.c_str(), ios_base::openmode (ios::out|ios::trunc));
-
- if (!ofs) {
- return;
- }
+ stringstream ofs;
for (PluginStatusList::iterator i = statuses.begin(); i != statuses.end(); ++i) {
switch ((*i).type) {
case LXVST:
ofs << "LXVST";
break;
+ case MacVST:
+ ofs << "MacVST";
+ break;
+ case Lua:
+ ofs << "Lua";
+ break;
}
ofs << ' ';
ofs << (*i).unique_id;;
ofs << endl;
}
-
- ofs.close ();
+ g_file_set_contents (path.c_str(), ofs.str().c_str(), -1, NULL);
+ PluginStatusesChanged (); /* EMIT SIGNAL */
}
void
PluginManager::load_statuses ()
{
std::string path = Glib::build_filename (user_config_directory(), "plugin_statuses");
- ifstream ifs (path.c_str());
-
- if (!ifs) {
+ gchar *fbuf = NULL;
+ if (!g_file_get_contents (path.c_str(), &fbuf, NULL, NULL)) {
return;
}
+ stringstream ifs (fbuf);
+ g_free (fbuf);
std::string stype;
std::string sstatus;
type = Windows_VST;
} else if (stype == "LXVST") {
type = LXVST;
+ } else if (stype == "MacVST") {
+ type = MacVST;
+ } else if (stype == "Lua") {
+ type = Lua;
} else {
error << string_compose (_("unknown plugin type \"%1\" - ignored"), stype)
<< endmsg;
strip_whitespace_edges (id);
set_status (type, id, status);
}
-
- ifs.close ();
}
void
statuses.insert (ps);
}
-ARDOUR::PluginInfoList&
+const ARDOUR::PluginInfoList&
PluginManager::windows_vst_plugin_info ()
{
#ifdef WINDOWS_VST_SUPPORT
#endif
}
-ARDOUR::PluginInfoList&
+const ARDOUR::PluginInfoList&
+PluginManager::mac_vst_plugin_info ()
+{
+#ifdef MACVST_SUPPORT
+ assert(_mac_vst_plugin_info);
+ return *_mac_vst_plugin_info;
+#else
+ return _empty_plugin_info;
+#endif
+}
+
+const ARDOUR::PluginInfoList&
PluginManager::lxvst_plugin_info ()
{
#ifdef LXVST_SUPPORT
#endif
}
-ARDOUR::PluginInfoList&
+const ARDOUR::PluginInfoList&
PluginManager::ladspa_plugin_info ()
{
assert(_ladspa_plugin_info);
return *_ladspa_plugin_info;
}
-ARDOUR::PluginInfoList&
+const ARDOUR::PluginInfoList&
PluginManager::lv2_plugin_info ()
{
#ifdef LV2_SUPPORT
#endif
}
-ARDOUR::PluginInfoList&
+const ARDOUR::PluginInfoList&
PluginManager::au_plugin_info ()
{
#ifdef AUDIOUNIT_SUPPORT
- assert(_au_plugin_info);
- return *_au_plugin_info;
-#else
- return _empty_plugin_info;
+ if (_au_plugin_info) {
+ return *_au_plugin_info;
+ }
#endif
+ return _empty_plugin_info;
+}
+
+const ARDOUR::PluginInfoList&
+PluginManager::lua_plugin_info ()
+{
+ assert(_lua_plugin_info);
+ return *_lua_plugin_info;
}