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