X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmtc_slave.cc;h=102694e7ac7d9a9ab637871f2e085eede99bc400;hb=c8c6bca6587450ff64303dbc994a4cd28d6ce7aa;hp=5edb5583f71055e108ef6f6c798d9709c6f9d0b8;hpb=a473d630eb165272992e90f8d854b1d66ec0be63;p=ardour.git diff --git a/libs/ardour/mtc_slave.cc b/libs/ardour/mtc_slave.cc index 5edb5583f7..102694e7ac 100644 --- a/libs/ardour/mtc_slave.cc +++ b/libs/ardour/mtc_slave.cc @@ -1,5 +1,6 @@ /* Copyright (C) 2002-4 Paul Davis + Overhaul 2012 Robin Gareus 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 @@ -18,28 +19,28 @@ */ #include #include -#include #include #include #include "pbd/error.h" -#include "pbd/enumwriter.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/pi_controller.h" +#include "ardour/slave.h" + +#include -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; 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 @@ -48,84 +49,270 @@ using namespace PBD; recently received position (and without the direction of timecode reversing too), we will stop+locate+wait+chase. */ - const int MTC_Slave::frame_tolerance = 2; -MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p) +MTC_Slave::MTC_Slave (Session& s, MidiPort& p) : session (s) + , port (&p) { can_notify_on_unknown_rate = true; did_reset_tc_format = false; reset_pending = 0; reset_position = false; - - pic = new PIChaser(); + 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 (); - mtc_frame = 0; + quarter_frame_duration = (double(session.frames_per_timecode_frame()) / 4.0); - speed_accumulator_size = 16; - speed_accumulator = new double[speed_accumulator_size]; + mtc_timecode = session.config.get_timecode_format(); + a3e_timecode = session.config.get_timecode_format(); + printed_timecode_warning = false; - rebind (p); + session.config.ParameterChanged.connect_same_thread (config_connection, boost::bind (&MTC_Slave::parameter_changed, this, _1)); + parse_timecode_offset(); reset (true); + + 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)); } MTC_Slave::~MTC_Slave() { + 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(); + } + if (did_reset_tc_format) { session.config.set_timecode_format (saved_tc_format); } +} + +void +MTC_Slave::rebind (MidiPort& p) +{ + port_connections.drop_connections (); + + port = &p; - delete pic; - delete [] speed_accumulator; +} + +void +MTC_Slave::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_Slave::parameter_changed (std::string const & p) +{ + if (p == "slave-timecode-offset" + || p == "timecode-format" + ) { + parse_timecode_offset(); + } } bool MTC_Slave::give_slave_full_control_over_transport_speed() const { - return true; // for PiC control */ + return true; // DLL align to engine transport // return false; // for Session-level computed varispeed } +ARDOUR::framecnt_t +MTC_Slave::resolution () const +{ + return (framecnt_t) quarter_frame_duration * 4.0; +} + +ARDOUR::framecnt_t +MTC_Slave::seekahead_distance () const +{ + return quarter_frame_duration * 8 * transport_direction; +} + +bool +MTC_Slave::outside_window (framepos_t pos) const +{ + return ((pos < window_begin) || (pos > window_end)); +} + + +bool +MTC_Slave::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; +} + +bool +MTC_Slave::ok() const +{ + return true; +} + void -MTC_Slave::rebind (MIDI::Port& p) +MTC_Slave::queue_reset (bool reset_pos) { - port_connections.drop_connections (); + Glib::Threads::Mutex::Lock lm (reset_lock); + reset_pending++; + if (reset_pos) { + reset_position = true; + } +} - port = &p; +void +MTC_Slave::maybe_reset () +{ + Glib::Threads::Mutex::Lock lm (reset_lock); + + if (reset_pending) { + reset (reset_position); + reset_pending = 0; + reset_position = false; + } +} + +void +MTC_Slave::reset (bool with_position) +{ + DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC_Slave reset %1\n", with_position?"with position":"without position")); + if (with_position) { + last_inbound_frame = 0; + current.guard1++; + current.position = 0; + current.timestamp = 0; + current.speed = 0; + current.guard2++; + } else { + last_inbound_frame = 0; + current.guard1++; + current.timestamp = 0; + current.speed = 0; + current.guard2++; + } + first_mtc_timestamp = 0; + window_begin = 0; + window_end = 0; + transport_direction = 1; + current_delta = 0; + ActiveChanged(false); +} + +void +MTC_Slave::handle_locate (const MIDI::byte* mmc_tc) +{ + MIDI::byte mtc[5]; + DEBUG_TRACE (DEBUG::MTC, "MTC_Slave::handle_locate\n"); - port->parser()->mtc_time.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3)); - port->parser()->mtc_qtr.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3)); - port->parser()->mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1)); + 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_Slave::read_current (SafeTime *st) const +{ + int tries = 0; + + do { + if (tries == 10) { + error << _("MTC Slave: atomic read of current time failed, sleeping!") << endmsg; + Glib::usleep (20); + tries = 0; + } + *st = current; + tries++; + + } while (st->guard1 != st->guard2); +} + +void +MTC_Slave::init_mtc_dll(framepos_t tme, double qtr) +{ + omega = 2.0 * M_PI * qtr / 2.0 / double(session.frame_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*/, int which_qtr, framepos_t now) { - DEBUG_TRACE (DEBUG::MTC, string_compose ("qtr frame %1 at %2\n", which_qtr, now)); + busy_guard1++; + const double qtr_d = quarter_frame_duration; + + mtc_frame_dll += qtr_d * (double) transport_direction; + mtc_frame = rint(mtc_frame_dll); + + DEBUG_TRACE (DEBUG::MTC, string_compose ("qtr frame %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 frame DLL t0:%1 t1:%2 err:%3 spd:%4 ddt:%5\n", t0, t1, e, mtc_speed, e2 - qtr_d)); + + current.guard1++; + current.position = mtc_frame; + current.timestamp = now; + current.speed = mtc_speed; + current.guard2++; + + last_inbound_frame = now; + } + 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, framepos_t now) +MTC_Slave::update_mtc_time (const MIDI::byte *msg, bool was_full, framepos_t now) { + 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. */ - - if (now) { - maybe_reset (); - } - - Timecode::Time timecode; + DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::update_mtc_time - TID:%1\n", pthread_name())); TimecodeFormat tc_format; bool reset_tc = true; - framepos_t window_root = -1; - - DEBUG_TRACE (DEBUG::MTC, string_compose ("full mtc time known at %1, full ? %2\n", now, was_full)); timecode.hours = msg[3]; timecode.minutes = msg[2]; @@ -134,6 +321,12 @@ MTC_Slave::update_mtc_time (const byte *msg, bool was_full, framepos_t now) 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; @@ -148,9 +341,14 @@ MTC_Slave::update_mtc_time (const byte *msg, bool was_full, framepos_t now) can_notify_on_unknown_rate = true; break; case MTC_30_FPS_DROP: - timecode.rate = 30; + if (Config->get_timecode_source_2997()) { + 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; - tc_format = timecode_30drop; can_notify_on_unknown_rate = true; break; case MTC_30_FPS: @@ -173,25 +371,67 @@ MTC_Slave::update_mtc_time (const byte *msg, bool was_full, framepos_t now) } if (reset_tc) { - if (!did_reset_tc_format) { - saved_tc_format = session.config.get_timecode_format(); - did_reset_tc_format = true; + 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; + } } - session.config.set_timecode_format (tc_format); + mtc_timecode = tc_format; + a3e_timecode = cur_timecode; + + speedup_due_to_tc_mismatch = timecode.rate / Timecode::timecode_to_frames_per_second(a3e_timecode); } - DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC time timestamp = %1 TC %2 = frame %3 (from full message ? %4)\n", - now, timecode, mtc_frame, was_full)); + /* do a careful conversion of the timecode value to a position + so that we take drop/nondrop and all that nonsense into + consideration. + */ - if (was_full || outside_window (mtc_frame)) { + quarter_frame_duration = (double(session.frame_rate()) / (double) timecode.rate / 4.0); + + Timecode::timecode_to_sample (timecode, mtc_frame, true, false, + double(session.frame_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)); - session.timecode_to_sample (timecode, mtc_frame, true, false); + if (was_full || outside_window (mtc_frame)) { + DEBUG_TRACE (DEBUG::MTC, string_compose ("update_mtc_time: full TC %1 or outside window %2\n", was_full, outside_window (mtc_frame))); session.request_locate (mtc_frame, false); session.request_transport_speed (0); update_mtc_status (MIDI::MTC_Stopped); reset (false); reset_window (mtc_frame); - } else { /* we've had the first set of 8 qtr frame messages, determine position @@ -199,138 +439,61 @@ MTC_Slave::update_mtc_time (const byte *msg, bool was_full, framepos_t now) and speed information. */ - /* do a careful conversion of the timecode value to a position - so that we take drop/nondrop and all that nonsense into - consideration. - */ - - session.timecode_to_sample (timecode, mtc_frame, true, false); - /* 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. + frames. */ + 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.frames_per_timecode_frame())); + + switch (port->self_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_playback_latency(); - + DEBUG_TRACE (DEBUG::MTC, string_compose ("new mtc_frame (w/offset) = %1\n", mtc_frame)); if (now) { - - if (last_mtc_timestamp == 0) { - - last_mtc_timestamp = now; - last_mtc_frame = mtc_frame; - - } else { - - if (give_slave_full_control_over_transport_speed()) { - /* PIC - * - * its not the average, but we will assign it to current.speed below - */ - - static framepos_t last_seen_timestamp = 0; - static framepos_t last_seen_position = 0; - - if ((now - last_seen_timestamp) < 300) { - mtc_frame = (mtc_frame + last_seen_position)/2; - } - - last_seen_timestamp = now; - last_seen_position = mtc_frame; - - - - } else { - - /* Non-PiC - */ - - framepos_t time_delta = (now - last_mtc_timestamp); - - if (time_delta != 0) { - double apparent_speed = (mtc_frame - last_mtc_frame) / (double) (time_delta); - - process_apparent_speed (apparent_speed); - DEBUG_TRACE (DEBUG::Slave, string_compose ("apparent speed was %1 average is now %2\n", apparent_speed, average_speed)); - } else { - DEBUG_TRACE (DEBUG::Slave, string_compose ("no apparent calc, average is %1\n", average_speed)); - } - - /* every second, recalibrate the starting point for the speed measurement */ - if (mtc_frame - last_mtc_frame > session.frame_rate()) { - last_mtc_timestamp = now; - last_mtc_frame = mtc_frame; - } - } + if (first_mtc_timestamp == 0 || current.timestamp == 0) { + 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; current.timestamp = now; - current.speed = average_speed; current.guard2++; - window_root = mtc_frame; + reset_window (mtc_frame); } } if (now) { last_inbound_frame = now; } - - if (window_root >= 0) { - reset_window (window_root); - } -} - -void -MTC_Slave::process_apparent_speed (double this_speed) -{ - DEBUG_TRACE (DEBUG::MTC, string_compose ("speed cnt %1 sz %2 have %3\n", speed_accumulator_cnt, speed_accumulator_size, have_first_speed_accumulator)); - - /* clamp to an expected range */ - - if (this_speed > 4.0 || this_speed < -4.0) { - this_speed = average_speed; - } - - if (speed_accumulator_cnt >= speed_accumulator_size) { - have_first_speed_accumulator = true; - speed_accumulator_cnt = 0; - } - - speed_accumulator[speed_accumulator_cnt++] = this_speed; - - if (have_first_speed_accumulator) { - average_speed = 0.0; - for (size_t i = 0; i < speed_accumulator_size; ++i) { - average_speed += speed_accumulator[i]; - } - average_speed /= speed_accumulator_size; - } -} - -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, 0); + busy_guard2++; } void MTC_Slave::update_mtc_status (MIDI::MTC_Status status) { /* XXX !!! thread safety ... called from MIDI I/O context - and process() context (via ::speed_and_position()) - */ + * on locate (via ::update_mtc_time()) + */ + DEBUG_TRACE (DEBUG::MTC, string_compose("MTC_Slave::update_mtc_status - TID:%1\n", pthread_name())); + return; // why was this fn needed anyway ? it just messes up things -> use reset. + busy_guard1++; switch (status) { case MTC_Stopped: @@ -358,238 +521,206 @@ MTC_Slave::update_mtc_status (MIDI::MTC_Status status) current.guard2++; break; } - + busy_guard2++; } void -MTC_Slave::read_current (SafeTime *st) const +MTC_Slave::reset_window (framepos_t root) { - int tries = 0; + /* if we're waiting for the master to catch us after seeking ahead, keep the window + of acceptable MTC frames wide open. otherwise, shrink it down to just 2 video frames + ahead of the window root (taking direction into account). + */ - do { - if (tries == 10) { - error << _("MTC Slave: atomic read of current time failed, sleeping!") << endmsg; - usleep (20); - tries = 0; + framecnt_t const d = (quarter_frame_duration * 4 * frame_tolerance); + + switch (port->self_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; } - *st = current; - tries++; + window_end = root; + break; - } while (st->guard1 != st->guard2); -} + default: + /* do nothing */ + break; + } -bool -MTC_Slave::locked () const -{ - return port->parser()->mtc_locked(); + DEBUG_TRACE (DEBUG::MTC, string_compose ("reset MTC window @ %3, now %1 .. %2\n", window_begin, window_end, root)); } -bool -MTC_Slave::ok() const +void +MTC_Slave::init_engine_dll (framepos_t pos, framepos_t inc) { - return true; + /* 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.frame_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, framepos_t& pos) { - framepos_t now = session.engine().frame_time(); + framepos_t now = session.engine().sample_time_at_cycle_start(); + framepos_t sess_pos = session.transport_frame(); // corresponds to now + //sess_pos -= session.engine().frames_since_cycle_start(); + SafeTime last; - framecnt_t elapsed; - bool in_control = false; + frameoffset_t elapsed; + bool engine_dll_reinitialized = 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", + 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 = last.position; - DEBUG_TRACE (DEBUG::MTC, string_compose ("first call to MTC_Slave::speed_and_position, pos = %1\n", last.position)); + pos = session.transport_frame() ; // last.position; + DEBUG_TRACE (DEBUG::MTC, string_compose ("first call to MTC_Slave::speed_and_position, pos = %1\n", pos)); 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) { + /* no timecode for two frames - 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.request_locate (pos, false); session.request_transport_speed (0); + engine_dll_initstate = 0; queue_reset (false); - DEBUG_TRACE (DEBUG::MTC, "MTC not seen for 1/4 second - reset pending\n"); + ActiveChanged (false); + DEBUG_TRACE (DEBUG::MTC, "MTC not seen for 2 frames - reset pending\n"); return false; } - DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position %1 %2\n", last.speed, last.position)); - - if (give_slave_full_control_over_transport_speed()) { - in_control = (session.slave_state() == Session::Running); - framepos_t pic_want_locate = 0; - //framepos_t slave_pos = session.audible_frame(); - framepos_t slave_pos = session.transport_frame(); - static double average_speed = 0; - framepos_t ref_now = session.engine().frame_time_at_cycle_start(); - average_speed = pic->get_ratio (last.timestamp, last.position, ref_now, slave_pos, in_control, session.engine().frames_per_cycle()); - - pic_want_locate = pic->want_locate(); - - if (in_control && pic_want_locate) { - last.speed = average_speed + (double) (pic_want_locate - session.transport_frame()) / (double)session.get_block_size(); - std::cout << "locate req " << pic_want_locate << " speed: " << average_speed << "\n"; - } else { - last.speed = average_speed; - } - } + 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)); - if (last.speed == 0.0f) { + 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 */ - - if (last.timestamp && (now > last.timestamp)) { - elapsed = (framecnt_t) floor (last.speed * (now - last.timestamp)); - DEBUG_TRACE (DEBUG::MTC, string_compose ("last timecode received @ %1, now = %2, elapsed frames = %3 w/speed= %4\n", - last.timestamp, now, elapsed, last.speed)); - } else { - elapsed = 0; /* XXX is this right? */ + elapsed = (framecnt_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 frame-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() )); } } - /* now add the most recent timecode value plus the estimated elapsed interval */ - - if (in_control) { - pos = session.transport_frame(); - } else { - pos = last.position + elapsed; + 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.frame_rate()))) { + engine_dll_initstate = 0; + queue_reset (false); } - speed = last.speed; - - DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position FINAL %1 %2\n", last.speed, pos)); + /* provide a .1% deadzone to lock the speed */ + 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)); - DEBUG_TRACE (DEBUG::MTC, string_compose ("last = %1 elapsed = %2 pos = %3 speed = %4\n", last.position, elapsed, pos, speed)); + current_delta = (pos - sess_pos); return true; } -ARDOUR::framecnt_t -MTC_Slave::resolution () const +Timecode::TimecodeFormat +MTC_Slave::apparent_timecode_format () const { - return (framecnt_t) session.frames_per_timecode_frame(); + return mtc_timecode; } -void -MTC_Slave::queue_reset (bool reset_pos) +std::string +MTC_Slave::approximate_current_position() const { - Glib::Mutex::Lock lm (reset_lock); - reset_pending++; - if (reset_pos) { - reset_position = true; - } -} - -void -MTC_Slave::maybe_reset () -{ - Glib::Mutex::Lock lm (reset_lock); - - if (reset_pending) { - reset (reset_position); - reset_pending = 0; - reset_position = false; + SafeTime last; + read_current (&last); + if (last.timestamp == 0 || reset_pending) { + return " --:--:--:--"; } + return Timecode::timecode_format_sampletime( + last.position, + double(session.frame_rate()), + Timecode::timecode_to_frames_per_second(mtc_timecode), + Timecode::timecode_has_drop_frames(mtc_timecode)); } -void -MTC_Slave::reset (bool with_position) +std::string +MTC_Slave::approximate_current_delta() const { - if (with_position) { - last_inbound_frame = 0; - current.guard1++; - current.position = 0; - current.timestamp = 0; - current.speed = 0; - current.guard2++; + char delta[80]; + SafeTime last; + read_current (&last); + if (last.timestamp == 0 || reset_pending) { + snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012"); } else { - last_inbound_frame = 0; - current.guard1++; - current.timestamp = 0; - current.speed = 0; - current.guard2++; - } - - window_begin = 0; - window_end = 0; - last_mtc_frame = 0; - last_mtc_timestamp = 0; - - average_speed = 0; - have_first_speed_accumulator = false; - speed_accumulator_cnt = 0; - - pic->reset(); -} - -void -MTC_Slave::reset_window (framepos_t root) -{ - - /* if we're waiting for the master to catch us after seeking ahead, keep the window - of acceptable MTC frames wide open. otherwise, shrink it down to just 2 video frames - ahead of the window root (taking direction into account). - */ - - switch (port->parser()->mtc_running()) { - case MTC_Forward: - window_begin = root; - if (session.slave_state() == Session::Running) { - window_end = root + (session.frames_per_timecode_frame() * frame_tolerance); - } else { - window_end = root + seekahead_distance (); - } - break; - - case MTC_Backward: - if (session.slave_state() == Session::Running) { - framecnt_t const d = session.frames_per_timecode_frame() * frame_tolerance; - if (root > d) { - window_begin = root - d; - window_end = root; - } else { - window_begin = 0; - } - } else { - framecnt_t const d = seekahead_distance (); - if (root > d) { - window_begin = root - d; - } else { - window_begin = 0; - } - } - window_end = root; - break; - - default: - /* do nothing */ - break; + snprintf(delta, sizeof(delta), "\u0394%s%s%" PRIi64 "sm", + LEADINGZERO(abs(current_delta)), PLUSMINUS(-current_delta), abs(current_delta)); } - - DEBUG_TRACE (DEBUG::MTC, string_compose ("legal MTC window now %1 .. %2\n", window_begin, window_end)); -} - -ARDOUR::framecnt_t -MTC_Slave::seekahead_distance () const -{ - /* 1 second */ - return session.frame_rate(); -} - -bool -MTC_Slave::outside_window (framepos_t pos) const -{ - return ((pos < window_begin) || (pos > window_end)); + return std::string(delta); }