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