X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fardour%2Fsession_export.cc;h=879f34020af63004387fe0314a118004c9e54fc7;hb=3d366053e2719ca0f129c16575ce481fcd214f61;hp=840c752badcb3e4ba8228edbc29c446fcd77b902;hpb=f450df300c9c057141a4caf79ff6dbfbf58492d9;p=ardour.git diff --git a/libs/ardour/session_export.cc b/libs/ardour/session_export.cc index 840c752bad..879f34020a 100644 --- a/libs/ardour/session_export.cc +++ b/libs/ardour/session_export.cc @@ -19,20 +19,19 @@ #include "pbd/error.h" -#include +#include + +#include -#include "ardour/audio_diskstream.h" #include "ardour/audioengine.h" #include "ardour/butler.h" -#include "ardour/export_failed.h" -#include "ardour/export_file_io.h" #include "ardour/export_handler.h" #include "ardour/export_status.h" -#include "ardour/export_utilities.h" -#include "ardour/route.h" +#include "ardour/process_thread.h" #include "ardour/session.h" +#include "ardour/track.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; @@ -64,8 +63,6 @@ Session::pre_export () { get_export_status (); // Init export_status - _butler->wait_until_finished (); - /* take everyone out of awrite to avoid disasters */ { @@ -76,41 +73,75 @@ 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 (); - post_export_position = _transport_frame; + post_export_position = _transport_sample; config.set_external_sync (false); _exporting = true; - export_status->running = true; - export_status->Aborting.connect_same_thread (*this, boost::bind (&Session::stop_audio_export, this)); + export_status->set_running (true); export_status->Finished.connect_same_thread (*this, boost::bind (&Session::finalize_audio_export, this)); + /* disable MMC output early */ + + _pre_export_mmc_enabled = _mmc->send_enabled (); + _mmc->enable_send (false); + return 0; } +/** Called for each range that is being exported */ int -Session::start_audio_export (nframes_t position, bool realtime) +Session::start_audio_export (samplepos_t position, bool realtime, bool region_export) { if (!_exporting) { pre_export (); } + _realtime_export = realtime; + _region_export = region_export; + + if (region_export) { + _export_preroll = 0; + } + else if (realtime) { + _export_preroll = nominal_sample_rate (); + } else { + _export_preroll = Config->get_export_preroll() * nominal_sample_rate (); + } + + if (_export_preroll == 0) { + // must be > 0 so that transport is started in sync. + _export_preroll = 1; + } + + /* 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 + it here. + */ + + _butler->wait_until_finished (); + /* get everyone to the right position */ { - boost::shared_ptr dsl = diskstreams.reader(); + boost::shared_ptr rl = routes.reader(); - for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { - if ((*i)-> seek (position, true)) { + for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { + boost::shared_ptr tr = boost::dynamic_pointer_cast (*i); + if (tr && tr->seek (position, true)) { error << string_compose (_("%1: cannot seek to %2 for export"), (*i)->name(), position) << endmsg; @@ -120,13 +151,17 @@ Session::start_audio_export (nframes_t position, bool realtime) } /* we just did the core part of a locate() call above, but - for the sake of any GUI, put the _transport_frame in + for the sake of any GUI, put the _transport_sample in the right place too. */ - _transport_frame = position; + _transport_sample = position; - _exporting_realtime = realtime; + if (!region_export) { + _remaining_latency_preroll = worst_latency_preroll (); + } else { + _remaining_latency_preroll = 0; + } export_status->stop = false; /* get transport ready. note how this is calling butler functions @@ -135,112 +170,165 @@ Session::start_audio_export (nframes_t position, bool realtime) since then has re-awakened it. */ - set_transport_speed (1.0, false); - butler_transport_work (); - g_atomic_int_set (&_butler->should_do_transport_work, 0); - post_transport (); - /* we are ready to go ... */ if (!_engine.connected()) { return -1; } - if (realtime) { - last_process_function = process_function; - process_function = &Session::process_export; + _engine.Freewheel.connect_same_thread (export_freewheel_connection, boost::bind (&Session::process_export_fw, this, _1)); + + if (_realtime_export) { + Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); + _export_rolling = true; + process_function = &Session::process_export_fw; + return 0; } else { - _engine.Freewheel.connect_same_thread (export_freewheel_connection, boost::bind (&Session::process_export_fw, this, _1)); + _export_rolling = true; return _engine.freewheel (true); } - - return 0; } void -Session::process_export (nframes_t nframes) +Session::process_export (pframes_t nframes) { - try { - - if (export_status->stop) { - stop_audio_export (); - return; - } + if (_export_rolling && export_status->stop) { + stop_audio_export (); + } - if (!_exporting_realtime) { - /* make sure we've caught up with disk i/o, since - we're running faster than realtime c/o JACK. - */ + /* for Region Raw or Fades, we can skip this + * RegionExportChannelFactory::update_buffers() does not care + * about anything done here + */ + if (!_region_export) { + if (_export_rolling) { + 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 (); + } - _butler->wait_until_finished (); - } + /* do the usual stuff */ - /* do the usual stuff */ + process_without_events (nframes); - process_without_events (nframes); + } else if (_realtime_export) { + fail_roll (nframes); // somehow we need to silence _ALL_ output buffers + } + } + try { /* handle export - XXX what about error handling? */ ProcessExport (nframes); - } catch (ExportFailed e) { + } catch (std::exception & e) { + error << string_compose (_("Export ended unexpectedly: %1"), e.what()) << endmsg; export_status->abort (true); } } -int -Session::process_export_fw (nframes_t nframes) +void +Session::process_export_fw (pframes_t nframes) { + 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 ((samplepos_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; + } + + if (_remaining_latency_preroll > 0) { + samplepos_t remain = std::min ((samplepos_t)nframes, _remaining_latency_preroll); + + if (need_buffers) { + _engine.main_thread()->get_buffers (); + } + + process_without_events (remain); + + if (need_buffers) { + _engine.main_thread()->drop_buffers (); + } + + _remaining_latency_preroll -= remain; + _transport_sample -= remain; + nframes -= remain; + + if (nframes == 0) { + return; + } + _engine.split_cycle (remain); + } + + if (need_buffers) { + _engine.main_thread()->get_buffers (); + } process_export (nframes); - return 0; + if (need_buffers) { + _engine.main_thread()->drop_buffers (); + } + + return; } int Session::stop_audio_export () { - if (_exporting_realtime) { - process_function = last_process_function; - } else { - export_freewheel_connection.disconnect(); - } - /* can't use stop_transport() here because we need an immediate halt and don't require all the declick stuff that stop_transport() implements. */ realtime_stop (true, true); + _export_rolling = false; _butler->schedule_transport_work (); - if (!export_status->aborted()) { - ExportReadFinished (); - } else { - finalize_audio_export (); - } - return 0; - } void Session::finalize_audio_export () { _exporting = false; - export_status->running = false; - if (!_exporting_realtime) { - _engine.freewheel (false); - _exporting_realtime = false; + if (_export_rolling) { + stop_audio_export (); } /* Clean up */ - /* BOOST SIGNAL are these necessary? - ProcessExport.clear(); - ExportReadFinished.clear(); - */ - + 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); + + /* maybe write CUE/TOC */ + export_handler.reset(); export_status.reset(); @@ -249,6 +337,6 @@ Session::finalize_audio_export () if (post_export_sync) { config.set_external_sync (true); } else { - locate (post_export_position, false, false, false); + locate (post_export_position, false, false, false, false, false); } }