X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fcontrol_protocol_manager.cc;h=49b3d0776161c6ecfe2b99473c194ad151905bd5;hb=0de7c8920b57e9af99597affb1b18e3435fc1f67;hp=be173e71024264b690377ebd93d17e627c4f1a41;hpb=e488378d42777b436c6a2708d9dff2def51a5271;p=ardour.git diff --git a/libs/ardour/control_protocol_manager.cc b/libs/ardour/control_protocol_manager.cc index be173e7102..49b3d07761 100644 --- a/libs/ardour/control_protocol_manager.cc +++ b/libs/ardour/control_protocol_manager.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2000-2007 Paul Davis + Copyright (C) 2000-2007 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 @@ -17,7 +17,9 @@ */ -#include +#include + +#include #include "pbd/compose.h" #include "pbd/file_utils.h" @@ -25,9 +27,11 @@ #include "control_protocol/control_protocol.h" -#include "ardour/session.h" +#include "ardour/debug.h" #include "ardour/control_protocol_manager.h" -#include "ardour/control_protocol_search_path.h" + +#include "ardour/search_paths.h" + using namespace ARDOUR; using namespace std; @@ -40,16 +44,11 @@ const string ControlProtocolManager::state_node_name = X_("ControlProtocols"); ControlProtocolManager::ControlProtocolManager () { - if (_instance == 0) { - _instance = this; - } - - _session = 0; } ControlProtocolManager::~ControlProtocolManager() { - Glib::Mutex::Lock lm (protocols_lock); + Glib::Threads::Mutex::Lock lm (protocols_lock); for (list::iterator i = control_protocols.begin(); i != control_protocols.end(); ++i) { delete (*i); @@ -57,7 +56,7 @@ ControlProtocolManager::~ControlProtocolManager() control_protocols.clear (); - + for (list::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) { delete (*p); } @@ -66,36 +65,79 @@ ControlProtocolManager::~ControlProtocolManager() } void -ControlProtocolManager::set_session (Session& s) +ControlProtocolManager::set_session (Session* s) { - _session = &s; - _session->GoingAway.connect (mem_fun (*this, &ControlProtocolManager::drop_session)); + SessionHandlePtr::set_session (s); - for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { - if ((*i)->requested || (*i)->mandatory) { - instantiate (**i); - (*i)->requested = false; + if (_session) { + Glib::Threads::Mutex::Lock lm (protocols_lock); - if ((*i)->protocol && (*i)->state) { - (*i)->protocol->set_state (*(*i)->state); + for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { + if ((*i)->requested || (*i)->mandatory) { + (void) activate (**i); } } } } +int +ControlProtocolManager::activate (ControlProtocolInfo& cpi) +{ + ControlProtocol* cp; + + cpi.requested = true; + + if ((cp = instantiate (cpi)) == 0) { + return -1; + } + + /* we split the set_state() and set_active() operations so that + protocols that need state to configure themselves (e.g. "What device + is connected, or supposed to be connected?") can get it before + actually starting any interaction. + */ + + if (cpi.state) { + /* force this by tweaking the internals of the state + * XMLNode. Ugh. + */ + cp->set_state (*cpi.state, Stateful::loading_state_version); + } else { + /* guarantee a call to + set_state() whether we have + existing state or not + */ + cp->set_state (XMLNode(""), Stateful::loading_state_version); + } + + cp->set_active (true); + + return 0; +} + +int +ControlProtocolManager::deactivate (ControlProtocolInfo& cpi) +{ + cpi.requested = false; + return teardown (cpi); +} + void -ControlProtocolManager::drop_session () +ControlProtocolManager::session_going_away() { - _session = 0; + SessionHandlePtr::session_going_away (); { - Glib::Mutex::Lock lm (protocols_lock); + Glib::Threads::Mutex::Lock lm (protocols_lock); + for (list::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) { delete *p; } + control_protocols.clear (); - + for (list::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) { + // mark existing protocols as requested // otherwise the ControlProtocol instances are not recreated in set_session if ((*p)->protocol) { (*p)->requested = true; @@ -108,25 +150,32 @@ ControlProtocolManager::drop_session () ControlProtocol* ControlProtocolManager::instantiate (ControlProtocolInfo& cpi) { + /* CALLER MUST HOLD LOCK */ + if (_session == 0) { return 0; } cpi.descriptor = get_descriptor (cpi.path); + DEBUG_TRACE (DEBUG::ControlProtocols, string_compose ("instantiating %1\n", cpi.name)); + if (cpi.descriptor == 0) { error << string_compose (_("control protocol name \"%1\" has no descriptor"), cpi.name) << endmsg; return 0; } + DEBUG_TRACE (DEBUG::ControlProtocols, string_compose ("initializing %1\n", cpi.name)); + if ((cpi.protocol = cpi.descriptor->initialize (cpi.descriptor, _session)) == 0) { error << string_compose (_("control protocol name \"%1\" could not be initialized"), cpi.name) << endmsg; return 0; } - Glib::Mutex::Lock lm (protocols_lock); control_protocols.push_back (cpi.protocol); + ProtocolStatusChange (&cpi); + return cpi.protocol; } @@ -144,28 +193,32 @@ ControlProtocolManager::teardown (ControlProtocolInfo& cpi) if (cpi.mandatory) { return 0; } + + /* save current state */ + + delete cpi.state; + cpi.state = new XMLNode (cpi.protocol->get_state()); + cpi.state->add_property (X_("active"), "no"); cpi.descriptor->destroy (cpi.descriptor, cpi.protocol); - + { - Glib::Mutex::Lock lm (protocols_lock); + Glib::Threads::Mutex::Lock lm (protocols_lock); list::iterator p = find (control_protocols.begin(), control_protocols.end(), cpi.protocol); if (p != control_protocols.end()) { control_protocols.erase (p); } else { cerr << "Programming error: ControlProtocolManager::teardown() called for " << cpi.name << ", but it was not found in control_protocols" << endl; } - - list::iterator p2 = find (control_protocol_info.begin(), control_protocol_info.end(), &cpi); - if (p2 != control_protocol_info.end()) { - control_protocol_info.erase (p2); - } else { - cerr << "Programming error: ControlProtocolManager::teardown() called for " << cpi.name << ", but it was not found in control_protocol_info" << endl; - } } - + cpi.protocol = 0; - dlclose (cpi.descriptor->module); + delete cpi.state; + cpi.state = 0; + delete (Glib::Module*)cpi.descriptor->module; + + ProtocolStatusChange (&cpi); + return 0; } @@ -176,9 +229,12 @@ ControlProtocolManager::load_mandatory_protocols () return; } + Glib::Threads::Mutex::Lock lm (protocols_lock); + for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { if ((*i)->mandatory && ((*i)->protocol == 0)) { - info << string_compose (_("Instantiating mandatory control protocol %1"), (*i)->name) << endmsg; + DEBUG_TRACE (DEBUG::ControlProtocols, + string_compose (_("Instantiating mandatory control protocol %1"), (*i)->name)); instantiate (**i); } } @@ -187,21 +243,45 @@ ControlProtocolManager::load_mandatory_protocols () void ControlProtocolManager::discover_control_protocols () { - vector cp_modules; + vector cp_modules; + +#ifdef COMPILER_MSVC + /** + * Different build targets (Debug / Release etc) use different versions + * of the 'C' runtime (which can't be 'mixed & matched'). Therefore, in + * case the supplied search path contains multiple version(s) of a given + * module, only select the one(s) which match the current build target + */ + #if defined (_DEBUG) + Glib::PatternSpec dll_extension_pattern("*D.dll"); + #elif defined (RDC_BUILD) + Glib::PatternSpec dll_extension_pattern("*RDC.dll"); + #elif defined (_WIN64) + Glib::PatternSpec dll_extension_pattern("*64.dll"); + #else + Glib::PatternSpec dll_extension_pattern("*32.dll"); + #endif +#else + Glib::PatternSpec dll_extension_pattern("*.dll"); +#endif Glib::PatternSpec so_extension_pattern("*.so"); Glib::PatternSpec dylib_extension_pattern("*.dylib"); find_matching_files_in_search_path (control_protocol_search_path (), - so_extension_pattern, cp_modules); + dll_extension_pattern, cp_modules); find_matching_files_in_search_path (control_protocol_search_path (), - dylib_extension_pattern, cp_modules); + so_extension_pattern, cp_modules); - info << string_compose (_("looking for control protocols in %1"), control_protocol_search_path().to_string()) << endmsg; + find_matching_files_in_search_path (control_protocol_search_path (), + dylib_extension_pattern, cp_modules); - for (vector::iterator i = cp_modules.begin(); i != cp_modules.end(); ++i) { - control_protocol_discover ((*i).to_string()); + DEBUG_TRACE (DEBUG::ControlProtocols, + string_compose (_("looking for control protocols in %1\n"), control_protocol_search_path().to_string())); + + for (vector::iterator i = cp_modules.begin(); i != cp_modules.end(); ++i) { + control_protocol_discover (*i); } } @@ -210,14 +290,24 @@ ControlProtocolManager::control_protocol_discover (string path) { ControlProtocolDescriptor* descriptor; - if ((descriptor = get_descriptor (path)) != 0) { +#ifdef __APPLE__ + /* don't load OS X shared objects that are just symlinks to the real thing. + */ + + if (path.find (".dylib") && Glib::file_test (path, Glib::FILE_TEST_IS_SYMLINK)) { + return 0; + } +#endif - ControlProtocolInfo* cpi = new ControlProtocolInfo (); + if ((descriptor = get_descriptor (path)) != 0) { if (!descriptor->probe (descriptor)) { - info << string_compose (_("Control protocol %1 not usable"), descriptor->name) << endmsg; + DEBUG_TRACE (DEBUG::ControlProtocols, + string_compose (_("Control protocol %1 not usable"), descriptor->name)); } else { + ControlProtocolInfo* cpi = new ControlProtocolInfo (); + cpi->descriptor = descriptor; cpi->name = descriptor->name; cpi->path = path; @@ -226,13 +316,14 @@ ControlProtocolManager::control_protocol_discover (string path) cpi->mandatory = descriptor->mandatory; cpi->supports_feedback = descriptor->supports_feedback; cpi->state = 0; - + control_protocol_info.push_back (cpi); - - info << string_compose(_("Control surface protocol discovered: \"%1\""), cpi->name) << endmsg; + + DEBUG_TRACE (DEBUG::ControlProtocols, + string_compose(_("Control surface protocol discovered: \"%1\"\n"), cpi->name)); } - dlclose (descriptor->module); + delete (Glib::Module*)descriptor->module; } return 0; @@ -241,38 +332,38 @@ ControlProtocolManager::control_protocol_discover (string path) ControlProtocolDescriptor* ControlProtocolManager::get_descriptor (string path) { - void *module; + Glib::Module* module = new Glib::Module(path); ControlProtocolDescriptor *descriptor = 0; ControlProtocolDescriptor* (*dfunc)(void); - const char *errstr; + void* func = 0; - if ((module = dlopen (path.c_str(), RTLD_NOW)) == 0) { - error << string_compose(_("ControlProtocolManager: cannot load module \"%1\" (%2)"), path, dlerror()) << endmsg; + if (!(*module)) { + error << string_compose(_("ControlProtocolManager: cannot load module \"%1\" (%2)"), path, Glib::Module::get_last_error()) << endmsg; + delete module; return 0; } - - dfunc = (ControlProtocolDescriptor* (*)(void)) dlsym (module, "protocol_descriptor"); - - if ((errstr = dlerror()) != 0) { + if (!module->get_symbol("protocol_descriptor", func)) { error << string_compose(_("ControlProtocolManager: module \"%1\" has no descriptor function."), path) << endmsg; - error << errstr << endmsg; - dlclose (module); + error << Glib::Module::get_last_error() << endmsg; + delete module; return 0; } + dfunc = (ControlProtocolDescriptor* (*)(void))func; descriptor = dfunc(); + if (descriptor) { - descriptor->module = module; + descriptor->module = (void*)module; } else { - dlclose (module); + delete module; } return descriptor; } void -ControlProtocolManager::foreach_known_protocol (sigc::slot method) +ControlProtocolManager::foreach_known_protocol (boost::function method) { for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { method (*i); @@ -291,100 +382,99 @@ ControlProtocolManager::cpi_by_name (string name) } int -ControlProtocolManager::set_state (const XMLNode& node) +ControlProtocolManager::set_state (const XMLNode& node, int /*version*/) { XMLNodeList clist; XMLNodeConstIterator citer; XMLProperty* prop; + Glib::Threads::Mutex::Lock lm (protocols_lock); + clist = node.children(); for (citer = clist.begin(); citer != clist.end(); ++citer) { if ((*citer)->name() == X_("Protocol")) { - prop = (*citer)->property (X_("active")); - - if (prop && string_is_affirmative (prop->value())) { - if ((prop = (*citer)->property (X_("name"))) != 0) { - ControlProtocolInfo* cpi = cpi_by_name (prop->value()); - if (cpi) { - if (!(*citer)->children().empty()) { - cpi->state = (*citer)->children().front (); - } else { - cpi->state = 0; - } - - if (_session) { - instantiate (*cpi); - } else { - cpi->requested = true; - } + if ((prop = (*citer)->property (X_("active"))) == 0) { + continue; + } + + bool active = string_is_affirmative (prop->value()); + + if ((prop = (*citer)->property (X_("name"))) == 0) { + continue; + } + + ControlProtocolInfo* cpi = cpi_by_name (prop->value()); + + if (cpi) { + cpi->state = new XMLNode (**citer); + + if (active) { + if (_session) { + instantiate (*cpi); + } else { + cpi->requested = true; + } + } else { + if (_session) { + teardown (*cpi); + } else { + cpi->requested = false; } } } - } + } } + return 0; } XMLNode& -ControlProtocolManager::get_state (void) +ControlProtocolManager::get_state () { XMLNode* root = new XMLNode (state_node_name); - Glib::Mutex::Lock lm (protocols_lock); + Glib::Threads::Mutex::Lock lm (protocols_lock); for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { - XMLNode * child; - if ((*i)->protocol) { - child = &((*i)->protocol->get_state()); - child->add_property (X_("active"), "yes"); - // should we update (*i)->state here? probably. - root->add_child_nocopy (*child); - } - else if ((*i)->state) { - // keep ownership clear - root->add_child_copy (*(*i)->state); - } - else { - child = new XMLNode (X_("Protocol")); - child->add_property (X_("name"), (*i)->name); - child->add_property (X_("active"), "no"); - root->add_child_nocopy (*child); + XMLNode& child_state ((*i)->protocol->get_state()); + child_state.add_property (X_("active"), "yes"); + root->add_child_nocopy (child_state); + } else if ((*i)->state) { + XMLNode* child_state = new XMLNode (*(*i)->state); + child_state->add_property (X_("active"), "no"); + root->add_child_nocopy (*child_state); + } else { + XMLNode* child_state = new XMLNode (X_("Protocol")); + child_state->add_property (X_("name"), (*i)->name); + child_state->add_property (X_("active"), "no"); + root->add_child_nocopy (*child_state); } + } return *root; } -void -ControlProtocolManager::set_protocol_states (const XMLNode& node) -{ - XMLNodeList nlist; - XMLNodeConstIterator niter; - XMLProperty* prop; - - nlist = node.children(); - for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - - XMLNode* child = (*niter); - - if ((prop = child->property ("name")) == 0) { - error << _("control protocol XML node has no name property. Ignored.") << endmsg; - continue; - } - - ControlProtocolInfo* cpi = cpi_by_name (prop->value()); +ControlProtocolManager& +ControlProtocolManager::instance () +{ + if (_instance == 0) { + _instance = new ControlProtocolManager (); + } - if (!cpi) { - warning << string_compose (_("control protocol \"%1\" is not known. Ignored"), prop->value()) << endmsg; - continue; - } + return *_instance; +} - /* copy the node so that ownership is clear */ +void +ControlProtocolManager::midi_connectivity_established () +{ + Glib::Threads::Mutex::Lock lm (protocols_lock); - cpi->state = new XMLNode (*child); + for (list::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) { + (*p)->midi_connectivity_established (); } }