use shared_ptr to manage backend port lifetimes (Pulse,ALSA,Dummy,JACK)

JACK is not yet finished.

Changes also include minor reformatting and a spelling correction (latecies to latencies)

3 files changed, 62 insertions, 45 deletions

diff --git a/libs/backends/jack/jack_audiobackend.cc b/libs/backends/jack/jack_audiobackend.cc
index 9c4edfe078..d33d3d6c5f 100644
--- a/libs/backends/jack/jack_audiobackend.cc
+++ b/libs/backends/jack/jack_audiobackend.cc
@@ -1086,7 +1086,8 @@ JACKAudioBackend::n_physical (unsigned long flags) const
 	if (ports) {
 		for (uint32_t i = 0; ports[i]; ++i) {
 			if (!strstr (ports[i], "Midi-Through")) {
-				DataType t = port_data_type (jack_port_by_name (_priv_jack, ports[i]));
+				boost::shared_ptr<JackPort> jp (new JackPort (jack_port_by_name (_priv_jack, ports[i])));
+				DataType t = port_data_type (jp);
 				if (t != DataType::NIL) {
 					c.set (t, c.get (t) + 1);
 				}
diff --git a/libs/backends/jack/jack_audiobackend.h b/libs/backends/jack/jack_audiobackend.h
index 2e6498a012..11c41f4c46 100644
--- a/libs/backends/jack/jack_audiobackend.h
+++ b/libs/backends/jack/jack_audiobackend.h
@@ -39,6 +39,16 @@ namespace ARDOUR {
 class JackConnection;
 class JACKSession;
 
+class JackPort : public ProtoPort
+{
+  public:
+	JackPort (jack_port_t* p) : jack_ptr (p) {}
+
+  private:
+	friend class JACKAudioBackend;
+	jack_port_t* jack_ptr;
+};
+
 class JACKAudioBackend : public AudioBackend {
   public:
     JACKAudioBackend (AudioEngine& e, AudioBackendInfo& info, boost::shared_ptr<JackConnection>);
@@ -133,7 +143,7 @@ class JACKAudioBackend : public AudioBackend {
     int         set_port_name (PortHandle, const std::string&);
     std::string get_port_name (PortHandle) const;
     PortFlags get_port_flags (PortHandle) const;
-    PortHandle  get_port_by_name (const std::string&) const;
+    PortPtr  get_port_by_name (const std::string&) const;
     int get_port_property (PortHandle, const std::string& key, std::string& value, std::string& type) const;
     int set_port_property (PortHandle, const std::string& key, const std::string& value, const std::string& type);
 
@@ -141,7 +151,7 @@ class JACKAudioBackend : public AudioBackend {
 
     DataType port_data_type (PortHandle) const;
 
-    PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
+    PortPtr register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
     void  unregister_port (PortHandle);
 
     bool  connected (PortHandle, bool process_callback_safe);
@@ -310,4 +320,3 @@ class JACKAudioBackend : public AudioBackend {
 } // namespace
 
 #endif /* __ardour_audiobackend_h__ */
-
diff --git a/libs/backends/jack/jack_portengine.cc b/libs/backends/jack/jack_portengine.cc
index 362b97c952..488d900da5 100644
--- a/libs/backends/jack/jack_portengine.cc
+++ b/libs/backends/jack/jack_portengine.cc
@@ -109,25 +109,25 @@ JACKAudioBackend::set_port_name (PortHandle port, const std::string& name)
 #if HAVE_JACK_PORT_RENAME
 	jack_client_t* client = _jack_connection->jack();
 	if (client) {
-		return jack_port_rename (client, (jack_port_t*) port, name.c_str());
+		return jack_port_rename (client, boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr, name.c_str());
 	} else {
 		return -1;
 	}
 #else
-	return jack_port_set_name ((jack_port_t*) port, name.c_str());
+	return jack_port_set_name (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr, name.c_str());
 #endif
 }
 
 string
 JACKAudioBackend::get_port_name (PortHandle port) const
 {
-	return jack_port_name ((jack_port_t*) port);
+	return jack_port_name (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr);
 }
 
 PortFlags
 JACKAudioBackend::get_port_flags (PortHandle port) const
 {
-	return PortFlags (jack_port_flags ((jack_port_t*) port));
+	return PortFlags (jack_port_flags (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr));
 }
 
 int
@@ -138,8 +138,8 @@ JACKAudioBackend::get_port_property (PortHandle port, const std::string& key, st
 	char *cvalue = NULL;
 	char *ctype = NULL;
 
-	jack_uuid_t uuid = jack_port_uuid((jack_port_t*) port);
-	rv = jack_get_property(uuid, key.c_str(), &cvalue, &ctype);
+	jack_uuid_t uuid = jack_port_uuid (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr);
+	rv = jack_get_property (uuid, key.c_str(), &cvalue, &ctype);
 
 	if (0 == rv && cvalue) {
 		value = cvalue;
@@ -164,7 +164,7 @@ JACKAudioBackend::set_port_property (PortHandle port, const std::string& key, co
 #ifdef HAVE_JACK_METADATA // really everyone ought to have this by now.
 	int rv = -1;
 	jack_client_t* client = _jack_connection->jack();
-	jack_uuid_t uuid = jack_port_uuid((jack_port_t*) port);
+	jack_uuid_t uuid = jack_port_uuid (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr);
 	return jack_set_property(client, uuid, key.c_str(), value.c_str(), type.c_str());
 	return rv;
 #else
@@ -172,11 +172,11 @@ JACKAudioBackend::set_port_property (PortHandle port, const std::string& key, co
 #endif
 }
 
-PortEngine::PortHandle
+PortEngine::PortPtr
 JACKAudioBackend:: get_port_by_name (const std::string& name) const
 {
 	GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
-	return (PortHandle) jack_port_by_name (_priv_jack, name.c_str());
+	return boost::shared_ptr<ProtoPort> (new JackPort (jack_port_by_name (_priv_jack, name.c_str())));
 }
 
 void
@@ -213,17 +213,17 @@ JACKAudioBackend::connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, in
 }
 
 bool
-JACKAudioBackend::connected (PortHandle port, bool process_callback_safe)
+JACKAudioBackend::connected (PortHandle p, bool process_callback_safe)
 {
 	bool ret = false;
-
+	jack_port_t* port = boost::dynamic_pointer_cast<JackPort>(p)->jack_ptr;
 	const char** ports;
 
 	if (process_callback_safe) {
-		ports = jack_port_get_connections ((jack_port_t*)port);
+		ports = jack_port_get_connections (port);
 	} else {
 		GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
-		ports = jack_port_get_all_connections (_priv_jack, (jack_port_t*)port);
+		ports = jack_port_get_all_connections (_priv_jack, port);
 	}
 
 	if (ports) {
@@ -236,16 +236,17 @@ JACKAudioBackend::connected (PortHandle port, bool process_callback_safe)
 }
 
 bool
-JACKAudioBackend::connected_to (PortHandle port, const std::string& other, bool process_callback_safe)
+JACKAudioBackend::connected_to (PortHandle p, const std::string& other, bool process_callback_safe)
 {
 	bool ret = false;
 	const char** ports;
+	jack_port_t* port = boost::dynamic_pointer_cast<JackPort>(p)->jack_ptr;
 
 	if (process_callback_safe) {
-		ports = jack_port_get_connections ((jack_port_t*)port);
+		ports = jack_port_get_connections (port);
 	} else {
 		GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
-		ports = jack_port_get_all_connections (_priv_jack, (jack_port_t*)port);
+		ports = jack_port_get_all_connections (_priv_jack, port);
 	}
 
 	if (ports) {
@@ -264,7 +265,7 @@ bool
 JACKAudioBackend::physically_connected (PortHandle p, bool process_callback_safe)
 {
 	GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
-	jack_port_t* port = (jack_port_t*) p;
+	jack_port_t* port = boost::dynamic_pointer_cast<JackPort>(p)->jack_ptr;
 
 	const char** ports;
 
@@ -295,7 +296,7 @@ bool
 JACKAudioBackend::externally_connected (PortHandle p, bool process_callback_safe)
 {
 	GET_PRIVATE_JACK_POINTER_RET (_priv_jack, false);
-	jack_port_t* port = (jack_port_t*) p;
+	jack_port_t* port = boost::dynamic_pointer_cast<JackPort>(p)->jack_ptr;
 
 	const char** ports;
 
@@ -325,15 +326,16 @@ JACKAudioBackend::externally_connected (PortHandle p, bool process_callback_safe
 }
 
 int
-JACKAudioBackend::get_connections (PortHandle port, vector<string>& s, bool process_callback_safe)
+JACKAudioBackend::get_connections (PortHandle p, vector<string>& s, bool process_callback_safe)
 {
 	const char** ports;
+	jack_port_t* port = boost::dynamic_pointer_cast<JackPort>(p)->jack_ptr;
 
 	if (process_callback_safe) {
-		ports = jack_port_get_connections ((jack_port_t*)port);
+		ports = jack_port_get_connections (port);
 	} else {
 		GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
-		ports = jack_port_get_all_connections (_priv_jack, (jack_port_t*)port);
+		ports = jack_port_get_all_connections (_priv_jack, port);
 	}
 
 	if (ports) {
@@ -347,9 +349,9 @@ JACKAudioBackend::get_connections (PortHandle port, vector<string>& s, bool proc
 }
 
 DataType
-JACKAudioBackend::port_data_type (PortHandle p) const
+JACKAudioBackend::port_data_type (PortHandle port) const
 {
-	return jack_port_type_to_ardour_data_type (jack_port_type ((jack_port_t*) p));
+	return jack_port_type_to_ardour_data_type (jack_port_type (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr));
 }
 
 const string&
@@ -359,13 +361,13 @@ JACKAudioBackend::my_name() const
 }
 
 bool
-JACKAudioBackend::port_is_physical (PortHandle ph) const
+JACKAudioBackend::port_is_physical (PortHandle port) const
 {
-	if (!ph) {
+	if (!port) {
                 return false;
         }
 
-        return jack_port_flags ((jack_port_t*) ph) & JackPortIsPhysical;
+	return jack_port_flags (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr) & JackPortIsPhysical;
 }
 
 int
@@ -461,41 +463,46 @@ JACKAudioBackend::can_monitor_input () const
 int
 JACKAudioBackend::request_input_monitoring (PortHandle port, bool yn)
 {
-	return jack_port_request_monitor ((jack_port_t*) port, yn);
+	return jack_port_request_monitor (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr, yn);
 }
 int
 JACKAudioBackend::ensure_input_monitoring (PortHandle port, bool yn)
 {
-	return jack_port_ensure_monitor ((jack_port_t*) port, yn);
+	return jack_port_ensure_monitor (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr, yn);
 }
 bool
 JACKAudioBackend::monitoring_input (PortHandle port)
 {
-	return jack_port_monitoring_input ((jack_port_t*) port);
+	return jack_port_monitoring_input (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr);
 }
 
-PortEngine::PortHandle
+PortEngine::PortPtr
 JACKAudioBackend::register_port (const std::string& shortname, ARDOUR::DataType type, ARDOUR::PortFlags flags)
 {
 	GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
-	return jack_port_register (_priv_jack, shortname.c_str(),
-				   ardour_data_type_to_jack_port_type (type),
-				   ardour_port_flags_to_jack_flags (flags),
-				   0);
+	jack_port_t* p = jack_port_register (_priv_jack, shortname.c_str(),
+	                                     ardour_data_type_to_jack_port_type (type),
+	                                     ardour_port_flags_to_jack_flags (flags),
+	                                     0);
+	if (!p) {
+		return PortEngine::PortPtr();
+	}
+
+	return boost::shared_ptr<ProtoPort> (new JackPort (p));
 }
 
 void
 JACKAudioBackend::unregister_port (PortHandle port)
 {
 	GET_PRIVATE_JACK_POINTER (_priv_jack);
-	(void) jack_port_unregister (_priv_jack, (jack_port_t*) port);
+	(void) jack_port_unregister (_priv_jack, boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr);
 }
 
 int
 JACKAudioBackend::connect (PortHandle port, const std::string& other)
 {
 	GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
-	return jack_connect (_priv_jack, jack_port_name ((jack_port_t*) port), other.c_str());
+	return jack_connect (_priv_jack, jack_port_name (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr), other.c_str());
 }
 int
 JACKAudioBackend::connect (const std::string& src, const std::string& dst)
@@ -510,7 +517,7 @@ int
 JACKAudioBackend::disconnect (PortHandle port, const std::string& other)
 {
 	GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
-	return jack_disconnect (_priv_jack, jack_port_name ((jack_port_t*) port), other.c_str());
+	return jack_disconnect (_priv_jack, jack_port_name (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr), other.c_str());
 }
 
 int
@@ -524,7 +531,7 @@ int
 JACKAudioBackend::disconnect_all (PortHandle port)
 {
 	GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
-	return jack_port_disconnect (_priv_jack, (jack_port_t*) port);
+	return jack_port_disconnect (_priv_jack, boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr);
 }
 
 int
@@ -568,7 +575,7 @@ JACKAudioBackend::set_latency_range (PortHandle port, bool for_playback, Latency
 	range.min = r.min;
 	range.max = r.max;
 
-	jack_port_set_latency_range ((jack_port_t*) port, for_playback ? JackPlaybackLatency : JackCaptureLatency, &range);
+	jack_port_set_latency_range (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr, for_playback ? JackPlaybackLatency : JackCaptureLatency, &range);
 }
 
 LatencyRange
@@ -577,7 +584,7 @@ JACKAudioBackend::get_latency_range (PortHandle port, bool for_playback)
 	jack_latency_range_t range;
 	LatencyRange ret;
 
-	jack_port_get_latency_range ((jack_port_t*) port, for_playback ? JackPlaybackLatency : JackCaptureLatency, &range);
+	jack_port_get_latency_range (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr, for_playback ? JackPlaybackLatency : JackCaptureLatency, &range);
 
 	ret.min = range.min;
 	ret.max = range.max;
@@ -588,7 +595,7 @@ JACKAudioBackend::get_latency_range (PortHandle port, bool for_playback)
 void*
 JACKAudioBackend::get_buffer (PortHandle port, pframes_t nframes)
 {
-	return jack_port_get_buffer ((jack_port_t*) port, nframes);
+	return jack_port_get_buffer (boost::dynamic_pointer_cast<JackPort>(port)->jack_ptr, nframes);
 }
 
 uint32_t