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/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         // XXX DISK
 557 }
 558
 559 void
 560 Track::ensure_input_monitoring (bool m)
 561 {
 562         // XXX DISK
 563 }
 564
 565 bool
 566 Track::destructive () const
 567 {
 568         return _disk_writer->destructive ();
 569 }
 570
 571 list<boost::shared_ptr<Source> > &
 572 Track::last_capture_sources ()
 573 {
 574         return _disk_writer->last_capture_sources ();
 575 }
 576
 577 void
 578 Track::set_capture_offset ()
 579 {
 580         _disk_writer->set_capture_offset ();
 581 }
 582
 583 std::string
 584 Track::steal_write_source_name()
 585 {
 586         return _disk_writer->steal_write_source_name ();
 587 }
 588
 589 void
 590 Track::reset_write_sources (bool r, bool force)
 591 {
 592         _disk_writer->reset_write_sources (r, force);
 593 }
 594
 595 float
 596 Track::playback_buffer_load () const
 597 {
 598         return _disk_reader->buffer_load ();
 599 }
 600
 601 float
 602 Track::capture_buffer_load () const
 603 {
 604         return _disk_writer->buffer_load ();
 605 }
 606
 607 int
 608 Track::do_refill ()
 609 {
 610         return _disk_reader->do_refill ();
 611 }
 612
 613 int
 614 Track::do_flush (RunContext c, bool force)
 615 {
 616         return _disk_writer->do_flush (c, force);
 617 }
 618
 619 void
 620 Track::set_pending_overwrite (bool o)
 621 {
 622         _disk_reader->set_pending_overwrite (o);
 623 }
 624
 625 int
 626 Track::seek (framepos_t p, bool complete_refill)
 627 {
 628         if (_disk_reader->seek (p, complete_refill)) {
 629                 return -1;
 630         }
 631         return _disk_writer->seek (p, complete_refill);
 632 }
 633
 634 bool
 635 Track::hidden () const
 636 {
 637         return _disk_writer->hidden () || _disk_reader->hidden();
 638 }
 639
 640 int
 641 Track::can_internal_playback_seek (framecnt_t p)
 642 {
 643         return _disk_reader->can_internal_playback_seek (p);
 644 }
 645
 646 int
 647 Track::internal_playback_seek (framecnt_t p)
 648 {
 649         return _disk_reader->internal_playback_seek (p);
 650 }
 651
 652 void
 653 Track::non_realtime_locate (framepos_t p)
 654 {
 655         Route::non_realtime_locate (p);
 656
 657         if (!hidden()) {
 658                 /* don't waste i/o cycles and butler calls
 659                    for hidden (secret) tracks
 660                 */
 661                 _disk_reader->non_realtime_locate (p);
 662                 _disk_writer->non_realtime_locate (p);
 663         }
 664 }
 665
 666 void
 667 Track::non_realtime_set_speed ()
 668 {
 669         _disk_reader->non_realtime_set_speed ();
 670 }
 671
 672 int
 673 Track::overwrite_existing_buffers ()
 674 {
 675         return _disk_reader->overwrite_existing_buffers ();
 676 }
 677
 678 framecnt_t
 679 Track::get_captured_frames (uint32_t n) const
 680 {
 681         return _disk_writer->get_captured_frames (n);
 682 }
 683
 684 int
 685 Track::set_loop (Location* l)
 686 {
 687         if (_disk_reader->set_loop (l)) {
 688                 return -1;
 689         }
 690         return _disk_writer->set_loop (l);
 691 }
 692
 693 void
 694 Track::transport_looped (framepos_t p)
 695 {
 696         return _disk_writer->transport_looped (p);
 697 }
 698
 699 bool
 700 Track::realtime_set_speed (double s, bool g)
 701 {
 702         if (_disk_reader->realtime_set_speed (s, g)) {
 703                 return -1;
 704         }
 705         return _disk_writer->realtime_set_speed (s, g);
 706 }
 707
 708 void
 709 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 710 {
 711         _disk_writer->transport_stopped_wallclock (n, t, g);
 712 }
 713
 714 bool
 715 Track::pending_overwrite () const
 716 {
 717         return _disk_reader->pending_overwrite ();
 718 }
 719
 720 double
 721 Track::speed () const
 722 {
 723         return _disk_reader->speed ();
 724 }
 725
 726 void
 727 Track::prepare_to_stop (framepos_t t, framepos_t a)
 728 {
 729         _disk_writer->prepare_to_stop (t, a);
 730 }
 731
 732 void
 733 Track::set_slaved (bool s)
 734 {
 735         _disk_reader->set_slaved (s);
 736         _disk_writer->set_slaved (s);
 737 }
 738
 739 ChanCount
 740 Track::n_channels ()
 741 {
 742         return _disk_reader->output_streams(); // XXX DISK
 743 }
 744
 745 framepos_t
 746 Track::get_capture_start_frame (uint32_t n) const
 747 {
 748         return _disk_writer->get_capture_start_frame (n);
 749 }
 750
 751 AlignStyle
 752 Track::alignment_style () const
 753 {
 754         return _disk_writer->alignment_style ();
 755 }
 756
 757 AlignChoice
 758 Track::alignment_choice () const
 759 {
 760         return _disk_writer->alignment_choice ();
 761 }
 762
 763 framepos_t
 764 Track::current_capture_start () const
 765 {
 766         return _disk_writer->current_capture_start ();
 767 }
 768
 769 framepos_t
 770 Track::current_capture_end () const
 771 {
 772         return _disk_writer->current_capture_end ();
 773 }
 774
 775 void
 776 Track::playlist_modified ()
 777 {
 778         _disk_reader->playlist_modified ();
 779 }
 780
 781 int
 782 Track::find_and_use_playlist (DataType dt, PBD::ID const & id)
 783 {
 784         boost::shared_ptr<Playlist> playlist;
 785
 786         if ((playlist = _session.playlists->by_id (id)) == 0) {
 787                 return -1;
 788         }
 789
 790         if (!playlist) {
 791                 error << string_compose(_("DiskIOProcessor: \"%1\" isn't an playlist"), id.to_s()) << endmsg;
 792                 return -1;
 793         }
 794
 795         return use_playlist (dt, playlist);
 796 }
 797
 798 int
 799 Track::use_playlist (DataType dt, boost::shared_ptr<Playlist> p)
 800 {
 801         int ret;
 802
 803         if ((ret = _disk_reader->use_playlist (dt, p)) == 0) {
 804                 if ((ret = _disk_writer->use_playlist (dt, p)) == 0) {
 805                         p->set_orig_track_id (id());
 806                 }
 807         }
 808
 809         if (ret == 0) {
 810                 _playlists[dt] = p;
 811         }
 812
 813         return ret;
 814 }
 815
 816 int
 817 Track::use_copy_playlist ()
 818 {
 819         assert (_playlists[data_type()]);
 820
 821         if (_playlists[data_type()] == 0) {
 822                 error << string_compose(_("DiskIOProcessor %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 823                 return -1;
 824         }
 825
 826         string newname;
 827         boost::shared_ptr<Playlist> playlist;
 828
 829         newname = Playlist::bump_name (_playlists[data_type()]->name(), _session);
 830
 831         if ((playlist = PlaylistFactory::create (_playlists[data_type()], newname)) == 0) {
 832                 return -1;
 833         }
 834
 835         playlist->reset_shares();
 836
 837         return use_playlist (data_type(), playlist);
 838 }
 839
 840 int
 841 Track::use_new_playlist ()
 842 {
 843         string newname;
 844         boost::shared_ptr<Playlist> playlist = _playlists[data_type()];
 845
 846         if (playlist) {
 847                 newname = Playlist::bump_name (playlist->name(), _session);
 848         } else {
 849                 newname = Playlist::bump_name (_name, _session);
 850         }
 851
 852         playlist = PlaylistFactory::create (data_type(), _session, newname, hidden());
 853
 854         if (!playlist) {
 855                 return -1;
 856         }
 857
 858         return use_playlist (data_type(), playlist);
 859 }
 860
 861 void
 862 Track::set_align_style (AlignStyle s, bool force)
 863 {
 864         // XXX DISK
 865 }
 866
 867 void
 868 Track::set_align_choice (AlignChoice s, bool force)
 869 {
 870         // XXX DISK
 871 }
 872
 873 void
 874 Track::set_block_size (pframes_t n)
 875 {
 876         Route::set_block_size (n);
 877         _disk_reader->set_block_size (n);
 878         _disk_writer->set_block_size (n);
 879 }
 880
 881 void
 882 Track::adjust_playback_buffering ()
 883 {
 884         if (_disk_reader) {
 885                 _disk_reader->adjust_buffering ();
 886         }
 887 }
 888
 889 void
 890 Track::adjust_capture_buffering ()
 891 {
 892         if (_disk_writer) {
 893                 _disk_writer->adjust_buffering ();
 894         }
 895 }
 896
 897 #ifdef USE_TRACKS_CODE_FEATURES
 898
 899 /* This is the Tracks version of Track::monitoring_state().
 900  *
 901  * Ardour developers: try to flag or fix issues if parts of the libardour API
 902  * change in ways that invalidate this
 903  */
 904
 905 MonitorState
 906 Track::monitoring_state () const
 907 {
 908         /* Explicit requests */
 909
 910         if (_monitoring & MonitorInput) {
 911                 return MonitoringInput;
 912         }
 913
 914         if (_monitoring & MonitorDisk) {
 915                 return MonitoringDisk;
 916         }
 917
 918         /* This is an implementation of the truth table in doc/monitor_modes.pdf;
 919            I don't think it's ever going to be too pretty too look at.
 920         */
 921
 922         // GZ: NOT USED IN TRACKS
 923         //bool const auto_input = _session.config.get_auto_input ();
 924         //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 925         //bool const tape_machine_mode = Config->get_tape_machine_mode ();
 926
 927         bool const roll = _session.transport_rolling ();
 928         bool const track_rec = _diskstream->record_enabled ();
 929         bool session_rec = _session.actively_recording ();
 930
 931         if (track_rec) {
 932
 933                 if (!session_rec && roll) {
 934                         return MonitoringDisk;
 935                 } else {
 936                         return MonitoringInput;
 937                 }
 938
 939         } else {
 940
 941                 if (roll) {
 942                         return MonitoringDisk;
 943                 }
 944         }
 945
 946         return MonitoringSilence;
 947 }
 948
 949 #else
 950
 951 /* This is the Ardour/Mixbus version of Track::monitoring_state().
 952  *
 953  * Tracks developers: do NOT modify this method under any circumstances.
 954  */
 955
 956 MonitorState
 957 Track::monitoring_state () const
 958 {
 959         /* Explicit requests */
 960         MonitorChoice m (_monitoring_control->monitoring_choice());
 961
 962         if (m & MonitorInput) {
 963                 return MonitoringInput;
 964         }
 965
 966         if (m & MonitorDisk) {
 967                 return MonitoringDisk;
 968         }
 969
 970         switch (_session.config.get_session_monitoring ()) {
 971                 case MonitorDisk:
 972                         return MonitoringDisk;
 973                         break;
 974                 case MonitorInput:
 975                         return MonitoringInput;
 976                         break;
 977                 default:
 978                         break;
 979         }
 980
 981         /* This is an implementation of the truth table in doc/monitor_modes.pdf;
 982            I don't think it's ever going to be too pretty too look at.
 983         */
 984
 985         bool const roll = _session.transport_rolling ();
 986         bool const track_rec = _disk_writer->record_enabled ();
 987         bool const auto_input = _session.config.get_auto_input ();
 988         bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 989         bool const tape_machine_mode = Config->get_tape_machine_mode ();
 990         bool session_rec;
 991
 992         /* I suspect that just use actively_recording() is good enough all the
 993          * time, but just to keep the semantics the same as they were before
 994          * sept 26th 2012, we differentiate between the cases where punch is
 995          * enabled and those where it is not.
 996          *
 997          * rg: I suspect this is not the case: monitoring may differ
 998          */
 999
1000         if (_session.config.get_punch_in() || _session.config.get_punch_out() || _session.preroll_record_punch_enabled ()) {
1001                 session_rec = _session.actively_recording ();
1002         } else {
1003                 session_rec = _session.get_record_enabled();
1004         }
1005
1006         if (track_rec) {
1007
1008                 if (!session_rec && roll && auto_input) {
1009                         return MonitoringDisk;
1010                 } else {
1011                         return software_monitor ? MonitoringInput : MonitoringSilence;
1012                 }
1013
1014         } else {
1015
1016                 if (tape_machine_mode) {
1017
1018                         return MonitoringDisk;
1019
1020                 } else {
1021
1022                         if (!roll && auto_input) {
1023                                 return software_monitor ? MonitoringInput : MonitoringSilence;
1024                         } else {
1025                                 return MonitoringDisk;
1026                         }
1027
1028                 }
1029         }
1030
1031         abort(); /* NOTREACHED */
1032         return MonitoringSilence;
1033 }
1034
1035 #endif
1036
1037 void
1038 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
1039 {
1040         /* never declick if there is an internal generator - we just want it to
1041            keep generating sound without interruption.
1042
1043            ditto if we are monitoring inputs.
1044         */
1045
1046         if (_have_internal_generator || (_monitoring_control->monitoring_choice() == MonitorInput)) {
1047                 return;
1048         }
1049
1050         if (!declick) {
1051                 declick = _pending_declick;
1052         }
1053
1054         if (declick != 0) {
1055                 Amp::declick (bufs, nframes, declick);
1056         }
1057 }
1058
1059 framecnt_t
1060 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
1061 {
1062         if (_roll_delay > nframes) {
1063
1064                 _roll_delay -= nframes;
1065                 silence_unlocked (nframes);
1066                 /* transport frame is not legal for caller to use */
1067                 return 0;
1068
1069         } else if (_roll_delay > 0) {
1070
1071                 nframes -= _roll_delay;
1072                 silence_unlocked (_roll_delay);
1073                 transport_frame += _roll_delay;
1074
1075                 /* shuffle all the port buffers for things that lead "out" of this Route
1076                    to reflect that we just wrote _roll_delay frames of silence.
1077                 */
1078
1079                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1080                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1081                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1082                         if (iop) {
1083                                 iop->increment_port_buffer_offset (_roll_delay);
1084                         }
1085                 }
1086                 _output->increment_port_buffer_offset (_roll_delay);
1087
1088                 _roll_delay = 0;
1089
1090         }
1091
1092         return nframes;
1093 }
1094
1095 void
1096 Track::monitoring_changed (bool, Controllable::GroupControlDisposition)
1097 {
1098         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1099                 (*i)->monitoring_changed ();
1100         }
1101 }
1102
1103 MeterState
1104 Track::metering_state () const
1105 {
1106         bool rv;
1107         if (_session.transport_rolling ()) {
1108                 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1109                 rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled());
1110         } else {
1111                 // track no_roll() always metering if
1112                 rv = _meter_point == MeterInput;
1113         }
1114         return rv ? MeteringInput : MeteringRoute;
1115 }
1116
1117 void
1118 Track::non_realtime_input_change ()
1119 {
1120         // XXX DISK do we need to do anything here anymore ?
1121 }