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 "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         // [DR] FIXME: find out exactly where this should go below
1160         _transport_frame = target_frame;
1161         _last_roll_or_reversal_location = target_frame;
1162         timecode_time(_transport_frame, transmitting_timecode_time);
1163         outbound_mtc_timecode_frame = _transport_frame;
1164         next_quarter_frame_to_send = 0;
1165
1166         /* do "stopped" stuff if:
1167          *
1168          * we are rolling AND
1169          *    no autoplay in effect AND
1170          *       we're not going to keep rolling after the locate AND
1171          *           !(playing a loop with JACK sync)
1172          *
1173          */
1174
1175         bool transport_was_stopped = !transport_rolling();
1176
1177         if (!transport_was_stopped && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_engine() && play_loop) &&
1178             (!Profile->get_trx() || !(config.get_external_sync() && !synced_to_engine()))) {
1179                 realtime_stop (false, true); // XXX paul - check if the 2nd arg is really correct
1180                 transport_was_stopped = true;
1181         } else {
1182                 /* otherwise tell the world that we located */
1183                 realtime_locate ();
1184         }
1185
1186         if (force || !for_loop_enabled || loop_changing) {
1187
1188                 PostTransportWork todo = PostTransportLocate;
1189
1190                 if (with_roll && transport_was_stopped) {
1191                         todo = PostTransportWork (todo | PostTransportRoll);
1192                 }
1193
1194                 add_post_transport_work (todo);
1195                 need_butler = true;
1196
1197         } else {
1198
1199                 /* this is functionally what clear_clicks() does but with a tentative lock */
1200
1201                 Glib::Threads::RWLock::WriterLock clickm (click_lock, Glib::Threads::TRY_LOCK);
1202
1203                 if (clickm.locked()) {
1204
1205                         for (Clicks::iterator i = clicks.begin(); i != clicks.end(); ++i) {
1206                                 delete *i;
1207                         }
1208
1209                         clicks.clear ();
1210                 }
1211         }
1212
1213         if (with_roll) {
1214                 /* switch from input if we're going to roll */
1215                 if (Config->get_monitoring_model() == HardwareMonitoring) {
1216                         set_track_monitor_input_status (!config.get_auto_input());
1217                 }
1218         } else {
1219                 /* otherwise we're going to stop, so do the opposite */
1220                 if (Config->get_monitoring_model() == HardwareMonitoring) {
1221                         set_track_monitor_input_status (true);
1222                 }
1223         }
1224
1225         /* cancel looped playback if transport pos outside of loop range */
1226         if (play_loop) {
1227
1228                 Location* al = _locations->auto_loop_location();
1229
1230                 if (al) {
1231                         if (_transport_frame < al->start() || _transport_frame >= al->end()) {
1232
1233                                 // located outside the loop: cancel looping directly, this is called from event handling context
1234
1235                                 have_looped = false;
1236
1237                                 if (!Config->get_loop_is_mode()) {
1238                                         set_play_loop (false, _transport_speed);
1239                                 } else {
1240                                         if (Config->get_seamless_loop()) {
1241                                                 /* this will make the non_realtime_locate() in the butler
1242                                                    which then causes seek() in tracks actually do the right
1243                                                    thing.
1244                                                 */
1245                                                 set_track_loop (false);
1246                                         }
1247                                 }
1248
1249                         } else if (_transport_frame == al->start()) {
1250
1251                                 // located to start of loop - this is looping, basically
1252
1253                                 if (!have_looped) {
1254                                         /* first time */
1255                                         if (_last_roll_location != al->start()) {
1256                                                 /* didn't start at loop start - playback must have
1257                                                  * started before loop since we've now hit the loop
1258                                                  * end.
1259                                                  */
1260                                                 add_post_transport_work (PostTransportLocate);
1261                                                 need_butler = true;
1262                                         }
1263
1264                                 }
1265
1266                                 boost::shared_ptr<RouteList> rl = routes.reader();
1267
1268                                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1269                                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1270
1271                                         if (tr && tr->record_enabled ()) {
1272                                                 // tell it we've looped, so it can deal with the record state
1273                                                 tr->transport_looped (_transport_frame);
1274                                         }
1275                                 }
1276
1277                                 have_looped = true;
1278                                 TransportLooped(); // EMIT SIGNAL
1279                         }
1280                 }
1281         }
1282
1283         if (need_butler) {
1284                 _butler->schedule_transport_work ();
1285         }
1286
1287         loop_changing = false;
1288
1289         _send_timecode_update = true;
1290
1291         if (with_mmc) {
1292                 send_mmc_locate (_transport_frame);
1293         }
1294
1295         _last_roll_location = _last_roll_or_reversal_location =  _transport_frame;
1296         Located (); /* EMIT SIGNAL */
1297 }
1298
1299 /** Set the transport speed.
1300  *  Called from the process thread.
1301  *  @param speed New speed
1302  */
1303 void
1304 Session::set_transport_speed (double speed, framepos_t destination_frame, bool abort, bool clear_state, bool as_default)
1305 {
1306         DEBUG_TRACE (DEBUG::Transport, string_compose ("@ %5 Set transport speed to %1, abort = %2 clear_state = %3, current = %4 as_default %6\n",
1307                                                        speed, abort, clear_state, _transport_speed, _transport_frame, as_default));
1308
1309         if (_transport_speed == speed) {
1310                 if (as_default && speed == 0.0) { // => reset default transport speed. hacky or what?
1311                         _default_transport_speed = 1.0;
1312                 }
1313                 return;
1314         }
1315
1316         if (actively_recording() && speed != 1.0 && speed != 0.0) {
1317                 /* no varispeed during recording */
1318                 DEBUG_TRACE (DEBUG::Transport, string_compose ("No varispeed during recording cur_speed %1, frame %2\n",
1319                                                        _transport_speed, _transport_frame));
1320                 return;
1321         }
1322
1323         _target_transport_speed = fabs(speed);
1324
1325         /* 8.0 max speed is somewhat arbitrary but based on guestimates regarding disk i/o capability
1326            and user needs. We really need CD-style "skip" playback for ffwd and rewind.
1327         */
1328
1329         if (speed > 0) {
1330                 speed = min (8.0, speed);
1331         } else if (speed < 0) {
1332                 speed = max (-8.0, speed);
1333         }
1334
1335         if (transport_rolling() && speed == 0.0) {
1336
1337                 /* we are rolling and we want to stop */
1338
1339                 if (Config->get_monitoring_model() == HardwareMonitoring) {
1340                         set_track_monitor_input_status (true);
1341                 }
1342
1343                 if (synced_to_engine ()) {
1344                         if (clear_state) {
1345                                 /* do this here because our response to the slave won't
1346                                    take care of it.
1347                                 */
1348                                 _play_range = false;
1349                                 unset_play_loop ();
1350                         }
1351                         _engine.transport_stop ();
1352                 } else {
1353                         bool const auto_return_enabled = (!config.get_external_sync() && (Config->get_auto_return_target_list() || abort));
1354
1355                         if (!auto_return_enabled) {
1356                                 _requested_return_frame = destination_frame;
1357                         }
1358
1359                         stop_transport (abort);
1360                 }
1361
1362         } else if (transport_stopped() && speed == 1.0) {
1363                 if (as_default) {
1364                         _default_transport_speed = speed;
1365                 }
1366                 /* we are stopped and we want to start rolling at speed 1 */
1367
1368                 if (Config->get_loop_is_mode() && play_loop) {
1369
1370                         Location *location = _locations->auto_loop_location();
1371
1372                         if (location != 0) {
1373                                 if (_transport_frame != location->start()) {
1374
1375                                         if (Config->get_seamless_loop()) {
1376                                                 /* force tracks to do their thing */
1377                                                 set_track_loop (true);
1378                                         }
1379
1380                                         /* jump to start and then roll from there */
1381
1382                                         request_locate (location->start(), true);
1383                                         return;
1384                                 }
1385                         }
1386                 }
1387
1388                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1389                         set_track_monitor_input_status (false);
1390                 }
1391
1392                 if (synced_to_engine()) {
1393                         _engine.transport_start ();
1394                 } else {
1395                         start_transport ();
1396                 }
1397
1398         } else {
1399
1400                 /* not zero, not 1.0 ... varispeed */
1401
1402                 if ((synced_to_engine()) && speed != 0.0 && speed != 1.0) {
1403                         warning << string_compose (
1404                                 _("Global varispeed cannot be supported while %1 is connected to JACK transport control"),
1405                                 PROGRAM_NAME)
1406                                 << endmsg;
1407                         return;
1408                 }
1409
1410                 if (actively_recording()) {
1411                         return;
1412                 }
1413
1414                 if (speed > 0.0 && _transport_frame == current_end_frame()) {
1415                         return;
1416                 }
1417
1418                 if (speed < 0.0 && _transport_frame == 0) {
1419                         return;
1420                 }
1421
1422                 clear_clicks ();
1423
1424                 /* if we are reversing relative to the current speed, or relative to the speed
1425                    before the last stop, then we have to do extra work.
1426                 */
1427
1428                 PostTransportWork todo = PostTransportWork (0);
1429
1430                 if ((_transport_speed && speed * _transport_speed < 0.0) || (_last_transport_speed * speed < 0.0) || (_last_transport_speed == 0.0 && speed < 0.0)) {
1431                         todo = PostTransportWork (todo | PostTransportReverse);
1432                         _last_roll_or_reversal_location = _transport_frame;
1433                 }
1434
1435                 _last_transport_speed = _transport_speed;
1436                 _transport_speed = speed;
1437
1438                 if (as_default) {
1439                         _default_transport_speed = speed;
1440                 }
1441
1442                 boost::shared_ptr<RouteList> rl = routes.reader();
1443                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1444                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1445                         if (tr && tr->realtime_set_speed (tr->speed(), true)) {
1446                                 todo = PostTransportWork (todo | PostTransportSpeed);
1447                         }
1448                 }
1449
1450                 if (todo) {
1451                         add_post_transport_work (todo);
1452                         _butler->schedule_transport_work ();
1453                 }
1454
1455                 DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC3 with speed = %1\n", _transport_speed));
1456
1457                 /* throttle signal emissions.
1458                  * when slaved [_last]_transport_speed
1459                  * usually changes every cycle (tiny amounts due to DLL).
1460                  * Emitting a signal every cycle is overkill and unwarranted.
1461                  *
1462                  * Using _last_transport_speed is not acceptable,
1463                  * since it allows for large changes over a long period
1464                  * of time. Hence we introduce a dedicated variable to keep track
1465                  *
1466                  * The 0.2% dead-zone is somewhat arbitrary. Main use-case
1467                  * for TransportStateChange() here is the ShuttleControl display.
1468                  */
1469                 if (fabs (_signalled_varispeed - speed) > .002
1470                     // still, signal hard changes to 1.0 and 0.0:
1471                     || ( speed == 1.0 && _signalled_varispeed != 1.0)
1472                     || ( speed == 0.0 && _signalled_varispeed != 0.0)
1473                    )
1474                 {
1475                         TransportStateChange (); /* EMIT SIGNAL */
1476                         _signalled_varispeed = speed;
1477                 }
1478         }
1479 }
1480
1481
1482 /** Stop the transport.  */
1483 void
1484 Session::stop_transport (bool abort, bool clear_state)
1485 {
1486         if (_transport_speed == 0.0f) {
1487                 return;
1488         }
1489
1490         DEBUG_TRACE (DEBUG::Transport, string_compose ("stop_transport, declick required? %1\n", get_transport_declick_required()));
1491
1492         if (!get_transport_declick_required()) {
1493
1494                 /* stop has not yet been scheduled */
1495
1496                 boost::shared_ptr<RouteList> rl = routes.reader();
1497                 framepos_t stop_target = audible_frame();
1498
1499                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1500                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1501                         if (tr) {
1502                                 tr->prepare_to_stop (_transport_frame, stop_target);
1503                         }
1504                 }
1505
1506                 SubState new_bits;
1507
1508                 if (actively_recording() &&                           /* we are recording */
1509                     worst_input_latency() > current_block_size) {     /* input latency exceeds block size, so simple 1 cycle delay before stop is not enough */
1510
1511                         /* we need to capture the audio that is still somewhere in the pipeline between
1512                            wherever it was generated and the process callback. This means that even though
1513                            the user (or something else)  has asked us to stop, we have to roll
1514                            past this point and then reset the playhead/transport location to
1515                            the position at which the stop was requested.
1516
1517                            we still need playback to "stop" now, however, which is why we schedule
1518                            a declick below.
1519                         */
1520
1521                         DEBUG_TRACE (DEBUG::Transport, string_compose ("stop transport requested @ %1, scheduled for + %2 = %3, abort = %4\n",
1522                                                                        _transport_frame, _worst_input_latency,
1523                                                                        _transport_frame + _worst_input_latency,
1524                                                                        abort));
1525
1526                         SessionEvent *ev = new SessionEvent (SessionEvent::StopOnce, SessionEvent::Replace,
1527                                                              _transport_frame + _worst_input_latency,
1528                                                              0, 0, abort);
1529
1530                         merge_event (ev);
1531
1532                         /* request a declick at the start of the next process cycle() so that playback ceases.
1533                            It will remain silent until we actually stop (at the StopOnce event somewhere in
1534                            the future). The extra flag (StopPendingCapture) is set to ensure that check_declick_out()
1535                            does not stop the transport too early.
1536                          */
1537                         new_bits = SubState (PendingDeclickOut|StopPendingCapture);
1538
1539                 } else {
1540
1541                         /* Not recording, schedule a declick in the next process() cycle and then stop at its end */
1542
1543                         new_bits = PendingDeclickOut;
1544                         DEBUG_TRACE (DEBUG::Transport, string_compose ("stop scheduled for next process cycle @ %1\n", _transport_frame));
1545                 }
1546
1547                 /* we'll be called again after the declick */
1548                 transport_sub_state = SubState (transport_sub_state|new_bits);
1549                 pending_abort = abort;
1550
1551                 return;
1552
1553         } else {
1554
1555                 DEBUG_TRACE (DEBUG::Transport, "time to actually stop\n");
1556
1557                 /* declick was scheduled, but we've been called again, which means it is really time to stop
1558
1559                    XXX: we should probably split this off into its own method and call it explicitly.
1560                 */
1561
1562                 realtime_stop (abort, clear_state);
1563                 _butler->schedule_transport_work ();
1564         }
1565 }
1566
1567 /** Called from the process thread */
1568 void
1569 Session::start_transport ()
1570 {
1571         DEBUG_TRACE (DEBUG::Transport, "start_transport\n");
1572
1573         _last_roll_location = _transport_frame;
1574         _last_roll_or_reversal_location = _transport_frame;
1575
1576         have_looped = false;
1577
1578         /* if record status is Enabled, move it to Recording. if its
1579            already Recording, move it to Disabled.
1580         */
1581
1582         switch (record_status()) {
1583         case Enabled:
1584                 if (!config.get_punch_in()) {
1585                         enable_record ();
1586                 }
1587                 break;
1588
1589         case Recording:
1590                 if (!play_loop) {
1591                         disable_record (false);
1592                 }
1593                 break;
1594
1595         default:
1596                 break;
1597         }
1598
1599         transport_sub_state |= PendingDeclickIn;
1600
1601         _transport_speed = _default_transport_speed;
1602         _target_transport_speed = _transport_speed;
1603
1604         boost::shared_ptr<RouteList> rl = routes.reader();
1605         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1606                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1607                 if (tr) {
1608                         tr->realtime_set_speed (tr->speed(), true);
1609                 }
1610         }
1611
1612         if (!_engine.freewheeling()) {
1613                 Timecode::Time time;
1614                 timecode_time_subframes (_transport_frame, time);
1615                 if (!dynamic_cast<MTC_Slave*>(_slave)) {
1616                         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
1617                 }
1618         }
1619
1620         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC4 with speed = %1\n", _transport_speed));
1621         TransportStateChange (); /* EMIT SIGNAL */
1622 }
1623
1624 /** Do any transport work in the audio thread that needs to be done after the
1625  * transport thread is finished.  Audio thread, realtime safe.
1626  */
1627 void
1628 Session::post_transport ()
1629 {
1630         PostTransportWork ptw = post_transport_work ();
1631
1632         if (ptw & PostTransportAudition) {
1633                 if (auditioner && auditioner->auditioning()) {
1634                         process_function = &Session::process_audition;
1635                 } else {
1636                         process_function = &Session::process_with_events;
1637                 }
1638         }
1639
1640         if (ptw & PostTransportStop) {
1641
1642                 transport_sub_state = 0;
1643         }
1644
1645         if (ptw & PostTransportLocate) {
1646
1647                 if (((!config.get_external_sync() && (auto_play_legal && config.get_auto_play())) && !_exporting) || (ptw & PostTransportRoll)) {
1648                         start_transport ();
1649                 } else {
1650                         transport_sub_state = 0;
1651                 }
1652         }
1653
1654         set_next_event ();
1655         /* XXX is this really safe? shouldn't we just be unsetting the bits that we actually
1656            know were handled ?
1657         */
1658         set_post_transport_work (PostTransportWork (0));
1659 }
1660
1661 void
1662 Session::reset_rf_scale (framecnt_t motion)
1663 {
1664         cumulative_rf_motion += motion;
1665
1666         if (cumulative_rf_motion < 4 * _current_frame_rate) {
1667                 rf_scale = 1;
1668         } else if (cumulative_rf_motion < 8 * _current_frame_rate) {
1669                 rf_scale = 4;
1670         } else if (cumulative_rf_motion < 16 * _current_frame_rate) {
1671                 rf_scale = 10;
1672         } else {
1673                 rf_scale = 100;
1674         }
1675
1676         if (motion != 0) {
1677                 set_dirty();
1678         }
1679 }
1680
1681 void
1682 Session::mtc_status_changed (bool yn)
1683 {
1684         g_atomic_int_set (&_mtc_active, yn);
1685         MTCSyncStateChanged( yn );
1686 }
1687
1688 void
1689 Session::ltc_status_changed (bool yn)
1690 {
1691         g_atomic_int_set (&_ltc_active, yn);
1692         LTCSyncStateChanged( yn );
1693 }
1694
1695 void
1696 Session::use_sync_source (Slave* new_slave)
1697 {
1698         /* Runs in process() context */
1699
1700         bool non_rt_required = false;
1701
1702         /* XXX this deletion is problematic because we're in RT context */
1703
1704         delete _slave;
1705         _slave = new_slave;
1706
1707         MTC_Slave* mtc_slave = dynamic_cast<MTC_Slave*>(_slave);
1708         if (mtc_slave) {
1709                 mtc_slave->ActiveChanged.connect_same_thread (mtc_status_connection, boost::bind (&Session::mtc_status_changed, this, _1));
1710                 MTCSyncStateChanged(mtc_slave->locked() );
1711         } else {
1712                 if (g_atomic_int_get (&_mtc_active) ){
1713                         g_atomic_int_set (&_mtc_active, 0);
1714                         MTCSyncStateChanged( false );
1715                 }
1716                 mtc_status_connection.disconnect ();
1717         }
1718
1719         LTC_Slave* ltc_slave = dynamic_cast<LTC_Slave*> (_slave);
1720         if (ltc_slave) {
1721                 ltc_slave->ActiveChanged.connect_same_thread (ltc_status_connection, boost::bind (&Session::ltc_status_changed, this, _1));
1722                 LTCSyncStateChanged (ltc_slave->locked() );
1723         } else {
1724                 if (g_atomic_int_get (&_ltc_active) ){
1725                         g_atomic_int_set (&_ltc_active, 0);
1726                         LTCSyncStateChanged( false );
1727                 }
1728                 ltc_status_connection.disconnect ();
1729         }
1730
1731         DEBUG_TRACE (DEBUG::Slave, string_compose ("set new slave to %1\n", _slave));
1732
1733         // need to queue this for next process() cycle
1734         _send_timecode_update = true;
1735
1736         boost::shared_ptr<RouteList> rl = routes.reader();
1737         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1738                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1739                 if (tr && !tr->hidden()) {
1740                         if (tr->realtime_set_speed (tr->speed(), true)) {
1741                                 non_rt_required = true;
1742                         }
1743                         tr->set_slaved (_slave != 0);
1744                 }
1745         }
1746
1747         if (non_rt_required) {
1748                 add_post_transport_work (PostTransportSpeed);
1749                 _butler->schedule_transport_work ();
1750         }
1751
1752         set_dirty();
1753 }
1754
1755 void
1756 Session::drop_sync_source ()
1757 {
1758         request_sync_source (0);
1759 }
1760
1761 void
1762 Session::switch_to_sync_source (SyncSource src)
1763 {
1764         Slave* new_slave;
1765
1766         DEBUG_TRACE (DEBUG::Slave, string_compose ("Setting up sync source %1\n", enum_2_string (src)));
1767
1768         switch (src) {
1769         case MTC:
1770                 if (_slave && dynamic_cast<MTC_Slave*>(_slave)) {
1771                         return;
1772                 }
1773
1774                 try {
1775                         new_slave = new MTC_Slave (*this, *_midi_ports->mtc_input_port());
1776                 }
1777
1778                 catch (failed_constructor& err) {
1779                         return;
1780                 }
1781                 break;
1782
1783         case LTC:
1784                 if (_slave && dynamic_cast<LTC_Slave*>(_slave)) {
1785                         return;
1786                 }
1787
1788                 try {
1789                         new_slave = new LTC_Slave (*this);
1790                 }
1791
1792                 catch (failed_constructor& err) {
1793                         return;
1794                 }
1795
1796                 break;
1797
1798         case MIDIClock:
1799                 if (_slave && dynamic_cast<MIDIClock_Slave*>(_slave)) {
1800                         return;
1801                 }
1802
1803                 try {
1804                         new_slave = new MIDIClock_Slave (*this, *_midi_ports->midi_clock_input_port(), 24);
1805                 }
1806
1807                 catch (failed_constructor& err) {
1808                         return;
1809                 }
1810                 break;
1811
1812         case Engine:
1813                 if (_slave && dynamic_cast<Engine_Slave*>(_slave)) {
1814                         return;
1815                 }
1816
1817                 if (config.get_video_pullup() != 0.0f) {
1818                         return;
1819                 }
1820
1821                 new_slave = new Engine_Slave (*AudioEngine::instance());
1822                 break;
1823
1824         default:
1825                 new_slave = 0;
1826                 break;
1827         };
1828
1829         request_sync_source (new_slave);
1830 }
1831
1832 void
1833 Session::set_track_speed (Track* track, double speed)
1834 {
1835         if (track->realtime_set_speed (speed, false)) {
1836                 add_post_transport_work (PostTransportSpeed);
1837                 _butler->schedule_transport_work ();
1838                 set_dirty ();
1839         }
1840 }
1841
1842 void
1843 Session::unset_play_range ()
1844 {
1845         _play_range = false;
1846         _clear_event_type (SessionEvent::RangeStop);
1847         _clear_event_type (SessionEvent::RangeLocate);
1848 }
1849
1850 void
1851 Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
1852 {
1853         SessionEvent* ev;
1854
1855         /* Called from event-processing context */
1856
1857         unset_play_range ();
1858
1859         if (range.empty()) {
1860                 /* _play_range set to false in unset_play_range()
1861                  */
1862                 if (!leave_rolling) {
1863                         /* stop transport */
1864                         SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0f, false);
1865                         merge_event (ev);
1866                 }
1867                 return;
1868         }
1869
1870         _play_range = true;
1871
1872         /* cancel loop play */
1873         unset_play_loop ();
1874
1875         list<AudioRange>::size_type sz = range.size();
1876
1877         if (sz > 1) {
1878
1879                 list<AudioRange>::iterator i = range.begin();
1880                 list<AudioRange>::iterator next;
1881
1882                 while (i != range.end()) {
1883
1884                         next = i;
1885                         ++next;
1886
1887                         /* locating/stopping is subject to delays for declicking.
1888                          */
1889
1890                         framepos_t requested_frame = i->end;
1891
1892                         if (requested_frame > current_block_size) {
1893                                 requested_frame -= current_block_size;
1894                         } else {
1895                                 requested_frame = 0;
1896                         }
1897
1898                         if (next == range.end()) {
1899                                 ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, requested_frame, 0, 0.0f);
1900                         } else {
1901                                 ev = new SessionEvent (SessionEvent::RangeLocate, SessionEvent::Add, requested_frame, (*next).start, 0.0f);
1902                         }
1903
1904                         merge_event (ev);
1905
1906                         i = next;
1907                 }
1908
1909         } else if (sz == 1) {
1910
1911                 ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, range.front().end, 0, 0.0f);
1912                 merge_event (ev);
1913
1914         }
1915
1916         /* save range so we can do auto-return etc. */
1917
1918         current_audio_range = range;
1919
1920         /* now start rolling at the right place */
1921
1922         ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, SessionEvent::Immediate, range.front().start, 0.0f, false);
1923         merge_event (ev);
1924
1925         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC5 with speed = %1\n", _transport_speed));
1926         TransportStateChange ();
1927 }
1928
1929 void
1930 Session::request_bounded_roll (framepos_t start, framepos_t end)
1931 {
1932         AudioRange ar (start, end, 0);
1933         list<AudioRange> lar;
1934
1935         lar.push_back (ar);
1936         request_play_range (&lar, true);
1937 }
1938
1939 void
1940 Session::set_requested_return_frame (framepos_t return_to)
1941 {
1942         _requested_return_frame = return_to;
1943 }
1944
1945 void
1946 Session::request_roll_at_and_return (framepos_t start, framepos_t return_to)
1947 {
1948         SessionEvent *ev = new SessionEvent (SessionEvent::LocateRollLocate, SessionEvent::Add, SessionEvent::Immediate, return_to, 1.0);
1949         ev->target2_frame = start;
1950         queue_event (ev);
1951 }
1952
1953 void
1954 Session::engine_halted ()
1955 {
1956         bool ignored;
1957
1958         /* there will be no more calls to process(), so
1959            we'd better clean up for ourselves, right now.
1960
1961            but first, make sure the butler is out of
1962            the picture.
1963         */
1964
1965         if (_butler) {
1966                 _butler->stop ();
1967         }
1968
1969         realtime_stop (false, true);
1970         non_realtime_stop (false, 0, ignored);
1971         transport_sub_state = 0;
1972
1973         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC6 with speed = %1\n", _transport_speed));
1974         TransportStateChange (); /* EMIT SIGNAL */
1975 }
1976
1977
1978 void
1979 Session::xrun_recovery ()
1980 {
1981         ++_xrun_count;
1982
1983         Xrun (_transport_frame); /* EMIT SIGNAL */
1984
1985         if (Config->get_stop_recording_on_xrun() && actively_recording()) {
1986
1987                 /* it didn't actually halt, but we need
1988                    to handle things in the same way.
1989                 */
1990
1991                 engine_halted();
1992         }
1993 }
1994
1995 void
1996 Session::route_processors_changed (RouteProcessorChange c)
1997 {
1998         if (ignore_route_processor_changes) {
1999                 return;
2000         }
2001
2002         if (c.type == RouteProcessorChange::MeterPointChange) {
2003                 set_dirty ();
2004                 return;
2005         }
2006
2007         if (c.type == RouteProcessorChange::RealTimeChange) {
2008                 set_dirty ();
2009                 return;
2010         }
2011
2012         update_latency_compensation ();
2013         resort_routes ();
2014
2015         set_dirty ();
2016 }
2017
2018 void
2019 Session::allow_auto_play (bool yn)
2020 {
2021         auto_play_legal = yn;
2022 }
2023
2024 bool
2025 Session::maybe_stop (framepos_t limit)
2026 {
2027         if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
2028                 if (synced_to_engine () && config.get_jack_time_master ()) {
2029                         _engine.transport_stop ();
2030                 } else if (!synced_to_engine ()) {
2031                         stop_transport ();
2032                 }
2033                 return true;
2034         }
2035         return false;
2036 }
2037
2038 void
2039 Session::send_mmc_locate (framepos_t t)
2040 {
2041         if (t < 0) {
2042                 return;
2043         }
2044
2045         if (!_engine.freewheeling()) {
2046                 Timecode::Time time;
2047                 timecode_time_subframes (t, time);
2048                 send_immediate_mmc (MIDI::MachineControlCommand (time));
2049         }
2050 }
2051
2052 /** Ask the transport to not send timecode until further notice.  The suspension
2053  *  will come into effect some finite time after this call, and timecode_transmission_suspended()
2054  *  should be checked by the caller to find out when.
2055  */
2056 void
2057 Session::request_suspend_timecode_transmission ()
2058 {
2059         SessionEvent* ev = new SessionEvent (SessionEvent::SetTimecodeTransmission, SessionEvent::Add, SessionEvent::Immediate, 0, 0, false);
2060         queue_event (ev);
2061 }
2062
2063 void
2064 Session::request_resume_timecode_transmission ()
2065 {
2066         SessionEvent* ev = new SessionEvent (SessionEvent::SetTimecodeTransmission, SessionEvent::Add, SessionEvent::Immediate, 0, 0, true);
2067         queue_event (ev);
2068 }
2069
2070 bool
2071 Session::timecode_transmission_suspended () const
2072 {
2073         return g_atomic_int_get (&_suspend_timecode_transmission) == 1;
2074 }