X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fcontrol_protocol_manager.cc;h=c2929a396870a5dc1ba660812f70f97f51570832;hb=8c04457be14673385287def048c387b3953fa8e8;hp=893124f0f59a5e1ca4f403677dcd7f0dc41f1889;hpb=a157537898eccf08009281633b19970515366a78;p=ardour.git diff --git a/libs/ardour/control_protocol_manager.cc b/libs/ardour/control_protocol_manager.cc index 893124f0f5..c2929a3968 100644 --- a/libs/ardour/control_protocol_manager.cc +++ b/libs/ardour/control_protocol_manager.cc @@ -1,92 +1,251 @@ -#include +/* + Copyright (C) 2000-2007 Paul Davis -#include -#include -#include + 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 + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -#include -#include -#include + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#include + +#include + +#include "pbd/compose.h" +#include "pbd/event_loop.h" +#include "pbd/file_utils.h" +#include "pbd/error.h" + +#include "control_protocol/control_protocol.h" + +#include "ardour/debug.h" +#include "ardour/control_protocol_manager.h" + +#include "ardour/search_paths.h" +#include "ardour/selection.h" +#include "ardour/session.h" using namespace ARDOUR; -using namespace PBD; using namespace std; +using namespace PBD; -#include "i18n.h" +#include "pbd/i18n.h" ControlProtocolManager* ControlProtocolManager::_instance = 0; +const string ControlProtocolManager::state_node_name = X_("ControlProtocols"); +PBD::Signal1 ControlProtocolManager::StripableSelectionChanged; -ControlProtocolManager::ControlProtocolManager () +ControlProtocolInfo::~ControlProtocolInfo () { - if (_instance == 0) { - _instance = this; + if (protocol && descriptor) { + descriptor->destroy (descriptor, protocol); + protocol = 0; } - _session = 0; + delete state; state = 0; + + if (descriptor) { + delete (Glib::Module*) descriptor->module; + descriptor = 0; + } +} + +ControlProtocolManager::ControlProtocolManager () +{ } ControlProtocolManager::~ControlProtocolManager() { - LockMonitor lm (protocols_lock, __LINE__, __FILE__); + Glib::Threads::RWLock::WriterLock lm (protocols_lock); for (list::iterator i = control_protocols.begin(); i != control_protocols.end(); ++i) { delete (*i); } control_protocols.clear (); - + + + for (list::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) { + (*p)->protocol = 0; // protocol was already destroyed above. + delete (*p); + } + + control_protocol_info.clear(); } void -ControlProtocolManager::set_session (Session& s) +ControlProtocolManager::set_session (Session* s) { - _session = &s; - _session->going_away.connect (mem_fun (*this, &ControlProtocolManager::drop_session)); + SessionHandlePtr::set_session (s); + + if (!_session) { + return; + } + + { + Glib::Threads::RWLock::ReaderLock lm (protocols_lock); + + for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { + if ((*i)->requested || (*i)->mandatory) { + (void) activate (**i); + } + } + } + + CoreSelection::StripableAutomationControls sac; + _session->selection().get_stripables (sac); + + if (!sac.empty()) { + StripableNotificationListPtr v (new StripableNotificationList); + for (CoreSelection::StripableAutomationControls::iterator i = sac.begin(); i != sac.end(); ++i) { + if ((*i).stripable) { + v->push_back (boost::weak_ptr ((*i).stripable)); + } + } + if (!v->empty()) { + StripableSelectionChanged (v); /* EMIT SIGNAL */ + } + } +} + +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); + } + + if (cp->set_active (true)) { + error << string_compose (_("Control protocol support for %1 failed to activate"), cpi.name) << endmsg; + teardown (cpi, false); + } + + return 0; +} + +int +ControlProtocolManager::deactivate (ControlProtocolInfo& cpi) +{ + cpi.requested = false; + return teardown (cpi, true); } void -ControlProtocolManager::drop_session () +ControlProtocolManager::session_going_away() { - _session = 0; + SessionHandlePtr::session_going_away (); + /* Session::destroy() will explicitly call drop_protocols() so we don't + * have to worry about that here. + */ +} - { - LockMonitor lm (protocols_lock, __LINE__, __FILE__); - for (list::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) { - delete *p; +void +ControlProtocolManager::drop_protocols () +{ + /* called explicitly by Session::destroy() so that we can clean up + * before the process cycle stops and ports vanish. + */ + + Glib::Threads::RWLock::WriterLock 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; + (*p)->protocol = 0; + ProtocolStatusChange (*p); /* EMIT SIGNAL */ } - control_protocols.clear (); } } 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; } - LockMonitor lm (protocols_lock, __LINE__, __FILE__); control_protocols.push_back (cpi.protocol); + ProtocolStatusChange (&cpi); + return cpi.protocol; } int -ControlProtocolManager::teardown (ControlProtocolInfo& cpi) +ControlProtocolManager::teardown (ControlProtocolInfo& cpi, bool lock_required) { if (!cpi.protocol) { + + /* we could still have a descriptor even if the protocol was + never instantiated. Close the associated module (shared + object/DLL) and make sure we forget about it. + */ + + if (cpi.descriptor) { + cerr << "Closing descriptor for CPI anyway\n"; + delete (Glib::Module*) cpi.descriptor->module; + cpi.descriptor = 0; + } + return 0; } @@ -94,42 +253,118 @@ ControlProtocolManager::teardown (ControlProtocolInfo& cpi) return 0; } + if (cpi.mandatory) { + return 0; + } + + /* save current state */ + + delete cpi.state; + cpi.state = new XMLNode (cpi.protocol->get_state()); + cpi.state->set_property (X_("active"), false); + cpi.descriptor->destroy (cpi.descriptor, cpi.protocol); - - { - LockMonitor lm (protocols_lock, __LINE__, __FILE__); + + if (lock_required) { + Glib::Threads::RWLock::WriterLock 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; + } + } else { 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; } } - + cpi.protocol = 0; - dlclose (cpi.descriptor->module); - return 0; -} -static bool protocol_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)); + if (lock_required) { + /* the lock is only required when the protocol is torn down from the GUI. + * If a user disables a protocol, we take this as indicator to forget the + * state. + */ + delete cpi.state; + cpi.state = 0; + } + delete (Glib::Module*) cpi.descriptor->module; + /* cpi->descriptor is now inaccessible since dlclose() or equivalent + * has been performed, and the descriptor is (or could be) a static + * object made accessible by dlopen(). + */ + cpi.descriptor = 0; + + ProtocolStatusChange (&cpi); + + return 0; } void -ControlProtocolManager::discover_control_protocols (string path) +ControlProtocolManager::load_mandatory_protocols () { - vector *found; - PathScanner scanner; + if (_session == 0) { + return; + } - found = scanner (path, protocol_filter, 0, false, true); + Glib::Threads::RWLock::ReaderLock lm (protocols_lock); - for (vector::iterator i = found->begin(); i != found->end(); ++i) { - control_protocol_discover (**i); - delete *i; + for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { + if ((*i)->mandatory && ((*i)->protocol == 0)) { + DEBUG_TRACE (DEBUG::ControlProtocols, + string_compose (_("Instantiating mandatory control protocol %1"), (*i)->name)); + instantiate (**i); + } } +} - delete found; +void +ControlProtocolManager::discover_control_protocols () +{ + 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_files_matching_pattern (cp_modules, control_protocol_search_path (), + dll_extension_pattern); + + find_files_matching_pattern (cp_modules, control_protocol_search_path (), + so_extension_pattern); + + find_files_matching_pattern (cp_modules, control_protocol_search_path (), + dylib_extension_pattern); + + 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); + } } int @@ -137,19 +372,37 @@ ControlProtocolManager::control_protocol_discover (string path) { ControlProtocolDescriptor* descriptor; +#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 + if ((descriptor = get_descriptor (path)) != 0) { - ControlProtocolInfo* info = new ControlProtocolInfo (); + if (!descriptor->probe (descriptor)) { + warning << string_compose (_("Control protocol %1 not usable"), descriptor->name) << endmsg; + } else { - info->descriptor = descriptor; - info->name = descriptor->name; - info->path = path; - info->protocol = 0; + ControlProtocolInfo* cpi = new ControlProtocolInfo (); - control_protocol_info.push_back (info); + cpi->descriptor = descriptor; + cpi->name = descriptor->name; + cpi->path = path; + cpi->protocol = 0; + cpi->requested = false; + cpi->mandatory = descriptor->mandatory; + cpi->supports_feedback = descriptor->supports_feedback; + cpi->state = 0; - dlclose (descriptor->module); + control_protocol_info.push_back (cpi); + DEBUG_TRACE (DEBUG::ControlProtocols, + string_compose(_("Control surface protocol discovered: \"%1\"\n"), cpi->name)); + } } return 0; @@ -158,40 +411,195 @@ 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; - } else { - dlclose (module); + descriptor->module = (void*)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); } } + +ControlProtocolInfo* +ControlProtocolManager::cpi_by_name (string name) +{ + for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { + if (name == (*i)->name) { + return *i; + } + } + return 0; +} + +int +ControlProtocolManager::set_state (const XMLNode& node, int /*version*/) +{ + XMLNodeList clist; + XMLNodeConstIterator citer; + + Glib::Threads::RWLock::WriterLock lm (protocols_lock); + + clist = node.children(); + + for (citer = clist.begin(); citer != clist.end(); ++citer) { + XMLNode const * child = *citer; + + if (child->name() == X_("Protocol")) { + + bool active; + std::string name; + if (!child->get_property (X_("active"), active) || + !child->get_property (X_("name"), name)) { + continue; + } + + ControlProtocolInfo* cpi = cpi_by_name (name); + + if (cpi) { +#ifndef NDEBUG + std::cerr << "protocol " << name << " active ? " << active << std::endl; +#endif + + if (active) { + delete cpi->state; + cpi->state = new XMLNode (**citer); + if (_session) { + instantiate (*cpi); + } else { + cpi->requested = true; + } + } else { + if (!cpi->state) { + cpi->state = new XMLNode (**citer); + cpi->state->set_property (X_("active"), false); + } + cpi->requested = false; + if (_session) { + teardown (*cpi, false); + } + } + } else { + std::cerr << "protocol " << name << " not found\n"; + } + } + } + + return 0; +} + +XMLNode& +ControlProtocolManager::get_state () +{ + XMLNode* root = new XMLNode (state_node_name); + Glib::Threads::RWLock::ReaderLock lm (protocols_lock); + + for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { + + if ((*i)->protocol) { + XMLNode& child_state ((*i)->protocol->get_state()); + child_state.set_property (X_("active"), true); + root->add_child_nocopy (child_state); + } else if ((*i)->state) { + XMLNode* child_state = new XMLNode (*(*i)->state); + child_state->set_property (X_("active"), false); + root->add_child_nocopy (*child_state); + } else { + XMLNode* child_state = new XMLNode (X_("Protocol")); + child_state->set_property (X_("name"), (*i)->name); + child_state->set_property (X_("active"), false); + root->add_child_nocopy (*child_state); + } + + } + + return *root; +} + + +ControlProtocolManager& +ControlProtocolManager::instance () +{ + if (_instance == 0) { + _instance = new ControlProtocolManager (); + } + + return *_instance; +} + +void +ControlProtocolManager::midi_connectivity_established () +{ + Glib::Threads::RWLock::ReaderLock lm (protocols_lock); + + for (list::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) { + (*p)->midi_connectivity_established (); + } +} + +void +ControlProtocolManager::register_request_buffer_factories () +{ + Glib::Threads::RWLock::ReaderLock lm (protocols_lock); + + for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { + + if ((*i)->descriptor == 0) { + warning << string_compose (_("Control protocol \"%1\" has no descriptor"), (*i)->name) << endmsg; + continue; + } + + if ((*i)->descriptor->request_buffer_factory) { + EventLoop::register_request_buffer_factory ((*i)->descriptor->name, (*i)->descriptor->request_buffer_factory); + } + } +} + +void +ControlProtocolManager::stripable_selection_changed (StripableNotificationListPtr sp) +{ + /* this sets up the (static) data structures owned by ControlProtocol + that are "shared" across all control protocols. + */ + + DEBUG_TRACE (DEBUG::Selection, string_compose ("Surface manager: selection changed, now %1 stripables\n", sp ? sp->size() : -1)); + StripableSelectionChanged (sp); /* EMIT SIGNAL */ + + /* now give each protocol the chance to respond to the selection change + */ + + { + Glib::Threads::RWLock::ReaderLock lm (protocols_lock); + + for (list::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) { + DEBUG_TRACE (DEBUG::Selection, string_compose ("selection change notification for surface \"%1\"\n", (*p)->name())); + (*p)->stripable_selection_changed (); + } + } +}