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
 500         framecnt_t playback_distance;
 501
 502         BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
 503
 504         int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
 505         need_butler = _diskstream->commit (playback_distance);
 506         return dret;
 507 }
 508
 509 void
 510 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
 511 {
 512         _diskstream = ds;
 513
 514         ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
 515         diskstream_playlist_changed ();
 516         ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
 517         ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
 518 }
 519
 520 void
 521 Track::diskstream_playlist_changed ()
 522 {
 523         PlaylistChanged (); /* EMIT SIGNAL */
 524 }
 525
 526 void
 527 Track::diskstream_speed_changed ()
 528 {
 529         SpeedChanged (); /* EMIT SIGNAL */
 530 }
 531
 532 void
 533 Track::diskstream_alignment_style_changed ()
 534 {
 535         AlignmentStyleChanged (); /* EMIT SIGNAL */
 536 }
 537
 538 boost::shared_ptr<Playlist>
 539 Track::playlist ()
 540 {
 541         return _diskstream->playlist ();
 542 }
 543
 544 void
 545 Track::request_input_monitoring (bool m)
 546 {
 547         _diskstream->request_input_monitoring (m);
 548 }
 549
 550 void
 551 Track::ensure_input_monitoring (bool m)
 552 {
 553         _diskstream->ensure_input_monitoring (m);
 554 }
 555
 556 bool
 557 Track::destructive () const
 558 {
 559         return _diskstream->destructive ();
 560 }
 561
 562 list<boost::shared_ptr<Source> > &
 563 Track::last_capture_sources ()
 564 {
 565         return _diskstream->last_capture_sources ();
 566 }
 567
 568 void
 569 Track::set_capture_offset ()
 570 {
 571         _diskstream->set_capture_offset ();
 572 }
 573
 574 std::string
 575 Track::steal_write_source_name()
 576 {
 577         return _diskstream->steal_write_source_name ();
 578 }
 579
 580 void
 581 Track::reset_write_sources (bool r, bool force)
 582 {
 583         _diskstream->reset_write_sources (r, force);
 584 }
 585
 586 float
 587 Track::playback_buffer_load () const
 588 {
 589         return _diskstream->playback_buffer_load ();
 590 }
 591
 592 float
 593 Track::capture_buffer_load () const
 594 {
 595         return _diskstream->capture_buffer_load ();
 596 }
 597
 598 int
 599 Track::do_refill ()
 600 {
 601         return _diskstream->do_refill ();
 602 }
 603
 604 int
 605 Track::do_flush (RunContext c, bool force)
 606 {
 607         return _diskstream->do_flush (c, force);
 608 }
 609
 610 void
 611 Track::set_pending_overwrite (bool o)
 612 {
 613         _diskstream->set_pending_overwrite (o);
 614 }
 615
 616 int
 617 Track::seek (framepos_t p, bool complete_refill)
 618 {
 619         return _diskstream->seek (p, complete_refill);
 620 }
 621
 622 bool
 623 Track::hidden () const
 624 {
 625         return _diskstream->hidden ();
 626 }
 627
 628 int
 629 Track::can_internal_playback_seek (framecnt_t p)
 630 {
 631         return _diskstream->can_internal_playback_seek (p);
 632 }
 633
 634 int
 635 Track::internal_playback_seek (framecnt_t p)
 636 {
 637         return _diskstream->internal_playback_seek (p);
 638 }
 639
 640 void
 641 Track::non_realtime_input_change ()
 642 {
 643         _diskstream->non_realtime_input_change ();
 644 }
 645
 646 void
 647 Track::non_realtime_locate (framepos_t p)
 648 {
 649         Route::non_realtime_locate (p);
 650
 651         if (!hidden()) {
 652                 /* don't waste i/o cycles and butler calls
 653                    for hidden (secret) tracks
 654                 */
 655                 _diskstream->non_realtime_locate (p);
 656         }
 657 }
 658
 659 void
 660 Track::non_realtime_set_speed ()
 661 {
 662         _diskstream->non_realtime_set_speed ();
 663 }
 664
 665 int
 666 Track::overwrite_existing_buffers ()
 667 {
 668         return _diskstream->overwrite_existing_buffers ();
 669 }
 670
 671 framecnt_t
 672 Track::get_captured_frames (uint32_t n) const
 673 {
 674         return _diskstream->get_captured_frames (n);
 675 }
 676
 677 int
 678 Track::set_loop (Location* l)
 679 {
 680         return _diskstream->set_loop (l);
 681 }
 682
 683 void
 684 Track::transport_looped (framepos_t p)
 685 {
 686         _diskstream->transport_looped (p);
 687 }
 688
 689 bool
 690 Track::realtime_set_speed (double s, bool g)
 691 {
 692         return _diskstream->realtime_set_speed (s, g);
 693 }
 694
 695 void
 696 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 697 {
 698         _diskstream->transport_stopped_wallclock (n, t, g);
 699 }
 700
 701 bool
 702 Track::pending_overwrite () const
 703 {
 704         return _diskstream->pending_overwrite ();
 705 }
 706
 707 double
 708 Track::speed () const
 709 {
 710         return _diskstream->speed ();
 711 }
 712
 713 void
 714 Track::prepare_to_stop (framepos_t t, framepos_t a)
 715 {
 716         _diskstream->prepare_to_stop (t, a);
 717 }
 718
 719 void
 720 Track::set_slaved (bool s)
 721 {
 722         _diskstream->set_slaved (s);
 723 }
 724
 725 ChanCount
 726 Track::n_channels ()
 727 {
 728         return _diskstream->n_channels ();
 729 }
 730
 731 framepos_t
 732 Track::get_capture_start_frame (uint32_t n) const
 733 {
 734         return _diskstream->get_capture_start_frame (n);
 735 }
 736
 737 AlignStyle
 738 Track::alignment_style () const
 739 {
 740         return _diskstream->alignment_style ();
 741 }
 742
 743 AlignChoice
 744 Track::alignment_choice () const
 745 {
 746         return _diskstream->alignment_choice ();
 747 }
 748
 749 framepos_t
 750 Track::current_capture_start () const
 751 {
 752         return _diskstream->current_capture_start ();
 753 }
 754
 755 framepos_t
 756 Track::current_capture_end () const
 757 {
 758         return _diskstream->current_capture_end ();
 759 }
 760
 761 void
 762 Track::playlist_modified ()
 763 {
 764         _diskstream->playlist_modified ();
 765 }
 766
 767 int
 768 Track::use_playlist (boost::shared_ptr<Playlist> p)
 769 {
 770         int ret = _diskstream->use_playlist (p);
 771         if (ret == 0) {
 772                 p->set_orig_track_id (id());
 773         }
 774         return ret;
 775 }
 776
 777 int
 778 Track::use_copy_playlist ()
 779 {
 780         int ret =  _diskstream->use_copy_playlist ();
 781
 782         if (ret == 0) {
 783                 _diskstream->playlist()->set_orig_track_id (id());
 784         }
 785
 786         return ret;
 787 }
 788
 789 int
 790 Track::use_new_playlist ()
 791 {
 792         int ret = _diskstream->use_new_playlist ();
 793
 794         if (ret == 0) {
 795                 _diskstream->playlist()->set_orig_track_id (id());
 796         }
 797
 798         return ret;
 799 }
 800
 801 void
 802 Track::set_align_style (AlignStyle s, bool force)
 803 {
 804         _diskstream->set_align_style (s, force);
 805 }
 806
 807 void
 808 Track::set_align_choice (AlignChoice s, bool force)
 809 {
 810         _diskstream->set_align_choice (s, force);
 811 }
 812
 813 bool
 814 Track::using_diskstream_id (PBD::ID id) const
 815 {
 816         return (id == _diskstream->id ());
 817 }
 818
 819 void
 820 Track::set_block_size (pframes_t n)
 821 {
 822         Route::set_block_size (n);
 823         _diskstream->set_block_size (n);
 824 }
 825
 826 void
 827 Track::adjust_playback_buffering ()
 828 {
 829         if (_diskstream) {
 830                 _diskstream->adjust_playback_buffering ();
 831         }
 832 }
 833
 834 void
 835 Track::adjust_capture_buffering ()
 836 {
 837         if (_diskstream) {
 838                 _diskstream->adjust_capture_buffering ();
 839         }
 840 }
 841
 842 #ifdef USE_TRACKS_CODE_FEATURES
 843
 844 /* This is the Tracks version of Track::monitoring_state().
 845  *
 846  * Ardour developers: try to flag or fix issues if parts of the libardour API
 847  * change in ways that invalidate this
 848  */
 849
 850 MonitorState
 851 Track::monitoring_state () const
 852 {
 853         /* Explicit requests */
 854
 855         if (_monitoring & MonitorInput) {
 856                 return MonitoringInput;
 857         }
 858
 859         if (_monitoring & MonitorDisk) {
 860                 return MonitoringDisk;
 861         }
 862
 863         /* This is an implementation of the truth table in doc/monitor_modes.pdf;
 864            I don't think it's ever going to be too pretty too look at.
 865         */
 866
 867         // GZ: NOT USED IN TRACKS
 868         //bool const auto_input = _session.config.get_auto_input ();
 869         //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 870         //bool const tape_machine_mode = Config->get_tape_machine_mode ();
 871
 872         bool const roll = _session.transport_rolling ();
 873         bool const track_rec = _diskstream->record_enabled ();
 874         bool session_rec = _session.actively_recording ();
 875
 876         if (track_rec) {
 877
 878                 if (!session_rec && roll) {
 879                         return MonitoringDisk;
 880                 } else {
 881                         return MonitoringInput;
 882                 }
 883
 884         } else {
 885
 886                 if (roll) {
 887                         return MonitoringDisk;
 888                 }
 889         }
 890
 891         return MonitoringSilence;
 892 }
 893
 894 #else
 895
 896 /* This is the Ardour/Mixbus version of Track::monitoring_state().
 897  *
 898  * Tracks developers: do NOT modify this method under any circumstances.
 899  */
 900
 901 MonitorState
 902 Track::monitoring_state () const
 903 {
 904         /* Explicit requests */
 905         MonitorChoice m (_monitoring_control->monitoring_choice());
 906
 907         if (m & MonitorInput) {
 908                 return MonitoringInput;
 909         }
 910
 911         if (m & MonitorDisk) {
 912                 return MonitoringDisk;
 913         }
 914
 915         /* This is an implementation of the truth table in doc/monitor_modes.pdf;
 916            I don't think it's ever going to be too pretty too look at.
 917         */
 918
 919         bool const roll = _session.transport_rolling ();
 920         bool const track_rec = _diskstream->record_enabled ();
 921         bool const auto_input = _session.config.get_auto_input ();
 922         bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 923         bool const tape_machine_mode = Config->get_tape_machine_mode ();
 924         bool session_rec;
 925
 926         /* I suspect that just use actively_recording() is good enough all the
 927          * time, but just to keep the semantics the same as they were before
 928          * sept 26th 2012, we differentiate between the cases where punch is
 929          * enabled and those where it is not.
 930          */
 931
 932         if (_session.config.get_punch_in() || _session.config.get_punch_out()) {
 933                 session_rec = _session.actively_recording ();
 934         } else {
 935                 session_rec = _session.get_record_enabled();
 936         }
 937
 938         if (track_rec) {
 939
 940                 if (!session_rec && roll && auto_input) {
 941                         return MonitoringDisk;
 942                 } else {
 943                         return software_monitor ? MonitoringInput : MonitoringSilence;
 944                 }
 945
 946         } else {
 947
 948                 if (tape_machine_mode) {
 949
 950                         return MonitoringDisk;
 951
 952                 } else {
 953
 954                         if (!roll && auto_input) {
 955                                 return software_monitor ? MonitoringInput : MonitoringSilence;
 956                         } else {
 957                                 return MonitoringDisk;
 958                         }
 959
 960                 }
 961         }
 962
 963         abort(); /* NOTREACHED */
 964         return MonitoringSilence;
 965 }
 966
 967 #endif
 968
 969 void
 970 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
 971 {
 972         /* never declick if there is an internal generator - we just want it to
 973            keep generating sound without interruption.
 974
 975            ditto if we are monitoring inputs.
 976         */
 977
 978         if (_have_internal_generator || (_monitoring_control->monitoring_choice() == MonitorInput)) {
 979                 return;
 980         }
 981
 982         if (!declick) {
 983                 declick = _pending_declick;
 984         }
 985
 986         if (declick != 0) {
 987                 Amp::declick (bufs, nframes, declick);
 988         }
 989 }
 990
 991 framecnt_t
 992 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
 993 {
 994         if (_roll_delay > nframes) {
 995
 996                 _roll_delay -= nframes;
 997                 silence_unlocked (nframes);
 998                 /* transport frame is not legal for caller to use */
 999                 return 0;
1000
1001         } else if (_roll_delay > 0) {
1002
1003                 nframes -= _roll_delay;
1004                 silence_unlocked (_roll_delay);
1005                 transport_frame += _roll_delay;
1006
1007                 /* shuffle all the port buffers for things that lead "out" of this Route
1008                    to reflect that we just wrote _roll_delay frames of silence.
1009                 */
1010
1011                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1012                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1013                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1014                         if (iop) {
1015                                 iop->increment_port_buffer_offset (_roll_delay);
1016                         }
1017                 }
1018                 _output->increment_port_buffer_offset (_roll_delay);
1019
1020                 _roll_delay = 0;
1021
1022         }
1023
1024         return nframes;
1025 }
1026
1027 void
1028 Track::monitoring_changed (bool, Controllable::GroupControlDisposition)
1029 {
1030         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1031                 (*i)->monitoring_changed ();
1032         }
1033 }
1034
1035 MeterState
1036 Track::metering_state () const
1037 {
1038         bool rv;
1039         if (_session.transport_rolling ()) {
1040                 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1041                 rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled());
1042         } else {
1043                 // track no_roll() always metering if
1044                 rv = _meter_point == MeterInput;
1045         }
1046         return rv ? MeteringInput : MeteringRoute;
1047 }