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