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                 be_silent = send_silence ();
 379         }
 380
 381         _amp->apply_gain_automation(false);
 382
 383         if (be_silent) {
 384
 385                 /* if we're sending silence, but we want the meters to show levels for the signal,
 386                    meter right here.
 387                 */
 388
 389                 if (_have_internal_generator) {
 390                         passthru_silence (start_frame, end_frame, nframes, 0);
 391                 } else {
 392                         if (_meter_point == MeterInput) {
 393                                 _input->process_input (_meter, start_frame, end_frame, nframes);
 394                         }
 395                         passthru_silence (start_frame, end_frame, nframes, 0);
 396                 }
 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 bool
 778 Track::send_silence () const
 779 {
 780         bool send_silence;
 781
 782         if (Config->get_tape_machine_mode()) {
 783
 784                 /* ADATs work in a strange way..
 785                    they monitor input always when stopped.and auto-input is engaged.
 786                 */
 787
 788                 if ((Config->get_monitoring_model() == SoftwareMonitoring)
 789                     && ((_monitoring & MonitorInput) || (_diskstream->record_enabled()))) {
 790                         send_silence = false;
 791                 } else {
 792                         send_silence = true;
 793                 }
 794
 795
 796         } else {
 797
 798                 /* Other machines switch to input on stop if the track is record enabled,
 799                    regardless of the auto input setting (auto input only changes the
 800                    monitoring state when the transport is rolling)
 801                 */
 802
 803                 if ((Config->get_monitoring_model() == SoftwareMonitoring)
 804                     && ((_monitoring & MonitorInput) ||
 805                         (!(_monitoring & MonitorDisk) && (_session.config.get_auto_input () || _diskstream->record_enabled())))){
 806
 807                         DEBUG_TRACE (DEBUG::Monitor,
 808                                      string_compose ("%1: no roll, use silence = FALSE,  monitoring choice %2 recenable %3 sRA %4 autoinput %5\n",
 809                                                      name(), enum_2_string (_monitoring),
 810                                                      _diskstream->record_enabled(), _session.actively_recording(),
 811                                                      _session.config.get_auto_input()));
 812
 813                         send_silence = false;
 814                 } else {
 815                         DEBUG_TRACE (DEBUG::Monitor,
 816                                      string_compose ("%1: no roll, use silence = TRUE,  monitoring choice %2 recenable %3 sRA %4 autoinput %5\n",
 817                                                      name(), enum_2_string (_monitoring),
 818                                                      _diskstream->record_enabled(), _session.actively_recording(),
 819                                                      _session.config.get_auto_input()));
 820                         send_silence = true;
 821                 }
 822         }
 823
 824         return send_silence;
 825 }
 826
 827 MonitorState
 828 Track::monitoring_state ()
 829 {
 830         MonitorState ms = MonitoringSilence;
 831
 832         if (_session.transport_rolling()) {
 833
 834                 /* roll case */
 835
 836                 if (_monitoring & MonitorInput) { // explicitly requested input monitoring
 837
 838                         ms = MonitoringInput;
 839
 840                 } else if (_monitoring & MonitorDisk) { // explicitly requested disk monitoring
 841
 842                         ms = MonitoringDisk;
 843
 844                 } else if (_diskstream->record_enabled() && _session.actively_recording()) { // Track actually recording
 845
 846                         ms = MonitoringInput;
 847
 848                 } else if (_diskstream->record_enabled() && !_session.actively_recording() && _session.config.get_auto_input()) { // Track armed but not recording, with auto input enabled
 849
 850                         ms = MonitoringInput;
 851
 852                 } else { // Every other state
 853
 854                         ms = MonitoringDisk;
 855
 856                 }
 857
 858         } else {
 859
 860                 /* no-roll case */
 861
 862                 if (send_silence()) {
 863
 864                         ms = MonitoringSilence;
 865                 } else {
 866
 867                         ms = MonitoringInput;
 868                 }
 869         }
 870
 871         return ms;
 872 }
 873
 874 void
 875 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
 876 {
 877         /* never declick if there is an internal generator - we just want it to
 878            keep generating sound without interruption.
 879
 880            ditto if we are monitoring inputs.
 881         */
 882
 883         if (_have_internal_generator || monitoring_choice() == MonitorInput) {
 884                 return;
 885         }
 886
 887         if (!declick) {
 888                 declick = _pending_declick;
 889         }
 890
 891         if (declick != 0) {
 892                 Amp::declick (bufs, nframes, declick);
 893         }
 894 }
 895
 896 framecnt_t
 897 Track::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
 898 {
 899         if (_roll_delay > nframes) {
 900
 901                 _roll_delay -= nframes;
 902                 silence_unlocked (nframes);
 903                 /* transport frame is not legal for caller to use */
 904                 return 0;
 905
 906         } else if (_roll_delay > 0) {
 907
 908                 nframes -= _roll_delay;
 909                 silence_unlocked (_roll_delay);
 910                 transport_frame += _roll_delay;
 911
 912                 /* shuffle all the port buffers for things that lead "out" of this Route
 913                    to reflect that we just wrote _roll_delay frames of silence.
 914                 */
 915
 916                 Glib::RWLock::ReaderLock lm (_processor_lock);
 917                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 918                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
 919                         if (iop) {
 920                                 iop->increment_port_buffer_offset (_roll_delay);
 921                         }
 922                 }
 923                 _output->increment_port_buffer_offset (_roll_delay);
 924
 925                 _roll_delay = 0;
 926
 927         }
 928
 929         return nframes;
 930 }
 931
 932 void
 933 Track::set_monitoring (MonitorChoice mc)
 934 {
 935         if (mc !=  _monitoring) {
 936                 _monitoring = mc;
 937                 MonitoringChanged (); /* EMIT SIGNAL */
 938         }
 939 }
 940
 941 void
 942 Track::parameter_changed (string p)
 943 {
 944         if (p != "do-not-record-plugins") {
 945                 return;
 946         }
 947
 948         if (record_enabled ()) {
 949                 if (Config->get_do_not_record_plugins ()) {
 950                         deactivate_visible_processors ();
 951                 } else {
 952                         activate_deactivated_processors ();
 953                 }
 954         }
 955 }
 956
 957