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