new transport slave/master implementation, libs/ edition

1 files changed, 144 insertions, 188 deletions

diff --git a/libs/ardour/mtc_slave.cc b/libs/ardour/mtc_slave.cc
index 0f277a7f55..409fb9da69 100644
--- a/libs/ardour/mtc_slave.cc
+++ b/libs/ardour/mtc_slave.cc
@@ -30,7 +30,7 @@
 #include "ardour/midi_buffer.h"
 #include "ardour/midi_port.h"
 #include "ardour/session.h"
-#include "ardour/slave.h"
+#include "ardour/transport_master.h"
 
 #include <glibmm/timer.h>
 
@@ -49,38 +49,35 @@ using namespace Timecode;
    recently received position (and without the direction of timecode reversing too), we
    will stop+locate+wait+chase.
 */
-const int MTC_Slave::sample_tolerance = 2;
-
-MTC_Slave::MTC_Slave (Session& s, MidiPort& p)
-	: session (s)
-	, port (&p)
+const int MTC_TransportMaster::sample_tolerance = 2;
+
+MTC_TransportMaster::MTC_TransportMaster (std::string const & name)
+	: TimecodeTransportMaster (name, MTC)
+	, can_notify_on_unknown_rate (true)
+	, mtc_frame (0)
+	, mtc_frame_dll (0)
+	, last_inbound_frame (0)
+	, window_begin (0)
+	, window_end (0)
+	, first_mtc_timestamp (0)
+	, did_reset_tc_format (false)
+	, reset_pending (0)
+	, reset_position (false)
+	, transport_direction (1)
+	, busy_guard1 (0)
+	, busy_guard2 (0)
+	, printed_timecode_warning (false)
 {
-	can_notify_on_unknown_rate = true;
-	did_reset_tc_format = false;
-	reset_pending = 0;
-	reset_position = false;
-	mtc_frame = 0;
-	mtc_frame_dll = 0;
-	engine_dll_initstate = 0;
-	busy_guard1 = busy_guard2 = 0;
-
-	last_mtc_fps_byte = session.get_mtc_timecode_bits ();
-	quarter_frame_duration = (double(session.samples_per_timecode_frame()) / 4.0);
-
-	mtc_timecode = session.config.get_timecode_format();
-	a3e_timecode = session.config.get_timecode_format();
-	printed_timecode_warning = false;
-
-	session.config.ParameterChanged.connect_same_thread (config_connection, boost::bind (&MTC_Slave::parameter_changed, this, _1));
-	parse_timecode_offset();
-	reset (true);
+	if ((_port = create_midi_port (string_compose ("%1 in", name))) == 0) {
+		throw failed_constructor();
+	}
+
+	DEBUG_TRACE (DEBUG::Slave, string_compose ("MTC registered %1\n", _port->name()));
 
-	port->self_parser().mtc_time.connect_same_thread (port_connections,  boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3));
-	port->self_parser().mtc_qtr.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3));
-	port->self_parser().mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1));
+	init ();
 }
 
-MTC_Slave::~MTC_Slave()
+MTC_TransportMaster::~MTC_TransportMaster()
 {
 	port_connections.drop_connections();
 	config_connection.disconnect();
@@ -96,31 +93,69 @@ MTC_Slave::~MTC_Slave()
 	}
 
 	if (did_reset_tc_format) {
-		session.config.set_timecode_format (saved_tc_format);
+		_session->config.set_timecode_format (saved_tc_format);
 	}
 }
 
 void
-MTC_Slave::rebind (MidiPort& p)
+MTC_TransportMaster::init ()
+{
+	reset (true);
+}
+
+void
+MTC_TransportMaster::set_session (Session *s)
 {
-	port_connections.drop_connections ();
+	config_connection.disconnect ();
+	port_connections.drop_connections();
+
+	_session = s;
+
+	if (_session) {
+
+		last_mtc_fps_byte = _session->get_mtc_timecode_bits ();
+		quarter_frame_duration = (double) (_session->samples_per_timecode_frame() / 4.0);
+		mtc_timecode = _session->config.get_timecode_format();
+		a3e_timecode = _session->config.get_timecode_format();
+
+		parse_timecode_offset ();
+		reset (true);
 
-	port = &p;
+		parser.mtc_time.connect_same_thread (port_connections,  boost::bind (&MTC_TransportMaster::update_mtc_time, this, _1, _2, _3));
+		parser.mtc_qtr.connect_same_thread (port_connections, boost::bind (&MTC_TransportMaster::update_mtc_qtr, this, _1, _2, _3));
+		parser.mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_TransportMaster::update_mtc_status, this, _1));
 
+		_session->config.ParameterChanged.connect_same_thread (config_connection, boost::bind (&MTC_TransportMaster::parameter_changed, this, _1));
+	}
 }
 
 void
-MTC_Slave::parse_timecode_offset() {
+MTC_TransportMaster::pre_process (pframes_t nframes, samplepos_t now, boost::optional<samplepos_t> session_pos)
+{
+	/* Read and parse incoming MIDI */
+
+	_midi_port->read_and_parse_entire_midi_buffer_with_no_speed_adjustment (nframes, parser, now);
+
+	if (session_pos) {
+		const samplepos_t current_pos = current.position + ((now - current.timestamp) * current.speed);
+		_current_delta = current_pos - *session_pos;
+	} else {
+		_current_delta = 0;
+	}
+}
+
+void
+MTC_TransportMaster::parse_timecode_offset() {
 	Timecode::Time offset_tc;
-	Timecode::parse_timecode_format(session.config.get_slave_timecode_offset(), offset_tc);
-	offset_tc.rate = session.timecode_frames_per_second();
-	offset_tc.drop = session.timecode_drop_frames();
-	session.timecode_to_sample(offset_tc, timecode_offset, false, false);
+	Timecode::parse_timecode_format (_session->config.get_slave_timecode_offset(), offset_tc);
+	offset_tc.rate = _session->timecode_frames_per_second();
+	offset_tc.drop = _session->timecode_drop_frames();
+	_session->timecode_to_sample(offset_tc, timecode_offset, false, false);
 	timecode_negative_offset = offset_tc.negative;
 }
 
 void
-MTC_Slave::parameter_changed (std::string const & p)
+MTC_TransportMaster::parameter_changed (std::string const & p)
 {
 	if (p == "slave-timecode-offset"
 			|| p == "timecode-format"
@@ -129,47 +164,40 @@ MTC_Slave::parameter_changed (std::string const & p)
 	}
 }
 
-bool
-MTC_Slave::give_slave_full_control_over_transport_speed() const
-{
-	return true; // DLL align to engine transport
-	// return false; // for Session-level computed varispeed
-}
-
 ARDOUR::samplecnt_t
-MTC_Slave::resolution () const
+MTC_TransportMaster::resolution () const
 {
 	return (samplecnt_t) quarter_frame_duration * 4.0;
 }
 
 ARDOUR::samplecnt_t
-MTC_Slave::seekahead_distance () const
+MTC_TransportMaster::seekahead_distance () const
 {
 	return quarter_frame_duration * 8 * transport_direction;
 }
 
 bool
-MTC_Slave::outside_window (samplepos_t pos) const
+MTC_TransportMaster::outside_window (samplepos_t pos) const
 {
 	return ((pos < window_begin) || (pos > window_end));
 }
 
 
 bool
-MTC_Slave::locked () const
+MTC_TransportMaster::locked () const
 {
-	DEBUG_TRACE (DEBUG::MTC, string_compose ("locked ? %1 last %2 initstate %3\n", port->self_parser().mtc_locked(), last_inbound_frame, engine_dll_initstate));
-	return port->self_parser().mtc_locked() && last_inbound_frame !=0 && engine_dll_initstate !=0;
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("locked ? %1 last %2\n", parser.mtc_locked(), last_inbound_frame));
+	return parser.mtc_locked() && last_inbound_frame !=0;
 }
 
 bool
-MTC_Slave::ok() const
+MTC_TransportMaster::ok() const
 {
 	return true;
 }
 
 void
-MTC_Slave::queue_reset (bool reset_pos)
+MTC_TransportMaster::queue_reset (bool reset_pos)
 {
 	Glib::Threads::Mutex::Lock lm (reset_lock);
 	reset_pending++;
@@ -179,7 +207,7 @@ MTC_Slave::queue_reset (bool reset_pos)
 }
 
 void
-MTC_Slave::maybe_reset ()
+MTC_TransportMaster::maybe_reset ()
 {
 	Glib::Threads::Mutex::Lock lm (reset_lock);
 
@@ -191,9 +219,10 @@ MTC_Slave::maybe_reset ()
 }
 
 void
-MTC_Slave::reset (bool with_position)
+MTC_TransportMaster::reset (bool with_position)
 {
-	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC_Slave reset %1\n", with_position?"with position":"without position"));
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC_TransportMaster reset %1\n", with_position?"with position":"without position"));
+
 	if (with_position) {
 		last_inbound_frame = 0;
 		current.guard1++;
@@ -212,15 +241,14 @@ MTC_Slave::reset (bool with_position)
 	window_begin = 0;
 	window_end = 0;
 	transport_direction = 1;
-	current_delta = 0;
-	ActiveChanged(false);
+	_current_delta = 0;
 }
 
 void
-MTC_Slave::handle_locate (const MIDI::byte* mmc_tc)
+MTC_TransportMaster::handle_locate (const MIDI::byte* mmc_tc)
 {
 	MIDI::byte mtc[5];
-	DEBUG_TRACE (DEBUG::MTC, "MTC_Slave::handle_locate\n");
+	DEBUG_TRACE (DEBUG::MTC, "MTC_TransportMaster::handle_locate\n");
 
 	mtc[4] = last_mtc_fps_byte;
 	mtc[3] = mmc_tc[0] & 0xf; /* hrs only */
@@ -232,7 +260,7 @@ MTC_Slave::handle_locate (const MIDI::byte* mmc_tc)
 }
 
 void
-MTC_Slave::read_current (SafeTime *st) const
+MTC_TransportMaster::read_current (SafeTime *st) const
 {
 	int tries = 0;
 
@@ -249,9 +277,9 @@ MTC_Slave::read_current (SafeTime *st) const
 }
 
 void
-MTC_Slave::init_mtc_dll(samplepos_t tme, double qtr)
+MTC_TransportMaster::init_mtc_dll(samplepos_t tme, double qtr)
 {
-	omega = 2.0 * M_PI * qtr / 2.0 / double(session.sample_rate());
+	const double omega = 2.0 * M_PI * qtr / 2.0 / double(_session->sample_rate());
 	b = 1.4142135623730950488 * omega;
 	c = omega * omega;
 
@@ -263,7 +291,7 @@ MTC_Slave::init_mtc_dll(samplepos_t tme, double qtr)
 
 /* called from MIDI parser */
 void
-MTC_Slave::update_mtc_qtr (Parser& /*p*/, int which_qtr, samplepos_t now)
+MTC_TransportMaster::update_mtc_qtr (Parser& p, int which_qtr, samplepos_t now)
 {
 	busy_guard1++;
 	const double qtr_d = quarter_frame_duration;
@@ -302,7 +330,7 @@ MTC_Slave::update_mtc_qtr (Parser& /*p*/, int which_qtr, samplepos_t now)
  * when a full TC has been received
  * OR on locate */
 void
-MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t now)
+MTC_TransportMaster::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t now)
 {
 	busy_guard1++;
 
@@ -341,7 +369,7 @@ MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t no
 		can_notify_on_unknown_rate = true;
 		break;
 	case MTC_30_FPS_DROP:
-		if (Config->get_timecode_source_2997()) {
+		if (fr2997()) {
 			tc_format = Timecode::timecode_2997000drop;
 			timecode.rate = (29970.0/1000.0);
 		} else {
@@ -365,13 +393,13 @@ MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t no
 			      << endmsg;
 			can_notify_on_unknown_rate = false;
 		}
-		timecode.rate = session.timecode_frames_per_second();
-		timecode.drop = session.timecode_drop_frames();
+		timecode.rate = _session->timecode_frames_per_second();
+		timecode.drop = _session->timecode_drop_frames();
 		reset_tc = false;
 	}
 
 	if (reset_tc) {
-		TimecodeFormat cur_timecode = session.config.get_timecode_format();
+		TimecodeFormat cur_timecode = _session->config.get_timecode_format();
 		if (Config->get_timecode_sync_frame_rate()) {
 			/* enforce time-code */
 			if (!did_reset_tc_format) {
@@ -386,7 +414,7 @@ MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t no
 						<< endmsg;
 				}
 			}
-			session.config.set_timecode_format (tc_format);
+			_session->config.set_timecode_format (tc_format);
 		} else {
 			/* only warn about TC mismatch */
 			if (mtc_timecode != tc_format) printed_timecode_warning = false;
@@ -414,11 +442,11 @@ MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t no
 	   consideration.
 	*/
 
-	quarter_frame_duration = (double(session.sample_rate()) / (double) timecode.rate / 4.0);
+	quarter_frame_duration = (double(_session->sample_rate()) / (double) timecode.rate / 4.0);
 
 	Timecode::timecode_to_sample (timecode, mtc_frame, true, false,
-		double(session.sample_rate()),
-		session.config.get_subframes_per_frame(),
+		double(_session->sample_rate()),
+		_session->config.get_subframes_per_frame(),
 		timecode_negative_offset, timecode_offset
 		);
 
@@ -427,9 +455,9 @@ MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t no
 
 	if (was_full || outside_window (mtc_frame)) {
 		DEBUG_TRACE (DEBUG::MTC, string_compose ("update_mtc_time: full TC %1 or outside window %2 MTC %3\n", was_full, outside_window (mtc_frame), mtc_frame));
-		session.set_requested_return_sample (-1);
-		session.request_transport_speed (0);
-		session.request_locate (mtc_frame, false);
+		_session->set_requested_return_sample (-1);
+		_session->request_transport_speed (0, TRS_MTC);
+		_session->request_locate (mtc_frame, false, TRS_MTC);
 		update_mtc_status (MIDI::MTC_Stopped);
 		reset (false);
 		reset_window (mtc_frame);
@@ -449,9 +477,9 @@ MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t no
 		long int mtc_off = (long) rint(7.0 * qtr);
 
 		DEBUG_TRACE (DEBUG::MTC, string_compose ("new mtc_frame: %1 | MTC-FpT: %2 A3-FpT:%3\n",
-							 mtc_frame, (4.0*qtr), session.samples_per_timecode_frame()));
+							 mtc_frame, (4.0*qtr), _session->samples_per_timecode_frame()));
 
-		switch (port->self_parser().mtc_running()) {
+		switch (parser.mtc_running()) {
 		case MTC_Backward:
 			mtc_frame -= mtc_off;
 			qtr *= -1.0;
@@ -470,7 +498,6 @@ MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t no
 				first_mtc_timestamp = now;
 				init_mtc_dll(mtc_frame, qtr);
 				mtc_frame_dll = mtc_frame;
-				ActiveChanged (true); // emit signal
 			}
 			current.guard1++;
 			current.position = mtc_frame;
@@ -487,12 +514,12 @@ MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t no
 }
 
 void
-MTC_Slave::update_mtc_status (MIDI::MTC_Status status)
+MTC_TransportMaster::update_mtc_status (MIDI::MTC_Status status)
 {
 	/* XXX !!! thread safety ... called from MIDI I/O context
 	 * on locate (via ::update_mtc_time())
 	 */
-	DEBUG_TRACE (DEBUG::MTC, string_compose("MTC_Slave::update_mtc_status - TID:%1 MTC:%2\n", pthread_name(), mtc_frame));
+	DEBUG_TRACE (DEBUG::MTC, string_compose("MTC_TransportMaster::update_mtc_status - TID:%1 MTC:%2\n", pthread_name(), mtc_frame));
 	return; // why was this fn needed anyway ? it just messes up things -> use reset.
 	busy_guard1++;
 
@@ -526,7 +553,7 @@ MTC_Slave::update_mtc_status (MIDI::MTC_Status status)
 }
 
 void
-MTC_Slave::reset_window (samplepos_t root)
+MTC_TransportMaster::reset_window (samplepos_t root)
 {
 	/* if we're waiting for the master to catch us after seeking ahead, keep the window
 	   of acceptable MTC samples wide open. otherwise, shrink it down to just 2 video frames
@@ -535,7 +562,7 @@ MTC_Slave::reset_window (samplepos_t root)
 
 	samplecnt_t const d = (quarter_frame_duration * 4 * sample_tolerance);
 
-	switch (port->self_parser().mtc_running()) {
+	switch (parser.mtc_running()) {
 	case MTC_Forward:
 		window_begin = root;
 		transport_direction = 1;
@@ -561,144 +588,70 @@ MTC_Slave::reset_window (samplepos_t root)
 	DEBUG_TRACE (DEBUG::MTC, string_compose ("reset MTC window @ %3, now %1 .. %2\n", window_begin, window_end, root));
 }
 
-void
-MTC_Slave::init_engine_dll (samplepos_t pos, samplepos_t inc)
-{
-	/* the bandwidth of the DLL is a trade-off,
-	 * because the max-speed of the transport in ardour is
-	 * limited to +-8.0, a larger bandwidth would cause oscillations
-	 *
-	 * But this is only really a problem if the user performs manual
-	 * seeks while transport is running and slaved to MTC.
-	 */
-	oe = 2.0 * M_PI * double(inc) / 2.0 / double(session.sample_rate());
-	be = 1.4142135623730950488 * oe;
-	ce = oe * oe;
-
-	ee2 = double(transport_direction * inc);
-	te0 = double(pos);
-	te1 = te0 + ee2;
-	DEBUG_TRACE (DEBUG::MTC, string_compose ("[re-]init Engine DLL %1 %2 %3\n", te0, te1, ee2));
-}
-
 /* main entry point from session_process.cc
 xo * in process callback context */
 bool
-MTC_Slave::speed_and_position (double& speed, samplepos_t& pos)
+MTC_TransportMaster::speed_and_position (double& speed, samplepos_t& pos, samplepos_t now)
 {
-	samplepos_t now = session.engine().sample_time_at_cycle_start();
-	samplepos_t sess_pos = session.transport_sample(); // corresponds to now
-	//sess_pos -= session.engine().samples_since_cycle_start();
-
 	SafeTime last;
-	sampleoffset_t elapsed;
-	bool engine_dll_reinitialized = false;
+
+	if (!_collect) {
+		return false;
+	}
 
 	read_current (&last);
 
-	DEBUG_TRACE (DEBUG::MTC, string_compose ("speed&pos: timestamp %1 speed %2 initstate %3 dir %4 tpos %5 now %6 last-in %7\n",
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("speed&pos: timestamp %1 speed %2 dir %4 now %5 last-in %6\n",
 						 last.timestamp,
 						 last.speed,
-						 engine_dll_initstate,
 						 transport_direction,
-						 sess_pos,
 						 now,
 						 last_inbound_frame));
 
-	/* re-init engine DLL here when state changed (direction, first_mtc_timestamp) */
 	if (last.timestamp == 0) {
-		engine_dll_initstate = 0;
-	} else if (engine_dll_initstate != transport_direction && last.speed != 0) {
-		engine_dll_initstate = transport_direction;
-		init_engine_dll(last.position, session.engine().samples_per_cycle());
-		engine_dll_reinitialized = true;
-	}
-
-	if (last.timestamp == 0) {
-		speed = 0;
-		pos = session.transport_sample() ; // last.position;
-		DEBUG_TRACE (DEBUG::MTC, string_compose ("first call to MTC_Slave::speed_and_position, pos = %1\n", pos));
-		return true;
+		return false;
 	}
 
-	/* no timecode for two samples - conclude that it's stopped */
 	if (last_inbound_frame && now > last_inbound_frame && now - last_inbound_frame > labs(seekahead_distance())) {
-		speed = 0;
-		pos = last.position;
-		session.set_requested_return_sample (-1);
-		session.request_locate (pos, false);
-		session.request_transport_speed (0);
-		engine_dll_initstate = 0;
-		queue_reset (false);
-		ActiveChanged (false);
-		DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC not seen for 2 samples - reset pending, pos = %1\n", pos));
-		return false;
+		/* no timecode for two cycles - conclude that it's stopped */
+
+		if (!Config->get_transport_masters_just_roll_when_sync_lost()) {
+			speed = 0;
+			pos = last.position;
+			_current_delta = 0;
+			queue_reset (false);
+			DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC not seen for 2 samples - reset pending, pos = %1\n", pos));
+			return false;
+		}
 	}
 
 
 	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position mtc-tme: %1 mtc-pos: %2 mtc-spd: %3\n", last.timestamp, last.position, last.speed));
-	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position eng-tme: %1 eng-pos: %2\n", now, sess_pos));
-
-	double speed_flt = last.speed; ///< MTC speed from MTC-quarter-frame DLL
-
-	/* interpolate position according to speed and time since last quarter-frame*/
-	if (speed_flt == 0.0f) {
-		elapsed = 0;
-	} else {
-		/* scale elapsed time by the current MTC speed */
-		elapsed = (samplecnt_t) rint (speed_flt * (now - last.timestamp));
-		if (give_slave_full_control_over_transport_speed() && !engine_dll_reinitialized) {
-			/* there is an engine vs MTC position sample-delta.
-			 * This mostly due to quantization and rounding of (speed * nframes)
-			 * but can also due to the session-process not calling
-			 * speed_and_position() every cycle under some circumstances.
-			 * Thus we use an other DLL to align the engine and the MTC
-			 */
-
-			/* update engine DLL and calculate speed */
-			const double e = double (last.position + elapsed - sess_pos);
-			te0 = te1;
-			te1 += be * e + ee2;
-			ee2 += ce * e;
-			speed_flt = (te1 - te0) / double(session.engine().samples_per_cycle());
-			DEBUG_TRACE (DEBUG::MTC, string_compose ("engine DLL t0:%1 t1:%2 err:%3 spd:%4 ddt:%5\n", te0, te1, e, speed_flt, ee2 - session.engine().samples_per_cycle() ));
-		}
-	}
 
-	pos = last.position + elapsed;
-	speed = speed_flt;
-
-	/* may happen if the user performs a seek in the timeline while slaved to running MTC
-	 * engine-DLL can oscillate back before 0.
-	 * also see note in MTC_Slave::init_engine_dll
-	 */
-	if (!session.actively_recording()
-	    && speed != 0
-	    && ((pos < 0) || (labs(pos - sess_pos) > 3 * session.sample_rate()))) {
-		engine_dll_initstate = 0;
-		queue_reset (false);
-	}
+	speed = last.speed;
 
 	/* provide a .1% deadzone to lock the speed */
-	if (fabs (speed - 1.0) <= 0.001)
-	        speed = 1.0;
+	if (fabs (speed - 1.0) <= 0.001) {
+		speed = 1.0;
+	}
 
-	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTCsync spd: %1 pos: %2 | last-pos: %3 elapsed: %4 delta: %5\n",
-						 speed, pos, last.position, elapsed,  pos - sess_pos));
+	pos =  last.position;
+	pos += (now - last.timestamp) * speed;
 
-	current_delta = (pos - sess_pos);
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTCsync spd: %1 pos: %2 | last-pos: %3 | elapsed: %4\n",
+	                                         speed, pos, last.position, (now - last.timestamp)));
 
 	return true;
 }
 
 Timecode::TimecodeFormat
-MTC_Slave::apparent_timecode_format () const
+MTC_TransportMaster::apparent_timecode_format () const
 {
 	return mtc_timecode;
 }
 
 std::string
-MTC_Slave::approximate_current_position() const
+MTC_TransportMaster::position_string() const
 {
 	SafeTime last;
 	read_current (&last);
@@ -707,22 +660,25 @@ MTC_Slave::approximate_current_position() const
 	}
 	return Timecode::timecode_format_sampletime(
 		last.position,
-		double(session.sample_rate()),
+		double(_session->sample_rate()),
 		Timecode::timecode_to_frames_per_second(mtc_timecode),
 		Timecode::timecode_has_drop_frames(mtc_timecode));
 }
 
 std::string
-MTC_Slave::approximate_current_delta() const
+MTC_TransportMaster::delta_string () const
 {
 	char delta[80];
 	SafeTime last;
 	read_current (&last);
+
+	delta[0] = '\0';
+
 	if (last.timestamp == 0 || reset_pending) {
 		snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012");
 	} else {
 		snprintf(delta, sizeof(delta), "\u0394<span foreground=\"green\" face=\"monospace\" >%s%s%" PRIi64 "</span>sm",
-				LEADINGZERO(abs(current_delta)), PLUSMINUS(-current_delta), abs(current_delta));
+				LEADINGZERO(abs(_current_delta)), PLUSMINUS(-_current_delta), abs(_current_delta));
 	}
 	return std::string(delta);
 }