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