libs/ardour/track.cc

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