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