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