X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_transport.cc;h=69de9ead2efa836303a0cfb769c2210c8de41e94;hb=e374518ca9c4643874eee3877e270eef32d95f18;hp=31dc52a11b78f9aaaf35542346b01c0449dc9aaf;hpb=e6eb059576eefd9a26c177627ae7dd3ba2feb727;p=ardour.git

diff --git a/libs/ardour/session_transport.cc b/libs/ardour/session_transport.cc
index 31dc52a11b..69de9ead2e 100644
--- a/libs/ardour/session_transport.cc
+++ b/libs/ardour/session_transport.cc
@@ -26,21 +26,22 @@
 
 #include "pbd/undo.h"
 #include "pbd/error.h"
-#include <glibmm/thread.h>
+#include "pbd/enumwriter.h"
 #include "pbd/pthread_utils.h"
 #include "pbd/memento_command.h"
-#include "pbd/stacktrace.h"
 
 #include "midi++/mmc.h"
 #include "midi++/port.h"
 
 #include "ardour/ardour.h"
-#include "ardour/audioengine.h"
-#include "ardour/session.h"
 #include "ardour/audio_diskstream.h"
+#include "ardour/audioengine.h"
 #include "ardour/auditioner.h"
-#include "ardour/slave.h"
+#include "ardour/butler.h"
+#include "ardour/debug.h"
 #include "ardour/location.h"
+#include "ardour/session.h"
+#include "ardour/slave.h"
 
 #include "i18n.h"
 
@@ -49,6 +50,25 @@ using namespace ARDOUR;
 using namespace sigc;
 using namespace PBD;
 
+void
+Session::add_post_transport_work (PostTransportWork ptw)
+{
+	PostTransportWork oldval;
+	PostTransportWork newval;
+	int tries = 0;
+
+	while (tries < 8) {
+		oldval = (PostTransportWork) g_atomic_int_get (&_post_transport_work);
+		newval = PostTransportWork (oldval | ptw);
+		if (g_atomic_int_compare_and_exchange (&_post_transport_work, oldval, newval)) {
+			/* success */
+			return;
+		}
+	}
+
+	error << "Could not set post transport work! Crazy thread madness, call the programmers" << endmsg;
+}
+
 void
 Session::request_input_change_handling ()
 {
@@ -59,17 +79,25 @@ Session::request_input_change_handling ()
 }
 
 void
-Session::request_slave_source (SlaveSource src)
+Session::request_sync_source (SyncSource src)
 {
-	Event* ev = new Event (Event::SetSlaveSource, Event::Add, Event::Immediate, 0, 0.0);
+	Event* ev = new Event (Event::SetSyncSource, Event::Add, Event::Immediate, 0, 0.0);
+	bool seamless;
+
+	seamless = Config->get_seamless_loop ();
 
 	if (src == JACK) {
-		/* could set_seamless_loop() be disposed of entirely?*/
+		/* JACK cannot support seamless looping at present */
 		Config->set_seamless_loop (false);
 	} else {
-		Config->set_seamless_loop (true);
+		/* reset to whatever the value was before we last switched slaves */
+		Config->set_seamless_loop (_was_seamless);
 	}
-	ev->slave = src;
+
+	/* save value of seamless from before the switch */
+	_was_seamless = seamless;
+
+	ev->sync_source = src;
 	queue_event (ev);
 }
 
@@ -77,6 +105,7 @@ void
 Session::request_transport_speed (double speed)
 {
 	Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, speed);
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport speed = %1\n", speed));
 	queue_event (ev);
 }
 
@@ -89,9 +118,10 @@ Session::request_diskstream_speed (Diskstream& ds, double speed)
 }
 
 void
-Session::request_stop (bool abort)
+Session::request_stop (bool abort, bool clear_state)
 {
-	Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0, abort);
+	Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0, abort, clear_state);
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport stop, abort = %1, clear state = %2\n", abort, clear_state));
 	queue_event (ev);
 }
 
@@ -99,18 +129,20 @@ void
 Session::request_locate (nframes_t target_frame, bool with_roll)
 {
 	Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, false);
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request locate to %1\n", target_frame));
 	queue_event (ev);
 }
 
 void
-Session::force_locate (nframes_t target_frame, bool with_roll)
+Session::force_locate (nframes64_t target_frame, bool with_roll)
 {
 	Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, true);
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request forced locate to %1\n", target_frame));
 	queue_event (ev);
 }
 
 void
-Session::request_play_loop (bool yn)
+Session::request_play_loop (bool yn, bool leave_rolling)
 {
 	Event* ev;
 	Location *location = _locations.auto_loop_location();
@@ -121,10 +153,11 @@ Session::request_play_loop (bool yn)
 		return;
 	}
 
-	ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, 0.0, yn);
+	ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, (leave_rolling ? 1.0 : 0.0), yn);
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request set loop = %1, leave rolling ? %2\n", yn, leave_rolling));
 	queue_event (ev);
 
-	if (!yn && Config->get_seamless_loop() && transport_rolling()) {
+	if (!leave_rolling && !yn && Config->get_seamless_loop() && transport_rolling()) {
 		// request an immediate locate to refresh the diskstreams
 		// after disabling looping
 		request_locate (_transport_frame-1, false);
@@ -132,8 +165,24 @@ Session::request_play_loop (bool yn)
 }
 
 void
-Session::realtime_stop (bool abort)
+Session::request_play_range (list<AudioRange>* range, bool leave_rolling)
+{
+	Event* ev = new Event (Event::SetPlayAudioRange, Event::Add, Event::Immediate, 0, (leave_rolling ? 1.0 : 0.0));
+	if (range) {
+		ev->audio_range = *range;
+	} else {
+		ev->audio_range.clear ();
+	}
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Request play range, leave rolling ? %1\n", leave_rolling));
+	queue_event (ev);
+}
+
+void
+Session::realtime_stop (bool abort, bool clear_state)
 {
+	DEBUG_TRACE (DEBUG::Transport, "realtime stop\n");
+	PostTransportWork todo = PostTransportWork (0);
+
 	/* assume that when we start, we'll be moving forwards */
 
 	// FIXME: where should this really be? [DR]
@@ -142,9 +191,9 @@ Session::realtime_stop (bool abort)
 	deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
 
 	if (_transport_speed < 0.0f) {
-		post_transport_work = PostTransportWork (post_transport_work | PostTransportStop | PostTransportReverse);
+		todo = (PostTransportWork (todo | PostTransportStop | PostTransportReverse));
 	} else {
-		post_transport_work = PostTransportWork (post_transport_work | PostTransportStop);
+		todo = PostTransportWork (todo | PostTransportStop);
 	}
 
 	if (actively_recording()) {
@@ -154,17 +203,23 @@ Session::realtime_stop (bool abort)
 		   past that point to pick up delayed input.
 		*/
 
-#ifndef LEAVE_TRANSPORT_UNADJUSTED
 		decrement_transport_position (_worst_output_latency);
-#endif
 
 		/* the duration change is not guaranteed to have happened, but is likely */
 
-		post_transport_work = PostTransportWork (post_transport_work | PostTransportDuration);
+		todo = PostTransportWork (todo | PostTransportDuration);
 	}
 
 	if (abort) {
-		post_transport_work = PostTransportWork (post_transport_work | PostTransportAbort);
+		todo = PostTransportWork (todo | PostTransportAbort);
+	}
+
+	if (clear_state) {
+		todo = PostTransportWork (todo | PostTransportClearSubstate);
+	}
+
+	if (todo) {
+		add_post_transport_work (todo);
 	}
 
 	_clear_event_type (Event::StopOnce);
@@ -176,15 +231,13 @@ Session::realtime_stop (bool abort)
 	reset_slave_state ();
 
 	_transport_speed = 0;
-	phi = 0;
-	target_phi = 0;
-	phase = 0;
+	_target_transport_speed = 0;
 
 	if (config.get_use_video_sync()) {
 		waiting_for_sync_offset = true;
 	}
 
-	transport_sub_state = ((Config->get_slave_source() == None && config.get_auto_return()) ? AutoReturning : 0);
+	transport_sub_state = ((!config.get_external_sync()&& config.get_auto_return()) ? AutoReturning : 0);
 }
 
 void
@@ -192,76 +245,80 @@ Session::butler_transport_work ()
 {
   restart:
 	bool finished;
+	PostTransportWork ptw;
 	boost::shared_ptr<RouteList> r = routes.reader ();
 	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 
-	int on_entry = g_atomic_int_get (&butler_should_do_transport_work);
+	int on_entry = g_atomic_int_get (&_butler->should_do_transport_work);
 	finished = true;
+	ptw = post_transport_work();
 
-	if (post_transport_work & PostTransportCurveRealloc) {
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Butler transport work, todo = %1\n", enum_2_string (ptw)));
+		     
+	if (ptw & PostTransportCurveRealloc) {
 		for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 			(*i)->curve_reallocate();
 		}
 	}
 
-	if (post_transport_work & PostTransportInputChange) {
+	if (ptw & PostTransportInputChange) {
 		for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 			(*i)->non_realtime_input_change ();
 		}
 	}
 
-	if (post_transport_work & PostTransportSpeed) {
+	if (ptw & PostTransportSpeed) {
 		non_realtime_set_speed ();
 	}
 
-	if (post_transport_work & PostTransportReverse) {
-		
+	if (ptw & PostTransportReverse) {
+
 		clear_clicks();
 		cumulative_rf_motion = 0;
 		reset_rf_scale (0);
 
 		/* don't seek if locate will take care of that in non_realtime_stop() */
 
-		if (!(post_transport_work & PostTransportLocate)) {
+		if (!(ptw & PostTransportLocate)) {
 
 			for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 				if (!(*i)->hidden()) {
 					(*i)->non_realtime_locate (_transport_frame);
 				}
-				if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
+				if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
 					/* new request, stop seeking, and start again */
-					g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+					g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 					goto restart;
 				}
 			}
 		}
 	}
 
-	if (post_transport_work & PostTransportLocate) {
+	if (ptw & PostTransportLocate) {
 		non_realtime_locate ();
 	}
 
-	if (post_transport_work & PostTransportStop) {
-		non_realtime_stop (post_transport_work & PostTransportAbort, on_entry, finished);
+	if (ptw & PostTransportStop) {
+		non_realtime_stop (ptw & PostTransportAbort, on_entry, finished);
 		if (!finished) {
-			g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+			g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 			goto restart;
 		}
 	}
 
-	if (post_transport_work & PostTransportOverWrite) {
+	if (ptw & PostTransportOverWrite) {
 		non_realtime_overwrite (on_entry, finished);
 		if (!finished) {
-			g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+			g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 			goto restart;
 		}
 	}
 
-	if (post_transport_work & PostTransportAudition) {
+	if (ptw & PostTransportAudition) {
 		non_realtime_set_audition ();
 	}
 
-	g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+	g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 }
 
 void
@@ -283,7 +340,7 @@ Session::non_realtime_overwrite (int on_entry, bool& finished)
 		if ((*i)->pending_overwrite) {
 			(*i)->overwrite_existing_buffers ();
 		}
-		if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
+		if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
 			finished = false;
 			return;
 		}
@@ -309,6 +366,7 @@ Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
 	time_t     xnow;
 	bool       did_record;
 	bool       saved;
+	PostTransportWork ptw = post_transport_work();
 
 	did_record = false;
 	saved = false;
@@ -391,10 +449,10 @@ Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
 	}
 
 	bool const auto_return_enabled =
-		(Config->get_slave_source() == None && config.get_auto_return());
-	
+		(!config.get_external_sync() && config.get_auto_return());
+
 	if (auto_return_enabled ||
-	    (post_transport_work & PostTransportLocate) ||
+	    (ptw & PostTransportLocate) ||
 	    (_requested_return_frame >= 0) ||
 	    synced_to_jack()) {
 
@@ -403,71 +461,97 @@ Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
 		}
 
 		if ((auto_return_enabled || synced_to_jack() || _requested_return_frame >= 0) &&
-		    !(post_transport_work & PostTransportLocate)) {
+		    !(ptw & PostTransportLocate)) {
+
+	/* no explicit locate queued */
 
 			bool do_locate = false;
 
 			if (_requested_return_frame >= 0) {
+
+				/* explicit return request pre-queued in event list. overrides everything else */
+				
+				cerr << "explicit auto-return to " << _requested_return_frame << endl;
+
 				_transport_frame = _requested_return_frame;
-				_requested_return_frame = -1;
 				do_locate = true;
+
 			} else {
-				_transport_frame = _last_roll_location;
-			}
+				if (config.get_auto_return()) {
 
-			if (synced_to_jack() && !play_loop) {
-				do_locate = true;
+					if (play_loop) {
+
+						/* don't try to handle loop play when synced to JACK */
+
+						if (!synced_to_jack()) {
+
+							Location *location = _locations.auto_loop_location();
+							
+							if (location != 0) {
+								_transport_frame = location->start();
+							} else {
+								_transport_frame = _last_roll_location;
+							}
+							do_locate = true;
+						}
+
+					} else if (_play_range) {
+
+						/* return to start of range */
+
+						if (!current_audio_range.empty()) {
+							_transport_frame = current_audio_range.front().start;
+							do_locate = true;
+						}
+
+					} else {
+						
+						/* regular auto-return */
+						
+						_transport_frame = _last_roll_location;
+						do_locate = true;
+					}
+				} 
 			}
 
+			_requested_return_frame = -1;			
+
 			if (do_locate) {
-				// cerr << "non-realtimestop: transport locate to " << _transport_frame << endl;
 				_engine.transport_locate (_transport_frame);
 			}
-		}
+		} 
 
-#ifndef LEAVE_TRANSPORT_UNADJUSTED
 	}
-#endif
 
-		for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
-			if (!(*i)->hidden()) {
-				(*i)->non_realtime_locate (_transport_frame);
-			}
-			if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
-				finished = false;
-				/* we will be back */
-				return;
-			}
-		}
+	/* do this before seeking, because otherwise the Diskstreams will do the wrong thing in seamless loop mode.
+	*/
 
-#ifdef LEAVE_TRANSPORT_UNADJUSTED
+	if (ptw & PostTransportClearSubstate) {
+		_play_range = false;
+		unset_play_loop ();
 	}
-#endif
 
-        have_looped = false; 
+	/* this for() block can be put inside the previous if() and has the effect of ... ??? what */
 
-        send_full_time_code (0);
-	deliver_mmc (MIDI::MachineControl::cmdStop, 0);
-	deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
 
-	if (did_record) {
-
-		/* XXX its a little odd that we're doing this here
-		   when realtime_stop(), which has already executed,
-		   will have done this.
-		   JLC - so let's not because it seems unnecessary and breaks loop record
-		*/
-#if 0
-		if (!Config->get_latched_record_enable()) {
-			g_atomic_int_set (&_record_status, Disabled);
-		} else {
-			g_atomic_int_set (&_record_status, Enabled);
+	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
+		if (!(*i)->hidden()) {
+			(*i)->non_realtime_locate (_transport_frame);
+		}
+		if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
+			finished = false;
+			/* we will be back */
+			return;
 		}
-		RecordStateChanged (); /* emit signal */
-#endif
 	}
 
-	if ((post_transport_work & PostTransportLocate) && get_record_enabled()) {
+	have_looped = false;
+
+	send_full_time_code (0);
+	deliver_mmc (MIDI::MachineControl::cmdStop, 0);
+	deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
+
+	if ((ptw & PostTransportLocate) && get_record_enabled()) {
 		/* capture start has been changed, so save pending state */
 		save_state ("", true);
 		saved = true;
@@ -483,25 +567,21 @@ Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
 		save_state (_current_snapshot_name);
 	}
 
-	if (post_transport_work & PostTransportDuration) {
+	if (ptw & PostTransportDuration) {
 		DurationChanged (); /* EMIT SIGNAL */
 	}
 
-	if (post_transport_work & PostTransportStop) {
+	if (ptw & PostTransportStop) {
 		_play_range = false;
-
-		/* do not turn off autoloop on stop */
-
+		play_loop = false;
 	}
 
-        nframes_t tf = _transport_frame;
-
-        PositionChanged (tf); /* EMIT SIGNAL */
+        PositionChanged ((nframes64_t) _transport_frame); /* EMIT SIGNAL */
 	TransportStateChange (); /* EMIT SIGNAL */
 
 	/* and start it up again if relevant */
 
-	if ((post_transport_work & PostTransportLocate) && Config->get_slave_source() == None && pending_locate_roll) {
+	if ((ptw & PostTransportLocate) && !config.get_external_sync() && pending_locate_roll) {
 		request_transport_speed (1.0);
 		pending_locate_roll = false;
 	}
@@ -531,31 +611,49 @@ Session::check_declick_out ()
 	}
 }
 
+void
+Session::unset_play_loop ()
+{
+	play_loop = false;
+	clear_events (Event::AutoLoop);
+	
+	// set all diskstreams to NOT use internal looping
+	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
+		if (!(*i)->hidden()) {
+			(*i)->set_loop (0);
+		}
+	}
+}
+
 void
 Session::set_play_loop (bool yn)
 {
 	/* Called from event-handling context */
 
-	if ((actively_recording() && yn) || _locations.auto_loop_location() == 0) {
+	Location *loc;
+
+	if (yn == play_loop || (actively_recording() && yn) || (loc = _locations.auto_loop_location()) == 0) {
+		/* nothing to do, or can't change loop status while recording */
 		return;
 	}
-
+	
 	set_dirty();
-
+	
 	if (yn && Config->get_seamless_loop() && synced_to_jack()) {
 		warning << _("Seamless looping cannot be supported while Ardour is using JACK transport.\n"
 			     "Recommend changing the configured options")
 			<< endmsg;
 		return;
 	}
+	
+	if (yn) {
 
+		play_loop = true;
 
-	if ((play_loop = yn)) {
-
-		Location *loc;
-
+		if (loc) {
 
-		if ((loc = _locations.auto_loop_location()) != 0) {
+			unset_play_range ();
 
 			if (Config->get_seamless_loop()) {
 				// set all diskstreams to use internal looping
@@ -575,40 +673,26 @@ Session::set_play_loop (bool yn)
 					}
 				}
 			}
-
-			/* stick in the loop event */
-
+			
+			/* put the loop event into the event list */
+			
 			Event* event = new Event (Event::AutoLoop, Event::Replace, loc->end(), loc->start(), 0.0f);
 			merge_event (event);
 
-			/* locate to start of loop and roll if current pos is outside of the loop range */
-			if (_transport_frame < loc->start() || _transport_frame > loc->end()) {
-				event = new Event (Event::LocateRoll, Event::Add, Event::Immediate, loc->start(), 0, !synced_to_jack());
-				merge_event (event);
-			}
-			else {
-				// locate to current position (+ 1 to force reload)
-				event = new Event (Event::LocateRoll, Event::Add, Event::Immediate, _transport_frame + 1, 0, !synced_to_jack());
-				merge_event (event);
-			}
-		}
-
+			/* locate to start of loop and roll. If doing seamless loop, force a 
+			   locate+buffer refill even if we are positioned there already.
+			*/
 
+			start_locate (loc->start(), true, true, false, Config->get_seamless_loop());
+		}
 
 	} else {
-		clear_events (Event::AutoLoop);
-
-		// set all diskstreams to NOT use internal looping
-		boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-		for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
-			if (!(*i)->hidden()) {
-				(*i)->set_loop (0);
-			}
-		}
 
+		unset_play_loop ();
 	}
-}
 
+	TransportStateChange ();
+}
 void
 Session::flush_all_inserts ()
 {
@@ -620,12 +704,12 @@ Session::flush_all_inserts ()
 }
 
 void
-Session::start_locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+Session::start_locate (nframes64_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
 {
 	if (synced_to_jack()) {
 
 		double sp;
-		nframes_t pos;
+		nframes64_t pos;
 
 		_slave->speed_and_position (sp, pos);
 
@@ -644,19 +728,15 @@ Session::start_locate (nframes_t target_frame, bool with_roll, bool with_flush,
 		}
 
 	} else {
-		locate (target_frame, with_roll, with_flush, with_loop);
+		locate (target_frame, with_roll, with_flush, with_loop, force);
 	}
-
-	/* XXX: not sure if this should be emitted here in the synced_to_jack () case;
-	 * perhaps it should happen when the slave is actually followed */
-	Located (); /* EMIT SIGNAL */
 }
 
 int
 Session::micro_locate (nframes_t distance)
 {
 	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-	
+
 	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 		if (!(*i)->can_internal_playback_seek (distance)) {
 			return -1;
@@ -666,19 +746,19 @@ Session::micro_locate (nframes_t distance)
 	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 		(*i)->internal_playback_seek (distance);
 	}
-	
+
 	_transport_frame += distance;
 	return 0;
 }
 
 void
-Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+Session::locate (nframes64_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
 {
 	if (actively_recording() && !with_loop) {
 		return;
 	}
 
-	if (_transport_frame == target_frame && !loop_changing && !with_loop) {
+	if (!force && _transport_frame == target_frame && !loop_changing && !with_loop) {
 		if (with_roll) {
 			set_transport_speed (1.0, false);
 		}
@@ -686,11 +766,11 @@ Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool w
 		return;
 	}
 
-	// Update SMPTE time
+	// Update Timecode time
 	// [DR] FIXME: find out exactly where this should go below
 	_transport_frame = target_frame;
-	smpte_time(_transport_frame, transmitting_smpte_time);
-	outbound_mtc_smpte_frame = _transport_frame;
+	timecode_time(_transport_frame, transmitting_timecode_time);
+	outbound_mtc_timecode_frame = _transport_frame;
 	next_quarter_frame_to_send = 0;
 
 	if (_transport_speed && (!with_loop || loop_changing)) {
@@ -706,18 +786,19 @@ Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool w
 	}
 
 	if (transport_rolling() && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
-		realtime_stop (false);
+		realtime_stop (false, true); // XXX paul - check if the 2nd arg is really correct
 	}
 
-	if ( !with_loop || loop_changing) {
+	if (force || !with_loop || loop_changing) {
 
-		post_transport_work = PostTransportWork (post_transport_work | PostTransportLocate);
+		PostTransportWork todo = PostTransportLocate;
 
 		if (with_roll) {
-			post_transport_work = PostTransportWork (post_transport_work | PostTransportRoll);
-		}
+			todo = PostTransportWork (todo | PostTransportRoll);
+		} 
 
-		schedule_butler_transport_work ();
+		add_post_transport_work (todo);
+		_butler->schedule_transport_work ();
 
 	} else {
 
@@ -790,7 +871,9 @@ Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool w
 
 	loop_changing = false;
 
-	_send_smpte_update = true;
+	_send_timecode_update = true;
+
+	Located (); /* EMIT SIGNAL */
 }
 
 /** Set the transport speed.
@@ -798,18 +881,20 @@ Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool w
  * @param abort
  */
 void
-Session::set_transport_speed (double speed, bool abort)
+Session::set_transport_speed (double speed, bool abort, bool clear_state)
 {
+	DEBUG_TRACE (DEBUG::Transport, string_compose ("Set transport speed to %1, abort = %2 clear_state = %3, current = %4\n", speed, abort, clear_state, _transport_speed));
+
 	if (_transport_speed == speed) {
 		return;
 	}
 
-	target_phi = (uint64_t) (0x1000000 * fabs(speed));
+	_target_transport_speed = fabs(speed);
 
 	/* 8.0 max speed is somewhat arbitrary but based on guestimates regarding disk i/o capability
 	   and user needs. We really need CD-style "skip" playback for ffwd and rewind.
 	*/
-	
+
 	if (speed > 0) {
 		speed = min (8.0, speed);
 	} else if (speed < 0) {
@@ -833,6 +918,13 @@ Session::set_transport_speed (double speed, bool abort)
 		}
 
 		if (synced_to_jack ()) {
+			if (clear_state) {
+				/* do this here because our response to the slave won't 
+				   take care of it.
+				*/
+				_play_range = false;
+				unset_play_loop ();
+			}
 			_engine.transport_stop ();
 		} else {
 			stop_transport (abort);
@@ -866,7 +958,9 @@ Session::set_transport_speed (double speed, bool abort)
 
 	} else {
 
-		if (!get_record_enabled() && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame()) {
+		/* if not recording, don't roll forward past end if told to stop there */
+
+		if (!get_record_enabled() && (speed > 0.0 && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame())) {
 			return;
 		}
 
@@ -893,9 +987,11 @@ Session::set_transport_speed (double speed, bool abort)
 		/* if we are reversing relative to the current speed, or relative to the speed
 		   before the last stop, then we have to do extra work.
 		*/
+		
+		PostTransportWork todo = PostTransportWork (0);
 
 		if ((_transport_speed && speed * _transport_speed < 0.0) || (_last_transport_speed * speed < 0.0) || (_last_transport_speed == 0.0f && speed < 0.0f)) {
-			post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
+			todo = PostTransportWork (todo | PostTransportReverse);
 		}
 
 		_last_transport_speed = _transport_speed;
@@ -904,12 +1000,14 @@ Session::set_transport_speed (double speed, bool abort)
 		boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 		for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 			if ((*i)->realtime_set_speed ((*i)->speed(), true)) {
-				post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
+				todo = PostTransportWork (todo | PostTransportSpeed);
+				break;
 			}
 		}
 
-		if (post_transport_work & (PostTransportSpeed|PostTransportReverse)) {
-			schedule_butler_transport_work ();
+		if (todo) {
+			add_post_transport_work (todo);
+			_butler->schedule_transport_work ();
 		}
 	}
 }
@@ -917,7 +1015,7 @@ Session::set_transport_speed (double speed, bool abort)
 
 /** Stop the transport.  */
 void
-Session::stop_transport (bool abort)
+Session::stop_transport (bool abort, bool clear_state)
 {
 	if (_transport_speed == 0.0f) {
 		return;
@@ -953,8 +1051,8 @@ Session::stop_transport (bool abort)
 		return;
 	}
 
-	realtime_stop (abort);
-	schedule_butler_transport_work ();
+	realtime_stop (abort, clear_state);
+	_butler->schedule_transport_work ();
 }
 
 void
@@ -985,11 +1083,9 @@ Session::start_transport ()
 	}
 
 	transport_sub_state |= PendingDeclickIn;
-	
+
 	_transport_speed = 1.0;
-	target_phi       = 0x1000000; // speed = 1
-	phi              = target_phi;
-	phase            = 0;
+	_target_transport_speed = 1.0;
 
 	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
@@ -1007,7 +1103,9 @@ Session::start_transport ()
 void
 Session::post_transport ()
 {
-	if (post_transport_work & PostTransportAudition) {
+	PostTransportWork ptw = post_transport_work ();
+
+	if (ptw & PostTransportAudition) {
 		if (auditioner && auditioner->active()) {
 			process_function = &Session::process_audition;
 		} else {
@@ -1015,14 +1113,14 @@ Session::post_transport ()
 		}
 	}
 
-	if (post_transport_work & PostTransportStop) {
+	if (ptw & PostTransportStop) {
 
 		transport_sub_state = 0;
 	}
 
-	if (post_transport_work & PostTransportLocate) {
+	if (ptw & PostTransportLocate) {
 
-		if (((Config->get_slave_source() == None && (auto_play_legal && config.get_auto_play())) && !_exporting) || (post_transport_work & PostTransportRoll)) {
+		if (((!config.get_external_sync() && (auto_play_legal && config.get_auto_play())) && !_exporting) || (ptw & PostTransportRoll)) {
 			start_transport ();
 
 		} else {
@@ -1031,8 +1129,10 @@ Session::post_transport ()
 	}
 
 	set_next_event ();
-
-	post_transport_work = PostTransportWork (0);
+	/* XXX is this really safe? shouldn't we just be unsetting the bits that we actually
+	   know were handled ?
+	*/
+	set_post_transport_work (PostTransportWork (0));
 }
 
 void
@@ -1056,9 +1156,8 @@ Session::reset_rf_scale (nframes_t motion)
 }
 
 void
-Session::set_slave_source (SlaveSource src)
+Session::drop_sync_source ()
 {
-	bool reverse = false;
 	bool non_rt_required = false;
 
 	if (_transport_speed) {
@@ -1066,22 +1165,42 @@ Session::set_slave_source (SlaveSource src)
 		return;
 	}
 
-// 	if (src == JACK && Config->get_jack_time_master()) {
-// 		return;
-// 	}
-
 	delete _slave;
 	_slave = 0;
 
-	if (_transport_speed < 0.0) {
-		reverse = true;
+	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
+		if (!(*i)->hidden()) {
+			if ((*i)->realtime_set_speed ((*i)->speed(), true)) {
+				non_rt_required = true;
+			}
+			(*i)->set_slaved (0);
+		}
+	}
+
+	if (non_rt_required) {
+		add_post_transport_work (PostTransportSpeed);
+		_butler->schedule_transport_work ();
 	}
 
-	switch (src) {
-	case None:
-		stop_transport ();
-		break;
+	set_dirty();
+}
+
+void
+Session::use_sync_source (SyncSource src)
+{
+	bool reverse = false;
+	bool non_rt_required = false;
 
+	if (_transport_speed) {
+		error << _("please stop the transport before adjusting slave settings") << endmsg;
+		return;
+	}
+
+	delete _slave;
+	_slave = 0;
+
+	switch (src) {
 	case MTC:
 		if (_mtc_port) {
 			try {
@@ -1120,8 +1239,6 @@ Session::set_slave_source (SlaveSource src)
 
 	};
 
-	Config->set_slave_source (src);
-
 	boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 	for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 		if (!(*i)->hidden()) {
@@ -1137,8 +1254,8 @@ Session::set_slave_source (SlaveSource src)
 	}
 
 	if (non_rt_required) {
-		post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
-		schedule_butler_transport_work ();
+		add_post_transport_work (PostTransportSpeed);
+		_butler->schedule_transport_work ();
 	}
 
 	set_dirty();
@@ -1147,128 +1264,121 @@ Session::set_slave_source (SlaveSource src)
 void
 Session::reverse_diskstream_buffers ()
 {
-	post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
-	schedule_butler_transport_work ();
+	add_post_transport_work (PostTransportReverse);
+	_butler->schedule_transport_work ();
 }
 
 void
 Session::set_diskstream_speed (Diskstream* stream, double speed)
 {
 	if (stream->realtime_set_speed (speed, false)) {
-		post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
-		schedule_butler_transport_work ();
+		add_post_transport_work (PostTransportSpeed);
+		_butler->schedule_transport_work ();
 		set_dirty ();
 	}
 }
 
 void
-Session::set_audio_range (list<AudioRange>& range)
+Session::unset_play_range ()
 {
-	Event *ev = new Event (Event::SetAudioRange, Event::Add, Event::Immediate, 0, 0.0f);
-	ev->audio_range = range;
-	queue_event (ev);
+	_play_range = false;
+	_clear_event_type (Event::RangeStop);
+	_clear_event_type (Event::RangeLocate);
 }
 
 void
-Session::request_play_range (bool yn)
+Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
 {
-	Event* ev = new Event (Event::SetPlayRange, Event::Add, Event::Immediate, 0, 0.0f, yn);
-	queue_event (ev);
-}
+	Event* ev;
 
-void
-Session::set_play_range (bool yn)
-{
 	/* Called from event-processing context */
 
-	if (_play_range != yn) {
-		_play_range = yn;
-		setup_auto_play ();
-
-		if (!_play_range) {
+	unset_play_range ();
+	
+	if (range.empty()) {
+		/* _play_range set to false in unset_play_range()
+		 */
+		if (!leave_rolling) {
 			/* stop transport */
 			Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0f, false);
 			merge_event (ev);
 		}
-	}
-}
-
-void
-Session::setup_auto_play ()
-{
-	/* Called from event-processing context */
-
-	Event* ev;
-
-	_clear_event_type (Event::RangeStop);
-	_clear_event_type (Event::RangeLocate);
-
-	if (!_play_range) {
 		return;
 	}
 
-	list<AudioRange>::size_type sz = current_audio_range.size();
+	_play_range = true;
 
-	if (sz > 1) {
+	/* cancel loop play */
+	unset_play_loop ();
 
-		list<AudioRange>::iterator i = current_audio_range.begin();
+	list<AudioRange>::size_type sz = range.size();
+	
+	if (sz > 1) {
+		
+		list<AudioRange>::iterator i = range.begin(); 
 		list<AudioRange>::iterator next;
-
-		while (i != current_audio_range.end()) {
-
+		
+		while (i != range.end()) {
+			
 			next = i;
 			++next;
-
+			
 			/* locating/stopping is subject to delays for declicking.
 			 */
-
+			
 			nframes_t requested_frame = (*i).end;
-
+			
 			if (requested_frame > current_block_size) {
 				requested_frame -= current_block_size;
 			} else {
 				requested_frame = 0;
 			}
-
-			if (next == current_audio_range.end()) {
+			
+			if (next == range.end()) {
 				ev = new Event (Event::RangeStop, Event::Add, requested_frame, 0, 0.0f);
 			} else {
 				ev = new Event (Event::RangeLocate, Event::Add, requested_frame, (*next).start, 0.0f);
 			}
-
+			
 			merge_event (ev);
-
+			
 			i = next;
 		}
-
+		
 	} else if (sz == 1) {
 
-		ev = new Event (Event::RangeStop, Event::Add, current_audio_range.front().end, 0, 0.0f);
+		ev = new Event (Event::RangeStop, Event::Add, range.front().end, 0, 0.0f);
 		merge_event (ev);
+		
+	} 
 
-	}
+	/* save range so we can do auto-return etc. */
+
+	current_audio_range = range;
 
 	/* now start rolling at the right place */
 
-	ev = new Event (Event::LocateRoll, Event::Add, Event::Immediate, current_audio_range.front().start, 0.0f, false);
+	ev = new Event (Event::LocateRoll, Event::Add, Event::Immediate, range.front().start, 0.0f, false);
 	merge_event (ev);
+	
+	TransportStateChange ();
 }
 
 void
-Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
+Session::request_bounded_roll (nframes_t start, nframes_t end)
 {
- 	Event *ev = new Event (Event::LocateRollLocate, Event::Add, Event::Immediate, return_to, 1.0);
-	ev->target2_frame = start;
-	queue_event (ev);
-}
+	AudioRange ar (start, end, 0);
+	list<AudioRange> lar;
 
+	lar.push_back (ar);
+	request_play_range (&lar, true);
+}
 void
-Session::request_bounded_roll (nframes_t start, nframes_t end)
+Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
 {
-	request_stop ();
- 	Event *ev = new Event (Event::StopOnce, Event::Replace, end, Event::Immediate, 0.0);
+	Event *ev = new Event (Event::LocateRollLocate, Event::Add, Event::Immediate, return_to, 1.0);
+	ev->target2_frame = start;
 	queue_event (ev);
-	request_locate (start, true);
 }
 
 void
@@ -1283,11 +1393,11 @@ Session::engine_halted ()
 	   the picture.
 	*/
 
-	g_atomic_int_set (&butler_should_do_transport_work, 0);
-	post_transport_work = PostTransportWork (0);
-	stop_butler ();
+	g_atomic_int_set (&_butler->should_do_transport_work, 0);
+	set_post_transport_work (PostTransportWork (0));
+	_butler->stop ();
 
-	realtime_stop (false);
+	realtime_stop (false, true);
 	non_realtime_stop (false, 0, ignored);
 	transport_sub_state = 0;
 
@@ -1298,7 +1408,7 @@ Session::engine_halted ()
 void
 Session::xrun_recovery ()
 {
-	Xrun (transport_frame()); //EMIT SIGNAL
+	Xrun ((nframes64_t)_transport_frame); //EMIT SIGNAL
 
 	if (Config->get_stop_recording_on_xrun() && actively_recording()) {
 
@@ -1310,16 +1420,28 @@ Session::xrun_recovery ()
 	}
 }
 
+void
+Session::route_processors_changed (RouteProcessorChange c)
+{
+	if (c.type == RouteProcessorChange::MeterPointChange) {
+		return;
+	}
+
+	update_latency_compensation (false, false);
+}
+
 void
 Session::update_latency_compensation (bool with_stop, bool abort)
 {
 	bool update_jack = false;
+	PostTransportWork ptw;
 
 	if (_state_of_the_state & Deletion) {
 		return;
 	}
 
 	_worst_track_latency = 0;
+	ptw = post_transport_work();
 
 #undef DEBUG_LATENCY
 #ifdef DEBUG_LATENCY
@@ -1331,8 +1453,7 @@ Session::update_latency_compensation (bool with_stop, bool abort)
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 
 		if (with_stop) {
-			(*i)->handle_transport_stopped (abort, (post_transport_work & PostTransportLocate),
-							(!(post_transport_work & PostTransportLocate) || pending_locate_flush));
+			(*i)->handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
 		}
 
 		nframes_t old_latency = (*i)->output()->signal_latency ();
@@ -1344,7 +1465,7 @@ Session::update_latency_compensation (bool with_stop, bool abort)
 			update_jack = true;
 		}
 
- 		if (!(*i)->is_hidden() && ((*i)->active())) {
+		if (!(*i)->is_hidden() && ((*i)->active())) {
 			_worst_track_latency = max (_worst_track_latency, track_latency);
 		}
 	}
@@ -1388,3 +1509,17 @@ Session::reset_jack_connection (jack_client_t* jack)
 		js->reset_client (jack);
 	}
 }
+
+bool
+Session::maybe_stop (nframes_t limit)
+{
+       if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
+               if (synced_to_jack () && config.get_jack_time_master ()) {
+                       _engine.transport_stop ();
+               } else if (!synced_to_jack ()) {
+                       stop_transport ();
+               }
+               return true;
+       }
+       return false;
+}