Consistent AU factory Preset IDs
[ardour.git] / libs / ardour / mtc_slave.cc
index 39b9525bd0bc97ab2191670f4f777fbd004205fb..f8afe66d93d6986d59a3a5a91ff2155bd4f31c26 100644 (file)
@@ -1,5 +1,6 @@
 /*
     Copyright (C) 2002-4 Paul Davis
+    Overhaul 2012 Robin Gareus <robin@gareus.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
 */
 #include <iostream>
 #include <errno.h>
-#include <poll.h>
 #include <sys/types.h>
 #include <unistd.h>
+
 #include "pbd/error.h"
-#include "pbd/failed_constructor.h"
 #include "pbd/pthread_utils.h"
 
-#include "midi++/port.h"
+#include "ardour/audioengine.h"
 #include "ardour/debug.h"
-#include "ardour/slave.h"
+#include "ardour/midi_buffer.h"
+#include "ardour/midi_port.h"
 #include "ardour/session.h"
-#include "ardour/audioengine.h"
-#include "ardour/cycles.h"
+#include "ardour/transport_master.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace std;
 using namespace ARDOUR;
-using namespace sigc;
 using namespace MIDI;
 using namespace PBD;
+using namespace Timecode;
+
+/* length (in timecode frames) of the "window" that we consider legal given receipt of
+   a given timecode position. Ardour will try to chase within this window, and will
+   stop+locate+wait+chase if timecode arrives outside of it. The window extends entirely
+   in the current direction of motion, so if any timecode arrives that is before the most
+   recently received position (and without the direction of timecode reversing too), we
+   will stop+locate+wait+chase.
+*/
+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)
+{
+       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()));
 
-MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p)
-       : session (s)
+       init ();
+}
+
+MTC_TransportMaster::~MTC_TransportMaster()
 {
-       can_notify_on_unknown_rate = true;
+       port_connections.drop_connections();
+       config_connection.disconnect();
+
+       while (busy_guard1 != busy_guard2) {
+               /* make sure MIDI parser is not currently calling any callbacks in here,
+                * else there's a segfault ahead!
+                *
+                * XXX this is called from jack rt-context :(
+                * TODO fix libs/ardour/session_transport.cc:1321 (delete _slave;)
+                */
+               sched_yield();
+       }
 
-       last_mtc_fps_byte = session.get_mtc_timecode_bits ();
+       if (did_reset_tc_format) {
+               _session->config.set_timecode_format (saved_tc_format);
+       }
+}
 
-       rebind (p);
-       reset ();
+void
+MTC_TransportMaster::init ()
+{
+       reset (true);
 }
 
-MTC_Slave::~MTC_Slave()
+void
+MTC_TransportMaster::set_session (Session *s)
 {
+       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);
+
+               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::rebind (MIDI::Port& p)
+MTC_TransportMaster::pre_process (MIDI::pframes_t nframes, samplepos_t now, boost::optional<samplepos_t> session_pos)
 {
-       for (vector<sigc::connection>::iterator i = connections.begin(); i != connections.end(); ++i) {
-               (*i).disconnect ();
+       /* Read and parse incoming MIDI */
+
+       maybe_reset ();
+
+       _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_negative_offset = offset_tc.negative;
+}
+
+void
+MTC_TransportMaster::parameter_changed (std::string const & p)
+{
+       if (p == "slave-timecode-offset"
+                       || p == "timecode-format"
+                       ) {
+               parse_timecode_offset();
+       }
+}
+
+ARDOUR::samplecnt_t
+MTC_TransportMaster::update_interval() const
+{
+       if (timecode.rate) {
+               return AudioEngine::instance()->sample_rate() / timecode.rate;
        }
 
-       port = &p;
+       return AudioEngine::instance()->sample_rate(); /* useless but what other answer is there? */
+}
+
+ARDOUR::samplecnt_t
+MTC_TransportMaster::resolution () const
+{
+       return (samplecnt_t) quarter_frame_duration * 4.0;
+}
+
+ARDOUR::samplecnt_t
+MTC_TransportMaster::seekahead_distance () const
+{
+       return quarter_frame_duration * 8 * transport_direction;
+}
 
-       connections.push_back (port->input()->mtc_time.connect (mem_fun (*this, &MTC_Slave::update_mtc_time)));
-       connections.push_back (port->input()->mtc_qtr.connect (mem_fun (*this, &MTC_Slave::update_mtc_qtr)));
-       connections.push_back (port->input()->mtc_status.connect (mem_fun (*this, &MTC_Slave::update_mtc_status)));
+bool
+MTC_TransportMaster::outside_window (samplepos_t pos) const
+{
+       return ((pos < window_begin) || (pos > window_end));
 }
 
+
+bool
+MTC_TransportMaster::locked () const
+{
+       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_TransportMaster::ok() const
+{
+       return true;
+}
+
+void
+MTC_TransportMaster::queue_reset (bool reset_pos)
+{
+       Glib::Threads::Mutex::Lock lm (reset_lock);
+       reset_pending++;
+       if (reset_pos) {
+               reset_position = true;
+       }
+}
+
+void
+MTC_TransportMaster::maybe_reset ()
+{
+       Glib::Threads::Mutex::Lock lm (reset_lock);
+
+       if (reset_pending) {
+               reset (reset_position);
+               reset_pending = 0;
+               reset_position = false;
+       }
+}
+
+void
+MTC_TransportMaster::reset (bool with_position)
+{
+       DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC_TransportMaster reset %1\n", with_position?"with position":"without position"));
+
+       if (with_position) {
+               current.update (0, 0, 0);
+       } else {
+               current.update (current.position, 0, 0);
+       }
+       first_mtc_timestamp = 0;
+       window_begin = 0;
+       window_end = 0;
+       transport_direction = 1;
+       _current_delta = 0;
+}
+
+void
+MTC_TransportMaster::handle_locate (const MIDI::byte* mmc_tc)
+{
+       MIDI::byte mtc[5];
+       DEBUG_TRACE (DEBUG::MTC, "MTC_TransportMaster::handle_locate\n");
+
+       mtc[4] = last_mtc_fps_byte;
+       mtc[3] = mmc_tc[0] & 0xf; /* hrs only */
+       mtc[2] = mmc_tc[1];
+       mtc[1] = mmc_tc[2];
+       mtc[0] = mmc_tc[3];
+
+       update_mtc_time (mtc, true, 0);
+}
+
+void
+MTC_TransportMaster::init_mtc_dll(samplepos_t tme, double qtr)
+{
+       const double omega = 2.0 * M_PI * qtr / 2.0 / double(_session->sample_rate());
+       b = 1.4142135623730950488 * omega;
+       c = omega * omega;
+
+       e2 = qtr;
+       t0 = double(tme);
+       t1 = t0 + e2;
+       DEBUG_TRACE (DEBUG::MTC, string_compose ("[re-]init MTC DLL %1 %2 %3\n", t0, t1, e2));
+}
+
+/* called from MIDI parser */
 void
-MTC_Slave::update_mtc_qtr (Parser& /*p*/)
+MTC_TransportMaster::update_mtc_qtr (Parser& p, int which_qtr, samplepos_t now)
 {
-       cycles_t cnow = get_cycles ();
-       nframes64_t now = session.engine().frame_time();
-       nframes_t qtr;
-       static cycles_t last_qtr = 0;
+       busy_guard1++;
+       const double qtr_d = quarter_frame_duration;
 
-       qtr = (long) (session.frames_per_timecode_frame() / 4);
-       mtc_frame += qtr;
-       last_qtr = cnow;
+       mtc_frame_dll += qtr_d * (double) transport_direction;
+       mtc_frame = rint(mtc_frame_dll);
+
+       DEBUG_TRACE (DEBUG::MTC, string_compose ("qtr sample %1 at %2 -> mtc_frame: %3\n", which_qtr, now, mtc_frame));
+
+       double mtc_speed = 0;
+       if (first_mtc_timestamp != 0) {
+               /* update MTC DLL and calculate speed */
+               const double e = mtc_frame_dll - (double)transport_direction * ((double)now - (double)current.timestamp + t0);
+               t0 = t1;
+               t1 += b * e + e2;
+               e2 += c * e;
+
+               mtc_speed = (t1 - t0) / qtr_d;
+               DEBUG_TRACE (DEBUG::MTC, string_compose ("qtr sample DLL t0:%1 t1:%2 err:%3 spd:%4 ddt:%5\n", t0, t1, e, mtc_speed, e2 - qtr_d));
+
+               current.update (mtc_frame, now, mtc_speed);
+
+               last_inbound_frame = now;
+       }
 
-       current.guard1++;
-       current.position = mtc_frame;
-       current.timestamp = now;
-       current.guard2++;
+       maybe_reset ();
 
-       last_inbound_frame = now;
+       busy_guard2++;
 }
 
+/* called from MIDI parser _after_ update_mtc_qtr()
+ * when a full TC has been received
+ * OR on locate */
 void
-MTC_Slave::update_mtc_time (const byte *msg, bool was_full)
+MTC_TransportMaster::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_t now)
 {
-       nframes64_t now = session.engine().frame_time();
-       Timecode::Time timecode;
+       busy_guard1++;
+
+       /* "now" can be zero if this is called from a context where we do not have or do not want
+          to use a timestamp indicating when this MTC time was received. example: when we received
+          a locate command via MMC.
+       */
+       DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::update_mtc_time - TID:%1\n", pthread_name()));
+       TimecodeFormat tc_format;
+       bool reset_tc = true;
 
        timecode.hours = msg[3];
        timecode.minutes = msg[2];
@@ -102,19 +329,33 @@ MTC_Slave::update_mtc_time (const byte *msg, bool was_full)
 
        last_mtc_fps_byte = msg[4];
 
+       DEBUG_TRACE (DEBUG::MTC, string_compose ("full mtc time known at %1, full ? %2\n", now, was_full));
+
+       if (now) {
+               maybe_reset ();
+       }
+
        switch (msg[4]) {
        case MTC_24_FPS:
                timecode.rate = 24;
                timecode.drop = false;
+               tc_format = timecode_24;
                can_notify_on_unknown_rate = true;
                break;
        case MTC_25_FPS:
                timecode.rate = 25;
                timecode.drop = false;
+               tc_format = timecode_25;
                can_notify_on_unknown_rate = true;
                break;
        case MTC_30_FPS_DROP:
-               timecode.rate = 30;
+               if (fr2997()) {
+                       tc_format = Timecode::timecode_2997000drop;
+                       timecode.rate = (29970.0/1000.0);
+               } else {
+                       tc_format = timecode_2997drop;
+                       timecode.rate = (30000.0/1001.0);
+               }
                timecode.drop = true;
                can_notify_on_unknown_rate = true;
                break;
@@ -122,6 +363,7 @@ MTC_Slave::update_mtc_time (const byte *msg, bool was_full)
                timecode.rate = 30;
                timecode.drop = false;
                can_notify_on_unknown_rate = true;
+               tc_format = timecode_30;
                break;
        default:
                /* throttle error messages about unknown MTC rates */
@@ -131,243 +373,217 @@ MTC_Slave::update_mtc_time (const byte *msg, bool was_full)
                              << 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;
        }
 
-       session.timecode_to_sample (timecode, mtc_frame, true, false);
-
-       DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC time now %1 = frame %2 (from full message ? %3)\n", timecode, mtc_frame, was_full));
-
-       if (was_full) {
-
-               current.guard1++;
-               current.position = mtc_frame;
-               current.timestamp = 0;
-               current.guard2++;
+       if (reset_tc) {
+               TimecodeFormat cur_timecode = _session->config.get_timecode_format();
+               if (Config->get_timecode_sync_frame_rate()) {
+                       /* enforce time-code */
+                       if (!did_reset_tc_format) {
+                               saved_tc_format = cur_timecode;
+                               did_reset_tc_format = true;
+                       }
+                       if (cur_timecode != tc_format) {
+                               if (ceil(Timecode::timecode_to_frames_per_second(cur_timecode)) != ceil(Timecode::timecode_to_frames_per_second(tc_format))) {
+                                       warning << string_compose(_("Session framerate adjusted from %1 TO: MTC's %2."),
+                                                       Timecode::timecode_format_name(cur_timecode),
+                                                       Timecode::timecode_format_name(tc_format))
+                                               << endmsg;
+                               }
+                       }
+                       _session->config.set_timecode_format (tc_format);
+               } else {
+                       /* only warn about TC mismatch */
+                       if (mtc_timecode != tc_format) printed_timecode_warning = false;
+                       if (a3e_timecode != cur_timecode) printed_timecode_warning = false;
+
+                       if (cur_timecode != tc_format && ! printed_timecode_warning) {
+                               if (ceil(Timecode::timecode_to_frames_per_second(cur_timecode)) != ceil(Timecode::timecode_to_frames_per_second(tc_format))) {
+                                       warning << string_compose(_("Session and MTC framerate mismatch: MTC:%1 %2:%3."),
+                                                                 Timecode::timecode_format_name(tc_format),
+                                                                 PROGRAM_NAME,
+                                                                 Timecode::timecode_format_name(cur_timecode))
+                                               << endmsg;
+                               }
+                               printed_timecode_warning = true;
+                       }
+               }
+               mtc_timecode = tc_format;
+               a3e_timecode = cur_timecode;
 
-               session.request_locate (mtc_frame, false);
-               session.request_transport_speed (0);
-               update_mtc_status (MIDI::Parser::MTC_Stopped);
+               speedup_due_to_tc_mismatch = timecode.rate / Timecode::timecode_to_frames_per_second(a3e_timecode);
+       }
 
-               reset ();
+       /* do a careful conversion of the timecode value to a position
+          so that we take drop/nondrop and all that nonsense into
+          consideration.
+       */
 
+       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(),
+               timecode_negative_offset, timecode_offset
+               );
+
+       DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC at %1 TC %2 = mtc_frame %3 (from full message ? %4) tc-ratio %5\n",
+                                                now, timecode, mtc_frame, was_full, speedup_due_to_tc_mismatch));
+
+       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, TRS_MTC);
+               _session->request_locate (mtc_frame, false, TRS_MTC);
+               update_mtc_status (MIDI::MTC_Stopped);
+               reset (false);
+               reset_window (mtc_frame);
        } else {
 
+               /* we've had the first set of 8 qtr sample messages, determine position
+                  and allow continuing qtr sample messages to provide position
+                  and speed information.
+               */
+
                /* We received the last quarter frame 7 quarter frames (1.75 mtc
-                  frames) after the instance when the contents of the mtc quarter
-                  frames were decided. Add time to compensate for the elapsed 1.75
-                  frames.
-                  Also compensate for audio latency.
+                  samples) after the instance when the contents of the mtc quarter
+                  samples were decided. Add time to compensate for the elapsed 1.75
+                  samples.
                */
+               double qtr = quarter_frame_duration;
+               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()));
+
+               switch (parser.mtc_running()) {
+               case MTC_Backward:
+                       mtc_frame -= mtc_off;
+                       qtr *= -1.0;
+                       break;
+               case MTC_Forward:
+                       mtc_frame += mtc_off;
+                       break;
+               default:
+                       break;
+               }
 
-               mtc_frame += (long) (1.75 * session.frames_per_timecode_frame()) + session.worst_output_latency();
+               DEBUG_TRACE (DEBUG::MTC, string_compose ("new mtc_frame (w/offset) = %1\n", mtc_frame));
 
-               if (first_mtc_frame == 0) {
-                       first_mtc_frame = mtc_frame;
-                       first_mtc_time = now;
+               if (now) {
+                       if (first_mtc_timestamp == 0 || current.timestamp == 0) {
+                               first_mtc_timestamp = now;
+                               init_mtc_dll(mtc_frame, qtr);
+                               mtc_frame_dll = mtc_frame;
+                       }
+                       current.update (mtc_frame, now, current.speed);
+                       reset_window (mtc_frame);
                }
-
-               current.guard1++;
-               current.position = mtc_frame;
-               current.timestamp = now;
-               current.guard2++;
        }
 
-       last_inbound_frame = now;
-}
-
-void
-MTC_Slave::handle_locate (const MIDI::byte* mmc_tc)
-{
-       MIDI::byte mtc[5];
-
-       mtc[4] = last_mtc_fps_byte;
-       mtc[3] = mmc_tc[0] & 0xf; /* hrs only */
-       mtc[2] = mmc_tc[1];
-       mtc[1] = mmc_tc[2];
-       mtc[0] = mmc_tc[3];
-
-       update_mtc_time (mtc, true);
+       busy_guard2++;
 }
 
 void
-MTC_Slave::update_mtc_status (MIDI::Parser::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_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++;
 
        switch (status) {
        case MTC_Stopped:
-               mtc_speed = 0.0f;
-               mtc_frame = 0;
-
-               current.guard1++;
-               current.position = mtc_frame;
-               current.timestamp = 0;
-               current.guard2++;
-
+               current.update (mtc_frame, 0, 0);
                break;
 
        case MTC_Forward:
-               mtc_speed = 0.0f;
-               mtc_frame = 0;
-
-               current.guard1++;
-               current.position = mtc_frame;
-               current.timestamp = 0;
-               current.guard2++;
-
+               current.update (mtc_frame, 0, 0);
                break;
 
        case MTC_Backward:
-               mtc_speed = 0.0f;
-               mtc_frame = 0;
-
-               current.guard1++;
-               current.position = mtc_frame;
-               current.timestamp = 0;
-               current.guard2++;
-
+               current.update (mtc_frame, 0, 0);
                break;
        }
+       busy_guard2++;
 }
 
 void
-MTC_Slave::read_current (SafeTime *st) const
+MTC_TransportMaster::reset_window (samplepos_t root)
 {
-       int tries = 0;
-       do {
-               if (tries == 10) {
-                       error << _("MTC Slave: atomic read of current time failed, sleeping!") << endmsg;
-                       usleep (20);
-                       tries = 0;
+       /* 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
+          ahead of the window root (taking direction into account).
+       */
+
+       samplecnt_t const d = (quarter_frame_duration * 4 * sample_tolerance);
+
+       switch (parser.mtc_running()) {
+       case MTC_Forward:
+               window_begin = root;
+               transport_direction = 1;
+               window_end = root + d;
+               break;
+
+       case MTC_Backward:
+               transport_direction = -1;
+               if (root > d) {
+                       window_begin = root - d;
+                       window_end = root;
+               } else {
+                       window_begin = 0;
                }
+               window_end = root;
+               break;
 
-               *st = current;
-               tries++;
+       default:
+               /* do nothing */
+               break;
+       }
 
-       } while (st->guard1 != st->guard2);
+       DEBUG_TRACE (DEBUG::MTC, string_compose ("reset MTC window @ %3, now %1 .. %2\n", window_begin, window_end, root));
 }
 
-bool
-MTC_Slave::locked () const
+Timecode::TimecodeFormat
+MTC_TransportMaster::apparent_timecode_format () const
 {
-       return port->input()->mtc_locked();
+       return mtc_timecode;
 }
 
-bool
-MTC_Slave::ok() const
+std::string
+MTC_TransportMaster::position_string() const
 {
-       return true;
+       SafeTime last;
+       current.safe_read (last);
+       if (last.timestamp == 0 || reset_pending) {
+               return " --:--:--:--";
+       }
+       return Timecode::timecode_format_sampletime(
+               last.position,
+               double(_session->sample_rate()),
+               Timecode::timecode_to_frames_per_second(mtc_timecode),
+               Timecode::timecode_has_drop_frames(mtc_timecode));
 }
 
-bool
-MTC_Slave::speed_and_position (double& speed, nframes64_t& pos)
+std::string
+MTC_TransportMaster::delta_string () const
 {
-       nframes64_t now = session.engine().frame_time();
+       char delta[80];
        SafeTime last;
-       nframes_t frame_rate;
-       nframes_t elapsed;
-       double speed_now;
-
-       read_current (&last);
-
-       if (first_mtc_time == 0) {
-               speed = 0;
-               pos = last.position;
-               return true;
-       }
-
-       /* no timecode for 1/4 second ? conclude that its stopped */
-
-       if (last_inbound_frame && now > last_inbound_frame && now - last_inbound_frame > session.frame_rate() / 4) {
-               mtc_speed = 0;
-               pos = last.position;
-               session.request_locate (pos, false);
-               session.request_transport_speed (0);
-               update_mtc_status (MIDI::Parser::MTC_Stopped);
-               reset();
-               DEBUG_TRACE (DEBUG::MTC, "MTC not seen for 1/4 second - reset\n");
-               return false;
-       }
-
-       frame_rate = session.frame_rate();
-
-       speed_now = (double) ((last.position - first_mtc_frame) / (double) (now - first_mtc_time));
-
-       DEBUG_TRACE (DEBUG::MTC, string_compose ("apparent speed = %1 from last %2 now %3 first %4\n",
-                                                speed_now, last.position, now, first_mtc_time));
-
-
-       accumulator[accumulator_index++] = speed_now;
-
-       if (accumulator_index >= accumulator_size) {
-               have_first_accumulated_speed = true;
-               accumulator_index = 0;
-       }
-
-       if (have_first_accumulated_speed) {
-               double total = 0;
-
-               for (int32_t i = 0; i < accumulator_size; ++i) {
-                       total += accumulator[i];
-               }
-
-               mtc_speed = total / accumulator_size;
-
-       } else {
-
-               mtc_speed = speed_now;
-
-       }
-
-       if (mtc_speed == 0.0f) {
+       current.safe_read (last);
 
-               elapsed = 0;
+       delta[0] = '\0';
 
+       if (last.timestamp == 0 || reset_pending) {
+               snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012");
        } else {
-
-               /* scale elapsed time by the current MTC speed */
-
-               if (last.timestamp && (now > last.timestamp)) {
-                       elapsed = (nframes_t) floor (mtc_speed * (now - last.timestamp));
-               } else {
-                       elapsed = 0; /* XXX is this right? */
-               }
+               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));
        }
-
-       /* now add the most recent timecode value plus the estimated elapsed interval */
-
-       pos =  elapsed + last.position;
-
-       speed = mtc_speed;
-       return true;
-}
-
-ARDOUR::nframes_t
-MTC_Slave::resolution() const
-{
-       return (nframes_t) session.frames_per_timecode_frame();
-}
-
-void
-MTC_Slave::reset ()
-{
-       /* XXX massive thread safety issue here. MTC could
-          be being updated as we call this. but this
-          supposed to be a realtime-safe call.
-       */
-
-       port->input()->reset_mtc_state ();
-
-       last_inbound_frame = 0;
-       current.guard1++;
-       current.position = 0;
-       current.timestamp = 0;
-       current.guard2++;
-       first_mtc_frame = 0;
-       first_mtc_time = 0;
-
-       accumulator_index = 0;
-       have_first_accumulated_speed = false;
-       mtc_speed = 0;
+       return std::string(delta);
 }