libs/ardour/mtc_slave.cc

   1 /*
   2     Copyright (C) 2002-4 Paul Davis
   3     Overhaul 2012 Robin Gareus <robin@gareus.org>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20 #include <iostream>
  21 #include <errno.h>
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24
  25 #include "pbd/error.h"
  26 #include "pbd/pthread_utils.h"
  27
  28 #include "ardour/audioengine.h"
  29 #include "ardour/debug.h"
  30 #include "ardour/midi_buffer.h"
  31 #include "ardour/midi_port.h"
  32 #include "ardour/session.h"
  33 #include "ardour/slave.h"
  34
  35 #include <glibmm/timer.h>
  36
  37 #include "i18n.h"
  38
  39 using namespace std;
  40 using namespace ARDOUR;
  41 using namespace MIDI;
  42 using namespace PBD;
  43 using namespace Timecode;
  44
  45 /* length (in timecode frames) of the "window" that we consider legal given receipt of
  46    a given timecode position. Ardour will try to chase within this window, and will
  47    stop+locate+wait+chase if timecode arrives outside of it. The window extends entirely
  48    in the current direction of motion, so if any timecode arrives that is before the most
  49    recently received position (and without the direction of timecode reversing too), we
  50    will stop+locate+wait+chase.
  51 */
  52 const int MTC_Slave::frame_tolerance = 2;
  53
  54 MTC_Slave::MTC_Slave (Session& s, MidiPort& p)
  55         : session (s)
  56         , port (&p)
  57 {
  58         can_notify_on_unknown_rate = true;
  59         did_reset_tc_format = false;
  60         reset_pending = 0;
  61         reset_position = false;
  62         mtc_frame = 0;
  63         mtc_frame_dll = 0;
  64         engine_dll_initstate = 0;
  65         busy_guard1 = busy_guard2 = 0;
  66
  67         last_mtc_fps_byte = session.get_mtc_timecode_bits ();
  68         quarter_frame_duration = (double(session.frames_per_timecode_frame()) / 4.0);
  69
  70         mtc_timecode = session.config.get_timecode_format();
  71         a3e_timecode = session.config.get_timecode_format();
  72         printed_timecode_warning = false;
  73
  74         session.config.ParameterChanged.connect_same_thread (config_connection, boost::bind (&MTC_Slave::parameter_changed, this, _1));
  75         parse_timecode_offset();
  76         reset (true);
  77
  78         port->self_parser().mtc_time.connect_same_thread (port_connections,  boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3));
  79         port->self_parser().mtc_qtr.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3));
  80         port->self_parser().mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1));
  81 }
  82
  83 MTC_Slave::~MTC_Slave()
  84 {
  85         port_connections.drop_connections();
  86         config_connection.disconnect();
  87
  88         while (busy_guard1 != busy_guard2) {
  89                 /* make sure MIDI parser is not currently calling any callbacks in here,
  90                  * else there's a segfault ahead!
  91                  *
  92                  * XXX this is called from jack rt-context :(
  93                  * TODO fix libs/ardour/session_transport.cc:1321 (delete _slave;)
  94                  */
  95                 sched_yield();
  96         }
  97
  98         if (did_reset_tc_format) {
  99                 session.config.set_timecode_format (saved_tc_format);
 100         }
 101 }
 102
 103 void
 104 MTC_Slave::rebind (MidiPort& p)
 105 {
 106         port_connections.drop_connections ();
 107
 108         port = &p;
 109
 110 }
 111
 112 void
 113 MTC_Slave::parse_timecode_offset() {
 114         Timecode::Time offset_tc;
 115         Timecode::parse_timecode_format(session.config.get_slave_timecode_offset(), offset_tc);
 116         offset_tc.rate = session.timecode_frames_per_second();
 117         offset_tc.drop = session.timecode_drop_frames();
 118         session.timecode_to_sample(offset_tc, timecode_offset, false, false);
 119         timecode_negative_offset = offset_tc.negative;
 120 }
 121
 122 void
 123 MTC_Slave::parameter_changed (std::string const & p)
 124 {
 125         if (p == "slave-timecode-offset"
 126                         || p == "timecode-format"
 127                         ) {
 128                 parse_timecode_offset();
 129         }
 130 }
 131
 132 bool
 133 MTC_Slave::give_slave_full_control_over_transport_speed() const
 134 {
 135         return true; // DLL align to engine transport
 136         // return false; // for Session-level computed varispeed
 137 }
 138
 139 ARDOUR::framecnt_t
 140 MTC_Slave::resolution () const
 141 {
 142         return (framecnt_t) quarter_frame_duration * 4.0;
 143 }
 144
 145 ARDOUR::framecnt_t
 146 MTC_Slave::seekahead_distance () const
 147 {
 148         return quarter_frame_duration * 8 * transport_direction;
 149 }
 150
 151 bool
 152 MTC_Slave::outside_window (framepos_t pos) const
 153 {
 154         return ((pos < window_begin) || (pos > window_end));
 155 }
 156
 157
 158 bool
 159 MTC_Slave::locked () const
 160 {
 161         DEBUG_TRACE (DEBUG::MTC, string_compose ("locked ? %1 last %2 initstate %3\n", port->self_parser().mtc_locked(), last_inbound_frame, engine_dll_initstate));
 162         return port->self_parser().mtc_locked() && last_inbound_frame !=0 && engine_dll_initstate !=0;
 163 }
 164
 165 bool
 166 MTC_Slave::ok() const
 167 {
 168         return true;
 169 }
 170
 171 void
 172 MTC_Slave::queue_reset (bool reset_pos)
 173 {
 174         Glib::Threads::Mutex::Lock lm (reset_lock);
 175         reset_pending++;
 176         if (reset_pos) {
 177                 reset_position = true;
 178         }
 179 }
 180
 181 void
 182 MTC_Slave::maybe_reset ()
 183 {
 184         Glib::Threads::Mutex::Lock lm (reset_lock);
 185
 186         if (reset_pending) {
 187                 reset (reset_position);
 188                 reset_pending = 0;
 189                 reset_position = false;
 190         }
 191 }
 192
 193 void
 194 MTC_Slave::reset (bool with_position)
 195 {
 196         DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC_Slave reset %1\n", with_position?"with position":"without position"));
 197         if (with_position) {
 198                 last_inbound_frame = 0;
 199                 current.guard1++;
 200                 current.position = 0;
 201                 current.timestamp = 0;
 202                 current.speed = 0;
 203                 current.guard2++;
 204         } else {
 205                 last_inbound_frame = 0;
 206                 current.guard1++;
 207                 current.timestamp = 0;
 208                 current.speed = 0;
 209                 current.guard2++;
 210         }
 211         first_mtc_timestamp = 0;
 212         window_begin = 0;
 213         window_end = 0;
 214         transport_direction = 1;
 215         current_delta = 0;
 216 }
 217
 218 void
 219 MTC_Slave::handle_locate (const MIDI::byte* mmc_tc)
 220 {
 221         MIDI::byte mtc[5];
 222         DEBUG_TRACE (DEBUG::MTC, "MTC_Slave::handle_locate\n");
 223
 224         mtc[4] = last_mtc_fps_byte;
 225         mtc[3] = mmc_tc[0] & 0xf; /* hrs only */
 226         mtc[2] = mmc_tc[1];
 227         mtc[1] = mmc_tc[2];
 228         mtc[0] = mmc_tc[3];
 229
 230         update_mtc_time (mtc, true, 0);
 231 }
 232
 233 void
 234 MTC_Slave::read_current (SafeTime *st) const
 235 {
 236         int tries = 0;
 237
 238         do {
 239                 if (tries == 10) {
 240                         error << _("MTC Slave: atomic read of current time failed, sleeping!") << endmsg;
 241                         Glib::usleep (20);
 242                         tries = 0;
 243                 }
 244                 *st = current;
 245                 tries++;
 246
 247         } while (st->guard1 != st->guard2);
 248 }
 249
 250 void
 251 MTC_Slave::init_mtc_dll(framepos_t tme, double qtr)
 252 {
 253         omega = 2.0 * M_PI * qtr / 2.0 / double(session.frame_rate());
 254         b = 1.4142135623730950488 * omega;
 255         c = omega * omega;
 256
 257         e2 = qtr;
 258         t0 = double(tme);
 259         t1 = t0 + e2;
 260         DEBUG_TRACE (DEBUG::MTC, string_compose ("[re-]init MTC DLL %1 %2 %3\n", t0, t1, e2));
 261 }
 262
 263 /* called from MIDI parser */
 264 void
 265 MTC_Slave::update_mtc_qtr (Parser& /*p*/, int which_qtr, framepos_t now)
 266 {
 267         busy_guard1++;
 268         const double qtr_d = quarter_frame_duration;
 269
 270         mtc_frame_dll += qtr_d * (double) transport_direction;
 271         mtc_frame = rint(mtc_frame_dll);
 272
 273         DEBUG_TRACE (DEBUG::MTC, string_compose ("qtr frame %1 at %2 -> mtc_frame: %3\n", which_qtr, now, mtc_frame));
 274
 275         double mtc_speed = 0;
 276         if (first_mtc_timestamp != 0) {
 277                 /* update MTC DLL and calculate speed */
 278                 const double e = mtc_frame_dll - (double)transport_direction * ((double)now - (double)current.timestamp + t0);
 279                 t0 = t1;
 280                 t1 += b * e + e2;
 281                 e2 += c * e;
 282
 283                 mtc_speed = (t1 - t0) / qtr_d;
 284                 DEBUG_TRACE (DEBUG::MTC, string_compose ("qtr frame DLL t0:%1 t1:%2 err:%3 spd:%4 ddt:%5\n", t0, t1, e, mtc_speed, e2 - qtr_d));
 285
 286                 current.guard1++;
 287                 current.position = mtc_frame;
 288                 current.timestamp = now;
 289                 current.speed = mtc_speed;
 290                 current.guard2++;
 291
 292                 last_inbound_frame = now;
 293         }
 294
 295         maybe_reset ();
 296
 297         busy_guard2++;
 298 }
 299
 300 /* called from MIDI parser _after_ update_mtc_qtr()
 301  * when a full TC has been received
 302  * OR on locate */
 303 void
 304 MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, framepos_t now)
 305 {
 306         busy_guard1++;
 307
 308         /* "now" can be zero if this is called from a context where we do not have or do not want
 309            to use a timestamp indicating when this MTC time was received. example: when we received
 310            a locate command via MMC.
 311         */
 312
 313         DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::update_mtc_time - TID:%1\n", ::pthread_self()));
 314         TimecodeFormat tc_format;
 315         bool reset_tc = true;
 316
 317         timecode.hours = msg[3];
 318         timecode.minutes = msg[2];
 319         timecode.seconds = msg[1];
 320         timecode.frames = msg[0];
 321
 322         last_mtc_fps_byte = msg[4];
 323
 324         DEBUG_TRACE (DEBUG::MTC, string_compose ("full mtc time known at %1, full ? %2\n", now, was_full));
 325
 326         if (now) {
 327                 maybe_reset ();
 328         }
 329
 330         switch (msg[4]) {
 331         case MTC_24_FPS:
 332                 timecode.rate = 24;
 333                 timecode.drop = false;
 334                 tc_format = timecode_24;
 335                 can_notify_on_unknown_rate = true;
 336                 break;
 337         case MTC_25_FPS:
 338                 timecode.rate = 25;
 339                 timecode.drop = false;
 340                 tc_format = timecode_25;
 341                 can_notify_on_unknown_rate = true;
 342                 break;
 343         case MTC_30_FPS_DROP:
 344                 if (Config->get_timecode_source_2997()) {
 345                         tc_format = Timecode::timecode_2997000drop;
 346                         timecode.rate = (29970.0/1000.0);
 347                 } else {
 348                         tc_format = timecode_2997drop;
 349                         timecode.rate = (30000.0/1001.0);
 350                 }
 351                 timecode.drop = true;
 352                 can_notify_on_unknown_rate = true;
 353                 break;
 354         case MTC_30_FPS:
 355                 timecode.rate = 30;
 356                 timecode.drop = false;
 357                 can_notify_on_unknown_rate = true;
 358                 tc_format = timecode_30;
 359                 break;
 360         default:
 361                 /* throttle error messages about unknown MTC rates */
 362                 if (can_notify_on_unknown_rate) {
 363                         error << string_compose (_("Unknown rate/drop value %1 in incoming MTC stream, session values used instead"),
 364                                                  (int) msg[4])
 365                               << endmsg;
 366                         can_notify_on_unknown_rate = false;
 367                 }
 368                 timecode.rate = session.timecode_frames_per_second();
 369                 timecode.drop = session.timecode_drop_frames();
 370                 reset_tc = false;
 371         }
 372
 373         if (reset_tc) {
 374                 TimecodeFormat cur_timecode = session.config.get_timecode_format();
 375                 if (Config->get_timecode_sync_frame_rate()) {
 376                         /* enforce time-code */
 377                         if (!did_reset_tc_format) {
 378                                 saved_tc_format = cur_timecode;
 379                                 did_reset_tc_format = true;
 380                         }
 381                         if (cur_timecode != tc_format) {
 382                                 if (ceil(Timecode::timecode_to_frames_per_second(cur_timecode)) != ceil(Timecode::timecode_to_frames_per_second(tc_format))) {
 383                                         warning << string_compose(_("Session framerate adjusted from %1 TO: MTC's %2."),
 384                                                         Timecode::timecode_format_name(cur_timecode),
 385                                                         Timecode::timecode_format_name(tc_format))
 386                                                 << endmsg;
 387                                 }
 388                         }
 389                         session.config.set_timecode_format (tc_format);
 390                 } else {
 391                         /* only warn about TC mismatch */
 392                         if (mtc_timecode != tc_format) printed_timecode_warning = false;
 393                         if (a3e_timecode != cur_timecode) printed_timecode_warning = false;
 394
 395                         if (cur_timecode != tc_format && ! printed_timecode_warning) {
 396                                 if (ceil(Timecode::timecode_to_frames_per_second(cur_timecode)) != ceil(Timecode::timecode_to_frames_per_second(tc_format))) {
 397                                         warning << string_compose(_("Session and MTC framerate mismatch: MTC:%1 %2:%3."),
 398                                                                   Timecode::timecode_format_name(tc_format),
 399                                                                   PROGRAM_NAME,
 400                                                                   Timecode::timecode_format_name(cur_timecode))
 401                                                 << endmsg;
 402                                 }
 403                                 printed_timecode_warning = true;
 404                         }
 405                 }
 406                 mtc_timecode = tc_format;
 407                 a3e_timecode = cur_timecode;
 408
 409                 speedup_due_to_tc_mismatch = timecode.rate / Timecode::timecode_to_frames_per_second(a3e_timecode);
 410         }
 411
 412         /* do a careful conversion of the timecode value to a position
 413            so that we take drop/nondrop and all that nonsense into
 414            consideration.
 415         */
 416
 417         quarter_frame_duration = (double(session.frame_rate()) / (double) timecode.rate / 4.0);
 418
 419         Timecode::timecode_to_sample (timecode, mtc_frame, true, false,
 420                 double(session.frame_rate()),
 421                 session.config.get_subframes_per_frame(),
 422                 timecode_negative_offset, timecode_offset
 423                 );
 424
 425         DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC at %1 TC %2 = mtc_frame %3 (from full message ? %4) tc-ratio %5\n",
 426                                                  now, timecode, mtc_frame, was_full, speedup_due_to_tc_mismatch));
 427
 428         if (was_full || outside_window (mtc_frame)) {
 429                 DEBUG_TRACE (DEBUG::MTC, string_compose ("update_mtc_time: full TC %1 or outside window %2\n", was_full, outside_window (mtc_frame)));
 430                 session.request_locate (mtc_frame, false);
 431                 session.request_transport_speed (0);
 432                 update_mtc_status (MIDI::MTC_Stopped);
 433                 reset (false);
 434                 reset_window (mtc_frame);
 435         } else {
 436
 437                 /* we've had the first set of 8 qtr frame messages, determine position
 438                    and allow continuing qtr frame messages to provide position
 439                    and speed information.
 440                 */
 441
 442                 /* We received the last quarter frame 7 quarter frames (1.75 mtc
 443                    frames) after the instance when the contents of the mtc quarter
 444                    frames were decided. Add time to compensate for the elapsed 1.75
 445                    frames.
 446                 */
 447                 double qtr = quarter_frame_duration;
 448                 long int mtc_off = (long) rint(7.0 * qtr);
 449
 450                 DEBUG_TRACE (DEBUG::MTC, string_compose ("new mtc_frame: %1 | MTC-FpT: %2 A3-FpT:%3\n",
 451                                                          mtc_frame, (4.0*qtr), session.frames_per_timecode_frame()));
 452
 453                 switch (port->self_parser().mtc_running()) {
 454                 case MTC_Backward:
 455                         mtc_frame -= mtc_off;
 456                         qtr *= -1.0;
 457                         break;
 458                 case MTC_Forward:
 459                         mtc_frame += mtc_off;
 460                         break;
 461                 default:
 462                         break;
 463                 }
 464
 465                 DEBUG_TRACE (DEBUG::MTC, string_compose ("new mtc_frame (w/offset) = %1\n", mtc_frame));
 466
 467                 if (now) {
 468                         if (first_mtc_timestamp == 0 || current.timestamp == 0) {
 469                                 first_mtc_timestamp = now;
 470                                 init_mtc_dll(mtc_frame, qtr);
 471                                 mtc_frame_dll = mtc_frame;
 472                         }
 473                         current.guard1++;
 474                         current.position = mtc_frame;
 475                         current.timestamp = now;
 476                         current.guard2++;
 477                         reset_window (mtc_frame);
 478                 }
 479         }
 480
 481         if (now) {
 482                 last_inbound_frame = now;
 483         }
 484         busy_guard2++;
 485 }
 486
 487 void
 488 MTC_Slave::update_mtc_status (MIDI::MTC_Status status)
 489 {
 490         /* XXX !!! thread safety ... called from MIDI I/O context
 491          * on locate (via ::update_mtc_time())
 492          */
 493         DEBUG_TRACE (DEBUG::MTC, string_compose("MTC_Slave::update_mtc_status - TID:%1\n", pthread_name()));
 494         return; // why was this fn needed anyway ? it just messes up things -> use reset.
 495         busy_guard1++;
 496
 497         switch (status) {
 498         case MTC_Stopped:
 499                 current.guard1++;
 500                 current.position = mtc_frame;
 501                 current.timestamp = 0;
 502                 current.speed = 0;
 503                 current.guard2++;
 504
 505                 break;
 506
 507         case MTC_Forward:
 508                 current.guard1++;
 509                 current.position = mtc_frame;
 510                 current.timestamp = 0;
 511                 current.speed = 0;
 512                 current.guard2++;
 513                 break;
 514
 515         case MTC_Backward:
 516                 current.guard1++;
 517                 current.position = mtc_frame;
 518                 current.timestamp = 0;
 519                 current.speed = 0;
 520                 current.guard2++;
 521                 break;
 522         }
 523         busy_guard2++;
 524 }
 525
 526 void
 527 MTC_Slave::reset_window (framepos_t root)
 528 {
 529         /* if we're waiting for the master to catch us after seeking ahead, keep the window
 530            of acceptable MTC frames wide open. otherwise, shrink it down to just 2 video frames
 531            ahead of the window root (taking direction into account).
 532         */
 533
 534         framecnt_t const d = (quarter_frame_duration * 4 * frame_tolerance);
 535
 536         switch (port->self_parser().mtc_running()) {
 537         case MTC_Forward:
 538                 window_begin = root;
 539                 transport_direction = 1;
 540                 window_end = root + d;
 541                 break;
 542
 543         case MTC_Backward:
 544                 transport_direction = -1;
 545                 if (root > d) {
 546                         window_begin = root - d;
 547                         window_end = root;
 548                 } else {
 549                         window_begin = 0;
 550                 }
 551                 window_end = root;
 552                 break;
 553
 554         default:
 555                 /* do nothing */
 556                 break;
 557         }
 558
 559         DEBUG_TRACE (DEBUG::MTC, string_compose ("reset MTC window @ %3, now %1 .. %2\n", window_begin, window_end, root));
 560 }
 561
 562 void
 563 MTC_Slave::init_engine_dll (framepos_t pos, framepos_t inc)
 564 {
 565         /* the bandwidth of the DLL is a trade-off,
 566          * because the max-speed of the transport in ardour is
 567          * limited to +-8.0, a larger bandwidth would cause oscillations
 568          *
 569          * But this is only really a problem if the user performs manual
 570          * seeks while transport is running and slaved to MTC.
 571          */
 572         oe = 2.0 * M_PI * double(inc) / 2.0 / double(session.frame_rate());
 573         be = 1.4142135623730950488 * oe;
 574         ce = oe * oe;
 575
 576         ee2 = double(transport_direction * inc);
 577         te0 = double(pos);
 578         te1 = te0 + ee2;
 579         DEBUG_TRACE (DEBUG::MTC, string_compose ("[re-]init Engine DLL %1 %2 %3\n", te0, te1, ee2));
 580 }
 581
 582 /* main entry point from session_process.cc
 583 xo * in process callback context */
 584 bool
 585 MTC_Slave::speed_and_position (double& speed, framepos_t& pos)
 586 {
 587         framepos_t now = session.engine().sample_time_at_cycle_start();
 588         framepos_t sess_pos = session.transport_frame(); // corresponds to now
 589         //sess_pos -= session.engine().frames_since_cycle_start();
 590
 591         SafeTime last;
 592         frameoffset_t elapsed;
 593         bool engine_dll_reinitialized = false;
 594
 595         read_current (&last);
 596
 597         DEBUG_TRACE (DEBUG::MTC, string_compose ("speed&pos: timestamp %1 speed %2 initstate %3 dir %4 tpos %5 now %6 last-in %7\n",
 598                                                  last.timestamp,
 599                                                  last.speed,
 600                                                  engine_dll_initstate,
 601                                                  transport_direction,
 602                                                  sess_pos,
 603                                                  now,
 604                                                  last_inbound_frame));
 605
 606         /* re-init engine DLL here when state changed (direction, first_mtc_timestamp) */
 607         if (last.timestamp == 0) {
 608                 engine_dll_initstate = 0;
 609         } else if (engine_dll_initstate != transport_direction && last.speed != 0) {
 610                 engine_dll_initstate = transport_direction;
 611                 init_engine_dll(last.position, session.engine().samples_per_cycle());
 612                 engine_dll_reinitialized = true;
 613         }
 614
 615         if (last.timestamp == 0) {
 616                 speed = 0;
 617                 pos = session.transport_frame() ; // last.position;
 618                 DEBUG_TRACE (DEBUG::MTC, string_compose ("first call to MTC_Slave::speed_and_position, pos = %1\n", pos));
 619                 return true;
 620         }
 621
 622         /* no timecode for two frames - conclude that it's stopped */
 623         if (last_inbound_frame && now > last_inbound_frame && now - last_inbound_frame > labs(seekahead_distance())) {
 624                 speed = 0;
 625                 pos = last.position;
 626                 session.request_locate (pos, false);
 627                 session.request_transport_speed (0);
 628                 engine_dll_initstate = 0;
 629                 queue_reset (false);
 630                 DEBUG_TRACE (DEBUG::MTC, "MTC not seen for 2 frames - reset pending\n");
 631                 return false;
 632         }
 633
 634
 635         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));
 636         DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position eng-tme: %1 eng-pos: %2\n", now, sess_pos));
 637
 638         double speed_flt = last.speed; ///< MTC speed from MTC-quarter-frame DLL
 639
 640         /* interpolate position according to speed and time since last quarter-frame*/
 641         if (speed_flt == 0.0f) {
 642                 elapsed = 0;
 643         } else {
 644                 /* scale elapsed time by the current MTC speed */
 645                 elapsed = (framecnt_t) rint (speed_flt * (now - last.timestamp));
 646                 if (give_slave_full_control_over_transport_speed() && !engine_dll_reinitialized) {
 647                         /* there is an engine vs MTC position frame-delta.
 648                          * This mostly due to quantization and rounding of (speed * nframes)
 649                          * but can also due to the session-process not calling
 650                          * speed_and_position() every cycle under some circumstances.
 651                          * Thus we use an other DLL to align the engine and the MTC
 652                          */
 653
 654                         /* update engine DLL and calculate speed */
 655                         const double e = double (last.position + elapsed - sess_pos);
 656                         te0 = te1;
 657                         te1 += be * e + ee2;
 658                         ee2 += ce * e;
 659                         speed_flt = (te1 - te0) / double(session.engine().samples_per_cycle());
 660                         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() ));
 661                 }
 662         }
 663
 664         pos = last.position + elapsed;
 665         speed = speed_flt;
 666
 667         /* may happen if the user performs a seek in the timeline while slaved to running MTC
 668          * engine-DLL can oscillate back before 0.
 669          * also see note in MTC_Slave::init_engine_dll
 670          */
 671         if (!session.actively_recording()
 672             && speed != 0
 673             && ((pos < 0) || (labs(pos - sess_pos) > 3 * session.frame_rate()))) {
 674                 engine_dll_initstate = 0;
 675                 queue_reset (false);
 676         }
 677
 678         /* provide a .1% deadzone to lock the speed */
 679         if (fabs (speed - 1.0) <= 0.001)
 680                 speed = 1.0;
 681
 682         DEBUG_TRACE (DEBUG::MTC, string_compose ("MTCsync spd: %1 pos: %2 | last-pos: %3 elapsed: %4 delta: %5\n",
 683                                                  speed, pos, last.position, elapsed,  pos - sess_pos));
 684
 685         current_delta = (pos - sess_pos);
 686
 687         return true;
 688 }
 689
 690 Timecode::TimecodeFormat
 691 MTC_Slave::apparent_timecode_format () const
 692 {
 693         return mtc_timecode;
 694 }
 695
 696 std::string
 697 MTC_Slave::approximate_current_position() const
 698 {
 699         SafeTime last;
 700         read_current (&last);
 701         if (last.timestamp == 0 || reset_pending) {
 702                 return " --:--:--:--";
 703         }
 704         return Timecode::timecode_format_sampletime(
 705                 last.position,
 706                 double(session.frame_rate()),
 707                 Timecode::timecode_to_frames_per_second(mtc_timecode),
 708                 Timecode::timecode_has_drop_frames(mtc_timecode));
 709 }
 710
 711 std::string
 712 MTC_Slave::approximate_current_delta() const
 713 {
 714         char delta[80];
 715         SafeTime last;
 716         read_current (&last);
 717         if (last.timestamp == 0 || reset_pending) {
 718                 snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012");
 719         } else {
 720                 snprintf(delta, sizeof(delta), "\u0394<span foreground=\"green\" face=\"monospace\" >%s%s%" PRIi64 "</span>sm",
 721                                 LEADINGZERO(abs(current_delta)), PLUSMINUS(-current_delta), abs(current_delta));
 722         }
 723         return std::string(delta);
 724 }