X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmtc_slave.cc;h=f8afe66d93d6986d59a3a5a91ff2155bd4f31c26;hb=b285559767e21aae4467270590f048c3263fd742;hp=6c95730f24f6999d050b0ca5b886d5fcece66919;hpb=6fa6514cfdb0ce38d93b51197f599dfd091bad1d;p=ardour.git diff --git a/libs/ardour/mtc_slave.cc b/libs/ardour/mtc_slave.cc index 6c95730f24..f8afe66d93 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,25 +19,26 @@ */ #include #include -#include #include #include #include "pbd/error.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/transport_master.h" -#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 @@ -45,84 +47,280 @@ using namespace PBD; 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())); -const int MTC_Slave::frame_tolerance = 2; + init (); +} -MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p) - : session (s) +MTC_TransportMaster::~MTC_TransportMaster() { - can_notify_on_unknown_rate = true; - did_reset_tc_format = false; - reset_pending = 0; - reset_position = false; + 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(); + } - pic = new PIChaser(); + if (did_reset_tc_format) { + _session->config.set_timecode_format (saved_tc_format); + } +} - last_mtc_fps_byte = session.get_mtc_timecode_bits (); - mtc_frame = 0; +void +MTC_TransportMaster::init () +{ + reset (true); +} - speed_accumulator_size = 16; - speed_accumulator = new double[speed_accumulator_size]; +void +MTC_TransportMaster::set_session (Session *s) +{ + config_connection.disconnect (); + port_connections.drop_connections(); - rebind (p); - reset (true); + _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)); + } } -MTC_Slave::~MTC_Slave() +void +MTC_TransportMaster::pre_process (MIDI::pframes_t nframes, samplepos_t now, boost::optional session_pos) { - if (did_reset_tc_format) { - session.config.set_timecode_format (saved_tc_format); + /* 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; } +} - delete pic; - delete [] speed_accumulator; +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; + } + + 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; } bool -MTC_Slave::give_slave_full_control_over_transport_speed() const +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) { - return true; // for PiC control */ - // return false; // for Session-level computed varispeed + 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_Slave::rebind (MIDI::Port& p) +MTC_TransportMaster::handle_locate (const MIDI::byte* mmc_tc) { - port_connections.drop_connections (); + 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]; - port = &p; + update_mtc_time (mtc, true, 0); +} - 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)); +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*/, int which_qtr, framepos_t now) +MTC_TransportMaster::update_mtc_qtr (Parser& p, int which_qtr, samplepos_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 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; + } + 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_TransportMaster::update_mtc_time (const MIDI::byte *msg, bool was_full, samplepos_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]; @@ -131,6 +329,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; @@ -145,9 +349,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 (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; - tc_format = timecode_30drop; can_notify_on_unknown_rate = true; break; case MTC_30_FPS: @@ -164,408 +373,170 @@ MTC_Slave::update_mtc_time (const byte *msg, bool was_full, framepos_t now) << 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) { - 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->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 + ); - session.timecode_to_sample (timecode, mtc_frame, true, false); - session.request_locate (mtc_frame, false); - session.request_transport_speed (0); + 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 frame messages, determine position - and allow continuing qtr frame messages to provide position + /* 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. */ - /* 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. + 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_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; } - - current.guard1++; - current.position = mtc_frame; - current.timestamp = now; - current.speed = average_speed; - current.guard2++; - window_root = mtc_frame; + current.update (mtc_frame, now, current.speed); + 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; - } + busy_guard2++; } 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); -} - -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 - and process() context (via ::speed_and_position()) - */ + * 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: - current.guard1++; - current.position = mtc_frame; - current.timestamp = 0; - current.speed = 0; - current.guard2++; - + current.update (mtc_frame, 0, 0); break; case MTC_Forward: - current.guard1++; - current.position = mtc_frame; - current.timestamp = 0; - current.speed = 0; - current.guard2++; + current.update (mtc_frame, 0, 0); break; case MTC_Backward: - current.guard1++; - current.position = mtc_frame; - current.timestamp = 0; - current.speed = 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; - } - *st = current; - tries++; - - } while (st->guard1 != st->guard2); -} - -bool -MTC_Slave::locked () const -{ - return port->parser()->mtc_locked(); -} - -bool -MTC_Slave::ok() const -{ - return true; -} - -bool -MTC_Slave::speed_and_position (double& speed, framepos_t& pos) -{ - framepos_t now = session.engine().frame_time(); - SafeTime last; - framecnt_t elapsed; - bool in_control = false; - - read_current (&last); - - 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)); - 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) { - speed = 0; - pos = last.position; - session.request_locate (pos, false); - session.request_transport_speed (0); - queue_reset (false); - DEBUG_TRACE (DEBUG::MTC, "MTC not seen for 1/4 second - 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; - } - } - - if (last.speed == 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? */ - } - } - - /* now add the most recent timecode value plus the estimated elapsed interval */ - - if (in_control) { - pos = session.transport_frame(); - } else { - pos = last.position + elapsed; - } - - speed = last.speed; - - DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position FINAL %1 %2\n", last.speed, pos)); - - - DEBUG_TRACE (DEBUG::MTC, string_compose ("last = %1 elapsed = %2 pos = %3 speed = %4\n", last.position, elapsed, pos, speed)); - - return true; -} - -ARDOUR::framecnt_t -MTC_Slave::resolution () const -{ - return (framecnt_t) session.frames_per_timecode_frame(); -} - -void -MTC_Slave::queue_reset (bool reset_pos) -{ - 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; - } -} - -void -MTC_Slave::reset (bool with_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++; - } - - 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 + of acceptable MTC samples 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()) { + samplecnt_t const d = (quarter_frame_duration * 4 * sample_tolerance); + + switch (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 (); - } + transport_direction = 1; + window_end = root + d; 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; - } + transport_direction = -1; + if (root > d) { + window_begin = root - d; + window_end = root; } else { - framecnt_t const d = seekahead_distance (); - if (root > d) { - window_begin = root - d; - } else { - window_begin = 0; - } + window_begin = 0; } window_end = root; break; @@ -575,18 +546,44 @@ MTC_Slave::reset_window (framepos_t root) break; } - DEBUG_TRACE (DEBUG::MTC, string_compose ("legal MTC window now %1 .. %2\n", window_begin, window_end)); + DEBUG_TRACE (DEBUG::MTC, string_compose ("reset MTC window @ %3, now %1 .. %2\n", window_begin, window_end, root)); } -ARDOUR::framecnt_t -MTC_Slave::seekahead_distance () const +Timecode::TimecodeFormat +MTC_TransportMaster::apparent_timecode_format () const { - /* 1 second */ - return session.frame_rate(); + return mtc_timecode; } -bool -MTC_Slave::outside_window (framepos_t pos) const +std::string +MTC_TransportMaster::position_string() const { - return ((pos < window_begin) || (pos > window_end)); + 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)); +} + +std::string +MTC_TransportMaster::delta_string () const +{ + char delta[80]; + SafeTime last; + current.safe_read (last); + + delta[0] = '\0'; + + if (last.timestamp == 0 || reset_pending) { + snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012"); + } else { + snprintf(delta, sizeof(delta), "\u0394%s%s%" PRIi64 "sm", + LEADINGZERO(abs(_current_delta)), PLUSMINUS(-_current_delta), abs(_current_delta)); + } + return std::string(delta); }