libs/ardour/session_export.cc

   1 /*
   2     Copyright (C) 1999-2008 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20
  21 #include "pbd/error.h"
  22 #include <glibmm/threads.h>
  23
  24 #include <midi++/mmc.h>
  25
  26 #include "ardour/audioengine.h"
  27 #include "ardour/butler.h"
  28 #include "ardour/export_handler.h"
  29 #include "ardour/export_status.h"
  30 #include "ardour/process_thread.h"
  31 #include "ardour/session.h"
  32 #include "ardour/track.h"
  33
  34 #include "pbd/i18n.h"
  35
  36 using namespace std;
  37 using namespace ARDOUR;
  38 using namespace PBD;
  39
  40 boost::shared_ptr<ExportHandler>
  41 Session::get_export_handler ()
  42 {
  43         if (!export_handler) {
  44                 export_handler.reset (new ExportHandler (*this));
  45         }
  46
  47         return export_handler;
  48 }
  49
  50 boost::shared_ptr<ExportStatus>
  51 Session::get_export_status ()
  52 {
  53         if (!export_status) {
  54                 export_status.reset (new ExportStatus ());
  55         }
  56
  57         return export_status;
  58 }
  59
  60
  61 int
  62 Session::pre_export ()
  63 {
  64         get_export_status (); // Init export_status
  65
  66         /* take everyone out of awrite to avoid disasters */
  67
  68         {
  69                 boost::shared_ptr<RouteList> r = routes.reader ();
  70
  71                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
  72                         (*i)->protect_automation ();
  73                 }
  74         }
  75
  76         /* prepare transport */
  77
  78         realtime_stop (true, true);
  79
  80         if (get_record_enabled()) {
  81                 disable_record (false);
  82         }
  83
  84         unset_play_loop ();
  85
  86         /* no slaving */
  87
  88         post_export_sync = config.get_external_sync ();
  89         post_export_position = _transport_frame;
  90
  91         config.set_external_sync (false);
  92
  93         _exporting = true;
  94         export_status->set_running (true);
  95         export_status->Finished.connect_same_thread (*this, boost::bind (&Session::finalize_audio_export, this));
  96
  97         /* disable MMC output early */
  98
  99         _pre_export_mmc_enabled = _mmc->send_enabled ();
 100         _mmc->enable_send (false);
 101
 102         return 0;
 103 }
 104
 105 /** Called for each range that is being exported */
 106 int
 107 Session::start_audio_export (framepos_t position, bool realtime, bool region_export)
 108 {
 109         if (!_exporting) {
 110                 pre_export ();
 111         }
 112
 113         _realtime_export = realtime;
 114         _region_export = region_export;
 115
 116         if (region_export) {
 117                 _export_preroll = 0;
 118         }
 119         else if (realtime) {
 120                 _export_preroll = nominal_frame_rate ();
 121         } else {
 122                 _export_preroll = Config->get_export_preroll() * nominal_frame_rate ();
 123         }
 124
 125         if (_export_preroll == 0) {
 126                 // must be > 0 so that transport is started in sync.
 127                 _export_preroll = 1;
 128         }
 129
 130         /* "worst_track_latency" is the correct value for stem-exports
 131          * see to Route::add_export_point(),
 132          *
 133          * for master-bus export, we'd need to add the master's latency.
 134          * or actually longest-total-session-latency.
 135          *
 136          * We can't use worst_playback_latency because that includes
 137          * includes external latencies and would overcompensate.
 138          */
 139         _export_latency = worst_track_latency ();
 140
 141         if (region_export) {
 142                 _export_latency = 0;
 143         }
 144
 145         /* We're about to call Track::seek, so the butler must have finished everything
 146            up otherwise it could be doing do_refill in its thread while we are doing
 147            it here.
 148         */
 149
 150         _butler->wait_until_finished ();
 151
 152         /* get everyone to the right position */
 153
 154         {
 155                 boost::shared_ptr<RouteList> rl = routes.reader();
 156
 157                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 158                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 159                         if (tr && tr->seek (position, true)) {
 160                                 error << string_compose (_("%1: cannot seek to %2 for export"),
 161                                                   (*i)->name(), position)
 162                                       << endmsg;
 163                                 return -1;
 164                         }
 165                 }
 166         }
 167
 168         /* we just did the core part of a locate() call above, but
 169            for the sake of any GUI, put the _transport_frame in
 170            the right place too.
 171         */
 172
 173         _transport_frame = position;
 174         export_status->stop = false;
 175
 176         /* get transport ready. note how this is calling butler functions
 177            from a non-butler thread. we waited for the butler to stop
 178            what it was doing earlier in Session::pre_export() and nothing
 179            since then has re-awakened it.
 180          */
 181
 182         /* we are ready to go ... */
 183
 184         if (!_engine.connected()) {
 185                 return -1;
 186         }
 187
 188         _engine.Freewheel.connect_same_thread (export_freewheel_connection, boost::bind (&Session::process_export_fw, this, _1));
 189
 190         if (_realtime_export) {
 191                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 192                 _export_rolling = true;
 193                 process_function = &Session::process_export_fw;
 194                 return 0;
 195         } else {
 196                 _export_rolling = true;
 197                 return _engine.freewheel (true);
 198         }
 199 }
 200
 201 void
 202 Session::process_export (pframes_t nframes)
 203 {
 204         if (_export_rolling && export_status->stop) {
 205                 stop_audio_export ();
 206         }
 207
 208         /* for Region Raw or Fades, we can skip this
 209          * RegionExportChannelFactory::update_buffers() does not care
 210          * about anything done here
 211          */
 212         if (!_region_export) {
 213                 if (_export_rolling) {
 214                         if (!_realtime_export)  {
 215                                 /* make sure we've caught up with disk i/o, since
 216                                  * we're running faster than realtime c/o JACK.
 217                                  */
 218                                 _butler->wait_until_finished ();
 219                         }
 220
 221                         /* do the usual stuff */
 222
 223                         process_without_events (nframes);
 224
 225                 } else if (_realtime_export) {
 226                         fail_roll (nframes); // somehow we need to silence _ALL_ output buffers
 227                 }
 228         }
 229
 230         try {
 231                 /* handle export - XXX what about error handling? */
 232
 233                 ProcessExport (nframes);
 234
 235         } catch (std::exception & e) {
 236                 error << string_compose (_("Export ended unexpectedly: %1"), e.what()) << endmsg;
 237                 export_status->abort (true);
 238         }
 239 }
 240
 241 void
 242 Session::process_export_fw (pframes_t nframes)
 243 {
 244         const bool need_buffers = _engine.freewheeling ();
 245         if (_export_preroll > 0) {
 246
 247                 if (need_buffers) {
 248                         _engine.main_thread()->get_buffers ();
 249                 }
 250                 fail_roll (nframes);
 251                 if (need_buffers) {
 252                         _engine.main_thread()->drop_buffers ();
 253                 }
 254
 255                 _export_preroll -= std::min ((framepos_t)nframes, _export_preroll);
 256
 257                 if (_export_preroll > 0) {
 258                         // clear out buffers (reverb tails etc).
 259                         return;
 260                 }
 261
 262                 set_transport_speed (1.0, 0, false);
 263                 butler_transport_work ();
 264                 g_atomic_int_set (&_butler->should_do_transport_work, 0);
 265                 post_transport ();
 266
 267                 return;
 268         }
 269
 270         if (_export_latency > 0) {
 271                 framepos_t remain = std::min ((framepos_t)nframes, _export_latency);
 272
 273                 if (need_buffers) {
 274                         _engine.main_thread()->get_buffers ();
 275                 }
 276                 process_without_events (remain);
 277                 if (need_buffers) {
 278                         _engine.main_thread()->drop_buffers ();
 279                 }
 280
 281                 _export_latency -= remain;
 282                 nframes -= remain;
 283
 284                 if (nframes == 0) {
 285                         return;
 286                 }
 287         }
 288
 289         if (need_buffers) {
 290                 _engine.main_thread()->get_buffers ();
 291         }
 292         process_export (nframes);
 293         if (need_buffers) {
 294                 _engine.main_thread()->drop_buffers ();
 295         }
 296
 297         return;
 298 }
 299
 300 int
 301 Session::stop_audio_export ()
 302 {
 303         /* can't use stop_transport() here because we need
 304            an immediate halt and don't require all the declick
 305            stuff that stop_transport() implements.
 306         */
 307
 308         realtime_stop (true, true);
 309         _export_rolling = false;
 310         _butler->schedule_transport_work ();
 311
 312         return 0;
 313 }
 314
 315 void
 316 Session::finalize_audio_export ()
 317 {
 318         _exporting = false;
 319
 320         if (_export_rolling) {
 321                 stop_audio_export ();
 322         }
 323
 324         /* Clean up */
 325
 326         if (_realtime_export) {
 327                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 328                 process_function = &Session::process_with_events;
 329         }
 330         _engine.freewheel (false);
 331         export_freewheel_connection.disconnect();
 332
 333         _mmc->enable_send (_pre_export_mmc_enabled);
 334
 335         /* maybe write CUE/TOC */
 336
 337         export_handler.reset();
 338         export_status.reset();
 339
 340         /* restart slaving */
 341
 342         if (post_export_sync) {
 343                 config.set_external_sync (true);
 344         } else {
 345                 locate (post_export_position, false, false, false, false, false);
 346         }
 347 }