*/
#include <iostream>
#include <errno.h>
-#include <poll.h>
#include <sys/types.h>
#include <unistd.h>
#include "pbd/error.h"
+#include "pbd/pthread_utils.h"
#include "ardour/debug.h"
+#include "ardour/profile.h"
#include "ardour/slave.h"
#include "ardour/session.h"
#include "ardour/audioengine.h"
#include "ardour/audio_port.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
LTC_Slave::LTC_Slave (Session& s)
: session (s)
{
- frames_per_ltc_frame = session.frames_per_timecode_frame();
+ frames_per_ltc_frame = session.samples_per_timecode_frame();
timecode.rate = session.timecode_frames_per_second();
timecode.drop = session.timecode_drop_frames();
delayedlocked = 10;
monotonic_cnt = 0;
fps_detected=false;
+ sync_lock_broken = false;
ltc_timecode = session.config.get_timecode_format();
a3e_timecode = session.config.get_timecode_format();
{
DEBUG_TRACE (DEBUG::LTC, "LTC resync_xrun()\n");
engine_dll_initstate = 0;
+ sync_lock_broken = false;
}
void
{
DEBUG_TRACE (DEBUG::LTC, "LTC resync_latency()\n");
engine_dll_initstate = 0;
+ sync_lock_broken = false;
if (!session.deletion_in_progress() && session.ltc_output_io()) { /* check if Port exits */
boost::shared_ptr<Port> ltcport = session.ltc_input_port();
}
void
-LTC_Slave::reset()
+LTC_Slave::reset (bool with_ts)
{
DEBUG_TRACE (DEBUG::LTC, "LTC reset()\n");
- last_timestamp = 0;
- current_delta = 0;
+ if (with_ts) {
+ last_timestamp = 0;
+ current_delta = 0;
+ }
transport_direction = 0;
ltc_speed = 0;
engine_dll_initstate = 0;
+ sync_lock_broken = false;
+
+ ActiveChanged (false); /* EMIT SIGNAL */
}
void
-LTC_Slave::parse_ltc(const pframes_t nframes, const Sample* const in, const framecnt_t posinfo)
+LTC_Slave::parse_ltc(const ARDOUR::pframes_t nframes, const Sample* const in, const ARDOUR::framecnt_t posinfo)
{
pframes_t i;
unsigned char sound[8192];
ltc_frame_increment(&frame.ltc, fps_i, tv_standard, 0);
ltc_frame_to_time(&stime, &frame.ltc, 0);
transport_direction = 1;
- frame.off_start -= ltc_frame_alignment(session.frames_per_timecode_frame(), tv_standard);
- frame.off_end -= ltc_frame_alignment(session.frames_per_timecode_frame(), tv_standard);
+ frame.off_start -= ltc_frame_alignment(session.samples_per_timecode_frame(), tv_standard);
+ frame.off_end -= ltc_frame_alignment(session.samples_per_timecode_frame(), tv_standard);
} else {
ltc_frame_decrement(&frame.ltc, fps_i, tv_standard, 0);
int off = frame.off_end - frame.off_start;
- frame.off_start += off - ltc_frame_alignment(session.frames_per_timecode_frame(), tv_standard);
- frame.off_end += off - ltc_frame_alignment(session.frames_per_timecode_frame(), tv_standard);
+ frame.off_start += off - ltc_frame_alignment(session.samples_per_timecode_frame(), tv_standard);
+ frame.off_end += off - ltc_frame_alignment(session.samples_per_timecode_frame(), tv_standard);
transport_direction = -1;
}
timecode_negative_offset, timecode_offset
);
+ ltc_frame += ltc_slave_latency.max + session.worst_playback_latency();
+
framepos_t cur_timestamp = frame.off_end + 1;
DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC F: %1 LF: %2 N: %3 L: %4\n", ltc_frame, last_ltc_frame, cur_timestamp, last_timestamp));
if (frame.off_end + 1 <= last_timestamp || last_timestamp == 0) {
frameoffset_t skip = now - (monotonic_cnt + nframes);
monotonic_cnt = now;
- DEBUG_TRACE (DEBUG::LTC, string_compose ("speed_and_position - TID:%1 | latency: %2 | skip %3\n", ::pthread_self(), ltc_slave_latency.max, skip));
+ DEBUG_TRACE (DEBUG::LTC, string_compose ("speed_and_position - TID:%1 | latency: %2 | skip %3\n", pthread_name(), ltc_slave_latency.max, skip));
if (last_timestamp == 0) {
engine_dll_initstate = 0;
- delayedlocked++;
- }
- else if (engine_dll_initstate != transport_direction && ltc_speed != 0) {
+ if (delayedlocked < 10) ++delayedlocked;
+ } else if (engine_dll_initstate != transport_direction && ltc_speed != 0) {
+
+ ActiveChanged (true); /* EMIT SIGNAL */
+
engine_dll_initstate = transport_direction;
init_engine_dll(last_ltc_frame + rint(ltc_speed * double(2 * nframes + now - last_timestamp)),
session.engine().samples_per_cycle());
DEBUG_TRACE (DEBUG::LTC, string_compose("engine skipped %1 frames. Feeding silence to LTC parser.\n", skip));
if (skip >= 8192) skip = 8192;
unsigned char sound[8192];
- memset(sound, 0, sizeof(char) * skip);
+ memset(sound, 0x80, sizeof(char) * skip);
ltc_decoder_write(decoder, sound, nframes, now);
} else if (skip != 0) {
/* this should never happen. it may if monotonic_cnt, now overflow on 64bit */
reset();
}
- parse_ltc(nframes, in, now - ltc_slave_latency.max );
+ parse_ltc(nframes, in, now);
process_ltc(now);
}
pos = session.transport_frame();
return true;
} else if (ltc_speed != 0) {
- delayedlocked = 0;
+ if (delayedlocked > 1) delayedlocked--;
+ else if (current_delta == 0) delayedlocked = 0;
}
if (abs(now - last_timestamp) > FLYWHEEL_TIMEOUT) {
reset();
speed = 0;
pos = session.transport_frame();
+ ActiveChanged (false); /* EMIT SIGNAL */
return true;
}
if (((pos < 0) || (labs(current_delta) > 2 * session.frame_rate()))) {
DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC large drift: %1\n", current_delta));
- reset();
+ reset(false);
speed = 0;
- pos = session.transport_frame();
return true;
}
speed = 1.0;
}
+ if (speed != 0 && delayedlocked == 0 && fabs(speed) != 1.0) {
+ sync_lock_broken = true;
+ DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC speed not locked %1 %2\n", speed, ltc_speed));
+ }
+
return true;
}
} else if ((monotonic_cnt - last_timestamp) > 2 * frames_per_ltc_frame) {
snprintf(delta, sizeof(delta), "%s", _("flywheel"));
} else {
- 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));
+ snprintf(delta, sizeof(delta), "\u0394<span foreground=\"%s\" face=\"monospace\" >%s%s%lld</span>sm",
+ sync_lock_broken ? "red" : "green",
+ LEADINGZERO(::llabs(current_delta)), PLUSMINUS(-current_delta), ::llabs(current_delta));
}
return std::string(delta);
}
projects / ardour.git / blobdiff