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