X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fcontrol_protocol_manager.cc;h=2e65a8d6f89241e6f68ad37fff60bdf7ba467bb8;hb=7c719e441a834067c1b35e51f891fd4c1a252e76;hp=c2fb18895322398a462e6e874dc812c46a1602cc;hpb=7ff370e79895d7eb293e7214689b791bd98415fb;p=ardour.git diff --git a/libs/ardour/control_protocol_manager.cc b/libs/ardour/control_protocol_manager.cc index c2fb188953..2e65a8d6f8 100644 --- a/libs/ardour/control_protocol_manager.cc +++ b/libs/ardour/control_protocol_manager.cc @@ -1,13 +1,35 @@ +/* + 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 + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + 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 -#include +#include + +#include "pbd/compose.h" +#include "pbd/file_utils.h" +#include "pbd/error.h" -#include +#include "control_protocol/control_protocol.h" -#include -#include +#include "ardour/debug.h" +#include "ardour/control_protocol_manager.h" +#include "ardour/control_protocol_search_path.h" using namespace ARDOUR; using namespace std; @@ -20,75 +42,110 @@ 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); } control_protocols.clear (); - + + + for (list::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) { + 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)); - - for (list::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) { - if ((*i)->requested || (*i)->mandatory) { - instantiate (**i); - (*i)->requested = false; + SessionHandlePtr::set_session (s); + + if (_session) { + Glib::Threads::Mutex::Lock lm (protocols_lock); + + 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 ((*i)->protocol) { + if ((*i)->state) { + (*i)->protocol->set_state (*(*i)->state, Stateful::loading_state_version); + } else { + /* guarantee a call to + set_state() whether we have + existing state or not + */ + (*i)->protocol->set_state (XMLNode(""), Stateful::loading_state_version); + } + } + } } } } 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; + (*p)->protocol = 0; + } + } } } 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; } @@ -108,25 +165,25 @@ ControlProtocolManager::teardown (ControlProtocolInfo& cpi) } 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; } } - + cpi.protocol = 0; + delete cpi.state; + cpi.state = 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)); + ProtocolStatusChange (&cpi); + + return 0; } void @@ -136,30 +193,37 @@ 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); } } } void -ControlProtocolManager::discover_control_protocols (string path) +ControlProtocolManager::discover_control_protocols () { - vector *found; - PathScanner scanner; + vector cp_modules; - cerr << "looking for control protocols in " << path << endl; + Glib::PatternSpec so_extension_pattern("*.so"); + Glib::PatternSpec dylib_extension_pattern("*.dylib"); - found = scanner (path, protocol_filter, 0, false, true); + find_matching_files_in_search_path (control_protocol_search_path (), + so_extension_pattern, cp_modules); - for (vector::iterator i = found->begin(); i != found->end(); ++i) { - control_protocol_discover (**i); - delete *i; - } + find_matching_files_in_search_path (control_protocol_search_path (), + dylib_extension_pattern, cp_modules); - delete found; + 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 @@ -167,24 +231,37 @@ 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; cpi->protocol = 0; cpi->requested = false; 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); @@ -227,7 +304,7 @@ ControlProtocolManager::get_descriptor (string path) } 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); @@ -246,46 +323,100 @@ 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 && prop->value() == X_("yes")) { - if ((prop = (*citer)->property (X_("name"))) != 0) { - ControlProtocolInfo* cpi = cpi_by_name (prop->value()); - if (cpi) { - 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 = new XMLNode (X_("Protocol")); - child->add_property (X_("name"), (*i)->name); - child->add_property (X_("active"), (*i)->protocol ? "yes" : "no"); - root->add_child_nocopy (*child); + + 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); + } } return *root; } + + +ControlProtocolManager& +ControlProtocolManager::instance () +{ + if (_instance == 0) { + _instance = new ControlProtocolManager (); + } + + return *_instance; +} + +void +ControlProtocolManager::midi_connectivity_established () +{ + Glib::Threads::Mutex::Lock lm (protocols_lock); + + for (list::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) { + (*p)->midi_connectivity_established (); + } +}