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