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