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