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.
24 // 'std::isinf()' and 'std::isnan()' are not available in MSVC.
25 #define isinf_local(val) !((bool)_finite((double)val))
26 #define isnan_local(val) (bool)_isnan((double)val)
28 #define isinf_local std::isinf
29 #define isnan_local std::isnan
32 #include "pbd/enumwriter.h"
33 #include "pbd/types_convert.h"
34 #include "evoral/midi_util.h"
36 #include "ardour/amp.h"
37 #include "ardour/beats_samples_converter.h"
38 #include "ardour/buffer_set.h"
39 #include "ardour/debug.h"
40 #include "ardour/delivery.h"
41 #include "ardour/disk_reader.h"
42 #include "ardour/disk_writer.h"
43 #include "ardour/event_type_map.h"
44 #include "ardour/meter.h"
45 #include "ardour/midi_playlist.h"
46 #include "ardour/midi_port.h"
47 #include "ardour/midi_region.h"
48 #include "ardour/midi_track.h"
49 #include "ardour/monitor_control.h"
50 #include "ardour/parameter_types.h"
51 #include "ardour/port.h"
52 #include "ardour/processor.h"
53 #include "ardour/profile.h"
54 #include "ardour/route_group_specialized.h"
55 #include "ardour/session.h"
56 #include "ardour/session_playlists.h"
57 #include "ardour/types_convert.h"
58 #include "ardour/utils.h"
63 class InterThreadInfo;
70 using namespace ARDOUR;
73 MidiTrack::MidiTrack (Session& sess, string name, TrackMode mode)
74 : Track (sess, name, PresentationInfo::MidiTrack, mode, DataType::MIDI)
75 , _immediate_events(6096) // FIXME: size?
76 , _immediate_event_buffer(6096)
77 , _step_edit_ring_buffer(64) // FIXME: size?
78 , _note_mode (Sustained)
79 , _step_editing (false)
80 , _input_active (true)
82 _session.SessionLoaded.connect_same_thread (*this, boost::bind (&MidiTrack::restore_controls, this));
85 MidiTrack::~MidiTrack ()
96 _input->changed.connect_same_thread (*this, boost::bind (&MidiTrack::track_input_active, this, _1, _2));
98 _disk_writer->set_note_mode (_note_mode);
99 _disk_reader->reset_tracker ();
101 _disk_writer->DataRecorded.connect_same_thread (*this, boost::bind (&MidiTrack::data_recorded, this, _1));
107 MidiTrack::data_recorded (boost::weak_ptr<MidiSource> src)
109 DataRecorded (src); /* EMIT SIGNAL */
113 MidiTrack::can_be_record_safe ()
119 return Track::can_be_record_safe ();
123 MidiTrack::can_be_record_enabled ()
129 return Track::can_be_record_enabled ();
133 MidiTrack::set_state (const XMLNode& node, int version)
135 /* This must happen before Track::set_state(), as there will be a buffer
136 fill during that call, and we must fill buffers using the correct
139 if (!node.get_property (X_("note-mode"), _note_mode)) {
140 _note_mode = Sustained;
143 if (Track::set_state (node, version)) {
147 // No destructive MIDI tracks (yet?)
151 if (node.get_property ("input-active", yn)) {
152 set_input_active (yn);
155 ChannelMode playback_channel_mode = AllChannels;
156 ChannelMode capture_channel_mode = AllChannels;
158 node.get_property ("playback-channel-mode", playback_channel_mode);
159 node.get_property ("capture-channel-mode", capture_channel_mode);
161 if (node.get_property ("channel-mode", playback_channel_mode)) {
162 /* 3.0 behaviour where capture and playback modes were not separated */
163 capture_channel_mode = playback_channel_mode;
166 XMLProperty const * prop;
168 unsigned int playback_channel_mask = 0xffff;
169 unsigned int capture_channel_mask = 0xffff;
171 if ((prop = node.property ("playback-channel-mask")) != 0) {
172 sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask);
174 if ((prop = node.property ("capture-channel-mask")) != 0) {
175 sscanf (prop->value().c_str(), "0x%x", &capture_channel_mask);
177 if ((prop = node.property ("channel-mask")) != 0) {
178 sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask);
179 capture_channel_mask = playback_channel_mask;
182 set_playback_channel_mode (playback_channel_mode, playback_channel_mask);
183 set_capture_channel_mode (capture_channel_mode, capture_channel_mask);
185 pending_state = const_cast<XMLNode*> (&node);
187 if (_session.state_of_the_state() & Session::Loading) {
188 _session.StateReady.connect_same_thread (
189 *this, boost::bind (&MidiTrack::set_state_part_two, this));
191 set_state_part_two ();
198 MidiTrack::state(bool save_template)
200 XMLNode& root (Track::state (save_template));
201 XMLNode* freeze_node;
204 if (_freeze_record.playlist) {
207 freeze_node = new XMLNode (X_("freeze-info"));
208 freeze_node->set_property ("playlist", _freeze_record.playlist->name());
209 freeze_node->set_property ("state", _freeze_record.state);
211 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
212 inode = new XMLNode (X_("processor"));
213 inode->set_property (X_("id"), id());
214 inode->add_child_copy ((*i)->state);
216 freeze_node->add_child_nocopy (*inode);
219 root.add_child_nocopy (*freeze_node);
222 root.set_property("playback-channel-mode", get_playback_channel_mode());
223 root.set_property("capture-channel-mode", get_capture_channel_mode());
224 snprintf (buf, sizeof(buf), "0x%x", get_playback_channel_mask());
225 root.set_property("playback-channel-mask", std::string(buf));
226 snprintf (buf, sizeof(buf), "0x%x", get_capture_channel_mask());
227 root.set_property("capture-channel-mask", std::string(buf));
229 root.set_property ("note-mode", _note_mode);
230 root.set_property ("step-editing", _step_editing);
231 root.set_property ("input-active", _input_active);
233 for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
234 if (boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second)) {
235 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c->second);
237 root.add_child_nocopy (ac->get_state ());
245 MidiTrack::set_state_part_two ()
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 ();
267 if (fnode->get_property (X_("playlist"), str)) {
268 boost::shared_ptr<Playlist> pl = _session.playlists->by_name (str);
270 _freeze_record.playlist = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
272 _freeze_record.playlist.reset();
273 _freeze_record.state = NoFreeze;
278 fnode->get_property (X_("state"), _freeze_record.state);
280 XMLNodeConstIterator citer;
281 XMLNodeList clist = fnode->children();
283 for (citer = clist.begin(); citer != clist.end(); ++citer) {
284 if ((*citer)->name() != X_("processor")) {
288 if (!(*citer)->get_property (X_("id"), str)) {
292 FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
293 boost::shared_ptr<Processor>());
295 _freeze_record.processor_info.push_back (frii);
303 MidiTrack::restore_controls ()
305 // TODO order events (CC before PGM to set banks)
306 for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
307 boost::shared_ptr<MidiTrack::MidiControl> mctrl = boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second);
309 mctrl->restore_value();
315 MidiTrack::update_controls (BufferSet const& bufs)
317 const MidiBuffer& buf = bufs.get_midi(0);
318 for (MidiBuffer::const_iterator e = buf.begin(); e != buf.end(); ++e) {
319 const Evoral::Event<samplepos_t>& ev = *e;
320 const Evoral::Parameter param = midi_parameter(ev.buffer(), ev.size());
321 const boost::shared_ptr<AutomationControl> control = automation_control (param);
323 double old = control->get_double (false, 0);
324 control->set_double (ev.value(), 0, false);
325 if (old != ev.value()) {
326 control->Changed (false, Controllable::NoGroup);
333 MidiTrack::no_roll_unlocked (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool state_changing)
335 int ret = Track::no_roll_unlocked (nframes, start_sample, end_sample, state_changing);
337 if (ret == 0 && _step_editing) {
338 push_midi_input_to_step_edit_ringbuffer (nframes);
345 MidiTrack::realtime_locate ()
347 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
353 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
354 (*i)->realtime_locate ();
357 _disk_reader->reset_tracker ();
361 MidiTrack::non_realtime_locate (samplepos_t pos)
363 Track::non_realtime_locate(pos);
365 boost::shared_ptr<MidiPlaylist> playlist = _disk_writer->midi_playlist();
370 /* Get the top unmuted region at this position. */
371 boost::shared_ptr<MidiRegion> region = boost::dynamic_pointer_cast<MidiRegion>(
372 playlist->top_unmuted_region_at(pos));
377 /* the source may be missing, but the control still referenced in the GUI */
378 if (!region->midi_source() || !region->model()) {
382 Glib::Threads::Mutex::Lock lm (_control_lock, Glib::Threads::TRY_LOCK);
387 /* Update track controllers based on its "automation". */
388 const samplepos_t origin = region->position() - region->start();
389 BeatsSamplesConverter bfc(_session.tempo_map(), origin);
390 for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
391 boost::shared_ptr<MidiTrack::MidiControl> tcontrol;
392 boost::shared_ptr<Evoral::Control> rcontrol;
393 if ((tcontrol = boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second)) &&
394 (rcontrol = region->control(tcontrol->parameter()))) {
395 const Temporal::Beats pos_beats = bfc.from(pos - origin);
396 if (rcontrol->list()->size() > 0) {
397 tcontrol->set_value(rcontrol->list()->eval(pos_beats.to_double()), Controllable::NoGroup);
404 MidiTrack::push_midi_input_to_step_edit_ringbuffer (samplecnt_t nframes)
406 PortSet& ports (_input->ports());
408 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
410 Buffer& b (p->get_buffer (nframes));
411 const MidiBuffer* const mb = dynamic_cast<MidiBuffer*>(&b);
414 for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) {
416 const Evoral::Event<samplepos_t> ev(*e, false);
418 /* note on, since for step edit, note length is determined
422 if (ev.is_note_on()) {
423 /* we don't care about the time for this purpose */
424 _step_edit_ring_buffer.write (0, ev.event_type(), ev.size(), ev.buffer());
431 MidiTrack::snapshot_out_of_band_data (samplecnt_t nframes)
433 _immediate_event_buffer.clear ();
434 if (0 == _immediate_events.read_space()) {
438 assert (nframes > 0);
440 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 has %2 of immediate events to deliver\n",
441 name(), _immediate_events.read_space()));
443 /* write as many of the immediate events as we can, but give "true" as
444 * the last argument ("stop on overflow in destination") so that we'll
445 * ship the rest out next time.
447 * the Port::port_offset() + (nframes-1) argument puts all these events at the last
448 * possible position of the output buffer, so that we do not
449 * violate monotonicity when writing. Port::port_offset() will
450 * be non-zero if we're in a split process cycle.
452 _immediate_events.read (_immediate_event_buffer, 0, 1, Port::port_offset() + nframes - 1, true);
456 MidiTrack::write_out_of_band_data (BufferSet& bufs, samplecnt_t nframes) const
458 MidiBuffer& buf (bufs.get_midi (0));
459 buf.merge_from (_immediate_event_buffer, nframes);
463 MidiTrack::export_stuff (BufferSet& buffers,
466 boost::shared_ptr<Processor> endpoint,
467 bool include_endpoint,
471 if (buffers.count().n_midi() == 0) {
475 Glib::Threads::RWLock::ReaderLock rlock (_processor_lock);
477 boost::shared_ptr<MidiPlaylist> mpl = _disk_writer->midi_playlist();
482 buffers.get_midi(0).clear();
483 if (mpl->read(buffers.get_midi(0), start, nframes, 0) != nframes) {
487 //bounce_process (buffers, start, nframes, endpoint, include_endpoint, for_export, for_freeze);
492 boost::shared_ptr<Region>
493 MidiTrack::bounce (InterThreadInfo& itt)
495 return bounce_range (_session.current_start_sample(), _session.current_end_sample(), itt, main_outs(), false);
498 boost::shared_ptr<Region>
499 MidiTrack::bounce_range (samplepos_t start,
501 InterThreadInfo& itt,
502 boost::shared_ptr<Processor> endpoint,
503 bool include_endpoint)
505 vector<boost::shared_ptr<Source> > srcs;
506 return _session.write_one_track (*this, start, end, false, srcs, itt, endpoint, include_endpoint, false, false);
510 MidiTrack::freeze_me (InterThreadInfo& /*itt*/)
512 std::cerr << "MIDI freeze currently unsupported" << std::endl;
516 MidiTrack::unfreeze ()
518 _freeze_record.state = UnFrozen;
519 FreezeChange (); /* EMIT SIGNAL */
523 MidiTrack::set_note_mode (NoteMode m)
526 _disk_writer->set_note_mode(m);
530 MidiTrack::describe_parameter (Evoral::Parameter param)
532 const std::string str(instrument_info().get_controller_name(param));
533 return str.empty() ? Automatable::describe_parameter(param) : str;
537 MidiTrack::midi_panic()
539 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers panic data\n", name()));
540 for (uint8_t channel = 0; channel <= 0xF; channel++) {
541 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), ((uint8_t) MIDI_CTL_SUSTAIN), 0 };
542 write_immediate_event(3, ev);
543 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
544 write_immediate_event(3, ev);
545 ev[1] = MIDI_CTL_RESET_CONTROLLERS;
546 write_immediate_event(3, ev);
550 /** \return true on success, false on failure (no buffer space left)
553 MidiTrack::write_immediate_event(size_t size, const uint8_t* buf)
555 if (!Evoral::midi_event_is_valid(buf, size)) {
556 cerr << "WARNING: Ignoring illegal immediate MIDI event" << endl;
559 return (_immediate_events.write (0, Evoral::MIDI_EVENT, size, buf) == size);
563 MidiTrack::set_parameter_automation_state (Evoral::Parameter param, AutoState state)
565 switch (param.type()) {
566 case MidiCCAutomation:
567 case MidiPgmChangeAutomation:
568 case MidiPitchBenderAutomation:
569 case MidiChannelPressureAutomation:
570 case MidiNotePressureAutomation:
571 case MidiSystemExclusiveAutomation:
572 /* The track control for MIDI parameters is for immediate events to act
573 as a control surface, write/touch for them is not currently
577 Automatable::set_parameter_automation_state(param, state);
582 MidiTrack::MidiControl::restore_value ()
584 actually_set_value (get_value(), Controllable::NoGroup);
588 MidiTrack::MidiControl::actually_set_value (double val, PBD::Controllable::GroupControlDisposition group_override)
590 const Evoral::Parameter ¶meter = _list ? _list->parameter() : Control::parameter();
591 const Evoral::ParameterDescriptor &desc = EventTypeMap::instance().descriptor(parameter);
594 if (isinf_local(val)) {
595 cerr << "MIDIControl value is infinity" << endl;
596 } else if (isnan_local(val)) {
597 cerr << "MIDIControl value is NaN" << endl;
598 } else if (val < desc.lower) {
599 cerr << "MIDIControl value is < " << desc.lower << endl;
600 } else if (val > desc.upper) {
601 cerr << "MIDIControl value is > " << desc.upper << endl;
610 assert(val <= desc.upper);
611 if ( ! _list || ! automation_playback()) {
613 uint8_t ev[3] = { parameter.channel(), uint8_t (val), 0 };
614 switch(parameter.type()) {
615 case MidiCCAutomation:
616 ev[0] |= MIDI_CMD_CONTROL;
617 ev[1] = parameter.id();
621 case MidiPgmChangeAutomation:
623 ev[0] |= MIDI_CMD_PGM_CHANGE;
627 case MidiChannelPressureAutomation:
629 ev[0] |= MIDI_CMD_CHANNEL_PRESSURE;
633 case MidiNotePressureAutomation:
634 ev[0] |= MIDI_CMD_NOTE_PRESSURE;
635 ev[1] = parameter.id();
639 case MidiPitchBenderAutomation:
640 ev[0] |= MIDI_CMD_BENDER;
641 ev[1] = 0x7F & int(val);
642 ev[2] = 0x7F & (int(val) >> 7);
649 _route->write_immediate_event(size, ev);
652 AutomationControl::actually_set_value(val, group_override);
656 MidiTrack::set_step_editing (bool yn)
658 if (_session.record_status() != Session::Disabled) {
662 if (yn != _step_editing) {
664 StepEditStatusChange (yn);
668 boost::shared_ptr<SMFSource>
669 MidiTrack::write_source (uint32_t)
671 return _disk_writer->midi_write_source ();
675 MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask)
677 if (_playback_filter.set_channel_mode(mode, mask)) {
678 _session.set_dirty();
683 MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask)
685 if (_capture_filter.set_channel_mode(mode, mask)) {
686 _session.set_dirty();
691 MidiTrack::set_playback_channel_mask (uint16_t mask)
693 if (_playback_filter.set_channel_mask(mask)) {
694 _session.set_dirty();
699 MidiTrack::set_capture_channel_mask (uint16_t mask)
701 if (_capture_filter.set_channel_mask(mask)) {
702 _session.set_dirty();
706 boost::shared_ptr<MidiPlaylist>
707 MidiTrack::midi_playlist ()
709 return boost::dynamic_pointer_cast<MidiPlaylist> (_playlists[DataType::MIDI]);
713 MidiTrack::input_active () const
715 return _input_active;
719 MidiTrack::set_input_active (bool yn)
721 if (yn != _input_active) {
723 map_input_active (yn);
724 InputActiveChanged (); /* EMIT SIGNAL */
729 MidiTrack::map_input_active (bool yn)
735 PortSet& ports (_input->ports());
737 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
738 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
739 if (yn != mp->input_active()) {
740 mp->set_input_active (yn);
746 MidiTrack::track_input_active (IOChange change, void* /* src */)
748 if (change.type & IOChange::ConfigurationChanged) {
749 map_input_active (_input_active);
753 boost::shared_ptr<MidiBuffer>
754 MidiTrack::get_gui_feed_buffer () const
756 return _disk_writer->get_gui_feed_buffer ();
760 MidiTrack::act_on_mute ()
762 /* this is called right after our mute status has changed.
763 if we are now muted, send suitable output to shutdown
766 XXX we should should also stop all relevant note trackers.
769 /* If we haven't got a diskstream yet, there's nothing to worry about,
770 and we can't call get_channel_mask() anyway.
776 if (muted() || _mute_master->muted_by_others_soloing_at (MuteMaster::AllPoints)) {
777 /* only send messages for channels we are using */
779 uint16_t mask = _playback_filter.get_channel_mask();
781 for (uint8_t channel = 0; channel <= 0xF; channel++) {
783 if ((1<<channel) & mask) {
785 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers mute message to channel %2\n", name(), channel+1));
786 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), MIDI_CTL_SUSTAIN, 0 };
787 write_immediate_event (3, ev);
789 /* Note we do not send MIDI_CTL_ALL_NOTES_OFF here, since this may
790 silence notes that came from another non-muted track. */
794 /* Resolve active notes. */
795 _disk_reader->resolve_tracker(_immediate_events, Port::port_offset());
800 MidiTrack::monitoring_changed (bool self, Controllable::GroupControlDisposition gcd)
802 Track::monitoring_changed (self, gcd);
804 /* monitoring state changed, so flush out any on notes at the
808 PortSet& ports (_output->ports());
810 for (PortSet::iterator p = ports.begin(); p != ports.end(); ++p) {
811 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
813 mp->require_resolve ();
817 _disk_reader->reset_tracker ();
821 MidiTrack::monitoring_state () const
823 MonitorState ms = Track::monitoring_state();
824 if (ms == MonitoringSilence) {
825 return MonitoringInput;
831 MidiTrack::get_auto_monitoring_state () const
833 //if we are a midi track, we ignore auto_input, tape_mode, etc etc. "Auto" will monitor Disk+In
834 return MonitoringCue;
838 MidiTrack::filter_input (BufferSet& bufs)
840 _capture_filter.filter (bufs);