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 (!software_monitor && tape_machine_mode && !track_rec) {
 420                                 no_meter=true;
 421                         }
 422                         else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
 423                                 no_meter=true;
 424                         }
 425
 426                         if (no_meter) {
 427                                 _meter->reset();
 428                                 _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, nframes);
 429                         } else {
 430                                 _input->process_input (_meter, start_frame, end_frame, nframes);
 431                         }
 432                 }
 433
 434                 passthru_silence (start_frame, end_frame, nframes, 0);
 435
 436         } else {
 437
 438                 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 439
 440                 fill_buffers_with_input (bufs, _input, nframes);
 441
 442                 if (_meter_point == MeterInput) {
 443                         _meter->run (bufs, start_frame, end_frame, nframes, true);
 444                 }
 445
 446                 passthru (bufs, start_frame, end_frame, nframes, false);
 447         }
 448
 449         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 450                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
 451                 if (d) {
 452                         d->flush_buffers (nframes);
 453                 }
 454         }
 455
 456         return 0;
 457 }
 458
 459 int
 460 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
 461 {
 462         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 463         if (!lm.locked()) {
 464                 return 0;
 465         }
 466
 467         if (n_outputs().n_total() == 0 && _processors.empty()) {
 468                 return 0;
 469         }
 470
 471         if (!_active) {
 472                 silence (nframes);
 473                 return 0;
 474         }
 475
 476         _silent = true;
 477         _amp->apply_gain_automation(false);
 478
 479         silence (nframes);
 480
 481         framecnt_t playback_distance;
 482
 483         BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
 484
 485         int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
 486         need_butler = _diskstream->commit (playback_distance);
 487         return dret;
 488 }
 489
 490 void
 491 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
 492 {
 493         _diskstream = ds;
 494
 495         ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
 496         diskstream_playlist_changed ();
 497         ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
 498         ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
 499         ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
 500 }
 501
 502 void
 503 Track::diskstream_playlist_changed ()
 504 {
 505         PlaylistChanged (); /* EMIT SIGNAL */
 506 }
 507
 508 void
 509 Track::diskstream_record_enable_changed ()
 510 {
 511         RecordEnableChanged (); /* EMIT SIGNAL */
 512 }
 513
 514 void
 515 Track::diskstream_speed_changed ()
 516 {
 517         SpeedChanged (); /* EMIT SIGNAL */
 518 }
 519
 520 void
 521 Track::diskstream_alignment_style_changed ()
 522 {
 523         AlignmentStyleChanged (); /* EMIT SIGNAL */
 524 }
 525
 526 boost::shared_ptr<Playlist>
 527 Track::playlist ()
 528 {
 529         return _diskstream->playlist ();
 530 }
 531
 532 void
 533 Track::request_jack_monitors_input (bool m)
 534 {
 535         _diskstream->request_jack_monitors_input (m);
 536 }
 537
 538 void
 539 Track::ensure_jack_monitors_input (bool m)
 540 {
 541         _diskstream->ensure_jack_monitors_input (m);
 542 }
 543
 544 bool
 545 Track::destructive () const
 546 {
 547         return _diskstream->destructive ();
 548 }
 549
 550 list<boost::shared_ptr<Source> > &
 551 Track::last_capture_sources ()
 552 {
 553         return _diskstream->last_capture_sources ();
 554 }
 555
 556 void
 557 Track::set_capture_offset ()
 558 {
 559         _diskstream->set_capture_offset ();
 560 }
 561
 562 list<boost::shared_ptr<Source> >
 563 Track::steal_write_sources()
 564 {
 565         return _diskstream->steal_write_sources ();
 566 }
 567
 568 void
 569 Track::reset_write_sources (bool r, bool force)
 570 {
 571         _diskstream->reset_write_sources (r, force);
 572 }
 573
 574 float
 575 Track::playback_buffer_load () const
 576 {
 577         return _diskstream->playback_buffer_load ();
 578 }
 579
 580 float
 581 Track::capture_buffer_load () const
 582 {
 583         return _diskstream->capture_buffer_load ();
 584 }
 585
 586 int
 587 Track::do_refill ()
 588 {
 589         return _diskstream->do_refill ();
 590 }
 591
 592 int
 593 Track::do_flush (RunContext c, bool force)
 594 {
 595         return _diskstream->do_flush (c, force);
 596 }
 597
 598 void
 599 Track::set_pending_overwrite (bool o)
 600 {
 601         _diskstream->set_pending_overwrite (o);
 602 }
 603
 604 int
 605 Track::seek (framepos_t p, bool complete_refill)
 606 {
 607         return _diskstream->seek (p, complete_refill);
 608 }
 609
 610 bool
 611 Track::hidden () const
 612 {
 613         return _diskstream->hidden ();
 614 }
 615
 616 int
 617 Track::can_internal_playback_seek (framecnt_t p)
 618 {
 619         return _diskstream->can_internal_playback_seek (p);
 620 }
 621
 622 int
 623 Track::internal_playback_seek (framecnt_t p)
 624 {
 625         return _diskstream->internal_playback_seek (p);
 626 }
 627
 628 void
 629 Track::non_realtime_input_change ()
 630 {
 631         _diskstream->non_realtime_input_change ();
 632 }
 633
 634 void
 635 Track::non_realtime_locate (framepos_t p)
 636 {
 637         Route::non_realtime_locate (p);
 638
 639         if (!hidden()) {
 640                 /* don't waste i/o cycles and butler calls
 641                    for hidden (secret) tracks
 642                 */
 643                 _diskstream->non_realtime_locate (p);
 644         }
 645 }
 646
 647 void
 648 Track::non_realtime_set_speed ()
 649 {
 650         _diskstream->non_realtime_set_speed ();
 651 }
 652
 653 int
 654 Track::overwrite_existing_buffers ()
 655 {
 656         return _diskstream->overwrite_existing_buffers ();
 657 }
 658
 659 framecnt_t
 660 Track::get_captured_frames (uint32_t n) const
 661 {
 662         return _diskstream->get_captured_frames (n);
 663 }
 664
 665 int
 666 Track::set_loop (Location* l)
 667 {
 668         return _diskstream->set_loop (l);
 669 }
 670
 671 void
 672 Track::transport_looped (framepos_t p)
 673 {
 674         _diskstream->transport_looped (p);
 675 }
 676
 677 bool
 678 Track::realtime_set_speed (double s, bool g)
 679 {
 680         return _diskstream->realtime_set_speed (s, g);
 681 }
 682
 683 void
 684 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 685 {
 686         _diskstream->transport_stopped_wallclock (n, t, g);
 687 }
 688
 689 bool
 690 Track::pending_overwrite () const
 691 {
 692         return _diskstream->pending_overwrite ();
 693 }
 694
 695 double
 696 Track::speed () const
 697 {
 698         return _diskstream->speed ();
 699 }
 700
 701 void
 702 Track::prepare_to_stop (framepos_t p)
 703 {
 704         _diskstream->prepare_to_stop (p);
 705 }
 706
 707 void
 708 Track::set_slaved (bool s)
 709 {
 710         _diskstream->set_slaved (s);
 711 }
 712
 713 ChanCount
 714 Track::n_channels ()
 715 {
 716         return _diskstream->n_channels ();
 717 }
 718
 719 framepos_t
 720 Track::get_capture_start_frame (uint32_t n) const
 721 {
 722         return _diskstream->get_capture_start_frame (n);
 723 }
 724
 725 AlignStyle
 726 Track::alignment_style () const
 727 {
 728         return _diskstream->alignment_style ();
 729 }
 730
 731 AlignChoice
 732 Track::alignment_choice () const
 733 {
 734         return _diskstream->alignment_choice ();
 735 }
 736
 737 framepos_t
 738 Track::current_capture_start () const
 739 {
 740         return _diskstream->current_capture_start ();
 741 }
 742
 743 framepos_t
 744 Track::current_capture_end () const
 745 {
 746         return _diskstream->current_capture_end ();
 747 }
 748
 749 void
 750 Track::playlist_modified ()
 751 {
 752         _diskstream->playlist_modified ();
 753 }
 754
 755 int
 756 Track::use_playlist (boost::shared_ptr<Playlist> p)
 757 {
 758         int ret = _diskstream->use_playlist (p);
 759         if (ret == 0) {
 760                 p->set_orig_track_id (id());
 761         }
 762         return ret;
 763 }
 764
 765 int
 766 Track::use_copy_playlist ()
 767 {
 768         int ret =  _diskstream->use_copy_playlist ();
 769
 770         if (ret == 0) {
 771                 _diskstream->playlist()->set_orig_track_id (id());
 772         }
 773
 774         return ret;
 775 }
 776
 777 int
 778 Track::use_new_playlist ()
 779 {
 780         int ret = _diskstream->use_new_playlist ();
 781
 782         if (ret == 0) {
 783                 _diskstream->playlist()->set_orig_track_id (id());
 784         }
 785
 786         return ret;
 787 }
 788
 789 void
 790 Track::set_align_style (AlignStyle s, bool force)
 791 {
 792         _diskstream->set_align_style (s, force);
 793 }
 794
 795 void
 796 Track::set_align_choice (AlignChoice s, bool force)
 797 {
 798         _diskstream->set_align_choice (s, force);
 799 }
 800
 801 bool
 802 Track::using_diskstream_id (PBD::ID id) const
 803 {
 804         return (id == _diskstream->id ());
 805 }
 806
 807 void
 808 Track::set_block_size (pframes_t n)
 809 {
 810         Route::set_block_size (n);
 811         _diskstream->set_block_size (n);
 812 }
 813
 814 void
 815 Track::adjust_playback_buffering ()
 816 {
 817         if (_diskstream) {
 818                 _diskstream->adjust_playback_buffering ();
 819         }
 820 }
 821
 822 void
 823 Track::adjust_capture_buffering ()
 824 {
 825         if (_diskstream) {
 826                 _diskstream->adjust_capture_buffering ();
 827         }
 828 }
 829
 830 MonitorState
 831 Track::monitoring_state () const
 832 {
 833         /* Explicit requests */
 834
 835         if (_monitoring & MonitorInput) {
 836                 return MonitoringInput;
 837         }
 838
 839         if (_monitoring & MonitorDisk) {
 840                 return MonitoringDisk;
 841         }
 842
 843         /* This is an implementation of the truth table in doc/monitor_modes.pdf;
 844            I don't think it's ever going to be too pretty too look at.
 845         */
 846
 847         bool const roll = _session.transport_rolling ();
 848         bool const track_rec = _diskstream->record_enabled ();
 849         bool const auto_input = _session.config.get_auto_input ();
 850         bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 851         bool const tape_machine_mode = Config->get_tape_machine_mode ();
 852         bool session_rec;
 853
 854         /* I suspect that just use actively_recording() is good enough all the
 855          * time, but just to keep the semantics the same as they were before
 856          * sept 26th 2012, we differentiate between the cases where punch is
 857          * enabled and those where it is not.
 858          */
 859
 860         if (_session.config.get_punch_in() || _session.config.get_punch_out()) {
 861                 session_rec = _session.actively_recording ();
 862         } else {
 863                 session_rec = _session.get_record_enabled();
 864         }
 865
 866         if (track_rec) {
 867
 868                 if (!session_rec && roll && auto_input) {
 869                         return MonitoringDisk;
 870                 } else {
 871                         return software_monitor ? MonitoringInput : MonitoringSilence;
 872                 }
 873
 874         } else {
 875
 876                 if (tape_machine_mode) {
 877
 878                         return MonitoringDisk;
 879
 880                 } else {
 881
 882                         if (!roll && auto_input) {
 883                                 return software_monitor ? MonitoringInput : MonitoringSilence;
 884                         } else {
 885                                 return MonitoringDisk;
 886                         }
 887
 888                 }
 889         }
 890
 891         /* NOTREACHED */
 892         return MonitoringSilence;
 893 }
 894
 895 void
 896 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
 897 {
 898         /* never declick if there is an internal generator - we just want it to
 899            keep generating sound without interruption.
 900
 901            ditto if we are monitoring inputs.
 902         */
 903
 904         if (_have_internal_generator || monitoring_choice() == MonitorInput) {
 905                 return;
 906         }
 907
 908         if (!declick) {
 909                 declick = _pending_declick;
 910         }
 911
 912         if (declick != 0) {
 913                 Amp::declick (bufs, nframes, declick);
 914         }
 915 }
 916
 917 framecnt_t
 918 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
 919 {
 920         if (_roll_delay > nframes) {
 921
 922                 _roll_delay -= nframes;
 923                 silence_unlocked (nframes);
 924                 /* transport frame is not legal for caller to use */
 925                 return 0;
 926
 927         } else if (_roll_delay > 0) {
 928
 929                 nframes -= _roll_delay;
 930                 silence_unlocked (_roll_delay);
 931                 transport_frame += _roll_delay;
 932
 933                 /* shuffle all the port buffers for things that lead "out" of this Route
 934                    to reflect that we just wrote _roll_delay frames of silence.
 935                 */
 936
 937                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 938                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 939                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
 940                         if (iop) {
 941                                 iop->increment_port_buffer_offset (_roll_delay);
 942                         }
 943                 }
 944                 _output->increment_port_buffer_offset (_roll_delay);
 945
 946                 _roll_delay = 0;
 947
 948         }
 949
 950         return nframes;
 951 }
 952
 953 void
 954 Track::set_monitoring (MonitorChoice mc)
 955 {
 956         if (mc !=  _monitoring) {
 957                 _monitoring = mc;
 958
 959                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 960                         (*i)->monitoring_changed ();
 961                 }
 962
 963                 MonitoringChanged (); /* EMIT SIGNAL */
 964         }
 965 }
 966
 967 MeterState
 968 Track::metering_state () const
 969 {
 970         bool rv;
 971         if (_session.transport_rolling ()) {
 972                 // audio_track.cc || midi_track.cc roll() runs meter IFF:
 973                 rv = _meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled());
 974         } else {
 975                 // track no_roll() always metering if
 976                 rv = _meter_point == MeterInput;
 977         }
 978         return rv ? MeteringInput : MeteringRoute;
 979 }
 980