X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmtc_slave.cc;h=cf308f98749a17a783747e3ffeb467bb8c0bf239;hb=7d96960b162d25da87c388a3083775e8770bba56;hp=3447a92ce4bc9bcc53115cd381fadc2653fdafe3;hpb=99904735e066804358f1d0bd138a84f1e9ecda91;p=ardour.git

diff --git a/libs/ardour/mtc_slave.cc b/libs/ardour/mtc_slave.cc
index 3447a92ce4..cf308f9874 100644
--- a/libs/ardour/mtc_slave.cc
+++ b/libs/ardour/mtc_slave.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2002-4 Paul Davis 
+    Copyright (C) 2002-4 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -16,32 +16,55 @@
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
 */
-
+#include <iostream>
 #include <errno.h>
 #include <poll.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <pbd/error.h>
-#include <pbd/failed_constructor.h>
-#include <pbd/pthread_utils.h>
 
-#include <midi++/port.h>
-#include <ardour/slave.h>
-#include <ardour/session.h>
-#include <ardour/audioengine.h>
-#include <ardour/cycles.h>
+#include "pbd/error.h"
+#include "pbd/stacktrace.h"
+#include "pbd/enumwriter.h"
+#include "pbd/failed_constructor.h"
+#include "pbd/pthread_utils.h"
+
+#include "midi++/port.h"
+#include "ardour/debug.h"
+#include "ardour/slave.h"
+#include "ardour/session.h"
+#include "ardour/audioengine.h"
+#include "ardour/pi_controller.h"
 
 #include "i18n.h"
 
+using namespace std;
 using namespace ARDOUR;
-using namespace sigc;
 using namespace MIDI;
 using namespace PBD;
 
-MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p) 
+/* length (in timecode frames) of the "window" that we consider legal given receipt of
+   a given timecode position. Ardour will try to chase within this window, and will
+   stop+locate+wait+chase if timecode arrives outside of it. The window extends entirely
+   in the current direction of motion, so if any timecode arrives that is before the most
+   recently received position (and without the direction of timecode reversing too), we
+   will stop+locate+wait+chase.
+*/
+
+const int MTC_Slave::frame_tolerance = 2;
+
+MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p)
 	: session (s)
 {
 	can_notify_on_unknown_rate = true;
+	did_reset_tc_format = false;
+
+	pic = new PIChaser();
+	
+	last_mtc_fps_byte = session.get_mtc_timecode_bits ();
+	mtc_frame = 0;
+
+	speed_accumulator_size = 16;
+	speed_accumulator = new double[speed_accumulator_size];
 
 	rebind (p);
 	reset ();
@@ -49,187 +72,313 @@ MTC_Slave::MTC_Slave (Session& s, MIDI::Port& p)
 
 MTC_Slave::~MTC_Slave()
 {
+	if (did_reset_tc_format) {
+		session.config.set_timecode_format (saved_tc_format);
+	}
+
+	delete pic;
+	delete [] speed_accumulator;
+}
+
+bool 
+MTC_Slave::give_slave_full_control_over_transport_speed() const
+{
+	// return true; // for PiC control */
+	return false; // for Session-level computed varispeed
 }
 
 void
 MTC_Slave::rebind (MIDI::Port& p)
 {
-	for (vector<sigc::connection>::iterator i = connections.begin(); i != connections.end(); ++i) {
-		(*i).disconnect ();
-	}
-
+	port_connections.drop_connections ();
+	
 	port = &p;
-
-	connections.push_back (port->input()->mtc_time.connect (mem_fun (*this, &MTC_Slave::update_mtc_time)));
-	connections.push_back (port->input()->mtc_qtr.connect (mem_fun (*this, &MTC_Slave::update_mtc_qtr)));
-	connections.push_back (port->input()->mtc_status.connect (mem_fun (*this, &MTC_Slave::update_mtc_status)));
+	
+	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));
 }
 
 void
-MTC_Slave::update_mtc_qtr (Parser& p)
+MTC_Slave::update_mtc_qtr (Parser& /*p*/, int which_qtr, nframes_t now)
 {
-	cycles_t cnow = get_cycles ();
-	nframes_t now = session.engine().frame_time();
-	nframes_t qtr;
-	static cycles_t last_qtr = 0;
-
-	qtr = (long) (session.frames_per_smpte_frame() / 4);
-	mtc_frame += qtr;
-	last_qtr = cnow;
-
-	current.guard1++;
-	current.position = mtc_frame;
-	current.timestamp = now;
-	current.guard2++;
+	maybe_reset ();
 
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("qtr frame %1 at %2\n", which_qtr, now));
 	last_inbound_frame = now;
 }
 
 void
-MTC_Slave::update_mtc_time (const byte *msg, bool was_full)
+MTC_Slave::update_mtc_time (const byte *msg, bool was_full, nframes_t now)
 {
-	nframes_t now = session.engine().frame_time();
-	SMPTE::Time smpte;
+	/* "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
+	   a locate command via MMC.
+	*/
+
+	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;
+
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("full mtc time known at %1, full ? %2\n", now, was_full));
 	
-	smpte.hours = msg[3];
-	smpte.minutes = msg[2];
-	smpte.seconds = msg[1];
-	smpte.frames = msg[0];
+	timecode.hours = msg[3];
+	timecode.minutes = msg[2];
+	timecode.seconds = msg[1];
+	timecode.frames = msg[0];
+
+	last_mtc_fps_byte = msg[4];
 
 	switch (msg[4]) {
 	case MTC_24_FPS:
-		smpte.rate = 24;
-		smpte.drop = false;
+		timecode.rate = 24;
+		timecode.drop = false;
+		tc_format = timecode_24;
 		can_notify_on_unknown_rate = true;
 		break;
 	case MTC_25_FPS:
-		smpte.rate = 25;
-		smpte.drop = false;
+		timecode.rate = 25;
+		timecode.drop = false;
+		tc_format = timecode_25;
 		can_notify_on_unknown_rate = true;
 		break;
 	case MTC_30_FPS_DROP:
-		smpte.rate = 30;
-		smpte.drop = true;
+		timecode.rate = 30;
+		timecode.drop = true;
+		tc_format = timecode_30drop;
 		can_notify_on_unknown_rate = true;
 		break;
 	case MTC_30_FPS:
-		smpte.rate = 30;
-		smpte.drop = false;
+		timecode.rate = 30;
+		timecode.drop = false;
 		can_notify_on_unknown_rate = true;
+		tc_format = timecode_30;
 		break;
 	default:
 		/* throttle error messages about unknown MTC rates */
 		if (can_notify_on_unknown_rate) {
-			error << _("Unknown rate/drop value in incoming MTC stream, session values used instead") << endmsg;
+			error << string_compose (_("Unknown rate/drop value %1 in incoming MTC stream, session values used instead"),
+						 (int) msg[4])
+			      << endmsg;
 			can_notify_on_unknown_rate = false;
 		}
-		smpte.rate = session.smpte_frames_per_second();
-		smpte.drop = session.smpte_drop_frames();
+		timecode.rate = session.timecode_frames_per_second();
+		timecode.drop = session.timecode_drop_frames();
+		reset_tc = false;
+	}
+
+	if (reset_tc) {
+		if (!did_reset_tc_format) {
+			saved_tc_format = session.config.get_timecode_format();
+			did_reset_tc_format = true;
+		}
+		session.config.set_timecode_format (tc_format);
 	}
 
-	session.smpte_to_sample (smpte, mtc_frame, true, false);
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC time timestamp = %1 TC %2 = frame %3 (from full message ? %4)\n", 
+						 now, timecode, mtc_frame, was_full));
 	
-	if (was_full) {
-		
-		current.guard1++; 	 
-		current.position = mtc_frame; 	 
-		current.timestamp = 0; 	 
-		current.guard2++; 	 
-		
-		session.request_locate (mtc_frame, false); 	 
-		update_mtc_status (MIDI::Parser::MTC_Stopped); 	 
+	if (was_full || outside_window (mtc_frame)) {
+
+		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_window (mtc_frame);
+		reset ();
 
- 		reset ();
-		
 	} else {
+			
+		/* we've had the first set of 8 qtr frame messages, determine position
+		   and allow continuing qtr frame messages to provide position
+		   and speed information.
+		*/
+		
+		/* do a careful conversion of the timecode value to a position
+		   so that we take drop/nondrop and all that nonsense into 
+		   consideration.
+		*/
+
+		session.timecode_to_sample (timecode, mtc_frame, true, false);
 		
 		/* We received the last quarter frame 7 quarter frames (1.75 mtc
 		   frames) after the instance when the contents of the mtc quarter
 		   frames were decided. Add time to compensate for the elapsed 1.75
-		   frames.
-		   Also compensate for audio latency. 
+		   frames. Also compensate for audio latency.
 		*/
-
-		mtc_frame += (long) (1.75 * session.frames_per_smpte_frame()) + session.worst_output_latency();
 		
-		if (first_mtc_frame == 0) {
-			first_mtc_frame = mtc_frame;
-			first_mtc_time = now;
-		} 
-		
-		current.guard1++;
-		current.position = mtc_frame;
-		current.timestamp = now;
-		current.guard2++;
+		mtc_frame += (long) (1.75 * session.frames_per_timecode_frame()) + session.worst_output_latency();
+
+
+		if (now) {
+
+			if (last_mtc_timestamp == 0) {
+
+				last_mtc_timestamp = now;
+				last_mtc_frame = mtc_frame;
+
+			} else {
+
+				if (give_slave_full_control_over_transport_speed()) {
+					/* PIC 
+					 * 
+					 * 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; 
+
+				    if ((now - last_seen_timestamp) < 300) {
+					mtc_frame = (mtc_frame + last_seen_position)/2;
+				    }
+
+				    last_seen_timestamp = now;
+				    last_seen_position = mtc_frame;
+
+					
+					
+				} else {
+
+					/* Non-PiC 
+					 */
+
+					nframes64_t time_delta = (now - last_mtc_timestamp);
+					
+					if (time_delta != 0) {
+						double apparent_speed = (mtc_frame - last_mtc_frame) / (double) (time_delta);
+						
+						process_apparent_speed (apparent_speed);
+						DEBUG_TRACE (DEBUG::Slave, string_compose ("apparent speed was %1 average is now %2\n", apparent_speed, average_speed));
+					} else {
+						DEBUG_TRACE (DEBUG::Slave, string_compose ("no apparent calc, average is %1\n", average_speed));
+					}
+					
+					/* every second, recalibrate the starting point for the speed measurement */
+					if (mtc_frame - last_mtc_frame > session.frame_rate()) {
+						last_mtc_timestamp = now;
+						last_mtc_frame = mtc_frame;
+					}
+				}
+			}
+
+			current.guard1++;
+			current.position = mtc_frame;
+			current.timestamp = now;
+			current.speed = average_speed;
+			current.guard2++;
+			window_root = mtc_frame;
+		}
+	}
+
+	if (now) {
+		last_inbound_frame = now;
+	}
+
+	if (window_root >= 0) {
+		DEBUG_TRACE (DEBUG::MTC, string_compose ("window root reset to %1\n", window_root));
+		reset_window (window_root);
+	}
+}
+
+void
+MTC_Slave::process_apparent_speed (double this_speed)
+{
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("speed cnt %1 sz %2 have %3\n", speed_accumulator_cnt, speed_accumulator_size, have_first_speed_accumulator));
+
+	/* clamp to an expected range */
+
+	if (this_speed > 4.0 || this_speed < -4.0) {
+		this_speed = average_speed;
+	}
+
+	if (speed_accumulator_cnt >= speed_accumulator_size) {
+		have_first_speed_accumulator = true;
+		speed_accumulator_cnt = 0;
+	}
+
+	speed_accumulator[speed_accumulator_cnt++] = this_speed;
+
+	if (have_first_speed_accumulator) {
+		average_speed = 0.0;
+		for (size_t i = 0; i < speed_accumulator_size; ++i) {
+			average_speed += speed_accumulator[i];
+		}
+		average_speed /= speed_accumulator_size;
 	}
-	
-	last_inbound_frame = now;
 }
 
 void
 MTC_Slave::handle_locate (const MIDI::byte* mmc_tc)
 {
-	MIDI::byte mtc[4];
-	
+	MIDI::byte mtc[5];
+
+	mtc[4] = last_mtc_fps_byte;
 	mtc[3] = mmc_tc[0] & 0xf; /* hrs only */
 	mtc[2] = mmc_tc[1];
 	mtc[1] = mmc_tc[2];
 	mtc[0] = mmc_tc[3];
 
-	update_mtc_time (mtc, true);
+	update_mtc_time (mtc, true, 0);
 }
 
 void
-MTC_Slave::update_mtc_status (MIDI::Parser::MTC_Status status)
+MTC_Slave::update_mtc_status (MIDI::MTC_Status status)
 {
+	/* XXX !!! thread safety ... called from MIDI I/O context
+	   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:
-		mtc_speed = 0.0f;
-		mtc_frame = 0;
-
 		current.guard1++;
 		current.position = mtc_frame;
 		current.timestamp = 0;
+		current.speed = 0;
 		current.guard2++;
 
 		break;
 
 	case MTC_Forward:
-		mtc_speed = 0.0f;
-		mtc_frame = 0;
-
 		current.guard1++;
 		current.position = mtc_frame;
 		current.timestamp = 0;
+		current.speed = 0;
 		current.guard2++;
-
 		break;
 
 	case MTC_Backward:
-		mtc_speed = 0.0f;
-		mtc_frame = 0;
-
 		current.guard1++;
 		current.position = mtc_frame;
 		current.timestamp = 0;
+		current.speed = 0;
 		current.guard2++;
-
 		break;
 	}
+	
 }
 
 void
 MTC_Slave::read_current (SafeTime *st) const
 {
 	int tries = 0;
+
 	do {
 		if (tries == 10) {
 			error << _("MTC Slave: atomic read of current time failed, sleeping!") << endmsg;
 			usleep (20);
 			tries = 0;
 		}
-
 		*st = current;
 		tries++;
 
@@ -248,70 +397,66 @@ MTC_Slave::ok() const
 	return true;
 }
 
-bool 
-MTC_Slave::speed_and_position (float& speed, nframes_t& pos)
+bool
+MTC_Slave::speed_and_position (double& speed, nframes64_t& pos)
 {
-	nframes_t now = session.engine().frame_time();
+	nframes64_t now = session.engine().frame_time();
 	SafeTime last;
-	nframes_t frame_rate;
 	nframes_t elapsed;
-	float speed_now;
 
 	read_current (&last);
 
-	if (first_mtc_time == 0) {
+	if (last.timestamp == 0) {
 		speed = 0;
 		pos = last.position;
+		DEBUG_TRACE (DEBUG::MTC, string_compose ("first call to MTC_Slave::speed_and_position, pos = %1\n", last.position));
 		return true;
 	}
-	
+
 	/* no timecode for 1/4 second ? conclude that its stopped */
 
 	if (last_inbound_frame && now > last_inbound_frame && now - last_inbound_frame > session.frame_rate() / 4) {
-		mtc_speed = 0;
+		speed = 0;
 		pos = last.position;
 		session.request_locate (pos, false);
-		update_mtc_status (MIDI::Parser::MTC_Stopped);
-		reset();
+		session.request_transport_speed (0);
+		queue_reset ();
+		DEBUG_TRACE (DEBUG::MTC, "MTC not seen for 1/4 second - reset pending\n");
 		return false;
 	}
 
-	frame_rate = session.frame_rate();
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position %1 %2\n", last.speed, last.position));
 
-	speed_now = (float) ((last.position - first_mtc_frame) / (double) (now - first_mtc_time));
+	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;
 
-	accumulator[accumulator_index++] = speed_now;
+	    average_speed = pic->get_ratio (last.timestamp, last.position, slave_pos, in_control );
+	    pic_want_locate = pic->want_locate();
 
-	if (accumulator_index >= accumulator_size) {
-		have_first_accumulated_speed = true;
-		accumulator_index = 0;
+	    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 (have_first_accumulated_speed) {
-		float total = 0;
-
-		for (int32_t i = 0; i < accumulator_size; ++i) {
-			total += accumulator[i];
-		}
-
-		mtc_speed = total / accumulator_size;
-
-	} else {
-
-		mtc_speed = speed_now;
-
-	}
-
-	if (mtc_speed == 0.0f) {
+	if (last.speed == 0.0f) {
 
 		elapsed = 0;
 
 	} else {
-	
+
 		/* scale elapsed time by the current MTC speed */
-		
+
 		if (last.timestamp && (now > last.timestamp)) {
-			elapsed = (nframes_t) floor (mtc_speed * (now - last.timestamp));
+			elapsed = (nframes_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 {
 			elapsed = 0; /* XXX is this right? */
 		}
@@ -319,37 +464,127 @@ MTC_Slave::speed_and_position (float& speed, nframes_t& pos)
 
 	/* now add the most recent timecode value plus the estimated elapsed interval */
 
-	pos =  elapsed + last.position;
+	pos = last.position + elapsed; 
+	speed = last.speed;
+
+	DEBUG_TRACE (DEBUG::MTC, string_compose ("MTC::speed_and_position FINAL %1 %2\n", last.speed, pos));
 
-	speed = mtc_speed;
 	return true;
 }
 
 ARDOUR::nframes_t
 MTC_Slave::resolution() const
 {
-	return (nframes_t) session.frames_per_smpte_frame();
+	return (nframes_t) session.frames_per_timecode_frame();
+}
+
+void
+MTC_Slave::queue_reset ()
+{
+	Glib::Mutex::Lock lm (reset_lock);
+	reset_pending++;
+}
+
+void
+MTC_Slave::maybe_reset ()
+{
+	reset_lock.lock ();
+
+	if (reset_pending) {
+		DEBUG_TRACE (DEBUG::MTC, "actually reset\n");
+		reset ();
+		reset_pending = 0;
+	} 
+
+	reset_lock.unlock ();
 }
 
 void
 MTC_Slave::reset ()
 {
-	/* XXX massive thread safety issue here. MTC could
-	   be being updated as we call this. but this
-	   supposed to be a realtime-safe call.
-	*/
-	
 	port->input()->reset_mtc_state ();
-	
+
 	last_inbound_frame = 0;
 	current.guard1++;
 	current.position = 0;
 	current.timestamp = 0;
+	current.speed = 0;
 	current.guard2++;
-	first_mtc_frame = 0;
-	first_mtc_time = 0;
 
-	accumulator_index = 0;
-	have_first_accumulated_speed = false;
-	mtc_speed = 0;
+	window_begin = 0;
+	window_end = 0;
+	last_mtc_frame = 0;
+	last_mtc_timestamp = 0;
+
+	average_speed = 0;
+	have_first_speed_accumulator = false;
+	speed_accumulator_cnt = 0;
+
+	pic->reset();
+}
+
+void
+MTC_Slave::reset_window (nframes64_t root)
+{
+	
+	/* if we're waiting for the master to catch us after seeking ahead, keep the window
+	   of acceptable MTC frames wide open. otherwise, shrink it down to just 2 video frames
+	   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())));
+	PBD::stacktrace (cerr, 35);
+
+	switch (port->input()->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);
+		} else {
+			window_end = root + seekahead_distance ();
+		}
+		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;
+			if (root > d) {
+				window_begin = root - d;
+				window_end = root;
+			} else {
+				window_begin = 0;
+			}
+		} else {
+			nframes_t d = seekahead_distance ();
+			if (root > d) {
+				window_begin = root - d;
+			} else {
+				window_begin = 0;
+			}
+		}
+		window_end = root;
+		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
+MTC_Slave::seekahead_distance () const
+{
+	/* 1 second */
+	return session.frame_rate();
+}
+
+bool
+MTC_Slave::outside_window (nframes64_t pos) const
+{
+	return ((pos < window_begin) || (pos > window_end));
 }