2 Copyright (C) 2006 Paul Davis
3 Author: David Robillard
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "pbd/enumwriter.h"
22 #include "pbd/convert.h"
23 #include "evoral/midi_util.h"
25 #include "ardour/buffer_set.h"
26 #include "ardour/debug.h"
27 #include "ardour/delivery.h"
28 #include "ardour/meter.h"
29 #include "ardour/midi_diskstream.h"
30 #include "ardour/midi_playlist.h"
31 #include "ardour/midi_port.h"
32 #include "ardour/midi_track.h"
33 #include "ardour/port.h"
34 #include "ardour/processor.h"
35 #include "ardour/session.h"
36 #include "ardour/session_playlists.h"
37 #include "ardour/utils.h"
42 class InterThreadInfo;
49 using namespace ARDOUR;
52 MidiTrack::MidiTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
53 : Track (sess, name, flag, mode, DataType::MIDI)
54 , _immediate_events(1024) // FIXME: size?
55 , _step_edit_ring_buffer(64) // FIXME: size?
56 , _note_mode(Sustained)
57 , _step_editing (false)
58 , _input_active (true)
59 , _playback_channel_mask(0x0000ffff)
60 , _capture_channel_mask(0x0000ffff)
64 MidiTrack::~MidiTrack ()
75 _input->changed.connect_same_thread (*this, boost::bind (&MidiTrack::track_input_active, this, _1, _2));
80 boost::shared_ptr<Diskstream>
81 MidiTrack::create_diskstream ()
83 MidiDiskstream::Flag dflags = MidiDiskstream::Flag (MidiDiskstream::Recordable);
85 assert(_mode != Destructive);
87 return boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, name(), dflags));
92 MidiTrack::set_record_enabled (bool yn, void *src)
98 Track::set_record_enabled (yn, src);
102 MidiTrack::set_diskstream (boost::shared_ptr<Diskstream> ds)
104 /* We have to do this here, as Track::set_diskstream will cause a buffer refill,
105 and the diskstream must be set up to fill its buffers using the correct _note_mode.
107 boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream> (ds);
108 mds->set_note_mode (_note_mode);
110 Track::set_diskstream (ds);
112 mds->reset_tracker ();
114 _diskstream->set_track (this);
115 _diskstream->set_destructive (_mode == Destructive);
116 _diskstream->set_record_enabled (false);
118 _diskstream_data_recorded_connection.disconnect ();
119 mds->DataRecorded.connect_same_thread (
120 _diskstream_data_recorded_connection,
121 boost::bind (&MidiTrack::diskstream_data_recorded, this, _1));
123 DiskstreamChanged (); /* EMIT SIGNAL */
126 boost::shared_ptr<MidiDiskstream>
127 MidiTrack::midi_diskstream() const
129 return boost::dynamic_pointer_cast<MidiDiskstream>(_diskstream);
133 MidiTrack::set_state (const XMLNode& node, int version)
135 const XMLProperty *prop;
137 /* This must happen before Track::set_state(), as there will be a buffer
138 fill during that call, and we must fill buffers using the correct
141 if ((prop = node.property (X_("note-mode"))) != 0) {
142 _note_mode = NoteMode (string_2_enum (prop->value(), _note_mode));
144 _note_mode = Sustained;
147 if (Track::set_state (node, version)) {
151 // No destructive MIDI tracks (yet?)
154 if ((prop = node.property ("input-active")) != 0) {
155 set_input_active (string_is_affirmative (prop->value()));
158 ChannelMode playback_channel_mode = AllChannels;
159 ChannelMode capture_channel_mode = AllChannels;
161 if ((prop = node.property ("playback-channel-mode")) != 0) {
162 playback_channel_mode = ChannelMode (string_2_enum(prop->value(), playback_channel_mode));
164 if ((prop = node.property ("capture-channel-mode")) != 0) {
165 capture_channel_mode = ChannelMode (string_2_enum(prop->value(), capture_channel_mode));
167 if ((prop = node.property ("channel-mode")) != 0) {
168 /* 3.0 behaviour where capture and playback modes were not separated */
169 playback_channel_mode = ChannelMode (string_2_enum(prop->value(), playback_channel_mode));
170 capture_channel_mode = playback_channel_mode;
173 unsigned int playback_channel_mask = 0xffff;
174 unsigned int capture_channel_mask = 0xffff;
176 if ((prop = node.property ("playback-channel-mask")) != 0) {
177 sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask);
179 if ((prop = node.property ("capture-channel-mask")) != 0) {
180 sscanf (prop->value().c_str(), "0x%x", &capture_channel_mask);
182 if ((prop = node.property ("channel-mask")) != 0) {
183 sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask);
184 capture_channel_mask = playback_channel_mask;
187 set_playback_channel_mode (playback_channel_mode, playback_channel_mask);
188 set_capture_channel_mode (capture_channel_mode, capture_channel_mask);
190 pending_state = const_cast<XMLNode*> (&node);
192 if (_session.state_of_the_state() & Session::Loading) {
193 _session.StateReady.connect_same_thread (
194 *this, boost::bind (&MidiTrack::set_state_part_two, this));
196 set_state_part_two ();
203 MidiTrack::state(bool full_state)
205 XMLNode& root (Track::state(full_state));
206 XMLNode* freeze_node;
209 if (_freeze_record.playlist) {
212 freeze_node = new XMLNode (X_("freeze-info"));
213 freeze_node->add_property ("playlist", _freeze_record.playlist->name());
214 freeze_node->add_property ("state", enum_2_string (_freeze_record.state));
216 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
217 inode = new XMLNode (X_("processor"));
218 (*i)->id.print (buf, sizeof(buf));
219 inode->add_property (X_("id"), buf);
220 inode->add_child_copy ((*i)->state);
222 freeze_node->add_child_nocopy (*inode);
225 root.add_child_nocopy (*freeze_node);
228 root.add_property("playback_channel-mode", enum_2_string(get_playback_channel_mode()));
229 root.add_property("capture_channel-mode", enum_2_string(get_capture_channel_mode()));
230 snprintf (buf, sizeof(buf), "0x%x", get_playback_channel_mask());
231 root.add_property("playback-channel-mask", buf);
232 snprintf (buf, sizeof(buf), "0x%x", get_capture_channel_mask());
233 root.add_property("capture-channel-mask", buf);
235 root.add_property ("note-mode", enum_2_string (_note_mode));
236 root.add_property ("step-editing", (_step_editing ? "yes" : "no"));
237 root.add_property ("input-active", (_input_active ? "yes" : "no"));
243 MidiTrack::set_state_part_two ()
247 LocaleGuard lg (X_("POSIX"));
249 /* This is called after all session state has been restored but before
250 have been made ports and connections are established.
253 if (pending_state == 0) {
257 if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
259 _freeze_record.state = Frozen;
261 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
264 _freeze_record.processor_info.clear ();
266 if ((prop = fnode->property (X_("playlist"))) != 0) {
267 boost::shared_ptr<Playlist> pl = _session.playlists->by_name (prop->value());
269 _freeze_record.playlist = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
271 _freeze_record.playlist.reset();
272 _freeze_record.state = NoFreeze;
277 if ((prop = fnode->property (X_("state"))) != 0) {
278 _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state));
281 XMLNodeConstIterator citer;
282 XMLNodeList clist = fnode->children();
284 for (citer = clist.begin(); citer != clist.end(); ++citer) {
285 if ((*citer)->name() != X_("processor")) {
289 if ((prop = (*citer)->property (X_("id"))) == 0) {
293 FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
294 boost::shared_ptr<Processor>());
295 frii->id = prop->value ();
296 _freeze_record.processor_info.push_back (frii);
300 if (midi_diskstream ()) {
301 midi_diskstream()->set_block_size (_session.get_block_size ());
307 /** @param need_butler to be set to true if this track now needs the butler, otherwise it can be left alone
311 MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
313 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
315 boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
316 framecnt_t playback_distance = diskstream->calculate_playback_distance(nframes);
317 if (can_internal_playback_seek(llabs(playback_distance))) {
318 /* TODO should declick, and/or note-off */
319 internal_playback_seek(playback_distance);
324 boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
326 if (n_outputs().n_total() == 0 && _processors.empty()) {
332 if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
338 framepos_t transport_frame = _session.transport_frame();
341 framecnt_t playback_distance;
343 if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) {
344 /* need to do this so that the diskstream sets its
345 playback distance to zero, thus causing diskstream::commit
348 BufferSet bufs; /* empty set - is OK, since nothing will happen */
350 dret = diskstream->process (bufs, transport_frame, 0, playback_distance, false);
351 need_butler = diskstream->commit (playback_distance);
355 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
357 fill_buffers_with_input (bufs, _input, nframes);
359 if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
360 _meter->run (bufs, start_frame, end_frame, nframes, true);
363 /* filter captured data before the diskstream sees it */
365 filter_channels (bufs, get_capture_channel_mode(), get_capture_channel_mask());
369 if ((dret = diskstream->process (bufs, transport_frame, nframes, playback_distance, (monitoring_state() == MonitoringDisk))) != 0) {
370 need_butler = diskstream->commit (playback_distance);
375 /* filter playback data before we do anything else */
377 filter_channels (bufs, get_playback_channel_mode(), get_playback_channel_mask ());
379 if (monitoring_state() == MonitoringInput) {
381 /* not actually recording, but we want to hear the input material anyway,
382 at least potentially (depending on monitoring options)
385 /* because the playback buffer is event based and not a
386 * continuous stream, we need to make sure that we empty
387 * it of events every cycle to avoid it filling up with events
388 * read from disk, while we are actually monitoring input
391 diskstream->flush_playback (start_frame, end_frame);
396 /* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
398 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
400 /* final argument: don't waste time with automation if we're not recording or rolling */
402 process_output_buffers (bufs, start_frame, end_frame, nframes,
403 declick, (!diskstream->record_enabled() && !_session.transport_stopped()));
405 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
406 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
408 d->flush_buffers (nframes);
412 need_butler = diskstream->commit (playback_distance);
418 MidiTrack::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool state_changing)
420 int ret = Track::no_roll (nframes, start_frame, end_frame, state_changing);
422 if (ret == 0 && _step_editing) {
423 push_midi_input_to_step_edit_ringbuffer (nframes);
430 MidiTrack::realtime_locate ()
432 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
438 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
439 (*i)->realtime_locate ();
442 midi_diskstream()->reset_tracker ();
446 MidiTrack::realtime_handle_transport_stopped ()
448 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
454 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
455 (*i)->realtime_handle_transport_stopped ();
460 MidiTrack::push_midi_input_to_step_edit_ringbuffer (framecnt_t nframes)
462 PortSet& ports (_input->ports());
464 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
466 Buffer& b (p->get_buffer (nframes));
467 const MidiBuffer* const mb = dynamic_cast<MidiBuffer*>(&b);
470 for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) {
472 const Evoral::MIDIEvent<framepos_t> ev(*e, false);
474 /* note on, since for step edit, note length is determined
478 if (ev.is_note_on()) {
479 /* we don't care about the time for this purpose */
480 _step_edit_ring_buffer.write (0, ev.type(), ev.size(), ev.buffer());
487 MidiTrack::filter_channels (BufferSet& bufs, ChannelMode mode, uint32_t mask)
489 if (mode == AllChannels) {
493 MidiBuffer& buf (bufs.get_midi (0));
495 for (MidiBuffer::iterator e = buf.begin(); e != buf.end(); ) {
497 Evoral::MIDIEvent<framepos_t> ev(*e, false);
499 if (ev.is_channel_event()) {
502 if (0 == ((1<<ev.channel()) & mask)) {
509 ev.set_channel (PBD::ffs (mask) - 1);
513 /* handled by the opening if() */
524 MidiTrack::write_out_of_band_data (BufferSet& bufs, framepos_t /*start*/, framepos_t /*end*/, framecnt_t nframes)
526 MidiBuffer& buf (bufs.get_midi (0));
528 // Append immediate events
530 if (_immediate_events.read_space()) {
532 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 has %2 of immediate events to deliver\n",
533 name(), _immediate_events.read_space()));
535 /* write as many of the immediate events as we can, but give "true" as
536 * the last argument ("stop on overflow in destination") so that we'll
537 * ship the rest out next time.
539 * the Port::port_offset() + (nframes-1) argument puts all these events at the last
540 * possible position of the output buffer, so that we do not
541 * violate monotonicity when writing. Port::port_offset() will
542 * be non-zero if we're in a split process cycle.
544 _immediate_events.read (buf, 0, 1, Port::port_offset() + nframes - 1, true);
549 MidiTrack::export_stuff (BufferSet& /*bufs*/, framepos_t /*start_frame*/, framecnt_t /*nframes*/,
550 boost::shared_ptr<Processor> /*endpoint*/, bool /*include_endpoint*/, bool /*for_export*/, bool /*for_freeze*/)
555 boost::shared_ptr<Region>
556 MidiTrack::bounce (InterThreadInfo& /*itt*/)
558 std::cerr << "MIDI bounce currently unsupported" << std::endl;
559 return boost::shared_ptr<Region> ();
563 boost::shared_ptr<Region>
564 MidiTrack::bounce_range (framepos_t /*start*/, framepos_t /*end*/, InterThreadInfo& /*itt*/,
565 boost::shared_ptr<Processor> /*endpoint*/, bool /*include_endpoint*/)
567 std::cerr << "MIDI bounce range currently unsupported" << std::endl;
568 return boost::shared_ptr<Region> ();
572 MidiTrack::freeze_me (InterThreadInfo& /*itt*/)
574 std::cerr << "MIDI freeze currently unsupported" << std::endl;
578 MidiTrack::unfreeze ()
580 _freeze_record.state = UnFrozen;
581 FreezeChange (); /* EMIT SIGNAL */
585 MidiTrack::set_note_mode (NoteMode m)
588 midi_diskstream()->set_note_mode(m);
592 MidiTrack::describe_parameter (Evoral::Parameter param)
594 const std::string str(instrument_info().get_controller_name(param));
595 return str.empty() ? Automatable::describe_parameter(param) : str;
599 MidiTrack::midi_panic()
601 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers panic data\n", name()));
602 for (uint8_t channel = 0; channel <= 0xF; channel++) {
603 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), ((uint8_t) MIDI_CTL_SUSTAIN), 0 };
604 write_immediate_event(3, ev);
605 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
606 write_immediate_event(3, ev);
607 ev[1] = MIDI_CTL_RESET_CONTROLLERS;
608 write_immediate_event(3, ev);
612 /** \return true on success, false on failure (no buffer space left)
615 MidiTrack::write_immediate_event(size_t size, const uint8_t* buf)
617 if (!Evoral::midi_event_is_valid(buf, size)) {
618 cerr << "WARNING: Ignoring illegal immediate MIDI event" << endl;
621 const uint32_t type = EventTypeMap::instance().midi_event_type(buf[0]);
622 return (_immediate_events.write (0, type, size, buf) == size);
626 MidiTrack::set_parameter_automation_state (Evoral::Parameter param, AutoState state)
628 switch (param.type()) {
629 case MidiCCAutomation:
630 case MidiPgmChangeAutomation:
631 case MidiPitchBenderAutomation:
632 case MidiChannelPressureAutomation:
633 case MidiSystemExclusiveAutomation:
634 /* The track control for MIDI parameters is for immediate events to act
635 as a control surface, write/touch for them is not currently
639 Automatable::set_parameter_automation_state(param, state);
644 MidiTrack::MidiControl::set_value(double val)
646 const Evoral::Parameter ¶meter = _list ? _list->parameter() : Control::parameter();
650 cerr << "MIDIControl value is infinity" << endl;
651 } else if (isnan(val)) {
652 cerr << "MIDIControl value is NaN" << endl;
653 } else if (val < parameter.min()) {
654 cerr << "MIDIControl value is < " << parameter.min() << endl;
655 } else if (val > parameter.max()) {
656 cerr << "MIDIControl value is > " << parameter.max() << endl;
665 assert(val <= parameter.max());
666 if ( ! _list || ! automation_playback()) {
668 uint8_t ev[3] = { parameter.channel(), uint8_t (val), 0 };
669 switch(parameter.type()) {
670 case MidiCCAutomation:
671 ev[0] += MIDI_CMD_CONTROL;
672 ev[1] = parameter.id();
676 case MidiPgmChangeAutomation:
678 ev[0] += MIDI_CMD_PGM_CHANGE;
682 case MidiChannelPressureAutomation:
684 ev[0] += MIDI_CMD_CHANNEL_PRESSURE;
688 case MidiPitchBenderAutomation:
689 ev[0] += MIDI_CMD_BENDER;
690 ev[1] = 0x7F & int(val);
691 ev[2] = 0x7F & (int(val) >> 7);
697 _route->write_immediate_event(size, ev);
700 AutomationControl::set_value(val);
704 MidiTrack::set_step_editing (bool yn)
706 if (_session.record_status() != Session::Disabled) {
710 if (yn != _step_editing) {
712 StepEditStatusChange (yn);
716 boost::shared_ptr<SMFSource>
717 MidiTrack::write_source (uint32_t)
719 return midi_diskstream()->write_source ();
723 MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask)
725 ChannelMode old = get_playback_channel_mode ();
726 uint16_t old_mask = get_playback_channel_mask ();
728 if (old != mode || mask != old_mask) {
729 _set_playback_channel_mode (mode, mask);
730 PlaybackChannelModeChanged ();
731 _session.set_dirty ();
736 MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask)
738 ChannelMode old = get_capture_channel_mode ();
739 uint16_t old_mask = get_capture_channel_mask ();
741 if (old != mode || mask != old_mask) {
742 _set_capture_channel_mode (mode, mask);
743 CaptureChannelModeChanged ();
744 _session.set_dirty ();
749 MidiTrack::set_playback_channel_mask (uint16_t mask)
751 uint16_t old = get_playback_channel_mask();
754 _set_playback_channel_mask (mask);
755 PlaybackChannelMaskChanged ();
756 _session.set_dirty ();
761 MidiTrack::set_capture_channel_mask (uint16_t mask)
763 uint16_t old = get_capture_channel_mask();
766 _set_capture_channel_mask (mask);
767 CaptureChannelMaskChanged ();
768 _session.set_dirty ();
772 boost::shared_ptr<MidiPlaylist>
773 MidiTrack::midi_playlist ()
775 return midi_diskstream()->midi_playlist ();
779 MidiTrack::diskstream_data_recorded (boost::weak_ptr<MidiSource> src)
781 DataRecorded (src); /* EMIT SIGNAL */
785 MidiTrack::input_active () const
787 return _input_active;
791 MidiTrack::set_input_active (bool yn)
793 if (yn != _input_active) {
795 map_input_active (yn);
796 InputActiveChanged (); /* EMIT SIGNAL */
801 MidiTrack::map_input_active (bool yn)
807 PortSet& ports (_input->ports());
809 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
810 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
811 if (yn != mp->input_active()) {
812 mp->set_input_active (yn);
818 MidiTrack::track_input_active (IOChange change, void* /* src */)
820 if (change.type & IOChange::ConfigurationChanged) {
821 map_input_active (_input_active);
825 boost::shared_ptr<Diskstream>
826 MidiTrack::diskstream_factory (XMLNode const & node)
828 return boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, node));
831 boost::shared_ptr<MidiBuffer>
832 MidiTrack::get_gui_feed_buffer () const
834 return midi_diskstream()->get_gui_feed_buffer ();
838 MidiTrack::act_on_mute ()
840 /* this is called right after our mute status has changed.
841 if we are now muted, send suitable output to shutdown
844 XXX we should should also stop all relevant note trackers.
847 /* If we haven't got a diskstream yet, there's nothing to worry about,
848 and we can't call get_channel_mask() anyway.
850 if (!midi_diskstream()) {
855 /* only send messages for channels we are using */
857 uint16_t mask = get_playback_channel_mask();
859 for (uint8_t channel = 0; channel <= 0xF; channel++) {
861 if ((1<<channel) & mask) {
863 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers mute message to channel %2\n", name(), channel+1));
864 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), MIDI_CTL_SUSTAIN, 0 };
865 write_immediate_event (3, ev);
866 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
867 write_immediate_event (3, ev);
874 MidiTrack::set_monitoring (MonitorChoice mc)
876 if (mc != _monitoring) {
878 Track::set_monitoring (mc);
880 /* monitoring state changed, so flush out any on notes at the
884 PortSet& ports (_output->ports());
886 for (PortSet::iterator p = ports.begin(); p != ports.end(); ++p) {
887 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
889 mp->require_resolve ();
893 boost::shared_ptr<MidiDiskstream> md (midi_diskstream());
896 md->reset_tracker ();
902 MidiTrack::monitoring_state () const
904 MonitorState ms = Track::monitoring_state();
905 if (ms == MonitoringSilence) {
906 return MonitoringInput;