bring in more connection-related changes from Tracks

libs/ardour/ardour/midiport_manager.h

@@ -60,6 +60,9 @@ class LIBARDOUR_API MidiPortManager {
     MIDI::Port* scene_input_port () const { return _scene_input_port; }
     MIDI::Port* scene_output_port () const { return _scene_output_port; }
     
+    boost::shared_ptr<MidiPort> mmc_in() const { return boost::dynamic_pointer_cast<MidiPort>(_mmc_in); }
+    boost::shared_ptr<MidiPort> mmc_out() const { return boost::dynamic_pointer_cast<MidiPort>(_mmc_out); }
+
     boost::shared_ptr<MidiPort> scene_in() const { return boost::dynamic_pointer_cast<MidiPort>(_scene_in); }
     boost::shared_ptr<MidiPort> scene_out() const { return boost::dynamic_pointer_cast<MidiPort>(_scene_out); }
 

libs/ardour/ardour/session.h

@@ -996,6 +996,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	MIDI::MachineControl& mmc() { return *_mmc; }
 
 	void reconnect_midi_scene_ports (bool);
+	void reconnect_mtc_ports ();
+	void reconnect_mmc_ports (bool);
 
   protected:
 	friend class AudioEngine;

libs/ardour/engine_state_controller.cc

@@ -582,10 +582,10 @@ EngineStateController::_validate_current_device_state()
 	std::vector<pframes_t>::iterator bs_iter = std::find (buffer_sizes.begin(), buffer_sizes.end(), _current_state->buffer_size);
 	// if current is not found switch to default if is supported
 	if (bs_iter == buffer_sizes.end()) {
-		bs_iter = std::find (buffer_sizes.begin(), buffer_sizes.end(), backend->default_buffer_size ());
+		bs_iter = std::find (buffer_sizes.begin(), buffer_sizes.end(), backend->default_buffer_size (_current_state->device_name));
 	
 		if (bs_iter != buffer_sizes.end()) {
-			_current_state->buffer_size = backend->default_buffer_size ();
+			_current_state->buffer_size = backend->default_buffer_size (_current_state->device_name);
 		} else {
 			if (!buffer_sizes.empty()) {
 				_current_state->buffer_size = buffer_sizes.front();
@@ -665,7 +665,7 @@ EngineStateController::get_default_buffer_size() const
 {
 	boost::shared_ptr<AudioBackend> backend = AudioEngine::instance()->current_backend();
 	assert(backend);
-	return backend->default_buffer_size();
+	return backend->default_buffer_size(_current_state->device_name);
 }
 
 

libs/ardour/session.cc

@@ -46,6 +46,7 @@
 #include "pbd/search_path.h"
 #include "pbd/stacktrace.h"
 #include "pbd/stl_delete.h"
+#include "pbd/replace_all.h"
 #include "pbd/unwind.h"
 
 #include "ardour/amp.h"
@@ -404,7 +405,8 @@ Session::Session (AudioEngine &eng,
 				string track_name = "";
 				for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
 					string track_name;
-					remove_pattern_from_string(inputs[i], "system:capture:", track_name);
+					track_name = inputs[i];
+					replace_all (track_name, "system:capture", "");
 					
 					list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
 					tracks.insert(tracks.begin(), single_track.front());
@@ -2652,6 +2654,74 @@ Session::reconnect_midi_scene_ports(bool inputs)
     }
 }
 
+void
+Session::reconnect_mtc_ports()
+{
+#if 0
+	boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
+
+	if (mtc_in_ptr) {
+		mtc_in_ptr->disconnect_all ();
+        
+		std::vector<EngineStateController::MidiPortState> midi_port_states;
+		EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
+        
+		std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
+        
+		for (; state_iter != midi_port_states.end(); ++state_iter) {
+			if (state_iter->available && state_iter->mtc_in) {
+				mtc_in_ptr->connect (state_iter->name);
+			}
+		}
+        
+		if (!_midi_ports->mtc_input_port ()->connected () &&
+		    config.get_external_sync () &&
+		    (Config->get_sync_source () == MTC) ) {
+			config.set_external_sync (false);
+		}
+		if ( ARDOUR::Profile->get_trx () ) {
+			// Tracks need this signal to update timecode_source_dropdown
+			MtcOrLtcInputPortChanged (); //emit signal
+		}
+	}
+#endif
+}
+
+void
+Session::reconnect_mmc_ports(bool inputs)
+{
+	if (inputs ) { // get all enabled midi input ports
+        
+		boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
+		if (mmc_in_ptr) {
+			mmc_in_ptr->disconnect_all ();
+			std::vector<std::string> enabled_midi_inputs;
+			EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
+            
+			std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
+            
+			for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
+				mmc_in_ptr->connect (*port_iter);
+			}
+
+		}
+	} else { // get all enabled midi output ports
+        
+		boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
+		if (mmc_out_ptr ) {
+			mmc_out_ptr->disconnect_all ();
+			std::vector<std::string> enabled_midi_outputs;
+			EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
+            
+			std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
+            
+			for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
+				mmc_out_ptr->connect (*port_iter);
+			}
+		}
+	}
+}
+
 #endif
 
 /** Caller must not hold process lock