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);
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 (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.
544 _immediate_events.read (buf, 0, 1, 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 /*forexport*/)
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::MidiControl::set_value(double val)
629 if (std::isinf(val)) {
630 cerr << "MIDIControl value is infinity" << endl;
631 } else if (std::isnan(val)) {
632 cerr << "MIDIControl value is NaN" << endl;
633 } else if (val < _list->parameter().min()) {
634 cerr << "MIDIControl value is < " << _list->parameter().min() << endl;
635 } else if (val > _list->parameter().max()) {
636 cerr << "MIDIControl value is > " << _list->parameter().max() << endl;
645 assert(val <= _list->parameter().max());
646 if ( ! automation_playback()) {
648 uint8_t ev[3] = { _list->parameter().channel(), uint8_t (val), 0 };
649 switch(_list->parameter().type()) {
650 case MidiCCAutomation:
651 ev[0] += MIDI_CMD_CONTROL;
652 ev[1] = _list->parameter().id();
656 case MidiPgmChangeAutomation:
658 ev[0] += MIDI_CMD_PGM_CHANGE;
662 case MidiChannelPressureAutomation:
664 ev[0] += MIDI_CMD_CHANNEL_PRESSURE;
668 case MidiPitchBenderAutomation:
669 ev[0] += MIDI_CMD_BENDER;
670 ev[1] = 0x7F & int(val);
671 ev[2] = 0x7F & (int(val) >> 7);
677 _route->write_immediate_event(size, ev);
680 AutomationControl::set_value(val);
684 MidiTrack::set_step_editing (bool yn)
686 if (_session.record_status() != Session::Disabled) {
690 if (yn != _step_editing) {
692 StepEditStatusChange (yn);
696 boost::shared_ptr<SMFSource>
697 MidiTrack::write_source (uint32_t)
699 return midi_diskstream()->write_source ();
703 MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask)
705 ChannelMode old = get_playback_channel_mode ();
706 uint16_t old_mask = get_playback_channel_mask ();
708 if (old != mode || mask != old_mask) {
709 _set_playback_channel_mode (mode, mask);
710 PlaybackChannelModeChanged ();
711 _session.set_dirty ();
716 MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask)
718 ChannelMode old = get_capture_channel_mode ();
719 uint16_t old_mask = get_capture_channel_mask ();
721 if (old != mode || mask != old_mask) {
722 _set_capture_channel_mode (mode, mask);
723 CaptureChannelModeChanged ();
724 _session.set_dirty ();
729 MidiTrack::set_playback_channel_mask (uint16_t mask)
731 uint16_t old = get_playback_channel_mask();
734 _set_playback_channel_mask (mask);
735 PlaybackChannelMaskChanged ();
736 _session.set_dirty ();
741 MidiTrack::set_capture_channel_mask (uint16_t mask)
743 uint16_t old = get_capture_channel_mask();
746 _set_capture_channel_mask (mask);
747 CaptureChannelMaskChanged ();
748 _session.set_dirty ();
752 boost::shared_ptr<MidiPlaylist>
753 MidiTrack::midi_playlist ()
755 return midi_diskstream()->midi_playlist ();
759 MidiTrack::diskstream_data_recorded (boost::weak_ptr<MidiSource> src)
761 DataRecorded (src); /* EMIT SIGNAL */
765 MidiTrack::input_active () const
767 return _input_active;
771 MidiTrack::set_input_active (bool yn)
773 if (yn != _input_active) {
775 map_input_active (yn);
776 InputActiveChanged (); /* EMIT SIGNAL */
781 MidiTrack::map_input_active (bool yn)
787 PortSet& ports (_input->ports());
789 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
790 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
791 if (yn != mp->input_active()) {
792 mp->set_input_active (yn);
798 MidiTrack::track_input_active (IOChange change, void* /* src */)
800 if (change.type & IOChange::ConfigurationChanged) {
801 map_input_active (_input_active);
805 boost::shared_ptr<Diskstream>
806 MidiTrack::diskstream_factory (XMLNode const & node)
808 return boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, node));
811 boost::shared_ptr<MidiBuffer>
812 MidiTrack::get_gui_feed_buffer () const
814 return midi_diskstream()->get_gui_feed_buffer ();
818 MidiTrack::act_on_mute ()
820 /* this is called right after our mute status has changed.
821 if we are now muted, send suitable output to shutdown
824 XXX we should should also stop all relevant note trackers.
827 /* If we haven't got a diskstream yet, there's nothing to worry about,
828 and we can't call get_channel_mask() anyway.
830 if (!midi_diskstream()) {
835 /* only send messages for channels we are using */
837 uint16_t mask = get_playback_channel_mask();
839 for (uint8_t channel = 0; channel <= 0xF; channel++) {
841 if ((1<<channel) & mask) {
843 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers mute message to channel %2\n", name(), channel+1));
844 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), MIDI_CTL_SUSTAIN, 0 };
845 write_immediate_event (3, ev);
846 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
847 write_immediate_event (3, ev);
854 MidiTrack::set_monitoring (MonitorChoice mc)
856 if (mc != _monitoring) {
858 Track::set_monitoring (mc);
860 /* monitoring state changed, so flush out any on notes at the
864 PortSet& ports (_output->ports());
866 for (PortSet::iterator p = ports.begin(); p != ports.end(); ++p) {
867 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
869 mp->require_resolve ();
873 boost::shared_ptr<MidiDiskstream> md (midi_diskstream());
876 md->reset_tracker ();
882 MidiTrack::monitoring_state () const
884 MonitorState ms = Track::monitoring_state();
885 if (ms == MonitoringSilence) {
886 return MonitoringInput;