libs/ardour/control_protocol_manager.cc

   1 /*
   2     Copyright (C) 2000-2007 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 #include <glibmm/module.h>
  21
  22 #include <glibmm/fileutils.h>
  23
  24 #include "pbd/compose.h"
  25 #include "pbd/event_loop.h"
  26 #include "pbd/file_utils.h"
  27 #include "pbd/error.h"
  28
  29 #include "control_protocol/control_protocol.h"
  30
  31 #include "ardour/debug.h"
  32 #include "ardour/control_protocol_manager.h"
  33
  34 #include "ardour/search_paths.h"
  35
  36
  37 using namespace ARDOUR;
  38 using namespace std;
  39 using namespace PBD;
  40
  41 #include "pbd/i18n.h"
  42
  43 ControlProtocolManager* ControlProtocolManager::_instance = 0;
  44 const string ControlProtocolManager::state_node_name = X_("ControlProtocols");
  45
  46
  47 ControlProtocolInfo::~ControlProtocolInfo ()
  48 {
  49         if (protocol && descriptor) {
  50                 descriptor->destroy (descriptor, protocol);
  51                 protocol = 0;
  52         }
  53
  54         delete state; state = 0;
  55
  56         if (descriptor) {
  57                 delete (Glib::Module*) descriptor->module;
  58                 descriptor = 0;
  59         }
  60 }
  61
  62 ControlProtocolManager::ControlProtocolManager ()
  63 {
  64 }
  65
  66 ControlProtocolManager::~ControlProtocolManager()
  67 {
  68         Glib::Threads::Mutex::Lock lm (protocols_lock);
  69
  70         for (list<ControlProtocol*>::iterator i = control_protocols.begin(); i != control_protocols.end(); ++i) {
  71                 delete (*i);
  72         }
  73
  74         control_protocols.clear ();
  75
  76
  77         for (list<ControlProtocolInfo*>::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) {
  78                 delete (*p);
  79         }
  80
  81         control_protocol_info.clear();
  82 }
  83
  84 void
  85 ControlProtocolManager::set_session (Session* s)
  86 {
  87         SessionHandlePtr::set_session (s);
  88
  89         if (_session) {
  90                 Glib::Threads::Mutex::Lock lm (protocols_lock);
  91
  92                 for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
  93                         if ((*i)->requested || (*i)->mandatory) {
  94                                 (void) activate (**i);
  95                         }
  96                 }
  97         }
  98 }
  99
 100 int
 101 ControlProtocolManager::activate (ControlProtocolInfo& cpi)
 102 {
 103         ControlProtocol* cp;
 104
 105         cpi.requested = true;
 106
 107         if ((cp = instantiate (cpi)) == 0) {
 108                 return -1;
 109         }
 110
 111         /* we split the set_state() and set_active() operations so that
 112            protocols that need state to configure themselves (e.g. "What device
 113            is connected, or supposed to be connected?") can get it before
 114            actually starting any interaction.
 115         */
 116
 117         if (cpi.state) {
 118                 /* force this by tweaking the internals of the state
 119                  * XMLNode. Ugh.
 120                  */
 121                 cp->set_state (*cpi.state, Stateful::loading_state_version);
 122         } else {
 123                 /* guarantee a call to
 124                    set_state() whether we have
 125                    existing state or not
 126                 */
 127                 cp->set_state (XMLNode(""), Stateful::loading_state_version);
 128         }
 129
 130         if (cp->set_active (true)) {
 131                 error << string_compose (_("Control protocol support for %1 failed to activate"), cpi.name) << endmsg;
 132                 teardown (cpi, false);
 133         }
 134
 135         return 0;
 136 }
 137
 138 int
 139 ControlProtocolManager::deactivate (ControlProtocolInfo& cpi)
 140 {
 141         cpi.requested = false;
 142         return teardown (cpi, true);
 143 }
 144
 145 void
 146 ControlProtocolManager::session_going_away()
 147 {
 148         SessionHandlePtr::session_going_away ();
 149         /* Session::destroy() will explicitly call drop_protocols() so we don't
 150          * have to worry about that here.
 151          */
 152 }
 153
 154 void
 155 ControlProtocolManager::drop_protocols ()
 156 {
 157         /* called explicitly by Session::destroy() so that we can clean up
 158          * before the process cycle stops and ports vanish.
 159          */
 160
 161         Glib::Threads::Mutex::Lock lm (protocols_lock);
 162
 163         for (list<ControlProtocol*>::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) {
 164                 delete *p;
 165         }
 166
 167         control_protocols.clear ();
 168
 169         for (list<ControlProtocolInfo*>::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) {
 170                 // mark existing protocols as requested
 171                 // otherwise the ControlProtocol instances are not recreated in set_session
 172                 if ((*p)->protocol) {
 173                         (*p)->requested = true;
 174                         (*p)->protocol = 0;
 175                         ProtocolStatusChange (*p); /* EMIT SIGNAL */
 176                 }
 177         }
 178 }
 179
 180 ControlProtocol*
 181 ControlProtocolManager::instantiate (ControlProtocolInfo& cpi)
 182 {
 183         /* CALLER MUST HOLD LOCK */
 184
 185         if (_session == 0) {
 186                 return 0;
 187         }
 188
 189         cpi.descriptor = get_descriptor (cpi.path);
 190
 191         DEBUG_TRACE (DEBUG::ControlProtocols, string_compose ("instantiating %1\n", cpi.name));
 192
 193         if (cpi.descriptor == 0) {
 194                 error << string_compose (_("control protocol name \"%1\" has no descriptor"), cpi.name) << endmsg;
 195                 return 0;
 196         }
 197
 198         DEBUG_TRACE (DEBUG::ControlProtocols, string_compose ("initializing %1\n", cpi.name));
 199
 200         if ((cpi.protocol = cpi.descriptor->initialize (cpi.descriptor, _session)) == 0) {
 201                 error << string_compose (_("control protocol name \"%1\" could not be initialized"), cpi.name) << endmsg;
 202                 return 0;
 203         }
 204
 205         control_protocols.push_back (cpi.protocol);
 206
 207         ProtocolStatusChange (&cpi);
 208
 209         return cpi.protocol;
 210 }
 211
 212 int
 213 ControlProtocolManager::teardown (ControlProtocolInfo& cpi, bool lock_required)
 214 {
 215         if (!cpi.protocol) {
 216
 217                 /* we could still have a descriptor even if the protocol was
 218                    never instantiated. Close the associated module (shared
 219                    object/DLL) and make sure we forget about it.
 220                 */
 221
 222                 if (cpi.descriptor) {
 223                         cerr << "Closing descriptor for CPI anyway\n";
 224                         delete (Glib::Module*) cpi.descriptor->module;
 225                         cpi.descriptor = 0;
 226                 }
 227
 228                 return 0;
 229         }
 230
 231         if (!cpi.descriptor) {
 232                 return 0;
 233         }
 234
 235         if (cpi.mandatory) {
 236                 return 0;
 237         }
 238
 239         /* save current state */
 240
 241         delete cpi.state;
 242         cpi.state = new XMLNode (cpi.protocol->get_state());
 243         cpi.state->set_property (X_("active"), false);
 244
 245         cpi.descriptor->destroy (cpi.descriptor, cpi.protocol);
 246
 247         if (lock_required) {
 248                 Glib::Threads::Mutex::Lock lm (protocols_lock);
 249                 list<ControlProtocol*>::iterator p = find (control_protocols.begin(), control_protocols.end(), cpi.protocol);
 250                 if (p != control_protocols.end()) {
 251                         control_protocols.erase (p);
 252                 } else {
 253                         cerr << "Programming error: ControlProtocolManager::teardown() called for " << cpi.name << ", but it was not found in control_protocols" << endl;
 254                 }
 255         } else {
 256                 list<ControlProtocol*>::iterator p = find (control_protocols.begin(), control_protocols.end(), cpi.protocol);
 257                 if (p != control_protocols.end()) {
 258                         control_protocols.erase (p);
 259                 } else {
 260                         cerr << "Programming error: ControlProtocolManager::teardown() called for " << cpi.name << ", but it was not found in control_protocols" << endl;
 261                 }
 262         }
 263
 264         cpi.protocol = 0;
 265
 266         delete cpi.state;
 267         cpi.state = 0;
 268         delete (Glib::Module*) cpi.descriptor->module;
 269         /* cpi->descriptor is now inaccessible since dlclose() or equivalent
 270          * has been performed, and the descriptor is (or could be) a static
 271          * object made accessible by dlopen().
 272          */
 273         cpi.descriptor = 0;
 274
 275         ProtocolStatusChange (&cpi);
 276
 277         return 0;
 278 }
 279
 280 void
 281 ControlProtocolManager::load_mandatory_protocols ()
 282 {
 283         if (_session == 0) {
 284                 return;
 285         }
 286
 287         Glib::Threads::Mutex::Lock lm (protocols_lock);
 288
 289         for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
 290                 if ((*i)->mandatory && ((*i)->protocol == 0)) {
 291                         DEBUG_TRACE (DEBUG::ControlProtocols,
 292                                      string_compose (_("Instantiating mandatory control protocol %1"), (*i)->name));
 293                         instantiate (**i);
 294                 }
 295         }
 296 }
 297
 298 void
 299 ControlProtocolManager::discover_control_protocols ()
 300 {
 301         vector<std::string> cp_modules;
 302
 303 #ifdef COMPILER_MSVC
 304    /**
 305     * Different build targets (Debug / Release etc) use different versions
 306     * of the 'C' runtime (which can't be 'mixed & matched'). Therefore, in
 307     * case the supplied search path contains multiple version(s) of a given
 308     * module, only select the one(s) which match the current build target
 309     */
 310         #if defined (_DEBUG)
 311                 Glib::PatternSpec dll_extension_pattern("*D.dll");
 312         #elif defined (RDC_BUILD)
 313                 Glib::PatternSpec dll_extension_pattern("*RDC.dll");
 314         #elif defined (_WIN64)
 315                 Glib::PatternSpec dll_extension_pattern("*64.dll");
 316         #else
 317                 Glib::PatternSpec dll_extension_pattern("*32.dll");
 318         #endif
 319 #else
 320         Glib::PatternSpec dll_extension_pattern("*.dll");
 321 #endif
 322
 323         Glib::PatternSpec so_extension_pattern("*.so");
 324         Glib::PatternSpec dylib_extension_pattern("*.dylib");
 325
 326         find_files_matching_pattern (cp_modules, control_protocol_search_path (),
 327                                      dll_extension_pattern);
 328
 329         find_files_matching_pattern (cp_modules, control_protocol_search_path (),
 330                                      so_extension_pattern);
 331
 332         find_files_matching_pattern (cp_modules, control_protocol_search_path (),
 333                                      dylib_extension_pattern);
 334
 335         DEBUG_TRACE (DEBUG::ControlProtocols,
 336                      string_compose (_("looking for control protocols in %1\n"), control_protocol_search_path().to_string()));
 337
 338         for (vector<std::string>::iterator i = cp_modules.begin(); i != cp_modules.end(); ++i) {
 339                 control_protocol_discover (*i);
 340         }
 341 }
 342
 343 int
 344 ControlProtocolManager::control_protocol_discover (string path)
 345 {
 346         ControlProtocolDescriptor* descriptor;
 347
 348 #ifdef __APPLE__
 349         /* don't load OS X shared objects that are just symlinks to the real thing.
 350          */
 351
 352         if (path.find (".dylib") && Glib::file_test (path, Glib::FILE_TEST_IS_SYMLINK)) {
 353                 return 0;
 354         }
 355 #endif
 356
 357         if ((descriptor = get_descriptor (path)) != 0) {
 358
 359                 if (!descriptor->probe (descriptor)) {
 360                         warning << string_compose (_("Control protocol %1 not usable"), descriptor->name) << endmsg;
 361                 } else {
 362
 363                         ControlProtocolInfo* cpi = new ControlProtocolInfo ();
 364
 365                         cpi->descriptor = descriptor;
 366                         cpi->name = descriptor->name;
 367                         cpi->path = path;
 368                         cpi->protocol = 0;
 369                         cpi->requested = false;
 370                         cpi->mandatory = descriptor->mandatory;
 371                         cpi->supports_feedback = descriptor->supports_feedback;
 372                         cpi->state = 0;
 373
 374                         control_protocol_info.push_back (cpi);
 375
 376                         DEBUG_TRACE (DEBUG::ControlProtocols,
 377                                      string_compose(_("Control surface protocol discovered: \"%1\"\n"), cpi->name));
 378                 }
 379         }
 380
 381         return 0;
 382 }
 383
 384 ControlProtocolDescriptor*
 385 ControlProtocolManager::get_descriptor (string path)
 386 {
 387         Glib::Module* module = new Glib::Module(path);
 388         ControlProtocolDescriptor *descriptor = 0;
 389         ControlProtocolDescriptor* (*dfunc)(void);
 390         void* func = 0;
 391
 392         if (!(*module)) {
 393                 error << string_compose(_("ControlProtocolManager: cannot load module \"%1\" (%2)"), path, Glib::Module::get_last_error()) << endmsg;
 394                 delete module;
 395                 return 0;
 396         }
 397
 398         if (!module->get_symbol("protocol_descriptor", func)) {
 399                 error << string_compose(_("ControlProtocolManager: module \"%1\" has no descriptor function."), path) << endmsg;
 400                 error << Glib::Module::get_last_error() << endmsg;
 401                 delete module;
 402                 return 0;
 403         }
 404
 405         dfunc = (ControlProtocolDescriptor* (*)(void))func;
 406         descriptor = dfunc();
 407
 408         if (descriptor) {
 409                 descriptor->module = (void*)module;
 410         }
 411
 412         return descriptor;
 413 }
 414
 415 void
 416 ControlProtocolManager::foreach_known_protocol (boost::function<void(const ControlProtocolInfo*)> method)
 417 {
 418         for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
 419                 method (*i);
 420         }
 421 }
 422
 423 ControlProtocolInfo*
 424 ControlProtocolManager::cpi_by_name (string name)
 425 {
 426         for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
 427                 if (name == (*i)->name) {
 428                         return *i;
 429                 }
 430         }
 431         return 0;
 432 }
 433
 434 int
 435 ControlProtocolManager::set_state (const XMLNode& node, int /*version*/)
 436 {
 437         XMLNodeList clist;
 438         XMLNodeConstIterator citer;
 439
 440         Glib::Threads::Mutex::Lock lm (protocols_lock);
 441
 442         clist = node.children();
 443
 444         for (citer = clist.begin(); citer != clist.end(); ++citer) {
 445                 XMLNode const * child = *citer;
 446
 447                 if (child->name() == X_("Protocol")) {
 448
 449                         bool active;
 450                         std::string name;
 451                         if (!child->get_property (X_("active"), active) ||
 452                             !child->get_property (X_("name"), name)) {
 453                                 continue;
 454                         }
 455
 456                         ControlProtocolInfo* cpi = cpi_by_name (name);
 457
 458                         if (cpi) {
 459                                 delete cpi->state;
 460                                 cpi->state = new XMLNode (**citer);
 461
 462                                 std::cerr << "protocol " << name << " active ? " << active << std::endl;
 463
 464                                 if (active) {
 465                                         if (_session) {
 466                                                 instantiate (*cpi);
 467                                         } else {
 468                                                 cpi->requested = true;
 469                                         }
 470                                 } else {
 471                                         if (_session) {
 472                                                 teardown (*cpi, false);
 473                                         } else {
 474                                                 cpi->requested = false;
 475                                         }
 476                                 }
 477                         } else {
 478                                 std::cerr << "protocol " << name << " not found\n";
 479                         }
 480                 }
 481         }
 482
 483         return 0;
 484 }
 485
 486 XMLNode&
 487 ControlProtocolManager::get_state ()
 488 {
 489         XMLNode* root = new XMLNode (state_node_name);
 490         Glib::Threads::Mutex::Lock lm (protocols_lock);
 491
 492         for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
 493
 494                 if ((*i)->protocol) {
 495                         XMLNode& child_state ((*i)->protocol->get_state());
 496                         child_state.set_property (X_("active"), true);
 497                         root->add_child_nocopy (child_state);
 498                 } else if ((*i)->state) {
 499                         XMLNode* child_state = new XMLNode (*(*i)->state);
 500                         child_state->set_property (X_("active"), false);
 501                         root->add_child_nocopy (*child_state);
 502                 } else {
 503                         XMLNode* child_state = new XMLNode (X_("Protocol"));
 504                         child_state->set_property (X_("name"), (*i)->name);
 505                         child_state->set_property (X_("active"), false);
 506                         root->add_child_nocopy (*child_state);
 507                 }
 508
 509         }
 510
 511         return *root;
 512 }
 513
 514
 515 ControlProtocolManager&
 516 ControlProtocolManager::instance ()
 517 {
 518         if (_instance == 0) {
 519                 _instance = new ControlProtocolManager ();
 520         }
 521
 522         return *_instance;
 523 }
 524
 525 void
 526 ControlProtocolManager::midi_connectivity_established ()
 527 {
 528         Glib::Threads::Mutex::Lock lm (protocols_lock);
 529
 530         for (list<ControlProtocol*>::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) {
 531                 (*p)->midi_connectivity_established ();
 532         }
 533 }
 534
 535 void
 536 ControlProtocolManager::register_request_buffer_factories ()
 537 {
 538         Glib::Threads::Mutex::Lock lm (protocols_lock);
 539
 540         for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
 541
 542                 if ((*i)->descriptor == 0) {
 543                         warning << string_compose (_("Control protocol \"%1\" has no descriptor"), (*i)->name) << endmsg;
 544                         continue;
 545                 }
 546
 547                 if ((*i)->descriptor->request_buffer_factory) {
 548                         EventLoop::register_request_buffer_factory ((*i)->descriptor->name, (*i)->descriptor->request_buffer_factory);
 549                 }
 550         }
 551 }