libs/ardour/plugin_manager.cc

   1 /*
   2     Copyright (C) 2000-2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "libardour-config.h"
  22 #endif
  23
  24 #include <stdint.h>
  25
  26 #include <sys/types.h>
  27 #include <cstdio>
  28 #include <lrdf.h>
  29 #include <dlfcn.h>
  30 #include <cstdlib>
  31 #include <fstream>
  32
  33 #ifdef VST_SUPPORT
  34 #include <fst.h>
  35 #include "pbd/basename.h"
  36 #include <cstring>
  37 #endif // VST_SUPPORT
  38
  39 #include <glibmm/miscutils.h>
  40
  41 #include "pbd/pathscanner.h"
  42 #include "pbd/whitespace.h"
  43
  44 #include "ardour/ladspa.h"
  45 #include "ardour/session.h"
  46 #include "ardour/plugin_manager.h"
  47 #include "ardour/plugin.h"
  48 #include "ardour/ladspa_plugin.h"
  49 #include "ardour/filesystem_paths.h"
  50
  51 #ifdef HAVE_SLV2
  52 #include <slv2/slv2.h>
  53 #include "ardour/lv2_plugin.h"
  54 #endif
  55
  56 #ifdef VST_SUPPORT
  57 #include "ardour/vst_plugin.h"
  58 #endif
  59
  60 #ifdef HAVE_AUDIOUNITS
  61 #include "ardour/audio_unit.h"
  62 #include <Carbon/Carbon.h>
  63 #endif
  64
  65 #include "pbd/error.h"
  66 #include "pbd/stl_delete.h"
  67
  68 #include "i18n.h"
  69
  70 using namespace ARDOUR;
  71 using namespace PBD;
  72 using namespace std;
  73
  74 PluginManager* PluginManager::_manager = 0;
  75
  76 PluginManager::PluginManager ()
  77         : _vst_plugin_info(0)
  78         , _ladspa_plugin_info(0)
  79         , _lv2_plugin_info(0)
  80         , _au_plugin_info(0)
  81 {
  82         char* s;
  83         string lrdf_path;
  84
  85         load_statuses ();
  86
  87 #ifdef HAVE_AUDIOUNITS
  88         ProcessSerialNumber psn = { 0, kCurrentProcess };
  89         OSStatus returnCode = TransformProcessType(& psn, kProcessTransformToForegroundApplication);
  90         if( returnCode != 0) {
  91                 error << _("Cannot become GUI app") << endmsg;
  92         }
  93 #endif
  94
  95         if ((s = getenv ("LADSPA_RDF_PATH"))){
  96                 lrdf_path = s;
  97         }
  98
  99         if (lrdf_path.length() == 0) {
 100                 lrdf_path = "/usr/local/share/ladspa/rdf:/usr/share/ladspa/rdf";
 101         }
 102
 103         add_lrdf_data(lrdf_path);
 104         add_ladspa_presets();
 105 #ifdef VST_SUPPORT
 106         if (Config->get_use_vst()) {
 107                 add_vst_presets();
 108         }
 109 #endif /* VST_SUPPORT */
 110
 111         if ((s = getenv ("LADSPA_PATH"))) {
 112                 ladspa_path = s;
 113         }
 114
 115         if ((s = getenv ("VST_PATH"))) {
 116                 vst_path = s;
 117         } else if ((s = getenv ("VST_PLUGINS"))) {
 118                 vst_path = s;
 119         }
 120
 121         if (_manager == 0) {
 122                 _manager = this;
 123         }
 124
 125         /* the plugin manager is constructed too early to use Profile */
 126
 127         if (getenv ("ARDOUR_SAE")) {
 128                 ladspa_plugin_whitelist.push_back (1203); // single band parametric
 129                 ladspa_plugin_whitelist.push_back (1772); // caps compressor
 130                 ladspa_plugin_whitelist.push_back (1913); // fast lookahead limiter
 131                 ladspa_plugin_whitelist.push_back (1075); // simple RMS expander
 132                 ladspa_plugin_whitelist.push_back (1061); // feedback delay line (max 5s)
 133                 ladspa_plugin_whitelist.push_back (1216); // gverb
 134                 ladspa_plugin_whitelist.push_back (2150); // tap pitch shifter
 135         }
 136
 137 #ifdef HAVE_SLV2
 138         _lv2_world = new LV2World();
 139 #endif
 140
 141         BootMessage (_("Discovering Plugins"));
 142 }
 143
 144
 145 PluginManager::~PluginManager()
 146 {
 147 #ifdef HAVE_SLV2
 148         delete _lv2_world;
 149 #endif
 150 }
 151
 152
 153 void
 154 PluginManager::refresh ()
 155 {
 156         ladspa_refresh ();
 157 #ifdef HAVE_SLV2
 158         lv2_refresh ();
 159 #endif
 160 #ifdef VST_SUPPORT
 161         if (Config->get_use_vst()) {
 162                 vst_refresh ();
 163         }
 164 #endif // VST_SUPPORT
 165 #ifdef HAVE_AUDIOUNITS
 166         au_refresh ();
 167 #endif
 168
 169         PluginListChanged (); /* EMIT SIGNAL */
 170 }
 171
 172 void
 173 PluginManager::ladspa_refresh ()
 174 {
 175         if (_ladspa_plugin_info)
 176                 _ladspa_plugin_info->clear ();
 177         else
 178                 _ladspa_plugin_info = new ARDOUR::PluginInfoList ();
 179
 180         static const char *standard_paths[] = {
 181                 "/usr/local/lib64/ladspa",
 182                 "/usr/local/lib/ladspa",
 183                 "/usr/lib64/ladspa",
 184                 "/usr/lib/ladspa",
 185                 "/Library/Audio/Plug-Ins/LADSPA",
 186                 ""
 187         };
 188
 189         /* allow LADSPA_PATH to augment, not override standard locations */
 190
 191         /* Only add standard locations to ladspa_path if it doesn't
 192          * already contain them. Check for trailing G_DIR_SEPARATOR too.
 193          */
 194
 195         int i;
 196         for (i = 0; standard_paths[i][0]; i++) {
 197                 size_t found = ladspa_path.find(standard_paths[i]);
 198                 if (found != ladspa_path.npos) {
 199                         switch (ladspa_path[found + strlen(standard_paths[i])]) {
 200                                 case ':' :
 201                                 case '\0':
 202                                         continue;
 203                                 case G_DIR_SEPARATOR :
 204                                         if (ladspa_path[found + strlen(standard_paths[i]) + 1] == ':' ||
 205                                             ladspa_path[found + strlen(standard_paths[i]) + 1] == '\0') {
 206                                                 continue;
 207                                         }
 208                         }
 209                 }
 210                 if (!ladspa_path.empty())
 211                         ladspa_path += ":";
 212
 213                 ladspa_path += standard_paths[i];
 214
 215         }
 216
 217         ladspa_discover_from_path (ladspa_path);
 218 }
 219
 220
 221 int
 222 PluginManager::add_ladspa_directory (string path)
 223 {
 224         if (ladspa_discover_from_path (path) == 0) {
 225                 ladspa_path += ':';
 226                 ladspa_path += path;
 227                 return 0;
 228         }
 229         return -1;
 230 }
 231
 232 static bool ladspa_filter (const string& str, void */*arg*/)
 233 {
 234         /* Not a dotfile, has a prefix before a period, suffix is "so" */
 235
 236         return str[0] != '.' && (str.length() > 3 && str.find (".so") == (str.length() - 3));
 237 }
 238
 239 int
 240 PluginManager::ladspa_discover_from_path (string /*path*/)
 241 {
 242         PathScanner scanner;
 243         vector<string *> *plugin_objects;
 244         vector<string *>::iterator x;
 245         int ret = 0;
 246
 247         plugin_objects = scanner (ladspa_path, ladspa_filter, 0, true, true);
 248
 249         if (plugin_objects) {
 250                 for (x = plugin_objects->begin(); x != plugin_objects->end (); ++x) {
 251                         ladspa_discover (**x);
 252                 }
 253         }
 254
 255         vector_delete (plugin_objects);
 256         return ret;
 257 }
 258
 259 static bool rdf_filter (const string &str, void* /*arg*/)
 260 {
 261         return str[0] != '.' &&
 262                    ((str.find(".rdf")  == (str.length() - 4)) ||
 263             (str.find(".rdfs") == (str.length() - 5)) ||
 264                     (str.find(".n3")   == (str.length() - 3)) ||
 265                     (str.find(".ttl")  == (str.length() - 4)));
 266 }
 267
 268 void
 269 PluginManager::add_ladspa_presets()
 270 {
 271         add_presets ("ladspa");
 272 }
 273
 274 void
 275 PluginManager::add_vst_presets()
 276 {
 277         add_presets ("vst");
 278 }
 279 void
 280 PluginManager::add_presets(string domain)
 281 {
 282
 283         PathScanner scanner;
 284         vector<string *> *presets;
 285         vector<string *>::iterator x;
 286
 287         char* envvar;
 288         if ((envvar = getenv ("HOME")) == 0) {
 289                 return;
 290         }
 291
 292         string path = string_compose("%1/.%2/rdf", envvar, domain);
 293         presets = scanner (path, rdf_filter, 0, true, true);
 294
 295         if (presets) {
 296                 for (x = presets->begin(); x != presets->end (); ++x) {
 297                         string file = "file:" + **x;
 298                         if (lrdf_read_file(file.c_str())) {
 299                                 warning << string_compose(_("Could not parse rdf file: %1"), *x) << endmsg;
 300                         }
 301                 }
 302         }
 303
 304         vector_delete (presets);
 305 }
 306
 307 void
 308 PluginManager::add_lrdf_data (const string &path)
 309 {
 310         PathScanner scanner;
 311         vector<string *>* rdf_files;
 312         vector<string *>::iterator x;
 313
 314         rdf_files = scanner (path, rdf_filter, 0, true, true);
 315
 316         if (rdf_files) {
 317                 for (x = rdf_files->begin(); x != rdf_files->end (); ++x) {
 318                         const string uri(string("file://") + **x);
 319
 320                         if (lrdf_read_file(uri.c_str())) {
 321                                 warning << "Could not parse rdf file: " << uri << endmsg;
 322                         }
 323                 }
 324         }
 325
 326         vector_delete (rdf_files);
 327 }
 328
 329 int
 330 PluginManager::ladspa_discover (string path)
 331 {
 332         void *module;
 333         const LADSPA_Descriptor *descriptor;
 334         LADSPA_Descriptor_Function dfunc;
 335         const char *errstr;
 336
 337         if ((module = dlopen (path.c_str(), RTLD_NOW)) == 0) {
 338                 error << string_compose(_("LADSPA: cannot load module \"%1\" (%2)"), path, dlerror()) << endmsg;
 339                 return -1;
 340         }
 341
 342         dfunc = (LADSPA_Descriptor_Function) dlsym (module, "ladspa_descriptor");
 343
 344         if ((errstr = dlerror()) != 0) {
 345                 error << string_compose(_("LADSPA: module \"%1\" has no descriptor function."), path) << endmsg;
 346                 error << errstr << endmsg;
 347                 dlclose (module);
 348                 return -1;
 349         }
 350
 351         for (uint32_t i = 0; ; ++i) {
 352                 if ((descriptor = dfunc (i)) == 0) {
 353                         break;
 354                 }
 355
 356                 if (!ladspa_plugin_whitelist.empty()) {
 357                         if (find (ladspa_plugin_whitelist.begin(), ladspa_plugin_whitelist.end(), descriptor->UniqueID) == ladspa_plugin_whitelist.end()) {
 358                                 continue;
 359                         }
 360                 }
 361
 362                 PluginInfoPtr info(new LadspaPluginInfo);
 363                 info->name = descriptor->Name;
 364                 info->category = get_ladspa_category(descriptor->UniqueID);
 365                 info->creator = descriptor->Maker;
 366                 info->path = path;
 367                 info->index = i;
 368                 info->n_inputs = ChanCount();
 369                 info->n_outputs = ChanCount();
 370                 info->type = ARDOUR::LADSPA;
 371
 372                 char buf[32];
 373                 snprintf (buf, sizeof (buf), "%lu", descriptor->UniqueID);
 374                 info->unique_id = buf;
 375
 376                 for (uint32_t n=0; n < descriptor->PortCount; ++n) {
 377                         if ( LADSPA_IS_PORT_AUDIO (descriptor->PortDescriptors[n]) ) {
 378                                 if ( LADSPA_IS_PORT_INPUT (descriptor->PortDescriptors[n]) ) {
 379                                         info->n_inputs.set_audio(info->n_inputs.n_audio() + 1);
 380                                 }
 381                                 else if ( LADSPA_IS_PORT_OUTPUT (descriptor->PortDescriptors[n]) ) {
 382                                         info->n_outputs.set_audio(info->n_outputs.n_audio() + 1);
 383                                 }
 384                         }
 385                 }
 386
 387                 if(_ladspa_plugin_info->empty()){
 388                         _ladspa_plugin_info->push_back (info);
 389                 }
 390
 391                 //Ensure that the plugin is not already in the plugin list.
 392
 393                 bool found = false;
 394
 395                 for (PluginInfoList::const_iterator i = _ladspa_plugin_info->begin(); i != _ladspa_plugin_info->end(); ++i) {
 396                         if(0 == info->unique_id.compare((*i)->unique_id)){
 397                               found = true;
 398                         }
 399                 }
 400
 401                 if(!found){
 402                     _ladspa_plugin_info->push_back (info);
 403                 }
 404         }
 405
 406 // GDB WILL NOT LIKE YOU IF YOU DO THIS
 407 //      dlclose (module);
 408
 409         return 0;
 410 }
 411
 412 string
 413 PluginManager::get_ladspa_category (uint32_t plugin_id)
 414 {
 415         char buf[256];
 416         lrdf_statement pattern;
 417
 418         snprintf(buf, sizeof(buf), "%s%" PRIu32, LADSPA_BASE, plugin_id);
 419         pattern.subject = buf;
 420         pattern.predicate = (char*)RDF_TYPE;
 421         pattern.object = 0;
 422         pattern.object_type = lrdf_uri;
 423
 424         lrdf_statement* matches1 = lrdf_matches (&pattern);
 425
 426         if (!matches1) {
 427                 return "Unknown";
 428         }
 429
 430         pattern.subject = matches1->object;
 431         pattern.predicate = (char*)(LADSPA_BASE "hasLabel");
 432         pattern.object = 0;
 433         pattern.object_type = lrdf_literal;
 434
 435         lrdf_statement* matches2 = lrdf_matches (&pattern);
 436         lrdf_free_statements(matches1);
 437
 438         if (!matches2) {
 439                 return ("Unknown");
 440         }
 441
 442         string label = matches2->object;
 443         lrdf_free_statements(matches2);
 444
 445         return label;
 446 }
 447
 448 #ifdef HAVE_SLV2
 449 void
 450 PluginManager::lv2_refresh ()
 451 {
 452         delete _lv2_plugin_info;
 453         _lv2_plugin_info = LV2PluginInfo::discover(_lv2_world);
 454 }
 455 #endif
 456
 457 #ifdef HAVE_AUDIOUNITS
 458 void
 459 PluginManager::au_refresh ()
 460 {
 461         delete _au_plugin_info;
 462         _au_plugin_info = AUPluginInfo::discover();
 463 }
 464
 465 #endif
 466
 467 #ifdef VST_SUPPORT
 468
 469 void
 470 PluginManager::vst_refresh ()
 471 {
 472         if (_vst_plugin_info)
 473                 _vst_plugin_info->clear ();
 474         else
 475                 _vst_plugin_info = new ARDOUR::PluginInfoList();
 476
 477         if (vst_path.length() == 0) {
 478                 vst_path = "/usr/local/lib/vst:/usr/lib/vst";
 479         }
 480
 481         vst_discover_from_path (vst_path);
 482 }
 483
 484 int
 485 PluginManager::add_vst_directory (string path)
 486 {
 487         if (vst_discover_from_path (path) == 0) {
 488                 vst_path += ':';
 489                 vst_path += path;
 490                 return 0;
 491         }
 492         return -1;
 493 }
 494
 495 static bool vst_filter (const string& str, void *arg)
 496 {
 497         /* Not a dotfile, has a prefix before a period, suffix is "dll" */
 498
 499         return str[0] != '.' && (str.length() > 4 && str.find (".dll") == (str.length() - 4));
 500 }
 501
 502 int
 503 PluginManager::vst_discover_from_path (string path)
 504 {
 505         PathScanner scanner;
 506         vector<string *> *plugin_objects;
 507         vector<string *>::iterator x;
 508         int ret = 0;
 509
 510         info << "detecting VST plugins along " << path << endmsg;
 511
 512         plugin_objects = scanner (vst_path, vst_filter, 0, true, true);
 513
 514         if (plugin_objects) {
 515                 for (x = plugin_objects->begin(); x != plugin_objects->end (); ++x) {
 516                         vst_discover (**x);
 517                 }
 518         }
 519
 520         vector_delete (plugin_objects);
 521         return ret;
 522 }
 523
 524 int
 525 PluginManager::vst_discover (string path)
 526 {
 527         FSTInfo* finfo;
 528         char buf[32];
 529
 530         if ((finfo = fst_get_info (const_cast<char *> (path.c_str()))) == 0) {
 531                 warning << "Cannot get VST information from " << path << endmsg;
 532                 return -1;
 533         }
 534
 535         if (!finfo->canProcessReplacing) {
 536                 warning << string_compose (_("VST plugin %1 does not support processReplacing, and so cannot be used in ardour at this time"),
 537                                     finfo->name)
 538                         << endl;
 539         }
 540
 541         PluginInfoPtr info(new VSTPluginInfo);
 542
 543         /* what a joke freeware VST is */
 544
 545         if (!strcasecmp ("The Unnamed plugin", finfo->name)) {
 546                 info->name = PBD::basename_nosuffix (path);
 547         } else {
 548                 info->name = finfo->name;
 549         }
 550
 551
 552         snprintf (buf, sizeof (buf), "%d", finfo->UniqueID);
 553         info->unique_id = buf;
 554         info->category = "VST";
 555         info->path = path;
 556         info->creator = finfo->creator;
 557         info->index = 0;
 558         info->n_inputs.set_audio (finfo->numInputs);
 559         info->n_outputs.set_audio (finfo->numOutputs);
 560         info->n_inputs.set_midi (finfo->wantMidi ? 1 : 0);
 561         info->type = ARDOUR::VST;
 562
 563         _vst_plugin_info->push_back (info);
 564         fst_free_info (finfo);
 565
 566         return 0;
 567 }
 568
 569 #endif // VST_SUPPORT
 570
 571 PluginManager::PluginStatusType
 572 PluginManager::get_status (const PluginInfoPtr& pi)
 573 {
 574         PluginStatus ps (pi->type, pi->unique_id);
 575         PluginStatusList::const_iterator i =  find (statuses.begin(), statuses.end(), ps);
 576         if (i ==  statuses.end() ) {
 577                 return Normal;
 578         } else {
 579                 return i->status;
 580         }
 581 }
 582
 583 void
 584 PluginManager::save_statuses ()
 585 {
 586         ofstream ofs;
 587         sys::path path = user_config_directory();
 588         path /= "plugin_statuses";
 589
 590         ofs.open (path.to_string().c_str(), ios_base::openmode (ios::out|ios::trunc));
 591
 592         if (!ofs) {
 593                 return;
 594         }
 595
 596         for (PluginStatusList::iterator i = statuses.begin(); i != statuses.end(); ++i) {
 597                 switch ((*i).type) {
 598                 case LADSPA:
 599                         ofs << "LADSPA";
 600                         break;
 601                 case AudioUnit:
 602                         ofs << "AudioUnit";
 603                         break;
 604                 case LV2:
 605                         ofs << "LV2";
 606                         break;
 607                 case VST:
 608                         ofs << "VST";
 609                         break;
 610                 }
 611
 612                 ofs << ' ';
 613
 614                 switch ((*i).status) {
 615                 case Normal:
 616                         ofs << "Normal";
 617                         break;
 618                 case Favorite:
 619                         ofs << "Favorite";
 620                         break;
 621                 case Hidden:
 622                         ofs << "Hidden";
 623                         break;
 624                 }
 625
 626                 ofs << ' ';
 627                 ofs << (*i).unique_id;;
 628                 ofs << endl;
 629         }
 630
 631         ofs.close ();
 632 }
 633
 634 void
 635 PluginManager::load_statuses ()
 636 {
 637         sys::path path = user_config_directory();
 638         path /= "plugin_statuses";
 639         ifstream ifs (path.to_string().c_str());
 640
 641         if (!ifs) {
 642                 return;
 643         }
 644
 645         std::string stype;
 646         std::string sstatus;
 647         std::string id;
 648         PluginType type;
 649         PluginStatusType status;
 650         char buf[1024];
 651
 652         while (ifs) {
 653
 654                 ifs >> stype;
 655                 if (!ifs) {
 656                         break;
 657
 658                 }
 659
 660                 ifs >> sstatus;
 661                 if (!ifs) {
 662                         break;
 663
 664                 }
 665
 666                 /* rest of the line is the plugin ID */
 667
 668                 ifs.getline (buf, sizeof (buf), '\n');
 669                 if (!ifs) {
 670                         break;
 671                 }
 672
 673                 if (sstatus == "Normal") {
 674                         status = Normal;
 675                 } else if (sstatus == "Favorite") {
 676                         status = Favorite;
 677                 } else if (sstatus == "Hidden") {
 678                         status = Hidden;
 679                 } else {
 680                         error << string_compose (_("unknown plugin status type \"%1\" - all entries ignored"), sstatus)
 681                                   << endmsg;
 682                         statuses.clear ();
 683                         break;
 684                 }
 685
 686                 if (stype == "LADSPA") {
 687                         type = LADSPA;
 688                 } else if (stype == "AudioUnit") {
 689                         type = AudioUnit;
 690                 } else if (stype == "LV2") {
 691                         type = LV2;
 692                 } else if (stype == "VST") {
 693                         type = VST;
 694                 } else {
 695                         error << string_compose (_("unknown plugin type \"%1\" - ignored"), stype)
 696                               << endmsg;
 697                         continue;
 698                 }
 699
 700                 id = buf;
 701                 strip_whitespace_edges (id);
 702                 set_status (type, id, status);
 703         }
 704
 705         ifs.close ();
 706 }
 707
 708 void
 709 PluginManager::set_status (PluginType t, string id, PluginStatusType status)
 710 {
 711         PluginStatus ps (t, id, status);
 712         statuses.erase (ps);
 713
 714         if (status == Normal) {
 715                 return;
 716         }
 717
 718         pair<PluginStatusList::iterator, bool> res = statuses.insert (ps);
 719         //cerr << "Added " << t << " " << id << " " << status << " success ? " << res.second << endl;
 720 }
 721
 722 ARDOUR::PluginInfoList&
 723 PluginManager::vst_plugin_info ()
 724 {
 725 #ifdef VST_SUPPORT
 726         if (!_vst_plugin_info)
 727                 vst_refresh();
 728         return *_vst_plugin_info;
 729 #else
 730         return _empty_plugin_info;
 731 #endif
 732 }
 733
 734 ARDOUR::PluginInfoList&
 735 PluginManager::ladspa_plugin_info ()
 736 {
 737         if (!_ladspa_plugin_info)
 738                 ladspa_refresh();
 739         return *_ladspa_plugin_info;
 740 }
 741
 742 ARDOUR::PluginInfoList&
 743 PluginManager::lv2_plugin_info ()
 744 {
 745 #ifdef HAVE_SLV2
 746         if (!_lv2_plugin_info)
 747                 lv2_refresh();
 748         return *_lv2_plugin_info;
 749 #else
 750         return _empty_plugin_info;
 751 #endif
 752 }
 753
 754 ARDOUR::PluginInfoList&
 755 PluginManager::au_plugin_info ()
 756 {
 757 #ifdef HAVE_AUDIOUNITS
 758         if (!_au_plugin_info)
 759                 au_refresh();
 760         return *_au_plugin_info;
 761 #else
 762         return _empty_plugin_info;
 763 #endif
 764 }