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 (0);
85 if (_flags & Auditioner) {
86 dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Hidden);
88 dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Recordable);
91 assert(_mode != Destructive);
93 return boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, name(), dflags));
98 MidiTrack::set_record_enabled (bool yn, void *src)
104 Track::set_record_enabled (yn, src);
108 MidiTrack::set_diskstream (boost::shared_ptr<Diskstream> ds)
110 /* We have to do this here, as Track::set_diskstream will cause a buffer refill,
111 and the diskstream must be set up to fill its buffers using the correct _note_mode.
113 boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream> (ds);
114 mds->set_note_mode (_note_mode);
116 Track::set_diskstream (ds);
118 mds->reset_tracker ();
120 _diskstream->set_track (this);
121 _diskstream->set_destructive (_mode == Destructive);
122 _diskstream->set_record_enabled (false);
124 _diskstream_data_recorded_connection.disconnect ();
125 mds->DataRecorded.connect_same_thread (
126 _diskstream_data_recorded_connection,
127 boost::bind (&MidiTrack::diskstream_data_recorded, this, _1));
129 DiskstreamChanged (); /* EMIT SIGNAL */
132 boost::shared_ptr<MidiDiskstream>
133 MidiTrack::midi_diskstream() const
135 return boost::dynamic_pointer_cast<MidiDiskstream>(_diskstream);
139 MidiTrack::set_state (const XMLNode& node, int version)
141 const XMLProperty *prop;
143 /* This must happen before Track::set_state(), as there will be a buffer
144 fill during that call, and we must fill buffers using the correct
147 if ((prop = node.property (X_("note-mode"))) != 0) {
148 _note_mode = NoteMode (string_2_enum (prop->value(), _note_mode));
150 _note_mode = Sustained;
153 if (Track::set_state (node, version)) {
157 // No destructive MIDI tracks (yet?)
160 if ((prop = node.property ("input-active")) != 0) {
161 set_input_active (string_is_affirmative (prop->value()));
164 ChannelMode playback_channel_mode = AllChannels;
165 ChannelMode capture_channel_mode = AllChannels;
167 if ((prop = node.property ("playback-channel-mode")) != 0) {
168 playback_channel_mode = ChannelMode (string_2_enum(prop->value(), playback_channel_mode));
170 if ((prop = node.property ("capture-channel-mode")) != 0) {
171 capture_channel_mode = ChannelMode (string_2_enum(prop->value(), capture_channel_mode));
173 if ((prop = node.property ("channel-mode")) != 0) {
174 /* 3.0 behaviour where capture and playback modes were not separated */
175 playback_channel_mode = ChannelMode (string_2_enum(prop->value(), playback_channel_mode));
176 capture_channel_mode = playback_channel_mode;
179 unsigned int playback_channel_mask = 0xffff;
180 unsigned int capture_channel_mask = 0xffff;
182 if ((prop = node.property ("playback-channel-mask")) != 0) {
183 sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask);
185 if ((prop = node.property ("capture-channel-mask")) != 0) {
186 sscanf (prop->value().c_str(), "0x%x", &capture_channel_mask);
188 if ((prop = node.property ("channel-mask")) != 0) {
189 sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask);
190 capture_channel_mask = playback_channel_mask;
193 set_playback_channel_mode (playback_channel_mode, playback_channel_mask);
194 set_capture_channel_mode (capture_channel_mode, capture_channel_mask);
196 pending_state = const_cast<XMLNode*> (&node);
198 if (_session.state_of_the_state() & Session::Loading) {
199 _session.StateReady.connect_same_thread (
200 *this, boost::bind (&MidiTrack::set_state_part_two, this));
202 set_state_part_two ();
209 MidiTrack::state(bool full_state)
211 XMLNode& root (Track::state(full_state));
212 XMLNode* freeze_node;
215 if (_freeze_record.playlist) {
218 freeze_node = new XMLNode (X_("freeze-info"));
219 freeze_node->add_property ("playlist", _freeze_record.playlist->name());
220 freeze_node->add_property ("state", enum_2_string (_freeze_record.state));
222 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
223 inode = new XMLNode (X_("processor"));
224 (*i)->id.print (buf, sizeof(buf));
225 inode->add_property (X_("id"), buf);
226 inode->add_child_copy ((*i)->state);
228 freeze_node->add_child_nocopy (*inode);
231 root.add_child_nocopy (*freeze_node);
234 root.add_property("playback_channel-mode", enum_2_string(get_playback_channel_mode()));
235 root.add_property("capture_channel-mode", enum_2_string(get_capture_channel_mode()));
236 snprintf (buf, sizeof(buf), "0x%x", get_playback_channel_mask());
237 root.add_property("playback-channel-mask", buf);
238 snprintf (buf, sizeof(buf), "0x%x", get_capture_channel_mask());
239 root.add_property("capture-channel-mask", buf);
241 root.add_property ("note-mode", enum_2_string (_note_mode));
242 root.add_property ("step-editing", (_step_editing ? "yes" : "no"));
243 root.add_property ("input-active", (_input_active ? "yes" : "no"));
249 MidiTrack::set_state_part_two ()
253 LocaleGuard lg (X_("POSIX"));
255 /* This is called after all session state has been restored but before
256 have been made ports and connections are established.
259 if (pending_state == 0) {
263 if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
265 _freeze_record.state = Frozen;
267 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
270 _freeze_record.processor_info.clear ();
272 if ((prop = fnode->property (X_("playlist"))) != 0) {
273 boost::shared_ptr<Playlist> pl = _session.playlists->by_name (prop->value());
275 _freeze_record.playlist = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
277 _freeze_record.playlist.reset();
278 _freeze_record.state = NoFreeze;
283 if ((prop = fnode->property (X_("state"))) != 0) {
284 _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state));
287 XMLNodeConstIterator citer;
288 XMLNodeList clist = fnode->children();
290 for (citer = clist.begin(); citer != clist.end(); ++citer) {
291 if ((*citer)->name() != X_("processor")) {
295 if ((prop = (*citer)->property (X_("id"))) == 0) {
299 FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
300 boost::shared_ptr<Processor>());
301 frii->id = prop->value ();
302 _freeze_record.processor_info.push_back (frii);
306 if (midi_diskstream ()) {
307 midi_diskstream()->set_block_size (_session.get_block_size ());
313 /** @param need_butler to be set to true if this track now needs the butler, otherwise it can be left alone
317 MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
319 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
321 boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
322 framecnt_t playback_distance = diskstream->calculate_playback_distance(nframes);
323 if (can_internal_playback_seek(std::llabs(playback_distance))) {
324 /* TODO should declick, and/or note-off */
325 internal_playback_seek(playback_distance);
330 boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
332 if (n_outputs().n_total() == 0 && _processors.empty()) {
338 if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
344 framepos_t transport_frame = _session.transport_frame();
347 framecnt_t playback_distance;
349 if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) {
350 /* need to do this so that the diskstream sets its
351 playback distance to zero, thus causing diskstream::commit
354 BufferSet bufs; /* empty set - is OK, since nothing will happen */
356 dret = diskstream->process (bufs, transport_frame, 0, playback_distance, false);
357 need_butler = diskstream->commit (playback_distance);
361 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
363 fill_buffers_with_input (bufs, _input, nframes);
365 if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
366 _meter->run (bufs, start_frame, end_frame, nframes, true);
369 /* filter captured data before the diskstream sees it */
371 filter_channels (bufs, get_capture_channel_mode(), get_capture_channel_mask());
375 if ((dret = diskstream->process (bufs, transport_frame, nframes, playback_distance, (monitoring_state() == MonitoringDisk))) != 0) {
376 need_butler = diskstream->commit (playback_distance);
381 /* filter playback data before we do anything else */
383 filter_channels (bufs, get_playback_channel_mode(), get_playback_channel_mask ());
385 if (monitoring_state() == MonitoringInput) {
387 /* not actually recording, but we want to hear the input material anyway,
388 at least potentially (depending on monitoring options)
391 /* because the playback buffer is event based and not a
392 * continuous stream, we need to make sure that we empty
393 * it of events every cycle to avoid it filling up with events
394 * read from disk, while we are actually monitoring input
397 diskstream->flush_playback (start_frame, end_frame);
402 /* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
404 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
406 /* final argument: don't waste time with automation if we're not recording or rolling */
408 process_output_buffers (bufs, start_frame, end_frame, nframes,
409 declick, (!diskstream->record_enabled() && !_session.transport_stopped()));
411 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
412 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
414 d->flush_buffers (nframes);
418 need_butler = diskstream->commit (playback_distance);
424 MidiTrack::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool state_changing)
426 int ret = Track::no_roll (nframes, start_frame, end_frame, state_changing);
428 if (ret == 0 && _step_editing) {
429 push_midi_input_to_step_edit_ringbuffer (nframes);
436 MidiTrack::realtime_locate ()
438 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
444 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
445 (*i)->realtime_locate ();
448 midi_diskstream()->reset_tracker ();
452 MidiTrack::realtime_handle_transport_stopped ()
454 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
460 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
461 (*i)->realtime_handle_transport_stopped ();
466 MidiTrack::push_midi_input_to_step_edit_ringbuffer (framecnt_t nframes)
468 PortSet& ports (_input->ports());
470 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
472 Buffer& b (p->get_buffer (nframes));
473 const MidiBuffer* const mb = dynamic_cast<MidiBuffer*>(&b);
476 for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) {
478 const Evoral::MIDIEvent<framepos_t> ev(*e, false);
480 /* note on, since for step edit, note length is determined
484 if (ev.is_note_on()) {
485 /* we don't care about the time for this purpose */
486 _step_edit_ring_buffer.write (0, ev.type(), ev.size(), ev.buffer());
493 MidiTrack::filter_channels (BufferSet& bufs, ChannelMode mode, uint32_t mask)
495 if (mode == AllChannels) {
499 MidiBuffer& buf (bufs.get_midi (0));
501 for (MidiBuffer::iterator e = buf.begin(); e != buf.end(); ) {
503 Evoral::MIDIEvent<framepos_t> ev(*e, false);
505 if (ev.is_channel_event()) {
508 if (0 == ((1<<ev.channel()) & mask)) {
515 ev.set_channel (PBD::ffs (mask) - 1);
519 /* handled by the opening if() */
530 MidiTrack::write_out_of_band_data (BufferSet& bufs, framepos_t /*start*/, framepos_t /*end*/, framecnt_t nframes)
532 MidiBuffer& buf (bufs.get_midi (0));
534 // Append immediate events
536 if (_immediate_events.read_space()) {
538 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 has %2 of immediate events to deliver\n",
539 name(), _immediate_events.read_space()));
541 /* write as many of the immediate events as we can, but give "true" as
542 * the last argument ("stop on overflow in destination") so that we'll
543 * ship the rest out next time.
545 * the (nframes-1) argument puts all these events at the last
546 * possible position of the output buffer, so that we do not
547 * violate monotonicity when writing.
550 _immediate_events.read (buf, 0, 1, nframes-1, true);
555 MidiTrack::export_stuff (BufferSet& /*bufs*/, framepos_t /*start_frame*/, framecnt_t /*nframes*/,
556 boost::shared_ptr<Processor> /*endpoint*/, bool /*include_endpoint*/, bool /*forexport*/)
561 boost::shared_ptr<Region>
562 MidiTrack::bounce (InterThreadInfo& /*itt*/)
564 std::cerr << "MIDI bounce currently unsupported" << std::endl;
565 return boost::shared_ptr<Region> ();
569 boost::shared_ptr<Region>
570 MidiTrack::bounce_range (framepos_t /*start*/, framepos_t /*end*/, InterThreadInfo& /*itt*/,
571 boost::shared_ptr<Processor> /*endpoint*/, bool /*include_endpoint*/)
573 std::cerr << "MIDI bounce range currently unsupported" << std::endl;
574 return boost::shared_ptr<Region> ();
578 MidiTrack::freeze_me (InterThreadInfo& /*itt*/)
580 std::cerr << "MIDI freeze currently unsupported" << std::endl;
584 MidiTrack::unfreeze ()
586 _freeze_record.state = UnFrozen;
587 FreezeChange (); /* EMIT SIGNAL */
591 MidiTrack::set_note_mode (NoteMode m)
594 midi_diskstream()->set_note_mode(m);
598 MidiTrack::describe_parameter (Evoral::Parameter param)
600 const std::string str(instrument_info().get_controller_name(param));
601 return str.empty() ? Automatable::describe_parameter(param) : str;
605 MidiTrack::midi_panic()
607 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers panic data\n", name()));
608 for (uint8_t channel = 0; channel <= 0xF; channel++) {
609 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), ((uint8_t) MIDI_CTL_SUSTAIN), 0 };
610 write_immediate_event(3, ev);
611 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
612 write_immediate_event(3, ev);
613 ev[1] = MIDI_CTL_RESET_CONTROLLERS;
614 write_immediate_event(3, ev);
618 /** \return true on success, false on failure (no buffer space left)
621 MidiTrack::write_immediate_event(size_t size, const uint8_t* buf)
623 if (!Evoral::midi_event_is_valid(buf, size)) {
624 cerr << "WARNING: Ignoring illegal immediate MIDI event" << endl;
627 const uint32_t type = EventTypeMap::instance().midi_event_type(buf[0]);
628 return (_immediate_events.write(0, type, size, buf) == size);
632 MidiTrack::MidiControl::set_value(double val)
636 cerr << "MIDIControl value is infinity" << endl;
637 } else if (isnan(val)) {
638 cerr << "MIDIControl value is NaN" << endl;
639 } else if (val < _list->parameter().min()) {
640 cerr << "MIDIControl value is < " << _list->parameter().min() << endl;
641 } else if (val > _list->parameter().max()) {
642 cerr << "MIDIControl value is > " << _list->parameter().max() << endl;
651 assert(val <= _list->parameter().max());
652 if ( ! automation_playback()) {
654 uint8_t ev[3] = { _list->parameter().channel(), uint8_t (val), 0 };
655 switch(_list->parameter().type()) {
656 case MidiCCAutomation:
657 ev[0] += MIDI_CMD_CONTROL;
658 ev[1] = _list->parameter().id();
662 case MidiPgmChangeAutomation:
664 ev[0] += MIDI_CMD_PGM_CHANGE;
668 case MidiChannelPressureAutomation:
670 ev[0] += MIDI_CMD_CHANNEL_PRESSURE;
674 case MidiPitchBenderAutomation:
675 ev[0] += MIDI_CMD_BENDER;
676 ev[1] = 0x7F & int(val);
677 ev[2] = 0x7F & (int(val) >> 7);
683 _route->write_immediate_event(size, ev);
686 AutomationControl::set_value(val);
690 MidiTrack::set_step_editing (bool yn)
692 if (_session.record_status() != Session::Disabled) {
696 if (yn != _step_editing) {
698 StepEditStatusChange (yn);
702 boost::shared_ptr<SMFSource>
703 MidiTrack::write_source (uint32_t)
705 return midi_diskstream()->write_source ();
709 MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask)
711 ChannelMode old = get_playback_channel_mode ();
712 uint16_t old_mask = get_playback_channel_mask ();
714 if (old != mode || mask != old_mask) {
715 _set_playback_channel_mode (mode, mask);
716 PlaybackChannelModeChanged ();
717 _session.set_dirty ();
722 MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask)
724 ChannelMode old = get_capture_channel_mode ();
725 uint16_t old_mask = get_capture_channel_mask ();
727 if (old != mode || mask != old_mask) {
728 _set_capture_channel_mode (mode, mask);
729 CaptureChannelModeChanged ();
730 _session.set_dirty ();
735 MidiTrack::set_playback_channel_mask (uint16_t mask)
737 uint16_t old = get_playback_channel_mask();
740 _set_playback_channel_mask (mask);
741 PlaybackChannelMaskChanged ();
742 _session.set_dirty ();
747 MidiTrack::set_capture_channel_mask (uint16_t mask)
749 uint16_t old = get_capture_channel_mask();
752 _set_capture_channel_mask (mask);
753 CaptureChannelMaskChanged ();
754 _session.set_dirty ();
758 boost::shared_ptr<MidiPlaylist>
759 MidiTrack::midi_playlist ()
761 return midi_diskstream()->midi_playlist ();
765 MidiTrack::diskstream_data_recorded (boost::weak_ptr<MidiSource> src)
767 DataRecorded (src); /* EMIT SIGNAL */
771 MidiTrack::input_active () const
773 return _input_active;
777 MidiTrack::set_input_active (bool yn)
779 if (yn != _input_active) {
781 map_input_active (yn);
782 InputActiveChanged (); /* EMIT SIGNAL */
787 MidiTrack::map_input_active (bool yn)
793 PortSet& ports (_input->ports());
795 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
796 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
797 if (yn != mp->input_active()) {
798 mp->set_input_active (yn);
804 MidiTrack::track_input_active (IOChange change, void* /* src */)
806 if (change.type & IOChange::ConfigurationChanged) {
807 map_input_active (_input_active);
811 boost::shared_ptr<Diskstream>
812 MidiTrack::diskstream_factory (XMLNode const & node)
814 return boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, node));
817 boost::shared_ptr<MidiBuffer>
818 MidiTrack::get_gui_feed_buffer () const
820 return midi_diskstream()->get_gui_feed_buffer ();
824 MidiTrack::act_on_mute ()
826 /* this is called right after our mute status has changed.
827 if we are now muted, send suitable output to shutdown
830 XXX we should should also stop all relevant note trackers.
833 /* If we haven't got a diskstream yet, there's nothing to worry about,
834 and we can't call get_channel_mask() anyway.
836 if (!midi_diskstream()) {
841 /* only send messages for channels we are using */
843 uint16_t mask = get_playback_channel_mask();
845 for (uint8_t channel = 0; channel <= 0xF; channel++) {
847 if ((1<<channel) & mask) {
849 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers mute message to channel %2\n", name(), channel+1));
850 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), MIDI_CTL_SUSTAIN, 0 };
851 write_immediate_event (3, ev);
852 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
853 write_immediate_event (3, ev);
860 MidiTrack::set_monitoring (MonitorChoice mc)
862 if (mc != _monitoring) {
864 Track::set_monitoring (mc);
866 /* monitoring state changed, so flush out any on notes at the
870 PortSet& ports (_output->ports());
872 for (PortSet::iterator p = ports.begin(); p != ports.end(); ++p) {
873 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
875 mp->require_resolve ();
879 boost::shared_ptr<MidiDiskstream> md (midi_diskstream());
882 md->reset_tracker ();
888 MidiTrack::monitoring_state () const
890 MonitorState ms = Track::monitoring_state();
891 if (ms == MonitoringSilence) {
892 return MonitoringInput;