LTC slave reworked

* detect LTC framerate
* detect LTC discontinuities
* use a DLL for flywheel sync (engine rate)
* don't use seekahead - internal resync

git-svn-id: svn://localhost/ardour2/branches/3.0@13291 d708f5d6-7413-0410-9779-e7cbd77b26cf

1 files changed, 236 insertions, 48 deletions

diff --git a/libs/ardour/ltc_slave.cc b/libs/ardour/ltc_slave.cc
index 52c49737e0..7ff3aa1659 100644
--- a/libs/ardour/ltc_slave.cc
+++ b/libs/ardour/ltc_slave.cc
@@ -39,25 +39,30 @@ using namespace MIDI;
 using namespace PBD;
 using namespace Timecode;
 
+#define FLYWHEEL_TIMEOUT ( 3 * session.frame_rate() )
+
 LTC_Slave::LTC_Slave (Session& s)
 	: session (s)
 {
-	frames_per_ltc_frame = session.frames_per_timecode_frame();
+	frames_per_ltc_frame = session.frames_per_timecode_frame(); // XXX at most 30fps ?
 	timecode.rate = session.timecode_frames_per_second();
 	timecode.drop  = session.timecode_drop_frames();
 
-	printf("LTC initial rate: %f %f\n", timecode.rate, frames_per_ltc_frame);
-
 	ltc_transport_pos = 0;
-	ltc_speed = 1.0;
-	last_timestamp = 0;
-	ltc_detect_fps_cnt = ltc_detect_fps_max = 0;
+	did_reset_tc_format = false;
+	delayedlocked = 10;
+	engine_dll_initstate = 0;
+	monotonic_cnt = 0;
+
+	memset(&prev_ltc_frame, 0, sizeof(LTCFrame));
 
 	ltc_timecode = timecode_60; // track changes of LTC timecode
 	a3e_timecode = timecode_60; // track canges of Ardour's timecode
 	printed_timecode_warning = false;
 
 	decoder = ltc_decoder_create((int) frames_per_ltc_frame, 128 /*queue size*/);
+	reset();
+	//session.engine().Xrun.connect_same_thread (*this, boost::bind (&LTC_Slave::reset, this));
 }
 
 LTC_Slave::~LTC_Slave()
@@ -85,13 +90,13 @@ LTC_Slave::resolution () const
 ARDOUR::framecnt_t
 LTC_Slave::seekahead_distance () const
 {
-	return (framecnt_t) (frames_per_ltc_frame * 2);
+	return 0;
 }
 
 bool
 LTC_Slave::locked () const
 {
-	return true; // TODO check if >2 sequential LTC frames have been received
+	return (delayedlocked < 5);
 }
 
 bool
@@ -100,6 +105,19 @@ LTC_Slave::ok() const
 	return true;
 }
 
+void
+LTC_Slave::reset()
+{
+	DEBUG_TRACE (DEBUG::LTC, "LTC reset()\n");
+	frames_in_sequence = 0;
+	ltc_detect_fps_cnt = ltc_detect_fps_max = 0;
+	last_timestamp = 0;
+	current_delta = 0;
+	transport_direction = 0;
+	ltc_speed = 0;
+	ltc_decoder_queue_flush(decoder);
+}
+
 int
 LTC_Slave::parse_ltc(const jack_nframes_t nframes, const jack_default_audio_sample_t * const in, const framecnt_t posinfo)
 {
@@ -115,7 +133,7 @@ LTC_Slave::parse_ltc(const jack_nframes_t nframes, const jack_default_audio_samp
 	return 0;
 }
 
-void
+bool
 LTC_Slave::detect_ltc_fps(int frameno, bool df)
 {
 	double detected_fps = 0;
@@ -151,7 +169,7 @@ LTC_Slave::detect_ltc_fps(int frameno, bool df)
 		frames_per_ltc_frame = double(session.frame_rate()) / timecode.rate;
 		DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC reset to FPS: %1%2 ; audio-frames per LTC: %3\n",
 				detected_fps, df?"df":"ndf", frames_per_ltc_frame));
-		last_timestamp = 0; // re-init
+		return true; // reset()
 	}
 
 	/* poll and check session TC */
@@ -187,23 +205,57 @@ LTC_Slave::detect_ltc_fps(int frameno, bool df)
 		ltc_timecode = tc_format;
 		a3e_timecode = cur_timecode;
 	}
+	return false;
+}
 
+bool
+LTC_Slave::detect_ltc_discontinuity(LTCFrameExt *frame) {
+	bool discontinuity_detected = false;
+	/* detect discontinuities */
+	if (frame->reverse) {
+		ltc_frame_decrement(&prev_ltc_frame, ceil(timecode.rate), 0);
+	} else {
+		ltc_frame_increment(&prev_ltc_frame, ceil(timecode.rate), 0);
+	}
+
+	if (memcmp(&prev_ltc_frame, &frame->ltc, sizeof(LTCFrame))) {
+		discontinuity_detected = true;
+	}
+	memcpy(&prev_ltc_frame, &frame->ltc, sizeof(LTCFrame));
+
+	/* notfify about discontinuities */
+	if (frames_in_sequence > 0 && discontinuity_detected) {
+		fprintf(stdout, "# LTC DISCONTINUITY\n");
+		frames_in_sequence=0;
+		return true;
+	}
+	frames_in_sequence++;
+
+	return false;
 }
 
 bool
-LTC_Slave::process_ltc(framepos_t now, framecnt_t nframes)
+LTC_Slave::process_ltc(framepos_t const now, framepos_t const sess_pos, framecnt_t const nframes)
 {
 	bool have_frame = false;
-
-	framepos_t sess_pos = session.transport_frame(); // corresponds to now
-	//sess_pos -= session.engine().frames_since_cycle_start();
-
 	DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC Process eng-tme: %1 eng-pos: %2\n", now, sess_pos));
 
 	LTCFrameExt frame;
 	while (ltc_decoder_read(decoder,&frame)) {
+		bool reinitialize_ltc_dll = false;
 		SMPTETimecode stime;
+
 		ltc_frame_to_time(&stime, &frame.ltc, 0);
+		timecode.negative  = false;
+		timecode.subframes  = 0;
+		/* set timecode.rate and timecode.drop: */
+		if (detect_ltc_fps(stime.frame, (frame.ltc.dfbit)? true : false)) {
+			reset();
+			break;
+		}
+		if (detect_ltc_discontinuity(&frame)) {
+			ltc_discontinuity = true;
+		}
 
 #if 0 // Devel/Debug
 		fprintf(stdout, "LTC %02d:%02d:%02d%c%02d | %8lld %8lld%s\n",
@@ -216,12 +268,16 @@ LTC_Slave::process_ltc(framepos_t now, framecnt_t nframes)
 			frame.off_end,
 			frame.reverse ? " R" : "  "
 			);
-#endif
 
-		timecode.negative  = false;
-		timecode.subframes  = 0;
-		/* set timecode.rate and timecode.drop: */
-		detect_ltc_fps(stime.frame, (frame.ltc.dfbit)? true : false);
+		if (frames_in_sequence < 1) {
+			fprintf(stdout, " ####### FIRST LTC FRAME in SEQ #######\n");
+			continue;
+		}
+
+		if (ltc_discontinuity) {
+			fprintf(stdout, " ####### LTC DISCONTINUITY #######\n");
+		}
+#endif
 
 		/* when a full LTC frame is decoded, the timecode the LTC frame
 		 * is referring has just passed.
@@ -244,45 +300,95 @@ LTC_Slave::process_ltc(framepos_t now, framecnt_t nframes)
 		timecode.seconds = stime.secs;
 		timecode.frames  = stime.frame;
 
-		framepos_t ltc_frame;
+		/* map LTC timecode to session TC setting */
+		framepos_t ltc_frame; ///< audio-frame corresponding to LTC frame
 		Timecode::timecode_to_sample (timecode, ltc_frame, true, false,
 			double(session.frame_rate()),
 			session.config.get_subframes_per_frame(),
 			session.config.get_timecode_offset_negative(), session.config.get_timecode_offset()
 			);
 
-		double poff = (frame.off_end - now);
-
+		/* (frame.off_end + 1) = start of next LTC frame */
+		double poff = (frame.off_end + 1 - now);
 		ltc_transport_pos = ltc_frame - poff;
-		frames_per_ltc_frame = (double(session.frame_rate()) / timecode.rate);
-		//frames_per_ltc_frame = frame.off_end - frame.off_start; // the first one is off.
 
-		DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC frame: %1 poff: %2 pos :%3\n", ltc_frame, poff, ltc_transport_pos));
+#if 0 // vari-speed LTC, no DLL
+			frames_per_ltc_frame = 1 + frame.off_end - frame.off_start;
+#else
+			frames_per_ltc_frame = (double(session.frame_rate()) / timecode.rate);
+#endif
 
-		if (last_timestamp == 0 || ((now - last_timestamp) > 4 * frames_per_ltc_frame) ) {
-			init_ltc_dll(ltc_frame, frames_per_ltc_frame);
-			ltc_speed = 1.0; // XXX
-		} else {
+		DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC frame: %1 poff: %2 pos: %3\n", ltc_frame, poff, ltc_transport_pos));
 
-			double e = (double(ltc_frame) - poff - double(sess_pos));
+		if (ltc_discontinuity) {
+			ltc_discontinuity=false;
+			if (ltc_speed==0
+					|| !locked()
+					|| (ltc_transport_pos - sess_pos) > FLYWHEEL_TIMEOUT)
+			{
+				engine_dll_initstate = 0;
+				reset();
+			}
+			reinitialize_ltc_dll = true;
+		}
+
+		if (last_timestamp == 0
+			|| ((now - last_timestamp) > FLYWHEEL_TIMEOUT)
+			|| (abs(current_delta) >  FLYWHEEL_TIMEOUT) // TODO LTC-delta not engine delta
+			|| (frame.reverse && transport_direction != -1)
+			|| (!frame.reverse && transport_direction != 1)
+			) {
+			reinitialize_ltc_dll = true;
+			engine_dll_initstate = 0;
+			reset();
+		}
+
+		if (reinitialize_ltc_dll) {
+			init_ltc_dll(ltc_transport_pos, frames_per_ltc_frame);
+
+			if (ltc_speed==0 || !locked()) {
+				if (frame.reverse) {
+					transport_direction = -1;
+					ltc_transport_pos -= nframes * rint((2 * frames_per_ltc_frame + poff)/nframes);
+				} else {
+					transport_direction = 1;
+					ltc_transport_pos += nframes * rint((2 * frames_per_ltc_frame + poff)/nframes);
+				}
+			}
+
+		} else {
 			// update DLL
+			double e = (double(ltc_frame) - poff - double(sess_pos));
 			t0 = t1;
 			t1 += b * e + e2;
 			e2 += c * e;
 
 			ltc_speed = (t1 - t0) / frames_per_ltc_frame;
+			current_delta = (ltc_transport_pos - sess_pos);
 			DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC DLL t0:%1 t1:%2 err:%3 spd:%4 ddt:%5\n", t0, t1, e, ltc_speed, e2 - frames_per_ltc_frame));
 
 		}
+
+		/* the are equivalent
+		 * TODO: choose the value with larger diff ->
+		 * minimize roundig errors when extrapolating
+		 */
+#if 1
 		last_timestamp = now;
+		last_ltc_frame = ltc_transport_pos;
+#else
+		last_timestamp = frame.off_end + 1;
 		last_ltc_frame = ltc_frame;
+#endif
+
 		have_frame = true;
-	}
+	} /* end foreach decoded LTC frame */
+
 	return have_frame;
 }
 
 void
-LTC_Slave::init_ltc_dll(framepos_t tme, double dt)
+LTC_Slave::init_ltc_dll(framepos_t const tme, double const dt)
 {
 	omega = 2.0 * M_PI * dt / double(session.frame_rate());
 	b = 1.4142135623730950488 * omega;
@@ -294,6 +400,26 @@ LTC_Slave::init_ltc_dll(framepos_t tme, double dt)
 	DEBUG_TRACE (DEBUG::LTC, string_compose ("[re-]init LTC DLL %1 %2 %3\n", t0, t1, e2));
 }
 
+void
+LTC_Slave::init_engine_dll (framepos_t pos, framepos_t inc)
+{
+	/* the bandwidth of the DLL is a trade-off,
+	 * because the max-speed of the transport in ardour is
+	 * limited to +-8.0, a larger bandwidth would cause oscillations
+	 *
+	 * But this is only really a problem if the user performs manual
+	 * seeks while transport is running and slaved to LTC.
+	 */
+	oe = 2.0 * M_PI * double(inc/2.0) / double(session.frame_rate());
+	be = 1.4142135623730950488 * oe;
+	ce = oe * oe;
+
+	ee2 = double(transport_direction * inc);
+	te0 = double(pos);
+	te1 = te0 + ee2;
+	DEBUG_TRACE (DEBUG::LTC, string_compose ("[re-]init Engine DLL %1 %2 %3\n", te0, te1, ee2));
+}
+
 /* main entry point from session_process.cc
  * called from jack_process callback context
  * so it is OK to use jack_port_get_buffer() etc
@@ -301,39 +427,87 @@ LTC_Slave::init_ltc_dll(framepos_t tme, double dt)
 bool
 LTC_Slave::speed_and_position (double& speed, framepos_t& pos)
 {
-
-	framepos_t now = session.engine().frame_time_at_cycle_start();
+	//framepos_t now = session.engine().frame_time_at_cycle_start();
+	//framepos_t now = session.engine().processed_frames();
+	framepos_t now = monotonic_cnt;
+	framepos_t sess_pos = session.transport_frame(); // corresponds to now
 	framecnt_t nframes = session.engine().frames_per_cycle();
 	jack_default_audio_sample_t *in;
 	jack_latency_range_t ltc_latency;
 
+	monotonic_cnt += nframes;
+
 	boost::shared_ptr<Port> ltcport = session.engine().ltc_input_port();
 	ltcport->get_connected_latency_range(ltc_latency, false);
 	in = (jack_default_audio_sample_t*) jack_port_get_buffer (ltcport->jack_port(), nframes);
 
 	DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC_Slave::speed_and_position - TID:%1 | latency: %2\n", ::pthread_self(), ltc_latency.max));
 
+	if (last_timestamp == 0) {
+		engine_dll_initstate = 0;
+		delayedlocked++;
+	}
+	else if (engine_dll_initstate != transport_direction) {
+		engine_dll_initstate = transport_direction;
+		init_engine_dll(last_ltc_frame, session.engine().frames_per_cycle());
+	}
+
 	if (in) {
 		parse_ltc(nframes, in, now  + ltc_latency.max );
-		if (!process_ltc(now, nframes)) {
-			/* fly wheel */
-			double elapsed = (now - last_timestamp) * ltc_speed;
-			ltc_transport_pos = last_ltc_frame + elapsed;
-			DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC fly wheel elapsed: %1 @speed %2\n", elapsed, ltc_speed));
+		if (!process_ltc(now, sess_pos, nframes) && ltc_speed != 0) {
 		}
 	}
 
-	if (((now - last_timestamp) > 4 * frames_per_ltc_frame) ) {
+	/* interpolate position according to speed and time since last LTC-frame*/
+	double speed_flt = ltc_speed;
+	framecnt_t elapsed;
+	if (speed_flt == 0.0f) {
+		elapsed = 0;
+	} else {
+		/* scale elapsed time by the current LTC speed */
+		if (last_timestamp && (now > last_timestamp)) {
+			elapsed = (now - last_timestamp) * speed_flt;
+		} else {
+			elapsed = 0;
+		}
+		/* update engine DLL and calculate speed */
+		const double e = double (last_ltc_frame + elapsed - sess_pos);
+		te0 = te1;
+		te1 += be * e + ee2;
+		ee2 += ce * e;
+		speed_flt = (te1 - te0) / 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", te0, te1, e, speed_flt, ee2 - session.engine().frames_per_cycle() ));
+	}
+
+	pos = last_ltc_frame + elapsed;
+	speed = speed_flt;
+	current_delta = (pos - sess_pos);
+
+	DEBUG_TRACE (DEBUG::LTC, string_compose ("LTCsync spd: %1 pos: %2 | last-pos: %3 elapsed: %4 delta: %5\n",
+						 speed, pos, last_ltc_frame, elapsed, current_delta));
+
+	if (last_timestamp != 0 /* && frames_in_sequence > 8*/) {
+		delayedlocked = 0;
+	}
+
+	if (last_timestamp == 0 || ((now - last_timestamp) > FLYWHEEL_TIMEOUT)) {
 		DEBUG_TRACE (DEBUG::LTC, "LTC no-signal - reset\n");
-		speed = ltc_speed = 0;
+		reset();
+		engine_dll_initstate = 0;
+		speed = 0;
 		pos = session.transport_frame();
-		last_timestamp = 0;
-		ltc_detect_fps_cnt = ltc_detect_fps_max = 0;
 		return true;
 	}
 
-	pos = ltc_transport_pos;
-	speed = ltc_speed;
+	if (last_timestamp != 0  && ltc_speed != 0 && ((ltc_transport_pos < 0) || (labs(current_delta) > 10 * session.frame_rate()))) {
+		DEBUG_TRACE (DEBUG::LTC, string_compose ("LTC large drift. %1\n", current_delta));
+		// XXX only re-init engine DLL ?
+		reset();
+		engine_dll_initstate = 0;
+		speed = 0;
+		pos = session.transport_frame();
+		return true;
+	}
 
 	return true;
 }
@@ -358,11 +532,25 @@ LTC_Slave::apparent_timecode_format () const
 	return session.config.get_timecode_format();
 }
 
-std::string 
+std::string
 LTC_Slave::approximate_current_position() const
 {
 	if (last_timestamp == 0) {
-		return "--:--:--:--";
+		return " --:--:--:--";
 	}
 	return Timecode::timecode_format_time(timecode);
 }
+
+std::string
+LTC_Slave::approximate_current_delta() const
+{
+	char delta[24];
+	if (last_timestamp == 0 || frames_in_sequence < 3) {
+		snprintf(delta, sizeof(delta), "---");
+	} else {
+		// TODO if current_delta > 1 frame -> display timecode.
+		// delta >0 if A3's transport is _behind_ LTC
+		snprintf(delta, sizeof(delta), "%+4" PRIi64 " sm", current_delta);
+	}
+	return std::string(delta);
+}