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         }
  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         _disk_reader->set_owner (this);
 100
 101         _disk_writer.reset (new DiskWriter (_session, name(), dflags));
 102         _disk_writer->set_block_size (_session.get_block_size ());
 103         _disk_writer->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
 104         _disk_writer->set_owner (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::state (bool save_template)
 143 {
 144         XMLNode& root (Route::state (save_template));
 145
 146         if (_playlists[DataType::AUDIO]) {
 147                 root.set_property (X_("audio-playlist"), _playlists[DataType::AUDIO]->id().to_s());
 148         }
 149
 150         if (_playlists[DataType::MIDI]) {
 151                 root.set_property (X_("midi-playlist"), _playlists[DataType::MIDI]->id().to_s());
 152         }
 153
 154         root.add_child_nocopy (_monitoring_control->get_state ());
 155         root.add_child_nocopy (_record_safe_control->get_state ());
 156         root.add_child_nocopy (_record_enable_control->get_state ());
 157
 158         root.set_property (X_("saved-meter-point"), _saved_meter_point);
 159         root.set_property (X_("alignment-choice"), _alignment_choice);
 160
 161         return root;
 162 }
 163
 164 int
 165 Track::set_state (const XMLNode& node, int version)
 166 {
 167         if (Route::set_state (node, version)) {
 168                 return -1;
 169         }
 170
 171         if (version >= 3000 && version < 6000) {
 172                 if (XMLNode* ds_node = find_named_node (node, "Diskstream")) {
 173                         std::string name;
 174                         if (ds_node->get_property ("name", name)) {
 175
 176                                 ds_node->set_property ("active", true);
 177
 178                                 _disk_writer->set_state (*ds_node, version);
 179                                 _disk_reader->set_state (*ds_node, version);
 180
 181                                 AlignChoice ac;
 182                                 if (ds_node->get_property (X_("capture-alignment"), ac)) {
 183                                         set_align_choice (ac, true);
 184                                 }
 185
 186                                 if (boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlists->by_name (name))) {
 187                                         use_playlist (DataType::AUDIO, pl);
 188                                 }
 189
 190                                 if (boost::shared_ptr<MidiPlaylist> pl = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) {
 191                                         use_playlist (DataType::MIDI, pl);
 192                                 }
 193                         }
 194                 }
 195         }
 196
 197         XMLNode* child;
 198         std::string playlist_id;
 199
 200         if (node.get_property (X_("audio-playlist"), playlist_id)) {
 201                 find_and_use_playlist (DataType::AUDIO, PBD::ID (playlist_id));
 202         }
 203
 204         if (node.get_property (X_("midi-playlist"), playlist_id)) {
 205                 find_and_use_playlist (DataType::MIDI, PBD::ID (playlist_id));
 206         }
 207
 208         XMLNodeList nlist = node.children();
 209         for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
 210                 child = *niter;
 211
 212                 if (child->name() == Controllable::xml_node_name) {
 213                         std::string name;
 214                         if (!child->get_property ("name", name)) {
 215                                 continue;
 216                         }
 217
 218                         if (name == _record_enable_control->name()) {
 219                                 _record_enable_control->set_state (*child, version);
 220                         } else if (name == _record_safe_control->name()) {
 221                                 _record_safe_control->set_state (*child, version);
 222                         } else if (name == _monitoring_control->name()) {
 223                                 _monitoring_control->set_state (*child, version);
 224                         }
 225                 }
 226         }
 227
 228         if (!node.get_property (X_("saved-meter-point"), _saved_meter_point)) {
 229                 _saved_meter_point = _meter_point;
 230         }
 231
 232
 233         AlignChoice ac;
 234
 235         if (node.get_property (X_("alignment-choice"), ac)) {
 236                 set_align_choice (ac, true);
 237         }
 238
 239         return 0;
 240 }
 241
 242 Track::FreezeRecord::~FreezeRecord ()
 243 {
 244         for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
 245                 delete *i;
 246         }
 247 }
 248
 249 Track::FreezeState
 250 Track::freeze_state() const
 251 {
 252         return _freeze_record.state;
 253 }
 254
 255 bool
 256 Track::can_record()
 257 {
 258         bool will_record = true;
 259         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
 260                 if (!i->connected())
 261                         will_record = false;
 262         }
 263
 264         return will_record;
 265 }
 266
 267 int
 268 Track::prep_record_enabled (bool yn)
 269 {
 270         if (yn && _record_safe_control->get_value()) {
 271                 return -1;
 272         }
 273
 274         if (!can_be_record_enabled()) {
 275                 return -1;
 276         }
 277
 278         /* keep track of the meter point as it was before we rec-enabled */
 279         if (!_disk_writer->record_enabled()) {
 280                 _saved_meter_point = _meter_point;
 281         }
 282
 283         bool will_follow;
 284
 285         if (yn) {
 286                 will_follow = _disk_writer->prep_record_enable ();
 287         } else {
 288                 will_follow = _disk_writer->prep_record_disable ();
 289         }
 290
 291         if (will_follow) {
 292                 if (yn) {
 293                         if (_meter_point != MeterCustom) {
 294                                 set_meter_point (MeterInput);
 295                         }
 296                 } else {
 297                         set_meter_point (_saved_meter_point);
 298                 }
 299         }
 300
 301         return 0;
 302 }
 303
 304 void
 305 Track::record_enable_changed (bool, Controllable::GroupControlDisposition)
 306 {
 307         _disk_writer->set_record_enabled (_record_enable_control->get_value());
 308 }
 309
 310 void
 311 Track::record_safe_changed (bool, Controllable::GroupControlDisposition)
 312 {
 313         _disk_writer->set_record_safe (_record_safe_control->get_value());
 314 }
 315
 316 bool
 317 Track::can_be_record_safe ()
 318 {
 319         return !_record_enable_control->get_value() && _disk_writer && _session.writable() && (_freeze_record.state != Frozen);
 320 }
 321
 322 bool
 323 Track::can_be_record_enabled ()
 324 {
 325         return !_record_safe_control->get_value() && _disk_writer && !_disk_writer->record_safe() && _session.writable() && (_freeze_record.state != Frozen);
 326 }
 327
 328 void
 329 Track::parameter_changed (string const & p)
 330 {
 331         if (p == "track-name-number") {
 332                 resync_track_name ();
 333         }
 334         else if (p == "track-name-take") {
 335                 resync_track_name ();
 336         }
 337         else if (p == "take-name") {
 338                 if (_session.config.get_track_name_take()) {
 339                         resync_track_name ();
 340                 }
 341         }
 342 }
 343
 344 void
 345 Track::resync_track_name ()
 346 {
 347         set_name(name());
 348 }
 349
 350 bool
 351 Track::set_name (const string& str)
 352 {
 353         bool ret;
 354
 355         if (str.empty ()) {
 356                 return false;
 357         }
 358
 359         if (_record_enable_control->get_value()) {
 360                 /* when re-arm'ed the file (named after the track) is already ready to rolll */
 361                 return false;
 362         }
 363
 364         string diskstream_name = "";
 365         if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
 366                 // Note: any text is fine, legalize_for_path() fixes this later
 367                 diskstream_name += _session.config.get_take_name ();
 368                 diskstream_name += "_";
 369         }
 370         const int64_t tracknumber = track_number();
 371         if (tracknumber > 0 && _session.config.get_track_name_number()) {
 372                 char num[64], fmt[10];
 373                 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
 374                 snprintf(num, sizeof(num), fmt, tracknumber);
 375                 diskstream_name += num;
 376                 diskstream_name += "_";
 377         }
 378         diskstream_name += str;
 379
 380         if (diskstream_name == _diskstream_name) {
 381                 return true;
 382         }
 383         _diskstream_name = diskstream_name;
 384
 385         _disk_writer->set_write_source_name (diskstream_name);
 386
 387         boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
 388
 389         if (_playlists[data_type()]->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
 390                 /* Only rename the diskstream (and therefore the playlist) if
 391                    a) the playlist has never had a region added to it and
 392                    b) there is only one playlist for this track.
 393
 394                    If (a) is not followed, people can get confused if, say,
 395                    they have notes about a playlist with a given name and then
 396                    it changes (see mantis #4759).
 397
 398                    If (b) is not followed, we rename the current playlist and not
 399                    the other ones, which is a bit confusing (see mantis #4977).
 400                 */
 401                 _disk_reader->set_name (str);
 402                 _disk_writer->set_name (str);
 403         }
 404
 405         for (uint32_t n = 0; n < DataType::num_types; ++n) {
 406                 if (_playlists[n]) {
 407                         _playlists[n]->set_name (str);
 408                 }
 409         }
 410
 411         /* save state so that the statefile fully reflects any filename changes */
 412
 413         if ((ret = Route::set_name (str)) == 0) {
 414                 _session.save_state ("");
 415         }
 416
 417         return ret;
 418 }
 419
 420 boost::shared_ptr<Playlist>
 421 Track::playlist ()
 422 {
 423         return _playlists[data_type()];
 424 }
 425
 426 void
 427 Track::request_input_monitoring (bool m)
 428 {
 429         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
 430                 AudioEngine::instance()->request_input_monitoring ((*i)->name(), m);
 431         }
 432 }
 433
 434 void
 435 Track::ensure_input_monitoring (bool m)
 436 {
 437         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
 438                 AudioEngine::instance()->ensure_input_monitoring ((*i)->name(), m);
 439         }
 440 }
 441
 442 bool
 443 Track::destructive () const
 444 {
 445         return _disk_writer->destructive ();
 446 }
 447
 448 list<boost::shared_ptr<Source> > &
 449 Track::last_capture_sources ()
 450 {
 451         return _disk_writer->last_capture_sources ();
 452 }
 453
 454 std::string
 455 Track::steal_write_source_name()
 456 {
 457         return _disk_writer->steal_write_source_name ();
 458 }
 459
 460 void
 461 Track::reset_write_sources (bool r, bool force)
 462 {
 463         _disk_writer->reset_write_sources (r, force);
 464 }
 465
 466 float
 467 Track::playback_buffer_load () const
 468 {
 469         return _disk_reader->buffer_load ();
 470 }
 471
 472 float
 473 Track::capture_buffer_load () const
 474 {
 475         return _disk_writer->buffer_load ();
 476 }
 477
 478 int
 479 Track::do_refill ()
 480 {
 481         return _disk_reader->do_refill ();
 482 }
 483
 484 int
 485 Track::do_flush (RunContext c, bool force)
 486 {
 487         return _disk_writer->do_flush (c, force);
 488 }
 489
 490 void
 491 Track::set_pending_overwrite (bool o)
 492 {
 493         _disk_reader->set_pending_overwrite (o);
 494 }
 495
 496 int
 497 Track::seek (samplepos_t p, bool complete_refill)
 498 {
 499         if (_disk_reader->seek (p, complete_refill)) {
 500                 return -1;
 501         }
 502         return _disk_writer->seek (p, complete_refill);
 503 }
 504
 505 int
 506 Track::can_internal_playback_seek (samplecnt_t p)
 507 {
 508         return _disk_reader->can_internal_playback_seek (p);
 509 }
 510
 511 int
 512 Track::internal_playback_seek (samplecnt_t p)
 513 {
 514         return _disk_reader->internal_playback_seek (p);
 515 }
 516
 517 void
 518 Track::non_realtime_locate (samplepos_t p)
 519 {
 520         Route::non_realtime_locate (p);
 521 }
 522
 523 void
 524 Track::non_realtime_speed_change ()
 525 {
 526         _disk_reader->non_realtime_speed_change ();
 527 }
 528
 529 int
 530 Track::overwrite_existing_buffers ()
 531 {
 532         return _disk_reader->overwrite_existing_buffers ();
 533 }
 534
 535 samplecnt_t
 536 Track::get_captured_samples (uint32_t n) const
 537 {
 538         return _disk_writer->get_captured_samples (n);
 539 }
 540
 541 int
 542 Track::set_loop (Location* l)
 543 {
 544         if (_disk_reader->set_loop (l)) {
 545                 return -1;
 546         }
 547         return _disk_writer->set_loop (l);
 548 }
 549
 550 void
 551 Track::transport_looped (samplepos_t p)
 552 {
 553         return _disk_writer->transport_looped (p);
 554 }
 555
 556 void
 557 Track::realtime_handle_transport_stopped ()
 558 {
 559         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 560
 561         if (!lm.locked ()) {
 562                 return;
 563         }
 564
 565         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 566                 (*i)->realtime_handle_transport_stopped ();
 567         }
 568 }
 569
 570 void
 571 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 572 {
 573         _disk_writer->transport_stopped_wallclock (n, t, g);
 574 }
 575
 576 bool
 577 Track::pending_overwrite () const
 578 {
 579         return _disk_reader->pending_overwrite ();
 580 }
 581
 582 void
 583 Track::set_slaved (bool s)
 584 {
 585         _disk_reader->set_slaved (s);
 586         _disk_writer->set_slaved (s);
 587 }
 588
 589 ChanCount
 590 Track::n_channels ()
 591 {
 592         return _disk_reader->output_streams();
 593 }
 594
 595 samplepos_t
 596 Track::get_capture_start_sample (uint32_t n) const
 597 {
 598         return _disk_writer->get_capture_start_sample (n);
 599 }
 600
 601 AlignStyle
 602 Track::alignment_style () const
 603 {
 604         return _disk_writer->alignment_style ();
 605 }
 606
 607 AlignChoice
 608 Track::alignment_choice () const
 609 {
 610         return _alignment_choice;
 611 }
 612
 613 samplepos_t
 614 Track::current_capture_start () const
 615 {
 616         return _disk_writer->current_capture_start ();
 617 }
 618
 619 samplepos_t
 620 Track::current_capture_end () const
 621 {
 622         return _disk_writer->current_capture_end ();
 623 }
 624
 625 void
 626 Track::playlist_modified ()
 627 {
 628         _disk_reader->playlist_modified ();
 629 }
 630
 631 int
 632 Track::find_and_use_playlist (DataType dt, PBD::ID const & id)
 633 {
 634         boost::shared_ptr<Playlist> playlist;
 635
 636         if ((playlist = _session.playlists->by_id (id)) == 0) {
 637                 return -1;
 638         }
 639
 640         if (!playlist) {
 641                 error << string_compose(_("DiskIOProcessor: \"%1\" isn't an playlist"), id.to_s()) << endmsg;
 642                 return -1;
 643         }
 644
 645         return use_playlist (dt, playlist);
 646 }
 647
 648 int
 649 Track::use_playlist (DataType dt, boost::shared_ptr<Playlist> p)
 650 {
 651         int ret;
 652
 653         if ((ret = _disk_reader->use_playlist (dt, p)) == 0) {
 654                 if ((ret = _disk_writer->use_playlist (dt, p)) == 0) {
 655                         p->set_orig_track_id (id());
 656                 }
 657         }
 658
 659         if (ret == 0) {
 660                 _playlists[dt] = p;
 661         }
 662
 663         _session.set_dirty ();
 664         PlaylistChanged (); /* EMIT SIGNAL */
 665
 666         return ret;
 667 }
 668
 669 int
 670 Track::use_copy_playlist ()
 671 {
 672         assert (_playlists[data_type()]);
 673
 674         if (_playlists[data_type()] == 0) {
 675                 error << string_compose(_("DiskIOProcessor %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 676                 return -1;
 677         }
 678
 679         string newname;
 680         boost::shared_ptr<Playlist> playlist;
 681
 682         newname = Playlist::bump_name (_playlists[data_type()]->name(), _session);
 683
 684         if ((playlist = PlaylistFactory::create (_playlists[data_type()], newname)) == 0) {
 685                 return -1;
 686         }
 687
 688         playlist->reset_shares();
 689
 690         return use_playlist (data_type(), playlist);
 691 }
 692
 693 int
 694 Track::use_new_playlist (DataType dt)
 695 {
 696         string newname;
 697         boost::shared_ptr<Playlist> playlist = _playlists[dt];
 698
 699         if (playlist) {
 700                 newname = Playlist::bump_name (playlist->name(), _session);
 701         } else {
 702                 newname = Playlist::bump_name (_name, _session);
 703         }
 704
 705         playlist = PlaylistFactory::create (dt, _session, newname, is_private_route());
 706
 707         if (!playlist) {
 708                 return -1;
 709         }
 710
 711         return use_playlist (dt, playlist);
 712 }
 713
 714 void
 715 Track::set_align_choice (AlignChoice ac, bool force)
 716 {
 717         _alignment_choice = ac;
 718         switch (ac) {
 719                 case Automatic:
 720                         set_align_choice_from_io ();
 721                         break;
 722                 case UseCaptureTime:
 723                         _disk_writer->set_align_style (CaptureTime, force);
 724                         break;
 725                 case UseExistingMaterial:
 726                         _disk_writer->set_align_style (ExistingMaterial, force);
 727                         break;
 728         }
 729 }
 730
 731 void
 732 Track::set_align_style (AlignStyle s, bool force)
 733 {
 734         _disk_writer->set_align_style (s, force);
 735 }
 736
 737 void
 738 Track::set_align_choice_from_io ()
 739 {
 740         bool have_physical = false;
 741
 742         if (_input) {
 743                 uint32_t n = 0;
 744                 vector<string> connections;
 745                 boost::shared_ptr<Port> p;
 746
 747                 while (true) {
 748
 749                         p = _input->nth (n++);
 750
 751                         if (!p) {
 752                                 break;
 753                         }
 754
 755                         if (p->get_connections (connections) != 0) {
 756                                 if (AudioEngine::instance()->port_is_physical (connections[0])) {
 757                                         have_physical = true;
 758                                         break;
 759                                 }
 760                         }
 761
 762                         connections.clear ();
 763                 }
 764         }
 765
 766 #ifdef MIXBUS
 767         // compensate for latency when bouncing from master or mixbus.
 768         // we need to use "ExistingMaterial" to pick up the master bus' latency
 769         // see also Route::direct_feeds_according_to_reality
 770         IOVector ios;
 771         ios.push_back (_input);
 772         if (_session.master_out() && ios.fed_by (_session.master_out()->output())) {
 773                 have_physical = true;
 774         }
 775         for (uint32_t n = 0; n < NUM_MIXBUSES && !have_physical; ++n) {
 776                 if (_session.get_mixbus (n) && ios.fed_by (_session.get_mixbus(n)->output())) {
 777                         have_physical = true;
 778                 }
 779         }
 780 #endif
 781
 782         if (have_physical) {
 783                 _disk_writer->set_align_style (ExistingMaterial);
 784         } else {
 785                 _disk_writer->set_align_style (CaptureTime);
 786         }
 787 }
 788
 789 void
 790 Track::set_block_size (pframes_t n)
 791 {
 792         Route::set_block_size (n);
 793         _disk_reader->set_block_size (n);
 794         _disk_writer->set_block_size (n);
 795 }
 796
 797 void
 798 Track::adjust_playback_buffering ()
 799 {
 800         if (_disk_reader) {
 801                 _disk_reader->adjust_buffering ();
 802         }
 803 }
 804
 805 void
 806 Track::adjust_capture_buffering ()
 807 {
 808         if (_disk_writer) {
 809                 _disk_writer->adjust_buffering ();
 810         }
 811 }
 812
 813
 814 void
 815 Track::maybe_declick (BufferSet& bufs, samplecnt_t nframes, int declick)
 816 {
 817         /* never declick if there is an internal generator - we just want it to
 818            keep generating sound without interruption.
 819
 820            ditto if we are monitoring inputs.
 821         */
 822
 823         if (_have_internal_generator || (_monitoring_control->monitoring_choice() == MonitorInput)) {
 824                 return;
 825         }
 826
 827         if (!declick) {
 828                 declick = _pending_declick;
 829         }
 830
 831         if (declick != 0) {
 832                 Amp::declick (bufs, nframes, declick);
 833         }
 834 }
 835
 836 void
 837 Track::monitoring_changed (bool, Controllable::GroupControlDisposition)
 838 {
 839         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 840                 (*i)->monitoring_changed ();
 841         }
 842 }
 843
 844 MeterState
 845 Track::metering_state () const
 846 {
 847         bool rv;
 848         if (_session.transport_rolling ()) {
 849                 // audio_track.cc || midi_track.cc roll() runs meter IFF:
 850                 rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled());
 851         } else {
 852                 // track no_roll() always metering if
 853                 rv = _meter_point == MeterInput;
 854         }
 855         return rv ? MeteringInput : MeteringRoute;
 856 }
 857
 858 bool
 859 Track::set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure)
 860 {
 861         if (Route::set_processor_state (node, prop, new_order, must_configure)) {
 862                 return true;
 863         }
 864
 865         cerr << name() << " looking for state for track procs, DR = " << _disk_reader << endl;
 866
 867         if (prop->value() == "diskreader") {
 868                 if (_disk_reader) {
 869                         _disk_reader->set_state (node, Stateful::current_state_version);
 870                         new_order.push_back (_disk_reader);
 871                         return true;
 872                 }
 873         } else if (prop->value() == "diskwriter") {
 874                 if (_disk_writer) {
 875                         _disk_writer->set_state (node, Stateful::current_state_version);
 876                         new_order.push_back (_disk_writer);
 877                         return true;
 878                 }
 879         }
 880
 881         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
 882         return false;
 883 }
 884
 885 void
 886 Track::use_captured_sources (SourceList& srcs, CaptureInfos const & capture_info)
 887 {
 888         if (srcs.empty()) {
 889                 return;
 890         }
 891
 892         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (srcs.front());
 893         boost::shared_ptr<SMFSource> mfs = boost::dynamic_pointer_cast<SMFSource> (srcs.front());
 894
 895         if (afs) {
 896                 use_captured_audio_sources (srcs, capture_info);
 897         }
 898
 899         if (mfs) {
 900                 use_captured_midi_sources (srcs, capture_info);
 901         }
 902 }
 903
 904 void
 905 Track::use_captured_midi_sources (SourceList& srcs, CaptureInfos const & capture_info)
 906 {
 907         if (srcs.empty() || data_type() != DataType::MIDI) {
 908                 return;
 909         }
 910
 911         boost::shared_ptr<SMFSource> mfs = boost::dynamic_pointer_cast<SMFSource> (srcs.front());
 912         boost::shared_ptr<Playlist> pl = _playlists[DataType::MIDI];
 913         boost::shared_ptr<MidiRegion> midi_region;
 914         CaptureInfos::const_iterator ci;
 915
 916         if (!mfs || !pl) {
 917                 return;
 918         }
 919
 920         samplecnt_t total_capture = 0;
 921
 922         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 923                 total_capture += (*ci)->samples;
 924         }
 925
 926         /* we will want to be able to keep (over)writing the source
 927            but we don't want it to be removable. this also differs
 928            from the audio situation, where the source at this point
 929            must be considered immutable. luckily, we can rely on
 930            MidiSource::mark_streaming_write_completed() to have
 931            already done the necessary work for that.
 932         */
 933
 934         string whole_file_region_name;
 935         whole_file_region_name = region_name_from_path (mfs->name(), true);
 936
 937         /* Register a new region with the Session that
 938            describes the entire source. Do this first
 939            so that any sub-regions will obviously be
 940            children of this one (later!)
 941         */
 942
 943         try {
 944                 PropertyList plist;
 945
 946                 plist.add (Properties::name, whole_file_region_name);
 947                 plist.add (Properties::whole_file, true);
 948                 plist.add (Properties::automatic, true);
 949                 plist.add (Properties::start, 0);
 950                 plist.add (Properties::length, total_capture);
 951                 plist.add (Properties::layer, 0);
 952
 953                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 954
 955                 midi_region = boost::dynamic_pointer_cast<MidiRegion> (rx);
 956                 midi_region->special_set_position (capture_info.front()->start);
 957         }
 958
 959         catch (failed_constructor& err) {
 960                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
 961                 /* XXX what now? */
 962         }
 963
 964         pl->clear_changes ();
 965         pl->freeze ();
 966
 967         /* Session sample time of the initial capture in this pass, which is where the source starts */
 968         samplepos_t initial_capture = 0;
 969         if (!capture_info.empty()) {
 970                 initial_capture = capture_info.front()->start;
 971         }
 972
 973         BeatsSamplesConverter converter (_session.tempo_map(), capture_info.front()->start);
 974         const samplepos_t preroll_off = _session.preroll_record_trim_len ();
 975
 976         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 977
 978                 string region_name;
 979
 980                 RegionFactory::region_name (region_name, mfs->name(), false);
 981
 982                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
 983                                                                       _name, (*ci)->start, (*ci)->samples, region_name));
 984
 985
 986                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->samples << " add a region\n";
 987
 988                 try {
 989                         PropertyList plist;
 990
 991                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
 992                         plist.add (Properties::start, (*ci)->start - initial_capture);
 993                         plist.add (Properties::length, (*ci)->samples);
 994                         plist.add (Properties::length_beats, converter.from((*ci)->samples).to_double());
 995                         plist.add (Properties::name, region_name);
 996
 997                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 998                         midi_region = boost::dynamic_pointer_cast<MidiRegion> (rx);
 999                         if (preroll_off > 0) {
1000                                 midi_region->trim_front ((*ci)->start - initial_capture + preroll_off);
1001                         }
1002                 }
1003
1004                 catch (failed_constructor& err) {
1005                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1006                         continue; /* XXX is this OK? */
1007                 }
1008
1009                 cerr << "add new region, len = " << (*ci)->samples << " @ " << (*ci)->start << endl;
1010
1011                 pl->add_region (midi_region, (*ci)->start + preroll_off, 1, _session.config.get_layered_record_mode ());
1012         }
1013
1014         pl->thaw ();
1015         _session.add_command (new StatefulDiffCommand (pl));
1016 }
1017
1018 void
1019 Track::use_captured_audio_sources (SourceList& srcs, CaptureInfos const & capture_info)
1020 {
1021         if (srcs.empty() || data_type() != DataType::AUDIO) {
1022                 return;
1023         }
1024
1025         boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (srcs.front());
1026         boost::shared_ptr<Playlist> pl = _playlists[DataType::AUDIO];
1027         boost::shared_ptr<AudioRegion> region;
1028
1029         if (!afs || !pl) {
1030                 return;
1031         }
1032
1033         /* destructive tracks have a single, never changing region */
1034
1035         if (destructive()) {
1036
1037                 /* send a signal that any UI can pick up to do the right thing. there is
1038                    a small problem here in that a UI may need the peak data to be ready
1039                    for the data that was recorded and this isn't interlocked with that
1040                    process. this problem is deferred to the UI.
1041                  */
1042
1043                 pl->LayeringChanged(); // XXX this may not get the UI to do the right thing
1044                 return;
1045         }
1046
1047         string whole_file_region_name;
1048         whole_file_region_name = region_name_from_path (afs->name(), true);
1049
1050         /* Register a new region with the Session that
1051            describes the entire source. Do this first
1052            so that any sub-regions will obviously be
1053            children of this one (later!)
1054         */
1055
1056         try {
1057                 PropertyList plist;
1058
1059                 plist.add (Properties::start, afs->last_capture_start_sample());
1060                 plist.add (Properties::length, afs->length(0));
1061                 plist.add (Properties::name, whole_file_region_name);
1062                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1063                 rx->set_automatic (true);
1064                 rx->set_whole_file (true);
1065
1066                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1067                 region->special_set_position (afs->natural_position());
1068         }
1069
1070
1071         catch (failed_constructor& err) {
1072                 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1073                 /* XXX what now? */
1074         }
1075
1076         pl->clear_changes ();
1077         pl->set_capture_insertion_in_progress (true);
1078         pl->freeze ();
1079
1080         const samplepos_t preroll_off = _session.preroll_record_trim_len ();
1081         samplecnt_t buffer_position = afs->last_capture_start_sample ();
1082         CaptureInfos::const_iterator ci;
1083
1084         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1085
1086                 string region_name;
1087
1088                 RegionFactory::region_name (region_name, whole_file_region_name, false);
1089
1090                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n",
1091                                                                       _name, (*ci)->start, (*ci)->samples, region_name, buffer_position));
1092
1093                 try {
1094
1095                         PropertyList plist;
1096
1097                         plist.add (Properties::start, buffer_position);
1098                         plist.add (Properties::length, (*ci)->samples);
1099                         plist.add (Properties::name, region_name);
1100
1101                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1102                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1103                         if (preroll_off > 0) {
1104                                 region->trim_front (buffer_position + preroll_off);
1105                         }
1106                 }
1107
1108                 catch (failed_constructor& err) {
1109                         error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1110                         continue; /* XXX is this OK? */
1111                 }
1112
1113                 pl->add_region (region, (*ci)->start + preroll_off, 1, _session.config.get_layered_record_mode());
1114                 pl->set_layer (region, DBL_MAX);
1115
1116                 buffer_position += (*ci)->samples;
1117         }
1118
1119         pl->thaw ();
1120         pl->set_capture_insertion_in_progress (false);
1121         _session.add_command (new StatefulDiffCommand (pl));
1122 }
1123
1124