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