X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fardour%2Fcontrol_protocol_manager.cc;h=ca8f21e87959aa812cccb8831f8799e4edb9088c;hb=66163305317e8acf20c4a16b9709fc809d6a0ff9;hp=59001dce144f95c5b4be0fe7d9787cedf5503d36;hpb=1d75f753d8dd4c4230b8d209c03d77e623ecc505;p=ardour.git

diff --git a/libs/ardour/control_protocol_manager.cc b/libs/ardour/control_protocol_manager.cc
index 59001dce14..ca8f21e879 100644
--- a/libs/ardour/control_protocol_manager.cc
+++ b/libs/ardour/control_protocol_manager.cc
@@ -17,37 +17,55 @@
 
 */
 
-#include <dlfcn.h>
+#include <glibmm/module.h>
 
 #include <glibmm/fileutils.h>
 
 #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/session.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;
 using namespace PBD;
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 ControlProtocolManager* ControlProtocolManager::_instance = 0;
 const string ControlProtocolManager::state_node_name = X_("ControlProtocols");
 
+
+ControlProtocolInfo::~ControlProtocolInfo ()
+{
+	if (protocol && descriptor) {
+		descriptor->destroy (descriptor, protocol);
+		protocol = 0;
+	}
+
+	delete state; state = 0;
+
+	if (descriptor) {
+		delete (Glib::Module*) descriptor->module;
+		descriptor = 0;
+	}
+}
+
 ControlProtocolManager::ControlProtocolManager ()
 {
 }
 
 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);
@@ -69,50 +87,91 @@ ControlProtocolManager::set_session (Session* s)
 	SessionHandlePtr::set_session (s);
 
 	if (_session) {
-		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) {
 			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) 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);
+	}
+
+	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::session_going_away()
 {
 	SessionHandlePtr::session_going_away ();
+	/* Session::destroy() will explicitly call drop_protocols() so we don't
+	 * have to worry about that here.
+	 */
+}
 
-	{
-		Glib::Mutex::Lock lm (protocols_lock);
+void
+ControlProtocolManager::drop_protocols ()
+{
+	/* called explicitly by Session::destroy() so that we can clean up
+	 * before the process cycle stops and ports vanish.
+	 */
 
-		for (list<ControlProtocol*>::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) {
-			delete *p;
-		}
+	Glib::Threads::Mutex::Lock lm (protocols_lock);
 
-		control_protocols.clear ();
+	for (list<ControlProtocol*>::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) {
+		delete *p;
+	}
 
-		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;
-				(*p)->protocol = 0;
-			}
+	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;
+			(*p)->protocol = 0;
 		}
 	}
 }
@@ -128,11 +187,15 @@ ControlProtocolManager::instantiate (ControlProtocolInfo& cpi)
 
 	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;
@@ -140,13 +203,27 @@ ControlProtocolManager::instantiate (ControlProtocolInfo& cpi)
 
 	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;
 	}
 
@@ -158,10 +235,23 @@ ControlProtocolManager::teardown (ControlProtocolInfo& cpi)
 		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);
+	if (lock_required) {
+		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;
+		}
+	} else {
 		list<ControlProtocol*>::iterator p = find (control_protocols.begin(), control_protocols.end(), cpi.protocol);
 		if (p != control_protocols.end()) {
 			control_protocols.erase (p);
@@ -171,9 +261,18 @@ ControlProtocolManager::teardown (ControlProtocolInfo& cpi)
 	}
 
 	cpi.protocol = 0;
+
 	delete cpi.state;
 	cpi.state = 0;
-	dlclose (cpi.descriptor->module);
+	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;
 }
 
@@ -184,7 +283,7 @@ ControlProtocolManager::load_mandatory_protocols ()
 		return;
 	}
 
-	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) {
 		if ((*i)->mandatory && ((*i)->protocol == 0)) {
@@ -198,22 +297,45 @@ ControlProtocolManager::load_mandatory_protocols ()
 void
 ControlProtocolManager::discover_control_protocols ()
 {
-	vector<sys::path> cp_modules;
+	vector<std::string> 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);
+	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);
 
-	find_matching_files_in_search_path (control_protocol_search_path (),
-					    dylib_extension_pattern, cp_modules);
+	DEBUG_TRACE (DEBUG::ControlProtocols,
+		     string_compose (_("looking for control protocols in %1\n"), control_protocol_search_path().to_string()));
 
-	DEBUG_TRACE (DEBUG::ControlProtocols, 
-		     string_compose (_("looking for control protocols in %1"), control_protocol_search_path().to_string()));
-	
-	for (vector<sys::path>::iterator i = cp_modules.begin(); i != cp_modules.end(); ++i) {
-		control_protocol_discover ((*i).to_string());
+	for (vector<std::string>::iterator i = cp_modules.begin(); i != cp_modules.end(); ++i) {
+		control_protocol_discover (*i);
 	}
 }
 
@@ -222,18 +344,19 @@ ControlProtocolManager::control_protocol_discover (string path)
 {
 	ControlProtocolDescriptor* descriptor;
 
-	/* don't load shared objects that are just symlinks to the real thing.
+#ifdef __APPLE__
+	/* don't load OS X shared objects that are just symlinks to the real thing.
 	 */
 
-	if (Glib::file_test (path, Glib::FILE_TEST_IS_SYMLINK)) {
+	if (path.find (".dylib") && Glib::file_test (path, Glib::FILE_TEST_IS_SYMLINK)) {
 		return 0;
 	}
+#endif
 
 	if ((descriptor = get_descriptor (path)) != 0) {
 
 		if (!descriptor->probe (descriptor)) {
-			DEBUG_TRACE (DEBUG::ControlProtocols,
-				     string_compose (_("Control protocol %1 not usable"), descriptor->name));
+			warning << string_compose (_("Control protocol %1 not usable"), descriptor->name) << endmsg;
 		} else {
 
 			ControlProtocolInfo* cpi = new ControlProtocolInfo ();
@@ -249,11 +372,9 @@ ControlProtocolManager::control_protocol_discover (string path)
 
 			control_protocol_info.push_back (cpi);
 
-			DEBUG_TRACE (DEBUG::ControlProtocols, 
-				     string_compose(_("Control surface protocol discovered: \"%1\""), cpi->name));
+			DEBUG_TRACE (DEBUG::ControlProtocols,
+				     string_compose(_("Control surface protocol discovered: \"%1\"\n"), cpi->name));
 		}
-
-		dlclose (descriptor->module);
 	}
 
 	return 0;
@@ -262,31 +383,29 @@ 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;
@@ -316,39 +435,54 @@ ControlProtocolManager::set_state (const XMLNode& node, int /*version*/)
 {
 	XMLNodeList clist;
 	XMLNodeConstIterator citer;
-	XMLProperty* prop;
+	XMLProperty const * prop;
 
-	Glib::Mutex::Lock lm (protocols_lock);
+	Glib::Threads::Mutex::Lock lm (protocols_lock);
 
 	clist = node.children();
 
 	for (citer = clist.begin(); citer != clist.end(); ++citer) {
-		if ((*citer)->name() == X_("Protocol")) {
+		XMLNode const * child = *citer;
+
+		if (child->name() == X_("Protocol")) {
+
+			if ((prop = child->property (X_("active"))) == 0) {
+				continue;
+			}
 
-			prop = (*citer)->property (X_("active"));
+			bool active = string_is_affirmative (prop->value());
 
-			if (prop && string_is_affirmative (prop->value())) {
-				if ((prop = (*citer)->property (X_("name"))) != 0) {
-					ControlProtocolInfo* cpi = cpi_by_name (prop->value());
+			if ((prop = child->property (X_("name"))) == 0) {
+				continue;
+			}
 
-					if (cpi) {
+			ControlProtocolInfo* cpi = cpi_by_name (prop->value());
 
-						if (cpi->state) {
-							delete cpi->state;
-						}
+			if (cpi) {
+				delete cpi->state;
+				cpi->state = new XMLNode (**citer);
 
-						cpi->state = new XMLNode (**citer);
+				std::cerr << "protocol " << prop->value() << " active ? " << active << std::endl;
 
-						if (_session) {
-							instantiate (*cpi);
-						} else {
-							cpi->requested = true;
-						}
+				if (active) {
+					if (_session) {
+						instantiate (*cpi);
+					} else {
+						cpi->requested = true;
+					}
+				} else {
+					if (_session) {
+						teardown (*cpi, true);
+					} else {
+						cpi->requested = false;
 					}
 				}
+			} else {
+				std::cerr << "protocol " << prop->value() << " not found\n";
 			}
 		}
 	}
+
 	return 0;
 }
 
@@ -356,61 +490,30 @@ XMLNode&
 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) {
 
-		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);
+			XMLNode& child_state ((*i)->protocol->get_state());
+			child_state.add_property (X_("active"), "yes");
+			root->add_child_nocopy (child_state);
 		} else if ((*i)->state) {
-			// keep ownership clear
-			root->add_child_copy (*(*i)->state);
+			XMLNode* child_state = new XMLNode (*(*i)->state);
+			child_state->add_property (X_("active"), "no");
+			root->add_child_nocopy (*child_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 = 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());
-
-		if (!cpi) {
-			warning << string_compose (_("control protocol \"%1\" is not known. Ignored"), prop->value()) << endmsg;
-			continue;
-		}
-
-		/* copy the node so that ownership is clear */
-
-		cpi->state = new XMLNode (*child);
-	}
-}
 
 ControlProtocolManager&
 ControlProtocolManager::instance ()
@@ -425,9 +528,27 @@ ControlProtocolManager::instance ()
 void
 ControlProtocolManager::midi_connectivity_established ()
 {
-	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) {
 		(*p)->midi_connectivity_established ();
 	}
 }
+
+void
+ControlProtocolManager::register_request_buffer_factories ()
+{
+	Glib::Threads::Mutex::Lock lm (protocols_lock);
+
+	for (list<ControlProtocolInfo*>::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);
+		}
+	}
+}