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