libs/ardour/session_transport.cc

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