substantive changes to allow the audio/MIDI setup dialog to change settings as intended

So far only tested with JACK backend, but expected to be more correct for other backends too

1 files changed, 259 insertions, 86 deletions

diff --git a/gtk2_ardour/engine_dialog.cc b/gtk2_ardour/engine_dialog.cc
index 5ed438111f..304a20a7b2 100644
--- a/gtk2_ardour/engine_dialog.cc
+++ b/gtk2_ardour/engine_dialog.cc
@@ -45,6 +45,7 @@
 #include "pbd/convert.h"
 #include "pbd/error.h"
 
+#include "ardour_ui.h"
 #include "engine_dialog.h"
 #include "gui_thread.h"
 #include "i18n.h"
@@ -78,6 +79,12 @@ EngineControl::EngineControl ()
 	, ignore_changes (0)
 	, _desired_sample_rate (0)
 {
+	if (!ARDOUR::AudioEngine::instance()->setup_required()) {
+		_have_control = false;
+	} else {
+		_have_control = true;
+	}
+
 	set_name (X_("AudioMIDISetup"));
 
 	build_notebook ();
@@ -600,15 +607,9 @@ EngineControl::device_changed ()
 
 	vector<float> sr = backend->available_sample_rates (device_name);
 	for (vector<float>::const_iterator x = sr.begin(); x != sr.end(); ++x) {
-		char buf[32];
-		if (fmod (*x, 1000.0f)) {
-			snprintf (buf, sizeof (buf), "%.1f kHz", (*x)/1000.0);
-		} else {
-			snprintf (buf, sizeof (buf), "%.0f kHz", (*x)/1000.0);
-		}
-		s.push_back (buf);
+		s.push_back (rate_as_string (*x));
 		if (*x == _desired_sample_rate) {
-			desired = buf;
+			desired = s.back();
 		}
 	}
 
@@ -630,12 +631,7 @@ EngineControl::device_changed ()
 	vector<uint32_t> bs = backend->available_buffer_sizes(device_name);
 	s.clear ();
 	for (vector<uint32_t>::const_iterator x = bs.begin(); x != bs.end(); ++x) {
-		char buf[32];
-		/* Translators: "samples" is always plural here, so no
-		   need for plural+singular forms.
-		*/
-		snprintf (buf, sizeof (buf), _("%u samples"), *x);
-		s.push_back (buf);
+		s.push_back (bufsize_as_string (*x));
 	}
 
 	if (!s.empty()) {
@@ -661,6 +657,29 @@ EngineControl::device_changed ()
 	push_state_to_backend (false);
 }	
 
+string
+EngineControl::rate_as_string (float r)
+{
+	char buf[32];
+	if (fmod (r, 1000.0f)) {
+		snprintf (buf, sizeof (buf), "%.1f kHz", r/1000.0);
+	} else {
+		snprintf (buf, sizeof (buf), "%.0f kHz", r/1000.0);
+	}
+	return buf;
+}
+
+string
+EngineControl::bufsize_as_string (uint32_t sz)
+{
+	/* Translators: "samples" is always plural here, so no
+	   need for plural+singular forms.
+	*/
+	char buf[32];
+	snprintf (buf, sizeof (buf), _("%u samples"), sz);
+	return buf;
+}
+
 void 
 EngineControl::sample_rate_changed ()
 {
@@ -673,7 +692,6 @@ EngineControl::sample_rate_changed ()
 	*/
 
 	show_buffer_duration ();
-	push_state_to_backend (false);
 	save_state ();
 
 }
@@ -686,7 +704,6 @@ EngineControl::buffer_size_changed ()
 	}
 
 	show_buffer_duration ();
-	push_state_to_backend (false);
 	save_state ();
 }
 
@@ -765,15 +782,7 @@ EngineControl::save_state ()
 		state = new State;
 	}
 	
-	state->backend = backend_combo.get_active_text ();
-	state->driver = driver_combo.get_active_text ();
-	state->device = device_combo.get_active_text ();
-	state->buffer_size = buffer_size_combo.get_active_text ();
-	state->sample_rate = sample_rate_combo.get_active_text ();
-	state->input_latency = (uint32_t) input_latency.get_value();
-	state->output_latency = (uint32_t) output_latency.get_value();
-	state->input_channels = (uint32_t) input_channels.get_value();
-	state->output_channels = (uint32_t) output_channels.get_value();
+	store_state (*state);
 
 	if (!existing) {
 		states.push_back (*state);
@@ -783,6 +792,20 @@ EngineControl::save_state ()
 }
 
 void
+EngineControl::store_state (State& state)
+{
+	state.backend = get_backend ();
+	state.driver = get_driver ();
+	state.device = get_device_name ();
+	state.sample_rate = get_rate ();
+	state.buffer_size = get_buffer_size ();
+	state.input_latency = get_input_latency ();
+	state.output_latency = get_output_latency ();
+	state.input_channels = get_input_channels ();
+	state.output_channels = get_output_channels ();
+}
+
+void
 EngineControl::maybe_display_saved_state ()
 {
 	State* state = get_saved_state_for_currently_displayed_backend_and_device ();
@@ -790,9 +813,9 @@ EngineControl::maybe_display_saved_state ()
 	if (state) {
 		ignore_changes++;
 		if (!_desired_sample_rate) {
-			sample_rate_combo.set_active_text (state->sample_rate);
+			sample_rate_combo.set_active_text (rate_as_string (state->sample_rate));
 		}
-		buffer_size_combo.set_active_text (state->buffer_size);
+		buffer_size_combo.set_active_text (bufsize_as_string (state->buffer_size));
 		/* call this explicitly because we're ignoring changes to
 		   the controls at this point.
 		*/
@@ -890,12 +913,12 @@ EngineControl::set_state (const XMLNode& root)
 			if ((prop = grandchild->property ("sample-rate")) == 0) {
 				continue;
 			}
-			state.sample_rate = prop->value ();
+			state.sample_rate = atof (prop->value ());
 			
 			if ((prop = grandchild->property ("buffer-size")) == 0) {
 				continue;
 			}
-			state.buffer_size = prop->value ();
+			state.buffer_size = atoi (prop->value ());
 			
 			if ((prop = grandchild->property ("input-latency")) == 0) {
 				continue;
@@ -934,13 +957,11 @@ EngineControl::set_state (const XMLNode& root)
 			backend_combo.set_active_text ((*i).backend);
 			driver_combo.set_active_text ((*i).driver);
 			device_combo.set_active_text ((*i).device);
-			sample_rate_combo.set_active_text ((*i).sample_rate);
-			buffer_size_combo.set_active_text ((*i).buffer_size);
+			sample_rate_combo.set_active_text (rate_as_string ((*i).sample_rate));
+			buffer_size_combo.set_active_text (bufsize_as_string ((*i).buffer_size));
 			input_latency.set_value ((*i).input_latency);
 			output_latency.set_value ((*i).output_latency);
 			ignore_changes--;
-
-			push_state_to_backend (false);
 			break;
 		}
 	}
@@ -954,100 +975,249 @@ EngineControl::push_state_to_backend (bool start)
 
 	if (!backend) {
 		return 0;
-	 }
+	}
+	
+	/* figure out what is going to change */
+
+	bool restart_required = false;
+	bool was_running = ARDOUR::AudioEngine::instance()->running();
+	bool change_driver = false;
+	bool change_device = false;
+	bool change_rate = false;
+	bool change_bufsize = false;
+	bool change_latency = false;
+	bool change_channels = false;
 
-	/* grab the parameters from the GUI and apply them */
+	uint32_t ochan = get_output_channels ();
+	uint32_t ichan = get_input_channels ();
+
+	if (_have_control) {
+		
+		/* we can control the backend */
 
-	try {
 		if (backend->requires_driver_selection()) {
-			if (backend->set_driver (get_driver())) {
-				return -1;
+			if (get_driver() != backend->driver_name()) {
+				change_driver = true;
 			}
 		}
 
-		if (backend->set_device_name (get_device_name())) {
-			return -1;
+		if (get_device_name() != backend->device_name()) {
+			change_device = true;
 		}
 
-		if (backend->set_sample_rate (get_rate())) {
-			error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
-			return -1;
+		if (get_rate() != backend->sample_rate()) {
+			change_rate = true;
 		}
-		if (backend->set_buffer_size (get_buffer_size())) {
-			error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
-			return -1;
+
+		if (get_buffer_size() != backend->buffer_size()) {
+			change_bufsize = true;
 		}
-		if (backend->set_input_channels (get_input_channels())) {
-			error << string_compose (_("Cannot set input channels to %1"), get_input_channels()) << endmsg;
-			return -1;
+
+		/* zero-requested channels means "all available" */
+
+		if (ichan == 0) {
+			ichan = backend->input_channels();
 		}
-		if (backend->set_output_channels (get_output_channels())) {
-			error << string_compose (_("Cannot set output channels to %1"), get_output_channels()) << endmsg;
-			return -1;
+
+		if (ochan == 0) {
+			ochan = backend->output_channels();
 		}
-		if (backend->set_systemic_input_latency (get_input_latency())) {
-			error << string_compose (_("Cannot set input latency to %1"), get_input_latency()) << endmsg;
-			return -1;
+
+		if (ichan != backend->input_channels()) {
+			change_channels = true;
 		}
-		if (backend->set_systemic_output_latency (get_output_latency())) {
-			error << string_compose (_("Cannot set output latency to %1"), get_output_latency()) << endmsg;
-			return -1;
+
+		if (ochan != backend->output_channels()) {
+			change_channels = true;
+		}
+
+		if (get_input_latency() != backend->systemic_input_latency() ||
+		    get_output_latency() != backend->systemic_output_latency()) {
+			change_latency = true;
 		}
 
-		/* get a pointer to the current state object, creating one if
-		 * necessary
+	} else {
+
+		/* we have no control over the backend, meaning that we can
+		 * only possibly change sample rate and buffer size.
 		 */
 
-		State* state = get_saved_state_for_currently_displayed_backend_and_device ();
 
-		if (!state) {
-			state = save_state ();
-			assert (state);
+		if (get_rate() != backend->sample_rate()) {
+			change_bufsize = true;
 		}
 
-		/* all off */
-
-		for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
-			(*i).active = false;
+		if (get_buffer_size() != backend->buffer_size()) {
+			change_bufsize = true;
 		}
+	}
+
+	if (!_have_control) {
 
-		/* mark this one active (to be used next time the dialog is
-		 * shown)
+		/* We do not have control over the backend, so the best we can
+		 * do is try to change the sample rate and/or bufsize and get
+		 * out of here.
 		 */
 
-		state->active = true;
+		if (change_rate) {
+			if (!backend->can_change_sample_rate_when_running()) {
+				return 1;
+			}
+		} 
+		if (change_bufsize) {
+			if (!backend->can_change_buffer_size_when_running()) {
+				return 1;
+			}
+		}
 		
-		if (start) {
-			if (ARDOUR::AudioEngine::instance()->start()) {
+		if (change_rate) {
+			backend->set_sample_rate (get_rate());
+		}
+		
+		if (change_bufsize) {
+			backend->set_buffer_size (get_buffer_size());
+		}
+
+		post_push ();
+
+		return 0;
+	} 
+
+	/* determine if we need to stop the backend before changing parameters */
+
+	if (change_driver || change_device || change_channels || change_latency ||
+	    (change_rate && !backend->can_change_sample_rate_when_running()) ||
+	    (change_bufsize && !backend->can_change_buffer_size_when_running())) {
+		restart_required = true;
+	} else {
+		restart_required = false;
+	}
+
+	if (was_running) {
+
+		if (!change_driver && !change_device && !change_channels && !change_latency) {
+			/* no changes in any parameters that absolutely require a
+			 * restart, so check those that might be changeable without a
+			 * restart
+			 */
+			
+			if (change_rate && !backend->can_change_sample_rate_when_running()) {
+				/* can't do this while running ... */
+				restart_required = true;
+			}
+
+			if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
+				/* can't do this while running ... */
+				restart_required = true;
+			}
+		}
+	}
+
+	if (was_running) {
+		if (restart_required) {
+			if (ARDOUR_UI::instance()->disconnect_from_engine ()) {
 				return -1;
 			}
+		}
+	}
+		
 
-			/* schedule a redisplay of MIDI ports */
+	if (change_driver && backend->set_driver (get_driver())) {
+		error << string_compose (_("Cannot set driver to %1"), get_driver()) << endmsg;
+		return -1;
+	}
+	if (change_device && backend->set_device_name (get_device_name())) {
+		error << string_compose (_("Cannot set device name to %1"), get_device_name()) << endmsg;
+		return -1;
+	}
+	if (change_rate && backend->set_sample_rate (get_rate())) {
+		error << string_compose (_("Cannot set sample rate to %1"), get_rate()) << endmsg;
+		return -1;
+	}
+	if (change_bufsize && backend->set_buffer_size (get_buffer_size())) {
+		error << string_compose (_("Cannot set buffer size to %1"), get_buffer_size()) << endmsg;
+		return -1;
+	}
 
-			Glib::signal_timeout().connect (sigc::bind_return (sigc::mem_fun (*this, &EngineControl::refresh_midi_display), false), 1000);
+	if (change_channels || get_input_channels() == 0 || get_output_channels() == 0) {
+		if (backend->set_input_channels (get_input_channels())) {
+			error << string_compose (_("Cannot set input channels to %1"), get_input_channels()) << endmsg;
+			return -1;
+		}
+		if (backend->set_output_channels (get_output_channels())) {
+			error << string_compose (_("Cannot set output channels to %1"), get_output_channels()) << endmsg;
+			return -1;
+		}
+	}
+	if (change_latency) {
+		if (backend->set_systemic_input_latency (get_input_latency())) {
+			error << string_compose (_("Cannot set input latency to %1"), get_input_latency()) << endmsg;
+			return -1;
+		}
+		if (backend->set_systemic_output_latency (get_output_latency())) {
+			error << string_compose (_("Cannot set output latency to %1"), get_output_latency()) << endmsg;
+			return -1;
+		}
+	}
+			
+	if (start || (was_running && restart_required)) {
+		if (ARDOUR_UI::instance()->reconnect_to_engine()) {
+			return -1;
 		}
+	}
+	
+	post_push ();
 
-		manage_control_app_sensitivity ();
-		return 0;
+	return 0;
+}
 
-	} catch (...) {
-		cerr << "exception thrown...\n";
-		return -1;
+void
+EngineControl::post_push ()
+{
+	/* get a pointer to the current state object, creating one if
+	 * necessary
+	 */
+	
+	State* state = get_saved_state_for_currently_displayed_backend_and_device ();
+	
+	if (!state) {
+		state = save_state ();
+		assert (state);
 	}
+	
+	/* all off */
+	
+	for (StateList::iterator i = states.begin(); i != states.end(); ++i) {
+		(*i).active = false;
+	}
+	
+	/* mark this one active (to be used next time the dialog is
+	 * shown)
+	 */
+	
+	state->active = true;
+
+	manage_control_app_sensitivity ();
+
+	/* schedule a redisplay of MIDI ports */
+	
+	Glib::signal_timeout().connect (sigc::bind_return (sigc::mem_fun (*this, &EngineControl::refresh_midi_display), false), 1000);
 }
 
-uint32_t
+
+float
 EngineControl::get_rate () const
 {
-	double r = atof (sample_rate_combo.get_active_text ());
+	float r = atof (sample_rate_combo.get_active_text ());
 	/* the string may have been translated with an abbreviation for
 	 * thousands, so use a crude heuristic to fix this.
 	 */
 	if (r < 1000.0) {
 		r *= 1000.0;
 	}
-	return lrint (r);
+	return r;
 }
+	
 
 uint32_t
 EngineControl::get_buffer_size () const
@@ -1087,6 +1257,12 @@ EngineControl::get_output_latency() const
 }
 
 string
+EngineControl::get_backend () const
+{
+	return backend_combo.get_active_text ();
+}
+
+string
 EngineControl::get_driver () const
 {
 	return driver_combo.get_active_text ();
@@ -1172,8 +1348,6 @@ EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
 			input_latency.set_value (0);
 			output_latency.set_value (0);
 			
-			push_state_to_backend (false);
-
 			/* reset control */
 
 			input_latency.set_value (il);
@@ -1219,7 +1393,6 @@ EngineControl::check_latency_measurement ()
         }
 
 	uint32_t frames_total = mtdm->del();
-	cerr << "total = " << frames_total << " delay = " << ARDOUR::AudioEngine::instance()->latency_signal_delay() << endl;
 	uint32_t extra = frames_total - ARDOUR::AudioEngine::instance()->latency_signal_delay();
 
         snprintf (buf, sizeof (buf), "%u samples %10.3lf ms", extra, extra * 1000.0f/sample_rate);