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