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         if (_transport_speed < 0.0f) {
 139                 post_transport_work = PostTransportWork (post_transport_work | PostTransportStop | PostTransportReverse);
 140         } else {
 141                 post_transport_work = PostTransportWork (post_transport_work | PostTransportStop);
 142         }
 143
 144         if (actively_recording()) {
 145
 146                 /* move the transport position back to where the
 147                    request for a stop was noticed. we rolled
 148                    past that point to pick up delayed input.
 149                 */
 150
 151 #ifndef LEAVE_TRANSPORT_UNADJUSTED
 152                 decrement_transport_position (_worst_output_latency);
 153 #endif
 154
 155                 /* the duration change is not guaranteed to have happened, but is likely */
 156
 157                 post_transport_work = PostTransportWork (post_transport_work | PostTransportDuration);
 158         }
 159
 160         if (abort) {
 161                 post_transport_work = PostTransportWork (post_transport_work | PostTransportAbort);
 162         }
 163
 164         _clear_event_type (Event::StopOnce);
 165         _clear_event_type (Event::RangeStop);
 166         _clear_event_type (Event::RangeLocate);
 167
 168         disable_record (true);
 169
 170         reset_slave_state ();
 171
 172         _transport_speed = 0;
 173
 174         if (Config->get_use_video_sync()) {
 175                 waiting_for_sync_offset = true;
 176         }
 177
 178         transport_sub_state = ((Config->get_slave_source() == None && Config->get_auto_return()) ? AutoReturning : 0);
 179 }
 180
 181 void
 182 Session::butler_transport_work ()
 183 {
 184   restart:
 185         bool finished;
 186         boost::shared_ptr<RouteList> r = routes.reader ();
 187         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 188
 189         int on_entry = g_atomic_int_get (&butler_should_do_transport_work);
 190         finished = true;
 191
 192         if (post_transport_work & PostTransportCurveRealloc) {
 193                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 194                         (*i)->curve_reallocate();
 195                 }
 196         }
 197
 198         if (post_transport_work & PostTransportInputChange) {
 199                 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 200                         (*i)->non_realtime_input_change ();
 201                 }
 202         }
 203
 204         if (post_transport_work & PostTransportSpeed) {
 205                 non_realtime_set_speed ();
 206         }
 207
 208         if (post_transport_work & PostTransportReverse) {
 209
 210
 211                 clear_clicks();
 212                 cumulative_rf_motion = 0;
 213                 reset_rf_scale (0);
 214
 215                 /* don't seek if locate will take care of that in non_realtime_stop() */
 216
 217                 if (!(post_transport_work & PostTransportLocate)) {
 218
 219                         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 220                                 if (!(*i)->hidden()) {
 221                                         if ((*i)->speed() != 1.0f || (*i)->speed() != -1.0f) {
 222                                                 (*i)->seek ((nframes_t) (_transport_frame * (double) (*i)->speed()));
 223                                         }
 224                                         else {
 225                                                 (*i)->seek (_transport_frame);
 226                                         }
 227                                 }
 228                                 if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
 229                                         /* new request, stop seeking, and start again */
 230                                         g_atomic_int_dec_and_test (&butler_should_do_transport_work);
 231                                         goto restart;
 232                                 }
 233                         }
 234                 }
 235         }
 236
 237         if (post_transport_work & (PostTransportStop|PostTransportLocate)) {
 238                 non_realtime_stop (post_transport_work & PostTransportAbort, on_entry, finished);
 239                 if (!finished) {
 240                         g_atomic_int_dec_and_test (&butler_should_do_transport_work);
 241                         goto restart;
 242                 }
 243         }
 244
 245         if (post_transport_work & PostTransportOverWrite) {
 246                 non_realtime_overwrite (on_entry, finished);
 247                 if (!finished) {
 248                         g_atomic_int_dec_and_test (&butler_should_do_transport_work);
 249                         goto restart;
 250                 }
 251         }
 252
 253         if (post_transport_work & PostTransportAudition) {
 254                 non_realtime_set_audition ();
 255         }
 256
 257         g_atomic_int_dec_and_test (&butler_should_do_transport_work);
 258 }
 259
 260 void
 261 Session::non_realtime_set_speed ()
 262 {
 263         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 264
 265         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 266                 (*i)->non_realtime_set_speed ();
 267         }
 268 }
 269
 270 void
 271 Session::non_realtime_overwrite (int on_entry, bool& finished)
 272 {
 273         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 274
 275         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 276                 if ((*i)->pending_overwrite) {
 277                         (*i)->overwrite_existing_buffers ();
 278                 }
 279                 if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
 280                         finished = false;
 281                         return;
 282                 }
 283         }
 284 }
 285
 286 void
 287 Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
 288 {
 289         struct tm* now;
 290         time_t     xnow;
 291         bool       did_record;
 292         bool       saved;
 293
 294         did_record = false;
 295         saved = false;
 296
 297         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 298
 299         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 300                 if ((*i)->get_captured_frames () != 0) {
 301                         did_record = true;
 302                         break;
 303                 }
 304         }
 305
 306         /* stop and locate are merged here because they share a lot of common stuff */
 307
 308         time (&xnow);
 309         now = localtime (&xnow);
 310
 311         if (auditioner) {
 312                 auditioner->cancel_audition ();
 313         }
 314
 315         clear_clicks();
 316         cumulative_rf_motion = 0;
 317         reset_rf_scale (0);
 318
 319         if (did_record) {
 320                 begin_reversible_command ("capture");
 321
 322                 Location* loc = _locations.end_location();
 323                 bool change_end = false;
 324
 325                 if (_transport_frame < loc->end()) {
 326
 327                         /* stopped recording before current end */
 328
 329                         if (_end_location_is_free) {
 330
 331                                 /* first capture for this session, move end back to where we are */
 332
 333                                 change_end = true;
 334                         }
 335
 336                 } else if (_transport_frame > loc->end()) {
 337
 338                         /* stopped recording after the current end, extend it */
 339
 340                         change_end = true;
 341                 }
 342
 343                 if (change_end) {
 344                         XMLNode &before = loc->get_state();
 345                         loc->set_end(_transport_frame);
 346                         XMLNode &after = loc->get_state();
 347                         add_command (new MementoCommand<Location>(*loc, &before, &after));
 348                 }
 349
 350                 _end_location_is_free = false;
 351                 _have_captured = true;
 352         }
 353
 354         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 355                 (*i)->transport_stopped (*now, xnow, abort);
 356         }
 357
 358         boost::shared_ptr<RouteList> r = routes.reader ();
 359
 360         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 361                 if (!(*i)->hidden()) {
 362                         (*i)->set_pending_declick (0);
 363                 }
 364         }
 365
 366         if (did_record) {
 367                 commit_reversible_command ();
 368         }
 369
 370         if (_engine.running()) {
 371                 update_latency_compensation (true, abort);
 372         }
 373
 374         if ((Config->get_slave_source() == None && Config->get_auto_return()) ||
 375             (post_transport_work & PostTransportLocate) ||
 376             (_requested_return_frame >= 0) ||
 377             synced_to_jack()) {
 378
 379                 if (pending_locate_flush) {
 380                         flush_all_redirects ();
 381                 }
 382
 383                 if (((Config->get_slave_source() == None && Config->get_auto_return()) ||
 384                      synced_to_jack() ||
 385                      _requested_return_frame >= 0) &&
 386                     !(post_transport_work & PostTransportLocate)) {
 387
 388                         bool do_locate = false;
 389
 390                         if (_requested_return_frame >= 0) {
 391                                 _transport_frame = _requested_return_frame;
 392                                 _requested_return_frame = -1;
 393                                 do_locate = true;
 394                         } else {
 395                                 _transport_frame = last_stop_frame;
 396                         }
 397
 398                         if (synced_to_jack() && !play_loop) {
 399                                 do_locate = true;
 400                         }
 401
 402                         if (do_locate) {
 403                                 // cerr << "non-realtimestop: transport locate to " << _transport_frame << endl;
 404                                 _engine.transport_locate (_transport_frame);
 405                         }
 406                 }
 407
 408 #ifndef LEAVE_TRANSPORT_UNADJUSTED
 409         }
 410 #endif
 411
 412                 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 413                         if (!(*i)->hidden()) {
 414                                 if ((*i)->speed() != 1.0f || (*i)->speed() != -1.0f) {
 415                                         (*i)->seek ((nframes_t) (_transport_frame * (double) (*i)->speed()));
 416                                 }
 417                                 else {
 418                                         (*i)->seek (_transport_frame);
 419                                 }
 420                         }
 421                         if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
 422                                 finished = false;
 423                                 /* we will be back */
 424                                 return;
 425                         }
 426                 }
 427 #ifdef LEAVE_TRANSPORT_UNADJUSTED
 428         }
 429 #endif
 430
 431         last_stop_frame = _transport_frame;
 432
 433         send_full_time_code ();
 434         deliver_mmc (MIDI::MachineControl::cmdStop, 0);
 435         deliver_mmc (MIDI::MachineControl::cmdLocate, _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_redirects ()
 596 {
 597         boost::shared_ptr<RouteList> r = routes.reader ();
 598
 599         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 600                 (*i)->flush_redirects ();
 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         _transport_frame = target_frame;
 650
 651         if (_transport_speed && (!with_loop || loop_changing)) {
 652                 /* schedule a declick. we'll be called again when its done */
 653
 654                 if (!(transport_sub_state & PendingDeclickOut)) {
 655                         transport_sub_state |= (PendingDeclickOut|PendingLocate);
 656                         pending_locate_frame = target_frame;
 657                         pending_locate_roll = with_roll;
 658                         pending_locate_flush = with_flush;
 659                         return;
 660                 }
 661         }
 662
 663         if (transport_rolling() && (!auto_play_legal || !Config->get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
 664                 realtime_stop (false);
 665         }
 666
 667         if ( !with_loop || loop_changing) {
 668
 669                 post_transport_work = PostTransportWork (post_transport_work | PostTransportLocate);
 670
 671                 if (with_roll) {
 672                         post_transport_work = PostTransportWork (post_transport_work | PostTransportRoll);
 673                 }
 674
 675                 schedule_butler_transport_work ();
 676
 677         } else {
 678
 679                 /* this is functionally what clear_clicks() does but with a tentative lock */
 680
 681                 Glib::RWLock::WriterLock clickm (click_lock, Glib::TRY_LOCK);
 682
 683                 if (clickm.locked()) {
 684
 685                         for (Clicks::iterator i = clicks.begin(); i != clicks.end(); ++i) {
 686                                 delete *i;
 687                         }
 688
 689                         clicks.clear ();
 690                 }
 691         }
 692
 693         if (with_roll) {
 694                 /* switch from input if we're going to roll */
 695                 if (Config->get_monitoring_model() == HardwareMonitoring) {
 696
 697                         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 698
 699                         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 700                                 if ((*i)->record_enabled ()) {
 701                                         //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
 702                                         (*i)->monitor_input (!Config->get_auto_input());
 703                                 }
 704                         }
 705                 }
 706         } else {
 707                 /* otherwise we're going to stop, so do the opposite */
 708                 if (Config->get_monitoring_model() == HardwareMonitoring) {
 709                         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 710
 711                         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 712                                 if ((*i)->record_enabled ()) {
 713                                         //cerr << "switching to input" << __FILE__ << __LINE__ << endl << endl;
 714                                         (*i)->monitor_input (true);
 715                                 }
 716                         }
 717                 }
 718         }
 719
 720         /* cancel looped playback if transport pos outside of loop range */
 721         if (play_loop) {
 722                 Location* al = _locations.auto_loop_location();
 723
 724                 if (al && (_transport_frame < al->start() || _transport_frame > al->end())) {
 725                         // cancel looping directly, this is called from event handling context
 726                         set_play_loop (false);
 727                 }
 728                 else if (al && _transport_frame == al->start()) {
 729                         if (with_loop) {
 730                                 // this is only necessary for seamless looping
 731
 732                                 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 733
 734                                 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 735                                         if ((*i)->record_enabled ()) {
 736                                                 // tell it we've looped, so it can deal with the record state
 737                                                 (*i)->transport_looped(_transport_frame);
 738                                         }
 739                                 }
 740                         }
 741
 742                         TransportLooped(); // EMIT SIGNAL
 743                 }
 744         }
 745
 746         loop_changing = false;
 747 }
 748
 749 void
 750 Session::set_transport_speed (float speed, bool abort)
 751 {
 752         if (_transport_speed == speed) {
 753                 return;
 754         }
 755
 756         if (speed > 0) {
 757                 speed = min (8.0f, speed);
 758         } else if (speed < 0) {
 759                 speed = max (-8.0f, speed);
 760         }
 761
 762         if (transport_rolling() && speed == 0.0) {
 763
 764                 if (Config->get_monitoring_model() == HardwareMonitoring)
 765                 {
 766                         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 767
 768                         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 769                                 if ((*i)->record_enabled ()) {
 770                                         //cerr << "switching to input" << __FILE__ << __LINE__ << endl << endl;
 771                                         (*i)->monitor_input (true);
 772                                 }
 773                         }
 774                 }
 775
 776                 if (synced_to_jack ()) {
 777                         _engine.transport_stop ();
 778                 } else {
 779                         stop_transport (abort);
 780                 }
 781
 782         } else if (transport_stopped() && speed == 1.0) {
 783
 784                 if (!get_record_enabled() && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame()) {
 785                         return;
 786                 }
 787
 788                 if (Config->get_monitoring_model() == HardwareMonitoring) {
 789
 790                         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 791
 792                         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 793                                 if (Config->get_auto_input() && (*i)->record_enabled ()) {
 794                                         //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
 795                                         (*i)->monitor_input (false);
 796                                 }
 797                         }
 798                 }
 799
 800                 if (synced_to_jack()) {
 801                         _engine.transport_start ();
 802                 } else {
 803                         start_transport ();
 804                 }
 805
 806         } else {
 807
 808                 if (!get_record_enabled() && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame()) {
 809                         return;
 810                 }
 811
 812                 if ((synced_to_jack()) && speed != 0.0 && speed != 1.0) {
 813                         warning << _("Global varispeed cannot be supported while Ardour is connected to JACK transport control")
 814                                 << endmsg;
 815                         return;
 816                 }
 817
 818                 if (actively_recording()) {
 819                         return;
 820                 }
 821
 822                 if (speed > 0.0f && _transport_frame == current_end_frame()) {
 823                         return;
 824                 }
 825
 826                 if (speed < 0.0f && _transport_frame == 0) {
 827                         return;
 828                 }
 829
 830                 clear_clicks ();
 831
 832                 /* if we are reversing relative to the current speed, or relative to the speed
 833                    before the last stop, then we have to do extra work.
 834                 */
 835
 836                 if ((_transport_speed && speed * _transport_speed < 0.0f) || (_last_transport_speed * speed < 0.0f) || (_last_transport_speed == 0.0f && speed < 0.0f)) {
 837                         post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
 838                 }
 839
 840                 _last_transport_speed = _transport_speed;
 841                 _transport_speed = speed;
 842
 843                 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 844                 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 845                         if ((*i)->realtime_set_speed ((*i)->speed(), true)) {
 846                                 post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
 847                         }
 848                 }
 849
 850                 if (post_transport_work & (PostTransportSpeed|PostTransportReverse)) {
 851                         schedule_butler_transport_work ();
 852                 }
 853         }
 854 }
 855
 856 void
 857 Session::stop_transport (bool abort)
 858 {
 859         if (_transport_speed == 0.0f) {
 860                 return;
 861         }
 862
 863         if (actively_recording() && !(transport_sub_state & StopPendingCapture) &&
 864             _worst_output_latency > current_block_size)
 865         {
 866
 867                 /* we need to capture the audio that has still not yet been received by the system
 868                    at the time the stop is requested, so we have to roll past that time.
 869
 870                    we want to declick before stopping, so schedule the autostop for one
 871                    block before the actual end. we'll declick in the subsequent block,
 872                    and then we'll really be stopped.
 873                 */
 874
 875                 Event *ev = new Event (Event::StopOnce, Event::Replace,
 876                                        _transport_frame + _worst_output_latency - current_block_size,
 877                                        0, 0, abort);
 878
 879                 merge_event (ev);
 880                 transport_sub_state |= StopPendingCapture;
 881                 pending_abort = abort;
 882                 return;
 883         }
 884
 885
 886         if ((transport_sub_state & PendingDeclickOut) == 0) {
 887                 transport_sub_state |= PendingDeclickOut;
 888                 /* we'll be called again after the declick */
 889                 pending_abort = abort;
 890                 return;
 891         }
 892
 893         realtime_stop (abort);
 894         schedule_butler_transport_work ();
 895 }
 896
 897 void
 898 Session::start_transport ()
 899 {
 900         _last_roll_location = _transport_frame;
 901
 902         /* if record status is Enabled, move it to Recording. if its
 903            already Recording, move it to Disabled.
 904         */
 905
 906         switch (record_status()) {
 907         case Enabled:
 908                 if (!Config->get_punch_in()) {
 909                         enable_record ();
 910                 }
 911                 break;
 912
 913         case Recording:
 914                 if (!play_loop) {
 915                         disable_record (false);
 916                 }
 917                 break;
 918
 919         default:
 920                 break;
 921         }
 922
 923         if (!synced_to_jack() || _exporting) {
 924                 actually_start_transport ();
 925         } else {
 926                 waiting_to_start = true;
 927         }
 928 }
 929
 930 void
 931 Session::actually_start_transport ()
 932 {
 933         waiting_to_start = false;
 934
 935         transport_sub_state |= PendingDeclickIn;
 936         _transport_speed = 1.0;
 937
 938         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
 939         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
 940                 (*i)->realtime_set_speed ((*i)->speed(), true);
 941         }
 942
 943         send_mmc_in_another_thread (MIDI::MachineControl::cmdDeferredPlay, 0);
 944
 945         TransportStateChange (); /* EMIT SIGNAL */
 946 }
 947
 948 void
 949 Session::post_transport ()
 950 {
 951         if (post_transport_work & PostTransportAudition) {
 952                 if (auditioner && auditioner->active()) {
 953                         process_function = &Session::process_audition;
 954                 } else {
 955                         process_function = &Session::process_with_events;
 956                 }
 957         }
 958
 959         if (post_transport_work & PostTransportStop) {
 960
 961                 transport_sub_state = 0;
 962         }
 963
 964         if (post_transport_work & PostTransportLocate) {
 965
 966                 if (((Config->get_slave_source() == None && (auto_play_legal && Config->get_auto_play())) && !_exporting) || (post_transport_work & PostTransportRoll)) {
 967                         start_transport ();
 968
 969                 } else {
 970                         transport_sub_state = 0;
 971                 }
 972         }
 973
 974         set_next_event ();
 975
 976         post_transport_work = PostTransportWork (0);
 977 }
 978
 979 void
 980 Session::reset_rf_scale (nframes_t motion)
 981 {
 982         cumulative_rf_motion += motion;
 983
 984         if (cumulative_rf_motion < 4 * _current_frame_rate) {
 985                 rf_scale = 1;
 986         } else if (cumulative_rf_motion < 8 * _current_frame_rate) {
 987                 rf_scale = 4;
 988         } else if (cumulative_rf_motion < 16 * _current_frame_rate) {
 989                 rf_scale = 10;
 990         } else {
 991                 rf_scale = 100;
 992         }
 993
 994         if (motion != 0) {
 995                 set_dirty();
 996         }
 997 }
 998
 999 void
1000 Session::set_slave_source (SlaveSource src)
1001 {
1002         bool reverse = false;
1003         bool non_rt_required = false;
1004
1005         if (_transport_speed) {
1006                 error << _("please stop the transport before adjusting slave settings") << endmsg;
1007                 return;
1008         }
1009
1010 //      if (src == JACK && Config->get_jack_time_master()) {
1011 //              return;
1012 //      }
1013
1014         if (_slave) {
1015                 delete _slave;
1016                 _slave = 0;
1017         }
1018
1019         if (_transport_speed < 0.0) {
1020                 reverse = true;
1021         }
1022
1023         switch (src) {
1024         case None:
1025                 stop_transport ();
1026                 break;
1027
1028         case MTC:
1029                 if (_mtc_port) {
1030                         try {
1031                                 _slave = new MTC_Slave (*this, *_mtc_port);
1032                         }
1033
1034                         catch (failed_constructor& err) {
1035                                 return;
1036                         }
1037
1038                 } else {
1039                         error << _("No MTC port defined: MTC slaving is impossible.") << endmsg;
1040                         return;
1041                 }
1042                 _desired_transport_speed = _transport_speed;
1043                 break;
1044
1045         case JACK:
1046                 _slave = new JACK_Slave (_engine.jack());
1047                 _desired_transport_speed = _transport_speed;
1048                 break;
1049         };
1050
1051         Config->set_slave_source (src);
1052
1053         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1054         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1055                 if (!(*i)->hidden()) {
1056                         if ((*i)->realtime_set_speed ((*i)->speed(), true)) {
1057                                 non_rt_required = true;
1058                         }
1059                         (*i)->set_slaved (_slave);
1060                 }
1061         }
1062
1063         if (reverse) {
1064                 reverse_diskstream_buffers ();
1065         }
1066
1067         if (non_rt_required) {
1068                 post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
1069                 schedule_butler_transport_work ();
1070         }
1071
1072         set_dirty();
1073 }
1074
1075 void
1076 Session::reverse_diskstream_buffers ()
1077 {
1078         post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
1079         schedule_butler_transport_work ();
1080 }
1081
1082 void
1083 Session::set_diskstream_speed (Diskstream* stream, float speed)
1084 {
1085         if (stream->realtime_set_speed (speed, false)) {
1086                 post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
1087                 schedule_butler_transport_work ();
1088                 set_dirty ();
1089         }
1090 }
1091
1092 void
1093 Session::set_audio_range (list<AudioRange>& range)
1094 {
1095         Event *ev = new Event (Event::SetAudioRange, Event::Add, Event::Immediate, 0, 0.0f);
1096         ev->audio_range = range;
1097         queue_event (ev);
1098 }
1099
1100 void
1101 Session::request_play_range (bool yn)
1102 {
1103         Event* ev = new Event (Event::SetPlayRange, Event::Add, Event::Immediate, 0, 0.0f, yn);
1104         queue_event (ev);
1105 }
1106
1107 void
1108 Session::set_play_range (bool yn)
1109 {
1110         /* Called from event-processing context */
1111
1112         if (_play_range != yn) {
1113                 _play_range = yn;
1114                 setup_auto_play ();
1115
1116                 if (!_play_range) {
1117                         /* stop transport */
1118                         Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0f, false);
1119                         merge_event (ev);
1120                 }
1121         }
1122 }
1123
1124 void
1125 Session::setup_auto_play ()
1126 {
1127         /* Called from event-processing context */
1128
1129         Event* ev;
1130
1131         _clear_event_type (Event::RangeStop);
1132         _clear_event_type (Event::RangeLocate);
1133
1134         if (!_play_range) {
1135                 return;
1136         }
1137
1138         list<AudioRange>::size_type sz = current_audio_range.size();
1139
1140         if (sz > 1) {
1141
1142                 list<AudioRange>::iterator i = current_audio_range.begin();
1143                 list<AudioRange>::iterator next;
1144
1145                 while (i != current_audio_range.end()) {
1146
1147                         next = i;
1148                         ++next;
1149
1150                         /* locating/stopping is subject to delays for declicking.
1151                          */
1152
1153                         nframes_t requested_frame = (*i).end;
1154
1155                         if (requested_frame > current_block_size) {
1156                                 requested_frame -= current_block_size;
1157                         } else {
1158                                 requested_frame = 0;
1159                         }
1160
1161                         if (next == current_audio_range.end()) {
1162                                 ev = new Event (Event::RangeStop, Event::Add, requested_frame, 0, 0.0f);
1163                         } else {
1164                                 ev = new Event (Event::RangeLocate, Event::Add, requested_frame, (*next).start, 0.0f);
1165                         }
1166
1167                         merge_event (ev);
1168
1169                         i = next;
1170                 }
1171
1172         } else if (sz == 1) {
1173
1174                 ev = new Event (Event::RangeStop, Event::Add, current_audio_range.front().end, 0, 0.0f);
1175                 merge_event (ev);
1176
1177         }
1178
1179         /* now start rolling at the right place */
1180
1181         ev = new Event (Event::LocateRoll, Event::Add, Event::Immediate, current_audio_range.front().start, 0.0f, false);
1182         merge_event (ev);
1183 }
1184
1185 void
1186 Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
1187 {
1188         request_locate (start, false);
1189         Event *ev = new Event (Event::LocateRollLocate, Event::Add, Event::Immediate, return_to, 1.0);
1190         queue_event (ev);
1191 }
1192
1193 void
1194 Session::request_bounded_roll (nframes_t start, nframes_t end)
1195 {
1196         request_stop ();
1197         Event *ev = new Event (Event::StopOnce, Event::Replace, end, Event::Immediate, 0.0);
1198         queue_event (ev);
1199         request_locate (start, true);
1200 }
1201
1202 void
1203 Session::engine_halted ()
1204 {
1205         bool ignored;
1206
1207         /* there will be no more calls to process(), so
1208            we'd better clean up for ourselves, right now.
1209
1210            but first, make sure the butler is out of
1211            the picture.
1212         */
1213
1214         g_atomic_int_set (&butler_should_do_transport_work, 0);
1215         post_transport_work = PostTransportWork (0);
1216         stop_butler ();
1217
1218         realtime_stop (false);
1219         non_realtime_stop (false, 0, ignored);
1220         transport_sub_state = 0;
1221
1222         TransportStateChange (); /* EMIT SIGNAL */
1223 }
1224
1225
1226 void
1227 Session::xrun_recovery ()
1228 {
1229         if (Config->get_stop_recording_on_xrun() && actively_recording()) {
1230
1231                  HaltOnXrun (); /* EMIT SIGNAL */
1232
1233                 /* it didn't actually halt, but we need
1234                    to handle things in the same way.
1235                 */
1236
1237                 engine_halted();
1238         }
1239 }
1240
1241 void
1242 Session::update_latency_compensation (bool with_stop, bool abort)
1243 {
1244         bool update_jack = false;
1245
1246         if (_state_of_the_state & Deletion) {
1247                 return;
1248         }
1249
1250         _worst_track_latency = 0;
1251
1252         boost::shared_ptr<RouteList> r = routes.reader ();
1253
1254         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1255                 if (with_stop) {
1256                         (*i)->handle_transport_stopped (abort, (post_transport_work & PostTransportLocate),
1257                                                         (!(post_transport_work & PostTransportLocate) || pending_locate_flush));
1258                 }
1259
1260                 nframes_t old_latency = (*i)->signal_latency ();
1261                 nframes_t track_latency = (*i)->update_total_latency ();
1262
1263                 if (old_latency != track_latency) {
1264                         update_jack = true;
1265                 }
1266
1267                 if (!(*i)->hidden() && ((*i)->active())) {
1268                         _worst_track_latency = max (_worst_track_latency, track_latency);
1269                 }
1270         }
1271
1272         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1273                 (*i)->set_latency_delay (_worst_track_latency);
1274         }
1275
1276         /* tell JACK to play catch up */
1277
1278         if (update_jack) {
1279                 _engine.update_total_latencies ();
1280         }
1281
1282         set_worst_io_latencies ();
1283
1284         /* reflect any changes in latencies into capture offsets
1285         */
1286
1287         boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1288
1289         for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1290                 (*i)->set_capture_offset ();
1291         }
1292 }
1293
1294 void
1295 Session::update_latency_compensation_proxy (void* ignored)
1296 {
1297         update_latency_compensation (false, false);
1298 }
1299
1300 void
1301 Session::allow_auto_play (bool yn)
1302 {
1303         auto_play_legal = yn;
1304 }
1305
1306 void
1307 Session::reset_jack_connection (jack_client_t* jack)
1308 {
1309         JACK_Slave* js;
1310
1311         if (_slave && ((js = dynamic_cast<JACK_Slave*> (_slave)) != 0)) {
1312                 js->reset_client (jack);
1313         }
1314 }