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