Merge branch 'master' into windows

13 files changed, 520 insertions, 208 deletions

diff --git a/gtk2_ardour/ardour.menus.in b/gtk2_ardour/ardour.menus.in
index 197b484698..9694556e56 100644
--- a/gtk2_ardour/ardour.menus.in
+++ b/gtk2_ardour/ardour.menus.in
@@ -494,21 +494,6 @@
       <menuitem action='ToggleGroupTabs'/>
       <menuitem action='show-marker-lines'/>
     </menu>
-    <menu name='JACK' action='JACK'>
-      <menuitem action='EngineDisconnect'/>
-      <menuitem action='EngineReconnect'/>
-      <menu name='Latency' action='Latency'>
-        <menuitem action='EngineLatency32'/>
-        <menuitem action='EngineLatency64'/>
-        <menuitem action='EngineLatency128'/>
-        <menuitem action='EngineLatency256'/>
-        <menuitem action='EngineLatency512'/>
-        <menuitem action='EngineLatency1024'/>
-        <menuitem action='EngineLatency2048'/>
-        <menuitem action='EngineLatency4096'/>
-        <menuitem action='EngineLatency8192'/>
-      </menu>
-    </menu>
     <menu action = 'WindowMenu'>
       <menuitem action='toggle-audio-midi-setup'/>
       <separator/>
diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index c3d3211db1..5dde7f977e 100644
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -3798,7 +3798,7 @@ audio may be played at the wrong sample rate.\n"), desired, PROGRAM_NAME, actual
         return 1;
 }
 
-void
+int
 ARDOUR_UI::disconnect_from_engine ()
 {
 	/* drop connection to AudioEngine::Halted so that we don't act
@@ -3807,24 +3807,28 @@ ARDOUR_UI::disconnect_from_engine ()
 	halt_connection.disconnect ();
 	
 	if (AudioEngine::instance()->stop ()) {
-		MessageDialog msg (*editor, _("Could not disconnect from JACK"));
+		MessageDialog msg (*editor, _("Could not disconnect from Audio/MIDI engine"));
 		msg.run ();
+		return -1;
 	} else {
 		AudioEngine::instance()->Halted.connect_same_thread (halt_connection, boost::bind (&ARDOUR_UI::engine_halted, this, _1, false));
 	}
 	
 	update_sample_rate (0);
+	return 0;
 }
 
-void
+int
 ARDOUR_UI::reconnect_to_engine ()
 {
 	if (AudioEngine::instance()->start ()) {
-		MessageDialog msg (*editor,  _("Could not reconnect to JACK"));
+		MessageDialog msg (*editor,  _("Could not reconnect to the Audio/MIDI engine"));
 		msg.run ();
+		return -1;
 	}
 	
 	update_sample_rate (0);
+	return 0;
 }
 
 void
diff --git a/gtk2_ardour/ardour_ui.h b/gtk2_ardour/ardour_ui.h
index 64309c7e38..0ca8cde907 100644
--- a/gtk2_ardour/ardour_ui.h
+++ b/gtk2_ardour/ardour_ui.h
@@ -289,6 +289,9 @@ class ARDOUR_UI : public Gtkmm2ext::UI, public ARDOUR::SessionHandlePtr
 
         const std::string& announce_string() const { return _announce_string; }
 
+        int disconnect_from_engine ();
+        int reconnect_to_engine ();
+
   protected:
 	friend class PublicEditor;
 
@@ -667,8 +670,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI, public ARDOUR::SessionHandlePtr
 	int pending_state_dialog ();
 	int sr_mismatch_dialog (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
 
-	void disconnect_from_engine ();
-	void reconnect_to_engine ();
 	void set_engine_buffer_size (ARDOUR::pframes_t);
 
 	Gtk::MenuItem* jack_disconnect_item;
diff --git a/gtk2_ardour/ardour_ui_ed.cc b/gtk2_ardour/ardour_ui_ed.cc
index 53ea7c02de..b64498fb33 100644
--- a/gtk2_ardour/ardour_ui_ed.cc
+++ b/gtk2_ardour/ardour_ui_ed.cc
@@ -183,39 +183,6 @@ ARDOUR_UI::install_actions ()
 	ActionManager::write_sensitive_actions.push_back (act);
 	ActionManager::session_sensitive_actions.push_back (act);
 
-	/* AudioEngine actions */
-
-	Glib::RefPtr<ActionGroup> engine_actions = ActionGroup::create (X_("Audio"));
-	ActionManager::register_action (engine_actions, X_("JACK"), _("JACK"));
-	ActionManager::register_action (engine_actions, X_("Latency"), _("Latency"));
-
-	act = ActionManager::register_action (engine_actions, X_("EngineReconnect"), _("Reconnect"), sigc::mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::reconnect_to_engine));
-	ActionManager::engine_opposite_sensitive_actions.push_back (act);
-
-	act = ActionManager::register_action (engine_actions, X_("EngineDisconnect"), _("Disconnect"), sigc::mem_fun (*(ARDOUR_UI::instance()), &ARDOUR_UI::disconnect_from_engine));
-	ActionManager::engine_sensitive_actions.push_back (act);
-
-	RadioAction::Group latency_group;
-
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency32"), X_("32"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 32));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency64"), X_("64"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 64));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency128"), X_("128"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 128));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency256"), X_("256"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 256));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency512"), X_("512"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 512));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency1024"), X_("1024"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 1024));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency2048"), X_("2048"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 2048));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency4096"), X_("4096"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 4096));
-	ActionManager::engine_sensitive_actions.push_back (act);
-	act = ActionManager::register_radio_action (engine_actions, latency_group, X_("EngineLatency8192"), X_("8192"), sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::set_engine_buffer_size), (pframes_t) 8192));
-	ActionManager::engine_sensitive_actions.push_back (act);
-
 	/* these actions are intended to be shared across all windows */
 
 	common_actions = ActionGroup::create (X_("Common"));
@@ -422,7 +389,6 @@ ARDOUR_UI::install_actions ()
 
 	ActionManager::add_action_group (shuttle_actions);
 	ActionManager::add_action_group (option_actions);
-	ActionManager::add_action_group (engine_actions);
 	ActionManager::add_action_group (transport_actions);
 	ActionManager::add_action_group (main_actions);
 	ActionManager::add_action_group (main_menu_actions);
diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index a0418892e7..fc4b6f4d6c 100644
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -365,6 +365,7 @@ Editor::Editor ()
 	location_loop_color = ARDOUR_UI::config()->canvasvar_LocationLoop.get();
 	location_punch_color = ARDOUR_UI::config()->canvasvar_LocationPunch.get();
 
+	zoom_focus = ZoomFocusLeft;
 	_edit_point = EditAtMouse;
 	_internal_editing = false;
 	current_canvas_cursor = 0;
@@ -373,8 +374,6 @@ Editor::Editor ()
 
 	_scroll_callbacks = 0;
 
-	zoom_focus = ZoomFocusLeft;
-	set_zoom_focus (ZoomFocusLeft);
 	zoom_range_clock->ValueChanged.connect (sigc::mem_fun(*this, &Editor::zoom_adjustment_changed));
 
 	bbt_label.set_name ("EditorRulerLabel");
@@ -635,6 +634,7 @@ Editor::Editor ()
 
 	setup_toolbar ();
 
+	set_zoom_focus (zoom_focus);
 	_snap_type = SnapToBeat;
 	set_snap_to (_snap_type);
 	_snap_mode = SnapOff;
diff --git a/gtk2_ardour/engine_dialog.cc b/gtk2_ardour/engine_dialog.cc
index 5fff838a6f..65fa7227a7 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"
@@ -57,6 +58,7 @@ using namespace Glib;
 
 EngineControl::EngineControl ()
 	: ArdourDialog (_("Audio/MIDI Setup"))
+	, basic_packer (9, 3)
 	, input_latency_adjustment (0, 0, 99999, 1)
 	, input_latency (input_latency_adjustment)
 	, output_latency_adjustment (0, 0, 99999, 1)
@@ -72,10 +74,17 @@ EngineControl::EngineControl ()
 	, lm_use_button (_("Use results"))
 	, lm_table (5, 2)
 	, have_lm_results (false)
-	, basic_packer (9, 3)
+	, midi_refresh_button (_("Refresh list"))
+	, aj_button (_("Start MIDI ALSA/JACK bridge"))
 	, 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 ();
@@ -237,8 +246,6 @@ EngineControl::build_notebook ()
 	control_app_button.show();
 	basic_vbox.pack_start (*hpacker);
 
-	midi_packer.set_border_width (12);
-
 	/* latency measurement tab */
 	
 	lm_title.set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("Latency Measurement Tool")));
@@ -323,7 +330,7 @@ EngineControl::build_notebook ()
 	/* pack it all up */
 
 	notebook.pages().push_back (TabElem (basic_vbox, _("Audio")));
-	notebook.pages().push_back (TabElem (midi_hbox, _("MIDI")));
+	notebook.pages().push_back (TabElem (midi_vbox, _("MIDI")));
 	notebook.pages().push_back (TabElem (lm_vbox, _("Latency")));
 	notebook.set_border_width (12);
 
@@ -383,6 +390,87 @@ EngineControl::enable_latency_tab ()
 }
 
 void
+EngineControl::setup_midi_tab_for_backend ()
+{
+	string backend = backend_combo.get_active_text ();
+
+	Gtkmm2ext::container_clear (midi_vbox);
+
+	midi_vbox.set_border_width (12);
+	midi_device_table.set_border_width (12);
+
+	if (backend == "JACK") {
+		setup_midi_tab_for_jack ();
+	}
+
+	midi_vbox.pack_start (midi_device_table, true, true);
+	midi_vbox.pack_start (midi_refresh_button, false, false);
+	midi_vbox.show_all ();
+
+	midi_refresh_button.signal_clicked().connect (sigc::mem_fun (*this, &EngineControl::refresh_midi_display));
+}
+
+void
+EngineControl::setup_midi_tab_for_jack ()
+{
+	midi_vbox.pack_start (aj_button, false, false);
+}	
+
+void
+EngineControl::refresh_midi_display ()
+{
+	boost::shared_ptr<ARDOUR::AudioBackend> backend = ARDOUR::AudioEngine::instance()->current_backend();
+	assert (backend);
+
+	vector<string> midi_inputs;
+	vector<string> midi_outputs;
+	int row  = 0;
+	AttachOptions xopt = AttachOptions (FILL|EXPAND);
+	Gtk::Label* l;
+
+	Gtkmm2ext::container_clear (midi_device_table);
+
+	backend->get_physical_inputs (ARDOUR::DataType::MIDI, midi_inputs);
+	backend->get_physical_outputs (ARDOUR::DataType::MIDI, midi_outputs);
+
+	midi_device_table.set_spacings (6);
+	midi_device_table.set_homogeneous (true);
+	midi_device_table.resize (midi_inputs.size() + midi_outputs.size() + 3, 1);
+
+	l = manage (new Label);
+	l->set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("MIDI Inputs")));
+	midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
+	l->set_alignment (0, 0.5);
+	row++;
+	l->show ();
+	
+	for (vector<string>::iterator p = midi_inputs.begin(); p != midi_inputs.end(); ++p) {
+		l = manage (new Label ((*p).substr ((*p).find_last_of (':') + 1)));
+		l->set_alignment (0, 0.5);
+		midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
+		l->show ();
+		row++;
+	}
+
+	row++; // extra row of spacing
+
+	l = manage (new Label);
+	l->set_markup (string_compose ("<span size=\"large\" weight=\"bold\">%1</span>", _("MIDI Outputs")));
+	midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
+	l->set_alignment (0, 0.5);
+	row++;
+	l->show ();
+
+	for (vector<string>::iterator p = midi_outputs.begin(); p != midi_outputs.end(); ++p) {
+		l = manage (new Label ((*p).substr ((*p).find_last_of (':') + 1)));
+		l->set_alignment (0, 0.5);
+		midi_device_table.attach (*l, 0, 1, row, row + 1, xopt, AttachOptions (0));
+		l->show ();
+		row++;
+	}
+}
+
+void
 EngineControl::backend_changed ()
 {
 	if (ignore_changes) {
@@ -397,6 +485,8 @@ EngineControl::backend_changed ()
 		return;
 	}
 
+	setup_midi_tab_for_backend ();
+
 	if (backend->requires_driver_selection()) {
 		vector<string> drivers = backend->enumerate_drivers();
 		driver_combo.set_sensitive (true);
@@ -517,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();
 		}
 	}
 
@@ -547,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()) {
@@ -578,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 ()
 {
@@ -590,7 +692,6 @@ EngineControl::sample_rate_changed ()
 	*/
 
 	show_buffer_duration ();
-	push_state_to_backend (false);
 	save_state ();
 
 }
@@ -603,7 +704,6 @@ EngineControl::buffer_size_changed ()
 	}
 
 	show_buffer_duration ();
-	push_state_to_backend (false);
 	save_state ();
 }
 
@@ -682,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);
@@ -700,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 ();
@@ -707,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.
 		*/
@@ -807,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;
@@ -851,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;
 		}
 	}
@@ -871,96 +975,246 @@ EngineControl::push_state_to_backend (bool start)
 
 	if (!backend) {
 		return 0;
-	 }
+	}
+	
+	/* figure out what is going to change */
 
-	/* grab the parameters from the GUI and apply them */
+	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;
+
+	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;
 		}
+	}
 
-		/* mark this one active (to be used next time the dialog is
-		 * shown)
+	if (!_have_control) {
+
+		/* 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 && !backend->can_change_sample_rate_when_running()) {
+			return 1;
+		}
+
+		if (change_bufsize && !backend->can_change_buffer_size_when_running()) {
+			return 1;
+		}
 		
-		if (start) {
-			if (ARDOUR::AudioEngine::instance()->start()) {
-				return -1;
-			}
+		if (change_rate) {
+			backend->set_sample_rate (get_rate());
+		}
+		
+		if (change_bufsize) {
+			backend->set_buffer_size (get_buffer_size());
 		}
 
-		manage_control_app_sensitivity ();
+		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;
+			}
+		}
+	}
 
-	} catch (...) {
-		cerr << "exception thrown...\n";
+	if (was_running) {
+		if (restart_required) {
+			if (ARDOUR_UI::instance()->disconnect_from_engine ()) {
+				return -1;
+			}
+		}
+	}
+		
+
+	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;
+	}
+
+	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 ();
+
+	return 0;
+}
+
+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
@@ -1000,6 +1254,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 ();
@@ -1051,6 +1311,21 @@ EngineControl::set_desired_sample_rate (uint32_t sr)
 void
 EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
 {
+	if (page_num == 0) {
+		cancel_button->set_sensitive (true);
+		ok_button->set_sensitive (true);
+		apply_button->set_sensitive (true);
+	} else {
+		cancel_button->set_sensitive (false);
+		ok_button->set_sensitive (false);
+		apply_button->set_sensitive (false);
+	}
+
+	if (page_num == 1) {
+		/* MIDI tab */
+		refresh_midi_display ();
+	}
+
 	if (page_num == 2) {
 		/* latency tab */
 
@@ -1070,13 +1345,12 @@ 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);
 			output_latency.set_value (ol);
-		}
+
+		} 
 
 		if (ARDOUR::AudioEngine::instance()->prepare_for_latency_measurement()) {
 			disable_latency_tab ();
@@ -1084,16 +1358,8 @@ EngineControl::on_switch_page (GtkNotebookPage*, guint page_num)
 
 		enable_latency_tab ();
 
-		cancel_button->set_sensitive (false);
-		ok_button->set_sensitive (false);
-		apply_button->set_sensitive (false);
-
 	} else {
 		ARDOUR::AudioEngine::instance()->stop_latency_detection();
-		
-		cancel_button->set_sensitive (true);
-		ok_button->set_sensitive (true);
-		apply_button->set_sensitive (true);
 	}
 }
 
@@ -1124,7 +1390,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);
diff --git a/gtk2_ardour/engine_dialog.h b/gtk2_ardour/engine_dialog.h
index 14724c8bfe..fcbdfe4cb8 100644
--- a/gtk2_ardour/engine_dialog.h
+++ b/gtk2_ardour/engine_dialog.h
@@ -54,7 +54,13 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
 
     /* core fields used by all backends */
 
+    Gtk::Table basic_packer;
+    Gtk::HBox basic_hbox;
+    Gtk::VBox basic_vbox;
+
     Gtk::ComboBoxText backend_combo;
+    Gtk::ComboBoxText driver_combo;
+    Gtk::ComboBoxText device_combo;
     Gtk::ComboBoxText sample_rate_combo;
     Gtk::ComboBoxText buffer_size_combo;
     Gtk::Label        buffer_size_duration_label;
@@ -88,34 +94,18 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     Gtk::Button* ok_button;
     Gtk::Button* apply_button;
 
-    /* JACK specific */
-    
-    Gtk::CheckButton realtime_button;
-    Gtk::CheckButton no_memory_lock_button;
-    Gtk::CheckButton unlock_memory_button;
-    Gtk::CheckButton soft_mode_button;
-    Gtk::CheckButton monitor_button;
-    Gtk::CheckButton force16bit_button;
-    Gtk::CheckButton hw_monitor_button;
-    Gtk::CheckButton hw_meter_button;
-    Gtk::CheckButton verbose_output_button;
+    /* MIDI Tab */
+
+    Gtk::VBox midi_vbox;
+    Gtk::Button midi_refresh_button;
+    Gtk::Table midi_device_table;
+
+    /* MIDI ... JACK */
     
-    Gtk::ComboBoxText preset_combo;
-    Gtk::ComboBoxText serverpath_combo;
-    Gtk::ComboBoxText driver_combo;
-    Gtk::ComboBoxText device_combo;
-    Gtk::ComboBoxText timeout_combo;
-    Gtk::ComboBoxText dither_mode_combo;
-    Gtk::ComboBoxText audio_mode_combo;
-    Gtk::ComboBoxText midi_driver_combo;
+    Gtk::CheckButton aj_button;
     
-    Gtk::Table basic_packer;
-    Gtk::Table midi_packer;
-    Gtk::HBox basic_hbox;
-    Gtk::VBox basic_vbox;
-    Gtk::HBox midi_hbox;
-
     uint32_t ignore_changes;
+    uint32_t _desired_sample_rate;
     
     static bool engine_running ();
     
@@ -125,7 +115,14 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     void buffer_size_changed ();
     void parameter_changed ();
 
-    uint32_t get_rate() const;
+    void setup_midi_tab_for_backend ();
+    void setup_midi_tab_for_jack ();
+    void refresh_midi_display ();
+    
+    std::string rate_as_string (float);
+    std::string bufsize_as_string (uint32_t);
+
+    float get_rate() const;
     uint32_t get_buffer_size() const;
     uint32_t get_input_channels() const;
     uint32_t get_output_channels() const;
@@ -133,6 +130,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     uint32_t get_output_latency() const;
     std::string get_device_name() const;
     std::string get_driver() const;
+    std::string get_backend() const;
 
     void device_changed ();
     void list_devices ();
@@ -142,15 +140,21 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
 	std::string backend;
 	std::string driver;
 	std::string device;
-	std::string sample_rate;
-	std::string buffer_size;
+	float sample_rate;
+	uint32_t buffer_size;
 	uint32_t input_latency;
 	uint32_t output_latency;
 	uint32_t input_channels;
 	uint32_t output_channels;
 	bool active;
 
-	State() : active (false) {};
+	State() 
+		: input_latency (0)
+		, output_latency (0)
+		, input_channels (0)
+		, output_channels (0)
+		, active (false) {}
+
     };
     
     typedef std::list<State> StateList;
@@ -163,6 +167,9 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     State* get_saved_state_for_currently_displayed_backend_and_device ();
     void maybe_display_saved_state ();
     State* save_state ();
+    void store_state (State&);
+
+    bool  _have_control;
 
     static bool print_channel_count (Gtk::SpinButton*);
 
@@ -173,7 +180,7 @@ class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
     void use_latency_button_clicked ();
     void manage_control_app_sensitivity ();
     int push_state_to_backend (bool start);
-    uint32_t _desired_sample_rate;
+    void post_push ();
 
     /* latency measurement */
     void latency_button_toggled ();
diff --git a/libs/ardour/ardour/audio_backend.h b/libs/ardour/ardour/audio_backend.h
index 4d57f0b43d..9052acd530 100644
--- a/libs/ardour/ardour/audio_backend.h
+++ b/libs/ardour/ardour/audio_backend.h
@@ -223,6 +223,11 @@ class AudioBackend : public PortEngine {
     virtual uint32_t     systemic_input_latency () const = 0;
     virtual uint32_t     systemic_output_latency () const = 0;
 
+    /** override this if this implementation returns true from
+     * requires_driver_selection()
+     */
+    virtual std::string  driver_name() const { return std::string(); }
+
     /** Return the name of a control application for the 
      * selected/in-use device. If no such application exists,
      * or if no device has been selected or is in-use,
diff --git a/libs/ardour/audioengine.cc b/libs/ardour/audioengine.cc
index ebebac5774..05fc469c77 100644
--- a/libs/ardour/audioengine.cc
+++ b/libs/ardour/audioengine.cc
@@ -1037,12 +1037,22 @@ AudioEngine::start_latency_detection ()
 	delete _mtdm;
 	_mtdm = 0;
 
+	/* find the ports we will connect to */
+
+	PortEngine::PortHandle* out = pe.get_port_by_name (_latency_output_name);
+	PortEngine::PortHandle* in = pe.get_port_by_name (_latency_input_name);
+
+	if (!out || !in) {
+		return;
+	}
+
 	/* create the ports we will use to read/write data */
 	
 	if ((_latency_output_port = pe.register_port ("latency_out", DataType::AUDIO, IsOutput)) == 0) {
 		return;
 	}
 	if (pe.connect (_latency_output_port, _latency_output_name)) {
+		pe.unregister_port (_latency_output_port);
 		return;
 	}
 
@@ -1058,9 +1068,9 @@ AudioEngine::start_latency_detection ()
 
 	LatencyRange lr;
 	_latency_signal_latency = 0;
-	lr = pe.get_latency_range (_latency_input_port, false);
+	lr = pe.get_latency_range (in, false);
 	_latency_signal_latency = lr.max;
-	lr = pe.get_latency_range (_latency_output_port, true);
+	lr = pe.get_latency_range (out, true);
 	_latency_signal_latency += lr.max;
 
 	/* all created and connected, lets go */
@@ -1076,9 +1086,14 @@ AudioEngine::stop_latency_detection ()
 {
 	_measuring_latency = false;
 
-	port_engine().unregister_port (_latency_output_port);
-	port_engine().unregister_port (_latency_input_port);
-	
+	if (_latency_output_port) {
+		port_engine().unregister_port (_latency_output_port);
+		_latency_output_port = 0;
+	}
+	if (_latency_input_port) {
+		port_engine().unregister_port (_latency_input_port);
+		_latency_input_port = 0;
+	}
 	if (_started_for_latency) {
 		stop ();
 	}
diff --git a/libs/backends/jack/jack_audiobackend.cc b/libs/backends/jack/jack_audiobackend.cc
index b3dbdcae71..1e7cb9d8d5 100644
--- a/libs/backends/jack/jack_audiobackend.cc
+++ b/libs/backends/jack/jack_audiobackend.cc
@@ -57,8 +57,8 @@ JACKAudioBackend::JACKAudioBackend (AudioEngine& e, boost::shared_ptr<JackConnec
 	, _target_buffer_size (1024)
 	, _target_sample_format (FormatFloat)
 	, _target_interleaved (false)
-	, _target_input_channels (-1)
-	, _target_output_channels (-1)
+	, _target_input_channels (0)
+	, _target_output_channels (0)
 	, _target_systemic_input_latency (0)
 	, _target_systemic_output_latency (0)
 	, _current_sample_rate (0)
@@ -292,7 +292,10 @@ int
 JACKAudioBackend::set_input_channels (uint32_t cnt)
 {
 	if (available()) {
-		return -1;
+		if (cnt != 0) {
+			/* can't set a real value for this while JACK runs */
+			return -1;
+		}
 	}
 
 	_target_input_channels = cnt;
@@ -304,7 +307,10 @@ int
 JACKAudioBackend::set_output_channels (uint32_t cnt)
 {
 	if (available()) {
-		return -1;
+		if (cnt != 0) {
+			/* can't set a real value for this while JACK runs */
+			return -1;
+		}
 	}
 
 	_target_output_channels = cnt;
@@ -316,6 +322,7 @@ int
 JACKAudioBackend::set_systemic_input_latency (uint32_t l)
 {
 	if (available()) {
+		/* can't do this while JACK runs */
 		return -1;
 	}
 
@@ -328,6 +335,7 @@ int
 JACKAudioBackend::set_systemic_output_latency (uint32_t l)
 {
 	if (available()) {
+		/* can't do this while JACK runs */
 		return -1;
 	}
 
@@ -341,18 +349,34 @@ JACKAudioBackend::set_systemic_output_latency (uint32_t l)
 std::string
 JACKAudioBackend::device_name () const
 {
-	if (available()) {
-		return "???";
+	if (!_jack_connection->in_control()) {
+		return "???"; // JACK has no way (as of fall 2013) to return
+			      // the device name
 	} 
 
 	return _target_device;
 }
 
+std::string
+JACKAudioBackend::driver_name() const
+{
+	if (!_jack_connection->in_control()) {
+		return "???"; // JACK has no way (as of fall 2013) to return
+			      // the driver name
+	}
+
+	return _target_driver;
+}
+
 float
 JACKAudioBackend::sample_rate () const
 {
-	if (available()) {
-		return _current_sample_rate;
+	if (!_jack_connection->in_control()) {
+		if (available()) {
+			return _current_sample_rate;
+		} else {
+			return 0;
+		}
 	}
 	return _target_sample_rate;
 }
@@ -360,8 +384,12 @@ JACKAudioBackend::sample_rate () const
 uint32_t
 JACKAudioBackend::buffer_size () const
 {
-	if (available()) {
-		return _current_buffer_size;
+	if (!_jack_connection->in_control()) {
+		if (available()) {
+			return _current_buffer_size;
+		} else {
+			return 0;
+		}
 	}
 	return _target_buffer_size;
 }
@@ -381,19 +409,37 @@ JACKAudioBackend::interleaved () const
 uint32_t
 JACKAudioBackend::input_channels () const
 {
-	if (available()) {
-		return n_physical (JackPortIsInput).n_audio();
-	} 
-	return _target_input_channels;
+	if (!_jack_connection->in_control()) {
+		if (available()) {
+			return n_physical (JackPortIsInput).n_audio();
+		} else {
+			return 0;
+		}
+	} else {
+		if (available()) {
+			return n_physical (JackPortIsInput).n_audio();
+		} else {
+			return _target_input_channels;
+		}
+	}
 }
 
 uint32_t
 JACKAudioBackend::output_channels () const
 {
-	if (available()) {
-		return n_physical (JackPortIsOutput).n_audio();
-	} 
-	return _target_output_channels;
+	if (!_jack_connection->in_control()) {
+		if (available()) {
+			return n_physical (JackPortIsOutput).n_audio();
+		} else {
+			return 0;
+		}
+	} else {
+		if (available()) {
+			return n_physical (JackPortIsOutput).n_audio();
+		} else {
+			return _target_output_channels;
+		}
+	}
 }
 
 uint32_t
diff --git a/libs/backends/jack/jack_audiobackend.h b/libs/backends/jack/jack_audiobackend.h
index 655c939c51..9ab545f3ee 100644
--- a/libs/backends/jack/jack_audiobackend.h
+++ b/libs/backends/jack/jack_audiobackend.h
@@ -85,6 +85,7 @@ class JACKAudioBackend : public AudioBackend {
     uint32_t     output_channels () const;
     uint32_t     systemic_input_latency () const;
     uint32_t     systemic_output_latency () const;
+    std::string  driver_name() const;
 
     std::string control_app_name () const;
     void launch_control_app ();
diff --git a/libs/backends/jack/jack_connection.cc b/libs/backends/jack/jack_connection.cc
index 7b3d35efa5..d5d25c747f 100644
--- a/libs/backends/jack/jack_connection.cc
+++ b/libs/backends/jack/jack_connection.cc
@@ -54,6 +54,7 @@ JackConnection::JackConnection (const std::string& arg1, const std::string& arg2
 	, _client_name (arg1)
 	, session_uuid (arg2)
 {
+	_in_control = !server_running();
 }
 
 JackConnection::~JackConnection ()
@@ -105,6 +106,19 @@ JackConnection::open ()
                 global_epa->restore ();
         }
 
+	/* check to see if the server is already running so that we know if we
+	 * are starting it.
+	 */
+
+	jack_client_t* c = jack_client_open ("ardourprobe", JackNoStartServer, &status);
+
+	if (status == 0) {
+		_in_control = false;
+		jack_client_close (c);
+	} else {
+		_in_control = true;
+	}
+
 	/* ensure that PATH or equivalent includes likely locations of the JACK
 	 * server, in case the user's default does not.
 	 */
diff --git a/libs/backends/jack/jack_connection.h b/libs/backends/jack/jack_connection.h
index cd45f3b9ba..229d9697d9 100644
--- a/libs/backends/jack/jack_connection.h
+++ b/libs/backends/jack/jack_connection.h
@@ -27,12 +27,15 @@ class JackConnection {
     void halted_callback ();
     void halted_info_callback (jack_status_t, const char*);
 
-    static bool server_running();
+    bool in_control() const { return _in_control; }
 
+    static bool server_running();
+    
   private:
     jack_client_t* volatile _jack;
     std::string _client_name;
     std::string session_uuid;
+    bool _in_control;
 };
 
 } // namespace