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 Track::FreezeRecord::~FreezeRecord ()
 186 {
 187         for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
 188                 delete *i;
 189         }
 190 }
 191
 192 Track::FreezeState
 193 Track::freeze_state() const
 194 {
 195         return _freeze_record.state;
 196 }
 197
 198 Track::RecEnableControllable::RecEnableControllable (Track& s)
 199         : Controllable (X_("recenable")), track (s)
 200 {
 201 }
 202
 203 void
 204 Track::RecEnableControllable::set_value (double val)
 205 {
 206         bool bval = ((val >= 0.5) ? true: false);
 207         track.set_record_enabled (bval, this);
 208 }
 209
 210 double
 211 Track::RecEnableControllable::get_value (void) const
 212 {
 213         if (track.record_enabled()) { return 1.0; }
 214         return 0.0;
 215 }
 216
 217 bool
 218 Track::record_enabled () const
 219 {
 220         return _diskstream && _diskstream->record_enabled ();
 221 }
 222
 223 bool
 224 Track::can_record()
 225 {
 226         bool will_record = true;
 227         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
 228                 if (!i->connected())
 229                         will_record = false;
 230         }
 231
 232         return will_record;
 233 }
 234
 235 /* Turn off visible processors (except Fader), keeping track of the old states */
 236 void
 237 Track::deactivate_visible_processors ()
 238 {
 239         _deactivated_processors.clear ();
 240         Glib::RWLock::ReaderLock lm (_processor_lock);
 241
 242         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 243                 if ((*i)->active() && (*i)->display_to_user() && boost::dynamic_pointer_cast<Amp> (*i) == 0) {
 244                         (*i)->deactivate ();
 245                         _deactivated_processors.push_back (*i);
 246                 }
 247         }
 248 }
 249
 250 /* Turn deactivated processors back on again */
 251 void
 252 Track::activate_deactivated_processors ()
 253 {
 254         for (list<boost::weak_ptr<Processor> >::iterator i = _deactivated_processors.begin(); i != _deactivated_processors.end(); ++i) {
 255                 boost::shared_ptr<Processor> p = i->lock ();
 256                 if (p) {
 257                         p->activate ();
 258                 }
 259         }
 260 }
 261
 262 void
 263 Track::set_record_enabled (bool yn, void *src)
 264 {
 265         if (!_session.writable()) {
 266                 return;
 267         }
 268
 269         if (_freeze_record.state == Frozen) {
 270                 return;
 271         }
 272
 273         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
 274                 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
 275                 return;
 276         }
 277
 278         /* keep track of the meter point as it was before we rec-enabled */
 279         if (!_diskstream->record_enabled()) {
 280                 _saved_meter_point = _meter_point;
 281         }
 282
 283         if (Config->get_do_not_record_plugins ()) {
 284                 if (yn) {
 285                         deactivate_visible_processors ();
 286                 } else {
 287                         activate_deactivated_processors ();
 288                 }
 289         }
 290
 291         _diskstream->set_record_enabled (yn);
 292
 293         if (_diskstream->record_enabled()) {
 294                 if (_meter_point != MeterCustom) {
 295                         set_meter_point (MeterInput);
 296                 }
 297         } else {
 298                 set_meter_point (_saved_meter_point);
 299         }
 300
 301         _rec_enable_control->Changed ();
 302 }
 303
 304
 305 bool
 306 Track::set_name (const string& str)
 307 {
 308         bool ret;
 309
 310         if (record_enabled() && _session.actively_recording()) {
 311                 /* this messes things up if done while recording */
 312                 return false;
 313         }
 314
 315         _diskstream->set_name (str);
 316
 317         /* save state so that the statefile fully reflects any filename changes */
 318
 319         if ((ret = Route::set_name (str)) == 0) {
 320                 _session.save_state ("");
 321         }
 322
 323         return ret;
 324 }
 325
 326 void
 327 Track::set_latency_compensation (framecnt_t longest_session_latency)
 328 {
 329         Route::set_latency_compensation (longest_session_latency);
 330         _diskstream->set_roll_delay (_roll_delay);
 331 }
 332
 333 int
 334 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
 335 {
 336         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 337         if (!lm.locked()) {
 338                 return 0;
 339         }
 340
 341         bool can_record = _session.actively_recording ();
 342
 343         if (n_outputs().n_total() == 0) {
 344                 return 0;
 345         }
 346
 347         if (!_active) {
 348                 silence (nframes);
 349                 return 0;
 350         }
 351
 352         if (session_state_changing) {
 353                 if (_session.transport_speed() != 0.0f) {
 354                         /* we're rolling but some state is changing (e.g. our diskstream contents)
 355                            so we cannot use them. Be silent till this is over. Don't declick.
 356
 357                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
 358                         */
 359                         passthru_silence (start_frame, end_frame, nframes, 0);
 360                         return 0;
 361                 }
 362                 /* we're really not rolling, so we're either delivery silence or actually
 363                    monitoring, both of which are safe to do while session_state_changing is true.
 364                 */
 365         }
 366
 367         _diskstream->check_record_status (start_frame, can_record);
 368
 369         bool be_silent;
 370
 371         if (_have_internal_generator) {
 372                 /* since the instrument has no input streams,
 373                    there is no reason to send any signal
 374                    into the route.
 375                 */
 376                 be_silent = true;
 377         } else {
 378                 MonitorState const s = monitoring_state ();
 379                 /* we are not rolling, so be silent even if we are monitoring disk, as there
 380                    will be no disk data coming in.
 381                 */
 382                 be_silent = (s == MonitoringSilence || s == MonitoringDisk);
 383         }
 384
 385         if (!_have_internal_generator && metering_state() == MeteringInput) {
 386                 _input->process_input (_meter, start_frame, end_frame, nframes);
 387         }
 388
 389         _amp->apply_gain_automation(false);
 390
 391         /* if have_internal_generator, or .. */
 392         //_input->process_input (_meter, start_frame, end_frame, nframes);
 393
 394         if (be_silent) {
 395
 396                 passthru_silence (start_frame, end_frame, nframes, 0);
 397
 398         } else {
 399
 400                 /* we're sending signal, but we may still want to meter the input.
 401                  */
 402
 403                 passthru (start_frame, end_frame, nframes, false);
 404         }
 405
 406         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 407                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
 408                 if (d) {
 409                         d->flush_buffers (nframes, end_frame - start_frame - 1);
 410                 }
 411         }
 412
 413         return 0;
 414 }
 415
 416 int
 417 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
 418 {
 419         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 420         if (!lm.locked()) {
 421                 return 0;
 422         }
 423
 424         if (n_outputs().n_total() == 0 && _processors.empty()) {
 425                 return 0;
 426         }
 427
 428         if (!_active) {
 429                 silence (nframes);
 430                 return 0;
 431         }
 432
 433         _silent = true;
 434         _amp->apply_gain_automation(false);
 435
 436         silence (nframes);
 437
 438         framecnt_t playback_distance;
 439         int const dret = _diskstream->process (_session.transport_frame(), nframes, playback_distance);
 440         need_butler = _diskstream->commit (playback_distance);
 441         return dret;
 442 }
 443
 444 void
 445 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
 446 {
 447         _diskstream = ds;
 448
 449         ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
 450         diskstream_playlist_changed ();
 451         ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
 452         ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
 453         ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
 454 }
 455
 456 void
 457 Track::diskstream_playlist_changed ()
 458 {
 459         PlaylistChanged (); /* EMIT SIGNAL */
 460 }
 461
 462 void
 463 Track::diskstream_record_enable_changed ()
 464 {
 465         RecordEnableChanged (); /* EMIT SIGNAL */
 466 }
 467
 468 void
 469 Track::diskstream_speed_changed ()
 470 {
 471         SpeedChanged (); /* EMIT SIGNAL */
 472 }
 473
 474 void
 475 Track::diskstream_alignment_style_changed ()
 476 {
 477         AlignmentStyleChanged (); /* EMIT SIGNAL */
 478 }
 479
 480 boost::shared_ptr<Playlist>
 481 Track::playlist ()
 482 {
 483         return _diskstream->playlist ();
 484 }
 485
 486 void
 487 Track::request_jack_monitors_input (bool m)
 488 {
 489         _diskstream->request_jack_monitors_input (m);
 490 }
 491
 492 void
 493 Track::ensure_jack_monitors_input (bool m)
 494 {
 495         _diskstream->ensure_jack_monitors_input (m);
 496 }
 497
 498 bool
 499 Track::destructive () const
 500 {
 501         return _diskstream->destructive ();
 502 }
 503
 504 list<boost::shared_ptr<Source> > &
 505 Track::last_capture_sources ()
 506 {
 507         return _diskstream->last_capture_sources ();
 508 }
 509
 510 void
 511 Track::set_capture_offset ()
 512 {
 513         _diskstream->set_capture_offset ();
 514 }
 515
 516 list<boost::shared_ptr<Source> >
 517 Track::steal_write_sources()
 518 {
 519         return _diskstream->steal_write_sources ();
 520 }
 521
 522 void
 523 Track::reset_write_sources (bool r, bool force)
 524 {
 525         _diskstream->reset_write_sources (r, force);
 526 }
 527
 528 float
 529 Track::playback_buffer_load () const
 530 {
 531         return _diskstream->playback_buffer_load ();
 532 }
 533
 534 float
 535 Track::capture_buffer_load () const
 536 {
 537         return _diskstream->capture_buffer_load ();
 538 }
 539
 540 int
 541 Track::do_refill ()
 542 {
 543         return _diskstream->do_refill ();
 544 }
 545
 546 int
 547 Track::do_flush (RunContext c, bool force)
 548 {
 549         return _diskstream->do_flush (c, force);
 550 }
 551
 552 void
 553 Track::set_pending_overwrite (bool o)
 554 {
 555         _diskstream->set_pending_overwrite (o);
 556 }
 557
 558 int
 559 Track::seek (framepos_t p, bool complete_refill)
 560 {
 561         return _diskstream->seek (p, complete_refill);
 562 }
 563
 564 bool
 565 Track::hidden () const
 566 {
 567         return _diskstream->hidden ();
 568 }
 569
 570 int
 571 Track::can_internal_playback_seek (framepos_t p)
 572 {
 573         return _diskstream->can_internal_playback_seek (p);
 574 }
 575
 576 int
 577 Track::internal_playback_seek (framepos_t p)
 578 {
 579         return _diskstream->internal_playback_seek (p);
 580 }
 581
 582 void
 583 Track::non_realtime_input_change ()
 584 {
 585         _diskstream->non_realtime_input_change ();
 586 }
 587
 588 void
 589 Track::non_realtime_locate (framepos_t p)
 590 {
 591         _diskstream->non_realtime_locate (p);
 592 }
 593
 594 void
 595 Track::non_realtime_set_speed ()
 596 {
 597         _diskstream->non_realtime_set_speed ();
 598 }
 599
 600 int
 601 Track::overwrite_existing_buffers ()
 602 {
 603         return _diskstream->overwrite_existing_buffers ();
 604 }
 605
 606 framecnt_t
 607 Track::get_captured_frames (uint32_t n) const
 608 {
 609         return _diskstream->get_captured_frames (n);
 610 }
 611
 612 int
 613 Track::set_loop (Location* l)
 614 {
 615         return _diskstream->set_loop (l);
 616 }
 617
 618 void
 619 Track::transport_looped (framepos_t p)
 620 {
 621         _diskstream->transport_looped (p);
 622 }
 623
 624 bool
 625 Track::realtime_set_speed (double s, bool g)
 626 {
 627         return _diskstream->realtime_set_speed (s, g);
 628 }
 629
 630 void
 631 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 632 {
 633         _diskstream->transport_stopped_wallclock (n, t, g);
 634 }
 635
 636 bool
 637 Track::pending_overwrite () const
 638 {
 639         return _diskstream->pending_overwrite ();
 640 }
 641
 642 double
 643 Track::speed () const
 644 {
 645         return _diskstream->speed ();
 646 }
 647
 648 void
 649 Track::prepare_to_stop (framepos_t p)
 650 {
 651         _diskstream->prepare_to_stop (p);
 652 }
 653
 654 void
 655 Track::set_slaved (bool s)
 656 {
 657         _diskstream->set_slaved (s);
 658 }
 659
 660 ChanCount
 661 Track::n_channels ()
 662 {
 663         return _diskstream->n_channels ();
 664 }
 665
 666 framepos_t
 667 Track::get_capture_start_frame (uint32_t n) const
 668 {
 669         return _diskstream->get_capture_start_frame (n);
 670 }
 671
 672 AlignStyle
 673 Track::alignment_style () const
 674 {
 675         return _diskstream->alignment_style ();
 676 }
 677
 678 AlignChoice
 679 Track::alignment_choice () const
 680 {
 681         return _diskstream->alignment_choice ();
 682 }
 683
 684 framepos_t
 685 Track::current_capture_start () const
 686 {
 687         return _diskstream->current_capture_start ();
 688 }
 689
 690 framepos_t
 691 Track::current_capture_end () const
 692 {
 693         return _diskstream->current_capture_end ();
 694 }
 695
 696 void
 697 Track::playlist_modified ()
 698 {
 699         _diskstream->playlist_modified ();
 700 }
 701
 702 int
 703 Track::use_playlist (boost::shared_ptr<Playlist> p)
 704 {
 705         int ret = _diskstream->use_playlist (p);
 706         if (ret == 0) {
 707                 p->set_orig_track_id (id());
 708         }
 709         return ret;
 710 }
 711
 712 int
 713 Track::use_copy_playlist ()
 714 {
 715         int ret =  _diskstream->use_copy_playlist ();
 716
 717         if (ret == 0) {
 718                 _diskstream->playlist()->set_orig_track_id (id());
 719         }
 720
 721         return ret;
 722 }
 723
 724 int
 725 Track::use_new_playlist ()
 726 {
 727         int ret = _diskstream->use_new_playlist ();
 728
 729         if (ret == 0) {
 730                 _diskstream->playlist()->set_orig_track_id (id());
 731         }
 732
 733         return ret;
 734 }
 735
 736 void
 737 Track::set_align_style (AlignStyle s, bool force)
 738 {
 739         _diskstream->set_align_style (s, force);
 740 }
 741
 742 void
 743 Track::set_align_choice (AlignChoice s, bool force)
 744 {
 745         _diskstream->set_align_choice (s, force);
 746 }
 747
 748 bool
 749 Track::using_diskstream_id (PBD::ID id) const
 750 {
 751         return (id == _diskstream->id ());
 752 }
 753
 754 void
 755 Track::set_block_size (pframes_t n)
 756 {
 757         Route::set_block_size (n);
 758         _diskstream->set_block_size (n);
 759 }
 760
 761 void
 762 Track::adjust_playback_buffering ()
 763 {
 764         if (_diskstream) {
 765                 _diskstream->adjust_playback_buffering ();
 766         }
 767 }
 768
 769 void
 770 Track::adjust_capture_buffering ()
 771 {
 772         if (_diskstream) {
 773                 _diskstream->adjust_capture_buffering ();
 774         }
 775 }
 776
 777 MonitorState
 778 Track::monitoring_state () const
 779 {
 780         /* Explicit requests */
 781
 782         if (_monitoring & MonitorInput) {
 783                 return MonitoringInput;
 784         }
 785
 786         if (_monitoring & MonitorDisk) {
 787                 return MonitoringDisk;
 788         }
 789
 790         /* This is an implementation of the truth table in doc/monitor_modes.pdf;
 791            I don't think it's ever going to be too pretty too look at.
 792         */
 793
 794         bool const roll = _session.transport_rolling ();
 795         bool const track_rec = _diskstream->record_enabled ();
 796         bool const session_rec = _session.get_record_enabled ();
 797         bool const auto_input = _session.config.get_auto_input ();
 798         bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 799         bool const tape_machine_mode = Config->get_tape_machine_mode ();
 800
 801         if (track_rec) {
 802
 803                 if (!session_rec && roll && auto_input) {
 804                         return MonitoringDisk;
 805                 } else {
 806                         return software_monitor ? MonitoringInput : MonitoringSilence;
 807                 }
 808
 809         } else {
 810
 811                 if (tape_machine_mode) {
 812
 813                         return MonitoringDisk;
 814
 815                 } else {
 816
 817                         if (!roll && auto_input) {
 818                                 return software_monitor ? MonitoringInput : MonitoringSilence;
 819                         } else {
 820                                 return MonitoringDisk;
 821                         }
 822
 823                 }
 824         }
 825
 826         /* NOTREACHED */
 827         return MonitoringSilence;
 828 }
 829
 830 void
 831 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
 832 {
 833         /* never declick if there is an internal generator - we just want it to
 834            keep generating sound without interruption.
 835
 836            ditto if we are monitoring inputs.
 837         */
 838
 839         if (_have_internal_generator || monitoring_choice() == MonitorInput) {
 840                 return;
 841         }
 842
 843         if (!declick) {
 844                 declick = _pending_declick;
 845         }
 846
 847         if (declick != 0) {
 848                 Amp::declick (bufs, nframes, declick);
 849         }
 850 }
 851
 852 framecnt_t
 853 Track::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
 854 {
 855         if (_roll_delay > nframes) {
 856
 857                 _roll_delay -= nframes;
 858                 silence_unlocked (nframes);
 859                 /* transport frame is not legal for caller to use */
 860                 return 0;
 861
 862         } else if (_roll_delay > 0) {
 863
 864                 nframes -= _roll_delay;
 865                 silence_unlocked (_roll_delay);
 866                 transport_frame += _roll_delay;
 867
 868                 /* shuffle all the port buffers for things that lead "out" of this Route
 869                    to reflect that we just wrote _roll_delay frames of silence.
 870                 */
 871
 872                 Glib::RWLock::ReaderLock lm (_processor_lock);
 873                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 874                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
 875                         if (iop) {
 876                                 iop->increment_port_buffer_offset (_roll_delay);
 877                         }
 878                 }
 879                 _output->increment_port_buffer_offset (_roll_delay);
 880
 881                 _roll_delay = 0;
 882
 883         }
 884
 885         return nframes;
 886 }
 887
 888 void
 889 Track::set_monitoring (MonitorChoice mc)
 890 {
 891         if (mc !=  _monitoring) {
 892                 _monitoring = mc;
 893                 MonitoringChanged (); /* EMIT SIGNAL */
 894         }
 895 }
 896
 897 void
 898 Track::parameter_changed (string p)
 899 {
 900         if (p != "do-not-record-plugins") {
 901                 return;
 902         }
 903
 904         if (record_enabled ()) {
 905                 if (Config->get_do_not_record_plugins ()) {
 906                         deactivate_visible_processors ();
 907                 } else {
 908                         activate_deactivated_processors ();
 909                 }
 910         }
 911 }
 912
 913 MeterState
 914 Track::metering_state () const
 915 {
 916         return _diskstream->record_enabled() ? MeteringInput : MeteringRoute;
 917 }