#include <unistd.h>
#include "pbd/error.h"
-#include "pbd/stacktrace.h"
#include "pbd/enumwriter.h"
#include "pbd/failed_constructor.h"
#include "pbd/pthread_utils.h"
{
can_notify_on_unknown_rate = true;
did_reset_tc_format = false;
+ reset_pending = 0;
+ reset_position = false;
pic = new PIChaser();
speed_accumulator = new double[speed_accumulator_size];
rebind (p);
- reset ();
+ reset (true);
}
MTC_Slave::~MTC_Slave()
bool
MTC_Slave::give_slave_full_control_over_transport_speed() const
{
- // return true; // for PiC control */
- return false; // for Session-level computed varispeed
+ return true; // for PiC control */
+ // return false; // for Session-level computed varispeed
}
void
port = &p;
- port->input()->mtc_time.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_time, this, _1, _2, _3));
- port->input()->mtc_qtr.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_qtr, this, _1, _2, _3));
- port->input()->mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1));
+ 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 ("update MTC qtr does a reset, qtr = %1 now = %2\n", which_qtr, now));
- maybe_reset ();
-
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. example: when we received
*/
if (now) {
- DEBUG_TRACE (DEBUG::MTC, string_compose ("update MTC time does a reset, was full ? %1 now = %2\n", was_full, 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));
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 ("reset MTC status to stopped, outside MTC window (%1 .. %2 vs. %3)\n",
- window_begin, window_end, mtc_frame));
update_mtc_status (MIDI::MTC_Stopped);
- DEBUG_TRACE (DEBUG::MTC, string_compose ("outside, so window root reset to %1\n", mtc_frame));
- reset ();
+ reset (false);
reset_window (mtc_frame);
} else {
* its not the average, but we will assign it to current.speed below
*/
- static nframes64_t last_seen_timestamp = 0;
- static nframes64_t last_seen_position = 0;
+ 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;
/* 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);
}
if (window_root >= 0) {
- DEBUG_TRACE (DEBUG::MTC, string_compose ("window root reset to %1\n", window_root));
reset_window (window_root);
}
}
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++;
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);
- queue_reset ();
+ 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()) {
- bool in_control = (session.slave_state() == Session::Running);
- nframes64_t pic_want_locate = 0;
- //nframes64_t slave_pos = session.audible_frame();
- nframes64_t slave_pos = session.transport_frame();
- static double average_speed = 0;
-
- average_speed = pic->get_ratio (last.timestamp, last.position, slave_pos, in_control );
- 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;
- }
+ 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) {
/* 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 = last.position + elapsed;
+ 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::queue_reset ()
+MTC_Slave::queue_reset (bool reset_pos)
{
- DEBUG_TRACE (DEBUG::MTC, "queue reset of MTC slave state\n");
- PBD::stacktrace (cerr, 35);
Glib::Mutex::Lock lm (reset_lock);
reset_pending++;
+ if (reset_pos) {
+ reset_position = true;
+ }
}
void
MTC_Slave::maybe_reset ()
{
- reset_lock.lock ();
+ Glib::Mutex::Lock lm (reset_lock);
if (reset_pending) {
- DEBUG_TRACE (DEBUG::MTC, "actually reset\n");
- reset ();
+ reset (reset_position);
reset_pending = 0;
+ reset_position = false;
}
-
- reset_lock.unlock ();
}
void
-MTC_Slave::reset ()
+MTC_Slave::reset (bool with_position)
{
- DEBUG_TRACE (DEBUG::MTC, "*****************\n\n\n MTC SLAVE reset ********************\n\n\n");
- PBD::stacktrace (cerr, 35);
- port->input()->reset_mtc_state ();
-
- last_inbound_frame = 0;
- current.guard1++;
- current.position = 0;
- current.timestamp = 0;
- current.speed = 0;
- current.guard2++;
+ 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;
}
void
-MTC_Slave::reset_window (nframes64_t root)
+MTC_Slave::reset_window (framepos_t root)
{
/* if we're waiting for the master to catch us after seeking ahead, keep the window
ahead of the window root (taking direction into account).
*/
- DEBUG_TRACE (DEBUG::MTC, string_compose ("trying to reset MTC window with state = %1\n", enum_2_string (port->input()->mtc_running())));
-
- switch (port->input()->mtc_running()) {
+ switch (port->parser()->mtc_running()) {
case MTC_Forward:
- DEBUG_TRACE (DEBUG::MTC, "set MTC window while running forward\n");
window_begin = root;
if (session.slave_state() == Session::Running) {
window_end = root + (session.frames_per_timecode_frame() * frame_tolerance);
break;
case MTC_Backward:
- DEBUG_TRACE (DEBUG::MTC, "set MTC window while running backward\n");
if (session.slave_state() == Session::Running) {
- nframes_t d = session.frames_per_timecode_frame() * frame_tolerance;
+ framecnt_t const d = session.frames_per_timecode_frame() * frame_tolerance;
if (root > d) {
window_begin = root - d;
window_end = root;
window_begin = 0;
}
} else {
- nframes_t d = seekahead_distance ();
+ framecnt_t const d = seekahead_distance ();
if (root > d) {
window_begin = root - d;
} else {
break;
default:
- DEBUG_TRACE (DEBUG::MTC, "not touching MTC window - MTC_Stopped\n");
/* 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