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/audiofilesource.h"
  23 #include "ardour/audioregion.h"
  24 #include "ardour/debug.h"
  25 #include "ardour/delivery.h"
  26 #include "ardour/disk_reader.h"
  27 #include "ardour/disk_writer.h"
  28 #include "ardour/event_type_map.h"
  29 #include "ardour/io_processor.h"
  30 #include "ardour/meter.h"
  31 #include "ardour/midi_region.h"
  32 #include "ardour/monitor_control.h"
  33 #include "ardour/playlist.h"
  34 #include "ardour/playlist_factory.h"
  35 #include "ardour/port.h"
  36 #include "ardour/processor.h"
  37 #include "ardour/profile.h"
  38 #include "ardour/region_factory.h"
  39 #include "ardour/record_enable_control.h"
  40 #include "ardour/record_safe_control.h"
  41 #include "ardour/route_group_specialized.h"
  42 #include "ardour/session.h"
  43 #include "ardour/session_playlists.h"
  44 #include "ardour/smf_source.h"
  45 #include "ardour/track.h"
  46 #include "ardour/types_convert.h"
  47 #include "ardour/utils.h"
  48
  49 #include "pbd/i18n.h"
  50
  51 using namespace std;
  52 using namespace ARDOUR;
  53 using namespace PBD;
  54
  55 Track::Track (Session& sess, string name, PresentationInfo::Flag flag, TrackMode mode, DataType default_type)
  56         : Route (sess, name, flag, default_type)
  57         , _saved_meter_point (_meter_point)
  58         , _mode (mode)
  59         , _alignment_choice (Automatic)
  60 {
  61         _freeze_record.state = NoFreeze;
  62         _declickable = true;
  63
  64 }
  65
  66 Track::~Track ()
  67 {
  68         DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
  69
  70         if (_disk_reader) {
  71                 _disk_reader->set_route (boost::shared_ptr<Route>());
  72                 _disk_reader.reset ();
  73         }
  74
  75         if (_disk_writer) {
  76                 _disk_writer->set_route (boost::shared_ptr<Route>());
  77                 _disk_writer.reset ();
  78         }
  79 }
  80
  81 int
  82 Track::init ()
  83 {
  84         if (Route::init ()) {
  85                 return -1;
  86         }
  87
  88         DiskIOProcessor::Flag dflags = DiskIOProcessor::Recordable;
  89
  90         if (_mode == Destructive && !Profile->get_trx()) {
  91                 dflags = DiskIOProcessor::Flag (dflags | DiskIOProcessor::Destructive);
  92         } else if (_mode == NonLayered){
  93                 dflags = DiskIOProcessor::Flag(dflags | DiskIOProcessor::NonLayered);
  94         }
  95
  96         _disk_reader.reset (new DiskReader (_session, name(), dflags));
  97         _disk_reader->set_block_size (_session.get_block_size ());
  98         _disk_reader->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
  99
 100         _disk_writer.reset (new DiskWriter (_session, name(), dflags));
 101         _disk_writer->set_block_size (_session.get_block_size ());
 102         _disk_writer->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
 103
 104         use_new_playlist (data_type());
 105
 106         boost::shared_ptr<Route> rp (boost::dynamic_pointer_cast<Route> (shared_from_this()));
 107         boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
 108
 109         _record_enable_control.reset (new RecordEnableControl (_session, EventTypeMap::instance().to_symbol (RecEnableAutomation), *this));
 110         add_control (_record_enable_control);
 111
 112         _record_safe_control.reset (new RecordSafeControl (_session, EventTypeMap::instance().to_symbol (RecSafeAutomation), *this));
 113         add_control (_record_safe_control);
 114
 115         _monitoring_control.reset (new MonitorControl (_session, EventTypeMap::instance().to_symbol (MonitoringAutomation), *this));
 116         add_control (_monitoring_control);
 117
 118         _session.config.ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1));
 119
 120         _monitoring_control->Changed.connect_same_thread (*this, boost::bind (&Track::monitoring_changed, this, _1, _2));
 121         _record_safe_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_safe_changed, this, _1, _2));
 122         _record_enable_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_enable_changed, this, _1, _2));
 123
 124         _input->changed.connect_same_thread (*this, boost::bind (&Track::input_changed, this));
 125
 126         return 0;
 127 }
 128
 129 void
 130 Track::input_changed ()
 131 {
 132         if (_disk_writer && _alignment_choice == Automatic) {
 133                 set_align_choice_from_io ();
 134         }
 135 }
 136
 137 XMLNode&
 138 Track::get_state ()
 139 {
 140         return state (true);
 141 }
 142
 143 XMLNode&
 144 Track::state (bool full)
 145 {
 146         XMLNode& root (Route::state (full));
 147
 148         if (_playlists[DataType::AUDIO]) {
 149                 root.set_property (X_("audio-playlist"), _playlists[DataType::AUDIO]->id().to_s());
 150         }
 151
 152         if (_playlists[DataType::MIDI]) {
 153                 root.set_property (X_("midi-playlist"), _playlists[DataType::MIDI]->id().to_s());
 154         }
 155
 156         root.add_child_nocopy (_monitoring_control->get_state ());
 157         root.add_child_nocopy (_record_safe_control->get_state ());
 158         root.add_child_nocopy (_record_enable_control->get_state ());
 159
 160         root.set_property (X_("saved-meter-point"), _saved_meter_point);
 161         root.set_property (X_("alignment-choice"), _alignment_choice);
 162
 163         return root;
 164 }
 165
 166 int
 167 Track::set_state (const XMLNode& node, int version)
 168 {
 169         if (Route::set_state (node, version)) {
 170                 return -1;
 171         }
 172
 173         XMLNode* child;
 174
 175         if (version >= 3000 && version < 4000) {
 176                 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
 177                         /* XXX if we remember anything from stored DiskStream
 178                            state (older Ardour versions) that is needed by a
 179                            DiskReader or DiskWriter, we should cook up a new
 180                            XMLNode here, populate it with that information
 181                            (child nodes, properties, etc.) and then call
 182                            ::set_state() on the writer/reader.
 183
 184                            But at present (June 2017), there's no such state.
 185                         */
 186                 }
 187         }
 188
 189         std::string playlist_id;
 190
 191         if (node.get_property (X_("audio-playlist"), playlist_id)) {
 192                 find_and_use_playlist (DataType::AUDIO, PBD::ID (playlist_id));
 193         }
 194
 195         if (node.get_property (X_("midi-playlist"), playlist_id)) {
 196                 find_and_use_playlist (DataType::MIDI, PBD::ID (playlist_id));
 197         }
 198
 199         XMLNodeList nlist = node.children();
 200         for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
 201                 child = *niter;
 202
 203                 if (child->name() == Controllable::xml_node_name) {
 204                         std::string name;
 205                         if (!child->get_property ("name", name)) {
 206                                 continue;
 207                         }
 208
 209                         if (name == _record_enable_control->name()) {
 210                                 _record_enable_control->set_state (*child, version);
 211                         } else if (name == _record_safe_control->name()) {
 212                                 _record_safe_control->set_state (*child, version);
 213                         } else if (name == _monitoring_control->name()) {
 214                                 _monitoring_control->set_state (*child, version);
 215                         }
 216                 }
 217         }
 218
 219         if (!node.get_property (X_("saved-meter-point"), _saved_meter_point)) {
 220                 _saved_meter_point = _meter_point;
 221         }
 222
 223
 224         AlignChoice ac;
 225
 226         if (node.get_property (X_("alignment-choice"), ac)) {
 227                 set_align_choice (ac, true);
 228         }
 229
 230         return 0;
 231 }
 232
 233 XMLNode&
 234 Track::get_template ()
 235 {
 236         return state (false);
 237 }
 238
 239 Track::FreezeRecord::~FreezeRecord ()
 240 {
 241         for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
 242                 delete *i;
 243         }
 244 }
 245
 246 Track::FreezeState
 247 Track::freeze_state() const
 248 {
 249         return _freeze_record.state;
 250 }
 251
 252 bool
 253 Track::can_record()
 254 {
 255         bool will_record = true;
 256         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
 257                 if (!i->connected())
 258                         will_record = false;
 259         }
 260
 261         return will_record;
 262 }
 263
 264 int
 265 Track::prep_record_enabled (bool yn)
 266 {
 267         if (yn && _record_safe_control->get_value()) {
 268                 return -1;
 269         }
 270
 271         if (!can_be_record_enabled()) {
 272                 return -1;
 273         }
 274
 275         /* keep track of the meter point as it was before we rec-enabled */
 276         if (!_disk_writer->record_enabled()) {
 277                 _saved_meter_point = _meter_point;
 278         }
 279
 280         bool will_follow;
 281
 282         if (yn) {
 283                 will_follow = _disk_writer->prep_record_enable ();
 284         } else {
 285                 will_follow = _disk_writer->prep_record_disable ();
 286         }
 287
 288         if (will_follow) {
 289                 if (yn) {
 290                         if (_meter_point != MeterCustom) {
 291                                 set_meter_point (MeterInput);
 292                         }
 293                 } else {
 294                         set_meter_point (_saved_meter_point);
 295                 }
 296         }
 297
 298         return 0;
 299 }
 300
 301 void
 302 Track::record_enable_changed (bool, Controllable::GroupControlDisposition)
 303 {
 304         _disk_writer->set_record_enabled (_record_enable_control->get_value());
 305 }
 306
 307 void
 308 Track::record_safe_changed (bool, Controllable::GroupControlDisposition)
 309 {
 310         _disk_writer->set_record_safe (_record_safe_control->get_value());
 311 }
 312
 313 bool
 314 Track::can_be_record_safe ()
 315 {
 316         return !_record_enable_control->get_value() && _disk_writer && _session.writable() && (_freeze_record.state != Frozen);
 317 }
 318
 319 bool
 320 Track::can_be_record_enabled ()
 321 {
 322         return !_record_safe_control->get_value() && _disk_writer && !_disk_writer->record_safe() && _session.writable() && (_freeze_record.state != Frozen);
 323 }
 324
 325 void
 326 Track::parameter_changed (string const & p)
 327 {
 328         if (p == "track-name-number") {
 329                 resync_track_name ();
 330         }
 331         else if (p == "track-name-take") {
 332                 resync_track_name ();
 333         }
 334         else if (p == "take-name") {
 335                 if (_session.config.get_track_name_take()) {
 336                         resync_track_name ();
 337                 }
 338         }
 339 }
 340
 341 void
 342 Track::resync_track_name ()
 343 {
 344         set_name(name());
 345 }
 346
 347 bool
 348 Track::set_name (const string& str)
 349 {
 350         bool ret;
 351
 352         if (str.empty ()) {
 353                 return false;
 354         }
 355
 356         if (_record_enable_control->get_value()) {
 357                 /* when re-arm'ed the file (named after the track) is already ready to rolll */
 358                 return false;
 359         }
 360
 361         string diskstream_name = "";
 362         if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
 363                 // Note: any text is fine, legalize_for_path() fixes this later
 364                 diskstream_name += _session.config.get_take_name ();
 365                 diskstream_name += "_";
 366         }
 367         const int64_t tracknumber = track_number();
 368         if (tracknumber > 0 && _session.config.get_track_name_number()) {
 369                 char num[64], fmt[10];
 370                 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
 371                 snprintf(num, sizeof(num), fmt, tracknumber);
 372                 diskstream_name += num;
 373                 diskstream_name += "_";
 374         }
 375         diskstream_name += str;
 376
 377         if (diskstream_name == _diskstream_name) {
 378                 return true;
 379         }
 380         _diskstream_name = diskstream_name;
 381
 382         _disk_writer->set_write_source_name (diskstream_name);
 383
 384         boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
 385
 386         if (_playlists[data_type()]->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
 387                 /* Only rename the diskstream (and therefore the playlist) if
 388                    a) the playlist has never had a region added to it and
 389                    b) there is only one playlist for this track.
 390
 391                    If (a) is not followed, people can get confused if, say,
 392                    they have notes about a playlist with a given name and then
 393                    it changes (see mantis #4759).
 394
 395                    If (b) is not followed, we rename the current playlist and not
 396                    the other ones, which is a bit confusing (see mantis #4977).
 397                 */
 398                 _disk_reader->set_name (str);
 399                 _disk_writer->set_name (str);
 400         }
 401
 402         for (uint32_t n = 0; n < DataType::num_types; ++n) {
 403                 if (_playlists[n]) {
 404                         _playlists[n]->set_name (str);
 405                 }
 406         }
 407
 408         /* save state so that the statefile fully reflects any filename changes */
 409
 410         if ((ret = Route::set_name (str)) == 0) {
 411                 _session.save_state ("");
 412         }
 413
 414         return ret;
 415 }
 416
 417 int
 418 Track::no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
 419 {
 420         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 421
 422         if (!lm.locked()) {
 423                 return 0;
 424         }
 425
 426         bool can_record = _session.actively_recording ();
 427
 428         /* no outputs? nothing to do ... what happens if we have sends etc. ? */
 429
 430         if (n_outputs().n_total() == 0 && !ARDOUR::Profile->get_mixbus()) {
 431                 //Note: Mixbus has its own output mechanism, so we should operate even if no explicit outputs are assigned
 432                 return 0;
 433         }
 434
 435         /* not active ... do the minimum possible by just outputting silence */
 436
 437         if (!_active) {
 438                 silence (nframes);
 439                 if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled())) {
 440                         _meter->reset();
 441                 }
 442                 return 0;
 443         }
 444
 445         if (session_state_changing) {
 446                 if (_session.transport_speed() != 0.0f) {
 447                         /* we're rolling but some state is changing (e.g. our
 448                            disk reader contents) so we cannot use them. Be
 449                            silent till this is over. Don't declick.
 450
 451                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
 452                         */
 453                         passthru_silence (start_sample, end_sample, nframes, 0);
 454                         return 0;
 455                 }
 456                 /* we're really not rolling, so we're either delivery silence or actually
 457                    monitoring, both of which are safe to do while session_state_changing is true.
 458                 */
 459         }
 460
 461         _disk_writer->check_record_status (start_sample, can_record);
 462
 463         bool be_silent;
 464
 465         MonitorState const s = monitoring_state ();
 466         /* we are not rolling, so be silent even if we are monitoring disk, as there
 467            will be no disk data coming in.
 468         */
 469         switch (s) {
 470         case MonitoringSilence:
 471                 be_silent = true;
 472                 break;
 473         case MonitoringDisk:
 474                 be_silent = true;
 475                 break;
 476         case MonitoringInput:
 477                 be_silent = false;
 478                 break;
 479         default:
 480                 be_silent = false;
 481                 break;
 482         }
 483
 484         //if we have an internal generator, let it play regardless of monitoring state
 485         if (_have_internal_generator) {
 486                 be_silent = false;
 487         }
 488
 489         /* if have_internal_generator, or .. */
 490
 491         if (be_silent) {
 492
 493                 if (_meter_point == MeterInput) {
 494                         /* still need input monitoring and metering */
 495
 496                         bool const track_rec = _disk_writer->record_enabled ();
 497                         bool const auto_input = _session.config.get_auto_input ();
 498                         bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 499                         bool const tape_machine_mode = Config->get_tape_machine_mode ();
 500                         bool no_meter = false;
 501
 502                         /* this needs a proper K-map
 503                          * and should be separated into a function similar to monitoring_state()
 504                          * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
 505                          *
 506                          * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
 507                          */
 508                         if (!auto_input && !track_rec) {
 509                                 no_meter=true;
 510                         }
 511                         else if (tape_machine_mode && !track_rec && auto_input) {
 512                                 no_meter=true;
 513                         }
 514                         else if (!software_monitor && tape_machine_mode && !track_rec) {
 515                                 no_meter=true;
 516                         }
 517                         else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
 518                                 no_meter=true;
 519                         }
 520
 521                         if (no_meter) {
 522                                 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
 523                                 _meter->run (bufs, start_sample, end_sample, 1.0, nframes, true);
 524                                 _input->process_input (boost::shared_ptr<Processor>(), start_sample, end_sample, _session.transport_speed(), nframes);
 525                         } else {
 526                                 _input->process_input (_meter, start_sample, end_sample, _session.transport_speed(), nframes);
 527                         }
 528                 }
 529
 530                 passthru_silence (start_sample, end_sample, nframes, 0);
 531
 532         } else {
 533
 534                 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
 535
 536                 fill_buffers_with_input (bufs, _input, nframes);
 537
 538                 if (_meter_point == MeterInput) {
 539                         _meter->run (bufs, start_sample, end_sample, _session.transport_speed(), nframes, true);
 540                 }
 541
 542                 passthru (bufs, start_sample, end_sample, nframes, false, true);
 543         }
 544
 545         flush_processor_buffers_locked (nframes);
 546
 547         return 0;
 548 }
 549
 550 boost::shared_ptr<Playlist>
 551 Track::playlist ()
 552 {
 553         return _playlists[data_type()];
 554 }
 555
 556 void
 557 Track::request_input_monitoring (bool m)
 558 {
 559         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
 560                 AudioEngine::instance()->request_input_monitoring ((*i)->name(), m);
 561         }
 562 }
 563
 564 void
 565 Track::ensure_input_monitoring (bool m)
 566 {
 567         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
 568                 AudioEngine::instance()->ensure_input_monitoring ((*i)->name(), m);
 569         }
 570 }
 571
 572 bool
 573 Track::destructive () const
 574 {
 575         return _disk_writer->destructive ();
 576 }
 577
 578 list<boost::shared_ptr<Source> > &
 579 Track::last_capture_sources ()
 580 {
 581         return _disk_writer->last_capture_sources ();
 582 }
 583
 584 void
 585 Track::update_latency_information ()
 586 {
 587         Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
 588         samplecnt_t chain_latency = _input->latency ();
 589
 590         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
 591                 (*p)->set_input_latency (chain_latency);
 592                 chain_latency += (*p)->signal_latency ();
 593         }
 594 }
 595
 596 std::string
 597 Track::steal_write_source_name()
 598 {
 599         return _disk_writer->steal_write_source_name ();
 600 }
 601
 602 void
 603 Track::reset_write_sources (bool r, bool force)
 604 {
 605         _disk_writer->reset_write_sources (r, force);
 606 }
 607
 608 float
 609 Track::playback_buffer_load () const
 610 {
 611         return _disk_reader->buffer_load ();
 612 }
 613
 614 float
 615 Track::capture_buffer_load () const
 616 {
 617         return _disk_writer->buffer_load ();
 618 }
 619
 620 int
 621 Track::do_refill ()
 622 {
 623         return _disk_reader->do_refill ();
 624 }
 625
 626 int
 627 Track::do_flush (RunContext c, bool force)
 628 {
 629         return _disk_writer->do_flush (c, force);
 630 }
 631
 632 void
 633 Track::set_pending_overwrite (bool o)
 634 {
 635         _disk_reader->set_pending_overwrite (o);
 636 }
 637
 638 int
 639 Track::seek (samplepos_t p, bool complete_refill)
 640 {
 641         if (_disk_reader->seek (p, complete_refill)) {
 642                 return -1;
 643         }
 644         return _disk_writer->seek (p, complete_refill);
 645 }
 646
 647 int
 648 Track::can_internal_playback_seek (samplecnt_t p)
 649 {
 650         return _disk_reader->can_internal_playback_seek (p);
 651 }
 652
 653 int
 654 Track::internal_playback_seek (samplecnt_t p)
 655 {
 656         return _disk_reader->internal_playback_seek (p);
 657 }
 658
 659 void
 660 Track::non_realtime_locate (samplepos_t p)
 661 {
 662         Route::non_realtime_locate (p);
 663
 664         if (!is_private_route()) {
 665                 /* don't waste i/o cycles and butler calls
 666                    for private tracks (e.g.auditioner)
 667                 */
 668                 _disk_reader->non_realtime_locate (p);
 669                 _disk_writer->non_realtime_locate (p);
 670         }
 671 }
 672
 673 void
 674 Track::non_realtime_speed_change ()
 675 {
 676         _disk_reader->non_realtime_speed_change ();
 677 }
 678
 679 int
 680 Track::overwrite_existing_buffers ()
 681 {
 682         return _disk_reader->overwrite_existing_buffers ();
 683 }
 684
 685 samplecnt_t
 686 Track::get_captured_samples (uint32_t n) const
 687 {
 688         return _disk_writer->get_captured_samples (n);
 689 }
 690
 691 int
 692 Track::set_loop (Location* l)
 693 {
 694         if (_disk_reader->set_loop (l)) {
 695                 return -1;
 696         }
 697         return _disk_writer->set_loop (l);
 698 }
 699
 700 void
 701 Track::transport_looped (samplepos_t p)
 702 {
 703         return _disk_writer->transport_looped (p);
 704 }
 705
 706 bool
 707 Track::realtime_speed_change ()
 708 {
 709         if (_disk_reader->realtime_speed_change ()) {
 710                 return -1;
 711         }
 712         return _disk_writer->realtime_speed_change ();
 713 }
 714
 715 void
 716 Track::realtime_handle_transport_stopped ()
 717 {
 718         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 719
 720         if (!lm.locked ()) {
 721                 return;
 722         }
 723
 724         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 725                 (*i)->realtime_handle_transport_stopped ();
 726         }
 727 }
 728
 729 void
 730 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 731 {
 732         _disk_writer->transport_stopped_wallclock (n, t, g);
 733 }
 734
 735 bool
 736 Track::pending_overwrite () const
 737 {
 738         return _disk_reader->pending_overwrite ();
 739 }
 740
 741 void
 742 Track::prepare_to_stop (samplepos_t t, samplepos_t a)
 743 {
 744         _disk_writer->prepare_to_stop (t, a);
 745 }
 746
 747 void
 748 Track::set_slaved (bool s)
 749 {
 750         _disk_reader->set_slaved (s);
 751         _disk_writer->set_slaved (s);
 752 }
 753
 754 ChanCount
 755 Track::n_channels ()
 756 {
 757         return _disk_reader->output_streams();
 758 }
 759
 760 samplepos_t
 761 Track::get_capture_start_sample (uint32_t n) const
 762 {
 763         return _disk_writer->get_capture_start_sample (n);
 764 }
 765
 766 AlignStyle
 767 Track::alignment_style () const
 768 {
 769         return _disk_writer->alignment_style ();
 770 }
 771
 772 AlignChoice
 773 Track::alignment_choice () const
 774 {
 775         return _disk_writer->alignment_choice ();
 776 }
 777
 778 samplepos_t
 779 Track::current_capture_start () const
 780 {
 781         return _disk_writer->current_capture_start ();
 782 }
 783
 784 samplepos_t
 785 Track::current_capture_end () const
 786 {
 787         return _disk_writer->current_capture_end ();
 788 }
 789
 790 void
 791 Track::playlist_modified ()
 792 {
 793         _disk_reader->playlist_modified ();
 794 }
 795
 796 int
 797 Track::find_and_use_playlist (DataType dt, PBD::ID const & id)
 798 {
 799         boost::shared_ptr<Playlist> playlist;
 800
 801         if ((playlist = _session.playlists->by_id (id)) == 0) {
 802                 return -1;
 803         }
 804
 805         if (!playlist) {
 806                 error << string_compose(_("DiskIOProcessor: \"%1\" isn't an playlist"), id.to_s()) << endmsg;
 807                 return -1;
 808         }
 809
 810         return use_playlist (dt, playlist);
 811 }
 812
 813 int
 814 Track::use_playlist (DataType dt, boost::shared_ptr<Playlist> p)
 815 {
 816         int ret;
 817
 818         if ((ret = _disk_reader->use_playlist (dt, p)) == 0) {
 819                 if ((ret = _disk_writer->use_playlist (dt, p)) == 0) {
 820                         p->set_orig_track_id (id());
 821                 }
 822         }
 823
 824         if (ret == 0) {
 825                 _playlists[dt] = p;
 826         }
 827
 828         return ret;
 829 }
 830
 831 int
 832 Track::use_copy_playlist ()
 833 {
 834         assert (_playlists[data_type()]);
 835
 836         if (_playlists[data_type()] == 0) {
 837                 error << string_compose(_("DiskIOProcessor %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 838                 return -1;
 839         }
 840
 841         string newname;
 842         boost::shared_ptr<Playlist> playlist;
 843
 844         newname = Playlist::bump_name (_playlists[data_type()]->name(), _session);
 845
 846         if ((playlist = PlaylistFactory::create (_playlists[data_type()], newname)) == 0) {
 847                 return -1;
 848         }
 849
 850         playlist->reset_shares();
 851
 852         return use_playlist (data_type(), playlist);
 853 }
 854
 855 int
 856 Track::use_new_playlist (DataType dt)
 857 {
 858         string newname;
 859         boost::shared_ptr<Playlist> playlist = _playlists[dt];
 860
 861         if (playlist) {
 862                 newname = Playlist::bump_name (playlist->name(), _session);
 863         } else {
 864                 newname = Playlist::bump_name (_name, _session);
 865         }
 866
 867         playlist = PlaylistFactory::create (dt, _session, newname, is_private_route());
 868
 869         if (!playlist) {
 870                 return -1;
 871         }
 872
 873         return use_playlist (dt, playlist);
 874 }
 875
 876 void
 877 Track::set_align_choice (AlignChoice ac, bool force)
 878 {
 879         switch (ac) {
 880         case Automatic:
 881                 _alignment_choice = Automatic;
 882                 set_align_choice_from_io ();
 883                 return;
 884         default:
 885                 break;
 886         }
 887
 888         _disk_writer->set_align_choice (ac, force);
 889         _alignment_choice = ac;
 890 }
 891
 892 void
 893 Track::set_align_style (AlignStyle s, bool force)
 894 {
 895         _disk_writer->set_align_style (s, force);
 896 }
 897
 898 void
 899 Track::set_align_choice_from_io ()
 900 {
 901         bool have_physical = false;
 902
 903         if (_input) {
 904                 uint32_t n = 0;
 905                 vector<string> connections;
 906                 boost::shared_ptr<Port> p;
 907
 908                 while (true) {
 909
 910                         p = _input->nth (n++);
 911
 912                         if (!p) {
 913                                 break;
 914                         }
 915
 916                         if (p->get_connections (connections) != 0) {
 917                                 if (AudioEngine::instance()->port_is_physical (connections[0])) {
 918                                         have_physical = true;
 919                                         break;
 920                                 }
 921                         }
 922
 923                         connections.clear ();
 924                 }
 925         }
 926
 927 #ifdef MIXBUS
 928         // compensate for latency when bouncing from master or mixbus.
 929         // we need to use "ExistingMaterial" to pick up the master bus' latency
 930         // see also Route::direct_feeds_according_to_reality
 931         IOVector ios;
 932         ios.push_back (_input);
 933         if (_session.master_out() && ios.fed_by (_session.master_out()->output())) {
 934                 have_physical = true;
 935         }
 936         for (uint32_t n = 0; n < NUM_MIXBUSES && !have_physical; ++n) {
 937                 if (_session.get_mixbus (n) && ios.fed_by (_session.get_mixbus(n)->output())) {
 938                         have_physical = true;
 939                 }
 940         }
 941 #endif
 942
 943         if (have_physical) {
 944                 _disk_writer->set_align_style (ExistingMaterial);
 945         } else {
 946                 _disk_writer->set_align_style (CaptureTime);
 947         }
 948 }
 949
 950 void
 951 Track::set_block_size (pframes_t n)
 952 {
 953         Route::set_block_size (n);
 954         _disk_reader->set_block_size (n);
 955         _disk_writer->set_block_size (n);
 956 }
 957
 958 void
 959 Track::adjust_playback_buffering ()
 960 {
 961         if (_disk_reader) {
 962                 _disk_reader->adjust_buffering ();
 963         }
 964 }
 965
 966 void
 967 Track::adjust_capture_buffering ()
 968 {
 969         if (_disk_writer) {
 970                 _disk_writer->adjust_buffering ();
 971         }
 972 }
 973
 974
 975 void
 976 Track::maybe_declick (BufferSet& bufs, samplecnt_t nframes, int declick)
 977 {
 978         /* never declick if there is an internal generator - we just want it to
 979            keep generating sound without interruption.
 980
 981            ditto if we are monitoring inputs.
 982         */
 983
 984         if (_have_internal_generator || (_monitoring_control->monitoring_choice() == MonitorInput)) {
 985                 return;
 986         }
 987
 988         if (!declick) {
 989                 declick = _pending_declick;
 990         }
 991
 992         if (declick != 0) {
 993                 Amp::declick (bufs, nframes, declick);
 994         }
 995 }
 996
 997 void
 998 Track::monitoring_changed (bool, Controllable::GroupControlDisposition)
 999 {
1000         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1001                 (*i)->monitoring_changed ();
1002         }
1003 }
1004
1005 MeterState
1006 Track::metering_state () const
1007 {
1008         bool rv;
1009         if (_session.transport_rolling ()) {
1010                 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1011                 rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled());
1012         } else {
1013                 // track no_roll() always metering if
1014                 rv = _meter_point == MeterInput;
1015         }
1016         return rv ? MeteringInput : MeteringRoute;
1017 }
1018
1019 bool
1020 Track::set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure)
1021 {
1022         if (Route::set_processor_state (node, prop, new_order, must_configure)) {
1023                 return true;
1024         }
1025
1026         cerr << name() << " looking for state for track procs, DR = " << _disk_reader << endl;
1027
1028         if (prop->value() == "diskreader") {
1029                 if (_disk_reader) {
1030                         _disk_reader->set_state (node, Stateful::current_state_version);
1031                         new_order.push_back (_disk_reader);
1032                         return true;
1033                 }
1034         } else if (prop->value() == "diskwriter") {
1035                 if (_disk_writer) {
1036                         _disk_writer->set_state (node, Stateful::current_state_version);
1037                         new_order.push_back (_disk_writer);
1038                         return true;
1039                 }
1040         }
1041
1042         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
1043         return false;
1044 }
1045
1046 void
1047 Track::use_captured_sources (SourceList& srcs, CaptureInfos const & capture_info)
1048 {
1049         if (srcs.empty()) {
1050                 return;
1051         }
1052
1053         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (srcs.front());
1054         boost::shared_ptr<SMFSource> mfs = boost::dynamic_pointer_cast<SMFSource> (srcs.front());
1055
1056         if (afs) {
1057                 use_captured_audio_sources (srcs, capture_info);
1058         }
1059
1060         if (mfs) {
1061                 use_captured_midi_sources (srcs, capture_info);
1062         }
1063 }
1064
1065 void
1066 Track::use_captured_midi_sources (SourceList& srcs, CaptureInfos const & capture_info)
1067 {
1068         if (srcs.empty() || data_type() != DataType::MIDI) {
1069                 return;
1070         }
1071
1072         boost::shared_ptr<SMFSource> mfs = boost::dynamic_pointer_cast<SMFSource> (srcs.front());
1073         boost::shared_ptr<Playlist> pl = _playlists[DataType::MIDI];
1074         boost::shared_ptr<MidiRegion> midi_region;
1075         CaptureInfos::const_iterator ci;
1076
1077         if (!mfs || !pl) {
1078                 return;
1079         }
1080
1081         samplecnt_t total_capture = 0;
1082
1083         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1084                 total_capture += (*ci)->samples;
1085         }
1086
1087         /* we will want to be able to keep (over)writing the source
1088            but we don't want it to be removable. this also differs
1089            from the audio situation, where the source at this point
1090            must be considered immutable. luckily, we can rely on
1091            MidiSource::mark_streaming_write_completed() to have
1092            already done the necessary work for that.
1093         */
1094
1095         string whole_file_region_name;
1096         whole_file_region_name = region_name_from_path (mfs->name(), true);
1097
1098         /* Register a new region with the Session that
1099            describes the entire source. Do this first
1100            so that any sub-regions will obviously be
1101            children of this one (later!)
1102         */
1103
1104         try {
1105                 PropertyList plist;
1106
1107                 plist.add (Properties::name, whole_file_region_name);
1108                 plist.add (Properties::whole_file, true);
1109                 plist.add (Properties::automatic, true);
1110                 plist.add (Properties::start, 0);
1111                 plist.add (Properties::length, total_capture);
1112                 plist.add (Properties::layer, 0);
1113
1114                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1115
1116                 midi_region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1117                 midi_region->special_set_position (capture_info.front()->start);
1118         }
1119
1120         catch (failed_constructor& err) {
1121                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1122                 /* XXX what now? */
1123         }
1124
1125         pl->clear_changes ();
1126         pl->freeze ();
1127
1128         /* Session sample time of the initial capture in this pass, which is where the source starts */
1129         samplepos_t initial_capture = 0;
1130         if (!capture_info.empty()) {
1131                 initial_capture = capture_info.front()->start;
1132         }
1133
1134         BeatsSamplesConverter converter (_session.tempo_map(), capture_info.front()->start);
1135         const samplepos_t preroll_off = _session.preroll_record_trim_len ();
1136
1137         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1138
1139                 string region_name;
1140
1141                 RegionFactory::region_name (region_name, mfs->name(), false);
1142
1143                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1144                                                                       _name, (*ci)->start, (*ci)->samples, region_name));
1145
1146
1147                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->samples << " add a region\n";
1148
1149                 try {
1150                         PropertyList plist;
1151
1152                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1153                         plist.add (Properties::start, (*ci)->start - initial_capture);
1154                         plist.add (Properties::length, (*ci)->samples);
1155                         plist.add (Properties::length_beats, converter.from((*ci)->samples).to_double());
1156                         plist.add (Properties::name, region_name);
1157
1158                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1159                         midi_region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1160                         if (preroll_off > 0) {
1161                                 midi_region->trim_front ((*ci)->start - initial_capture + preroll_off);
1162                         }
1163                 }
1164
1165                 catch (failed_constructor& err) {
1166                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1167                         continue; /* XXX is this OK? */
1168                 }
1169
1170                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1171
1172                 pl->add_region (midi_region, (*ci)->start + preroll_off, _disk_writer->non_layered());
1173         }
1174
1175         pl->thaw ();
1176         _session.add_command (new StatefulDiffCommand (pl));
1177 }
1178
1179 void
1180 Track::use_captured_audio_sources (SourceList& srcs, CaptureInfos const & capture_info)
1181 {
1182         if (srcs.empty() || data_type() != DataType::AUDIO) {
1183                 return;
1184         }
1185
1186         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (srcs.front());
1187         boost::shared_ptr<Playlist> pl = _playlists[DataType::AUDIO];
1188         boost::shared_ptr<AudioRegion> region;
1189
1190         if (!afs || !pl) {
1191                 return;
1192         }
1193
1194         /* destructive tracks have a single, never changing region */
1195
1196         if (destructive()) {
1197
1198                 /* send a signal that any UI can pick up to do the right thing. there is
1199                    a small problem here in that a UI may need the peak data to be ready
1200                    for the data that was recorded and this isn't interlocked with that
1201                    process. this problem is deferred to the UI.
1202                  */
1203
1204                 pl->LayeringChanged(); // XXX this may not get the UI to do the right thing
1205                 return;
1206         }
1207
1208         string whole_file_region_name;
1209         whole_file_region_name = region_name_from_path (afs->name(), true);
1210
1211         /* Register a new region with the Session that
1212            describes the entire source. Do this first
1213            so that any sub-regions will obviously be
1214            children of this one (later!)
1215         */
1216
1217         try {
1218                 PropertyList plist;
1219
1220                 plist.add (Properties::start, afs->last_capture_start_sample());
1221                 plist.add (Properties::length, afs->length(0));
1222                 plist.add (Properties::name, whole_file_region_name);
1223                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1224                 rx->set_automatic (true);
1225                 rx->set_whole_file (true);
1226
1227                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1228                 region->special_set_position (afs->natural_position());
1229         }
1230
1231
1232         catch (failed_constructor& err) {
1233                 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1234                 /* XXX what now? */
1235         }
1236
1237         pl->clear_changes ();
1238         pl->set_capture_insertion_in_progress (true);
1239         pl->freeze ();
1240
1241         const samplepos_t preroll_off = _session.preroll_record_trim_len ();
1242         samplecnt_t buffer_position = afs->last_capture_start_sample ();
1243         CaptureInfos::const_iterator ci;
1244
1245         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1246
1247                 string region_name;
1248
1249                 RegionFactory::region_name (region_name, whole_file_region_name, false);
1250
1251                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n",
1252                                                                       _name, (*ci)->start, (*ci)->samples, region_name, buffer_position));
1253
1254                 try {
1255
1256                         PropertyList plist;
1257
1258                         plist.add (Properties::start, buffer_position);
1259                         plist.add (Properties::length, (*ci)->samples);
1260                         plist.add (Properties::name, region_name);
1261
1262                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1263                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1264                         if (preroll_off > 0) {
1265                                 region->trim_front (buffer_position + preroll_off);
1266                         }
1267                 }
1268
1269                 catch (failed_constructor& err) {
1270                         error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1271                         continue; /* XXX is this OK? */
1272                 }
1273
1274                 pl->add_region (region, (*ci)->start + preroll_off, 1, _disk_writer->non_layered());
1275                 pl->set_layer (region, DBL_MAX);
1276
1277                 buffer_position += (*ci)->samples;
1278         }
1279
1280         pl->thaw ();
1281         pl->set_capture_insertion_in_progress (false);
1282         _session.add_command (new StatefulDiffCommand (pl));
1283 }
1284
1285