X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=1cc9a03e02902305f16183eb1908f5c8967fb4d7;hb=5fa05b403ca21a6573d07b921dc14f0769dc9fc7;hp=680f2861de2a2bdae8e90515ea89c96ef1fdd0d8;hpb=8c9749e42faf7808034ed8b7afce4a2fe6dc6f33;p=ardour.git

diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc
index 680f2861de..1cc9a03e02 100644
--- a/libs/ardour/session_process.cc
+++ b/libs/ardour/session_process.cc
@@ -32,36 +32,41 @@
 #include "ardour/butler.h"
 #include "ardour/cycle_timer.h"
 #include "ardour/debug.h"
+#include "ardour/disk_reader.h"
 #include "ardour/graph.h"
 #include "ardour/port.h"
 #include "ardour/process_thread.h"
 #include "ardour/scene_changer.h"
 #include "ardour/session.h"
-#include "ardour/slave.h"
+#include "ardour/transport_master.h"
+#include "ardour/transport_master_manager.h"
 #include "ardour/ticker.h"
 #include "ardour/types.h"
+#include "ardour/vca.h"
+#include "ardour/vca_manager.h"
 
 #include "midi++/mmc.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace ARDOUR;
 using namespace PBD;
 using namespace std;
 
 /** Called by the audio engine when there is work to be done with JACK.
- * @param nframes Number of frames to process.
+ * @param nframes Number of samples to process.
  */
 
 void
 Session::process (pframes_t nframes)
 {
-	framepos_t transport_at_start = _transport_frame;
+	samplepos_t transport_at_start = _transport_sample;
 
 	_silent = false;
 
 	if (processing_blocked()) {
 		_silent = true;
+		cerr << "%%%%%%%%%%%%%% session process blocked\n";
 		return;
 	}
 
@@ -75,9 +80,32 @@ Session::process (pframes_t nframes)
 
 	(this->*process_function) (nframes);
 
+	/* realtime-safe meter-position and processor-order changes
+	 *
+	 * ideally this would be done in
+	 * Route::process_output_buffers() but various functions
+	 * callig it hold a _processor_lock reader-lock
+	 */
+	boost::shared_ptr<RouteList> r = routes.reader ();
+	for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
+		if ((*i)->apply_processor_changes_rt()) {
+			_rt_emit_pending = true;
+		}
+	}
+	if (_rt_emit_pending) {
+		if (!_rt_thread_active) {
+			emit_route_signals ();
+		}
+		if (pthread_mutex_trylock (&_rt_emit_mutex) == 0) {
+			pthread_cond_signal (&_rt_emit_cond);
+			pthread_mutex_unlock (&_rt_emit_mutex);
+			_rt_emit_pending = false;
+		}
+	}
+
 	_engine.main_thread()->drop_buffers ();
 
-	/* deliver MIDI clock. Note that we need to use the transport frame
+	/* deliver MIDI clock. Note that we need to use the transport sample
 	 * position at the start of process(), not the value at the end of
 	 * it. We may already have ticked() because of a transport state
 	 * change, for example.
@@ -107,21 +135,25 @@ int
 Session::no_roll (pframes_t nframes)
 {
 	PT_TIMING_CHECK (4);
-	
-	framepos_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
+
+	samplepos_t end_sample = _transport_sample + nframes; // FIXME: varispeed + no_roll ??
 	int ret = 0;
-	int declick = get_transport_declick_required();
 	boost::shared_ptr<RouteList> r = routes.reader ();
 
 	if (_click_io) {
 		_click_io->silence (nframes);
 	}
 
-	ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes);
+	ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _target_transport_speed, _transport_speed, nframes);
+
+	VCAList v = _vca_manager->vcas ();
+	for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
+		(*i)->automation_run (_transport_sample, nframes);
+	}
 
 	if (_process_graph) {
 		DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/no-roll\n");
-		_process_graph->routes_no_roll( nframes, _transport_frame, end_frame, non_realtime_work_pending(), declick);
+		_process_graph->routes_no_roll( nframes, _transport_sample, end_sample, non_realtime_work_pending());
 	} else {
 		PT_TIMING_CHECK (10);
 		for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
@@ -130,9 +162,7 @@ Session::no_roll (pframes_t nframes)
 				continue;
 			}
 
-			(*i)->set_pending_declick (declick);
-
-			if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending())) {
+			if ((*i)->no_roll (nframes, _transport_sample, end_sample, non_realtime_work_pending())) {
 				error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg;
 				ret = -1;
 				break;
@@ -151,62 +181,26 @@ Session::no_roll (pframes_t nframes)
 int
 Session::process_routes (pframes_t nframes, bool& need_butler)
 {
-	int  declick = get_transport_declick_required();
 	boost::shared_ptr<RouteList> r = routes.reader ();
 
-	if (transport_sub_state & StopPendingCapture) {
-		/* force a declick out */
-		declick = -1;
-	}
-
-	const framepos_t start_frame = _transport_frame;
-	const framepos_t end_frame = _transport_frame + floor (nframes * _transport_speed);
-	
-	if (_process_graph) {
-		DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/process-routes\n");
-		_process_graph->process_routes (nframes, start_frame, end_frame, declick, need_butler);
-	} else {
-
-		for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-
-			int ret;
-
-			if ((*i)->is_auditioner()) {
-				continue;
-			}
-
-			(*i)->set_pending_declick (declick);
-
-			bool b = false;
+	const samplepos_t start_sample = _transport_sample;
+	const samplepos_t end_sample = _transport_sample + floor (nframes * _transport_speed);
 
-			if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, b)) < 0) {
-				stop_transport ();
-				return -1;
-			}
-
-			if (b) {
-				need_butler = true;
-			}
-		}
+	VCAList v = _vca_manager->vcas ();
+	for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
+		(*i)->automation_run (start_sample, nframes);
 	}
 
-	return 0;
-}
-
-/** @param need_butler to be set to true by this method if it needs the butler,
- *  otherwise it must be left alone.
- */
-int
-Session::silent_process_routes (pframes_t nframes, bool& need_butler)
-{
-	boost::shared_ptr<RouteList> r = routes.reader ();
-
-	const framepos_t start_frame = _transport_frame;
-	const framepos_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
+	_global_locate_pending = locate_pending ();
 
 	if (_process_graph) {
-		_process_graph->silent_process_routes (nframes, start_frame, end_frame, need_butler);
+		DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/process-routes\n");
+		if (_process_graph->process_routes (nframes, start_sample, end_sample, need_butler) < 0) {
+			stop_transport ();
+			return -1;
+		}
 	} else {
+
 		for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 
 			int ret;
@@ -217,12 +211,13 @@ Session::silent_process_routes (pframes_t nframes, bool& need_butler)
 
 			bool b = false;
 
-			if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, b)) < 0) {
+			if ((ret = (*i)->roll (nframes, start_sample, end_sample, b)) < 0) {
 				stop_transport ();
 				return -1;
 			}
 
 			if (b) {
+				DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 rolled and needs butler\n", (*i)->name()));
 				need_butler = true;
 			}
 		}
@@ -242,7 +237,7 @@ Session::get_track_statistics ()
 
 		boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 
-		if (!tr || tr->hidden()) {
+		if (!tr || tr->is_private_route()) {
 			continue;
 		}
 
@@ -258,17 +253,34 @@ Session::get_track_statistics ()
 	}
 }
 
+bool
+Session::compute_audible_delta (samplepos_t& pos_and_delta) const
+{
+	if (_transport_speed == 0.0 || _count_in_samples > 0 || _remaining_latency_preroll > 0) {
+		/* cannot compute audible delta, because the session is
+		   generating silence that does not correspond to the timeline,
+		   but is instead filling playback buffers to manage latency
+		   alignment.
+		*/
+		DEBUG_TRACE (DEBUG::Slave, string_compose ("still adjusting for latency (%1) and/or count-in (%2) or stopped %1\n", _remaining_latency_preroll, _count_in_samples, _transport_speed));
+		return false;
+	}
+
+	pos_and_delta -= _transport_sample;
+	return true;
+}
+
 /** Process callback used when the auditioner is not active */
 void
 Session::process_with_events (pframes_t nframes)
 {
 	PT_TIMING_CHECK (3);
-	
+
 	SessionEvent*  ev;
 	pframes_t      this_nframes;
-	framepos_t     end_frame;
+	samplepos_t     end_sample;
 	bool           session_needs_butler = false;
-	framecnt_t     frames_moved;
+	samplecnt_t     samples_moved;
 
 	/* make sure the auditioner is silent */
 
@@ -292,6 +304,91 @@ Session::process_with_events (pframes_t nframes)
 		immediate_events.pop_front ();
 		process_event (ev);
 	}
+	/* only count-in when going to roll at speed 1.0 */
+	if (_transport_speed != 1.0 && _count_in_samples > 0) {
+		_count_in_samples = 0;
+	}
+	if (_transport_speed == 0.0) {
+		_remaining_latency_preroll = 0;
+	}
+
+	assert (_count_in_samples == 0 || _remaining_latency_preroll == 0 || _count_in_samples == _remaining_latency_preroll);
+
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Running count in/latency preroll of %1 & %2\n", _count_in_samples, _remaining_latency_preroll));
+
+	while (_count_in_samples > 0 || _remaining_latency_preroll > 0) {
+		samplecnt_t ns;
+
+		if (_remaining_latency_preroll > 0) {
+			ns = std::min ((samplecnt_t)nframes, _remaining_latency_preroll);
+		} else {
+			ns = std::min ((samplecnt_t)nframes, _count_in_samples);
+		}
+
+		boost::shared_ptr<RouteList> r = routes.reader ();
+		for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+			samplecnt_t route_offset = (*i)->playback_latency ();
+			if (_remaining_latency_preroll > route_offset + ns) {
+				/* route will no-roll for complete pre-roll cycle */
+				continue;
+			}
+			if (_remaining_latency_preroll > route_offset) {
+				/* route may need partial no-roll and partial roll from
+				* (_transport_sample - _remaining_latency_preroll) ..  +ns.
+				* shorten and split the cycle.
+				*/
+				ns = std::min (ns, (_remaining_latency_preroll - route_offset));
+			}
+		}
+
+		if (_count_in_samples > 0) {
+			run_click (_transport_sample - _count_in_samples, ns);
+			assert (_count_in_samples >= ns);
+			_count_in_samples -= ns;
+		}
+
+		if (_remaining_latency_preroll > 0) {
+			if (_count_in_samples == 0) {
+				click (_transport_sample - _remaining_latency_preroll, ns);
+			}
+			if (process_routes (ns, session_needs_butler)) {
+				fail_roll (ns);
+			}
+		} else {
+			no_roll (ns);
+		}
+
+		if (_remaining_latency_preroll > 0) {
+			assert (_remaining_latency_preroll >= ns);
+			_remaining_latency_preroll -= ns;
+		}
+
+		nframes -= ns;
+
+		/* process events.. */
+		if (!events.empty() && next_event != events.end()) {
+			SessionEvent* this_event = *next_event;
+			Events::iterator the_next_one = next_event;
+			++the_next_one;
+
+			while (this_event && this_event->action_sample == _transport_sample) {
+				process_event (this_event);
+				if (the_next_one == events.end()) {
+					this_event = 0;
+				} else {
+					this_event = *the_next_one;
+					++the_next_one;
+				}
+			}
+			set_next_event ();
+		}
+
+		if (nframes == 0) {
+			return;
+		} else {
+			_engine.split_cycle (ns);
+		}
+	}
 
 	/* Decide on what to do with quarter-frame MTC during this cycle */
 
@@ -310,7 +407,7 @@ Session::process_with_events (pframes_t nframes)
 			_send_timecode_update = true;
 		}
 
-		if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (frame_rate () / 4)) {
+		if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (sample_rate () / 4)) {
 			/* we're sending MTC, but we're not sending QF MTC at the moment, and it's been
 			   a quarter of a second since we sent anything at all, so send a full MTC update
 			   this cycle.
@@ -328,7 +425,7 @@ Session::process_with_events (pframes_t nframes)
 	 * and prepare for rolling)
 	 */
 	if (_send_timecode_update) {
-		send_full_time_code (_transport_frame, nframes);
+		send_full_time_code (_transport_sample, nframes);
 	}
 
 	if (!process_can_proceed()) {
@@ -337,19 +434,22 @@ Session::process_with_events (pframes_t nframes)
 	}
 
 	if (events.empty() || next_event == events.end()) {
-		process_without_events (nframes);
-		return;
+		try_run_lua (nframes); // also during export ?? ->move to process_without_events()
+		/* lua scripts may inject events */
+		while (_n_lua_scripts > 0 && pending_events.read (&ev, 1) == 1) {
+			merge_event (ev);
+		}
+		if (events.empty() || next_event == events.end()) {
+			process_without_events (nframes);
+			return;
+		}
 	}
 
-	if (_transport_speed == 1.0) {
-		frames_moved = (framecnt_t) nframes;
-	} else {
-		interpolation.set_target_speed (_target_transport_speed);
-		interpolation.set_speed (_transport_speed);
-		frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0);
-	}
+	assert (_transport_speed == 0 || _transport_speed == 1.0 || _transport_speed == -1.0);
+
+	samples_moved = (samplecnt_t) nframes * _transport_speed;
 
-	end_frame = _transport_frame + frames_moved;
+	end_sample = _transport_sample + samples_moved;
 
 	{
 		SessionEvent* this_event;
@@ -360,8 +460,9 @@ Session::process_with_events (pframes_t nframes)
 			return;
 		}
 
-		if (!_exporting && _slave) {
-			if (!follow_slave (nframes)) {
+		if (!_exporting && config.get_external_sync()) {
+			if (!follow_transport_master (nframes)) {
+				ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _target_transport_speed, _transport_speed, nframes);
 				return;
 			}
 		}
@@ -372,10 +473,12 @@ Session::process_with_events (pframes_t nframes)
 		}
 
 		if (!_exporting && !timecode_transmission_suspended()) {
-			send_midi_time_code_for_cycle (_transport_frame, end_frame, nframes);
+			send_midi_time_code_for_cycle (_transport_sample, end_sample, nframes);
 		}
 
-		framepos_t stop_limit = compute_stop_limit ();
+		ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _target_transport_speed, _transport_speed, nframes);
+
+		samplepos_t stop_limit = compute_stop_limit ();
 
 		if (maybe_stop (stop_limit)) {
 			no_roll (nframes);
@@ -393,18 +496,20 @@ Session::process_with_events (pframes_t nframes)
 		while (nframes) {
 
 			this_nframes = nframes; /* real (jack) time relative */
-			frames_moved = (framecnt_t) floor (_transport_speed * nframes); /* transport relative */
+			samples_moved = (samplecnt_t) floor (_transport_speed * nframes); /* transport relative */
 
 			/* running an event, position transport precisely to its time */
-			if (this_event && this_event->action_frame <= end_frame && this_event->action_frame >= _transport_frame) {
+			if (this_event && this_event->action_sample <= end_sample && this_event->action_sample >= _transport_sample) {
 				/* this isn't quite right for reverse play */
-				frames_moved = (framecnt_t) (this_event->action_frame - _transport_frame);
-				this_nframes = abs (floor(frames_moved / _transport_speed));
+				samples_moved = (samplecnt_t) (this_event->action_sample - _transport_sample);
+				this_nframes = abs (floor(samples_moved / _transport_speed));
 			}
 
+			try_run_lua (this_nframes);
+
 			if (this_nframes) {
 
-				click (_transport_frame, this_nframes);
+				click (_transport_sample, this_nframes);
 
 				if (process_routes (this_nframes, session_needs_butler)) {
 					fail_roll (nframes);
@@ -415,14 +520,13 @@ Session::process_with_events (pframes_t nframes)
 
 				nframes -= this_nframes;
 
-				if (frames_moved < 0) {
-					decrement_transport_position (-frames_moved);
-				} else {
-					increment_transport_position (frames_moved);
+				if (samples_moved < 0) {
+					decrement_transport_position (-samples_moved);
+				} else if (samples_moved) {
+					increment_transport_position (samples_moved);
 				}
 
 				maybe_stop (stop_limit);
-				check_declick_out ();
 			}
 
 			if (nframes > 0) {
@@ -431,7 +535,7 @@ Session::process_with_events (pframes_t nframes)
 
 			/* now handle this event and all others scheduled for the same time */
 
-			while (this_event && this_event->action_frame == _transport_frame) {
+			while (this_event && this_event->action_sample == _transport_sample) {
 				process_event (this_event);
 
 				if (the_next_one == events.end()) {
@@ -450,7 +554,7 @@ Session::process_with_events (pframes_t nframes)
 			}
 
 			/* this is necessary to handle the case of seamless looping */
-			end_frame = _transport_frame + floor (nframes * _transport_speed);
+			end_sample = _transport_sample + floor (nframes * _transport_speed);
 		}
 
 		set_next_event ();
@@ -458,374 +562,58 @@ Session::process_with_events (pframes_t nframes)
 	} /* implicit release of route lock */
 
 	if (session_needs_butler) {
+		DEBUG_TRACE (DEBUG::Butler, "p-with-events: session needs butler, call it\n");
 		_butler->summon ();
 	}
 }
 
-void
-Session::reset_slave_state ()
-{
-	average_slave_delta = 1800;
-	delta_accumulator_cnt = 0;
-	have_first_delta_accumulator = false;
-	_slave_state = Stopped;
-}
-
 bool
 Session::transport_locked () const
 {
-	Slave* sl = _slave;
-
-	if (!locate_pending() && (!config.get_external_sync() || (sl && sl->ok() && sl->locked()))) {
-		return true;
-	}
-
-	return false;
-}
-
-bool
-Session::follow_slave (pframes_t nframes)
-{
-	double slave_speed;
-	framepos_t slave_transport_frame;
-	framecnt_t this_delta;
-	int dir;
-
-	if (!_slave->ok()) {
-		stop_transport ();
-		config.set_external_sync (false);
-		goto noroll;
-	}
-
-	_slave->speed_and_position (slave_speed, slave_transport_frame);
-
-	DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_frame, slave_speed));
-
-	if (!_slave->locked()) {
-		DEBUG_TRACE (DEBUG::Slave, "slave not locked\n");
-		goto noroll;
-	}
-
-	if (slave_transport_frame > _transport_frame) {
-		this_delta = slave_transport_frame - _transport_frame;
-		dir = 1;
-	} else {
-		this_delta = _transport_frame - slave_transport_frame;
-		dir = -1;
-	}
-
-	if (_slave->starting()) {
-		slave_speed = 0.0f;
-	}
-
-	if (_slave->is_always_synced() ||
-			(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
-			) {
-
-		/* if the TC source is synced, then we assume that its
-		   speed is binary: 0.0 or 1.0
-		*/
-
-		if (slave_speed != 0.0f) {
-			slave_speed = 1.0f;
-		}
-
-	} else {
-
-		/* if we are chasing and the average delta between us and the
-		   master gets too big, we want to switch to silent
-		   motion. so keep track of that here.
-		*/
-
-		if (_slave_state == Running) {
-			calculate_moving_average_of_slave_delta(dir, this_delta);
-		}
-	}
-
-	track_slave_state (slave_speed, slave_transport_frame, this_delta);
-
-	DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n",
-						   _slave_state, slave_transport_frame, slave_speed, this_delta, average_slave_delta));
-
-
-	if (_slave_state == Running && !_slave->is_always_synced() &&
-			!(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
-			) {
-
-		if (_transport_speed != 0.0f) {
-
-			/*
-			   note that average_dir is +1 or -1
-			*/
-
-			float delta;
-
-			if (average_slave_delta == 0) {
-				delta = this_delta;
-				delta *= dir;
-			} else {
-				delta = average_slave_delta;
-				delta *= average_dir;
-			}
-
-#ifndef NDEBUG
-			if (slave_speed != 0.0) {
-				DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n",
-									   (int) (dir * this_delta),
-									   slave_speed,
-									   _transport_speed,
-									   _transport_frame,
-									   slave_transport_frame,
-									   average_slave_delta));
-			}
-#endif
-
-			if (_slave->give_slave_full_control_over_transport_speed()) {
-				set_transport_speed (slave_speed, false, false);
-				//std::cout << "set speed = " << slave_speed << "\n";
-			} else {
-				float adjusted_speed = slave_speed + (1.5 * (delta /  float(_current_frame_rate)));
-				request_transport_speed (adjusted_speed);
-				DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n",
-									   delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed,
-									   slave_speed));
-			}
-
-#if 1
-			if (!actively_recording() && (framecnt_t) abs(average_slave_delta) > _slave->resolution()) {
-				cerr << "average slave delta greater than slave resolution (" << _slave->resolution() << "), going to silent motion\n";
-				goto silent_motion;
-			}
-#endif
-		}
-	}
-
-
-	if (_slave_state == Running && !non_realtime_work_pending()) {
-		/* speed is set, we're locked, and good to go */
+	if (!locate_pending() && (!config.get_external_sync() || (transport_master()->ok() && transport_master()->locked()))) {
 		return true;
 	}
 
-  silent_motion:
-	DEBUG_TRACE (DEBUG::Slave, "silent motion\n")
-	follow_slave_silently (nframes, slave_speed);
-
-  noroll:
-	/* don't move at all */
-	DEBUG_TRACE (DEBUG::Slave, "no roll\n")
-	no_roll (nframes);
 	return false;
 }
 
-void
-Session::calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta)
-{
-	if (delta_accumulator_cnt >= delta_accumulator_size) {
-		have_first_delta_accumulator = true;
-		delta_accumulator_cnt = 0;
-	}
-
-	if (delta_accumulator_cnt != 0 || this_delta < _current_frame_rate) {
-		delta_accumulator[delta_accumulator_cnt++] = (framecnt_t) dir *  (framecnt_t) this_delta;
-	}
-
-	if (have_first_delta_accumulator) {
-		average_slave_delta = 0L;
-		for (int i = 0; i < delta_accumulator_size; ++i) {
-			average_slave_delta += delta_accumulator[i];
-		}
-		average_slave_delta /= (int32_t) delta_accumulator_size;
-		if (average_slave_delta < 0L) {
-			average_dir = -1;
-			average_slave_delta = abs(average_slave_delta);
-		} else {
-			average_dir = 1;
-		}
-	}
-}
-
-void
-Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t /*this_delta*/)
-{
-	if (slave_speed != 0.0f) {
-
-		/* slave is running */
-
-		switch (_slave_state) {
-		case Stopped:
-			if (_slave->requires_seekahead()) {
-				slave_wait_end = slave_transport_frame + _slave->seekahead_distance ();
-				DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end));
-				/* we can call locate() here because we are in process context */
-				locate (slave_wait_end, false, false);
-				_slave_state = Waiting;
-
-			} else {
-
-				DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_frame));
-
-				memset (delta_accumulator, 0, sizeof (int32_t) * delta_accumulator_size);
-				average_slave_delta = 0L;
-
-				Location* al = _locations->auto_loop_location();
-
-				if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
-					// cancel looping
-					request_play_loop(false);
-				}
-
-				if (slave_transport_frame != _transport_frame) {
-					DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_frame, slave_transport_frame));
-					locate (slave_transport_frame, false, false);
-				}
-				_slave_state = Running;
-			}
-			break;
-
-		case Waiting:
-		default:
-			break;
-		}
-
-		if (_slave_state == Waiting) {
-
-			DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_frame));
-
-			if (slave_transport_frame >= slave_wait_end) {
-
-				DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_frame, _transport_frame));
-
-				_slave_state = Running;
-
-				/* now perform a "micro-seek" within the disk buffers to realign ourselves
-				   precisely with the master.
-				*/
-
-
-				bool ok = true;
-				framecnt_t frame_delta = slave_transport_frame - _transport_frame;
-
-				boost::shared_ptr<RouteList> rl = routes.reader();
-				for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
-					boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
-					if (tr && !tr->can_internal_playback_seek (frame_delta)) {
-						ok = false;
-						break;
-					}
-				}
-
-				if (ok) {
-					for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
-						boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
-						if (tr) {
-							tr->internal_playback_seek (frame_delta);
-						}
-					}
-					_transport_frame += frame_delta;
-
-				} else {
-					cerr << "cannot micro-seek\n";
-					/* XXX what? */
-				}
-			}
-		}
-
-		if (_slave_state == Running && _transport_speed == 0.0f) {
-			DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
-			start_transport ();
-		}
-
-	} else { // slave_speed is 0
-
-		/* slave has stopped */
-
-		if (_transport_speed != 0.0f) {
-			DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 frame %2 tf %3\n", slave_speed, slave_transport_frame, _transport_frame));
-			stop_transport ();
-		}
-
-		if (slave_transport_frame != _transport_frame) {
-			DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_frame));
-			force_locate (slave_transport_frame, false);
-		}
-
-		reset_slave_state();
-	}
-}
-
-void
-Session::follow_slave_silently (pframes_t nframes, float slave_speed)
-{
-	if (slave_speed && _transport_speed) {
-
-		/* something isn't right, but we should move with the master
-		   for now.
-		*/
-
-		bool need_butler;
-
-		silent_process_routes (nframes, need_butler);
-
-		get_track_statistics ();
-
-		if (need_butler) {
-			_butler->summon ();
-		}
-
-		int32_t frames_moved = (int32_t) floor (_transport_speed * nframes);
-
-		if (frames_moved < 0) {
-			decrement_transport_position (-frames_moved);
-		} else {
-			increment_transport_position (frames_moved);
-		}
-
-		framepos_t const stop_limit = compute_stop_limit ();
-		maybe_stop (stop_limit);
-	}
-}
-
 void
 Session::process_without_events (pframes_t nframes)
 {
 	bool session_needs_butler = false;
-	framecnt_t frames_moved;
+	samplecnt_t samples_moved;
 
 	if (!process_can_proceed()) {
 		_silent = true;
 		return;
 	}
 
-	if (!_exporting && _slave) {
-		if (!follow_slave (nframes)) {
-			ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame, 0, 0 , nframes);
+	if (!_exporting && config.get_external_sync()) {
+		if (!follow_transport_master (nframes)) {
+			ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample, 0, 0 , nframes);
 			return;
 		}
 	}
 
+	assert (_transport_speed == 0 || _transport_speed == 1.0 || _transport_speed == -1.0);
+
 	if (_transport_speed == 0) {
-		fail_roll (nframes);
+		no_roll (nframes);
 		return;
-	}
-
-	if (_transport_speed == 1.0) {
-		frames_moved = (framecnt_t) nframes;
 	} else {
-		interpolation.set_target_speed (_target_transport_speed);
-		interpolation.set_speed (_transport_speed);
-		frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0);
+		samples_moved = (samplecnt_t) nframes;
 	}
 
 	if (!_exporting && !timecode_transmission_suspended()) {
-		send_midi_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, nframes);
+		send_midi_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, nframes);
 	}
 
-	ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, _target_transport_speed, _transport_speed, nframes);
+	ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, _target_transport_speed, _transport_speed, nframes);
 
-	framepos_t const stop_limit = compute_stop_limit ();
+	samplepos_t const stop_limit = compute_stop_limit ();
 
 	if (maybe_stop (stop_limit)) {
-		fail_roll (nframes);
+		no_roll (nframes);
 		return;
 	}
 
@@ -833,7 +621,7 @@ Session::process_without_events (pframes_t nframes)
 		return;
 	}
 
-	click (_transport_frame, nframes);
+	click (_transport_sample, nframes);
 
 	if (process_routes (nframes, session_needs_butler)) {
 		fail_roll (nframes);
@@ -842,22 +630,22 @@ Session::process_without_events (pframes_t nframes)
 
 	get_track_statistics ();
 
-	if (frames_moved < 0) {
-		decrement_transport_position (-frames_moved);
-	} else {
-		increment_transport_position (frames_moved);
+	if (samples_moved < 0) {
+		decrement_transport_position (-samples_moved);
+	} else if (samples_moved) {
+		increment_transport_position (samples_moved);
 	}
 
 	maybe_stop (stop_limit);
-	check_declick_out ();
 
 	if (session_needs_butler) {
+		DEBUG_TRACE (DEBUG::Butler, "p-without-events: session needs butler, call it\n");
 		_butler->summon ();
 	}
 }
 
 /** Process callback used when the auditioner is active.
- * @param nframes number of frames to process.
+ * @param nframes number of samples to process.
  */
 void
 Session::process_audition (pframes_t nframes)
@@ -874,13 +662,14 @@ Session::process_audition (pframes_t nframes)
 	/* run the auditioner, and if it says we need butler service, ask for it */
 
 	if (auditioner->play_audition (nframes) > 0) {
+		DEBUG_TRACE (DEBUG::Butler, "auditioner needs butler, call it\n");
 		_butler->summon ();
 	}
 
 	/* if using a monitor section, run it because otherwise we don't hear anything */
 
 	if (_monitor_out && auditioner->needs_monitor()) {
-		_monitor_out->monitor_run (_transport_frame, _transport_frame + nframes, nframes, false);
+		_monitor_out->monitor_run (_transport_sample, _transport_sample + nframes, nframes);
 	}
 
 	/* handle pending events */
@@ -960,6 +749,7 @@ Session::queue_event (SessionEvent* ev)
 	} else if (_state_of_the_state & Loading) {
 		merge_event (ev);
 	} else {
+		Glib::Threads::Mutex::Lock lm (rb_write_lock);
 		pending_events.write (&ev, 1);
 	}
 }
@@ -976,12 +766,12 @@ Session::set_next_event ()
 		next_event = events.begin();
 	}
 
-	if ((*next_event)->action_frame > _transport_frame) {
+	if ((*next_event)->action_sample > _transport_sample) {
 		next_event = events.begin();
 	}
 
 	for (; next_event != events.end(); ++next_event) {
-		if ((*next_event)->action_frame >= _transport_frame) {
+		if ((*next_event)->action_sample >= _transport_sample) {
 			break;
 		}
 	}
@@ -1010,7 +800,7 @@ Session::process_event (SessionEvent* ev)
 		}
 	}
 
-	DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame));
+	DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_sample));
 
 	switch (ev->type) {
 	case SessionEvent::SetLoop:
@@ -1022,30 +812,19 @@ Session::process_event (SessionEvent* ev)
 			/* roll after locate, do not flush, set "with loop"
 			   true only if we are seamless looping
 			*/
-			start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
-		}
-		remove = false;
-		del = false;
-		break;
-
-	case SessionEvent::AutoLoopDeclick:
-		if (play_loop) {
-			/* Request a declick fade-out and a fade-in; the fade-out will happen
-			   at the end of the loop, and the fade-in at the start.
-			*/
-			transport_sub_state |= (PendingLoopDeclickOut | PendingLoopDeclickIn);
+			start_locate (ev->target_sample, true, false, Config->get_seamless_loop());
 		}
 		remove = false;
 		del = false;
 		break;
 
 	case SessionEvent::Locate:
-		if (ev->yes_or_no) {
+		if (ev->yes_or_no) { /* force locate */
 			/* args: do not roll after locate, do flush, not with loop */
-			locate (ev->target_frame, false, true, false);
+			locate (ev->target_sample, false, true, false);
 		} else {
 			/* args: do not roll after locate, do flush, not with loop */
-			start_locate (ev->target_frame, false, true, false);
+			start_locate (ev->target_sample, false, true, false);
 		}
 		_send_timecode_update = true;
 		break;
@@ -1053,27 +832,40 @@ Session::process_event (SessionEvent* ev)
 	case SessionEvent::LocateRoll:
 		if (ev->yes_or_no) {
 			/* args: roll after locate, do flush, not with loop */
-			locate (ev->target_frame, true, true, false);
+			locate (ev->target_sample, true, true, false);
 		} else {
 			/* args: roll after locate, do flush, not with loop */
-			start_locate (ev->target_frame, true, true, false);
+			start_locate (ev->target_sample, true, true, false);
 		}
 		_send_timecode_update = true;
 		break;
 
+	case SessionEvent::Skip:
+		if (Config->get_skip_playback()) {
+			start_locate (ev->target_sample, true, true, false);
+			_send_timecode_update = true;
+		}
+		remove = false;
+		del = false;
+		break;
+
 	case SessionEvent::LocateRollLocate:
 		// locate is handled by ::request_roll_at_and_return()
-		_requested_return_frame = ev->target_frame;
-		request_locate (ev->target2_frame, true);
+		_requested_return_sample = ev->target_sample;
+		request_locate (ev->target2_sample, true);
 		break;
 
 
 	case SessionEvent::SetTransportSpeed:
-		set_transport_speed (ev->speed, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no);
+		set_transport_speed (ev->speed, ev->target_sample, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no);
+		break;
+
+	case SessionEvent::SetTransportMaster:
+		TransportMasterManager::instance().set_current (ev->transport_master);
 		break;
 
 	case SessionEvent::PunchIn:
-		// cerr << "PunchIN at " << transport_frame() << endl;
+		// cerr << "PunchIN at " << transport_sample() << endl;
 		if (config.get_punch_in() && record_status() == Enabled) {
 			enable_record ();
 		}
@@ -1082,7 +874,7 @@ Session::process_event (SessionEvent* ev)
 		break;
 
 	case SessionEvent::PunchOut:
-		// cerr << "PunchOUT at " << transport_frame() << endl;
+		// cerr << "PunchOUT at " << transport_sample() << endl;
 		if (config.get_punch_out()) {
 			step_back_from_record ();
 		}
@@ -1092,8 +884,8 @@ Session::process_event (SessionEvent* ev)
 
 	case SessionEvent::StopOnce:
 		if (!non_realtime_work_pending()) {
-			stop_transport (ev->yes_or_no);
 			_clear_event_type (SessionEvent::StopOnce);
+			stop_transport (ev->yes_or_no);
 		}
 		remove = false;
 		del = false;
@@ -1109,7 +901,7 @@ Session::process_event (SessionEvent* ev)
 
 	case SessionEvent::RangeLocate:
 		/* args: roll after locate, do flush, not with loop */
-		start_locate (ev->target_frame, true, true, false);
+		start_locate (ev->target_sample, true, true, false);
 		remove = false;
 		del = false;
 		break;
@@ -1118,30 +910,20 @@ Session::process_event (SessionEvent* ev)
 		overwrite_some_buffers (static_cast<Track*>(ev->ptr));
 		break;
 
-	case SessionEvent::SetTrackSpeed:
-		set_track_speed (static_cast<Track*> (ev->ptr), ev->speed);
-		break;
-
-	case SessionEvent::SetSyncSource:
-		DEBUG_TRACE (DEBUG::Slave, "seen request for new slave\n");
-		use_sync_source (ev->slave);
-		break;
-
 	case SessionEvent::Audition:
 		set_audition (ev->region);
 		// drop reference to region
 		ev->region.reset ();
 		break;
 
-	case SessionEvent::InputConfigurationChange:
-		add_post_transport_work (PostTransportInputChange);
-		_butler->schedule_transport_work ();
-		break;
-
 	case SessionEvent::SetPlayAudioRange:
 		set_play_range (ev->audio_range, (ev->speed == 1.0f));
 		break;
 
+	case SessionEvent::CancelPlayAudioRange:
+		unset_play_range();
+		break;
+
 	case SessionEvent::RealTimeOperation:
 		process_rtop (ev);
 		del = false; // other side of RT request needs to clean up
@@ -1161,7 +943,7 @@ Session::process_event (SessionEvent* ev)
 
 	default:
 	  fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
-		/*NOTREACHED*/
+		abort(); /*NOTREACHED*/
 		break;
 	};
 
@@ -1174,31 +956,249 @@ Session::process_event (SessionEvent* ev)
 	}
 }
 
-framepos_t
+samplepos_t
 Session::compute_stop_limit () const
 {
 	if (!Config->get_stop_at_session_end ()) {
-		return max_framepos;
+		return max_samplepos;
 	}
 
-	if (_slave) {
-		return max_framepos;
+	if (config.get_external_sync()) {
+		return max_samplepos;
 	}
 
-	
 	bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location());
 	bool const punching_out = (config.get_punch_out () && _locations->auto_punch_location());
 
 	if (actively_recording ()) {
 		/* permanently recording */
-		return max_framepos;
+		return max_samplepos;
 	} else if (punching_in && !punching_out) {
 		/* punching in but never out */
-		return max_framepos;
-	} else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_frame()) {
+		return max_samplepos;
+	} else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_sample()) {
 		/* punching in and punching out after session end */
-		return max_framepos;
+		return max_samplepos;
+	}
+
+	return current_end_sample ();
+}
+
+
+
+/* dedicated thread for signal emission.
+ *
+ * while sending cross-thread signals from the process thread
+ * is fine in general, PBD::Signal's use of boost::function and
+ * boost:bind can produce a vast overhead which is not
+ * acceptable for low latency.
+ *
+ * This works around the issue by moving the boost overhead
+ * out of the RT thread. The overall load is probably higher but
+ * the realtime thread remains unaffected.
+ */
+
+void
+Session::emit_route_signals ()
+{
+	// TODO use RAII to allow using these signals in other places
+	BatchUpdateStart(); /* EMIT SIGNAL */
+	boost::shared_ptr<RouteList> r = routes.reader ();
+	for (RouteList::const_iterator ci = r->begin(); ci != r->end(); ++ci) {
+		(*ci)->emit_pending_signals ();
+	}
+	BatchUpdateEnd(); /* EMIT SIGNAL */
+}
+
+void
+Session::emit_thread_start ()
+{
+	if (_rt_thread_active) {
+		return;
+	}
+	_rt_thread_active = true;
+
+	if (pthread_create (&_rt_emit_thread, NULL, emit_thread, this)) {
+		_rt_thread_active = false;
+	}
+}
+
+void
+Session::emit_thread_terminate ()
+{
+	if (!_rt_thread_active) {
+		return;
+	}
+	_rt_thread_active = false;
+
+	if (pthread_mutex_lock (&_rt_emit_mutex) == 0) {
+		pthread_cond_signal (&_rt_emit_cond);
+		pthread_mutex_unlock (&_rt_emit_mutex);
+	}
+
+	void *status;
+	pthread_join (_rt_emit_thread, &status);
+}
+
+void *
+Session::emit_thread (void *arg)
+{
+	Session *s = static_cast<Session *>(arg);
+	s->emit_thread_run ();
+	pthread_exit (0);
+	return 0;
+}
+
+void
+Session::emit_thread_run ()
+{
+	pthread_mutex_lock (&_rt_emit_mutex);
+	while (_rt_thread_active) {
+		emit_route_signals();
+		pthread_cond_wait (&_rt_emit_cond, &_rt_emit_mutex);
+	}
+	pthread_mutex_unlock (&_rt_emit_mutex);
+}
+
+bool
+Session::follow_transport_master (pframes_t nframes)
+{
+	TransportMasterManager& tmm (TransportMasterManager::instance());
+
+	double slave_speed;
+	samplepos_t slave_transport_sample;
+	sampleoffset_t delta;
+
+	if (tmm.master_invalid_this_cycle()) {
+		DEBUG_TRACE (DEBUG::Slave, "session told not to use the transport master this cycle\n");
+		goto noroll;
+	}
+
+	slave_speed = tmm.get_current_speed_in_process_context();
+	slave_transport_sample = tmm.get_current_position_in_process_context ();
+	delta = _transport_sample - slave_transport_sample;
+
+	DEBUG_TRACE (DEBUG::Slave, string_compose ("session at %1, master at %2, delta: %3 res: %4\n", _transport_sample, slave_transport_sample, delta, tmm.current()->resolution()));
+
+	track_transport_master (slave_speed, slave_transport_sample);
+
+	if (transport_master_tracking_state == Running) {
+
+		if (!actively_recording() && abs (delta) > tmm.current()->resolution()) {
+			DEBUG_TRACE (DEBUG::Slave, string_compose ("average slave delta %1 greater than slave resolution %2\n", delta, tmm.current()->resolution()));
+			if (micro_locate (-delta) != 0) {
+				DEBUG_TRACE (DEBUG::Slave, "micro-locate didn't work, set no disk output true\n");
+
+				/* run routes as normal, but no disk output */
+				DiskReader::set_no_disk_output (true);
+			}
+			return true;
+		}
+
+		if (transport_master_tracking_state == Running) {
+			/* speed is set, we're locked, and good to go */
+			DiskReader::set_no_disk_output (false);
+			return true;
+		}
+	}
+
+  noroll:
+	/* don't move at all */
+	DEBUG_TRACE (DEBUG::Slave, "no roll\n")
+	no_roll (nframes);
+	return false;
+}
+
+void
+Session::track_transport_master (float slave_speed, samplepos_t slave_transport_sample)
+{
+	boost::shared_ptr<TransportMaster> master (TransportMasterManager::instance().current());
+
+	assert (master);
+
+	DEBUG_TRACE (DEBUG::Slave, string_compose ("session has master tracking state as %1\n", transport_master_tracking_state));
+
+	if (slave_speed != 0.0f) {
+
+		/* slave is running */
+
+		switch (transport_master_tracking_state) {
+		case Stopped:
+			if (master->requires_seekahead()) {
+				master_wait_end = slave_transport_sample + master->seekahead_distance ();
+				DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", master_wait_end));
+				/* we can call locate() here because we are in process context */
+				if (micro_locate (master_wait_end - _transport_sample) != 0) {
+					locate (master_wait_end, false, false);
+				}
+				transport_master_tracking_state = Waiting;
+
+			} else {
+
+				DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_sample));
+
+				if (slave_transport_sample != _transport_sample) {
+					DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_sample, slave_transport_sample));
+					if (micro_locate (slave_transport_sample - _transport_sample) != 0) {
+						locate (slave_transport_sample, false, false);
+					}
+				}
+				transport_master_tracking_state = Running;
+			}
+			break;
+
+		case Waiting:
+		default:
+			break;
+		}
+
+		if (transport_master_tracking_state == Waiting) {
+
+			DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_sample));
+
+			if (slave_transport_sample >= master_wait_end) {
+
+				DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_sample, _transport_sample));
+
+				transport_master_tracking_state = Running;
+
+				/* now perform a "micro-seek" within the disk buffers to realign ourselves
+				   precisely with the master.
+				*/
+
+				if (micro_locate (slave_transport_sample - _transport_sample) != 0) {
+					cerr << "cannot micro-seek\n";
+					/* XXX what? */
+				}
+			}
+		}
+
+		if (transport_master_tracking_state == Running && _transport_speed == 0.0f) {
+			DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
+			start_transport ();
+		}
+
+	} else { // slave_speed is 0
+
+		/* slave has stopped */
+
+		if (_transport_speed != 0.0f) {
+			DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 sample %2 tf %3\n", slave_speed, slave_transport_sample, _transport_sample));
+			stop_transport ();
+		}
+
+		if (slave_transport_sample != _transport_sample) {
+			DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_sample));
+			force_locate (slave_transport_sample, false);
+		}
+
+		reset_slave_state();
 	}
+}
 
-	return current_end_frame ();
+void
+Session::reset_slave_state ()
+{
+	transport_master_tracking_state = Stopped;
+	DiskReader::set_no_disk_output (false);
 }