2 Copyright (C) 2002-4 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <sys/types.h>
25 #include "pbd/error.h"
26 #include "pbd/enumwriter.h"
27 #include "pbd/failed_constructor.h"
28 #include "pbd/pthread_utils.h"
30 #include "midi++/port.h"
31 #include "ardour/debug.h"
32 #include "ardour/slave.h"
33 #include "ardour/session.h"
34 #include "ardour/audioengine.h"
35 #include "ardour/pi_controller.h"
40 using namespace ARDOUR;
44 /* length (in timecode frames) of the "window" that we consider legal given receipt of
45 a given timecode position. Ardour will try to chase within this window, and will
46 stop+locate+wait+chase if timecode arrives outside of it. The window extends entirely
47 in the current direction of motion, so if any timecode arrives that is before the most
48 recently received position (and without the direction of timecode reversing too), we
49 will stop+locate+wait+chase.
52 const int MTC_Slave::frame_tolerance = 2;
54 MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p)
57 can_notify_on_unknown_rate = true;
58 did_reset_tc_format = false;
60 reset_position = false;
64 last_mtc_fps_byte = session.get_mtc_timecode_bits ();
67 speed_accumulator_size = 16;
68 speed_accumulator = new double[speed_accumulator_size];
74 MTC_Slave::~MTC_Slave()
76 if (did_reset_tc_format) {
77 session.config.set_timecode_format (saved_tc_format);
81 delete [] speed_accumulator;
85 MTC_Slave::give_slave_full_control_over_transport_speed() const
87 return true; // for PiC control */
88 // return false; // for Session-level computed varispeed
92 MTC_Slave::rebind (MIDI::Port& p)
94 port_connections.drop_connections ();
98 port->parser()->mtc_time.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3));
99 port->parser()->mtc_qtr.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3));
100 port->parser()->mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1));
104 MTC_Slave::update_mtc_qtr (Parser& /*p*/, int which_qtr, framepos_t now)
106 DEBUG_TRACE (DEBUG::MTC, string_compose ("qtr frame %1 at %2\n", which_qtr, now));
108 last_inbound_frame = now;
112 MTC_Slave::update_mtc_time (const byte *msg, bool was_full, framepos_t now)
114 /* "now" can be zero if this is called from a context where we do not have or do not want
115 to use a timestamp indicating when this MTC time was received. example: when we received
116 a locate command via MMC.
123 Timecode::Time timecode;
124 TimecodeFormat tc_format;
125 bool reset_tc = true;
126 framepos_t window_root = -1;
128 DEBUG_TRACE (DEBUG::MTC, string_compose ("full mtc time known at %1, full ? %2\n", now, was_full));
130 timecode.hours = msg[3];
131 timecode.minutes = msg[2];
132 timecode.seconds = msg[1];
133 timecode.frames = msg[0];
135 last_mtc_fps_byte = msg[4];
140 timecode.drop = false;
141 tc_format = timecode_24;
142 can_notify_on_unknown_rate = true;
146 timecode.drop = false;
147 tc_format = timecode_25;
148 can_notify_on_unknown_rate = true;
150 case MTC_30_FPS_DROP:
152 timecode.drop = true;
153 tc_format = timecode_30drop;
154 can_notify_on_unknown_rate = true;
158 timecode.drop = false;
159 can_notify_on_unknown_rate = true;
160 tc_format = timecode_30;
163 /* throttle error messages about unknown MTC rates */
164 if (can_notify_on_unknown_rate) {
165 error << string_compose (_("Unknown rate/drop value %1 in incoming MTC stream, session values used instead"),
168 can_notify_on_unknown_rate = false;
170 timecode.rate = session.timecode_frames_per_second();
171 timecode.drop = session.timecode_drop_frames();
176 if (!did_reset_tc_format) {
177 saved_tc_format = session.config.get_timecode_format();
178 did_reset_tc_format = true;
180 session.config.set_timecode_format (tc_format);
183 DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC time timestamp = %1 TC %2 = frame %3 (from full message ? %4)\n",
184 now, timecode, mtc_frame, was_full));
186 if (was_full || outside_window (mtc_frame)) {
188 session.timecode_to_sample (timecode, mtc_frame, true, false);
189 session.request_locate (mtc_frame, false);
190 session.request_transport_speed (0);
191 update_mtc_status (MIDI::MTC_Stopped);
193 reset_window (mtc_frame);
197 /* we've had the first set of 8 qtr frame messages, determine position
198 and allow continuing qtr frame messages to provide position
199 and speed information.
202 /* do a careful conversion of the timecode value to a position
203 so that we take drop/nondrop and all that nonsense into
207 session.timecode_to_sample (timecode, mtc_frame, true, false);
209 /* We received the last quarter frame 7 quarter frames (1.75 mtc
210 frames) after the instance when the contents of the mtc quarter
211 frames were decided. Add time to compensate for the elapsed 1.75
212 frames. Also compensate for audio latency.
215 mtc_frame += (long) (1.75 * session.frames_per_timecode_frame()) + session.worst_playback_latency();
220 if (last_mtc_timestamp == 0) {
222 last_mtc_timestamp = now;
223 last_mtc_frame = mtc_frame;
227 if (give_slave_full_control_over_transport_speed()) {
230 * its not the average, but we will assign it to current.speed below
233 static framepos_t last_seen_timestamp = 0;
234 static framepos_t last_seen_position = 0;
236 if ((now - last_seen_timestamp) < 300) {
237 mtc_frame = (mtc_frame + last_seen_position)/2;
240 last_seen_timestamp = now;
241 last_seen_position = mtc_frame;
250 framepos_t time_delta = (now - last_mtc_timestamp);
252 if (time_delta != 0) {
253 double apparent_speed = (mtc_frame - last_mtc_frame) / (double) (time_delta);
255 process_apparent_speed (apparent_speed);
256 DEBUG_TRACE (DEBUG::Slave, string_compose ("apparent speed was %1 average is now %2\n", apparent_speed, average_speed));
258 DEBUG_TRACE (DEBUG::Slave, string_compose ("no apparent calc, average is %1\n", average_speed));
261 /* every second, recalibrate the starting point for the speed measurement */
262 if (mtc_frame - last_mtc_frame > session.frame_rate()) {
263 last_mtc_timestamp = now;
264 last_mtc_frame = mtc_frame;
270 current.position = mtc_frame;
271 current.timestamp = now;
272 current.speed = average_speed;
274 window_root = mtc_frame;
279 last_inbound_frame = now;
282 if (window_root >= 0) {
283 reset_window (window_root);
288 MTC_Slave::process_apparent_speed (double this_speed)
290 DEBUG_TRACE (DEBUG::MTC, string_compose ("speed cnt %1 sz %2 have %3\n", speed_accumulator_cnt, speed_accumulator_size, have_first_speed_accumulator));
292 /* clamp to an expected range */
294 if (this_speed > 4.0 || this_speed < -4.0) {
295 this_speed = average_speed;
298 if (speed_accumulator_cnt >= speed_accumulator_size) {
299 have_first_speed_accumulator = true;
300 speed_accumulator_cnt = 0;
303 speed_accumulator[speed_accumulator_cnt++] = this_speed;
305 if (have_first_speed_accumulator) {
307 for (size_t i = 0; i < speed_accumulator_size; ++i) {
308 average_speed += speed_accumulator[i];
310 average_speed /= speed_accumulator_size;
315 MTC_Slave::handle_locate (const MIDI::byte* mmc_tc)
319 mtc[4] = last_mtc_fps_byte;
320 mtc[3] = mmc_tc[0] & 0xf; /* hrs only */
325 update_mtc_time (mtc, true, 0);
329 MTC_Slave::update_mtc_status (MIDI::MTC_Status status)
331 /* XXX !!! thread safety ... called from MIDI I/O context
332 and process() context (via ::speed_and_position())
338 current.position = mtc_frame;
339 current.timestamp = 0;
347 current.position = mtc_frame;
348 current.timestamp = 0;
355 current.position = mtc_frame;
356 current.timestamp = 0;
365 MTC_Slave::read_current (SafeTime *st) const
371 error << _("MTC Slave: atomic read of current time failed, sleeping!") << endmsg;
378 } while (st->guard1 != st->guard2);
382 MTC_Slave::locked () const
384 return port->parser()->mtc_locked();
388 MTC_Slave::ok() const
394 MTC_Slave::speed_and_position (double& speed, framepos_t& pos)
396 framepos_t now = session.engine().frame_time();
399 bool in_control = false;
401 read_current (&last);
403 if (last.timestamp == 0) {
406 DEBUG_TRACE (DEBUG::MTC, string_compose ("first call to MTC_Slave::speed_and_position, pos = %1\n", last.position));
410 /* no timecode for 1/4 second ? conclude that its stopped */
412 if (last_inbound_frame && now > last_inbound_frame && now - last_inbound_frame > session.frame_rate() / 4) {
415 session.request_locate (pos, false);
416 session.request_transport_speed (0);
418 DEBUG_TRACE (DEBUG::MTC, "MTC not seen for 1/4 second - reset pending\n");
422 DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position %1 %2\n", last.speed, last.position));
424 if (give_slave_full_control_over_transport_speed()) {
425 in_control = (session.slave_state() == Session::Running);
426 framepos_t pic_want_locate = 0;
427 //framepos_t slave_pos = session.audible_frame();
428 framepos_t slave_pos = session.transport_frame();
429 static double average_speed = 0;
431 framepos_t ref_now = session.engine().frame_time_at_cycle_start();
432 average_speed = pic->get_ratio (last.timestamp, last.position, ref_now, slave_pos, in_control, session.engine().frames_per_cycle());
434 pic_want_locate = pic->want_locate();
436 if (in_control && pic_want_locate) {
437 last.speed = average_speed + (double) (pic_want_locate - session.transport_frame()) / (double)session.get_block_size();
438 std::cout << "locate req " << pic_want_locate << " speed: " << average_speed << "\n";
440 last.speed = average_speed;
444 if (last.speed == 0.0f) {
450 /* scale elapsed time by the current MTC speed */
452 if (last.timestamp && (now > last.timestamp)) {
453 elapsed = (framecnt_t) floor (last.speed * (now - last.timestamp));
454 DEBUG_TRACE (DEBUG::MTC, string_compose ("last timecode received @ %1, now = %2, elapsed frames = %3 w/speed= %4\n",
455 last.timestamp, now, elapsed, last.speed));
457 elapsed = 0; /* XXX is this right? */
461 /* now add the most recent timecode value plus the estimated elapsed interval */
464 pos = session.transport_frame();
466 pos = last.position + elapsed;
471 DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position FINAL %1 %2\n", last.speed, pos));
474 DEBUG_TRACE (DEBUG::MTC, string_compose ("last = %1 elapsed = %2 pos = %3 speed = %4\n", last.position, elapsed, pos, speed));
480 MTC_Slave::resolution () const
482 return (framecnt_t) session.frames_per_timecode_frame();
486 MTC_Slave::queue_reset (bool reset_pos)
488 Glib::Mutex::Lock lm (reset_lock);
491 reset_position = true;
496 MTC_Slave::maybe_reset ()
498 Glib::Mutex::Lock lm (reset_lock);
501 reset (reset_position);
503 reset_position = false;
508 MTC_Slave::reset (bool with_position)
511 last_inbound_frame = 0;
513 current.position = 0;
514 current.timestamp = 0;
518 last_inbound_frame = 0;
520 current.timestamp = 0;
528 last_mtc_timestamp = 0;
531 have_first_speed_accumulator = false;
532 speed_accumulator_cnt = 0;
538 MTC_Slave::reset_window (framepos_t root)
541 /* if we're waiting for the master to catch us after seeking ahead, keep the window
542 of acceptable MTC frames wide open. otherwise, shrink it down to just 2 video frames
543 ahead of the window root (taking direction into account).
546 switch (port->parser()->mtc_running()) {
549 if (session.slave_state() == Session::Running) {
550 window_end = root + (session.frames_per_timecode_frame() * frame_tolerance);
552 window_end = root + seekahead_distance ();
557 if (session.slave_state() == Session::Running) {
558 framecnt_t const d = session.frames_per_timecode_frame() * frame_tolerance;
560 window_begin = root - d;
566 framecnt_t const d = seekahead_distance ();
568 window_begin = root - d;
581 DEBUG_TRACE (DEBUG::MTC, string_compose ("legal MTC window now %1 .. %2\n", window_begin, window_end));
585 MTC_Slave::seekahead_distance () const
588 return session.frame_rate();
592 MTC_Slave::outside_window (framepos_t pos) const
594 return ((pos < window_begin) || (pos > window_end));