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