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