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