reset_pending = 0;
reset_position = false;
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 ();
quarter_frame_duration = (double(session.frames_per_timecode_frame()) / 4.0);
- mtc_timecode = timecode_60; // track changes of MTC timecode
- a3e_timecode = timecode_60; // track canges of Ardour's timecode
+ mtc_timecode = session.config.get_timecode_format();
+ a3e_timecode = session.config.get_timecode_format();
printed_timecode_warning = false;
+ session.config.ParameterChanged.connect_same_thread (config_connection, boost::bind (&MTC_Slave::parameter_changed, this, _1));
+ parse_timecode_offset();
reset (true);
rebind (p);
}
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,
port->parser()->mtc_status.connect_same_thread (port_connections, boost::bind (&MTC_Slave::update_mtc_status, this, _1));
}
+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
{
bool
MTC_Slave::locked () const
{
- return port->parser()->mtc_locked();
+ return port->parser()->mtc_locked() && last_inbound_frame !=0 && engine_dll_initstate !=0;
}
bool
void
MTC_Slave::init_mtc_dll(framepos_t tme, double qtr)
{
- omega = 2.0 * M_PI * qtr / double(session.frame_rate());
+ omega = 2.0 * M_PI * qtr / 2.0 / double(session.frame_rate());
b = 1.4142135623730950488 * omega;
c = omega * omega;
{
busy_guard1++;
const double qtr_d = quarter_frame_duration;
- const framepos_t qtr = rint(qtr_d);
- mtc_frame += qtr * transport_direction;
+ 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));
- framepos_t ts = 0;
double mtc_speed = 0;
if (first_mtc_timestamp != 0) {
/* update MTC DLL and calculate speed */
- const double e = double(transport_direction) * (double(now) - double(current.timestamp) - qtr_d);
+ 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;
- ts = now;
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 = ts;
- current.speed = mtc_speed;
- current.guard2++;
+ 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++;
}
can_notify_on_unknown_rate = true;
break;
case MTC_30_FPS_DROP:
- timecode.rate = (30000.0/1001.0);
+ 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_2997drop;
can_notify_on_unknown_rate = true;
break;
case MTC_30_FPS:
did_reset_tc_format = true;
}
if (cur_timecode != 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;
+ 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 {
if (a3e_timecode != cur_timecode) printed_timecode_warning = false;
if (cur_timecode != tc_format && ! printed_timecode_warning) {
- warning << string_compose(_("Session and MTC framerate mismatch: MTC:%1 Ardour:%2."),
- Timecode::timecode_format_name(tc_format),
- Timecode::timecode_format_name(cur_timecode))
- << endmsg;
+ 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;
}
}
Timecode::timecode_to_sample (timecode, mtc_frame, true, false,
double(session.frame_rate()),
session.config.get_subframes_per_frame(),
- session.config.get_timecode_offset_negative(), session.config.get_timecode_offset()
+ 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",
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;
* 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/6.0) / double(session.frame_rate());
+ oe = 2.0 * M_PI * double(inc) / 2.0 / double(session.frame_rate());
be = 1.4142135623730950488 * oe;
ce = oe * oe;
bool
MTC_Slave::speed_and_position (double& speed, framepos_t& pos)
{
- framepos_t now = session.engine().frame_time_at_cycle_start();
+ 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;
+ frameoffset_t elapsed;
+ bool engine_dll_reinitialized = false;
read_current (&last);
/* 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) {
+ else if (engine_dll_initstate != transport_direction && last.speed != 0) {
engine_dll_initstate = transport_direction;
- init_engine_dll(last.position, session.engine().frames_per_cycle());
+ init_engine_dll(last.position, session.engine().samples_per_cycle());
+ engine_dll_reinitialized = true;
}
if (last.timestamp == 0) {
}
-
- DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position mtc-tme: %1 mtc-pos: %2\n", last.timestamp, last.position));
+ 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));
double speed_flt = last.speed; ///< MTC speed from MTC-quarter-frame DLL
else
{
/* scale elapsed time by the current MTC speed */
- if (last.timestamp && (now > last.timestamp)) {
- elapsed = (framecnt_t) rint (speed_flt * (now - last.timestamp));
- } else {
- elapsed = 0;
- }
- if (give_slave_full_control_over_transport_speed()) {
- /* there is a frame-delta engine vs MTC position
- * mostly due to quantization and rounding of (speed * nframes)
- * thus we use an other DLL..
+ 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 */
te0 = te1;
te1 += be * e + ee2;
ee2 += ce * e;
- speed_flt = (te1 - te0) / double(session.engine().frames_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().frames_per_cycle() ));
+ 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() ));
}
}
queue_reset (false);
}
-#if 0
- /* provide a 1% deadzone to lock the speed */
- if (fabs(speed - 1.0) <= 0.01)
+ /* provide a .1% deadzone to lock the speed */
+ if (fabs(speed - 1.0) <= 0.001)
speed = 1.0;
-#endif
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));
return mtc_timecode;
}
-std::string
+std::string
MTC_Slave::approximate_current_position() const
{
SafeTime last;
std::string
MTC_Slave::approximate_current_delta() const
{
- char delta[24];
+ char delta[80];
SafeTime last;
read_current (&last);
if (last.timestamp == 0 || reset_pending) {
snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012");
} else {
- // TODO if current_delta > 1 frame -> display timecode.
- snprintf(delta, sizeof(delta), "%s%4" PRIi64 " sm",
- PLUSMINUS(-current_delta), abs(current_delta));
+ snprintf(delta, sizeof(delta), "\u0394<span foreground=\"green\" face=\"monospace\" >%s%s%" PRIi64 "</span>sm",
+ LEADINGZERO(abs(current_delta)), PLUSMINUS(-current_delta), abs(current_delta));
}
return std::string(delta);
}
projects / ardour.git / blobdiff