#include <poll.h>
#include <sys/types.h>
#include <unistd.h>
+
#include "pbd/error.h"
#include "pbd/enumwriter.h"
#include "pbd/failed_constructor.h"
using namespace std;
using namespace ARDOUR;
-using namespace sigc;
using namespace MIDI;
using namespace PBD;
+/* length (in timecode frames) of the "window" that we consider legal given receipt of
+ a given timecode position. Ardour will try to chase within this window, and will
+ stop+locate+wait+chase if timecode arrives outside of it. The window extends entirely
+ in the current direction of motion, so if any timecode arrives that is before the most
+ recently received position (and without the direction of timecode reversing too), we
+ will stop+locate+wait+chase.
+*/
+
+const int MTC_Slave::frame_tolerance = 2;
+
MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p)
: session (s)
{
can_notify_on_unknown_rate = true;
did_reset_tc_format = false;
+ reset_pending = 0;
+ reset_position = false;
+
+ pic = new PIChaser();
- pic = new PIController (1.0, 8);
-
last_mtc_fps_byte = session.get_mtc_timecode_bits ();
mtc_frame = 0;
speed_accumulator = new double[speed_accumulator_size];
rebind (p);
- reset ();
+ reset (true);
}
MTC_Slave::~MTC_Slave()
if (did_reset_tc_format) {
session.config.set_timecode_format (saved_tc_format);
}
+
delete pic;
delete [] speed_accumulator;
}
-bool
+bool
MTC_Slave::give_slave_full_control_over_transport_speed() const
{
return true; // for PiC control */
void
MTC_Slave::rebind (MIDI::Port& p)
{
- for (vector<sigc::connection>::iterator i = connections.begin(); i != connections.end(); ++i) {
- (*i).disconnect ();
- }
+ port_connections.drop_connections ();
port = &p;
- cerr << "Bind to port MTC messages\n";
-
- connections.push_back (port->input()->mtc_time.connect (mem_fun (*this, &MTC_Slave::update_mtc_time)));
- connections.push_back (port->input()->mtc_qtr.connect (mem_fun (*this, &MTC_Slave::update_mtc_qtr)));
- connections.push_back (port->input()->mtc_status.connect (mem_fun (*this, &MTC_Slave::update_mtc_status)));
+ 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_Slave::update_mtc_qtr (Parser& /*p*/, int which_qtr, nframes_t now)
+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));
+ maybe_reset ();
last_inbound_frame = now;
}
void
-MTC_Slave::update_mtc_time (const byte *msg, bool was_full, nframes_t now)
+MTC_Slave::update_mtc_time (const byte *msg, bool was_full, framepos_t now)
{
/* "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.
+ 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;
TimecodeFormat tc_format;
bool reset_tc = true;
- nframes64_t window_root = -1;
+ 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];
timecode.seconds = msg[1];
session.config.set_timecode_format (tc_format);
}
- DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC time timestamp = %1 TC %2 = frame %3 (from full message ? %4)\n",
+ 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));
if (was_full || outside_window (mtc_frame)) {
session.request_locate (mtc_frame, false);
session.request_transport_speed (0);
update_mtc_status (MIDI::MTC_Stopped);
- window_root = mtc_frame;
-
- reset ();
+ 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
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
+ 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.
*/
-
- mtc_frame += (long) (1.75 * session.frames_per_timecode_frame()) + session.worst_output_latency();
+
+ mtc_frame += (long) (1.75 * session.frames_per_timecode_frame()) + session.worst_playback_latency();
if (now) {
} else {
if (give_slave_full_control_over_transport_speed()) {
- /* PIC
- *
+ /* PIC
+ *
* its not the average, but we will assign it to current.speed below
*/
-
- average_speed = pic->get_ratio (session.audible_frame() - mtc_frame);
-
+
+ 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
+ /* Non-PiC
*/
- nframes64_t time_delta = (now - last_mtc_timestamp);
-
+ 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;
{
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;
and process() context (via ::speed_and_position())
*/
-
- DEBUG_TRACE (DEBUG::MTC, string_compose ("new MTC status %1\n", enum_2_string (status)));
switch (status) {
case MTC_Stopped:
current.guard1++;
current.guard2++;
break;
}
-
+
}
void
bool
MTC_Slave::locked () const
{
- return port->input()->mtc_locked();
+ return port->parser()->mtc_locked();
}
bool
}
bool
-MTC_Slave::speed_and_position (double& speed, nframes64_t& pos)
+MTC_Slave::speed_and_position (double& speed, framepos_t& pos)
{
- nframes64_t now = session.engine().frame_time();
+ framepos_t now = session.engine().frame_time();
SafeTime last;
- nframes_t elapsed;
+ framecnt_t elapsed;
+ bool in_control = false;
read_current (&last);
pos = last.position;
session.request_locate (pos, false);
session.request_transport_speed (0);
- update_mtc_status (MIDI::MTC_Stopped);
- reset();
- DEBUG_TRACE (DEBUG::MTC, "MTC not seen for 1/4 second - reset\n");
+ 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;
/* scale elapsed time by the current MTC speed */
if (last.timestamp && (now > last.timestamp)) {
- elapsed = (nframes_t) floor (last.speed * (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 {
/* now add the most recent timecode value plus the estimated elapsed interval */
- pos = elapsed + last.position;
+ 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::nframes_t
-MTC_Slave::resolution() const
+ARDOUR::framecnt_t
+MTC_Slave::resolution () const
{
- return (nframes_t) session.frames_per_timecode_frame();
+ return (framecnt_t) session.frames_per_timecode_frame();
}
void
-MTC_Slave::reset ()
+MTC_Slave::queue_reset (bool reset_pos)
{
- /* XXX massive thread safety issue here. MTC could
- be being updated as we call this. but this
- supposed to be a realtime-safe call.
- */
+ Glib::Mutex::Lock lm (reset_lock);
+ reset_pending++;
+ if (reset_pos) {
+ reset_position = true;
+ }
+}
- port->input()->reset_mtc_state ();
+void
+MTC_Slave::maybe_reset ()
+{
+ Glib::Mutex::Lock lm (reset_lock);
- last_inbound_frame = 0;
- current.guard1++;
- current.position = 0;
- current.timestamp = 0;
- current.speed = 0;
- current.guard2++;
+ 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;
have_first_speed_accumulator = false;
speed_accumulator_cnt = 0;
- pic->out_of_bounds();
+ pic->reset();
}
void
-MTC_Slave::reset_window (nframes64_t root)
+MTC_Slave::reset_window (framepos_t root)
{
- window_begin = root;
- if (session.slave_state() == Session::Running) {
- window_end = root + (session.frames_per_timecode_frame() * 2);
- } else {
- window_end = root + seekahead_distance ();
+ /* 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;
}
DEBUG_TRACE (DEBUG::MTC, string_compose ("legal MTC window now %1 .. %2\n", window_begin, window_end));
}
-nframes64_t
+ARDOUR::framecnt_t
MTC_Slave::seekahead_distance () const
{
/* 1 second */
}
bool
-MTC_Slave::outside_window (nframes64_t pos) const
+MTC_Slave::outside_window (framepos_t pos) const
{
return ((pos < window_begin) || (pos > window_end));
}
projects / ardour.git / blobdiff