X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession.cc;h=4b30543cb018021dfd904314d89819926b4a194f;hb=300b484cf6ac14c15e365c4062345d64a61c4b18;hp=ccc694f8788a60a5490a32ed393c88a216d62cde;hpb=f6ac5cadeaa003b38f4695cedc3ff643ef9031c1;p=ardour.git

diff --git a/libs/ardour/session.cc b/libs/ardour/session.cc
index ccc694f878..4b30543cb0 100644
--- a/libs/ardour/session.cc
+++ b/libs/ardour/session.cc
@@ -44,11 +44,12 @@
 #include "pbd/stacktrace.h"
 #include "pbd/file_utils.h"
 #include "pbd/convert.h"
-#include "pbd/strsplit.h"
 #include "pbd/unwind.h"
+#include "pbd/search_path.h"
 
 #include "ardour/amp.h"
 #include "ardour/analyser.h"
+#include "ardour/async_midi_port.h"
 #include "ardour/audio_buffer.h"
 #include "ardour/audio_diskstream.h"
 #include "ardour/audio_port.h"
@@ -66,6 +67,7 @@
 #include "ardour/debug.h"
 #include "ardour/filename_extensions.h"
 #include "ardour/graph.h"
+#include "ardour/midiport_manager.h"
 #include "ardour/midi_track.h"
 #include "ardour/midi_ui.h"
 #include "ardour/operations.h"
@@ -85,12 +87,11 @@
 #include "ardour/session_playlists.h"
 #include "ardour/smf_source.h"
 #include "ardour/source_factory.h"
+#include "ardour/speakers.h"
 #include "ardour/utils.h"
 
 #include "midi++/port.h"
-#include "midi++/jack_midi_port.h"
 #include "midi++/mmc.h"
-#include "midi++/manager.h"
 
 #include "i18n.h"
 
@@ -106,6 +107,7 @@ using namespace PBD;
 
 bool Session::_disable_all_loaded_plugins = false;
 
+PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
 PBD::Signal1<void,std::string> Session::Dialog;
 PBD::Signal0<int> Session::AskAboutPendingState;
 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
@@ -130,70 +132,195 @@ Session::Session (AudioEngine &eng,
                   const string& snapshot_name,
                   BusProfile* bus_profile,
                   string mix_template)
-	: _engine (eng)
+	: playlists (new SessionPlaylists)
+	, _engine (eng)
+	, process_function (&Session::process_with_events)
+	, waiting_for_sync_offset (false)
+	, _base_frame_rate (0)
+	, _current_frame_rate (0)
+	, _nominal_frame_rate (0)
+	, transport_sub_state (0)
+	, _record_status (Disabled)
+	, _transport_frame (0)
+	, _session_range_location (0)
+	, _slave (0)
+	, _silent (false)
+	, _transport_speed (0)
+	, _default_transport_speed (1.0)
+	, _last_transport_speed (0)
 	, _target_transport_speed (0.0)
+	, auto_play_legal (false)
+	, _last_slave_transport_frame (0)
+	, maximum_output_latency (0)
 	, _requested_return_frame (-1)
+	, current_block_size (0)
+	, _worst_output_latency (0)
+	, _worst_input_latency (0)
+ 	, _worst_track_latency (0)
+	, _have_captured (false)
+	, _meter_hold (0)
+	, _meter_falloff (0)
+	, _non_soloed_outs_muted (false)
+	, _listen_cnt (0)
+	, _solo_isolated_cnt (0)
+	, _writable (false)
+	, _was_seamless (Config->get_seamless_loop ())
 	, _under_nsm_control (false)
-	, _session_dir (new SessionDirectory(fullpath))
+	, delta_accumulator_cnt (0)
+	, average_slave_delta (1800) // !!! why 1800 ???
+	, average_dir (0)
+	, have_first_delta_accumulator (false)
+	, _slave_state (Stopped)
+	, post_export_sync (false)
+	, post_export_position (0)
+	, _exporting (false)
+	, _export_started (false)
+	, _export_rolling (false)
+	, _pre_export_mmc_enabled (false)
+	, _name (snapshot_name)
+	, _is_new (true)
+	, _send_qf_mtc (false)
+	, _pframes_since_last_mtc (0)
+	, session_midi_feedback (0)
+	, play_loop (false)
+	, loop_changing (false)
+	, last_loopend (0)
+	, _session_dir (new SessionDirectory (fullpath))
+	, _current_snapshot_name (snapshot_name)	  
 	, state_tree (0)
-	, _state_of_the_state (Clean)
+	, state_was_pending (false)
+	, _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
+	, _last_roll_location (0)
+	, _last_roll_or_reversal_location (0)
+	, _last_record_location (0)
+	, pending_locate_roll (false)
+	, pending_locate_frame (0)
+	, pending_locate_flush (false)
+	, pending_abort (false)
+	, pending_auto_loop (false)
 	, _butler (new Butler (*this))
 	, _post_transport_work (0)
+	,  cumulative_rf_motion (0)
+	, rf_scale (1.0)
+	, _locations (new Locations (*this))
+	, step_speed (0)
+	, outbound_mtc_timecode_frame (0)
+	, next_quarter_frame_to_send (-1)
+	, _frames_per_timecode_frame (0)
+	, _frames_per_hour (0)
+	, _timecode_frames_per_hour (0)
+	, last_timecode_valid (false)
+	, last_timecode_when (0)
 	, _send_timecode_update (false)
+	, ltc_encoder (0)
 	, ltc_enc_buf(0)
+	, ltc_buf_off (0)
+	, ltc_buf_len (0)
+	, ltc_speed (0)
+	, ltc_enc_byte (0)
+	, ltc_enc_pos (0)
+	, ltc_enc_cnt (0)
+	, ltc_enc_off (0)
+	, restarting (false)
+	, ltc_prev_cycle (0)
+	, ltc_timecode_offset (0)
+	, ltc_timecode_negative_offset (false)
+	, midi_control_ui (0)
+	, _tempo_map (0)
 	, _all_route_group (new RouteGroup (*this, "all"))
 	, routes (new RouteList)
+	, _adding_routes_in_progress (false)
+	, destructive_index (0)
+	, solo_update_disabled (false)
+	, default_fade_steepness (0)
+	, default_fade_msecs (0)
 	, _total_free_4k_blocks (0)
 	, _total_free_4k_blocks_uncertain (false)
+	, no_questions_about_missing_files (false)
+	, _playback_load (0)
+	, _capture_load (0)
 	, _bundles (new BundleList)
 	, _bundle_xml_node (0)
 	, _current_trans (0)
+	, _clicking (false)
 	, click_data (0)
 	, click_emphasis_data (0)
+	, click_length (0)
+	, click_emphasis_length (0)
+	, _clicks_cleared (0)
+	, _play_range (false)
 	, main_outs (0)
+	, first_file_data_format_reset (true)
+	, first_file_header_format_reset (true)
+	, have_looped (false)
 	, _have_rec_enabled_track (false)
+	, _step_editors (0)
 	, _suspend_timecode_transmission (0)
+	,  _speakers (new Speakers)
+	, ignore_route_processor_changes (false)
+	, _midi_ports (0)
+	, _mmc (0)
 {
-	_locations = new Locations (*this);
-	ltc_encoder = NULL;
+	uint32_t sr = 0;
 
-	if (how_many_dsp_threads () > 1) {
-		/* For now, only create the graph if we are using >1 DSP threads, as
-		   it is a bit slower than the old code with 1 thread.
-		*/
-		_process_graph.reset (new Graph (*this));
-	}
-
-	playlists.reset (new SessionPlaylists);
+	pre_engine_init (fullpath);
+	
+	if (_is_new) {
+		if (ensure_engine (sr)) {
+			destroy ();
+			throw failed_constructor ();
+		}
 
-	_all_route_group->set_active (true, this);
+		if (create (mix_template, bus_profile)) {
+			destroy ();
+			throw failed_constructor ();
+		}
 
-	interpolation.add_channel_to (0, 0);
+		/* if a mix template was provided, then ::create() will
+		 * have copied it into the session and we need to load it
+		 * so that we have the state ready for ::set_state()
+		 * after the engine is started.
+		 *
+		 * Note that we do NOT try to get the sample rate from
+		 * the template at this time, though doing so would
+		 * be easy if we decided this was an appropriate part
+		 * of a template.
+		 */
 
-	if (!eng.connected()) {
-		throw failed_constructor();
-	}
+		if (!mix_template.empty() && load_state (_current_snapshot_name)) {
+			throw failed_constructor ();
+		}
 
-	n_physical_outputs = _engine.n_physical_outputs ();
-	n_physical_inputs =  _engine.n_physical_inputs ();
+	} else {
 
-	first_stage_init (fullpath, snapshot_name);
+		if (load_state (_current_snapshot_name)) {
+			throw failed_constructor ();
+		}
+	
+		/* try to get sample rate from XML state so that we
+		 * can influence the SR if we set up the audio
+		 * engine.
+		 */
 
-	_is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
+		if (state_tree) {
+			const XMLProperty* prop;
+			if ((prop = state_tree->root()->property (X_("sample-rate"))) != 0) {		
+				sr = atoi (prop->value());
+			}
+		}
 
-	if (_is_new) {
-		if (create (mix_template, bus_profile)) {
+		if (ensure_engine (sr)) {
 			destroy ();
 			throw failed_constructor ();
 		}
 	}
 
-	if (second_stage_init ()) {
+	if (post_engine_init ()) {
 		destroy ();
 		throw failed_constructor ();
 	}
 
-	store_recent_sessions(_name, _path);
+	store_recent_sessions (_name, _path);
 
 	bool was_dirty = dirty();
 
@@ -210,6 +337,16 @@ Session::Session (AudioEngine &eng,
 	EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
 
 	_is_new = false;
+
+	/* hook us up to the engine since we are now completely constructed */
+
+	BootMessage (_("Connect to engine"));
+
+	_engine.set_session (this);
+	_engine.reset_timebase ();
+
+	BootMessage (_("Session loading complete"));
+
 }
 
 Session::~Session ()
@@ -220,6 +357,81 @@ Session::~Session ()
 	destroy ();
 }
 
+int
+Session::ensure_engine (uint32_t desired_sample_rate)
+{
+	if (_engine.current_backend() == 0) {
+		/* backend is unknown ... */
+		boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
+		if (r.get_value_or (-1) != 0) {
+			return -1;
+		}
+	} else if (_engine.setup_required()) {
+		/* backend is known, but setup is needed */
+		boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
+		if (r.get_value_or (-1) != 0) {
+			return -1;
+		}
+	} else if (!_engine.running()) {
+		if (_engine.start()) {
+			return -1;
+		}
+	}
+
+	/* at this point the engine should be running
+	*/
+
+	if (!_engine.running()) {
+		return -1;
+	}
+
+	return immediately_post_engine ();
+
+}
+
+int
+Session::immediately_post_engine ()
+{
+	/* Do various initializations that should take place directly after we
+	 * know that the engine is running, but before we either create a
+	 * session or set state for an existing one.
+	 */
+	 
+	if (how_many_dsp_threads () > 1) {
+		/* For now, only create the graph if we are using >1 DSP threads, as
+		   it is a bit slower than the old code with 1 thread.
+		*/
+		_process_graph.reset (new Graph (*this));
+	}
+
+	/* every time we reconnect, recompute worst case output latencies */
+
+	_engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
+
+	if (synced_to_engine()) {
+		_engine.transport_stop ();
+	}
+
+	if (config.get_jack_time_master()) {
+		_engine.transport_locate (_transport_frame);
+	}
+
+	try {
+		BootMessage (_("Set up LTC"));
+		setup_ltc ();
+		BootMessage (_("Set up Click"));
+		setup_click ();
+		BootMessage (_("Set up standard connections"));
+		setup_bundles ();
+	}
+
+	catch (failed_constructor& err) {
+		return -1;
+	}
+
+	return 0;
+}
+
 void
 Session::destroy ()
 {
@@ -330,7 +542,9 @@ Session::destroy ()
 	/* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
 	playlists.reset ();
 
-	delete _locations;
+	delete _mmc; _mmc = 0;
+	delete _midi_ports; _midi_ports = 0;
+	delete _locations; _locations = 0;
 
 	DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
 
@@ -340,135 +554,110 @@ Session::destroy ()
 }
 
 void
-Session::when_engine_running ()
+Session::setup_ltc ()
 {
-	string first_physical_output;
-
-	BootMessage (_("Set block size and sample rate"));
-
-	set_block_size (_engine.frames_per_cycle());
-	set_frame_rate (_engine.frame_rate());
-
-	BootMessage (_("Using configuration"));
-
-	boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
-	boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
-
-	Config->map_parameters (ff);
-	config.map_parameters (ft);
-
-	/* every time we reconnect, recompute worst case output latencies */
-
-	_engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
-
-	if (synced_to_jack()) {
-		_engine.transport_stop ();
+	XMLNode* child = 0;
+	
+	_ltc_input.reset (new IO (*this, _("LTC In"), IO::Input));
+	_ltc_output.reset (new IO (*this, _("LTC Out"), IO::Output));
+	
+	if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-In")) != 0) {
+		_ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
+	} else {
+		{
+			Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+			_ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
+		}
+		reconnect_ltc_input ();
 	}
-
-	if (config.get_jack_time_master()) {
-		_engine.transport_locate (_transport_frame);
+	
+	if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-Out")) != 0) {
+		_ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
+	} else {
+		{
+			Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+			_ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
+		}
+		reconnect_ltc_output ();
 	}
+	
+	/* fix up names of LTC ports because we don't want the normal
+	 * IO style of NAME/TYPE-{in,out}N
+	 */
+	
+	_ltc_input->nth (0)->set_name (_("LTC-in"));
+	_ltc_output->nth (0)->set_name (_("LTC-out"));
+}
 
+void
+Session::setup_click ()
+{
 	_clicking = false;
+	_click_io.reset (new ClickIO (*this, "click"));
+	_click_gain.reset (new Amp (*this));
+	_click_gain->activate ();
+	if (state_tree) {
+		setup_click_state (*state_tree->root());
+	}
+}
 
-	try {
-		XMLNode* child = 0;
-		
-		_ltc_input.reset (new IO (*this, _("LTC In"), IO::Input));
-		_ltc_output.reset (new IO (*this, _("LTC Out"), IO::Output));
-
-		if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-In")) != 0) {
-			_ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
-		} else {
-			{
-				Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-				_ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
-			}
-			reconnect_ltc_input ();
-		}
+void
+Session::setup_click_state (const XMLNode& node)
+{	
+	const XMLNode* child = 0;
 
-		if (state_tree && (child = find_named_node (*state_tree->root(), "LTC-Out")) != 0) {
-			_ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
-		} else {
-			{
-				Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-				_ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
-			}
-			reconnect_ltc_output ();
-		}
-						
-		/* fix up names of LTC ports because we don't want the normal
-		 * IO style of NAME/TYPE-{in,out}N
-		 */
+	if ((child = find_named_node (node, "Click")) != 0) {
 		
-		_ltc_input->nth (0)->set_name (_("LTC-in"));
-		_ltc_output->nth (0)->set_name (_("LTC-out"));
-
-		_click_io.reset (new ClickIO (*this, "click"));
-		_click_gain.reset (new Amp (*this));
-		_click_gain->activate ();
-
-		if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
-
-			/* existing state for Click */
-			int c = 0;
+		/* existing state for Click */
+		int c = 0;
 
-			if (Stateful::loading_state_version < 3000) {
-				c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
-			} else {
-				const XMLNodeList& children (child->children());
-				XMLNodeList::const_iterator i = children.begin();
-				if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
-					++i;
-					if (i != children.end()) {
-						c = _click_gain->set_state (**i, Stateful::loading_state_version);
-					}
+		if (Stateful::loading_state_version < 3000) {
+			c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
+		} else {
+			const XMLNodeList& children (child->children());
+			XMLNodeList::const_iterator i = children.begin();
+			if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
+				++i;
+				if (i != children.end()) {
+					c = _click_gain->set_state (**i, Stateful::loading_state_version);
 				}
 			}
+		}
 			
-			if (c == 0) {
-				_clicking = Config->get_clicking ();
+		if (c == 0) {
+			_clicking = Config->get_clicking ();
 
-			} else {
+		} else {
 
-				error << _("could not setup Click I/O") << endmsg;
-				_clicking = false;
-			}
+			error << _("could not setup Click I/O") << endmsg;
+			_clicking = false;
+		}
 
 
-		} else {
+	} else {
 
-			/* default state for Click: dual-mono to first 2 physical outputs */
+		/* default state for Click: dual-mono to first 2 physical outputs */
 
-			vector<string> outs;
-			_engine.get_physical_outputs (DataType::AUDIO, outs);
+		vector<string> outs;
+		_engine.get_physical_outputs (DataType::AUDIO, outs);
 
-			for (uint32_t physport = 0; physport < 2; ++physport) {
-				if (outs.size() > physport) {
-					if (_click_io->add_port (outs[physport], this)) {
-						// relax, even though its an error
-					}
+		for (uint32_t physport = 0; physport < 2; ++physport) {
+			if (outs.size() > physport) {
+				if (_click_io->add_port (outs[physport], this)) {
+					// relax, even though its an error
 				}
 			}
-
-			if (_click_io->n_ports () > ChanCount::ZERO) {
-				_clicking = Config->get_clicking ();
-			}
 		}
-	}
-
-	catch (failed_constructor& err) {
-		error << _("cannot setup Click I/O") << endmsg;
-	}
-
-	BootMessage (_("Compute I/O Latencies"));
 
-	if (_clicking) {
-		// XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
+		if (_click_io->n_ports () > ChanCount::ZERO) {
+			_clicking = Config->get_clicking ();
+		}
 	}
+}
 
-	BootMessage (_("Set up standard connections"));
-
+void
+Session::setup_bundles ()
+{
 	vector<string> inputs[DataType::num_types];
 	vector<string> outputs[DataType::num_types];
 	for (uint32_t i = 0; i < DataType::num_types; ++i) {
@@ -567,53 +756,6 @@ Session::when_engine_running ()
 		add_bundle (c);
 	}
 
-	BootMessage (_("Setup signal flow and plugins"));
-
-	/* Reset all panners */
-
-	Delivery::reset_panners ();
-
-	/* this will cause the CPM to instantiate any protocols that are in use
-	 * (or mandatory), which will pass it this Session, and then call
-	 * set_state() on each instantiated protocol to match stored state.
-	 */
-
-	ControlProtocolManager::instance().set_session (this);
-
-	/* This must be done after the ControlProtocolManager set_session above,
-	   as it will set states for ports which the ControlProtocolManager creates.
-	*/
-
-	MIDI::Manager::instance()->set_port_states (Config->midi_port_states ());
-
-	/* And this must be done after the MIDI::Manager::set_port_states as
-	 * it will try to make connections whose details are loaded by set_port_states.
-	 */
-
-	hookup_io ();
-
-	/* Let control protocols know that we are now all connected, so they
-	 * could start talking to surfaces if they want to.
-	 */
-
-	ControlProtocolManager::instance().midi_connectivity_established ();
-
-	if (_is_new && !no_auto_connect()) {
-		Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
-		auto_connect_master_bus ();
-	}
-
-	_state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
-
-        /* update latencies */
-
-        initialize_latencies ();
-
-	/* hook us up to the engine */
-
-	BootMessage (_("Connect to engine"));
-	_engine.set_session (this);
-	_engine.reset_timebase ();
 }
 
 void
@@ -775,14 +917,14 @@ Session::add_monitor_section ()
 			
 			/* Monitor bus is audio only */
 
-			uint32_t mod = n_physical_outputs.get (DataType::AUDIO);
-			uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
 			vector<string> outputs[DataType::num_types];
 
 			for (uint32_t i = 0; i < DataType::num_types; ++i) {
 				_engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
 			}
-			
+
+			uint32_t mod = outputs[DataType::AUDIO].size();
+			uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
 			
 			if (mod != 0) {
 				
@@ -874,7 +1016,12 @@ Session::hookup_io ()
 	/* Tell all IO objects to connect themselves together */
 
 	IO::enable_connecting ();
-	MIDI::JackMIDIPort::MakeConnections ();
+
+	/* Now tell all "floating" ports to connect to whatever
+	   they should be connected to.
+	*/
+
+	AudioEngine::instance()->reconnect_ports ();
 
 	/* Anyone who cares about input state, wake up and do something */
 
@@ -936,7 +1083,7 @@ Session::set_track_monitor_input_status (bool yn)
 		boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
 		if (tr && tr->record_enabled ()) {
 			//cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
-			tr->request_jack_monitors_input (yn);
+			tr->request_input_monitoring (yn);
 		}
 	}
 }
@@ -1169,7 +1316,7 @@ Session::enable_record ()
 		if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
 
 			_last_record_location = _transport_frame;
-			MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
+			_mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
 
 			if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
 				set_track_monitor_input_status (true);
@@ -1190,7 +1337,7 @@ Session::disable_record (bool rt_context, bool force)
 
 		if ((!Config->get_latched_record_enable () && !play_loop) || force) {
 			g_atomic_int_set (&_record_status, Disabled);
-			MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
+			_mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
 		} else {
 			if (rs == Recording) {
 				g_atomic_int_set (&_record_status, Enabled);
@@ -1244,7 +1391,7 @@ Session::maybe_enable_record ()
 			enable_record ();
 		}
 	} else {
-		MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
+		_mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
 		RecordStateChanged (); /* EMIT SIGNAL */
 	}
 
@@ -1281,7 +1428,7 @@ Session::audible_frame () const
 		offset = current_block_size;
 	}
 
-	if (synced_to_jack()) {
+	if (synced_to_engine()) {
 		tf = _engine.transport_frame();
 	} else {
 		tf = _transport_frame;
@@ -1341,6 +1488,7 @@ Session::set_frame_rate (framecnt_t frames_per_second)
 	*/
 
 	_base_frame_rate = frames_per_second;
+	_nominal_frame_rate = frames_per_second;
 
 	sync_time_vars();
 
@@ -4170,9 +4318,9 @@ Session::get_silent_buffers (ChanCount count)
 }
 
 BufferSet&
-Session::get_scratch_buffers (ChanCount count)
+Session::get_scratch_buffers (ChanCount count, bool silence)
 {
-	return ProcessThread::get_scratch_buffers (count);
+	return ProcessThread::get_scratch_buffers (count, silence);
 }
 
 BufferSet&
@@ -4427,18 +4575,18 @@ Session::end_time_changed (framepos_t old)
 	}
 }
 
-string
+std::vector<std::string>
 Session::source_search_path (DataType type) const
 {
-	vector<string> s;
+	Searchpath sp;
 
 	if (session_dirs.size() == 1) {
 		switch (type) {
 		case DataType::AUDIO:
-			s.push_back (_session_dir->sound_path());
+			sp.push_back (_session_dir->sound_path());
 			break;
 		case DataType::MIDI:
-			s.push_back (_session_dir->midi_path());
+			sp.push_back (_session_dir->midi_path());
 			break;
 		}
 	} else {
@@ -4446,10 +4594,10 @@ Session::source_search_path (DataType type) const
 			SessionDirectory sdir (i->path);
 			switch (type) {
 			case DataType::AUDIO:
-				s.push_back (sdir.sound_path());
+				sp.push_back (sdir.sound_path());
 				break;
 			case DataType::MIDI:
-			        s.push_back (sdir.midi_path());
+				sp.push_back (sdir.midi_path());
 				break;
 			}
 		}
@@ -4458,49 +4606,30 @@ Session::source_search_path (DataType type) const
 	if (type == DataType::AUDIO) {
 		const string sound_path_2X = _session_dir->sound_path_2X();
 		if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
-			if (find (s.begin(), s.end(), sound_path_2X) == s.end()) {
-				s.push_back (sound_path_2X);
+			if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
+				sp.push_back (sound_path_2X);
 			}
 		}
 	}
 
-	/* now check the explicit (possibly user-specified) search path
-	 */
-
-	vector<string> dirs;
+	// now check the explicit (possibly user-specified) search path
 
 	switch (type) {
 	case DataType::AUDIO:
-		split (config.get_audio_search_path (), dirs, ':');
+		sp += Searchpath(config.get_audio_search_path ());
 		break;
 	case DataType::MIDI:
-		split (config.get_midi_search_path (), dirs, ':');
+		sp += Searchpath(config.get_midi_search_path ());
 		break;
 	}
 
-	for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
-		if (find (s.begin(), s.end(), *i) == s.end()) {
-			s.push_back (*i);
-		}
-	}
-	
-	string search_path;
-
-	for (vector<string>::iterator si = s.begin(); si != s.end(); ++si) {
-		if (!search_path.empty()) {
-			search_path += ':';
-		}
-		search_path += *si;
-	}
-
-	return search_path;
+	return sp;
 }
 
 void
 Session::ensure_search_path_includes (const string& path, DataType type)
 {
-	string search_path;
-	vector<string> dirs;
+	Searchpath sp;
 
 	if (path == ".") {
 		return;
@@ -4508,16 +4637,14 @@ Session::ensure_search_path_includes (const string& path, DataType type)
 
 	switch (type) {
 	case DataType::AUDIO:
-		search_path = config.get_audio_search_path ();
+		sp += Searchpath(config.get_audio_search_path ());
 		break;
 	case DataType::MIDI:
-		search_path = config.get_midi_search_path ();
+		sp += Searchpath (config.get_midi_search_path ());
 		break;
 	}
 
-	split (search_path, dirs, ':');
-
-	for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
+	for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
 		/* No need to add this new directory if it has the same inode as
 		   an existing one; checking inode rather than name prevents duplicated
 		   directories when we are using symlinks.
@@ -4529,18 +4656,14 @@ Session::ensure_search_path_includes (const string& path, DataType type)
 		}
 	}
 
-	if (!search_path.empty()) {
-		search_path += ':';
-	}
-
-	search_path += path;
+	sp += path;
 
 	switch (type) {
 	case DataType::AUDIO:
-		config.set_audio_search_path (search_path);
+		config.set_audio_search_path (sp.to_string());
 		break;
 	case DataType::MIDI:
-		config.set_midi_search_path (search_path);
+		config.set_midi_search_path (sp.to_string());
 		break;
 	}
 }