X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_process.cc;h=eb986a3d8346d1573f36425cee263ede2db4cbe9;hb=015fc7b39fab97cee1875231694adce43155ceb5;hp=c877abdca462232061669d249a48c223164d6577;hpb=fedf3d34f32264ac57c6a222b678dc90f2bb1a88;p=ardour.git

diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc
index c877abdca4..eb986a3d83 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>
@@ -23,21 +22,21 @@
 #include <algorithm>
 #include <unistd.h>
 
-#include <pbd/error.h>
+#include "pbd/error.h"
 
 #include <glibmm/thread.h>
 
-#include <ardour/ardour.h>
-#include <ardour/session.h>
-#include <ardour/timestamps.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/audioengine.h>
-#include <ardour/slave.h>
-#include <ardour/auditioner.h>
-#include <ardour/cycles.h>
-#include <ardour/cycle_timer.h>
+#include "ardour/ardour.h"
+#include "ardour/session.h"
+#include "ardour/timestamps.h"
+#include "ardour/audio_diskstream.h"
+#include "ardour/audioengine.h"
+#include "ardour/slave.h"
+#include "ardour/auditioner.h"
+#include "ardour/cycles.h"
+#include "ardour/cycle_timer.h"
 
-#include <midi++/manager.h>
+#include "midi++/manager.h"
 
 #include "i18n.h"
 
@@ -45,28 +44,44 @@ 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.
+ */
 void
 Session::process (nframes_t nframes)
 {
+	// This is no more the appropriate place to call cycle
+	// start. cycle_start needs to be called at the Route::roll()
+	// where the signals which we want to mixdown have been calculated.
+	//
 	MIDI::Manager::instance()->cycle_start(nframes);
 
-	if (synced_to_jack() && waiting_to_start) {
-		if ( _engine.transport_state() == AudioEngine::TransportRolling) {
-			actually_start_transport ();
-		}
+	_silent = false;
+
+	if (processing_blocked()) {
+		_silent = true;
+		return;
 	}
 
 	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();
-
+	// the ticker is for sending time information like MidiClock
+	nframes_t transport_frames = transport_frame();
+	BBT_Time  transport_bbt;
+	bbt_time(transport_frames, transport_bbt);
+	SMPTE::Time transport_smpte;
+	smpte_time(transport_frames, transport_smpte);
+	tick (transport_frames, transport_bbt, transport_smpte); /* EMIT SIGNAL */
+	
 	SendFeedback (); /* EMIT SIGNAL */
+	
+	MIDI::Manager::instance()->cycle_end();
 }
 
 void
@@ -79,7 +94,13 @@ Session::prepare_diskstreams ()
 }
 
 int
-Session::no_roll (nframes_t nframes, nframes_t offset)
+Session::fail_roll (nframes_t nframes)
+{
+	return no_roll (nframes);
+}
+
+int
+Session::no_roll (nframes_t nframes)
 {
 	nframes_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
 	int ret = 0;
@@ -87,25 +108,18 @@ Session::no_roll (nframes_t nframes, nframes_t offset)
 	boost::shared_ptr<RouteList> r = routes.reader ();
 
 	if (_click_io) {
-		_click_io->silence (nframes, offset);
-	}
-
-	if (g_atomic_int_get (&processing_prohibited)) {
-		for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-			(*i)->silence (nframes, offset);
-		}
-		return 0;
+		_click_io->silence (nframes);
 	}
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 		
-		if ((*i)->hidden()) {
+		if ((*i)->is_hidden()) {
 			continue;
 		}
 		
 		(*i)->set_pending_declick (declick);
 		
-		if ((*i)->no_roll (nframes, _transport_frame, end_frame, offset, non_realtime_work_pending(), 
+		if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending(), 
 				   actively_recording(), declick)) {
 			error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg;
 			ret = -1;
@@ -117,7 +131,7 @@ Session::no_roll (nframes_t nframes, nframes_t offset)
 }
 
 int
-Session::process_routes (nframes_t nframes, nframes_t offset)
+Session::process_routes (nframes_t nframes)
 {
 	bool record_active;
 	int  declick = get_transport_declick_required();
@@ -131,20 +145,20 @@ Session::process_routes (nframes_t nframes, nframes_t offset)
 
 	record_active = actively_recording(); // || (get_record_enabled() && get_punch_in());
 
-	const jack_nframes_t start_frame = _transport_frame;
-	const jack_nframes_t end_frame = _transport_frame + (jack_nframes_t)floor(nframes * _transport_speed);
+	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, start_frame, end_frame, offset, declick, record_active, rec_monitors)) < 0) {
+		if ((ret = (*i)->roll (nframes, start_frame, end_frame, 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
@@ -165,7 +179,7 @@ Session::process_routes (nframes_t nframes, nframes_t offset)
 }
 
 int
-Session::silent_process_routes (nframes_t nframes, nframes_t offset)
+Session::silent_process_routes (nframes_t nframes)
 {
 	bool record_active = actively_recording();
 	int  declick = get_transport_declick_required();
@@ -177,18 +191,18 @@ Session::silent_process_routes (nframes_t nframes, nframes_t offset)
 		declick = -1;
 	}
 	
-	const jack_nframes_t start_frame = _transport_frame;
-	const jack_nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
+	const nframes_t start_frame = _transport_frame;
+	const nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
 
 	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, start_frame, end_frame, offset, record_active, rec_monitors)) < 0) {
+		if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, 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
@@ -223,9 +237,12 @@ Session::commit_diskstreams (nframes_t nframes, bool &needs_butler)
 		}
 		
 		/* 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) {
+		if ((dret = (*i)->process (_transport_frame, nframes, actively_recording(), get_rec_monitors_input())) == 0) {
 			if ((*i)->commit (nframes)) {
 				needs_butler = true;
 			}
@@ -253,22 +270,21 @@ Session::commit_diskstreams (nframes_t nframes, bool &needs_butler)
 	}
 }
 
-
+/** Process callback used when the auditioner is not active */
 void
 Session::process_with_events (nframes_t nframes)
 {
 	Event*         ev;
-	nframes_t this_nframes;
-	nframes_t end_frame;
-	nframes_t offset;
-	nframes_t stop_limit;
-	long           frames_moved;
+	nframes_t      this_nframes;
+	nframes_t      end_frame;
 	bool           session_needs_butler = false;
-
+	nframes_t      stop_limit;
+	long           frames_moved;
+	
 	/* make sure the auditioner is silent */
 
 	if (auditioner) {
-		auditioner->silence (nframes, 0);
+		auditioner->silence (nframes);
 	}
 
 	/* handle any pending events */
@@ -297,7 +313,7 @@ Session::process_with_events (nframes_t nframes)
 	}
 
 	if (!process_can_proceed()) {
-		no_roll (nframes, 0);
+		_silent = true;
 		return;
 	}
 
@@ -306,29 +322,41 @@ Session::process_with_events (nframes_t nframes)
 		return;
 	}
 
-	end_frame = _transport_frame + nframes;
+	/// TODO: Figure out what happens to phi and phase, if transport speed momentarily becomes
+	/// 1.0 eg. during the adjustments of a slave. If that is a bug, then AudioDiskstream::process
+	/// is very likely broken too
+	if (_transport_speed == 1.0) {
+		frames_moved = (long) nframes;
+	} else {		
+		frames_moved = (long) AudioDiskstream::
+			calculate_varispeed_playback_distance(nframes, phase, phi, target_phi); 
+	}
+
+	end_frame = _transport_frame + (nframes_t)frames_moved;
 
 	{
 		Event* this_event;
 		Events::iterator the_next_one;
 		
-		if (post_transport_work & (PostTransportLocate|PostTransportStop)) {
-			no_roll (nframes, 0);
+		if (!process_can_proceed()) {
+			_silent = true;
 			return;
 		}
 		
 		if (!_exporting && _slave) {
-			if (!follow_slave (nframes, 0)) {
+			if (!follow_slave (nframes)) {
 				return;
 			}
 		} 
 
 		if (_transport_speed == 0) {
-			no_roll (nframes, 0);
+			no_roll (nframes);
 			return;
 		}
 	
-		send_midi_time_code_for_cycle(nframes);
+		if (!_exporting) {
+			send_midi_time_code_for_cycle (nframes);
+		}
 
 		if (actively_recording()) {
 			stop_limit = max_frames;
@@ -342,7 +370,7 @@ Session::process_with_events (nframes_t nframes)
 		}
 
 		if (maybe_stop (stop_limit)) {
-			no_roll (nframes, 0);
+			no_roll (nframes);
 			return;
 		} 
 
@@ -350,44 +378,37 @@ Session::process_with_events (nframes_t nframes)
 		the_next_one = next_event;
 		++the_next_one;
 
-		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; /* real (jack) time relative */
 
-				this_nframes = nframes;
-				
-			} else {
-				
-				/* compute nframes to next event */
-
-				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) {
 				
-				click (_transport_frame, nframes, offset);
+				click (_transport_frame, this_nframes);
 				
 				/* now process frames between now and the first event in this block */
 				prepare_diskstreams ();
 
-				if (process_routes (this_nframes, offset)) {
-					no_roll (nframes, 0);
+				if (process_routes (this_nframes)) {
+					fail_roll (nframes);
 					return;
 				}
 				
 				commit_diskstreams (this_nframes, session_needs_butler);
 
 				nframes -= this_nframes;
-				offset += this_nframes;
 				
-				frames_moved = (nframes_t) floor (_transport_speed * this_nframes);
-			
 				if (frames_moved < 0) {
 					decrement_transport_position (-frames_moved);
 				} else {
@@ -398,6 +419,8 @@ Session::process_with_events (nframes_t nframes)
 				check_declick_out ();
 			}
 
+			_engine.split_cycle (this_nframes);
+			
 			/* now handle this event and all others scheduled for the same time */
 			
 			while (this_event && this_event->action_frame == _transport_frame) {
@@ -413,14 +436,13 @@ Session::process_with_events (nframes_t nframes)
 
 			/* if an event left our state changing, do the right thing */
 
-			if (non_realtime_work_pending()) {
-				no_roll (nframes, offset);
+			if (nframes && non_realtime_work_pending()) {
+				no_roll (nframes);
 				break;
 			}
 
 			/* 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);
 			
 		}
 
@@ -454,9 +476,9 @@ Session::transport_locked () const
 }
 
 bool
-Session::follow_slave (nframes_t nframes, nframes_t offset)
+Session::follow_slave (nframes_t nframes)
 {
-	float slave_speed;
+	double slave_speed;
 	nframes_t slave_transport_frame;
 	nframes_t this_delta;
 	int dir;
@@ -486,16 +508,7 @@ Session::follow_slave (nframes_t nframes, nframes_t offset)
 		slave_speed = 0.0f;
 	}
 
-#if 0
-	cerr << "delta = " << (int) (dir * this_delta)
-	     << " speed = " << slave_speed 
-	     << " ts = " << _transport_speed 
-	     << " 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
@@ -512,31 +525,122 @@ Session::follow_slave (nframes_t nframes, nframes_t offset)
 		   our speed to remain locked.
 		*/
 
-		if (delta_accumulator_cnt >= delta_accumulator_size) {
-			have_first_delta_accumulator = true;
-			delta_accumulator_cnt = 0;
-		}
+		calculate_moving_average_of_slave_delta(dir, this_delta);
+	}
+	
+	track_slave_state(slave_speed, slave_transport_frame, this_delta, starting);
 
-		if (delta_accumulator_cnt != 0 || this_delta < _current_frame_rate) {
-			delta_accumulator[delta_accumulator_cnt++] = dir*this_delta;
-		}
-		
-		if (have_first_delta_accumulator) {
-			average_slave_delta = 0;
-			for (int i = 0; i < delta_accumulator_size; ++i) {
-				average_slave_delta += delta_accumulator[i];
-			}
-			average_slave_delta /= delta_accumulator_size;
-			if (average_slave_delta < 0) {
-				average_dir = -1;
-				average_slave_delta = -average_slave_delta;
+	if (slave_state == Running && !_slave->is_always_synced() && !config.get_timecode_source_is_synced()) {
+
+		if (_transport_speed != 0.0f) {
+			
+			/* 
+			   note that average_dir is +1 or -1 
+			*/
+			
+			float delta;
+
+			#ifdef USE_MOVING_AVERAGE_OF_SLAVE
+				if (average_slave_delta == 0) {
+					delta = this_delta;
+					delta *= dir;
+				} else {
+					delta = average_slave_delta;
+					delta *= average_dir;
+				}
+			#else
+				delta = this_delta;
+				delta *= dir;
+			#endif
+
+			float adjusted_speed = slave_speed + (delta /  float(_current_frame_rate));
+			
+			if (_slave->give_slave_full_control_over_transport_speed()) {
+				request_transport_speed(slave_speed);
 			} else {
-				average_dir = 1;
+				request_transport_speed(adjusted_speed);
+				#ifdef DEBUG_SLAVES
+				cerr << "adjust using " << delta
+					 << " towards " << adjusted_speed
+					 << " ratio = " << adjusted_speed / slave_speed
+					 << " current = " << _transport_speed
+					 << " slave @ " << slave_speed
+					 << endl;
+				#endif
 			}
-			// cerr << "avgdelta = " << average_slave_delta*average_dir << endl;
+			
+			if (abs(average_slave_delta) > (long) _slave->resolution()) {
+				cerr << "average slave delta greater than slave resolution, going to silent motion\n";
+				goto silent_motion;
+			}
+		}
+	} 
+	
+	#ifdef DEBUG_SLAVES
+	if (slave_speed != 0.0)
+	cerr << "delta = " << (int) (dir * this_delta)
+		 << " speed = " << slave_speed 
+		 << " ts = " << _transport_speed 
+		 << " M@ "<< slave_transport_frame << " S@ " << _transport_frame 
+		 << " avgdelta = " << average_slave_delta 
+		 << endl;
+	#endif	
+
+	if (!starting && !non_realtime_work_pending()) {
+		/* speed is set, we're locked, and good to go */
+		return true;
+	}
+
+  silent_motion:
+	#ifdef DEBUG_SLAVES	
+	cerr << "reached silent_motion:" <<endl;
+	#endif
+	
+	follow_slave_silently (nframes, slave_speed);
+	
+  noroll:
+	/* don't move at all */
+	#ifdef DEBUG_SLAVES	
+	cerr << "reached no_roll:" <<endl;
+	#endif
+	no_roll (nframes);
+	return false;
+}
+
+void
+Session::calculate_moving_average_of_slave_delta(int dir, nframes_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++] = long(dir) * long(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 /= long(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, 
+		nframes_t slave_transport_frame, 
+		nframes_t this_delta,
+		bool starting)
+{
 	if (slave_speed != 0.0f) {
 
 		/* slave is running */
@@ -576,10 +680,13 @@ Session::follow_slave (nframes_t nframes, nframes_t offset)
 
 		if (slave_state == Waiting) {
 
-			// cerr << "waiting at " << slave_transport_frame << endl;
+		#ifdef DEBUG_SLAVES
+			cerr << "waiting at " << slave_transport_frame << endl;
+		#endif			
 			if (slave_transport_frame >= slave_wait_end) {
-				// cerr << "\tstart at " << _transport_frame << endl;
-
+#ifdef DEBUG_SLAVES
+				cerr << "\tstart at " << _transport_frame << endl;
+#endif
 				slave_state = Running;
 
 				bool ok = true;
@@ -601,96 +708,52 @@ Session::follow_slave (nframes_t nframes, nframes_t offset)
 					_transport_frame += frame_delta;
 				       
 				} else {
-					// cerr << "cannot micro-seek\n";
+					cerr << "cannot micro-seek\n";
 					/* XXX what? */
 				}
 
-				memset (delta_accumulator, 0, sizeof (nframes_t) * delta_accumulator_size);
-				average_slave_delta = 0;
+				memset (delta_accumulator, 0, sizeof (long) * delta_accumulator_size);
+				average_slave_delta = 0L;
 				this_delta = 0;
 			}
 		}
 		
 		if (slave_state == Running && _transport_speed == 0.0f) {
 			
-			// cerr << "slave starts transport\n";
-			
+        #ifdef DEBUG_SLAVES
+			cerr << "slave starts transport\n";
+        #endif
 			start_transport ();
 		} 
 
-	} else {
+	} else { // slave_speed is 0
 
 		/* slave has stopped */
 
 		if (_transport_speed != 0.0f) {
 
-			// cerr << "slave stops transport: " << slave_speed << " frame: " << slave_transport_frame 
-			// << " tf = " << _transport_frame
-			// << endl;
+         #ifdef DEBUG_SLAVES
+			cerr << "slave stops transport: " << slave_speed << " frame: " << slave_transport_frame 
+			     << " tf = " << _transport_frame << endl;
+         #endif
 			
-			if (Config->get_slave_source() == JACK) {
-				last_stop_frame = _transport_frame;
-			}
-
 			stop_transport();
 		}
 
 		if (slave_transport_frame != _transport_frame) {
-			// cerr << "slave stopped, move to " << slave_transport_frame << endl;
+        #ifdef DEBUG_SLAVES			
+			cerr << "slave stopped, move to " << slave_transport_frame << endl;
+        #endif
 			force_locate (slave_transport_frame, false);
 		}
 
 		slave_state = Stopped;
 	}
+}
 
-	if (slave_state == Running && !Config->get_timecode_source_is_synced()) {
-
-
-		if (_transport_speed != 0.0f) {
-			
-			/* 
-			   note that average_dir is +1 or -1 
-			*/
-			
-			const float adjust_seconds = 1.0f;
-			float delta;
-
-			//if (average_slave_delta == 0) {
-				delta = this_delta;
-				delta *= dir;
-//			} else {
-//				delta = average_slave_delta;
-//				delta *= average_dir;
-//			}
-
-			float adjusted_speed = slave_speed +
-				(delta / (adjust_seconds * _current_frame_rate));
-			
-			// cerr << "adjust using " << delta
-			// << " towards " << adjusted_speed
-			// << " ratio = " << adjusted_speed / slave_speed
-			// << " current = " << _transport_speed
-			// << " slave @ " << slave_speed
-			// << endl;
-			
-			request_transport_speed (adjusted_speed);
-			
-#if 1
-			if ((nframes_t) average_slave_delta > _slave->resolution()) {
-				// cerr << "not locked\n";
-				goto silent_motion;
-			}
-#endif
-		}
-	} 
-
-	if (!starting && !non_realtime_work_pending()) {
-		/* speed is set, we're locked, and good to go */
-		return true;
-	}
-
-  silent_motion:
-
+void
+Session::follow_slave_silently (nframes_t nframes, float slave_speed)
+{
 	if (slave_speed && _transport_speed) {
 
 		/* something isn't right, but we should move with the master
@@ -700,7 +763,7 @@ Session::follow_slave (nframes_t nframes, nframes_t offset)
 		bool need_butler;
 		
 		prepare_diskstreams ();
-		silent_process_routes (nframes, offset);
+		silent_process_routes (nframes);
 		commit_diskstreams (nframes, need_butler);
 
 		if (need_butler) {
@@ -729,11 +792,6 @@ Session::follow_slave (nframes_t nframes, nframes_t offset)
 
 		maybe_stop (stop_limit);
 	}
-
-  noroll:
-	/* don't move at all */
-	no_roll (nframes, 0);
-	return false;
 }
 
 void
@@ -742,74 +800,83 @@ Session::process_without_events (nframes_t nframes)
 	bool session_needs_butler = false;
 	nframes_t stop_limit;
 	long frames_moved;
-	nframes_t offset = 0;
 
-	{
-		if (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)) {
 			return;
 		}
-	
-		send_midi_time_code_for_cycle(nframes);
+	} 
+
+	if (_transport_speed == 0) {
+		fail_roll (nframes);
+		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)) {
+		fail_roll (nframes);
+		return;
+	} 
 
-		if (maybe_sync_start (nframes, offset)) {
-			return;
-		}
+	if (maybe_sync_start (nframes)) {
+		return;
+	}
 
-		click (_transport_frame, nframes, offset);
+	click (_transport_frame, nframes);
 
-		prepare_diskstreams ();
+	prepare_diskstreams ();
 	
-		frames_moved = (long) floor (_transport_speed * nframes);
-
-		if (process_routes (nframes, offset)) {
-			no_roll (nframes, offset);
- 			return;
- 		}
+	/// TODO: Figure out what happens to phi and phase, if transport speed momentarily becomes
+	/// 1.0 eg. during the adjustments of a slave. If that is a bug, then AudioDiskstream::process
+	/// is very likely broken too
+	if (_transport_speed == 1.0) {
+		frames_moved = (long) nframes;
+	} else {		
+		frames_moved = (long) AudioDiskstream::
+			calculate_varispeed_playback_distance(nframes, phase, phi, target_phi); 
+	}
+
+	if (process_routes (nframes)) {
+		fail_roll (nframes);
+		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);
-		}
+	if (frames_moved < 0) {
+		decrement_transport_position (-frames_moved);
+	} else {
+		increment_transport_position (frames_moved);
+	}
 
-		maybe_stop (stop_limit);
-		check_declick_out ();
-
-	} /* implicit release of route lock */
+	maybe_stop (stop_limit);
+	check_declick_out ();
 
 	if (session_needs_butler)
 		summon_butler ();
 }
 
+/** Process callback used when the auditioner is active.
+ * @param nframes number of frames to process.
+ */
 void
 Session::process_audition (nframes_t nframes)
 {
@@ -817,8 +884,8 @@ Session::process_audition (nframes_t nframes)
 	boost::shared_ptr<RouteList> r = routes.reader ();
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-		if (!(*i)->hidden()) {
-			(*i)->silence (nframes, 0);
+		if (!(*i)->is_hidden()) {
+			(*i)->silence (nframes);
 		}
 	}
 
@@ -846,33 +913,52 @@ Session::process_audition (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)
+Session::maybe_sync_start (nframes_t& nframes)
 {
 	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);
+		/* generate silence up to the sync point, then
+		   adjust nframes + offset to reflect whatever
+		   is left to do.
+		*/
+
+		no_roll (sync_offset);
 		nframes -= sync_offset;
-		offset += sync_offset;
+		Port::increment_port_offset (sync_offset);
 		waiting_for_sync_offset = false;
 		
 		if (nframes == 0) {
-			return true; // done
+			return true; // done, nothing left to process
 		}
 		
 	} else {
-		no_roll (nframes, 0);
-		return true; // done
+
+		/* sync offset point is not within this process()
+		   cycle, so just generate silence. and don't bother 
+		   with any fancy stuff here, just the minimal silence.
+		*/
+
+		_silent = true;
+
+		if (Config->get_locate_while_waiting_for_sync()) {
+			if (micro_locate (nframes)) {
+				/* XXX ERROR !!! XXX */
+			}
+		}
+
+		return true; // done, nothing left to process
 	}
 
 	return false;