libs/ardour/session_transport.cc

   1 /*
   2     Copyright (C) 1999-2003 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 #ifdef WAF_BUILD
  21 #include "libardour-config.h"
  22 #endif
  23
  24 #include <cmath>
  25 #include <cerrno>
  26 #include <unistd.h>
  27
  28 #include "pbd/undo.h"
  29 #include "pbd/error.h"
  30 #include "pbd/enumwriter.h"
  31 #include "pbd/pthread_utils.h"
  32 #include "pbd/memento_command.h"
  33 #include "pbd/stacktrace.h"
  34
  35 #include "midi++/mmc.h"
  36 #include "midi++/port.h"
  37
  38 #include "ardour/audioengine.h"
  39 #include "ardour/auditioner.h"
  40 #include "ardour/butler.h"
  41 #include "ardour/click.h"
  42 #include "ardour/debug.h"
  43 #include "ardour/location.h"
  44 #include "ardour/profile.h"
  45 #include "ardour/scene_changer.h"
  46 #include "ardour/session.h"
  47 #include "ardour/slave.h"
  48 #include "ardour/operations.h"
  49
  50 #include "pbd/i18n.h"
  51
  52 using namespace std;
  53 using namespace ARDOUR;
  54 using namespace PBD;
  55
  56 void
  57 Session::add_post_transport_work (PostTransportWork ptw)
  58 {
  59         PostTransportWork oldval;
  60         PostTransportWork newval;
  61         int tries = 0;
  62
  63         while (tries < 8) {
  64                 oldval = (PostTransportWork) g_atomic_int_get (&_post_transport_work);
  65                 newval = PostTransportWork (oldval | ptw);
  66                 if (g_atomic_int_compare_and_exchange (&_post_transport_work, oldval, newval)) {
  67                         /* success */
  68                         return;
  69                 }
  70         }
  71
  72         error << "Could not set post transport work! Crazy thread madness, call the programmers" << endmsg;
  73 }
  74
  75 void
  76 Session::request_input_change_handling ()
  77 {
  78         if (!(_state_of_the_state & (InitialConnecting|Deletion))) {
  79                 SessionEvent* ev = new SessionEvent (SessionEvent::InputConfigurationChange, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
  80                 queue_event (ev);
  81         }
  82 }
  83
  84 void
  85 Session::request_sync_source (Slave* new_slave)
  86 {
  87         SessionEvent* ev = new SessionEvent (SessionEvent::SetSyncSource, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
  88         bool seamless;
  89
  90         seamless = Config->get_seamless_loop ();
  91
  92         if (dynamic_cast<Engine_Slave*>(new_slave)) {
  93                 /* JACK cannot support seamless looping at present */
  94                 Config->set_seamless_loop (false);
  95         } else {
  96                 /* reset to whatever the value was before we last switched slaves */
  97                 Config->set_seamless_loop (_was_seamless);
  98         }
  99
 100         /* save value of seamless from before the switch */
 101         _was_seamless = seamless;
 102
 103         ev->slave = new_slave;
 104         DEBUG_TRACE (DEBUG::Slave, "sent request for new slave\n");
 105         queue_event (ev);
 106 }
 107
 108 void
 109 Session::request_transport_speed (double speed, bool as_default)
 110 {
 111         SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed);
 112         ev->third_yes_or_no = as_default; // as_default
 113         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport speed = %1 as default = %2\n", speed, as_default));
 114         queue_event (ev);
 115 }
 116
 117 /** Request a new transport speed, but if the speed parameter is exactly zero then use
 118  *  a very small +ve value to prevent the transport actually stopping.  This method should
 119  *  be used by callers who are varying transport speed but don't ever want to stop it.
 120  */
 121 void
 122 Session::request_transport_speed_nonzero (double speed, bool as_default)
 123 {
 124         if (speed == 0) {
 125                 speed = DBL_EPSILON;
 126         }
 127
 128         request_transport_speed (speed, as_default);
 129 }
 130
 131 void
 132 Session::request_track_speed (Track* tr, double speed)
 133 {
 134         SessionEvent* ev = new SessionEvent (SessionEvent::SetTrackSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed);
 135         ev->set_ptr (tr);
 136         queue_event (ev);
 137 }
 138
 139 void
 140 Session::request_stop (bool abort, bool clear_state)
 141 {
 142         SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, audible_frame(), 0.0, abort, clear_state);
 143         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport stop, audible %3 transport %4 abort = %1, clear state = %2\n", abort, clear_state, audible_frame(), _transport_frame));
 144         queue_event (ev);
 145 }
 146
 147 void
 148 Session::request_locate (framepos_t target_frame, bool with_roll)
 149 {
 150         SessionEvent *ev = new SessionEvent (with_roll ? SessionEvent::LocateRoll : SessionEvent::Locate, SessionEvent::Add, SessionEvent::Immediate, target_frame, 0, false);
 151         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request locate to %1\n", target_frame));
 152         queue_event (ev);
 153 }
 154
 155 void
 156 Session::force_locate (framepos_t target_frame, bool with_roll)
 157 {
 158         SessionEvent *ev = new SessionEvent (with_roll ? SessionEvent::LocateRoll : SessionEvent::Locate, SessionEvent::Add, SessionEvent::Immediate, target_frame, 0, true);
 159         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request forced locate to %1\n", target_frame));
 160         queue_event (ev);
 161 }
 162
 163 void
 164 Session::request_play_loop (bool yn, bool change_transport_roll)
 165 {
 166         if (_slave && yn) {
 167                 // don't attempt to loop when not using Internal Transport
 168                 // see also gtk2_ardour/ardour_ui_options.cc parameter_changed()
 169                 return;
 170         }
 171
 172         SessionEvent* ev;
 173         Location *location = _locations->auto_loop_location();
 174         double target_speed;
 175
 176         if (location == 0 && yn) {
 177                 error << _("Cannot loop - no loop range defined")
 178                       << endmsg;
 179                 return;
 180         }
 181
 182         if (change_transport_roll) {
 183                 if (transport_rolling()) {
 184                         /* start looping at current speed */
 185                         target_speed = transport_speed ();
 186                 } else {
 187                         /* currently stopped */
 188                         if (yn) {
 189                                 /* start looping at normal speed */
 190                                 target_speed = 1.0;
 191                         } else {
 192                                 target_speed = 0.0;
 193                         }
 194                 }
 195         } else {
 196                 /* leave the speed alone */
 197                 target_speed = transport_speed ();
 198         }
 199
 200         ev = new SessionEvent (SessionEvent::SetLoop, SessionEvent::Add, SessionEvent::Immediate, 0, target_speed, yn);
 201         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request set loop = %1, change roll state ? %2\n", yn, change_transport_roll));
 202         queue_event (ev);
 203
 204         if (yn) {
 205                 if (!change_transport_roll) {
 206                         if (!transport_rolling()) {
 207                                 /* we're not changing transport state, but we do want
 208                                    to set up position for the new loop. Don't
 209                                    do this if we're rolling already.
 210                                 */
 211                                 request_locate (location->start(), false);
 212                         }
 213                 }
 214         } else {
 215                 if (!change_transport_roll && Config->get_seamless_loop() && transport_rolling()) {
 216                         // request an immediate locate to refresh the tracks
 217                         // after disabling looping
 218                         request_locate (_transport_frame-1, false);
 219                 }
 220         }
 221 }
 222
 223 void
 224 Session::request_play_range (list<AudioRange>* range, bool leave_rolling)
 225 {
 226         SessionEvent* ev = new SessionEvent (SessionEvent::SetPlayAudioRange, SessionEvent::Add, SessionEvent::Immediate, 0, (leave_rolling ? 1.0 : 0.0));
 227         if (range) {
 228                 ev->audio_range = *range;
 229         } else {
 230                 ev->audio_range.clear ();
 231         }
 232         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request play range, leave rolling ? %1\n", leave_rolling));
 233         queue_event (ev);
 234 }
 235
 236 void
 237 Session::request_cancel_play_range ()
 238 {
 239         SessionEvent* ev = new SessionEvent (SessionEvent::CancelPlayAudioRange, SessionEvent::Add, SessionEvent::Immediate, 0, 0);
 240         queue_event (ev);
 241 }
 242
 243
 244 void
 245 Session::realtime_stop (bool abort, bool clear_state)
 246 {
 247         DEBUG_TRACE (DEBUG::Transport, string_compose ("realtime stop @ %1\n", _transport_frame));
 248         PostTransportWork todo = PostTransportWork (0);
 249
 250         /* assume that when we start, we'll be moving forwards */
 251
 252         if (_transport_speed < 0.0f) {
 253                 todo = (PostTransportWork (todo | PostTransportStop | PostTransportReverse));
 254                 _default_transport_speed = 1.0;
 255         } else {
 256                 todo = PostTransportWork (todo | PostTransportStop);
 257         }
 258
 259         /* call routes */
 260
 261         boost::shared_ptr<RouteList> r = routes.reader ();
 262
 263         for (RouteList::iterator i = r->begin (); i != r->end(); ++i) {
 264                 (*i)->realtime_handle_transport_stopped ();
 265         }
 266
 267         DEBUG_TRACE (DEBUG::Transport, string_compose ("stop complete, auto-return scheduled for return to %1\n", _requested_return_frame));
 268
 269         /* the duration change is not guaranteed to have happened, but is likely */
 270
 271         todo = PostTransportWork (todo | PostTransportDuration);
 272
 273         if (abort) {
 274                 todo = PostTransportWork (todo | PostTransportAbort);
 275         }
 276
 277         if (clear_state) {
 278                 todo = PostTransportWork (todo | PostTransportClearSubstate);
 279         }
 280
 281         if (todo) {
 282                 add_post_transport_work (todo);
 283         }
 284
 285         _clear_event_type (SessionEvent::StopOnce);
 286         _clear_event_type (SessionEvent::RangeStop);
 287         _clear_event_type (SessionEvent::RangeLocate);
 288
 289         /* if we're going to clear loop state, then force disabling record BUT only if we're not doing latched rec-enable */
 290         disable_record (true, (!Config->get_latched_record_enable() && clear_state));
 291
 292         if (clear_state && !Config->get_loop_is_mode()) {
 293                 unset_play_loop ();
 294         }
 295
 296         reset_slave_state ();
 297
 298         _transport_speed = 0;
 299         _target_transport_speed = 0;
 300
 301         g_atomic_int_set (&_playback_load, 100);
 302         g_atomic_int_set (&_capture_load, 100);
 303
 304         if (config.get_use_video_sync()) {
 305                 waiting_for_sync_offset = true;
 306         }
 307
 308         transport_sub_state = 0;
 309 }
 310
 311 void
 312 Session::realtime_locate ()
 313 {
 314         boost::shared_ptr<RouteList> r = routes.reader ();
 315         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 316                 (*i)->realtime_locate ();
 317         }
 318 }
 319
 320 void
 321 Session::butler_transport_work ()
 322 {
 323         /* Note: this function executes in the butler thread context */
 324
 325   restart:
 326         bool finished;
 327         PostTransportWork ptw;
 328         boost::shared_ptr<RouteList> r = routes.reader ();
 329         uint64_t before;
 330
 331         int on_entry = g_atomic_int_get (&_butler->should_do_transport_work);
 332         finished = true;
 333         ptw = post_transport_work();
 334
 335         DEBUG_TRACE (DEBUG::Transport, string_compose ("Butler transport work, todo = %1 at %2\n", enum_2_string (ptw), (before = g_get_monotonic_time())));
 336
 337
 338         if (ptw & PostTransportLocate) {
 339
 340                 if (get_play_loop() && !Config->get_seamless_loop()) {
 341
 342                         DEBUG_TRACE (DEBUG::Butler, "flush loop recording fragment to disk\n");
 343
 344                         /* this locate might be happening while we are
 345                          * loop recording.
 346                          *
 347                          * Non-seamless looping will require a locate (below) that
 348                          * will reset capture buffers and throw away data.
 349                          *
 350                          * Rather than first find all tracks and see if they
 351                          * have outstanding data, just do a flush anyway. It
 352                          * may be cheaper this way anyway, and is certainly
 353                          * more accurate.
 354                          */
 355
 356                         bool more_disk_io_to_do = false;
 357                         uint32_t errors = 0;
 358
 359                         do {
 360                                 more_disk_io_to_do = _butler->flush_tracks_to_disk_after_locate (r, errors);
 361
 362                                 if (errors) {
 363                                         break;
 364                                 }
 365
 366                                 if (more_disk_io_to_do) {
 367                                         continue;
 368                                 }
 369
 370                         } while (false);
 371
 372                 }
 373         }
 374
 375         if (ptw & PostTransportAdjustPlaybackBuffering) {
 376                 /* non_realtime_locate() calls Automatable::transport_located()
 377                  * for every route. This eventually calls
 378                  * ARDOUR::AutomationList::state () which has a LocaleGuard,
 379                  * and would switch locales forth/back every time.
 380                  */
 381                 LocaleGuard lg;
 382                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 383                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 384                         if (tr) {
 385                                 tr->adjust_playback_buffering ();
 386                                 /* and refill those buffers ... */
 387                         }
 388                         (*i)->non_realtime_locate (_transport_frame);
 389                 }
 390
 391         }
 392
 393         if (ptw & PostTransportAdjustCaptureBuffering) {
 394                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 395                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 396                         if (tr) {
 397                                 tr->adjust_capture_buffering ();
 398                         }
 399                 }
 400         }
 401
 402         if (ptw & PostTransportCurveRealloc) {
 403                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 404                         (*i)->curve_reallocate();
 405                 }
 406         }
 407
 408         if (ptw & PostTransportInputChange) {
 409                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 410                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 411                         if (tr) {
 412                                 tr->non_realtime_input_change ();
 413                         }
 414                 }
 415         }
 416
 417         if (ptw & PostTransportSpeed) {
 418                 non_realtime_set_speed ();
 419         }
 420
 421         if (ptw & PostTransportReverse) {
 422
 423                 clear_clicks();
 424                 cumulative_rf_motion = 0;
 425                 reset_rf_scale (0);
 426
 427                 /* don't seek if locate will take care of that in non_realtime_stop() */
 428
 429                 if (!(ptw & PostTransportLocate)) {
 430                         LocaleGuard lg; // see note for non_realtime_locate() above
 431                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 432                                 (*i)->non_realtime_locate (_transport_frame);
 433
 434                                 if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
 435                                         /* new request, stop seeking, and start again */
 436                                         g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 437                                         goto restart;
 438                                 }
 439                         }
 440                 }
 441         }
 442
 443         if (ptw & PostTransportLocate) {
 444                 DEBUG_TRACE (DEBUG::Transport, "nonrealtime locate invoked from BTW\n");
 445                 non_realtime_locate ();
 446         }
 447
 448         if (ptw & PostTransportStop) {
 449                 non_realtime_stop (ptw & PostTransportAbort, on_entry, finished);
 450                 if (!finished) {
 451                         g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 452                         goto restart;
 453                 }
 454         }
 455
 456         if (ptw & PostTransportOverWrite) {
 457                 non_realtime_overwrite (on_entry, finished);
 458                 if (!finished) {
 459                         g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 460                         goto restart;
 461                 }
 462         }
 463
 464         if (ptw & PostTransportAudition) {
 465                 non_realtime_set_audition ();
 466         }
 467
 468         g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 469
 470         DEBUG_TRACE (DEBUG::Transport, string_compose (X_("Butler transport work all done after %1 usecs\n"), g_get_monotonic_time() - before));
 471         DEBUG_TRACE (DEBUG::Transport, X_(string_compose ("Frame %1\n", _transport_frame)));
 472 }
 473
 474 void
 475 Session::non_realtime_set_speed ()
 476 {
 477         boost::shared_ptr<RouteList> rl = routes.reader();
 478         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 479                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 480                 if (tr) {
 481                         tr->non_realtime_set_speed ();
 482                 }
 483         }
 484 }
 485
 486 void
 487 Session::non_realtime_overwrite (int on_entry, bool& finished)
 488 {
 489         boost::shared_ptr<RouteList> rl = routes.reader();
 490         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 491                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 492                 if (tr && tr->pending_overwrite ()) {
 493                         tr->overwrite_existing_buffers ();
 494                 }
 495                 if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
 496                         finished = false;
 497                         return;
 498                 }
 499         }
 500 }
 501
 502
 503 void
 504 Session::non_realtime_locate ()
 505 {
 506         DEBUG_TRACE (DEBUG::Transport, string_compose ("locate tracks to %1\n", _transport_frame));
 507
 508         if (Config->get_loop_is_mode() && get_play_loop()) {
 509
 510                 Location *loc  = _locations->auto_loop_location();
 511
 512                 if (!loc || (_transport_frame < loc->start() || _transport_frame >= loc->end())) {
 513                         /* jumped out of loop range: stop tracks from looping,
 514                            but leave loop (mode) enabled.
 515                          */
 516                         set_track_loop (false);
 517
 518                 } else if (loc && Config->get_seamless_loop() &&
 519                    ((loc->start() <= _transport_frame) ||
 520                    (loc->end() > _transport_frame) ) ) {
 521
 522                         /* jumping to start of loop. This  might have been done before but it is
 523                          * idempotent and cheap. Doing it here ensures that when we start playback
 524                          * outside the loop we still flip tracks into the magic seamless mode
 525                          * when needed.
 526                          */
 527                         set_track_loop (true);
 528
 529                 } else if (loc) {
 530                         set_track_loop (false);
 531                 }
 532
 533         } else {
 534
 535                 /* no more looping .. should have been noticed elsewhere */
 536         }
 537
 538
 539         {
 540                 LocaleGuard lg; // see note for non_realtime_locate() above
 541                 boost::shared_ptr<RouteList> rl = routes.reader();
 542                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 543                         (*i)->non_realtime_locate (_transport_frame);
 544                 }
 545         }
 546
 547         _scene_changer->locate (_transport_frame);
 548
 549         /* XXX: it would be nice to generate the new clicks here (in the non-RT thread)
 550            rather than clearing them so that the RT thread has to spend time constructing
 551            them (in Session::click).
 552          */
 553         clear_clicks ();
 554 }
 555
 556 #ifdef USE_TRACKS_CODE_FEATURES
 557 bool
 558 Session::select_playhead_priority_target (framepos_t& jump_to)
 559 {
 560         jump_to = -1;
 561
 562         AutoReturnTarget autoreturn = Config->get_auto_return_target_list ();
 563
 564         if (!autoreturn) {
 565                 return false;
 566         }
 567
 568         if (Profile->get_trx() && transport_rolling() ) {
 569                 // We're playing, so do nothing.
 570                 // Next stop will put us where we need to be.
 571                 return false;
 572         }
 573
 574         /* Note that the order of checking each AutoReturnTarget flag defines
 575            the priority each flag.
 576
 577            Ardour/Mixbus: Last Locate
 578                           Range Selection
 579                           Loop Range
 580                           Region Selection
 581
 582            Tracks:        Range Selection
 583                           Loop Range
 584                           Region Selection
 585                           Last Locate
 586         */
 587
 588         if (autoreturn & RangeSelectionStart) {
 589                 if (!_range_selection.empty()) {
 590                         jump_to = _range_selection.from;
 591                 } else {
 592                         if (transport_rolling ()) {
 593                                 /* Range selection no longer exists, but we're playing,
 594                                    so do nothing. Next stop will put us where
 595                                    we need to be.
 596                                 */
 597                                 return false;
 598                         }
 599                 }
 600         }
 601
 602         if (jump_to < 0 && (autoreturn & Loop) && get_play_loop()) {
 603                 /* don't try to handle loop play when synced to JACK */
 604
 605                 if (!synced_to_engine()) {
 606                         Location *location = _locations->auto_loop_location();
 607
 608                         if (location) {
 609                                 jump_to = location->start();
 610
 611                                 if (Config->get_seamless_loop()) {
 612                                         /* need to get track buffers reloaded */
 613                                         set_track_loop (true);
 614                                 }
 615                         }
 616                 }
 617         }
 618
 619         if (jump_to < 0 && (autoreturn & RegionSelectionStart)) {
 620                 if (!_object_selection.empty()) {
 621                         jump_to = _object_selection.from;
 622                 }
 623         }
 624
 625         if (jump_to < 0 && (autoreturn & LastLocate)) {
 626                 jump_to = _last_roll_location;
 627         }
 628
 629         return jump_to >= 0;
 630 }
 631 #else
 632
 633 bool
 634 Session::select_playhead_priority_target (framepos_t& jump_to)
 635 {
 636         if (config.get_external_sync() || !config.get_auto_return()) {
 637                 return false;
 638         }
 639
 640         jump_to = _last_roll_location;
 641         return jump_to >= 0;
 642 }
 643
 644 #endif
 645
 646 void
 647 Session::follow_playhead_priority ()
 648 {
 649         framepos_t target;
 650
 651         if (select_playhead_priority_target (target)) {
 652                 request_locate (target);
 653         }
 654 }
 655
 656 void
 657 Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
 658 {
 659         struct tm* now;
 660         time_t     xnow;
 661         bool       did_record;
 662         bool       saved;
 663         PostTransportWork ptw = post_transport_work();
 664
 665         did_record = false;
 666         saved = false;
 667
 668         boost::shared_ptr<RouteList> rl = routes.reader();
 669         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 670                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 671                 if (tr && tr->get_captured_frames () != 0) {
 672                         did_record = true;
 673                         break;
 674                 }
 675         }
 676
 677         /* stop and locate are merged here because they share a lot of common stuff */
 678
 679         time (&xnow);
 680         now = localtime (&xnow);
 681
 682         if (auditioner) {
 683                 auditioner->cancel_audition ();
 684         }
 685
 686         cumulative_rf_motion = 0;
 687         reset_rf_scale (0);
 688
 689         if (did_record) {
 690                 begin_reversible_command (Operations::capture);
 691                 _have_captured = true;
 692         }
 693
 694         DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: DS stop\n"));
 695
 696         if (abort && did_record) {
 697                 /* no reason to save the session file when we remove sources
 698                  */
 699                 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
 700         }
 701
 702         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 703                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 704                 if (tr) {
 705                         tr->transport_stopped_wallclock (*now, xnow, abort);
 706                 }
 707         }
 708
 709         if (abort && did_record) {
 710                 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
 711         }
 712
 713         boost::shared_ptr<RouteList> r = routes.reader ();
 714
 715         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 716                 if (!(*i)->is_auditioner()) {
 717                         (*i)->set_pending_declick (0);
 718                 }
 719         }
 720
 721         if (did_record) {
 722                 commit_reversible_command ();
 723                 /* increase take name */
 724                 if (config.get_track_name_take () && !config.get_take_name ().empty()) {
 725                         string newname = config.get_take_name();
 726                         config.set_take_name(bump_name_number (newname));
 727                 }
 728         }
 729
 730         if (_engine.running()) {
 731                 PostTransportWork ptw = post_transport_work ();
 732                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 733                         (*i)->nonrealtime_handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
 734                 }
 735                 update_latency_compensation ();
 736         }
 737
 738         bool const auto_return_enabled = (!config.get_external_sync() && (Config->get_auto_return_target_list() || abort));
 739
 740         if (auto_return_enabled ||
 741             (ptw & PostTransportLocate) ||
 742             (_requested_return_frame >= 0) ||
 743             synced_to_engine()) {
 744
 745                 if (pending_locate_flush) {
 746                         flush_all_inserts ();
 747                 }
 748
 749                 if ((auto_return_enabled || synced_to_engine() || _requested_return_frame >= 0) &&
 750                     !(ptw & PostTransportLocate)) {
 751
 752                         /* no explicit locate queued */
 753
 754                         bool do_locate = false;
 755
 756                         if (_requested_return_frame >= 0) {
 757
 758                                 /* explicit return request pre-queued in event list. overrides everything else */
 759
 760                                 _transport_frame = _requested_return_frame;
 761                                 do_locate = true;
 762
 763                         } else {
 764                                 framepos_t jump_to;
 765
 766                                 if (select_playhead_priority_target (jump_to)) {
 767
 768                                         _transport_frame = jump_to;
 769                                         do_locate = true;
 770
 771                                 } else if (abort) {
 772
 773                                         _transport_frame = _last_roll_location;
 774                                         do_locate = true;
 775                                 }
 776                         }
 777
 778                         _requested_return_frame = -1;
 779
 780                         if (do_locate) {
 781                                 _engine.transport_locate (_transport_frame);
 782                         }
 783                 }
 784
 785         }
 786
 787         clear_clicks();
 788
 789         /* do this before seeking, because otherwise the tracks will do the wrong thing in seamless loop mode.
 790         */
 791
 792         if (ptw & PostTransportClearSubstate) {
 793                 unset_play_range ();
 794                 if (!Config->get_loop_is_mode()) {
 795                         unset_play_loop ();
 796                 }
 797         }
 798
 799         /* this for() block can be put inside the previous if() and has the effect of ... ??? what */
 800
 801         {
 802                 LocaleGuard lg; // see note for non_realtime_locate() above
 803                 DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: locate\n"));
 804                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 805                         DEBUG_TRACE (DEBUG::Transport, string_compose ("Butler PTW: locate on %1\n", (*i)->name()));
 806                         (*i)->non_realtime_locate (_transport_frame);
 807
 808                         if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
 809                                 finished = false;
 810                                 /* we will be back */
 811                                 return;
 812                         }
 813                 }
 814         }
 815
 816         have_looped = false;
 817
 818         /* don't bother with this stuff if we're disconnected from the engine,
 819            because there will be no process callbacks to deliver stuff from
 820         */
 821
 822         if (_engine.connected() && !_engine.freewheeling()) {
 823                 // need to queue this in the next RT cycle
 824                 _send_timecode_update = true;
 825
 826                 if (!dynamic_cast<MTC_Slave*>(_slave)) {
 827                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
 828
 829                         /* This (::non_realtime_stop()) gets called by main
 830                            process thread, which will lead to confusion
 831                            when calling AsyncMIDIPort::write().
 832
 833                            Something must be done. XXX
 834                         */
 835                         send_mmc_locate (_transport_frame);
 836                 }
 837         }
 838
 839         if ((ptw & PostTransportLocate) && get_record_enabled()) {
 840                 /* This is scheduled by realtime_stop(), which is also done
 841                  * when a slave requests /locate/ for an initial sync.
 842                  * We can't hold up the slave for long with a save() here,
 843                  * without breaking its initial sync cycle.
 844                  *
 845                  * save state only if there's no slave or if it's not yet locked.
 846                  */
 847                 if (!_slave || !_slave->locked()) {
 848                         DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: requests save\n"));
 849                         SaveSessionRequested (_current_snapshot_name);
 850                         saved = true;
 851                 }
 852         }
 853
 854         /* always try to get rid of this */
 855
 856         remove_pending_capture_state ();
 857
 858         /* save the current state of things if appropriate */
 859
 860         if (did_record && !saved) {
 861                 SaveSessionRequested (_current_snapshot_name);
 862         }
 863
 864         if (ptw & PostTransportStop) {
 865                 unset_play_range ();
 866                 if (!Config->get_loop_is_mode()) {
 867                         unset_play_loop ();
 868                 }
 869         }
 870
 871         PositionChanged (_transport_frame); /* EMIT SIGNAL */
 872         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC with speed = %1\n", _transport_speed));
 873         TransportStateChange (); /* EMIT SIGNAL */
 874
 875         /* and start it up again if relevant */
 876
 877         if ((ptw & PostTransportLocate) && !config.get_external_sync() && pending_locate_roll) {
 878                 request_transport_speed (1.0);
 879         }
 880
 881         /* Even if we didn't do a pending locate roll this time, we don't want it hanging
 882            around for next time.
 883         */
 884         pending_locate_roll = false;
 885 }
 886
 887 void
 888 Session::check_declick_out ()
 889 {
 890         bool locate_required = transport_sub_state & PendingLocate;
 891
 892         /* this is called after a process() iteration. if PendingDeclickOut was set,
 893            it means that we were waiting to declick the output (which has just been
 894            done) before maybe doing something else. this is where we do that "something else".
 895
 896            note: called from the audio thread.
 897         */
 898
 899         if (transport_sub_state & PendingDeclickOut) {
 900
 901                 if (locate_required) {
 902                         start_locate (pending_locate_frame, pending_locate_roll, pending_locate_flush);
 903                         transport_sub_state &= ~(PendingDeclickOut|PendingLocate);
 904                 } else {
 905                         if (!(transport_sub_state & StopPendingCapture)) {
 906                                 stop_transport (pending_abort);
 907                                 transport_sub_state &= ~(PendingDeclickOut|PendingLocate);
 908                         }
 909                 }
 910
 911         } else if (transport_sub_state & PendingLoopDeclickOut) {
 912                 /* Nothing else to do here; we've declicked, and the loop event will be along shortly */
 913                 transport_sub_state &= ~PendingLoopDeclickOut;
 914         }
 915 }
 916
 917 void
 918 Session::unset_play_loop ()
 919 {
 920         if (play_loop) {
 921                 play_loop = false;
 922                 clear_events (SessionEvent::AutoLoop);
 923                 clear_events (SessionEvent::AutoLoopDeclick);
 924                 set_track_loop (false);
 925
 926
 927                 if (Config->get_seamless_loop()) {
 928                         /* likely need to flush track buffers: this will locate us to wherever we are */
 929                         add_post_transport_work (PostTransportLocate);
 930                         _butler->schedule_transport_work ();
 931                 }
 932         }
 933 }
 934
 935 void
 936 Session::set_track_loop (bool yn)
 937 {
 938         Location* loc = _locations->auto_loop_location ();
 939
 940         if (!loc) {
 941                 yn = false;
 942         }
 943
 944         boost::shared_ptr<RouteList> rl = routes.reader ();
 945
 946         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 947                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 948                 if (tr && !tr->hidden()) {
 949                         tr->set_loop (yn ? loc : 0);
 950                 }
 951         }
 952 }
 953
 954 void
 955 Session::set_play_loop (bool yn, double speed)
 956 {
 957         /* Called from event-handling context */
 958
 959         Location *loc;
 960
 961         if (yn == play_loop || (actively_recording() && yn) || (loc = _locations->auto_loop_location()) == 0) {
 962                 /* nothing to do, or can't change loop status while recording */
 963                 return;
 964         }
 965
 966         if (yn && Config->get_seamless_loop() && synced_to_engine()) {
 967                 warning << string_compose (
 968                         _("Seamless looping cannot be supported while %1 is using JACK transport.\n"
 969                           "Recommend changing the configured options"), PROGRAM_NAME)
 970                         << endmsg;
 971                 return;
 972         }
 973
 974         if (yn) {
 975
 976                 play_loop = true;
 977                 have_looped = false;
 978
 979                 if (loc) {
 980
 981                         unset_play_range ();
 982
 983                         if (Config->get_seamless_loop()) {
 984                                 if (!Config->get_loop_is_mode()) {
 985                                         /* set all tracks to use internal looping */
 986                                         set_track_loop (true);
 987                                 } else {
 988                                         /* we will do this in the locate to the start OR when we hit the end
 989                                          * of the loop for the first time
 990                                          */
 991                                 }
 992                         } else {
 993                                 /* set all tracks to NOT use internal looping */
 994                                 set_track_loop (false);
 995                         }
 996
 997                         /* Put the delick and loop events in into the event list.  The declick event will
 998                            cause a de-clicking fade-out just before the end of the loop, and it will also result
 999                            in a fade-in when the loop restarts.  The AutoLoop event will peform the actual loop.
1000                         */
1001
1002                         framepos_t dcp;
1003                         framecnt_t dcl;
1004                         auto_loop_declick_range (loc, dcp, dcl);
1005                         merge_event (new SessionEvent (SessionEvent::AutoLoopDeclick, SessionEvent::Replace, dcp, dcl, 0.0f));
1006                         merge_event (new SessionEvent (SessionEvent::AutoLoop, SessionEvent::Replace, loc->end(), loc->start(), 0.0f));
1007
1008                         /* if requested to roll, locate to start of loop and
1009                          * roll but ONLY if we're not already rolling.
1010
1011                            args: positition, roll=true, flush=true, with_loop=false, force buffer refill if seamless looping
1012                         */
1013
1014                         if (Config->get_loop_is_mode()) {
1015                                 /* loop IS a transport mode: if already
1016                                    rolling, do not locate to loop start.
1017                                 */
1018                                 if (!transport_rolling() && (speed != 0.0)) {
1019                                         start_locate (loc->start(), true, true, false, true);
1020                                 }
1021                         } else {
1022                                 if (speed != 0.0) {
1023                                         start_locate (loc->start(), true, true, false, true);
1024                                 }
1025                         }
1026                 }
1027
1028         } else {
1029
1030                 unset_play_loop ();
1031         }
1032
1033         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC2 with speed = %1\n", _transport_speed));
1034         TransportStateChange ();
1035 }
1036 void
1037 Session::flush_all_inserts ()
1038 {
1039         boost::shared_ptr<RouteList> r = routes.reader ();
1040
1041         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1042                 (*i)->flush_processors ();
1043         }
1044 }
1045
1046 void
1047 Session::start_locate (framepos_t target_frame, bool with_roll, bool with_flush, bool for_loop_enabled, bool force)
1048 {
1049         if (target_frame < 0) {
1050                 error << _("Locate called for negative sample position - ignored") << endmsg;
1051                 return;
1052         }
1053
1054         if (synced_to_engine()) {
1055
1056                 double sp;
1057                 framepos_t pos;
1058
1059                 _slave->speed_and_position (sp, pos);
1060
1061                 if (target_frame != pos) {
1062
1063                         if (config.get_jack_time_master()) {
1064                                 /* actually locate now, since otherwise jack_timebase_callback
1065                                    will use the incorrect _transport_frame and report an old
1066                                    and incorrect time to Jack transport
1067                                 */
1068                                 locate (target_frame, with_roll, with_flush, for_loop_enabled, force);
1069                         }
1070
1071                         /* tell JACK to change transport position, and we will
1072                            follow along later in ::follow_slave()
1073                         */
1074
1075                         _engine.transport_locate (target_frame);
1076
1077                         if (sp != 1.0f && with_roll) {
1078                                 _engine.transport_start ();
1079                         }
1080
1081                 }
1082
1083         } else {
1084                 locate (target_frame, with_roll, with_flush, for_loop_enabled, force);
1085         }
1086 }
1087
1088 int
1089 Session::micro_locate (framecnt_t distance)
1090 {
1091         boost::shared_ptr<RouteList> rl = routes.reader();
1092         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1093                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1094                 if (tr && !tr->can_internal_playback_seek (distance)) {
1095                         return -1;
1096                 }
1097         }
1098
1099         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1100                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1101                 if (tr) {
1102                         tr->internal_playback_seek (distance);
1103                 }
1104         }
1105
1106         _transport_frame += distance;
1107         return 0;
1108 }
1109
1110 /** @param with_mmc true to send a MMC locate command when the locate is done */
1111 void
1112 Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool for_loop_enabled, bool force, bool with_mmc)
1113 {
1114         bool need_butler = false;
1115
1116         /* Locates for seamless looping are fairly different from other
1117          * locates. They assume that the diskstream buffers for each track
1118          * already have the correct data in them, and thus there is no need to
1119          * actually tell the tracks to locate. What does need to be done,
1120          * though, is all the housekeeping that is associated with non-linear
1121          * changes in the value of _transport_frame.
1122          */
1123
1124         DEBUG_TRACE (DEBUG::Transport, string_compose ("rt-locate to %1, roll %2 flush %3 loop-enabled %4 force %5 mmc %6\n",
1125                                                        target_frame, with_roll, with_flush, for_loop_enabled, force, with_mmc));
1126
1127         if (!force && _transport_frame == target_frame && !loop_changing && !for_loop_enabled) {
1128
1129                 /* already at the desired position. Not forced to locate,
1130                    the loop isn't changing, so unless we're told to
1131                    start rolling also, there's nothing to do but
1132                    tell the world where we are (again).
1133                 */
1134
1135                 if (with_roll) {
1136                         set_transport_speed (1.0, 0, false);
1137                 }
1138                 loop_changing = false;
1139                 Located (); /* EMIT SIGNAL */
1140                 return;
1141         }
1142
1143         if (_transport_speed && !(for_loop_enabled && Config->get_seamless_loop())) {
1144                 /* Schedule a declick.  We'll be called again when its done.
1145                    We only do it this way for ordinary locates, not those
1146                    due to **seamless** loops.
1147                 */
1148
1149                 if (!(transport_sub_state & PendingDeclickOut)) {
1150                         transport_sub_state |= (PendingDeclickOut|PendingLocate);
1151                         pending_locate_frame = target_frame;
1152                         pending_locate_roll = with_roll;
1153                         pending_locate_flush = with_flush;
1154                         return;
1155                 }
1156         }
1157
1158         // Update Timecode time
1159         _transport_frame = target_frame;
1160         _last_roll_or_reversal_location = target_frame;
1161         timecode_time(_transport_frame, transmitting_timecode_time);
1162
1163         /* do "stopped" stuff if:
1164          *
1165          * we are rolling AND
1166          *    no autoplay in effect AND
1167          *       we're not going to keep rolling after the locate AND
1168          *           !(playing a loop with JACK sync)
1169          *
1170          */
1171
1172         bool transport_was_stopped = !transport_rolling();
1173
1174         if (!transport_was_stopped && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_engine() && play_loop) &&
1175             (!Profile->get_trx() || !(config.get_external_sync() && !synced_to_engine()))) {
1176                 realtime_stop (false, true); // XXX paul - check if the 2nd arg is really correct
1177                 transport_was_stopped = true;
1178         } else {
1179                 /* otherwise tell the world that we located */
1180                 realtime_locate ();
1181         }
1182
1183         if (force || !for_loop_enabled || loop_changing) {
1184
1185                 PostTransportWork todo = PostTransportLocate;
1186
1187                 if (with_roll && transport_was_stopped) {
1188                         todo = PostTransportWork (todo | PostTransportRoll);
1189                 }
1190
1191                 add_post_transport_work (todo);
1192                 need_butler = true;
1193
1194         } else {
1195
1196                 /* this is functionally what clear_clicks() does but with a tentative lock */
1197
1198                 Glib::Threads::RWLock::WriterLock clickm (click_lock, Glib::Threads::TRY_LOCK);
1199
1200                 if (clickm.locked()) {
1201
1202                         for (Clicks::iterator i = clicks.begin(); i != clicks.end(); ++i) {
1203                                 delete *i;
1204                         }
1205
1206                         clicks.clear ();
1207                 }
1208         }
1209
1210         if (with_roll) {
1211                 /* switch from input if we're going to roll */
1212                 if (Config->get_monitoring_model() == HardwareMonitoring) {
1213                         set_track_monitor_input_status (!config.get_auto_input());
1214                 }
1215         } else {
1216                 /* otherwise we're going to stop, so do the opposite */
1217                 if (Config->get_monitoring_model() == HardwareMonitoring) {
1218                         set_track_monitor_input_status (true);
1219                 }
1220         }
1221
1222         /* cancel looped playback if transport pos outside of loop range */
1223         if (play_loop) {
1224
1225                 Location* al = _locations->auto_loop_location();
1226
1227                 if (al) {
1228                         if (_transport_frame < al->start() || _transport_frame >= al->end()) {
1229
1230                                 // located outside the loop: cancel looping directly, this is called from event handling context
1231
1232                                 have_looped = false;
1233
1234                                 if (!Config->get_loop_is_mode()) {
1235                                         set_play_loop (false, _transport_speed);
1236                                 } else {
1237                                         if (Config->get_seamless_loop()) {
1238                                                 /* this will make the non_realtime_locate() in the butler
1239                                                    which then causes seek() in tracks actually do the right
1240                                                    thing.
1241                                                 */
1242                                                 set_track_loop (false);
1243                                         }
1244                                 }
1245
1246                         } else if (_transport_frame == al->start()) {
1247
1248                                 // located to start of loop - this is looping, basically
1249
1250                                 if (!have_looped) {
1251                                         /* first time */
1252                                         if (_last_roll_location != al->start()) {
1253                                                 /* didn't start at loop start - playback must have
1254                                                  * started before loop since we've now hit the loop
1255                                                  * end.
1256                                                  */
1257                                                 add_post_transport_work (PostTransportLocate);
1258                                                 need_butler = true;
1259                                         }
1260
1261                                 }
1262
1263                                 boost::shared_ptr<RouteList> rl = routes.reader();
1264
1265                                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1266                                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1267
1268                                         if (tr && tr->rec_enable_control()->get_value()) {
1269                                                 // tell it we've looped, so it can deal with the record state
1270                                                 tr->transport_looped (_transport_frame);
1271                                         }
1272                                 }
1273
1274                                 have_looped = true;
1275                                 TransportLooped(); // EMIT SIGNAL
1276                         }
1277                 }
1278         }
1279
1280         if (need_butler) {
1281                 _butler->schedule_transport_work ();
1282         }
1283
1284         loop_changing = false;
1285
1286         _send_timecode_update = true;
1287
1288         if (with_mmc) {
1289                 send_mmc_locate (_transport_frame);
1290         }
1291
1292         _last_roll_location = _last_roll_or_reversal_location =  _transport_frame;
1293         Located (); /* EMIT SIGNAL */
1294 }
1295
1296 /** Set the transport speed.
1297  *  Called from the process thread.
1298  *  @param speed New speed
1299  */
1300 void
1301 Session::set_transport_speed (double speed, framepos_t destination_frame, bool abort, bool clear_state, bool as_default)
1302 {
1303         DEBUG_TRACE (DEBUG::Transport, string_compose ("@ %5 Set transport speed to %1, abort = %2 clear_state = %3, current = %4 as_default %6\n",
1304                                                        speed, abort, clear_state, _transport_speed, _transport_frame, as_default));
1305
1306         if (_transport_speed == speed) {
1307                 if (as_default && speed == 0.0) { // => reset default transport speed. hacky or what?
1308                         _default_transport_speed = 1.0;
1309                 }
1310                 return;
1311         }
1312
1313         if (actively_recording() && speed != 1.0 && speed != 0.0) {
1314                 /* no varispeed during recording */
1315                 DEBUG_TRACE (DEBUG::Transport, string_compose ("No varispeed during recording cur_speed %1, frame %2\n",
1316                                                        _transport_speed, _transport_frame));
1317                 return;
1318         }
1319
1320         _target_transport_speed = fabs(speed);
1321
1322         /* 8.0 max speed is somewhat arbitrary but based on guestimates regarding disk i/o capability
1323            and user needs. We really need CD-style "skip" playback for ffwd and rewind.
1324         */
1325
1326         if (speed > 0) {
1327                 speed = min (8.0, speed);
1328         } else if (speed < 0) {
1329                 speed = max (-8.0, speed);
1330         }
1331
1332         if (transport_rolling() && speed == 0.0) {
1333
1334                 /* we are rolling and we want to stop */
1335
1336                 if (Config->get_monitoring_model() == HardwareMonitoring) {
1337                         set_track_monitor_input_status (true);
1338                 }
1339
1340                 if (synced_to_engine ()) {
1341                         if (clear_state) {
1342                                 /* do this here because our response to the slave won't
1343                                    take care of it.
1344                                 */
1345                                 _play_range = false;
1346                                 unset_play_loop ();
1347                         }
1348                         _engine.transport_stop ();
1349                 } else {
1350                         bool const auto_return_enabled = (!config.get_external_sync() && (Config->get_auto_return_target_list() || abort));
1351
1352                         if (!auto_return_enabled) {
1353                                 _requested_return_frame = destination_frame;
1354                         }
1355
1356                         stop_transport (abort);
1357                 }
1358
1359         } else if (transport_stopped() && speed == 1.0) {
1360                 if (as_default) {
1361                         _default_transport_speed = speed;
1362                 }
1363                 /* we are stopped and we want to start rolling at speed 1 */
1364
1365                 if (Config->get_loop_is_mode() && play_loop) {
1366
1367                         Location *location = _locations->auto_loop_location();
1368
1369                         if (location != 0) {
1370                                 if (_transport_frame != location->start()) {
1371
1372                                         if (Config->get_seamless_loop()) {
1373                                                 /* force tracks to do their thing */
1374                                                 set_track_loop (true);
1375                                         }
1376
1377                                         /* jump to start and then roll from there */
1378
1379                                         request_locate (location->start(), true);
1380                                         return;
1381                                 }
1382                         }
1383                 }
1384
1385                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1386                         set_track_monitor_input_status (false);
1387                 }
1388
1389                 if (synced_to_engine()) {
1390                         _engine.transport_start ();
1391                 } else {
1392                         start_transport ();
1393                 }
1394
1395         } else {
1396
1397                 /* not zero, not 1.0 ... varispeed */
1398
1399                 if ((synced_to_engine()) && speed != 0.0 && speed != 1.0) {
1400                         warning << string_compose (
1401                                 _("Global varispeed cannot be supported while %1 is connected to JACK transport control"),
1402                                 PROGRAM_NAME)
1403                                 << endmsg;
1404                         return;
1405                 }
1406
1407                 if (actively_recording()) {
1408                         return;
1409                 }
1410
1411                 if (speed > 0.0 && _transport_frame == current_end_frame()) {
1412                         return;
1413                 }
1414
1415                 if (speed < 0.0 && _transport_frame == 0) {
1416                         return;
1417                 }
1418
1419                 clear_clicks ();
1420
1421                 /* if we are reversing relative to the current speed, or relative to the speed
1422                    before the last stop, then we have to do extra work.
1423                 */
1424
1425                 PostTransportWork todo = PostTransportWork (0);
1426
1427                 if ((_transport_speed && speed * _transport_speed < 0.0) || (_last_transport_speed * speed < 0.0) || (_last_transport_speed == 0.0 && speed < 0.0)) {
1428                         todo = PostTransportWork (todo | PostTransportReverse);
1429                         _last_roll_or_reversal_location = _transport_frame;
1430                 }
1431
1432                 _last_transport_speed = _transport_speed;
1433                 _transport_speed = speed;
1434
1435                 if (as_default) {
1436                         _default_transport_speed = speed;
1437                 }
1438
1439                 boost::shared_ptr<RouteList> rl = routes.reader();
1440                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1441                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1442                         if (tr && tr->realtime_set_speed (tr->speed(), true)) {
1443                                 todo = PostTransportWork (todo | PostTransportSpeed);
1444                         }
1445                 }
1446
1447                 if (todo) {
1448                         add_post_transport_work (todo);
1449                         _butler->schedule_transport_work ();
1450                 }
1451
1452                 DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC3 with speed = %1\n", _transport_speed));
1453
1454                 /* throttle signal emissions.
1455                  * when slaved [_last]_transport_speed
1456                  * usually changes every cycle (tiny amounts due to DLL).
1457                  * Emitting a signal every cycle is overkill and unwarranted.
1458                  *
1459                  * Using _last_transport_speed is not acceptable,
1460                  * since it allows for large changes over a long period
1461                  * of time. Hence we introduce a dedicated variable to keep track
1462                  *
1463                  * The 0.2% dead-zone is somewhat arbitrary. Main use-case
1464                  * for TransportStateChange() here is the ShuttleControl display.
1465                  */
1466                 if (fabs (_signalled_varispeed - speed) > .002
1467                     // still, signal hard changes to 1.0 and 0.0:
1468                     || ( speed == 1.0 && _signalled_varispeed != 1.0)
1469                     || ( speed == 0.0 && _signalled_varispeed != 0.0)
1470                    )
1471                 {
1472                         TransportStateChange (); /* EMIT SIGNAL */
1473                         _signalled_varispeed = speed;
1474                 }
1475         }
1476 }
1477
1478
1479 /** Stop the transport.  */
1480 void
1481 Session::stop_transport (bool abort, bool clear_state)
1482 {
1483         if (_transport_speed == 0.0f) {
1484                 return;
1485         }
1486
1487         DEBUG_TRACE (DEBUG::Transport, string_compose ("stop_transport, declick required? %1\n", get_transport_declick_required()));
1488
1489         if (!get_transport_declick_required()) {
1490
1491                 /* stop has not yet been scheduled */
1492
1493                 boost::shared_ptr<RouteList> rl = routes.reader();
1494                 framepos_t stop_target = audible_frame();
1495
1496                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1497                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1498                         if (tr) {
1499                                 tr->prepare_to_stop (_transport_frame, stop_target);
1500                         }
1501                 }
1502
1503                 SubState new_bits;
1504
1505                 if (actively_recording() &&                           /* we are recording */
1506                     worst_input_latency() > current_block_size) {     /* input latency exceeds block size, so simple 1 cycle delay before stop is not enough */
1507
1508                         /* we need to capture the audio that is still somewhere in the pipeline between
1509                            wherever it was generated and the process callback. This means that even though
1510                            the user (or something else)  has asked us to stop, we have to roll
1511                            past this point and then reset the playhead/transport location to
1512                            the position at which the stop was requested.
1513
1514                            we still need playback to "stop" now, however, which is why we schedule
1515                            a declick below.
1516                         */
1517
1518                         DEBUG_TRACE (DEBUG::Transport, string_compose ("stop transport requested @ %1, scheduled for + %2 = %3, abort = %4\n",
1519                                                                        _transport_frame, _worst_input_latency,
1520                                                                        _transport_frame + _worst_input_latency,
1521                                                                        abort));
1522
1523                         SessionEvent *ev = new SessionEvent (SessionEvent::StopOnce, SessionEvent::Replace,
1524                                                              _transport_frame + _worst_input_latency,
1525                                                              0, 0, abort);
1526
1527                         merge_event (ev);
1528
1529                         /* request a declick at the start of the next process cycle() so that playback ceases.
1530                            It will remain silent until we actually stop (at the StopOnce event somewhere in
1531                            the future). The extra flag (StopPendingCapture) is set to ensure that check_declick_out()
1532                            does not stop the transport too early.
1533                          */
1534                         new_bits = SubState (PendingDeclickOut|StopPendingCapture);
1535
1536                 } else {
1537
1538                         /* Not recording, schedule a declick in the next process() cycle and then stop at its end */
1539
1540                         new_bits = PendingDeclickOut;
1541                         DEBUG_TRACE (DEBUG::Transport, string_compose ("stop scheduled for next process cycle @ %1\n", _transport_frame));
1542                 }
1543
1544                 /* we'll be called again after the declick */
1545                 transport_sub_state = SubState (transport_sub_state|new_bits);
1546                 pending_abort = abort;
1547
1548                 return;
1549
1550         } else {
1551
1552                 DEBUG_TRACE (DEBUG::Transport, "time to actually stop\n");
1553
1554                 /* declick was scheduled, but we've been called again, which means it is really time to stop
1555
1556                    XXX: we should probably split this off into its own method and call it explicitly.
1557                 */
1558
1559                 realtime_stop (abort, clear_state);
1560                 _butler->schedule_transport_work ();
1561         }
1562 }
1563
1564 /** Called from the process thread */
1565 void
1566 Session::start_transport ()
1567 {
1568         DEBUG_TRACE (DEBUG::Transport, "start_transport\n");
1569
1570         _last_roll_location = _transport_frame;
1571         _last_roll_or_reversal_location = _transport_frame;
1572
1573         have_looped = false;
1574
1575         /* if record status is Enabled, move it to Recording. if its
1576            already Recording, move it to Disabled.
1577         */
1578
1579         switch (record_status()) {
1580         case Enabled:
1581                 if (!config.get_punch_in()) {
1582                         enable_record ();
1583                 }
1584                 break;
1585
1586         case Recording:
1587                 if (!play_loop) {
1588                         disable_record (false);
1589                 }
1590                 break;
1591
1592         default:
1593                 break;
1594         }
1595
1596         transport_sub_state |= PendingDeclickIn;
1597
1598         _transport_speed = _default_transport_speed;
1599         _target_transport_speed = _transport_speed;
1600
1601         boost::shared_ptr<RouteList> rl = routes.reader();
1602         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1603                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1604                 if (tr) {
1605                         tr->realtime_set_speed (tr->speed(), true);
1606                 }
1607         }
1608
1609         if (!_engine.freewheeling()) {
1610                 Timecode::Time time;
1611                 timecode_time_subframes (_transport_frame, time);
1612                 if (!dynamic_cast<MTC_Slave*>(_slave)) {
1613                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
1614                 }
1615         }
1616
1617         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC4 with speed = %1\n", _transport_speed));
1618         TransportStateChange (); /* EMIT SIGNAL */
1619 }
1620
1621 /** Do any transport work in the audio thread that needs to be done after the
1622  * transport thread is finished.  Audio thread, realtime safe.
1623  */
1624 void
1625 Session::post_transport ()
1626 {
1627         PostTransportWork ptw = post_transport_work ();
1628
1629         if (ptw & PostTransportAudition) {
1630                 if (auditioner && auditioner->auditioning()) {
1631                         process_function = &Session::process_audition;
1632                 } else {
1633                         process_function = &Session::process_with_events;
1634                 }
1635         }
1636
1637         if (ptw & PostTransportStop) {
1638
1639                 transport_sub_state = 0;
1640         }
1641
1642         if (ptw & PostTransportLocate) {
1643
1644                 if (((!config.get_external_sync() && (auto_play_legal && config.get_auto_play())) && !_exporting) || (ptw & PostTransportRoll)) {
1645                         start_transport ();
1646                 } else {
1647                         transport_sub_state = 0;
1648                 }
1649         }
1650
1651         set_next_event ();
1652         /* XXX is this really safe? shouldn't we just be unsetting the bits that we actually
1653            know were handled ?
1654         */
1655         set_post_transport_work (PostTransportWork (0));
1656 }
1657
1658 void
1659 Session::reset_rf_scale (framecnt_t motion)
1660 {
1661         cumulative_rf_motion += motion;
1662
1663         if (cumulative_rf_motion < 4 * _current_frame_rate) {
1664                 rf_scale = 1;
1665         } else if (cumulative_rf_motion < 8 * _current_frame_rate) {
1666                 rf_scale = 4;
1667         } else if (cumulative_rf_motion < 16 * _current_frame_rate) {
1668                 rf_scale = 10;
1669         } else {
1670                 rf_scale = 100;
1671         }
1672
1673         if (motion != 0) {
1674                 set_dirty();
1675         }
1676 }
1677
1678 void
1679 Session::mtc_status_changed (bool yn)
1680 {
1681         g_atomic_int_set (&_mtc_active, yn);
1682         MTCSyncStateChanged( yn );
1683 }
1684
1685 void
1686 Session::ltc_status_changed (bool yn)
1687 {
1688         g_atomic_int_set (&_ltc_active, yn);
1689         LTCSyncStateChanged( yn );
1690 }
1691
1692 void
1693 Session::use_sync_source (Slave* new_slave)
1694 {
1695         /* Runs in process() context */
1696
1697         bool non_rt_required = false;
1698
1699         /* XXX this deletion is problematic because we're in RT context */
1700
1701         delete _slave;
1702         _slave = new_slave;
1703
1704         MTC_Slave* mtc_slave = dynamic_cast<MTC_Slave*>(_slave);
1705         if (mtc_slave) {
1706                 mtc_slave->ActiveChanged.connect_same_thread (mtc_status_connection, boost::bind (&Session::mtc_status_changed, this, _1));
1707                 MTCSyncStateChanged(mtc_slave->locked() );
1708         } else {
1709                 if (g_atomic_int_get (&_mtc_active) ){
1710                         g_atomic_int_set (&_mtc_active, 0);
1711                         MTCSyncStateChanged( false );
1712                 }
1713                 mtc_status_connection.disconnect ();
1714         }
1715
1716         LTC_Slave* ltc_slave = dynamic_cast<LTC_Slave*> (_slave);
1717         if (ltc_slave) {
1718                 ltc_slave->ActiveChanged.connect_same_thread (ltc_status_connection, boost::bind (&Session::ltc_status_changed, this, _1));
1719                 LTCSyncStateChanged (ltc_slave->locked() );
1720         } else {
1721                 if (g_atomic_int_get (&_ltc_active) ){
1722                         g_atomic_int_set (&_ltc_active, 0);
1723                         LTCSyncStateChanged( false );
1724                 }
1725                 ltc_status_connection.disconnect ();
1726         }
1727
1728         DEBUG_TRACE (DEBUG::Slave, string_compose ("set new slave to %1\n", _slave));
1729
1730         // need to queue this for next process() cycle
1731         _send_timecode_update = true;
1732
1733         boost::shared_ptr<RouteList> rl = routes.reader();
1734         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1735                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1736                 if (tr && !tr->hidden()) {
1737                         if (tr->realtime_set_speed (tr->speed(), true)) {
1738                                 non_rt_required = true;
1739                         }
1740                         tr->set_slaved (_slave != 0);
1741                 }
1742         }
1743
1744         if (non_rt_required) {
1745                 add_post_transport_work (PostTransportSpeed);
1746                 _butler->schedule_transport_work ();
1747         }
1748
1749         set_dirty();
1750 }
1751
1752 void
1753 Session::drop_sync_source ()
1754 {
1755         request_sync_source (0);
1756 }
1757
1758 void
1759 Session::switch_to_sync_source (SyncSource src)
1760 {
1761         Slave* new_slave;
1762
1763         DEBUG_TRACE (DEBUG::Slave, string_compose ("Setting up sync source %1\n", enum_2_string (src)));
1764
1765         switch (src) {
1766         case MTC:
1767                 if (_slave && dynamic_cast<MTC_Slave*>(_slave)) {
1768                         return;
1769                 }
1770
1771                 try {
1772                         new_slave = new MTC_Slave (*this, *_midi_ports->mtc_input_port());
1773                 }
1774
1775                 catch (failed_constructor& err) {
1776                         return;
1777                 }
1778                 break;
1779
1780         case LTC:
1781                 if (_slave && dynamic_cast<LTC_Slave*>(_slave)) {
1782                         return;
1783                 }
1784
1785                 try {
1786                         new_slave = new LTC_Slave (*this);
1787                 }
1788
1789                 catch (failed_constructor& err) {
1790                         return;
1791                 }
1792
1793                 break;
1794
1795         case MIDIClock:
1796                 if (_slave && dynamic_cast<MIDIClock_Slave*>(_slave)) {
1797                         return;
1798                 }
1799
1800                 try {
1801                         new_slave = new MIDIClock_Slave (*this, *_midi_ports->midi_clock_input_port(), 24);
1802                 }
1803
1804                 catch (failed_constructor& err) {
1805                         return;
1806                 }
1807                 break;
1808
1809         case Engine:
1810                 if (_slave && dynamic_cast<Engine_Slave*>(_slave)) {
1811                         return;
1812                 }
1813
1814                 if (config.get_video_pullup() != 0.0f) {
1815                         return;
1816                 }
1817
1818                 new_slave = new Engine_Slave (*AudioEngine::instance());
1819                 break;
1820
1821         default:
1822                 new_slave = 0;
1823                 break;
1824         };
1825
1826         request_sync_source (new_slave);
1827 }
1828
1829 void
1830 Session::set_track_speed (Track* track, double speed)
1831 {
1832         if (track->realtime_set_speed (speed, false)) {
1833                 add_post_transport_work (PostTransportSpeed);
1834                 _butler->schedule_transport_work ();
1835                 set_dirty ();
1836         }
1837 }
1838
1839 void
1840 Session::unset_play_range ()
1841 {
1842         _play_range = false;
1843         _clear_event_type (SessionEvent::RangeStop);
1844         _clear_event_type (SessionEvent::RangeLocate);
1845 }
1846
1847 void
1848 Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
1849 {
1850         SessionEvent* ev;
1851
1852         /* Called from event-processing context */
1853
1854         unset_play_range ();
1855
1856         if (range.empty()) {
1857                 /* _play_range set to false in unset_play_range()
1858                  */
1859                 if (!leave_rolling) {
1860                         /* stop transport */
1861                         SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0f, false);
1862                         merge_event (ev);
1863                 }
1864                 return;
1865         }
1866
1867         _play_range = true;
1868
1869         /* cancel loop play */
1870         unset_play_loop ();
1871
1872         list<AudioRange>::size_type sz = range.size();
1873
1874         if (sz > 1) {
1875
1876                 list<AudioRange>::iterator i = range.begin();
1877                 list<AudioRange>::iterator next;
1878
1879                 while (i != range.end()) {
1880
1881                         next = i;
1882                         ++next;
1883
1884                         /* locating/stopping is subject to delays for declicking.
1885                          */
1886
1887                         framepos_t requested_frame = i->end;
1888
1889                         if (requested_frame > current_block_size) {
1890                                 requested_frame -= current_block_size;
1891                         } else {
1892                                 requested_frame = 0;
1893                         }
1894
1895                         if (next == range.end()) {
1896                                 ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, requested_frame, 0, 0.0f);
1897                         } else {
1898                                 ev = new SessionEvent (SessionEvent::RangeLocate, SessionEvent::Add, requested_frame, (*next).start, 0.0f);
1899                         }
1900
1901                         merge_event (ev);
1902
1903                         i = next;
1904                 }
1905
1906         } else if (sz == 1) {
1907
1908                 ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, range.front().end, 0, 0.0f);
1909                 merge_event (ev);
1910
1911         }
1912
1913         /* save range so we can do auto-return etc. */
1914
1915         current_audio_range = range;
1916
1917         /* now start rolling at the right place */
1918
1919         ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, SessionEvent::Immediate, range.front().start, 0.0f, false);
1920         merge_event (ev);
1921
1922         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC5 with speed = %1\n", _transport_speed));
1923         TransportStateChange ();
1924 }
1925
1926 void
1927 Session::request_bounded_roll (framepos_t start, framepos_t end)
1928 {
1929         AudioRange ar (start, end, 0);
1930         list<AudioRange> lar;
1931
1932         lar.push_back (ar);
1933         request_play_range (&lar, true);
1934 }
1935
1936 void
1937 Session::set_requested_return_frame (framepos_t return_to)
1938 {
1939         _requested_return_frame = return_to;
1940 }
1941
1942 void
1943 Session::request_roll_at_and_return (framepos_t start, framepos_t return_to)
1944 {
1945         SessionEvent *ev = new SessionEvent (SessionEvent::LocateRollLocate, SessionEvent::Add, SessionEvent::Immediate, return_to, 1.0);
1946         ev->target2_frame = start;
1947         queue_event (ev);
1948 }
1949
1950 void
1951 Session::engine_halted ()
1952 {
1953         bool ignored;
1954
1955         /* there will be no more calls to process(), so
1956            we'd better clean up for ourselves, right now.
1957
1958            but first, make sure the butler is out of
1959            the picture.
1960         */
1961
1962         if (_butler) {
1963                 _butler->stop ();
1964         }
1965
1966         realtime_stop (false, true);
1967         non_realtime_stop (false, 0, ignored);
1968         transport_sub_state = 0;
1969
1970         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC6 with speed = %1\n", _transport_speed));
1971         TransportStateChange (); /* EMIT SIGNAL */
1972 }
1973
1974
1975 void
1976 Session::xrun_recovery ()
1977 {
1978         ++_xrun_count;
1979
1980         Xrun (_transport_frame); /* EMIT SIGNAL */
1981
1982         if (Config->get_stop_recording_on_xrun() && actively_recording()) {
1983
1984                 /* it didn't actually halt, but we need
1985                    to handle things in the same way.
1986                 */
1987
1988                 engine_halted();
1989         }
1990 }
1991
1992 void
1993 Session::route_processors_changed (RouteProcessorChange c)
1994 {
1995         if (g_atomic_int_get (&_ignore_route_processor_changes) > 0) {
1996                 return;
1997         }
1998
1999         if (c.type == RouteProcessorChange::MeterPointChange) {
2000                 set_dirty ();
2001                 return;
2002         }
2003
2004         if (c.type == RouteProcessorChange::RealTimeChange) {
2005                 set_dirty ();
2006                 return;
2007         }
2008
2009         update_latency_compensation ();
2010         resort_routes ();
2011
2012         set_dirty ();
2013 }
2014
2015 void
2016 Session::allow_auto_play (bool yn)
2017 {
2018         auto_play_legal = yn;
2019 }
2020
2021 bool
2022 Session::maybe_stop (framepos_t limit)
2023 {
2024         if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
2025                 if (synced_to_engine () && config.get_jack_time_master ()) {
2026                         _engine.transport_stop ();
2027                 } else if (!synced_to_engine ()) {
2028                         stop_transport ();
2029                 }
2030                 return true;
2031         }
2032         return false;
2033 }
2034
2035 void
2036 Session::send_mmc_locate (framepos_t t)
2037 {
2038         if (t < 0) {
2039                 return;
2040         }
2041
2042         if (!_engine.freewheeling()) {
2043                 Timecode::Time time;
2044                 timecode_time_subframes (t, time);
2045                 send_immediate_mmc (MIDI::MachineControlCommand (time));
2046         }
2047 }
2048
2049 /** Ask the transport to not send timecode until further notice.  The suspension
2050  *  will come into effect some finite time after this call, and timecode_transmission_suspended()
2051  *  should be checked by the caller to find out when.
2052  */
2053 void
2054 Session::request_suspend_timecode_transmission ()
2055 {
2056         SessionEvent* ev = new SessionEvent (SessionEvent::SetTimecodeTransmission, SessionEvent::Add, SessionEvent::Immediate, 0, 0, false);
2057         queue_event (ev);
2058 }
2059
2060 void
2061 Session::request_resume_timecode_transmission ()
2062 {
2063         SessionEvent* ev = new SessionEvent (SessionEvent::SetTimecodeTransmission, SessionEvent::Add, SessionEvent::Immediate, 0, 0, true);
2064         queue_event (ev);
2065 }
2066
2067 bool
2068 Session::timecode_transmission_suspended () const
2069 {
2070         return g_atomic_int_get (&_suspend_timecode_transmission) == 1;
2071 }