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