LTC_Slave::parameter_changed (std::string const & p)
{
if (p == "slave-timecode-offset"
- || p == "subframes-per-frame"
|| p == "timecode-format"
) {
parse_timecode_offset();
if (!session.deletion_in_progress() && session.ltc_output_io()) { /* check if Port exits */
boost::shared_ptr<Port> ltcport = session.ltc_input_port();
- ltcport->get_connected_latency_range(ltc_slave_latency, false);
+ ltcport->get_connected_latency_range (ltc_slave_latency, false);
}
}
}
void
-LTC_Slave::parse_ltc(const jack_nframes_t nframes, const jack_default_audio_sample_t * const in, const framecnt_t posinfo)
+LTC_Slave::parse_ltc(const pframes_t nframes, const Sample* const in, const framecnt_t posinfo)
{
- jack_nframes_t i;
+ pframes_t i;
unsigned char sound[8192];
if (nframes > 8192) {
/* TODO warn once or wrap, loop conversion below
}
if (frame->reverse) {
- ltc_frame_decrement(&prev_frame.ltc, fps , 0);
+ ltc_frame_decrement(&prev_frame.ltc, fps, LTC_TV_525_60, 0);
} else {
- ltc_frame_increment(&prev_frame.ltc, fps , 0);
+ ltc_frame_increment(&prev_frame.ltc, fps, LTC_TV_525_60, 0);
}
if (!equal_ltc_frame_time(&prev_frame.ltc, &frame->ltc)) {
discontinuity_detected = true;
}
void
-LTC_Slave::process_ltc(framepos_t const now)
+LTC_Slave::process_ltc(framepos_t const /*now*/)
{
LTCFrameExt frame;
+ enum LTC_TV_STANDARD tv_standard = LTC_TV_625_50;
while (ltc_decoder_read(decoder, &frame)) {
SMPTETimecode stime;
* is expected to start at the end of the current frame
*/
int fps_i = ceil(timecode.rate);
+
+ switch(fps_i) {
+ case 30:
+ if (timecode.drop) {
+ tv_standard = LTC_TV_525_60;
+ } else {
+ tv_standard = LTC_TV_1125_60;
+ }
+ break;
+ case 25:
+ tv_standard = LTC_TV_625_50;
+ break;
+ default:
+ tv_standard = LTC_TV_FILM_24; /* == LTC_TV_1125_60 == no offset, 24,30fps BGF */
+ break;
+ }
+
if (!frame.reverse) {
- ltc_frame_increment(&frame.ltc, fps_i , 0);
+ 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);
} else {
- ltc_frame_decrement(&frame.ltc, fps_i , 0);
+ ltc_frame_decrement(&frame.ltc, fps_i, tv_standard, 0);
int off = frame.off_end - frame.off_start;
- frame.off_start += off;
- frame.off_end += off;
+ 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);
transport_direction = -1;
}
}
/* main entry point from session_process.cc
- * called from jack_process callback context
- * so it is OK to use jack_port_get_buffer()
+ * called from process callback context
+ * so it is OK to use get_buffer()
*/
bool
LTC_Slave::speed_and_position (double& speed, framepos_t& pos)
{
bool engine_init_called = false;
- 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
- framecnt_t nframes = session.engine().frames_per_cycle();
+ framecnt_t nframes = session.engine().samples_per_cycle();
- jack_default_audio_sample_t *in;
+ Sample* in;
boost::shared_ptr<Port> ltcport = session.ltc_input_port();
- in = (jack_default_audio_sample_t*) jack_port_get_buffer (ltcport->jack_port(), nframes);
+ in = (Sample*) AudioEngine::instance()->port_engine().get_buffer (ltcport->port_handle(), nframes);
frameoffset_t skip = now - (monotonic_cnt + nframes);
monotonic_cnt = now;
else if (engine_dll_initstate != transport_direction && ltc_speed != 0) {
engine_dll_initstate = transport_direction;
init_engine_dll(last_ltc_frame + rint(ltc_speed * double(2 * nframes + now - last_timestamp)),
- session.engine().frames_per_cycle());
+ session.engine().samples_per_cycle());
engine_init_called = true;
}
t0 = t1;
t1 += b * e + e2;
e2 += c * e;
- speed_flt = (t1 - t0) / double(session.engine().frames_per_cycle());
- DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC engine DLL t0:%1 t1:%2 err:%3 spd:%4 ddt:%5\n", t0, t1, e, speed_flt, e2 - session.engine().frames_per_cycle() ));
+ speed_flt = (t1 - t0) / double(session.engine().samples_per_cycle());
+ DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC engine DLL t0:%1 t1:%2 err:%3 spd:%4 ddt:%5\n", t0, t1, e, speed_flt, e2 - session.engine().samples_per_cycle() ));
} else {
DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC adjusting elapsed (no DLL) from %1 by %2\n", elapsed, (2 * nframes * ltc_speed)));
speed_flt = 0;
LTC_Slave::approximate_current_position() const
{
if (last_timestamp == 0) {
- return " \u2012\u2012:\u2012\u2012:\u2012\u2012:\u2012\u2012";
+ return " --:--:--:--";
}
return Timecode::timecode_format_time(timecode);
}
if (last_timestamp == 0 || engine_dll_initstate == 0) {
snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012");
} else if ((monotonic_cnt - last_timestamp) > 2 * frames_per_ltc_frame) {
- snprintf(delta, sizeof(delta), _("flywheel"));
+ snprintf(delta, sizeof(delta), "%s", _("flywheel"));
} else {
- snprintf(delta, sizeof(delta), "\u0394<span foreground=\"green\" face=\"monospace\" >%s%s%" PRIi64 "</span> sm",
+ 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