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
  34 #include "midi++/mmc.h"
  35 #include "midi++/port.h"
  36 #include "midi++/manager.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/session.h"
  45 #include "ardour/slave.h"
  46 #include "ardour/operations.h"
  47
  48 #include "i18n.h"
  49
  50 using namespace std;
  51 using namespace ARDOUR;
  52 using namespace PBD;
  53
  54 void
  55 Session::add_post_transport_work (PostTransportWork ptw)
  56 {
  57         PostTransportWork oldval;
  58         PostTransportWork newval;
  59         int tries = 0;
  60
  61         while (tries < 8) {
  62                 oldval = (PostTransportWork) g_atomic_int_get (&_post_transport_work);
  63                 newval = PostTransportWork (oldval | ptw);
  64                 if (g_atomic_int_compare_and_exchange (&_post_transport_work, oldval, newval)) {
  65                         /* success */
  66                         return;
  67                 }
  68         }
  69
  70         error << "Could not set post transport work! Crazy thread madness, call the programmers" << endmsg;
  71 }
  72
  73 void
  74 Session::request_input_change_handling ()
  75 {
  76         if (!(_state_of_the_state & (InitialConnecting|Deletion))) {
  77                 SessionEvent* ev = new SessionEvent (SessionEvent::InputConfigurationChange, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
  78                 queue_event (ev);
  79         }
  80 }
  81
  82 void
  83 Session::request_sync_source (Slave* new_slave)
  84 {
  85         SessionEvent* ev = new SessionEvent (SessionEvent::SetSyncSource, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
  86         bool seamless;
  87
  88         seamless = Config->get_seamless_loop ();
  89
  90         if (dynamic_cast<JACK_Slave*>(new_slave)) {
  91                 /* JACK cannot support seamless looping at present */
  92                 Config->set_seamless_loop (false);
  93         } else {
  94                 /* reset to whatever the value was before we last switched slaves */
  95                 Config->set_seamless_loop (_was_seamless);
  96         }
  97
  98         /* save value of seamless from before the switch */
  99         _was_seamless = seamless;
 100
 101         ev->slave = new_slave;
 102         queue_event (ev);
 103 }
 104
 105 void
 106 Session::request_transport_speed (double speed, bool as_default)
 107 {
 108         SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed);
 109         ev->third_yes_or_no = true;
 110         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport speed = %1 as default = %2\n", speed, as_default));
 111         queue_event (ev);
 112 }
 113
 114 /** Request a new transport speed, but if the speed parameter is exactly zero then use
 115  *  a very small +ve value to prevent the transport actually stopping.  This method should
 116  *  be used by callers who are varying transport speed but don't ever want to stop it.
 117  */
 118 void
 119 Session::request_transport_speed_nonzero (double speed, bool as_default)
 120 {
 121         if (speed == 0) {
 122                 speed = DBL_EPSILON;
 123         }
 124
 125         request_transport_speed (speed, as_default);
 126 }
 127
 128 void
 129 Session::request_track_speed (Track* tr, double speed)
 130 {
 131         SessionEvent* ev = new SessionEvent (SessionEvent::SetTrackSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed);
 132         ev->set_ptr (tr);
 133         queue_event (ev);
 134 }
 135
 136 void
 137 Session::request_stop (bool abort, bool clear_state)
 138 {
 139         SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0, abort, clear_state);
 140         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport stop, abort = %1, clear state = %2\n", abort, clear_state));
 141         queue_event (ev);
 142 }
 143
 144 void
 145 Session::request_locate (framepos_t target_frame, bool with_roll)
 146 {
 147         SessionEvent *ev = new SessionEvent (with_roll ? SessionEvent::LocateRoll : SessionEvent::Locate, SessionEvent::Add, SessionEvent::Immediate, target_frame, 0, false);
 148         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request locate to %1\n", target_frame));
 149         queue_event (ev);
 150 }
 151
 152 void
 153 Session::force_locate (framepos_t target_frame, bool with_roll)
 154 {
 155         SessionEvent *ev = new SessionEvent (with_roll ? SessionEvent::LocateRoll : SessionEvent::Locate, SessionEvent::Add, SessionEvent::Immediate, target_frame, 0, true);
 156         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request forced locate to %1\n", target_frame));
 157         queue_event (ev);
 158 }
 159
 160 void
 161 Session::request_play_loop (bool yn, bool leave_rolling)
 162 {
 163         SessionEvent* ev;
 164         Location *location = _locations->auto_loop_location();
 165
 166         if (location == 0 && yn) {
 167                 error << _("Cannot loop - no loop range defined")
 168                       << endmsg;
 169                 return;
 170         }
 171
 172         ev = new SessionEvent (SessionEvent::SetLoop, SessionEvent::Add, SessionEvent::Immediate, 0, (leave_rolling ? 1.0 : 0.0), yn);
 173         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request set loop = %1, leave rolling ? %2\n", yn, leave_rolling));
 174         queue_event (ev);
 175
 176         if (!leave_rolling && !yn && Config->get_seamless_loop() && transport_rolling()) {
 177                 // request an immediate locate to refresh the tracks
 178                 // after disabling looping
 179                 request_locate (_transport_frame-1, false);
 180         }
 181 }
 182
 183 void
 184 Session::request_play_range (list<AudioRange>* range, bool leave_rolling)
 185 {
 186         SessionEvent* ev = new SessionEvent (SessionEvent::SetPlayAudioRange, SessionEvent::Add, SessionEvent::Immediate, 0, (leave_rolling ? 1.0 : 0.0));
 187         if (range) {
 188                 ev->audio_range = *range;
 189         } else {
 190                 ev->audio_range.clear ();
 191         }
 192         DEBUG_TRACE (DEBUG::Transport, string_compose ("Request play range, leave rolling ? %1\n", leave_rolling));
 193         queue_event (ev);
 194 }
 195
 196 void
 197 Session::realtime_stop (bool abort, bool clear_state)
 198 {
 199         DEBUG_TRACE (DEBUG::Transport, string_compose ("realtime stop @ %1\n", _transport_frame));
 200         PostTransportWork todo = PostTransportWork (0);
 201
 202         /* assume that when we start, we'll be moving forwards */
 203
 204         if (_transport_speed < 0.0f) {
 205                 todo = (PostTransportWork (todo | PostTransportStop | PostTransportReverse));
 206         } else {
 207                 todo = PostTransportWork (todo | PostTransportStop);
 208         }
 209
 210         /* call routes */
 211
 212         boost::shared_ptr<RouteList> r = routes.reader ();
 213
 214         for (RouteList::iterator i = r->begin (); i != r->end(); ++i) {
 215                 (*i)->realtime_handle_transport_stopped ();
 216         }
 217
 218         if (actively_recording()) {
 219
 220                 /* move the transport position back to where the
 221                    request for a stop was noticed. we rolled
 222                    past that point to pick up delayed input (and/or to delick)
 223                 */
 224
 225                 if (worst_playback_latency() > current_block_size) {
 226                         /* we rolled past the stop point to pick up data that had
 227                            not yet arrived. move back to where the stop occured.
 228                         */
 229                         decrement_transport_position (current_block_size + (worst_input_latency() - current_block_size));
 230                 } else {
 231                         decrement_transport_position (current_block_size);
 232                 }
 233
 234                 /* the duration change is not guaranteed to have happened, but is likely */
 235
 236                 todo = PostTransportWork (todo | PostTransportDuration);
 237         }
 238
 239         if (abort) {
 240                 todo = PostTransportWork (todo | PostTransportAbort);
 241         }
 242
 243         if (clear_state) {
 244                 todo = PostTransportWork (todo | PostTransportClearSubstate);
 245         }
 246
 247         if (todo) {
 248                 add_post_transport_work (todo);
 249         }
 250
 251         _clear_event_type (SessionEvent::StopOnce);
 252         _clear_event_type (SessionEvent::RangeStop);
 253         _clear_event_type (SessionEvent::RangeLocate);
 254
 255         /* if we're going to clear loop state, then force disabling record BUT only if we're not doing latched rec-enable */
 256         disable_record (true, (!Config->get_latched_record_enable() && clear_state));
 257
 258         reset_slave_state ();
 259
 260         _transport_speed = 0;
 261         _target_transport_speed = 0;
 262
 263         g_atomic_int_set (&_playback_load, 100);
 264         g_atomic_int_set (&_capture_load, 100);
 265
 266         if (config.get_use_video_sync()) {
 267                 waiting_for_sync_offset = true;
 268         }
 269
 270         transport_sub_state = 0;
 271 }
 272
 273 void
 274 Session::realtime_locate ()
 275 {
 276         boost::shared_ptr<RouteList> r = routes.reader ();
 277         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 278                 (*i)->realtime_locate ();
 279         }
 280 }
 281
 282 void
 283 Session::butler_transport_work ()
 284 {
 285   restart:
 286         bool finished;
 287         PostTransportWork ptw;
 288         boost::shared_ptr<RouteList> r = routes.reader ();
 289
 290         int on_entry = g_atomic_int_get (&_butler->should_do_transport_work);
 291         finished = true;
 292         ptw = post_transport_work();
 293
 294         DEBUG_TRACE (DEBUG::Transport, string_compose ("Butler transport work, todo = %1\n", enum_2_string (ptw)));
 295
 296         if (ptw & PostTransportAdjustPlaybackBuffering) {
 297                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 298                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 299                         if (tr) {
 300                                 tr->adjust_playback_buffering ();
 301                                 /* and refill those buffers ... */
 302                         }
 303                         (*i)->non_realtime_locate (_transport_frame);
 304                 }
 305
 306         }
 307
 308         if (ptw & PostTransportAdjustCaptureBuffering) {
 309                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 310                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 311                         if (tr) {
 312                                 tr->adjust_capture_buffering ();
 313                         }
 314                 }
 315         }
 316
 317         if (ptw & PostTransportCurveRealloc) {
 318                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 319                         (*i)->curve_reallocate();
 320                 }
 321         }
 322
 323         if (ptw & PostTransportInputChange) {
 324                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 325                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 326                         if (tr) {
 327                                 tr->non_realtime_input_change ();
 328                         }
 329                 }
 330         }
 331
 332         if (ptw & PostTransportSpeed) {
 333                 non_realtime_set_speed ();
 334         }
 335
 336         if (ptw & PostTransportReverse) {
 337
 338                 clear_clicks();
 339                 cumulative_rf_motion = 0;
 340                 reset_rf_scale (0);
 341
 342                 /* don't seek if locate will take care of that in non_realtime_stop() */
 343
 344                 if (!(ptw & PostTransportLocate)) {
 345
 346                         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 347                                 (*i)->non_realtime_locate (_transport_frame);
 348
 349                                 if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
 350                                         /* new request, stop seeking, and start again */
 351                                         g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 352                                         goto restart;
 353                                 }
 354                         }
 355                 }
 356         }
 357
 358         if (ptw & PostTransportLocate) {
 359                 non_realtime_locate ();
 360         }
 361
 362         if (ptw & PostTransportStop) {
 363                 non_realtime_stop (ptw & PostTransportAbort, on_entry, finished);
 364                 if (!finished) {
 365                         g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 366                         goto restart;
 367                 }
 368         }
 369
 370         if (ptw & PostTransportOverWrite) {
 371                 non_realtime_overwrite (on_entry, finished);
 372                 if (!finished) {
 373                         g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 374                         goto restart;
 375                 }
 376         }
 377
 378         if (ptw & PostTransportAudition) {
 379                 non_realtime_set_audition ();
 380         }
 381
 382         g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
 383
 384         DEBUG_TRACE (DEBUG::Transport, X_("Butler transport work all done\n"));
 385 }
 386
 387 void
 388 Session::non_realtime_set_speed ()
 389 {
 390         boost::shared_ptr<RouteList> rl = routes.reader();
 391         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 392                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 393                 if (tr) {
 394                         tr->non_realtime_set_speed ();
 395                 }
 396         }
 397 }
 398
 399 void
 400 Session::non_realtime_overwrite (int on_entry, bool& finished)
 401 {
 402         boost::shared_ptr<RouteList> rl = routes.reader();
 403         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 404                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 405                 if (tr && tr->pending_overwrite ()) {
 406                         tr->overwrite_existing_buffers ();
 407                 }
 408                 if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
 409                         finished = false;
 410                         return;
 411                 }
 412         }
 413 }
 414
 415
 416 void
 417 Session::non_realtime_locate ()
 418 {
 419         boost::shared_ptr<RouteList> rl = routes.reader();
 420         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 421                 (*i)->non_realtime_locate (_transport_frame);
 422         }
 423
 424         /* XXX: it would be nice to generate the new clicks here (in the non-RT thread)
 425            rather than clearing them so that the RT thread has to spend time constructing
 426            them (in Session::click).
 427          */
 428         clear_clicks ();
 429 }
 430
 431
 432 void
 433 Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
 434 {
 435         struct tm* now;
 436         time_t     xnow;
 437         bool       did_record;
 438         bool       saved;
 439         PostTransportWork ptw = post_transport_work();
 440
 441         did_record = false;
 442         saved = false;
 443
 444         boost::shared_ptr<RouteList> rl = routes.reader();
 445         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 446                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 447                 if (tr && tr->get_captured_frames () != 0) {
 448                         did_record = true;
 449                         break;
 450                 }
 451         }
 452
 453         /* stop and locate are merged here because they share a lot of common stuff */
 454
 455         time (&xnow);
 456         now = localtime (&xnow);
 457
 458         if (auditioner) {
 459                 auditioner->cancel_audition ();
 460         }
 461
 462         cumulative_rf_motion = 0;
 463         reset_rf_scale (0);
 464
 465         if (did_record) {
 466                 begin_reversible_command (Operations::capture);
 467                 _have_captured = true;
 468         }
 469
 470         DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: DS stop\n"));
 471
 472         if (abort && did_record) {
 473                 /* no reason to save the session file when we remove sources
 474                  */
 475                 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
 476         }
 477
 478         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 479                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 480                 if (tr) {
 481                         tr->transport_stopped_wallclock (*now, xnow, abort);
 482                 }
 483         }
 484
 485         if (abort && did_record) {
 486                 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
 487         }
 488
 489         boost::shared_ptr<RouteList> r = routes.reader ();
 490
 491         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 492                 if (!(*i)->is_hidden()) {
 493                         (*i)->set_pending_declick (0);
 494                 }
 495         }
 496
 497         if (did_record) {
 498                 commit_reversible_command ();
 499         }
 500
 501         if (_engine.running()) {
 502                 PostTransportWork ptw = post_transport_work ();
 503                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 504                         (*i)->nonrealtime_handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
 505                 }
 506                 update_latency_compensation ();
 507         }
 508
 509         bool const auto_return_enabled =
 510                 (!config.get_external_sync() && config.get_auto_return());
 511
 512         if (auto_return_enabled ||
 513             (ptw & PostTransportLocate) ||
 514             (_requested_return_frame >= 0) ||
 515             synced_to_jack()) {
 516
 517                 if (pending_locate_flush) {
 518                         flush_all_inserts ();
 519                 }
 520
 521                 if ((auto_return_enabled || synced_to_jack() || _requested_return_frame >= 0) &&
 522                     !(ptw & PostTransportLocate)) {
 523
 524                         /* no explicit locate queued */
 525
 526                         bool do_locate = false;
 527
 528                         if (_requested_return_frame >= 0) {
 529
 530                                 /* explicit return request pre-queued in event list. overrides everything else */
 531
 532                                 cerr << "explicit auto-return to " << _requested_return_frame << endl;
 533
 534                                 _transport_frame = _requested_return_frame;
 535                                 do_locate = true;
 536
 537                         } else {
 538                                 if (config.get_auto_return()) {
 539
 540                                         if (play_loop) {
 541
 542                                                 /* don't try to handle loop play when synced to JACK */
 543
 544                                                 if (!synced_to_jack()) {
 545
 546                                                         Location *location = _locations->auto_loop_location();
 547
 548                                                         if (location != 0) {
 549                                                                 _transport_frame = location->start();
 550                                                         } else {
 551                                                                 _transport_frame = _last_roll_location;
 552                                                         }
 553                                                         do_locate = true;
 554                                                 }
 555
 556                                         } else if (_play_range) {
 557
 558                                                 /* return to start of range */
 559
 560                                                 if (!current_audio_range.empty()) {
 561                                                         _transport_frame = current_audio_range.front().start;
 562                                                         do_locate = true;
 563                                                 }
 564
 565                                         } else {
 566
 567                                                 /* regular auto-return */
 568
 569                                                 _transport_frame = _last_roll_location;
 570                                                 do_locate = true;
 571                                         }
 572                                 }
 573                         }
 574
 575                         _requested_return_frame = -1;
 576
 577                         if (do_locate) {
 578                                 _engine.transport_locate (_transport_frame);
 579                         }
 580                 }
 581
 582         }
 583
 584         clear_clicks();
 585
 586         /* do this before seeking, because otherwise the tracks will do the wrong thing in seamless loop mode.
 587         */
 588
 589         if (ptw & PostTransportClearSubstate) {
 590                 _play_range = false;
 591                 unset_play_loop ();
 592         }
 593
 594         /* this for() block can be put inside the previous if() and has the effect of ... ??? what */
 595
 596         DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: locate\n"));
 597         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 598                 DEBUG_TRACE (DEBUG::Transport, string_compose ("Butler PTW: locate on %1\n", (*i)->name()));
 599                 (*i)->non_realtime_locate (_transport_frame);
 600
 601                 if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
 602                         finished = false;
 603                         /* we will be back */
 604                         return;
 605                 }
 606         }
 607
 608         have_looped = false;
 609
 610         if (!_engine.freewheeling()) {
 611                 send_full_time_code (_transport_frame);
 612
 613                 if (!dynamic_cast<MTC_Slave*>(_slave)) {
 614                         MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
 615                         send_mmc_locate (_transport_frame);
 616                 }
 617         }
 618
 619         if ((ptw & PostTransportLocate) && get_record_enabled()) {
 620                 /* capture start has been changed, so save pending state */
 621                 save_state ("", true);
 622                 saved = true;
 623         }
 624
 625         /* always try to get rid of this */
 626
 627         remove_pending_capture_state ();
 628
 629         /* save the current state of things if appropriate */
 630
 631         if (did_record && !saved) {
 632                 save_state (_current_snapshot_name);
 633         }
 634
 635         if (ptw & PostTransportStop) {
 636                 _play_range = false;
 637                 play_loop = false;
 638         }
 639
 640         PositionChanged (_transport_frame); /* EMIT SIGNAL */
 641         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC with speed = %1\n", _transport_speed));
 642         TransportStateChange (); /* EMIT SIGNAL */
 643
 644         /* and start it up again if relevant */
 645
 646         if ((ptw & PostTransportLocate) && !config.get_external_sync() && pending_locate_roll) {
 647                 request_transport_speed (1.0);
 648         }
 649
 650         /* Even if we didn't do a pending locate roll this time, we don't want it hanging
 651            around for next time.
 652         */
 653         pending_locate_roll = false;
 654 }
 655
 656 void
 657 Session::check_declick_out ()
 658 {
 659         bool locate_required = transport_sub_state & PendingLocate;
 660
 661         /* this is called after a process() iteration. if PendingDeclickOut was set,
 662            it means that we were waiting to declick the output (which has just been
 663            done) before maybe doing something else. this is where we do that "something else".
 664
 665            note: called from the audio thread.
 666         */
 667
 668         if (transport_sub_state & PendingDeclickOut) {
 669
 670                 if (locate_required) {
 671                         start_locate (pending_locate_frame, pending_locate_roll, pending_locate_flush);
 672                         transport_sub_state &= ~(PendingDeclickOut|PendingLocate);
 673                 } else {
 674                         stop_transport (pending_abort);
 675                         transport_sub_state &= ~(PendingDeclickOut|PendingLocate);
 676                 }
 677
 678         } else if (transport_sub_state & PendingLoopDeclickOut) {
 679                 /* Nothing else to do here; we've declicked, and the loop event will be along shortly */
 680                 transport_sub_state &= ~PendingLoopDeclickOut;
 681         }
 682 }
 683
 684 void
 685 Session::unset_play_loop ()
 686 {
 687         play_loop = false;
 688         clear_events (SessionEvent::AutoLoop);
 689         clear_events (SessionEvent::AutoLoopDeclick);
 690
 691         // set all tracks to NOT use internal looping
 692         boost::shared_ptr<RouteList> rl = routes.reader ();
 693         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 694                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 695                 if (tr && !tr->hidden()) {
 696                         tr->set_loop (0);
 697                 }
 698         }
 699 }
 700
 701 void
 702 Session::set_play_loop (bool yn)
 703 {
 704         /* Called from event-handling context */
 705
 706         Location *loc;
 707
 708         if (yn == play_loop || (actively_recording() && yn) || (loc = _locations->auto_loop_location()) == 0) {
 709                 /* nothing to do, or can't change loop status while recording */
 710                 return;
 711         }
 712
 713         if (yn && Config->get_seamless_loop() && synced_to_jack()) {
 714                 warning << string_compose (
 715                         _("Seamless looping cannot be supported while %1 is using JACK transport.\n"
 716                           "Recommend changing the configured options"), PROGRAM_NAME)
 717                         << endmsg;
 718                 return;
 719         }
 720
 721         if (yn) {
 722
 723                 play_loop = true;
 724
 725                 if (loc) {
 726
 727                         unset_play_range ();
 728
 729                         if (Config->get_seamless_loop()) {
 730                                 // set all tracks to use internal looping
 731                                 boost::shared_ptr<RouteList> rl = routes.reader ();
 732                                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 733                                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 734                                         if (tr && !tr->hidden()) {
 735                                                 tr->set_loop (loc);
 736                                         }
 737                                 }
 738                         }
 739                         else {
 740                                 // set all tracks to NOT use internal looping
 741                                 boost::shared_ptr<RouteList> rl = routes.reader ();
 742                                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 743                                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 744                                         if (tr && !tr->hidden()) {
 745                                                 tr->set_loop (0);
 746                                         }
 747                                 }
 748                         }
 749
 750                         /* Put the delick and loop events in into the event list.  The declick event will
 751                            cause a de-clicking fade-out just before the end of the loop, and it will also result
 752                            in a fade-in when the loop restarts.  The AutoLoop event will peform the actual loop.
 753                         */
 754
 755                         framepos_t dcp;
 756                         framecnt_t dcl;
 757                         auto_loop_declick_range (loc, dcp, dcl);
 758                         merge_event (new SessionEvent (SessionEvent::AutoLoopDeclick, SessionEvent::Replace, dcp, dcl, 0.0f));
 759                         merge_event (new SessionEvent (SessionEvent::AutoLoop, SessionEvent::Replace, loc->end(), loc->start(), 0.0f));
 760
 761                         /* locate to start of loop and roll.
 762
 763                            args: positition, roll=true, flush=true, with_loop=false, force buffer refill if seamless looping
 764                         */
 765
 766                         start_locate (loc->start(), true, true, false, Config->get_seamless_loop());
 767                 }
 768
 769         } else {
 770
 771                 unset_play_loop ();
 772         }
 773
 774         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC2 with speed = %1\n", _transport_speed));
 775         TransportStateChange ();
 776 }
 777 void
 778 Session::flush_all_inserts ()
 779 {
 780         boost::shared_ptr<RouteList> r = routes.reader ();
 781
 782         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 783                 (*i)->flush_processors ();
 784         }
 785 }
 786
 787 void
 788 Session::start_locate (framepos_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
 789 {
 790         if (synced_to_jack()) {
 791
 792                 double sp;
 793                 framepos_t pos;
 794
 795                 _slave->speed_and_position (sp, pos);
 796
 797                 if (target_frame != pos) {
 798
 799                         if (config.get_jack_time_master()) {
 800                                 /* actually locate now, since otherwise jack_timebase_callback
 801                                    will use the incorrect _transport_frame and report an old
 802                                    and incorrect time to Jack transport
 803                                 */
 804                                 locate (target_frame, with_roll, with_flush, with_loop, force);
 805                         }
 806
 807                         /* tell JACK to change transport position, and we will
 808                            follow along later in ::follow_slave()
 809                         */
 810
 811                         _engine.transport_locate (target_frame);
 812
 813                         if (sp != 1.0f && with_roll) {
 814                                 _engine.transport_start ();
 815                         }
 816
 817                 }
 818
 819         } else {
 820                 locate (target_frame, with_roll, with_flush, with_loop, force);
 821         }
 822 }
 823
 824 int
 825 Session::micro_locate (framecnt_t distance)
 826 {
 827         boost::shared_ptr<RouteList> rl = routes.reader();
 828         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 829                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 830                 if (tr && !tr->can_internal_playback_seek (distance)) {
 831                         return -1;
 832                 }
 833         }
 834
 835         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 836                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 837                 if (tr) {
 838                         tr->internal_playback_seek (distance);
 839                 }
 840         }
 841
 842         _transport_frame += distance;
 843         return 0;
 844 }
 845
 846 /** @param with_mmc true to send a MMC locate command when the locate is done */
 847 void
 848 Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool for_seamless_loop, bool force, bool with_mmc)
 849 {
 850         /* Locates for seamless looping are fairly different from other
 851          * locates. They assume that the diskstream buffers for each track
 852          * already have the correct data in them, and thus there is no need to
 853          * actually tell the tracks to locate. What does need to be done,
 854          * though, is all the housekeeping that is associated with non-linear
 855          * changes in the value of _transport_frame.
 856          */
 857
 858         if (actively_recording() && !for_seamless_loop) {
 859                 return;
 860         }
 861
 862         if (!force && _transport_frame == target_frame && !loop_changing && !for_seamless_loop) {
 863                 if (with_roll) {
 864                         set_transport_speed (1.0, false);
 865                 }
 866                 loop_changing = false;
 867                 Located (); /* EMIT SIGNAL */
 868                 return;
 869         }
 870
 871         if (_transport_speed && !for_seamless_loop) {
 872                 /* Schedule a declick.  We'll be called again when its done.
 873                    We only do it this way for ordinary locates, not those
 874                    due to **seamless** loops.
 875                 */
 876
 877                 if (!(transport_sub_state & PendingDeclickOut)) {
 878                         transport_sub_state |= (PendingDeclickOut|PendingLocate);
 879                         pending_locate_frame = target_frame;
 880                         pending_locate_roll = with_roll;
 881                         pending_locate_flush = with_flush;
 882                         return;
 883                 }
 884         }
 885
 886         // Update Timecode time
 887         // [DR] FIXME: find out exactly where this should go below
 888         _transport_frame = target_frame;
 889         _last_roll_or_reversal_location = target_frame;
 890         timecode_time(_transport_frame, transmitting_timecode_time);
 891         outbound_mtc_timecode_frame = _transport_frame;
 892         next_quarter_frame_to_send = 0;
 893
 894         /* do "stopped" stuff if:
 895          *
 896          * we are rolling AND
 897          *    no autoplay in effect AND
 898          *       we're not going to keep rolling after the locate AND
 899          *           !(playing a loop with JACK sync)
 900          *
 901          */
 902
 903         bool transport_was_stopped = !transport_rolling();
 904
 905         if (transport_was_stopped && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
 906                 realtime_stop (false, true); // XXX paul - check if the 2nd arg is really correct
 907                 transport_was_stopped = true;
 908         } else {
 909                 /* otherwise tell the world that we located */
 910                 realtime_locate ();
 911         }
 912
 913         if (force || !for_seamless_loop || loop_changing) {
 914
 915                 PostTransportWork todo = PostTransportLocate;
 916
 917                 if (with_roll && transport_was_stopped) {
 918                         todo = PostTransportWork (todo | PostTransportRoll);
 919                 }
 920
 921                 add_post_transport_work (todo);
 922                 _butler->schedule_transport_work ();
 923
 924         } else {
 925
 926                 /* this is functionally what clear_clicks() does but with a tentative lock */
 927
 928                 Glib::Threads::RWLock::WriterLock clickm (click_lock, Glib::Threads::TRY_LOCK);
 929
 930                 if (clickm.locked()) {
 931
 932                         for (Clicks::iterator i = clicks.begin(); i != clicks.end(); ++i) {
 933                                 delete *i;
 934                         }
 935
 936                         clicks.clear ();
 937                 }
 938         }
 939
 940         if (with_roll) {
 941                 /* switch from input if we're going to roll */
 942                 if (Config->get_monitoring_model() == HardwareMonitoring) {
 943                         set_track_monitor_input_status (!config.get_auto_input());
 944                 }
 945         } else {
 946                 /* otherwise we're going to stop, so do the opposite */
 947                 if (Config->get_monitoring_model() == HardwareMonitoring) {
 948                         set_track_monitor_input_status (true);
 949                 }
 950         }
 951
 952         /* cancel looped playback if transport pos outside of loop range */
 953         if (play_loop) {
 954
 955                 Location* al = _locations->auto_loop_location();
 956
 957                 if (al) {
 958                         if (_transport_frame < al->start() || _transport_frame > al->end()) {
 959
 960                                 // located outside the loop: cancel looping directly, this is called from event handling context
 961
 962                                 set_play_loop (false);
 963
 964                         } else if (_transport_frame == al->start()) {
 965
 966                                 // located to start of loop - this is looping, basically
 967
 968                                 if (for_seamless_loop) {
 969
 970                                         // this is only necessary for seamless looping
 971
 972                                         boost::shared_ptr<RouteList> rl = routes.reader();
 973
 974                                         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 975                                                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
 976
 977                                                 if (tr && tr->record_enabled ()) {
 978                                                         // tell it we've looped, so it can deal with the record state
 979                                                         tr->transport_looped (_transport_frame);
 980                                                 }
 981                                         }
 982                                 }
 983
 984                                 have_looped = true;
 985                                 TransportLooped(); // EMIT SIGNAL
 986                         }
 987                 }
 988         }
 989
 990         loop_changing = false;
 991
 992         _send_timecode_update = true;
 993
 994         if (with_mmc) {
 995                 send_mmc_locate (_transport_frame);
 996         }
 997
 998         Located (); /* EMIT SIGNAL */
 999 }
1000
1001 /** Set the transport speed.
1002  *  Called from the process thread.
1003  *  @param speed New speed
1004  */
1005 void
1006 Session::set_transport_speed (double speed, bool abort, bool clear_state, bool as_default)
1007 {
1008         DEBUG_TRACE (DEBUG::Transport, string_compose ("@ %5 Set transport speed to %1, abort = %2 clear_state = %3, current = %4 as_default %6\n",
1009                                                        speed, abort, clear_state, _transport_speed, _transport_frame, as_default));
1010
1011         if (_transport_speed == speed) {
1012                 if (as_default && speed == 0.0) { // => reset default transport speed. hacky or what?
1013                         _default_transport_speed = 1.0;
1014                 }
1015                 return;
1016         }
1017
1018         if (actively_recording() && speed != 1.0 && speed != 0.0) {
1019                 /* no varispeed during recording */
1020                 return;
1021         }
1022
1023         _target_transport_speed = fabs(speed);
1024
1025         /* 8.0 max speed is somewhat arbitrary but based on guestimates regarding disk i/o capability
1026            and user needs. We really need CD-style "skip" playback for ffwd and rewind.
1027         */
1028
1029         if (speed > 0) {
1030                 speed = min (8.0, speed);
1031         } else if (speed < 0) {
1032                 speed = max (-8.0, speed);
1033         }
1034
1035         if (transport_rolling() && speed == 0.0) {
1036
1037                 /* we are rolling and we want to stop */
1038
1039                 if (Config->get_monitoring_model() == HardwareMonitoring) {
1040                         set_track_monitor_input_status (true);
1041                 }
1042
1043                 if (synced_to_jack ()) {
1044                         if (clear_state) {
1045                                 /* do this here because our response to the slave won't
1046                                    take care of it.
1047                                 */
1048                                 _play_range = false;
1049                                 unset_play_loop ();
1050                         }
1051                         _engine.transport_stop ();
1052                 } else {
1053                         stop_transport (abort);
1054                 }
1055
1056                 unset_play_loop ();
1057
1058         } else if (transport_stopped() && speed == 1.0) {
1059
1060                 /* we are stopped and we want to start rolling at speed 1 */
1061
1062                 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1063                         set_track_monitor_input_status (false);
1064                 }
1065
1066                 if (synced_to_jack()) {
1067                         _engine.transport_start ();
1068                 } else {
1069                         start_transport ();
1070                 }
1071
1072         } else {
1073
1074                 /* not zero, not 1.0 ... varispeed */
1075
1076                 if ((synced_to_jack()) && speed != 0.0 && speed != 1.0) {
1077                         warning << string_compose (
1078                                 _("Global varispeed cannot be supported while %1 is connected to JACK transport control"),
1079                                 PROGRAM_NAME)
1080                                 << endmsg;
1081                         return;
1082                 }
1083
1084                 if (actively_recording()) {
1085                         return;
1086                 }
1087
1088                 if (speed > 0.0 && _transport_frame == current_end_frame()) {
1089                         return;
1090                 }
1091
1092                 if (speed < 0.0 && _transport_frame == 0) {
1093                         return;
1094                 }
1095
1096                 clear_clicks ();
1097
1098                 /* if we are reversing relative to the current speed, or relative to the speed
1099                    before the last stop, then we have to do extra work.
1100                 */
1101
1102                 PostTransportWork todo = PostTransportWork (0);
1103
1104                 if ((_transport_speed && speed * _transport_speed < 0.0) || (_last_transport_speed * speed < 0.0) || (_last_transport_speed == 0.0f && speed < 0.0f)) {
1105                         todo = PostTransportWork (todo | PostTransportReverse);
1106                         _last_roll_or_reversal_location = _transport_frame;
1107                 }
1108
1109                 _last_transport_speed = _transport_speed;
1110                 _transport_speed = speed;
1111
1112                 if (as_default) {
1113                         _default_transport_speed = speed;
1114                 }
1115
1116                 boost::shared_ptr<RouteList> rl = routes.reader();
1117                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1118                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1119                         if (tr && tr->realtime_set_speed (tr->speed(), true)) {
1120                                 todo = PostTransportWork (todo | PostTransportSpeed);
1121                         }
1122                 }
1123
1124                 if (todo) {
1125                         add_post_transport_work (todo);
1126                         _butler->schedule_transport_work ();
1127                 }
1128
1129                 DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC3 with speed = %1\n", _transport_speed));
1130                 TransportStateChange (); /* EMIT SIGNAL */
1131         }
1132 }
1133
1134
1135 /** Stop the transport.  */
1136 void
1137 Session::stop_transport (bool abort, bool clear_state)
1138 {
1139         if (_transport_speed == 0.0f) {
1140                 return;
1141         }
1142
1143         if (actively_recording() && !(transport_sub_state & StopPendingCapture) && worst_input_latency() > current_block_size) {
1144
1145                 boost::shared_ptr<RouteList> rl = routes.reader();
1146                 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1147                         boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1148                         if (tr) {
1149                                 tr->prepare_to_stop (_transport_frame);
1150                         }
1151                 }
1152
1153                 /* we need to capture the audio that has still not yet been received by the system
1154                    at the time the stop is requested, so we have to roll past that time.
1155
1156                    we want to declick before stopping, so schedule the autostop for one
1157                    block before the actual end. we'll declick in the subsequent block,
1158                    and then we'll really be stopped.
1159                 */
1160
1161                 DEBUG_TRACE (DEBUG::Transport, string_compose ("stop transport requested @ %1, scheduled for + %2 - %3 = %4, abort = %5\n",
1162                                                                _transport_frame, _worst_input_latency, current_block_size,
1163                                                                _transport_frame - _worst_input_latency - current_block_size,
1164                                                                abort));
1165
1166                 SessionEvent *ev = new SessionEvent (SessionEvent::StopOnce, SessionEvent::Replace,
1167                                                      _transport_frame + _worst_input_latency - current_block_size,
1168                                                      0, 0, abort);
1169
1170                 merge_event (ev);
1171                 transport_sub_state |= StopPendingCapture;
1172                 pending_abort = abort;
1173                 return;
1174         }
1175
1176         if ((transport_sub_state & PendingDeclickOut) == 0) {
1177
1178                 if (!(transport_sub_state & StopPendingCapture)) {
1179                         boost::shared_ptr<RouteList> rl = routes.reader();
1180                         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1181                                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1182                                 if (tr) {
1183                                         tr->prepare_to_stop (_transport_frame);
1184                                 }
1185                         }
1186                 }
1187
1188                 transport_sub_state |= PendingDeclickOut;
1189                 /* we'll be called again after the declick */
1190                 pending_abort = abort;
1191                 return;
1192         }
1193
1194         realtime_stop (abort, clear_state);
1195         _butler->schedule_transport_work ();
1196 }
1197
1198 /** Called from the process thread */
1199 void
1200 Session::start_transport ()
1201 {
1202         DEBUG_TRACE (DEBUG::Transport, "start_transport\n");
1203
1204         _last_roll_location = _transport_frame;
1205         _last_roll_or_reversal_location = _transport_frame;
1206
1207         have_looped = false;
1208
1209         /* if record status is Enabled, move it to Recording. if its
1210            already Recording, move it to Disabled.
1211         */
1212
1213         switch (record_status()) {
1214         case Enabled:
1215                 if (!config.get_punch_in()) {
1216                         enable_record ();
1217                 }
1218                 break;
1219
1220         case Recording:
1221                 if (!play_loop) {
1222                         disable_record (false);
1223                 }
1224                 break;
1225
1226         default:
1227                 break;
1228         }
1229
1230         transport_sub_state |= PendingDeclickIn;
1231
1232         _transport_speed = _default_transport_speed;
1233         _target_transport_speed = _transport_speed;
1234
1235         boost::shared_ptr<RouteList> rl = routes.reader();
1236         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1237                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1238                 if (tr) {
1239                         tr->realtime_set_speed (tr->speed(), true);
1240                 }
1241         }
1242
1243         if (!_engine.freewheeling()) {
1244                 Timecode::Time time;
1245                 timecode_time_subframes (_transport_frame, time);
1246                 if (!dynamic_cast<MTC_Slave*>(_slave)) {
1247                         MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
1248                 }
1249         }
1250
1251         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC4 with speed = %1\n", _transport_speed));
1252         TransportStateChange (); /* EMIT SIGNAL */
1253 }
1254
1255 /** Do any transport work in the audio thread that needs to be done after the
1256  * transport thread is finished.  Audio thread, realtime safe.
1257  */
1258 void
1259 Session::post_transport ()
1260 {
1261         PostTransportWork ptw = post_transport_work ();
1262
1263         if (ptw & PostTransportAudition) {
1264                 if (auditioner && auditioner->auditioning()) {
1265                         process_function = &Session::process_audition;
1266                 } else {
1267                         process_function = &Session::process_with_events;
1268                 }
1269         }
1270
1271         if (ptw & PostTransportStop) {
1272
1273                 transport_sub_state = 0;
1274         }
1275
1276         if (ptw & PostTransportLocate) {
1277
1278                 if (((!config.get_external_sync() && (auto_play_legal && config.get_auto_play())) && !_exporting) || (ptw & PostTransportRoll)) {
1279                         start_transport ();
1280                 } else {
1281                         transport_sub_state = 0;
1282                 }
1283         }
1284
1285         set_next_event ();
1286         /* XXX is this really safe? shouldn't we just be unsetting the bits that we actually
1287            know were handled ?
1288         */
1289         set_post_transport_work (PostTransportWork (0));
1290 }
1291
1292 void
1293 Session::reset_rf_scale (framecnt_t motion)
1294 {
1295         cumulative_rf_motion += motion;
1296
1297         if (cumulative_rf_motion < 4 * _current_frame_rate) {
1298                 rf_scale = 1;
1299         } else if (cumulative_rf_motion < 8 * _current_frame_rate) {
1300                 rf_scale = 4;
1301         } else if (cumulative_rf_motion < 16 * _current_frame_rate) {
1302                 rf_scale = 10;
1303         } else {
1304                 rf_scale = 100;
1305         }
1306
1307         if (motion != 0) {
1308                 set_dirty();
1309         }
1310 }
1311
1312 void
1313 Session::use_sync_source (Slave* new_slave)
1314 {
1315         /* Runs in process() context */
1316
1317         bool non_rt_required = false;
1318
1319         /* XXX this deletion is problematic because we're in RT context */
1320
1321         delete _slave;
1322         _slave = new_slave;
1323
1324         send_full_time_code (_transport_frame);
1325
1326         boost::shared_ptr<RouteList> rl = routes.reader();
1327         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1328                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1329                 if (tr && !tr->hidden()) {
1330                         if (tr->realtime_set_speed (tr->speed(), true)) {
1331                                 non_rt_required = true;
1332                         }
1333                         tr->set_slaved (_slave != 0);
1334                 }
1335         }
1336
1337         if (non_rt_required) {
1338                 add_post_transport_work (PostTransportSpeed);
1339                 _butler->schedule_transport_work ();
1340         }
1341
1342         set_dirty();
1343 }
1344
1345 void
1346 Session::drop_sync_source ()
1347 {
1348         request_sync_source (0);
1349 }
1350
1351 void
1352 Session::switch_to_sync_source (SyncSource src)
1353 {
1354         Slave* new_slave;
1355
1356         DEBUG_TRACE (DEBUG::Slave, string_compose ("Setting up sync source %1\n", enum_2_string (src)));
1357
1358         switch (src) {
1359         case MTC:
1360                 if (_slave && dynamic_cast<MTC_Slave*>(_slave)) {
1361                         return;
1362                 }
1363
1364                 try {
1365                         new_slave = new MTC_Slave (*this, *MIDI::Manager::instance()->mtc_input_port());
1366                 }
1367
1368                 catch (failed_constructor& err) {
1369                         return;
1370                 }
1371                 break;
1372
1373         case MIDIClock:
1374                 if (_slave && dynamic_cast<MIDIClock_Slave*>(_slave)) {
1375                         return;
1376                 }
1377
1378                 try {
1379                         new_slave = new MIDIClock_Slave (*this, *MIDI::Manager::instance()->midi_clock_input_port(), 24);
1380                 }
1381
1382                 catch (failed_constructor& err) {
1383                         return;
1384                 }
1385                 break;
1386
1387         case JACK:
1388                 if (_slave && dynamic_cast<JACK_Slave*>(_slave)) {
1389                         return;
1390                 }
1391
1392                 if (config.get_video_pullup() != 0.0f) {
1393                         return;
1394                 }
1395
1396                 new_slave = new JACK_Slave (_engine.jack());
1397                 break;
1398
1399         default:
1400                 new_slave = 0;
1401                 break;
1402         };
1403
1404         request_sync_source (new_slave);
1405 }
1406
1407 void
1408 Session::set_track_speed (Track* track, double speed)
1409 {
1410         if (track->realtime_set_speed (speed, false)) {
1411                 add_post_transport_work (PostTransportSpeed);
1412                 _butler->schedule_transport_work ();
1413                 set_dirty ();
1414         }
1415 }
1416
1417 void
1418 Session::unset_play_range ()
1419 {
1420         _play_range = false;
1421         _clear_event_type (SessionEvent::RangeStop);
1422         _clear_event_type (SessionEvent::RangeLocate);
1423 }
1424
1425 void
1426 Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
1427 {
1428         SessionEvent* ev;
1429
1430         /* Called from event-processing context */
1431
1432         unset_play_range ();
1433
1434         if (range.empty()) {
1435                 /* _play_range set to false in unset_play_range()
1436                  */
1437                 if (!leave_rolling) {
1438                         /* stop transport */
1439                         SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0f, false);
1440                         merge_event (ev);
1441                 }
1442                 return;
1443         }
1444
1445         _play_range = true;
1446
1447         /* cancel loop play */
1448         unset_play_loop ();
1449
1450         list<AudioRange>::size_type sz = range.size();
1451
1452         if (sz > 1) {
1453
1454                 list<AudioRange>::iterator i = range.begin();
1455                 list<AudioRange>::iterator next;
1456
1457                 while (i != range.end()) {
1458
1459                         next = i;
1460                         ++next;
1461
1462                         /* locating/stopping is subject to delays for declicking.
1463                          */
1464
1465                         framepos_t requested_frame = i->end;
1466
1467                         if (requested_frame > current_block_size) {
1468                                 requested_frame -= current_block_size;
1469                         } else {
1470                                 requested_frame = 0;
1471                         }
1472
1473                         if (next == range.end()) {
1474                                 ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, requested_frame, 0, 0.0f);
1475                         } else {
1476                                 ev = new SessionEvent (SessionEvent::RangeLocate, SessionEvent::Add, requested_frame, (*next).start, 0.0f);
1477                         }
1478
1479                         merge_event (ev);
1480
1481                         i = next;
1482                 }
1483
1484         } else if (sz == 1) {
1485
1486                 ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, range.front().end, 0, 0.0f);
1487                 merge_event (ev);
1488
1489         }
1490
1491         /* save range so we can do auto-return etc. */
1492
1493         current_audio_range = range;
1494
1495         /* now start rolling at the right place */
1496
1497         ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, SessionEvent::Immediate, range.front().start, 0.0f, false);
1498         merge_event (ev);
1499
1500         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC5 with speed = %1\n", _transport_speed));
1501         TransportStateChange ();
1502 }
1503
1504 void
1505 Session::request_bounded_roll (framepos_t start, framepos_t end)
1506 {
1507         AudioRange ar (start, end, 0);
1508         list<AudioRange> lar;
1509
1510         lar.push_back (ar);
1511         request_play_range (&lar, true);
1512 }
1513 void
1514 Session::request_roll_at_and_return (framepos_t start, framepos_t return_to)
1515 {
1516         SessionEvent *ev = new SessionEvent (SessionEvent::LocateRollLocate, SessionEvent::Add, SessionEvent::Immediate, return_to, 1.0);
1517         ev->target2_frame = start;
1518         queue_event (ev);
1519 }
1520
1521 void
1522 Session::engine_halted ()
1523 {
1524         bool ignored;
1525
1526         /* there will be no more calls to process(), so
1527            we'd better clean up for ourselves, right now.
1528
1529            but first, make sure the butler is out of
1530            the picture.
1531         */
1532
1533         if (_butler) {
1534                 g_atomic_int_set (&_butler->should_do_transport_work, 0);
1535                 set_post_transport_work (PostTransportWork (0));
1536                 _butler->stop ();
1537         }
1538
1539         realtime_stop (false, true);
1540         non_realtime_stop (false, 0, ignored);
1541         transport_sub_state = 0;
1542
1543         DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC6 with speed = %1\n", _transport_speed));
1544         TransportStateChange (); /* EMIT SIGNAL */
1545 }
1546
1547
1548 void
1549 Session::xrun_recovery ()
1550 {
1551         Xrun (_transport_frame); /* EMIT SIGNAL */
1552
1553         if (Config->get_stop_recording_on_xrun() && actively_recording()) {
1554
1555                 /* it didn't actually halt, but we need
1556                    to handle things in the same way.
1557                 */
1558
1559                 engine_halted();
1560         }
1561 }
1562
1563 void
1564 Session::route_processors_changed (RouteProcessorChange c)
1565 {
1566         if (ignore_route_processor_changes) {
1567                 return;
1568         }
1569
1570         if (c.type == RouteProcessorChange::MeterPointChange) {
1571                 return;
1572         }
1573
1574         update_latency_compensation ();
1575         resort_routes ();
1576
1577         set_dirty ();
1578 }
1579
1580 void
1581 Session::allow_auto_play (bool yn)
1582 {
1583         auto_play_legal = yn;
1584 }
1585
1586 void
1587 Session::reset_jack_connection (jack_client_t* jack)
1588 {
1589         JACK_Slave* js;
1590
1591         if (_slave && ((js = dynamic_cast<JACK_Slave*> (_slave)) != 0)) {
1592                 js->reset_client (jack);
1593         }
1594 }
1595
1596 bool
1597 Session::maybe_stop (framepos_t limit)
1598 {
1599         if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
1600                 if (synced_to_jack () && config.get_jack_time_master ()) {
1601                         _engine.transport_stop ();
1602                 } else if (!synced_to_jack ()) {
1603                         stop_transport ();
1604                 }
1605                 return true;
1606         }
1607         return false;
1608 }
1609
1610 void
1611 Session::send_mmc_locate (framepos_t t)
1612 {
1613         if (!_engine.freewheeling()) {
1614                 Timecode::Time time;
1615                 timecode_time_subframes (t, time);
1616                 MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (time));
1617         }
1618 }
1619
1620 /** Ask the transport to not send timecode until further notice.  The suspension
1621  *  will come into effect some finite time after this call, and timecode_transmission_suspended()
1622  *  should be checked by the caller to find out when.
1623  */
1624 void
1625 Session::request_suspend_timecode_transmission ()
1626 {
1627         SessionEvent* ev = new SessionEvent (SessionEvent::SetTimecodeTransmission, SessionEvent::Add, SessionEvent::Immediate, 0, 0, false);
1628         queue_event (ev);
1629 }
1630
1631 void
1632 Session::request_resume_timecode_transmission ()
1633 {
1634         SessionEvent* ev = new SessionEvent (SessionEvent::SetTimecodeTransmission, SessionEvent::Add, SessionEvent::Immediate, 0, 0, true);
1635         queue_event (ev);
1636 }
1637
1638 bool
1639 Session::timecode_transmission_suspended () const
1640 {
1641         return g_atomic_int_get (&_suspend_timecode_transmission) == 1;
1642 }