/*
- 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
*/
-#include <dlfcn.h>
+#include <glibmm/module.h>
+
+#include <glibmm/fileutils.h>
#include "pbd/compose.h"
#include "pbd/file_utils.h"
#include "pbd/error.h"
-#include <control_protocol/control_protocol.h>
+#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"
+
using namespace ARDOUR;
using namespace std;
using namespace PBD;
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<ControlProtocol*>::iterator i = control_protocols.begin(); i != control_protocols.end(); ++i) {
delete (*i);
control_protocols.clear ();
-
+
for (list<ControlProtocolInfo*>::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) {
delete (*p);
}
}
void
-ControlProtocolManager::set_session (Session& s)
+ControlProtocolManager::set_session (Session* s)
{
- _session = &s;
- _session->GoingAway.connect (mem_fun (*this, &ControlProtocolManager::drop_session));
-
- for (list<ControlProtocolInfo*>::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 && (*i)->state) {
- (*i)->protocol->set_state (*(*i)->state);
+ SessionHandlePtr::set_session (s);
+
+ if (_session) {
+ Glib::Threads::Mutex::Lock lm (protocols_lock);
+
+ for (list<ControlProtocolInfo*>::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<ControlProtocol*>::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) {
delete *p;
}
+
control_protocols.clear ();
-
+
for (list<ControlProtocolInfo*>::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;
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;
}
}
cpi.descriptor->destroy (cpi.descriptor, cpi.protocol);
-
+
{
- Glib::Mutex::Lock lm (protocols_lock);
+ Glib::Threads::Mutex::Lock lm (protocols_lock);
list<ControlProtocol*>::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<ControlProtocolInfo*>::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;
}
return;
}
+ Glib::Threads::Mutex::Lock lm (protocols_lock);
+
for (list<ControlProtocolInfo*>::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 ()
{
- vector<sys::path> cp_modules;
+ vector<std::string> cp_modules;
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);
+ so_extension_pattern, cp_modules);
find_matching_files_in_search_path (control_protocol_search_path (),
- dylib_extension_pattern, cp_modules);
+ dylib_extension_pattern, cp_modules);
- info << string_compose (_("looking for control protocols in %1"), control_protocol_search_path().to_string()) << endmsg;
-
- for (vector<sys::path>::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<std::string>::iterator i = cp_modules.begin(); i != cp_modules.end(); ++i) {
+ control_protocol_discover (*i);
}
}
{
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->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;
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<void,const ControlProtocolInfo*> method)
+ControlProtocolManager::foreach_known_protocol (boost::function<void(const ControlProtocolInfo*)> method)
{
for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
method (*i);
}
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 (!(*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<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
child->add_property (X_("active"), "yes");
// should we update (*i)->state here? probably.
root->add_child_nocopy (*child);
- }
- else if ((*i)->state) {
+ } else if ((*i)->state) {
// keep ownership clear
root->add_child_copy (*(*i)->state);
- }
- else {
+ } else {
child = new XMLNode (X_("Protocol"));
child->add_property (X_("name"), (*i)->name);
child->add_property (X_("active"), "no");
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<ControlProtocol*>::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) {
+ (*p)->midi_connectivity_established ();
}
}
projects / ardour.git / blobdiff