X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fardour%2Fsession_export.cc;h=463f50441121fc1e5d090c9b6ac6092f69341cde;hb=c8c6bca6587450ff64303dbc994a4cd28d6ce7aa;hp=890871696517c7986622ef77212208df0ab08272;hpb=1ec78d26ee7cd5a612a7f98f9977dbb8ef46a593;p=ardour.git

diff --git a/libs/ardour/session_export.cc b/libs/ardour/session_export.cc
index 8908716965..463f504411 100644
--- a/libs/ardour/session_export.cc
+++ b/libs/ardour/session_export.cc
@@ -31,7 +31,7 @@
 #include "ardour/session.h"
 #include "ardour/track.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace std;
 using namespace ARDOUR;
@@ -73,12 +73,16 @@ Session::pre_export ()
 		}
 	}
 
-	/* make sure we are actually rolling */
+	/* prepare transport */
+
+	realtime_stop (true, true);
 
 	if (get_record_enabled()) {
 		disable_record (false);
 	}
 
+	unset_play_loop ();
+
 	/* no slaving */
 
 	post_export_sync = config.get_external_sync ();
@@ -100,12 +104,35 @@ Session::pre_export ()
 
 /** Called for each range that is being exported */
 int
-Session::start_audio_export (framepos_t position)
+Session::start_audio_export (framepos_t position, bool realtime)
 {
 	if (!_exporting) {
 		pre_export ();
 	}
-	_export_started = false;
+
+	_realtime_export = realtime;
+
+	if (realtime) {
+		_export_preroll = nominal_frame_rate ();
+	} else {
+		_export_preroll = Config->get_export_preroll() * nominal_frame_rate ();
+	}
+
+	if (_export_preroll == 0) {
+		// must be > 0 so that transport is started in sync.
+		_export_preroll = 1;
+	}
+
+	/* "worst_track_latency" is the correct value for stem-exports
+	 * see to Route::add_export_point(),
+	 *
+	 * for master-bus export, we'd need to add the master's latency.
+	 * or actually longest-total-session-latency.
+	 *
+	 * We can't use worst_playback_latency because that includes
+	 * includes external latencies and would overcompensate.
+	 */
+	_export_latency = worst_track_latency ();
 
 	/* We're about to call Track::seek, so the butler must have finished everything
 	   up otherwise it could be doing do_refill in its thread while we are doing
@@ -151,11 +178,19 @@ Session::start_audio_export (framepos_t position)
 	}
 
 	_engine.Freewheel.connect_same_thread (export_freewheel_connection, boost::bind (&Session::process_export_fw, this, _1));
-	_export_rolling = true;
-	return _engine.freewheel (true);
+
+	if (_realtime_export) {
+		Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+		_export_rolling = true;
+		process_function = &Session::process_export_fw;
+		return 0;
+	} else {
+		_export_rolling = true;
+		return _engine.freewheel (true);
+	}
 }
 
-int
+void
 Session::process_export (pframes_t nframes)
 {
 	if (_export_rolling && export_status->stop) {
@@ -163,14 +198,18 @@ Session::process_export (pframes_t nframes)
 	}
 
 	if (_export_rolling) {
-		/* make sure we've caught up with disk i/o, since
-		we're running faster than realtime c/o JACK.
-		*/
-		_butler->wait_until_finished ();
+		if (!_realtime_export)  {
+			/* make sure we've caught up with disk i/o, since
+			 * we're running faster than realtime c/o JACK.
+			 */
+			_butler->wait_until_finished ();
+		}
 
 		/* do the usual stuff */
 
 		process_without_events (nframes);
+	} else if (_realtime_export) {
+		fail_roll (nframes); // somehow we need to silence _ALL_ output buffers
 	}
 
 	try {
@@ -181,29 +220,66 @@ Session::process_export (pframes_t nframes)
 	} catch (std::exception & e) {
 		error << string_compose (_("Export ended unexpectedly: %1"), e.what()) << endmsg;
 		export_status->abort (true);
-		return -1;
 	}
-
-	return 0;
 }
 
-int
+void
 Session::process_export_fw (pframes_t nframes)
 {
-	if (!_export_started) {
-		_export_started = true;
+	const bool need_buffers = _engine.freewheeling ();
+	if (_export_preroll > 0) {
+
+		if (need_buffers) {
+			_engine.main_thread()->get_buffers ();
+		}
+		fail_roll (nframes);
+		if (need_buffers) {
+			_engine.main_thread()->drop_buffers ();
+		}
+
+		_export_preroll -= std::min ((framepos_t)nframes, _export_preroll);
+
+		if (_export_preroll > 0) {
+			// clear out buffers (reverb tails etc).
+			return;
+		}
+
 		set_transport_speed (1.0, 0, false);
 		butler_transport_work ();
 		g_atomic_int_set (&_butler->should_do_transport_work, 0);
 		post_transport ();
-		return 0;
+
+		return;
+	}
+
+	if (_export_latency > 0) {
+		framepos_t remain = std::min ((framepos_t)nframes, _export_latency);
+
+		if (need_buffers) {
+			_engine.main_thread()->get_buffers ();
+		}
+		process_without_events (remain);
+		if (need_buffers) {
+			_engine.main_thread()->drop_buffers ();
+		}
+
+		_export_latency -= remain;
+		nframes -= remain;
+
+		if (nframes == 0) {
+			return;
+		}
 	}
 
-        _engine.main_thread()->get_buffers ();
+	if (need_buffers) {
+		_engine.main_thread()->get_buffers ();
+	}
 	process_export (nframes);
-        _engine.main_thread()->drop_buffers ();
+	if (need_buffers) {
+		_engine.main_thread()->drop_buffers ();
+	}
 
-	return 0;
+	return;
 }
 
 int
@@ -232,8 +308,11 @@ Session::finalize_audio_export ()
 
 	/* Clean up */
 
+	if (_realtime_export) {
+		Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+		process_function = &Session::process_with_events;
+	}
 	_engine.freewheel (false);
-
 	export_freewheel_connection.disconnect();
 
 	_mmc->enable_send (_pre_export_mmc_enabled);