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