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