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