X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=d6890b31ae3f34346b9ba8d2d58a6ffe72d34247;hb=44fd104ada0fbd8b76d34150e941d85d6de6f81b;hp=e218bd24584b301f5ec73abe4a4dea52fa863bd6;hpb=b09ab546542040b1d468c9925c60bda2dfd80da8;p=ardour.git

diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc
index e218bd2458..d6890b31ae 100644
--- a/libs/ardour/session_process.cc
+++ b/libs/ardour/session_process.cc
@@ -15,7 +15,6 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
 #include <cmath>
@@ -24,7 +23,7 @@
 #include <unistd.h>
 
 #include <pbd/error.h>
- 
+
 #include <glibmm/thread.h>
 
 #include <ardour/ardour.h>
@@ -37,15 +36,24 @@
 #include <ardour/cycles.h>
 #include <ardour/cycle_timer.h>
 
+#include <midi++/manager.h>
+
 #include "i18n.h"
 
 using namespace ARDOUR;
-//using namespace sigc;
+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.
+ */
 void
-Session::process (jack_nframes_t nframes)
+Session::process (nframes_t nframes)
 {
+	MIDI::Manager::instance()->cycle_start(nframes);
+
+	_silent = false;
+
 	if (synced_to_jack() && waiting_to_start) {
 		if ( _engine.transport_state() == AudioEngine::TransportRolling) {
 			actually_start_transport ();
@@ -53,47 +61,49 @@ Session::process (jack_nframes_t nframes)
 	}
 
 	if (non_realtime_work_pending()) {
-		if (g_atomic_int_get (&butler_should_do_transport_work) == 0) {
+		if (!transport_work_requested ()) {
 			post_transport ();
 		} 
 	} 
 	
 	(this->*process_function) (nframes);
+	
+	MIDI::Manager::instance()->cycle_end();
+
+	SendFeedback (); /* EMIT SIGNAL */
 }
 
 void
 Session::prepare_diskstreams ()
 {
-	for (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_diskstreams.end(); ++i) {
+	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 		(*i)->prepare ();
 	}
 }
 
 int
-Session::no_roll (jack_nframes_t nframes, jack_nframes_t offset)
+Session::no_roll (nframes_t nframes, nframes_t offset)
 {
-	jack_nframes_t end_frame = _transport_frame + nframes;
+	nframes_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
 	int ret = 0;
 	bool declick = get_transport_declick_required();
+	boost::shared_ptr<RouteList> r = routes.reader ();
 
 	if (_click_io) {
 		_click_io->silence (nframes, offset);
 	}
 
-	/* XXX we're supposed to have the route_lock while doing this.
-	   this is really bad ...
-	*/
-
 	if (g_atomic_int_get (&processing_prohibited)) {
-		for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+		for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 			(*i)->silence (nframes, offset);
 		}
 		return 0;
 	}
 
-	for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 		
-		if ((*i)->hidden()) {
+		if ((*i)->is_hidden()) {
 			continue;
 		}
 		
@@ -111,11 +121,12 @@ Session::no_roll (jack_nframes_t nframes, jack_nframes_t offset)
 }
 
 int
-Session::process_routes (jack_nframes_t nframes, jack_nframes_t offset)
+Session::process_routes (nframes_t nframes, nframes_t offset)
 {
 	bool record_active;
 	int  declick = get_transport_declick_required();
 	bool rec_monitors = get_rec_monitors_input();
+	boost::shared_ptr<RouteList> r = routes.reader ();
 
 	if (transport_sub_state & StopPendingCapture) {
 		/* force a declick out */
@@ -124,24 +135,28 @@ Session::process_routes (jack_nframes_t nframes, jack_nframes_t offset)
 
 	record_active = actively_recording(); // || (get_record_enabled() && get_punch_in());
 
-	for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+	const nframes_t start_frame = _transport_frame;
+	const nframes_t end_frame = _transport_frame + (nframes_t)floor(nframes * _transport_speed);
+
+	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 
 		int ret;
 
-		if ((*i)->hidden()) {
+		if ((*i)->is_hidden()) {
 			continue;
 		}
 
 		(*i)->set_pending_declick (declick);
 
-		if ((ret = (*i)->roll (nframes, _transport_frame, _transport_frame + nframes, offset, declick, record_active, rec_monitors)) < 0) {
+		if ((ret = (*i)->roll (nframes, start_frame, end_frame, offset, declick, record_active, rec_monitors)) < 0) {
 
 			/* we have to do this here. Route::roll() for an AudioTrack will have called AudioDiskstream::process(),
 			   and the DS will expect AudioDiskstream::commit() to be called. but we're aborting from that
 			   call path, so make sure we release any outstanding locks here before we return failure.
 			*/
 
-			for (AudioDiskstreamList::iterator ids = audio_diskstreams.begin(); ids != audio_diskstreams.end(); ++ids) {
+			boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+			for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) {
 				(*ids)->recover ();
 			}
 
@@ -154,33 +169,38 @@ Session::process_routes (jack_nframes_t nframes, jack_nframes_t offset)
 }
 
 int
-Session::silent_process_routes (jack_nframes_t nframes, jack_nframes_t offset)
+Session::silent_process_routes (nframes_t nframes, nframes_t offset)
 {
 	bool record_active = actively_recording();
 	int  declick = get_transport_declick_required();
 	bool rec_monitors = get_rec_monitors_input();
+	boost::shared_ptr<RouteList> r = routes.reader ();
 
 	if (transport_sub_state & StopPendingCapture) {
 		/* force a declick out */
 		declick = -1;
 	}
+	
+	const nframes_t start_frame = _transport_frame;
+	const nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
 
-	for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 
 		int ret;
 
-		if ((*i)->hidden()) {
+		if ((*i)->is_hidden()) {
 			continue;
 		}
 
-		if ((ret = (*i)->silent_roll (nframes, _transport_frame, _transport_frame + nframes, offset, record_active, rec_monitors)) < 0) {
+		if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, offset, record_active, rec_monitors)) < 0) {
 			
 			/* we have to do this here. Route::roll() for an AudioTrack will have called AudioDiskstream::process(),
 			   and the DS will expect AudioDiskstream::commit() to be called. but we're aborting from that
 			   call path, so make sure we release any outstanding locks here before we return failure.
 			*/
 
-			for (AudioDiskstreamList::iterator ids = audio_diskstreams.begin(); ids != audio_diskstreams.end(); ++ids) {
+			boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+			for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) {
 				(*ids)->recover ();
 			}
 
@@ -193,19 +213,23 @@ Session::silent_process_routes (jack_nframes_t nframes, jack_nframes_t offset)
 }
 
 void
-Session::commit_diskstreams (jack_nframes_t nframes, bool &needs_butler)
+Session::commit_diskstreams (nframes_t nframes, bool &needs_butler)
 {
 	int dret;
 	float pworst = 1.0f;
 	float cworst = 1.0f;
 
-	for (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_diskstreams.end(); ++i) {
+	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 
 		if ((*i)->hidden()) {
 			continue;
 		}
 		
 		/* force all diskstreams not handled by a Route to call do their stuff.
+		   Note: the diskstreams that were handled by a route will just return zero
+		   from this call, because they know they were processed. So in fact, this
+		   also runs commit() for every diskstream.
 		 */
 
 		if ((dret = (*i)->process (_transport_frame, nframes, 0, actively_recording(), get_rec_monitors_input())) == 0) {
@@ -236,21 +260,26 @@ Session::commit_diskstreams (jack_nframes_t nframes, bool &needs_butler)
 	}
 }
 
+/** Process callback used when the auditioner is not active */
 void
-Session::process_with_events (jack_nframes_t nframes)
+Session::process_with_events (nframes_t nframes)
 {
-	Event* ev;
-	jack_nframes_t this_nframes;
-	jack_nframes_t end_frame;
-	jack_nframes_t offset;
+	Event*         ev;
+	nframes_t this_nframes;
+	nframes_t end_frame;
+	nframes_t offset;
 	bool session_needs_butler = false;
-	jack_nframes_t stop_limit;
+	nframes_t stop_limit;
 	long           frames_moved;
+	
+	/* make sure the auditioner is silent */
 
 	if (auditioner) {
 		auditioner->silence (nframes, 0);
 	}
 
+	/* handle any pending events */
+
 	while (pending_events.read (&ev, 1) == 1) {
 		merge_event (ev);
 	}
@@ -266,27 +295,32 @@ Session::process_with_events (jack_nframes_t nframes)
 		process_event (ev);
 	}
 
+	/* Events caused a transport change, send an MTC Full Frame (SMPTE) message.
+	 * This is sent whether rolling or not, to give slaves an idea of ardour time
+	 * on locates (and allow slow slaves to position and prepare for rolling)
+	 */
+	if (_send_smpte_update) {
+		send_full_time_code(nframes);
+	}
+
 	if (!process_can_proceed()) {
-		no_roll (nframes, 0);
+		_silent = true;
 		return;
 	}
-		
+
 	if (events.empty() || next_event == events.end()) {
 		process_without_events (nframes);
 		return;
 	}
 
-	end_frame = _transport_frame + nframes;
+	end_frame = _transport_frame + (nframes_t)abs(floor(nframes * _transport_speed));
 
 	{
-		Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
-		Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
-	
 		Event* this_event;
 		Events::iterator the_next_one;
-
-		if (!rm.locked() || !dsm.locked() || (post_transport_work & (PostTransportLocate|PostTransportStop))) {
-			no_roll (nframes, 0);
+		
+		if (!process_can_proceed()) {
+			_silent = true;
 			return;
 		}
 		
@@ -300,6 +334,10 @@ Session::process_with_events (jack_nframes_t nframes)
 			no_roll (nframes, 0);
 			return;
 		}
+	
+		if (!_exporting) {
+			send_midi_time_code_for_cycle (nframes);
+		}
 
 		if (actively_recording()) {
 			stop_limit = max_frames;
@@ -323,22 +361,19 @@ Session::process_with_events (jack_nframes_t nframes)
 
 		offset = 0;
 
+		/* yes folks, here it is, the actual loop where we really truly
+		   process some audio */
 		while (nframes) {
 
-			if (this_event == 0 || this_event->action_frame > end_frame || this_event->action_frame < _transport_frame) {
-
-				this_nframes = nframes;
-				
-			} else {
-				
-				/* compute nframes to next event */
+			this_nframes = nframes; /* real (jack) time relative */
+			frames_moved = (long) floor (_transport_speed * nframes); /* transport relative */
 
-				if (this_event->action_frame < end_frame) {
-					this_nframes = nframes - (end_frame - this_event->action_frame);
-				} else {
-					this_nframes = nframes;
-				}
-			}
+			/* running an event, position transport precisely to its time */
+			if (this_event && this_event->action_frame <= end_frame && this_event->action_frame >= _transport_frame) {
+				/* this isn't quite right for reverse play */
+				frames_moved = (long) (this_event->action_frame - _transport_frame);
+				this_nframes = (nframes_t) abs( floor(frames_moved / _transport_speed) );
+			} 
 
 			if (this_nframes) {
 				
@@ -357,8 +392,6 @@ Session::process_with_events (jack_nframes_t nframes)
 				nframes -= this_nframes;
 				offset += this_nframes;
 				
-				frames_moved = (jack_nframes_t) floor (_transport_speed * this_nframes);
-			
 				if (frames_moved < 0) {
 					decrement_transport_position (-frames_moved);
 				} else {
@@ -390,8 +423,7 @@ Session::process_with_events (jack_nframes_t nframes)
 			}
 
 			/* this is necessary to handle the case of seamless looping */
-			/* not sure if it will work in conjuction with varispeed */
-			end_frame = _transport_frame + nframes;
+			end_frame = _transport_frame + (nframes_t) floor (nframes * _transport_speed);
 			
 		}
 
@@ -399,17 +431,9 @@ Session::process_with_events (jack_nframes_t nframes)
 
 	} /* implicit release of route lock */
 
-
-	if (session_needs_butler) {
+	if (session_needs_butler)
 		summon_butler ();
-	} 
-	
-	if (!_engine.freewheeling() && send_mtc) {
-		send_midi_time_code_in_another_thread ();
-	}
-
-	return;
-}		
+}
 
 void
 Session::reset_slave_state ()
@@ -425,7 +449,7 @@ Session::transport_locked () const
 {
 	Slave* sl = _slave;
 
-	if (!locate_pending() && ((_slave_type == None) || (sl && sl->ok() && sl->locked()))) {
+	if (!locate_pending() && ((Config->get_slave_source() == None) || (sl && sl->ok() && sl->locked()))) {
 		return true;
 	}
 
@@ -433,17 +457,17 @@ Session::transport_locked () const
 }
 
 bool
-Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
+Session::follow_slave (nframes_t nframes, nframes_t offset)
 {
 	float slave_speed;
-	jack_nframes_t slave_transport_frame;
-	jack_nframes_t this_delta;
+	nframes_t slave_transport_frame;
+	nframes_t this_delta;
 	int dir;
 	bool starting;
 
 	if (!_slave->ok()) {
 		stop_transport ();
-		set_slave_source (None, 0);
+		Config->set_slave_source (None);
 		goto noroll;
 	}
 	
@@ -469,12 +493,12 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 	cerr << "delta = " << (int) (dir * this_delta)
 	     << " speed = " << slave_speed 
 	     << " ts = " << _transport_speed 
-	     << " M@"<< slave_transport_frame << " S@" << _transport_frame 
+	     << " M@ "<< slave_transport_frame << " S@ " << _transport_frame 
 	     << " avgdelta = " << average_slave_delta 
 	     << endl;
 #endif	
 
-	if (Config->get_timecode_source_is_synced()) {
+	if (_slave->is_always_synced() || Config->get_timecode_source_is_synced()) {
 
 		/* if the TC source is synced, then we assume that its 
 		   speed is binary: 0.0 or 1.0
@@ -534,9 +558,9 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 
 				Location* al = _locations.auto_loop_location();
 
-				if (al && auto_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
+				if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
 					// cancel looping
-					request_auto_loop(false);
+					request_play_loop(false);
 				}
 
 				if (slave_transport_frame != _transport_frame) {
@@ -556,17 +580,17 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 		if (slave_state == Waiting) {
 
 			// cerr << "waiting at " << slave_transport_frame << endl;
-			Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
-				
-			if (dsm.locked() && slave_transport_frame >= slave_wait_end) {
+			if (slave_transport_frame >= slave_wait_end) {
 				// cerr << "\tstart at " << _transport_frame << endl;
 
 				slave_state = Running;
 
 				bool ok = true;
-				jack_nframes_t frame_delta = slave_transport_frame - _transport_frame;
+				nframes_t frame_delta = slave_transport_frame - _transport_frame;
+
+				boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 				
-				for (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_diskstreams.end(); ++i) {
+				for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 					if (!(*i)->can_internal_playback_seek (frame_delta)) {
 						ok = false;
 						break;
@@ -574,7 +598,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 				}
 
 				if (ok) {
-					for (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_diskstreams.end(); ++i) {
+					for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 						(*i)->internal_playback_seek (frame_delta);
 					}
 					_transport_frame += frame_delta;
@@ -584,7 +608,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 					/* XXX what? */
 				}
 
-				memset (delta_accumulator, 0, sizeof (jack_nframes_t) * delta_accumulator_size);
+				memset (delta_accumulator, 0, sizeof (nframes_t) * delta_accumulator_size);
 				average_slave_delta = 0;
 				this_delta = 0;
 			}
@@ -607,7 +631,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 			// << " tf = " << _transport_frame
 			// << endl;
 			
-			if (_slave_type == JACK) {
+			if (Config->get_slave_source() == JACK) {
 				last_stop_frame = _transport_frame;
 			}
 
@@ -622,7 +646,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 		slave_state = Stopped;
 	}
 
-	if (slave_state == Running && !Config->get_timecode_source_is_synced()) {
+	if (slave_state == Running && !_slave->is_always_synced() && !Config->get_timecode_source_is_synced()) {
 
 
 		if (_transport_speed != 0.0f) {
@@ -655,7 +679,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 			request_transport_speed (adjusted_speed);
 			
 #if 1
-			if ((jack_nframes_t) average_slave_delta > _slave->resolution()) {
+			if ((nframes_t) average_slave_delta > _slave->resolution()) {
 				// cerr << "not locked\n";
 				goto silent_motion;
 			}
@@ -678,12 +702,6 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 
 		bool need_butler;
 		
-		Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
-		if (!dsm.locked()) {
-			goto noroll;
-		}
-
-		
 		prepare_diskstreams ();
 		silent_process_routes (nframes, offset);
 		commit_diskstreams (nframes, need_butler);
@@ -692,7 +710,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 			summon_butler ();
 		}
 		
-		jack_nframes_t frames_moved = (long) floor (_transport_speed * nframes);
+		int32_t frames_moved = (int32_t) floor (_transport_speed * nframes);
 		
 		if (frames_moved < 0) {
 			decrement_transport_position (-frames_moved);
@@ -700,7 +718,7 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 			increment_transport_position (frames_moved);
 		}
 		
-		jack_nframes_t stop_limit;
+		nframes_t stop_limit;
 		
 		if (actively_recording()) {
 			stop_limit = max_frames;
@@ -722,100 +740,101 @@ Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
 }
 
 void
-Session::process_without_events (jack_nframes_t nframes)
+Session::process_without_events (nframes_t nframes)
 {
 	bool session_needs_butler = false;
-	jack_nframes_t stop_limit;
+	nframes_t stop_limit;
 	long frames_moved;
-	
-	{
-		Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
-		Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
+	nframes_t offset = 0;
 
-		if (!rm.locked() || !dsm.locked() || (post_transport_work & (PostTransportLocate|PostTransportStop))) {
-			no_roll (nframes, 0);
-			return;
-		}
-
-		if (!_exporting && _slave) {
-			if (!follow_slave (nframes, 0)) {
-				return;
-			}
-		} 
+	if (!process_can_proceed()) {
+		_silent = true;
+		return;
+	}
 
-		if (_transport_speed == 0) {
-			no_roll (nframes, 0);
+	if (!_exporting && _slave) {
+		if (!follow_slave (nframes, 0)) {
 			return;
 		}
+	} 
+
+	if (_transport_speed == 0) {
+		no_roll (nframes, 0);
+		return;
+	}
 		
-		if (actively_recording()) {
-			stop_limit = max_frames;
+	if (!_exporting) {
+		send_midi_time_code_for_cycle (nframes);
+	}
+
+	if (actively_recording()) {
+		stop_limit = max_frames;
+	} else {
+		if (Config->get_stop_at_session_end()) {
+			stop_limit = current_end_frame();
 		} else {
-			if (Config->get_stop_at_session_end()) {
-				stop_limit = current_end_frame();
-			} else {
-				stop_limit = max_frames;
-			}
+			stop_limit = max_frames;
 		}
+	}
 		
-		if (maybe_stop (stop_limit)) {
-			no_roll (nframes, 0);
-			return;
-		} 
+	if (maybe_stop (stop_limit)) {
+		no_roll (nframes, 0);
+		return;
+	} 
 
-		click (_transport_frame, nframes, 0);
+	if (maybe_sync_start (nframes, offset)) {
+		return;
+	}
 
-		prepare_diskstreams ();
+	click (_transport_frame, nframes, offset);
+
+	prepare_diskstreams ();
 	
-		frames_moved = (long) floor (_transport_speed * nframes);
+	frames_moved = (long) floor (_transport_speed * nframes);
 
-		if (process_routes (nframes, 0)) {
-			no_roll (nframes, 0);
-			return;
-		}
+	if (process_routes (nframes, offset)) {
+		no_roll (nframes, offset);
+		return;
+	}
 
-		commit_diskstreams (nframes, session_needs_butler);
+	commit_diskstreams (nframes, session_needs_butler);
 
-		if (frames_moved < 0) {
-			decrement_transport_position (-frames_moved);
-		} else {
-			increment_transport_position (frames_moved);
-		}
-		
-		maybe_stop (stop_limit);
-		check_declick_out ();
+	if (frames_moved < 0) {
+		decrement_transport_position (-frames_moved);
+	} else {
+		increment_transport_position (frames_moved);
+	}
 
-	} /* implicit release of route lock */
+	maybe_stop (stop_limit);
+	check_declick_out ();
 
-	if (session_needs_butler) {
+	if (session_needs_butler)
 		summon_butler ();
-	} 
-	
-	if (!_engine.freewheeling() && send_mtc) {
-		send_midi_time_code_in_another_thread ();
-	}
-
-	return;
-}		
+}
 
+/** Process callback used when the auditioner is active.
+ * @param nframes number of frames to process.
+ */
 void
-Session::process_audition (jack_nframes_t nframes)
+Session::process_audition (nframes_t nframes)
 {
-	Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
 	Event* ev;
+	boost::shared_ptr<RouteList> r = routes.reader ();
 
-	if (rm.locked()) {
-		for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
-			if (!(*i)->hidden()) {
-				(*i)->silence (nframes, 0);
-			}
+	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+		if (!(*i)->is_hidden()) {
+			(*i)->silence (nframes, 0);
 		}
 	}
+
+	/* run the auditioner, and if it says we need butler service, ask for it */
 	
 	if (auditioner->play_audition (nframes) > 0) {
 		summon_butler ();
 	} 
 
+	/* handle pending events */
+
 	while (pending_events.read (&ev, 1) == 1) {
 		merge_event (ev);
 	}
@@ -832,7 +851,36 @@ Session::process_audition (jack_nframes_t nframes)
 	}
 
 	if (!auditioner->active()) {
+		/* auditioner no longer active, so go back to the normal process callback */
 		process_function = &Session::process_with_events;
 	}
 }
 
+bool
+Session::maybe_sync_start (nframes_t& nframes, nframes_t& offset)
+{
+	nframes_t sync_offset;
+
+	if (!waiting_for_sync_offset) {
+		return false;
+	}
+
+	if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) {
+
+		no_roll (sync_offset, 0);
+		nframes -= sync_offset;
+		offset += sync_offset;
+		waiting_for_sync_offset = false;
+		
+		if (nframes == 0) {
+			return true; // done
+		}
+		
+	} else {
+		no_roll (nframes, 0);
+		return true; // done
+	}
+
+	return false;
+}
+