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