2 Copyright (C) 2006 Paul Davis
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.
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.
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.
18 #include "pbd/error.h"
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"
38 using namespace ARDOUR;
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)
45 , _monitoring (MonitorAuto)
47 _freeze_record.state = NoFreeze;
53 DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
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 _monitoring_control.reset (new MonitoringControllable (X_("monitoring"), rt));
69 /* don't add rec_enable_control to controls because we don't want it to
70 * appear as an automatable parameter
72 track_number_changed.connect_same_thread (*this, boost::bind (&Track::resync_track_name, this));
73 _session.config.ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1));
79 Track::use_new_diskstream ()
81 boost::shared_ptr<Diskstream> ds = create_diskstream ();
83 ds->do_refill_with_alloc ();
84 ds->set_block_size (_session.get_block_size ());
85 ds->playlist()->set_orig_track_id (id());
97 Track::state (bool full)
99 XMLNode& root (Route::state (full));
100 root.add_property (X_("monitoring"), enum_2_string (_monitoring));
101 root.add_property (X_("saved-meter-point"), enum_2_string (_saved_meter_point));
102 root.add_child_nocopy (_rec_enable_control->get_state());
103 root.add_child_nocopy (_diskstream->get_state ());
109 Track::set_state (const XMLNode& node, int version)
111 if (Route::set_state (node, version)) {
117 if (version >= 3000) {
118 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
119 boost::shared_ptr<Diskstream> ds = diskstream_factory (*child);
120 ds->do_refill_with_alloc ();
126 _diskstream->playlist()->set_orig_track_id (id());
129 /* set rec-enable control *AFTER* setting up diskstream, because it may
130 want to operate on the diskstream as it sets its own state
133 XMLNodeList nlist = node.children();
134 for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
137 XMLProperty const * prop;
138 if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) {
139 if (prop->value() == X_("recenable")) {
140 _rec_enable_control->set_state (*child, version);
145 XMLProperty const * prop;
147 if ((prop = node.property (X_("monitoring"))) != 0) {
148 _monitoring = MonitorChoice (string_2_enum (prop->value(), _monitoring));
150 _monitoring = MonitorAuto;
153 if ((prop = node.property (X_("saved-meter-point"))) != 0) {
154 _saved_meter_point = MeterPoint (string_2_enum (prop->value(), _saved_meter_point));
156 _saved_meter_point = _meter_point;
163 Track::get_template ()
165 return state (false);
168 Track::FreezeRecord::~FreezeRecord ()
170 for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
176 Track::freeze_state() const
178 return _freeze_record.state;
181 Track::RecEnableControl::RecEnableControl (boost::shared_ptr<Track> t)
182 : AutomationControl (t->session(),
184 ParameterDescriptor(Evoral::Parameter(RecEnableAutomation)),
185 boost::shared_ptr<AutomationList>(),
189 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(RecEnableAutomation)));
194 Track::RecEnableControl::set_value (double val, Controllable::GroupControlDisposition group_override)
197 _set_value (val, group_override);
202 Track::RecEnableControl::set_value_unchecked (double val)
205 _set_value (val, Controllable::NoGroup);
210 Track::RecEnableControl::_set_value (double val, Controllable::GroupControlDisposition group_override)
212 boost::shared_ptr<Track> t = track.lock ();
217 t->set_record_enabled (val >= 0.5 ? true : false, group_override);
221 Track::RecEnableControl::get_value () const
223 boost::shared_ptr<Track> t = track.lock ();
228 return (t->record_enabled() ? 1.0 : 0.0);
232 Track::record_enabled () const
234 return _diskstream && _diskstream->record_enabled ();
240 bool will_record = true;
241 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
250 Track::prep_record_enabled (bool yn, Controllable::GroupControlDisposition group_override)
252 if (yn && record_safe ()) {
256 if (!_session.writable()) {
260 if (_freeze_record.state == Frozen) {
264 if (use_group (group_override, &RouteGroup::is_recenable)) {
265 _route_group->apply (&Track::prep_record_enabled, yn, Controllable::NoGroup);
269 /* keep track of the meter point as it was before we rec-enabled */
270 if (!_diskstream->record_enabled()) {
271 _saved_meter_point = _meter_point;
277 will_follow = _diskstream->prep_record_enable ();
279 will_follow = _diskstream->prep_record_disable ();
284 if (_meter_point != MeterCustom) {
285 set_meter_point (MeterInput);
288 set_meter_point (_saved_meter_point);
294 Track::set_record_enabled (bool yn, Controllable::GroupControlDisposition group_override)
296 if (_diskstream->record_safe ()) {
300 if (!_session.writable()) {
304 if (_freeze_record.state == Frozen) {
308 if (use_group (group_override, &RouteGroup::is_recenable)) {
309 _route_group->apply (&Track::set_record_enabled, yn, Controllable::NoGroup);
313 _diskstream->set_record_enabled (yn);
315 _rec_enable_control->Changed ();
319 Track::record_safe () const
321 return _diskstream && _diskstream->record_safe ();
325 Track::set_record_safe (bool yn, Controllable::GroupControlDisposition group_override)
327 if (!_session.writable()) {
331 if (_freeze_record.state == Frozen) {
335 if (record_enabled ()) {
339 if (use_group (group_override, &RouteGroup::is_recenable)) {
340 _route_group->apply (&Track::set_record_safe, yn, Controllable::NoGroup);
344 _diskstream->set_record_safe (yn);
348 Track::parameter_changed (string const & p)
350 if (p == "track-name-number") {
351 resync_track_name ();
353 else if (p == "track-name-take") {
354 resync_track_name ();
356 else if (p == "take-name") {
357 if (_session.config.get_track_name_take()) {
358 resync_track_name ();
364 Track::resync_track_name ()
370 Track::set_name (const string& str)
374 if (record_enabled() && _session.actively_recording()) {
375 /* this messes things up if done while recording */
379 string diskstream_name = "";
380 if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
381 // Note: any text is fine, legalize_for_path() fixes this later
382 diskstream_name += _session.config.get_take_name ();
383 diskstream_name += "_";
385 const int64_t tracknumber = track_number();
386 if (tracknumber > 0 && _session.config.get_track_name_number()) {
387 char num[64], fmt[10];
388 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
389 snprintf(num, sizeof(num), fmt, tracknumber);
390 diskstream_name += num;
391 diskstream_name += "_";
393 diskstream_name += str;
395 if (diskstream_name == _diskstream_name) {
398 _diskstream_name = diskstream_name;
400 _diskstream->set_write_source_name (diskstream_name);
402 boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
403 if (_diskstream->playlist()->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
404 /* Only rename the diskstream (and therefore the playlist) if
405 a) the playlist has never had a region added to it and
406 b) there is only one playlist for this track.
408 If (a) is not followed, people can get confused if, say,
409 they have notes about a playlist with a given name and then
410 it changes (see mantis #4759).
412 If (b) is not followed, we rename the current playlist and not
413 the other ones, which is a bit confusing (see mantis #4977).
415 _diskstream->set_name (str);
418 /* save state so that the statefile fully reflects any filename changes */
420 if ((ret = Route::set_name (str)) == 0) {
421 _session.save_state ("");
428 Track::set_latency_compensation (framecnt_t longest_session_latency)
430 Route::set_latency_compensation (longest_session_latency);
431 _diskstream->set_roll_delay (_roll_delay);
435 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
437 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
443 bool can_record = _session.actively_recording ();
445 /* no outputs? nothing to do ... what happens if we have sends etc. ? */
447 if (n_outputs().n_total() == 0) {
451 /* not active ... do the minimum possible by just outputting silence */
455 if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
461 if (session_state_changing) {
462 if (_session.transport_speed() != 0.0f) {
463 /* we're rolling but some state is changing (e.g. our diskstream contents)
464 so we cannot use them. Be silent till this is over. Don't declick.
466 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
468 passthru_silence (start_frame, end_frame, nframes, 0);
471 /* we're really not rolling, so we're either delivery silence or actually
472 monitoring, both of which are safe to do while session_state_changing is true.
476 _diskstream->check_record_status (start_frame, can_record);
480 MonitorState const s = monitoring_state ();
481 /* we are not rolling, so be silent even if we are monitoring disk, as there
482 will be no disk data coming in.
485 case MonitoringSilence:
491 case MonitoringInput:
499 //if we have an internal generator, let it play regardless of monitoring state
500 if (_have_internal_generator) {
504 _amp->apply_gain_automation (false);
506 /* if have_internal_generator, or .. */
510 if (_meter_point == MeterInput) {
511 /* still need input monitoring and metering */
513 bool const track_rec = _diskstream->record_enabled ();
514 bool const auto_input = _session.config.get_auto_input ();
515 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
516 bool const tape_machine_mode = Config->get_tape_machine_mode ();
517 bool no_meter = false;
519 /* this needs a proper K-map
520 * and should be separated into a function similar to monitoring_state()
521 * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
523 * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
525 if (!auto_input && !track_rec) {
528 else if (tape_machine_mode && !track_rec && auto_input) {
531 else if (!software_monitor && tape_machine_mode && !track_rec) {
534 else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
539 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
540 _meter->run (bufs, 0, 0, nframes, true);
541 _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, nframes);
543 _input->process_input (_meter, start_frame, end_frame, nframes);
547 passthru_silence (start_frame, end_frame, nframes, 0);
551 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
553 fill_buffers_with_input (bufs, _input, nframes);
555 if (_meter_point == MeterInput) {
556 _meter->run (bufs, start_frame, end_frame, nframes, true);
559 passthru (bufs, start_frame, end_frame, nframes, false);
562 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
563 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
565 d->flush_buffers (nframes);
573 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
575 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
577 framecnt_t playback_distance = _diskstream->calculate_playback_distance(nframes);
578 if (can_internal_playback_seek(playback_distance)) {
579 internal_playback_seek(playback_distance);
584 if (n_outputs().n_total() == 0 && _processors.empty()) {
594 _amp->apply_gain_automation(false);
598 framecnt_t playback_distance;
600 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
602 int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
603 need_butler = _diskstream->commit (playback_distance);
608 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
612 ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
613 diskstream_playlist_changed ();
614 ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
615 ds->RecordSafeChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_safe_changed, this));
616 ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
617 ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
621 Track::diskstream_playlist_changed ()
623 PlaylistChanged (); /* EMIT SIGNAL */
627 Track::diskstream_record_enable_changed ()
629 RecordEnableChanged (); /* EMIT SIGNAL */
633 Track::diskstream_record_safe_changed ()
635 RecordSafeChanged (); /* EMIT SIGNAL */
639 Track::diskstream_speed_changed ()
641 SpeedChanged (); /* EMIT SIGNAL */
645 Track::diskstream_alignment_style_changed ()
647 AlignmentStyleChanged (); /* EMIT SIGNAL */
650 boost::shared_ptr<Playlist>
653 return _diskstream->playlist ();
657 Track::request_input_monitoring (bool m)
659 _diskstream->request_input_monitoring (m);
663 Track::ensure_input_monitoring (bool m)
665 _diskstream->ensure_input_monitoring (m);
669 Track::destructive () const
671 return _diskstream->destructive ();
674 list<boost::shared_ptr<Source> > &
675 Track::last_capture_sources ()
677 return _diskstream->last_capture_sources ();
681 Track::set_capture_offset ()
683 _diskstream->set_capture_offset ();
687 Track::steal_write_source_name()
689 return _diskstream->steal_write_source_name ();
693 Track::reset_write_sources (bool r, bool force)
695 _diskstream->reset_write_sources (r, force);
699 Track::playback_buffer_load () const
701 return _diskstream->playback_buffer_load ();
705 Track::capture_buffer_load () const
707 return _diskstream->capture_buffer_load ();
713 return _diskstream->do_refill ();
717 Track::do_flush (RunContext c, bool force)
719 return _diskstream->do_flush (c, force);
723 Track::set_pending_overwrite (bool o)
725 _diskstream->set_pending_overwrite (o);
729 Track::seek (framepos_t p, bool complete_refill)
731 return _diskstream->seek (p, complete_refill);
735 Track::hidden () const
737 return _diskstream->hidden ();
741 Track::can_internal_playback_seek (framecnt_t p)
743 return _diskstream->can_internal_playback_seek (p);
747 Track::internal_playback_seek (framecnt_t p)
749 return _diskstream->internal_playback_seek (p);
753 Track::non_realtime_input_change ()
755 _diskstream->non_realtime_input_change ();
759 Track::non_realtime_locate (framepos_t p)
761 Route::non_realtime_locate (p);
764 /* don't waste i/o cycles and butler calls
765 for hidden (secret) tracks
767 _diskstream->non_realtime_locate (p);
772 Track::non_realtime_set_speed ()
774 _diskstream->non_realtime_set_speed ();
778 Track::overwrite_existing_buffers ()
780 return _diskstream->overwrite_existing_buffers ();
784 Track::get_captured_frames (uint32_t n) const
786 return _diskstream->get_captured_frames (n);
790 Track::set_loop (Location* l)
792 return _diskstream->set_loop (l);
796 Track::transport_looped (framepos_t p)
798 _diskstream->transport_looped (p);
802 Track::realtime_set_speed (double s, bool g)
804 return _diskstream->realtime_set_speed (s, g);
808 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
810 _diskstream->transport_stopped_wallclock (n, t, g);
814 Track::pending_overwrite () const
816 return _diskstream->pending_overwrite ();
820 Track::speed () const
822 return _diskstream->speed ();
826 Track::prepare_to_stop (framepos_t t, framepos_t a)
828 _diskstream->prepare_to_stop (t, a);
832 Track::set_slaved (bool s)
834 _diskstream->set_slaved (s);
840 return _diskstream->n_channels ();
844 Track::get_capture_start_frame (uint32_t n) const
846 return _diskstream->get_capture_start_frame (n);
850 Track::alignment_style () const
852 return _diskstream->alignment_style ();
856 Track::alignment_choice () const
858 return _diskstream->alignment_choice ();
862 Track::current_capture_start () const
864 return _diskstream->current_capture_start ();
868 Track::current_capture_end () const
870 return _diskstream->current_capture_end ();
874 Track::playlist_modified ()
876 _diskstream->playlist_modified ();
880 Track::use_playlist (boost::shared_ptr<Playlist> p)
882 int ret = _diskstream->use_playlist (p);
884 p->set_orig_track_id (id());
890 Track::use_copy_playlist ()
892 int ret = _diskstream->use_copy_playlist ();
895 _diskstream->playlist()->set_orig_track_id (id());
902 Track::use_new_playlist ()
904 int ret = _diskstream->use_new_playlist ();
907 _diskstream->playlist()->set_orig_track_id (id());
914 Track::set_align_style (AlignStyle s, bool force)
916 _diskstream->set_align_style (s, force);
920 Track::set_align_choice (AlignChoice s, bool force)
922 _diskstream->set_align_choice (s, force);
926 Track::using_diskstream_id (PBD::ID id) const
928 return (id == _diskstream->id ());
932 Track::set_block_size (pframes_t n)
934 Route::set_block_size (n);
935 _diskstream->set_block_size (n);
939 Track::adjust_playback_buffering ()
942 _diskstream->adjust_playback_buffering ();
947 Track::adjust_capture_buffering ()
950 _diskstream->adjust_capture_buffering ();
954 #ifdef USE_TRACKS_CODE_FEATURES
956 /* This is the Tracks version of Track::monitoring_state().
958 * Ardour developers: try to flag or fix issues if parts of the libardour API
959 * change in ways that invalidate this
963 Track::monitoring_state () const
965 /* Explicit requests */
967 if (_monitoring & MonitorInput) {
968 return MonitoringInput;
971 if (_monitoring & MonitorDisk) {
972 return MonitoringDisk;
975 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
976 I don't think it's ever going to be too pretty too look at.
979 // GZ: NOT USED IN TRACKS
980 //bool const auto_input = _session.config.get_auto_input ();
981 //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
982 //bool const tape_machine_mode = Config->get_tape_machine_mode ();
984 bool const roll = _session.transport_rolling ();
985 bool const track_rec = _diskstream->record_enabled ();
986 bool session_rec = _session.actively_recording ();
990 if (!session_rec && roll) {
991 return MonitoringDisk;
993 return MonitoringInput;
999 return MonitoringDisk;
1003 return MonitoringSilence;
1008 /* This is the Ardour/Mixbus version of Track::monitoring_state().
1010 * Tracks developers: do NOT modify this method under any circumstances.
1014 Track::monitoring_state () const
1016 /* Explicit requests */
1018 if (_monitoring & MonitorInput) {
1019 return MonitoringInput;
1022 if (_monitoring & MonitorDisk) {
1023 return MonitoringDisk;
1026 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
1027 I don't think it's ever going to be too pretty too look at.
1030 bool const roll = _session.transport_rolling ();
1031 bool const track_rec = _diskstream->record_enabled ();
1032 bool const auto_input = _session.config.get_auto_input ();
1033 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
1034 bool const tape_machine_mode = Config->get_tape_machine_mode ();
1037 /* I suspect that just use actively_recording() is good enough all the
1038 * time, but just to keep the semantics the same as they were before
1039 * sept 26th 2012, we differentiate between the cases where punch is
1040 * enabled and those where it is not.
1043 if (_session.config.get_punch_in() || _session.config.get_punch_out()) {
1044 session_rec = _session.actively_recording ();
1046 session_rec = _session.get_record_enabled();
1051 if (!session_rec && roll && auto_input) {
1052 return MonitoringDisk;
1054 return software_monitor ? MonitoringInput : MonitoringSilence;
1059 if (tape_machine_mode) {
1061 return MonitoringDisk;
1065 if (!roll && auto_input) {
1066 return software_monitor ? MonitoringInput : MonitoringSilence;
1068 return MonitoringDisk;
1074 abort(); /* NOTREACHED */
1075 return MonitoringSilence;
1081 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
1083 /* never declick if there is an internal generator - we just want it to
1084 keep generating sound without interruption.
1086 ditto if we are monitoring inputs.
1089 if (_have_internal_generator || monitoring_choice() == MonitorInput) {
1094 declick = _pending_declick;
1098 Amp::declick (bufs, nframes, declick);
1103 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
1105 if (_roll_delay > nframes) {
1107 _roll_delay -= nframes;
1108 silence_unlocked (nframes);
1109 /* transport frame is not legal for caller to use */
1112 } else if (_roll_delay > 0) {
1114 nframes -= _roll_delay;
1115 silence_unlocked (_roll_delay);
1116 transport_frame += _roll_delay;
1118 /* shuffle all the port buffers for things that lead "out" of this Route
1119 to reflect that we just wrote _roll_delay frames of silence.
1122 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1123 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1124 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1126 iop->increment_port_buffer_offset (_roll_delay);
1129 _output->increment_port_buffer_offset (_roll_delay);
1139 Track::set_monitoring (MonitorChoice mc, Controllable::GroupControlDisposition gcd)
1141 if (use_group (gcd, &RouteGroup::is_monitoring)) {
1142 _route_group->apply (&Track::set_monitoring, mc, Controllable::NoGroup);
1146 if (mc != _monitoring) {
1149 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1150 (*i)->monitoring_changed ();
1153 MonitoringChanged (); /* EMIT SIGNAL */
1154 _monitoring_control->Changed (); /* EMIT SIGNAL */
1159 Track::metering_state () const
1162 if (_session.transport_rolling ()) {
1163 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1164 rv = _meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled());
1166 // track no_roll() always metering if
1167 rv = _meter_point == MeterInput;
1169 return rv ? MeteringInput : MeteringRoute;
1172 Track::MonitoringControllable::MonitoringControllable (std::string name, boost::shared_ptr<Track> r)
1173 : RouteAutomationControl (name, MonitoringAutomation, boost::shared_ptr<AutomationList>(), r)
1175 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MonitoringAutomation)));
1176 gl->set_interpolation(Evoral::ControlList::Discrete);
1181 Track::MonitoringControllable::set_value (double val, Controllable::GroupControlDisposition gcd)
1183 _set_value (val, gcd);
1187 Track::MonitoringControllable::_set_value (double val, Controllable::GroupControlDisposition gcd)
1189 boost::shared_ptr<Route> r = _route.lock();
1194 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (r);
1201 if (mc < MonitorAuto || mc > MonitorDisk) {
1205 /* no group effect at present */
1207 t->set_monitoring ((MonitorChoice) mc, gcd);
1211 Track::MonitoringControllable::get_value () const
1213 boost::shared_ptr<Route> r = _route.lock();
1218 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (r);
1223 return t->monitoring_choice();