libs/ardour/track.cc

   1 /*
   2     Copyright (C) 2006 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 #include "pbd/error.h"
  19
  20 #include "ardour/amp.h"
  21 #include "ardour/debug.h"
  22 #include "ardour/delivery.h"
  23 #include "ardour/diskstream.h"
  24 #include "ardour/io_processor.h"
  25 #include "ardour/meter.h"
  26 #include "ardour/playlist.h"
  27 #include "ardour/port.h"
  28 #include "ardour/processor.h"
  29 #include "ardour/route_group_specialized.h"
  30 #include "ardour/session.h"
  31 #include "ardour/session_playlists.h"
  32 #include "ardour/track.h"
  33 #include "ardour/utils.h"
  34
  35 #include "i18n.h"
  36
  37 using namespace std;
  38 using namespace ARDOUR;
  39 using namespace PBD;
  40
  41 Track::Track (Session& sess, string name, Route::Flag flag, TrackMode mode, DataType default_type)
  42         : Route (sess, name, flag, default_type)
  43         , _saved_meter_point (_meter_point)
  44         , _mode (mode)
  45         , _monitoring (MonitorAuto)
  46 {
  47         _freeze_record.state = NoFreeze;
  48         _declickable = true;
  49
  50         Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1));
  51 }
  52
  53 Track::~Track ()
  54 {
  55         DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
  56 }
  57
  58 int
  59 Track::init ()
  60 {
  61         if (Route::init ()) {
  62                 return -1;
  63         }
  64
  65         boost::shared_ptr<Route> rp (shared_from_this());
  66         boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
  67         _rec_enable_control = boost::shared_ptr<RecEnableControl> (new RecEnableControl(rt));
  68         _rec_enable_control->set_flags (Controllable::Toggle);
  69
  70         /* don't add rec_enable_control to controls because we don't want it to
  71          * appear as an automatable parameter
  72          */
  73
  74         return 0;
  75 }
  76
  77 void
  78 Track::use_new_diskstream ()
  79 {
  80         boost::shared_ptr<Diskstream> ds = create_diskstream ();
  81
  82         ds->do_refill_with_alloc ();
  83         ds->set_block_size (_session.get_block_size ());
  84         ds->playlist()->set_orig_track_id (id());
  85
  86         set_diskstream (ds);
  87 }
  88
  89 XMLNode&
  90 Track::get_state ()
  91 {
  92         return state (true);
  93 }
  94
  95 XMLNode&
  96 Track::state (bool full)
  97 {
  98         XMLNode& root (Route::state (full));
  99         root.add_property (X_("monitoring"), enum_2_string (_monitoring));
 100         root.add_property (X_("saved-meter-point"), enum_2_string (_saved_meter_point));
 101         root.add_child_nocopy (_rec_enable_control->get_state());
 102         root.add_child_nocopy (_diskstream->get_state ());
 103
 104         if (!_deactivated_processors.empty ()) {
 105                 XMLNode* node = new XMLNode (X_("DeactivatedProcessors"));
 106                 for (list<boost::weak_ptr<Processor> >::iterator i = _deactivated_processors.begin(); i != _deactivated_processors.end(); ++i) {
 107                         boost::shared_ptr<Processor> p = i->lock ();
 108                         if (p) {
 109                                 XMLNode* c = new XMLNode (X_("Processor"));
 110                                 c->add_property (X_("id"), p->id().to_s());
 111                                 node->add_child_nocopy (*c);
 112                         }
 113                 }
 114                 root.add_child_nocopy (*node);
 115         }
 116
 117         return root;
 118 }
 119
 120 int
 121 Track::set_state (const XMLNode& node, int version)
 122 {
 123         if (Route::set_state (node, version)) {
 124                 return -1;
 125         }
 126
 127         XMLNode* child;
 128
 129         if (version >= 3000) {
 130                 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
 131                         boost::shared_ptr<Diskstream> ds = diskstream_factory (*child);
 132                         ds->do_refill_with_alloc ();
 133                         set_diskstream (ds);
 134                 }
 135         }
 136
 137         if (_diskstream) {
 138                 _diskstream->playlist()->set_orig_track_id (id());
 139         }
 140
 141         /* set rec-enable control *AFTER* setting up diskstream, because it may
 142            want to operate on the diskstream as it sets its own state
 143         */
 144
 145         XMLNodeList nlist = node.children();
 146         for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
 147                 child = *niter;
 148
 149                 XMLProperty* prop;
 150                 if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) {
 151                         if (prop->value() == X_("recenable")) {
 152                                 _rec_enable_control->set_state (*child, version);
 153                         }
 154                 }
 155
 156                 if (child->name() == X_("DeactivatedProcessors")) {
 157                         XMLNodeList dp = child->children ();
 158                         for (XMLNodeConstIterator i = dp.begin(); i != dp.end(); ++i) {
 159                                 assert ((*i)->name() == X_("Processor"));
 160                                 XMLProperty* prop = (*i)->property (X_("id"));
 161                                 boost::shared_ptr<Processor> p = processor_by_id (PBD::ID (prop->value ()));
 162                                 if (p) {
 163                                         _deactivated_processors.push_back (p);
 164                                 }
 165                         }
 166                 }
 167         }
 168
 169         const XMLProperty* prop;
 170
 171         if ((prop = node.property (X_("monitoring"))) != 0) {
 172                 _monitoring = MonitorChoice (string_2_enum (prop->value(), _monitoring));
 173         } else {
 174                 _monitoring = MonitorAuto;
 175         }
 176
 177         if ((prop = node.property (X_("saved-meter-point"))) != 0) {
 178                 _saved_meter_point = MeterPoint (string_2_enum (prop->value(), _saved_meter_point));
 179         } else {
 180                 _saved_meter_point = _meter_point;
 181         }
 182
 183         return 0;
 184 }
 185
 186 XMLNode&
 187 Track::get_template ()
 188 {
 189         return state (false);
 190 }
 191
 192 Track::FreezeRecord::~FreezeRecord ()
 193 {
 194         for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
 195                 delete *i;
 196         }
 197 }
 198
 199 Track::FreezeState
 200 Track::freeze_state() const
 201 {
 202         return _freeze_record.state;
 203 }
 204
 205 Track::RecEnableControl::RecEnableControl (boost::shared_ptr<Track> t)
 206         : AutomationControl (t->session(), RecEnableAutomation, boost::shared_ptr<AutomationList>(), X_("recenable"))
 207         , track (t)
 208 {
 209         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(RecEnableAutomation)));
 210         set_list (gl);
 211 }
 212
 213 void
 214 Track::RecEnableControl::set_value (double val)
 215 {
 216         boost::shared_ptr<Track> t = track.lock ();
 217         if (!t) {
 218                 return;
 219         }
 220
 221         t->set_record_enabled (val >= 0.5 ? true : false, this);
 222 }
 223
 224 double
 225 Track::RecEnableControl::get_value () const
 226 {
 227         boost::shared_ptr<Track> t = track.lock ();
 228         if (!t) {
 229                 return 0;
 230         }
 231
 232         return (t->record_enabled() ? 1.0 : 0.0);
 233 }
 234
 235 bool
 236 Track::record_enabled () const
 237 {
 238         return _diskstream && _diskstream->record_enabled ();
 239 }
 240
 241 bool
 242 Track::can_record()
 243 {
 244         bool will_record = true;
 245         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
 246                 if (!i->connected())
 247                         will_record = false;
 248         }
 249
 250         return will_record;
 251 }
 252
 253 /* Turn off visible processors (except Fader), keeping track of the old states */
 254 void
 255 Track::deactivate_visible_processors ()
 256 {
 257         _deactivated_processors.clear ();
 258         Glib::RWLock::ReaderLock lm (_processor_lock);
 259
 260         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 261                 if ((*i)->active() && (*i)->display_to_user() && boost::dynamic_pointer_cast<Amp> (*i) == 0) {
 262                         (*i)->deactivate ();
 263                         _deactivated_processors.push_back (*i);
 264                 }
 265         }
 266 }
 267
 268 /* Turn deactivated processors back on again */
 269 void
 270 Track::activate_deactivated_processors ()
 271 {
 272         for (list<boost::weak_ptr<Processor> >::iterator i = _deactivated_processors.begin(); i != _deactivated_processors.end(); ++i) {
 273                 boost::shared_ptr<Processor> p = i->lock ();
 274                 if (p) {
 275                         p->activate ();
 276                 }
 277         }
 278 }
 279
 280 void
 281 Track::set_record_enabled (bool yn, void *src)
 282 {
 283         if (!_session.writable()) {
 284                 return;
 285         }
 286
 287         if (_freeze_record.state == Frozen) {
 288                 return;
 289         }
 290
 291         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
 292                 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
 293                 return;
 294         }
 295
 296         /* keep track of the meter point as it was before we rec-enabled */
 297         if (!_diskstream->record_enabled()) {
 298                 _saved_meter_point = _meter_point;
 299         }
 300
 301         if (Config->get_do_not_record_plugins ()) {
 302                 if (yn) {
 303                         deactivate_visible_processors ();
 304                 } else {
 305                         activate_deactivated_processors ();
 306                 }
 307         }
 308
 309         _diskstream->set_record_enabled (yn);
 310
 311         if (_diskstream->record_enabled()) {
 312                 if (_meter_point != MeterCustom) {
 313                         set_meter_point (MeterInput);
 314                 }
 315         } else {
 316                 set_meter_point (_saved_meter_point);
 317         }
 318
 319         _rec_enable_control->Changed ();
 320 }
 321
 322
 323 bool
 324 Track::set_name (const string& str)
 325 {
 326         bool ret;
 327
 328         if (record_enabled() && _session.actively_recording()) {
 329                 /* this messes things up if done while recording */
 330                 return false;
 331         }
 332
 333         boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
 334         if (_diskstream->playlist()->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
 335                 /* Only rename the diskstream (and therefore the playlist) if
 336                    a) the playlist has never had a region added to it and
 337                    b) there is only one playlist for this track.
 338
 339                    If (a) is not followed, people can get confused if, say,
 340                    they have notes about a playlist with a given name and then
 341                    it changes (see mantis #4759).
 342
 343                    If (b) is not followed, we rename the current playlist and not
 344                    the other ones, which is a bit confusing (see mantis #4977).
 345                 */
 346                 _diskstream->set_name (str);
 347         }
 348
 349         /* save state so that the statefile fully reflects any filename changes */
 350
 351         if ((ret = Route::set_name (str)) == 0) {
 352                 _session.save_state ("");
 353         }
 354
 355         return ret;
 356 }
 357
 358 void
 359 Track::set_latency_compensation (framecnt_t longest_session_latency)
 360 {
 361         Route::set_latency_compensation (longest_session_latency);
 362         _diskstream->set_roll_delay (_roll_delay);
 363 }
 364
 365 int
 366 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
 367 {
 368         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 369         if (!lm.locked()) {
 370                 return 0;
 371         }
 372
 373         bool can_record = _session.actively_recording ();
 374
 375         if (n_outputs().n_total() == 0) {
 376                 return 0;
 377         }
 378
 379         if (!_active) {
 380                 silence (nframes);
 381                 return 0;
 382         }
 383
 384         if (session_state_changing) {
 385                 if (_session.transport_speed() != 0.0f) {
 386                         /* we're rolling but some state is changing (e.g. our diskstream contents)
 387                            so we cannot use them. Be silent till this is over. Don't declick.
 388
 389                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
 390                         */
 391                         passthru_silence (start_frame, end_frame, nframes, 0);
 392                         return 0;
 393                 }
 394                 /* we're really not rolling, so we're either delivery silence or actually
 395                    monitoring, both of which are safe to do while session_state_changing is true.
 396                 */
 397         }
 398
 399         _diskstream->check_record_status (start_frame, can_record);
 400
 401         bool be_silent;
 402
 403         if (_have_internal_generator) {
 404                 /* since the instrument has no input streams,
 405                    there is no reason to send any signal
 406                    into the route.
 407                 */
 408                 be_silent = true;
 409         } else {
 410                 MonitorState const s = monitoring_state ();
 411                 /* we are not rolling, so be silent even if we are monitoring disk, as there
 412                    will be no disk data coming in.
 413                 */
 414                 be_silent = (s == MonitoringSilence || s == MonitoringDisk);
 415         }
 416
 417         if (!_have_internal_generator && metering_state() == MeteringInput) {
 418                 _input->process_input (_meter, start_frame, end_frame, nframes);
 419         }
 420
 421         _amp->apply_gain_automation(false);
 422
 423         /* if have_internal_generator, or .. */
 424         //_input->process_input (_meter, start_frame, end_frame, nframes);
 425
 426         if (be_silent) {
 427
 428                 passthru_silence (start_frame, end_frame, nframes, 0);
 429
 430         } else {
 431
 432                 /* we're sending signal, but we may still want to meter the input.
 433                  */
 434
 435                 passthru (start_frame, end_frame, nframes, false);
 436         }
 437
 438         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 439                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
 440                 if (d) {
 441                         d->flush_buffers (nframes);
 442                 }
 443         }
 444
 445         return 0;
 446 }
 447
 448 int
 449 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
 450 {
 451         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 452         if (!lm.locked()) {
 453                 return 0;
 454         }
 455
 456         if (n_outputs().n_total() == 0 && _processors.empty()) {
 457                 return 0;
 458         }
 459
 460         if (!_active) {
 461                 silence (nframes);
 462                 return 0;
 463         }
 464
 465         _silent = true;
 466         _amp->apply_gain_automation(false);
 467
 468         silence (nframes);
 469
 470         framecnt_t playback_distance;
 471         int const dret = _diskstream->process (_session.transport_frame(), nframes, playback_distance);
 472         need_butler = _diskstream->commit (playback_distance);
 473         return dret;
 474 }
 475
 476 void
 477 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
 478 {
 479         _diskstream = ds;
 480
 481         ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
 482         diskstream_playlist_changed ();
 483         ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
 484         ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
 485         ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
 486 }
 487
 488 void
 489 Track::diskstream_playlist_changed ()
 490 {
 491         PlaylistChanged (); /* EMIT SIGNAL */
 492 }
 493
 494 void
 495 Track::diskstream_record_enable_changed ()
 496 {
 497         RecordEnableChanged (); /* EMIT SIGNAL */
 498 }
 499
 500 void
 501 Track::diskstream_speed_changed ()
 502 {
 503         SpeedChanged (); /* EMIT SIGNAL */
 504 }
 505
 506 void
 507 Track::diskstream_alignment_style_changed ()
 508 {
 509         AlignmentStyleChanged (); /* EMIT SIGNAL */
 510 }
 511
 512 boost::shared_ptr<Playlist>
 513 Track::playlist ()
 514 {
 515         return _diskstream->playlist ();
 516 }
 517
 518 void
 519 Track::request_jack_monitors_input (bool m)
 520 {
 521         _diskstream->request_jack_monitors_input (m);
 522 }
 523
 524 void
 525 Track::ensure_jack_monitors_input (bool m)
 526 {
 527         _diskstream->ensure_jack_monitors_input (m);
 528 }
 529
 530 bool
 531 Track::destructive () const
 532 {
 533         return _diskstream->destructive ();
 534 }
 535
 536 list<boost::shared_ptr<Source> > &
 537 Track::last_capture_sources ()
 538 {
 539         return _diskstream->last_capture_sources ();
 540 }
 541
 542 void
 543 Track::set_capture_offset ()
 544 {
 545         _diskstream->set_capture_offset ();
 546 }
 547
 548 list<boost::shared_ptr<Source> >
 549 Track::steal_write_sources()
 550 {
 551         return _diskstream->steal_write_sources ();
 552 }
 553
 554 void
 555 Track::reset_write_sources (bool r, bool force)
 556 {
 557         _diskstream->reset_write_sources (r, force);
 558 }
 559
 560 float
 561 Track::playback_buffer_load () const
 562 {
 563         return _diskstream->playback_buffer_load ();
 564 }
 565
 566 float
 567 Track::capture_buffer_load () const
 568 {
 569         return _diskstream->capture_buffer_load ();
 570 }
 571
 572 int
 573 Track::do_refill ()
 574 {
 575         return _diskstream->do_refill ();
 576 }
 577
 578 int
 579 Track::do_flush (RunContext c, bool force)
 580 {
 581         return _diskstream->do_flush (c, force);
 582 }
 583
 584 void
 585 Track::set_pending_overwrite (bool o)
 586 {
 587         _diskstream->set_pending_overwrite (o);
 588 }
 589
 590 int
 591 Track::seek (framepos_t p, bool complete_refill)
 592 {
 593         return _diskstream->seek (p, complete_refill);
 594 }
 595
 596 bool
 597 Track::hidden () const
 598 {
 599         return _diskstream->hidden ();
 600 }
 601
 602 int
 603 Track::can_internal_playback_seek (framecnt_t p)
 604 {
 605         return _diskstream->can_internal_playback_seek (p);
 606 }
 607
 608 int
 609 Track::internal_playback_seek (framecnt_t p)
 610 {
 611         return _diskstream->internal_playback_seek (p);
 612 }
 613
 614 void
 615 Track::non_realtime_input_change ()
 616 {
 617         _diskstream->non_realtime_input_change ();
 618 }
 619
 620 void
 621 Track::non_realtime_locate (framepos_t p)
 622 {
 623         _diskstream->non_realtime_locate (p);
 624 }
 625
 626 void
 627 Track::non_realtime_set_speed ()
 628 {
 629         _diskstream->non_realtime_set_speed ();
 630 }
 631
 632 int
 633 Track::overwrite_existing_buffers ()
 634 {
 635         return _diskstream->overwrite_existing_buffers ();
 636 }
 637
 638 framecnt_t
 639 Track::get_captured_frames (uint32_t n) const
 640 {
 641         return _diskstream->get_captured_frames (n);
 642 }
 643
 644 int
 645 Track::set_loop (Location* l)
 646 {
 647         return _diskstream->set_loop (l);
 648 }
 649
 650 void
 651 Track::transport_looped (framepos_t p)
 652 {
 653         _diskstream->transport_looped (p);
 654 }
 655
 656 bool
 657 Track::realtime_set_speed (double s, bool g)
 658 {
 659         return _diskstream->realtime_set_speed (s, g);
 660 }
 661
 662 void
 663 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 664 {
 665         _diskstream->transport_stopped_wallclock (n, t, g);
 666 }
 667
 668 bool
 669 Track::pending_overwrite () const
 670 {
 671         return _diskstream->pending_overwrite ();
 672 }
 673
 674 double
 675 Track::speed () const
 676 {
 677         return _diskstream->speed ();
 678 }
 679
 680 void
 681 Track::prepare_to_stop (framepos_t p)
 682 {
 683         _diskstream->prepare_to_stop (p);
 684 }
 685
 686 void
 687 Track::set_slaved (bool s)
 688 {
 689         _diskstream->set_slaved (s);
 690 }
 691
 692 ChanCount
 693 Track::n_channels ()
 694 {
 695         return _diskstream->n_channels ();
 696 }
 697
 698 framepos_t
 699 Track::get_capture_start_frame (uint32_t n) const
 700 {
 701         return _diskstream->get_capture_start_frame (n);
 702 }
 703
 704 AlignStyle
 705 Track::alignment_style () const
 706 {
 707         return _diskstream->alignment_style ();
 708 }
 709
 710 AlignChoice
 711 Track::alignment_choice () const
 712 {
 713         return _diskstream->alignment_choice ();
 714 }
 715
 716 framepos_t
 717 Track::current_capture_start () const
 718 {
 719         return _diskstream->current_capture_start ();
 720 }
 721
 722 framepos_t
 723 Track::current_capture_end () const
 724 {
 725         return _diskstream->current_capture_end ();
 726 }
 727
 728 void
 729 Track::playlist_modified ()
 730 {
 731         _diskstream->playlist_modified ();
 732 }
 733
 734 int
 735 Track::use_playlist (boost::shared_ptr<Playlist> p)
 736 {
 737         int ret = _diskstream->use_playlist (p);
 738         if (ret == 0) {
 739                 p->set_orig_track_id (id());
 740         }
 741         return ret;
 742 }
 743
 744 int
 745 Track::use_copy_playlist ()
 746 {
 747         int ret =  _diskstream->use_copy_playlist ();
 748
 749         if (ret == 0) {
 750                 _diskstream->playlist()->set_orig_track_id (id());
 751         }
 752
 753         return ret;
 754 }
 755
 756 int
 757 Track::use_new_playlist ()
 758 {
 759         int ret = _diskstream->use_new_playlist ();
 760
 761         if (ret == 0) {
 762                 _diskstream->playlist()->set_orig_track_id (id());
 763         }
 764
 765         return ret;
 766 }
 767
 768 void
 769 Track::set_align_style (AlignStyle s, bool force)
 770 {
 771         _diskstream->set_align_style (s, force);
 772 }
 773
 774 void
 775 Track::set_align_choice (AlignChoice s, bool force)
 776 {
 777         _diskstream->set_align_choice (s, force);
 778 }
 779
 780 bool
 781 Track::using_diskstream_id (PBD::ID id) const
 782 {
 783         return (id == _diskstream->id ());
 784 }
 785
 786 void
 787 Track::set_block_size (pframes_t n)
 788 {
 789         Route::set_block_size (n);
 790         _diskstream->set_block_size (n);
 791 }
 792
 793 void
 794 Track::adjust_playback_buffering ()
 795 {
 796         if (_diskstream) {
 797                 _diskstream->adjust_playback_buffering ();
 798         }
 799 }
 800
 801 void
 802 Track::adjust_capture_buffering ()
 803 {
 804         if (_diskstream) {
 805                 _diskstream->adjust_capture_buffering ();
 806         }
 807 }
 808
 809 MonitorState
 810 Track::monitoring_state () const
 811 {
 812         /* Explicit requests */
 813
 814         if (_monitoring & MonitorInput) {
 815                 return MonitoringInput;
 816         }
 817
 818         if (_monitoring & MonitorDisk) {
 819                 return MonitoringDisk;
 820         }
 821
 822         /* This is an implementation of the truth table in doc/monitor_modes.pdf;
 823            I don't think it's ever going to be too pretty too look at.
 824         */
 825
 826         bool const roll = _session.transport_rolling ();
 827         bool const track_rec = _diskstream->record_enabled ();
 828         bool const session_rec = _session.get_record_enabled ();
 829         bool const auto_input = _session.config.get_auto_input ();
 830         bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 831         bool const tape_machine_mode = Config->get_tape_machine_mode ();
 832
 833         if (track_rec) {
 834
 835                 if (!session_rec && roll && auto_input) {
 836                         return MonitoringDisk;
 837                 } else {
 838                         return software_monitor ? MonitoringInput : MonitoringSilence;
 839                 }
 840
 841         } else {
 842
 843                 if (tape_machine_mode) {
 844
 845                         return MonitoringDisk;
 846
 847                 } else {
 848
 849                         if (!roll && auto_input) {
 850                                 return software_monitor ? MonitoringInput : MonitoringSilence;
 851                         } else {
 852                                 return MonitoringDisk;
 853                         }
 854
 855                 }
 856         }
 857
 858         /* NOTREACHED */
 859         return MonitoringSilence;
 860 }
 861
 862 void
 863 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
 864 {
 865         /* never declick if there is an internal generator - we just want it to
 866            keep generating sound without interruption.
 867
 868            ditto if we are monitoring inputs.
 869         */
 870
 871         if (_have_internal_generator || monitoring_choice() == MonitorInput) {
 872                 return;
 873         }
 874
 875         if (!declick) {
 876                 declick = _pending_declick;
 877         }
 878
 879         if (declick != 0) {
 880                 Amp::declick (bufs, nframes, declick);
 881         }
 882 }
 883
 884 framecnt_t
 885 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
 886 {
 887         if (_roll_delay > nframes) {
 888
 889                 _roll_delay -= nframes;
 890                 silence_unlocked (nframes);
 891                 /* transport frame is not legal for caller to use */
 892                 return 0;
 893
 894         } else if (_roll_delay > 0) {
 895
 896                 nframes -= _roll_delay;
 897                 silence_unlocked (_roll_delay);
 898                 transport_frame += _roll_delay;
 899
 900                 /* shuffle all the port buffers for things that lead "out" of this Route
 901                    to reflect that we just wrote _roll_delay frames of silence.
 902                 */
 903
 904                 Glib::RWLock::ReaderLock lm (_processor_lock);
 905                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 906                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
 907                         if (iop) {
 908                                 iop->increment_port_buffer_offset (_roll_delay);
 909                         }
 910                 }
 911                 _output->increment_port_buffer_offset (_roll_delay);
 912
 913                 _roll_delay = 0;
 914
 915         }
 916
 917         return nframes;
 918 }
 919
 920 void
 921 Track::set_monitoring (MonitorChoice mc)
 922 {
 923         if (mc !=  _monitoring) {
 924                 _monitoring = mc;
 925
 926                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 927                         (*i)->monitoring_changed ();
 928                 }
 929
 930                 MonitoringChanged (); /* EMIT SIGNAL */
 931         }
 932 }
 933
 934 void
 935 Track::parameter_changed (string p)
 936 {
 937         if (p != "do-not-record-plugins") {
 938                 return;
 939         }
 940
 941         if (record_enabled ()) {
 942                 if (Config->get_do_not_record_plugins ()) {
 943                         deactivate_visible_processors ();
 944                 } else {
 945                         activate_deactivated_processors ();
 946                 }
 947         }
 948 }
 949
 950 MeterState
 951 Track::metering_state () const
 952 {
 953         return _diskstream->record_enabled() ? MeteringInput : MeteringRoute;
 954 }