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