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_frames_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 , _step_edit_ring_buffer(64) // FIXME: size?
77 , _note_mode (Sustained)
78 , _step_editing (false)
79 , _input_active (true)
81 _session.SessionLoaded.connect_same_thread (*this, boost::bind (&MidiTrack::restore_controls, this));
84 MidiTrack::~MidiTrack ()
95 _input->changed.connect_same_thread (*this, boost::bind (&MidiTrack::track_input_active, this, _1, _2));
97 _disk_writer->set_note_mode (_note_mode);
98 _disk_reader->reset_tracker ();
104 MidiTrack::can_be_record_safe ()
110 return Track::can_be_record_safe ();
114 MidiTrack::can_be_record_enabled ()
120 return Track::can_be_record_enabled ();
124 MidiTrack::set_state (const XMLNode& node, int version)
126 /* This must happen before Track::set_state(), as there will be a buffer
127 fill during that call, and we must fill buffers using the correct
130 if (!node.get_property (X_("note-mode"), _note_mode)) {
131 _note_mode = Sustained;
134 if (Track::set_state (node, version)) {
138 // No destructive MIDI tracks (yet?)
142 if (node.get_property ("input-active", yn)) {
143 set_input_active (yn);
146 ChannelMode playback_channel_mode = AllChannels;
147 ChannelMode capture_channel_mode = AllChannels;
149 node.get_property ("playback-channel-mode", playback_channel_mode);
150 node.get_property ("capture-channel-mode", capture_channel_mode);
152 if (node.get_property ("channel-mode", playback_channel_mode)) {
153 /* 3.0 behaviour where capture and playback modes were not separated */
154 capture_channel_mode = playback_channel_mode;
157 XMLProperty const * prop;
159 unsigned int playback_channel_mask = 0xffff;
160 unsigned int capture_channel_mask = 0xffff;
162 if ((prop = node.property ("playback-channel-mask")) != 0) {
163 sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask);
165 if ((prop = node.property ("capture-channel-mask")) != 0) {
166 sscanf (prop->value().c_str(), "0x%x", &capture_channel_mask);
168 if ((prop = node.property ("channel-mask")) != 0) {
169 sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask);
170 capture_channel_mask = playback_channel_mask;
173 set_playback_channel_mode (playback_channel_mode, playback_channel_mask);
174 set_capture_channel_mode (capture_channel_mode, capture_channel_mask);
176 pending_state = const_cast<XMLNode*> (&node);
178 if (_session.state_of_the_state() & Session::Loading) {
179 _session.StateReady.connect_same_thread (
180 *this, boost::bind (&MidiTrack::set_state_part_two, this));
182 set_state_part_two ();
189 MidiTrack::state(bool full_state)
191 XMLNode& root (Track::state(full_state));
192 XMLNode* freeze_node;
195 if (_freeze_record.playlist) {
198 freeze_node = new XMLNode (X_("freeze-info"));
199 freeze_node->set_property ("playlist", _freeze_record.playlist->name());
200 freeze_node->set_property ("state", _freeze_record.state);
202 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
203 inode = new XMLNode (X_("processor"));
204 inode->set_property (X_("id"), id());
205 inode->add_child_copy ((*i)->state);
207 freeze_node->add_child_nocopy (*inode);
210 root.add_child_nocopy (*freeze_node);
213 root.set_property("playback-channel-mode", get_playback_channel_mode());
214 root.set_property("capture-channel-mode", get_capture_channel_mode());
215 snprintf (buf, sizeof(buf), "0x%x", get_playback_channel_mask());
216 root.set_property("playback-channel-mask", std::string(buf));
217 snprintf (buf, sizeof(buf), "0x%x", get_capture_channel_mask());
218 root.set_property("capture-channel-mask", std::string(buf));
220 root.set_property ("note-mode", _note_mode);
221 root.set_property ("step-editing", _step_editing);
222 root.set_property ("input-active", _input_active);
224 for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
225 if (boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second)) {
226 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c->second);
228 root.add_child_nocopy (ac->get_state ());
236 MidiTrack::set_state_part_two ()
240 /* This is called after all session state has been restored but before
241 have been made ports and connections are established.
244 if (pending_state == 0) {
248 if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
250 _freeze_record.state = Frozen;
252 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
255 _freeze_record.processor_info.clear ();
258 if (fnode->get_property (X_("playlist"), str)) {
259 boost::shared_ptr<Playlist> pl = _session.playlists->by_name (str);
261 _freeze_record.playlist = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
263 _freeze_record.playlist.reset();
264 _freeze_record.state = NoFreeze;
269 fnode->get_property (X_("state"), _freeze_record.state);
271 XMLNodeConstIterator citer;
272 XMLNodeList clist = fnode->children();
274 for (citer = clist.begin(); citer != clist.end(); ++citer) {
275 if ((*citer)->name() != X_("processor")) {
279 if (!(*citer)->get_property (X_("id"), str)) {
283 FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
284 boost::shared_ptr<Processor>());
286 _freeze_record.processor_info.push_back (frii);
294 MidiTrack::restore_controls ()
296 // TODO order events (CC before PGM to set banks)
297 for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
298 boost::shared_ptr<MidiTrack::MidiControl> mctrl = boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second);
300 mctrl->restore_value();
306 MidiTrack::update_controls(const BufferSet& bufs)
308 const MidiBuffer& buf = bufs.get_midi(0);
309 for (MidiBuffer::const_iterator e = buf.begin(); e != buf.end(); ++e) {
310 const Evoral::Event<framepos_t>& ev = *e;
311 const Evoral::Parameter param = midi_parameter(ev.buffer(), ev.size());
312 const boost::shared_ptr<AutomationControl> control = automation_control (param);
314 control->set_double(ev.value(), _session.transport_frame(), false);
315 control->Changed (false, Controllable::NoGroup);
320 /** @param need_butler to be set to true if this track now needs the butler, otherwise it can be left alone
324 MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
326 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
332 if (n_outputs().n_total() == 0 && _processors.empty()) {
338 if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled())) {
345 _amp->apply_gain_automation (false);
347 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
349 fill_buffers_with_input (bufs, _input, nframes);
351 /* filter captured data before meter sees it */
352 _capture_filter.filter (bufs);
354 if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled())) {
355 _meter->run (bufs, start_frame, end_frame, 1.0 /*speed()*/, nframes, true);
358 /* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
360 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
362 /* final argument: don't waste time with automation if we're not recording or rolling */
364 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, (!_disk_writer->record_enabled() && !_session.transport_stopped()));
366 if (_disk_reader->need_butler() || _disk_writer->need_butler()) {
370 flush_processor_buffers_locked (nframes);
376 MidiTrack::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool state_changing)
378 int ret = Track::no_roll (nframes, start_frame, end_frame, state_changing);
380 if (ret == 0 && _step_editing) {
381 push_midi_input_to_step_edit_ringbuffer (nframes);
388 MidiTrack::realtime_locate ()
390 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
396 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
397 (*i)->realtime_locate ();
400 _disk_reader->reset_tracker ();
404 MidiTrack::non_realtime_locate (framepos_t pos)
406 Track::non_realtime_locate(pos);
408 boost::shared_ptr<MidiPlaylist> playlist = _disk_writer->midi_playlist();
413 /* Get the top unmuted region at this position. */
414 boost::shared_ptr<MidiRegion> region = boost::dynamic_pointer_cast<MidiRegion>(
415 playlist->top_unmuted_region_at(pos));
420 /* the source may be missing, but the control still referenced in the GUI */
421 if (!region->midi_source() || !region->model()) {
425 Glib::Threads::Mutex::Lock lm (_control_lock, Glib::Threads::TRY_LOCK);
430 /* Update track controllers based on its "automation". */
431 const framepos_t origin = region->position() - region->start();
432 BeatsFramesConverter bfc(_session.tempo_map(), origin);
433 for (Controls::const_iterator c = _controls.begin(); c != _controls.end(); ++c) {
434 boost::shared_ptr<MidiTrack::MidiControl> tcontrol;
435 boost::shared_ptr<Evoral::Control> rcontrol;
436 if ((tcontrol = boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second)) &&
437 (rcontrol = region->control(tcontrol->parameter()))) {
438 const Evoral::Beats pos_beats = bfc.from(pos - origin);
439 if (rcontrol->list()->size() > 0) {
440 tcontrol->set_value(rcontrol->list()->eval(pos_beats.to_double()), Controllable::NoGroup);
447 MidiTrack::push_midi_input_to_step_edit_ringbuffer (framecnt_t nframes)
449 PortSet& ports (_input->ports());
451 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
453 Buffer& b (p->get_buffer (nframes));
454 const MidiBuffer* const mb = dynamic_cast<MidiBuffer*>(&b);
457 for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) {
459 const Evoral::Event<framepos_t> ev(*e, false);
461 /* note on, since for step edit, note length is determined
465 if (ev.is_note_on()) {
466 /* we don't care about the time for this purpose */
467 _step_edit_ring_buffer.write (0, ev.event_type(), ev.size(), ev.buffer());
474 MidiTrack::write_out_of_band_data (BufferSet& bufs, framepos_t /*start*/, framepos_t /*end*/, framecnt_t nframes)
476 MidiBuffer& buf (bufs.get_midi (0));
478 update_controls (bufs);
480 // Append immediate events
482 if (_immediate_events.read_space()) {
484 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 has %2 of immediate events to deliver\n",
485 name(), _immediate_events.read_space()));
487 /* write as many of the immediate events as we can, but give "true" as
488 * the last argument ("stop on overflow in destination") so that we'll
489 * ship the rest out next time.
491 * the Port::port_offset() + (nframes-1) argument puts all these events at the last
492 * possible position of the output buffer, so that we do not
493 * violate monotonicity when writing. Port::port_offset() will
494 * be non-zero if we're in a split process cycle.
496 _immediate_events.read (buf, 0, 1, Port::port_offset() + nframes - 1, true);
501 MidiTrack::export_stuff (BufferSet& buffers,
504 boost::shared_ptr<Processor> endpoint,
505 bool include_endpoint,
509 if (buffers.count().n_midi() == 0) {
513 Glib::Threads::RWLock::ReaderLock rlock (_processor_lock);
515 boost::shared_ptr<MidiPlaylist> mpl = _disk_writer->midi_playlist();
520 buffers.get_midi(0).clear();
521 if (mpl->read(buffers.get_midi(0), start, nframes, 0) != nframes) {
525 //bounce_process (buffers, start, nframes, endpoint, include_endpoint, for_export, for_freeze);
530 boost::shared_ptr<Region>
531 MidiTrack::bounce (InterThreadInfo& itt)
533 return bounce_range (_session.current_start_frame(), _session.current_end_frame(), itt, main_outs(), false);
536 boost::shared_ptr<Region>
537 MidiTrack::bounce_range (framepos_t start,
539 InterThreadInfo& itt,
540 boost::shared_ptr<Processor> endpoint,
541 bool include_endpoint)
543 vector<boost::shared_ptr<Source> > srcs;
544 return _session.write_one_track (*this, start, end, false, srcs, itt, endpoint, include_endpoint, false, false);
548 MidiTrack::freeze_me (InterThreadInfo& /*itt*/)
550 std::cerr << "MIDI freeze currently unsupported" << std::endl;
554 MidiTrack::unfreeze ()
556 _freeze_record.state = UnFrozen;
557 FreezeChange (); /* EMIT SIGNAL */
561 MidiTrack::set_note_mode (NoteMode m)
564 _disk_writer->set_note_mode(m);
568 MidiTrack::describe_parameter (Evoral::Parameter param)
570 const std::string str(instrument_info().get_controller_name(param));
571 return str.empty() ? Automatable::describe_parameter(param) : str;
575 MidiTrack::midi_panic()
577 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers panic data\n", name()));
578 for (uint8_t channel = 0; channel <= 0xF; channel++) {
579 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), ((uint8_t) MIDI_CTL_SUSTAIN), 0 };
580 write_immediate_event(3, ev);
581 ev[1] = MIDI_CTL_ALL_NOTES_OFF;
582 write_immediate_event(3, ev);
583 ev[1] = MIDI_CTL_RESET_CONTROLLERS;
584 write_immediate_event(3, ev);
588 /** \return true on success, false on failure (no buffer space left)
591 MidiTrack::write_immediate_event(size_t size, const uint8_t* buf)
593 if (!Evoral::midi_event_is_valid(buf, size)) {
594 cerr << "WARNING: Ignoring illegal immediate MIDI event" << endl;
597 return (_immediate_events.write (0, Evoral::MIDI_EVENT, size, buf) == size);
601 MidiTrack::set_parameter_automation_state (Evoral::Parameter param, AutoState state)
603 switch (param.type()) {
604 case MidiCCAutomation:
605 case MidiPgmChangeAutomation:
606 case MidiPitchBenderAutomation:
607 case MidiChannelPressureAutomation:
608 case MidiNotePressureAutomation:
609 case MidiSystemExclusiveAutomation:
610 /* The track control for MIDI parameters is for immediate events to act
611 as a control surface, write/touch for them is not currently
615 Automatable::set_parameter_automation_state(param, state);
620 MidiTrack::MidiControl::restore_value ()
622 actually_set_value (get_value(), Controllable::NoGroup);
626 MidiTrack::MidiControl::actually_set_value (double val, PBD::Controllable::GroupControlDisposition group_override)
628 const Evoral::Parameter ¶meter = _list ? _list->parameter() : Control::parameter();
629 const Evoral::ParameterDescriptor &desc = EventTypeMap::instance().descriptor(parameter);
632 if (isinf_local(val)) {
633 cerr << "MIDIControl value is infinity" << endl;
634 } else if (isnan_local(val)) {
635 cerr << "MIDIControl value is NaN" << endl;
636 } else if (val < desc.lower) {
637 cerr << "MIDIControl value is < " << desc.lower << endl;
638 } else if (val > desc.upper) {
639 cerr << "MIDIControl value is > " << desc.upper << endl;
648 assert(val <= desc.upper);
649 if ( ! _list || ! automation_playback()) {
651 uint8_t ev[3] = { parameter.channel(), uint8_t (val), 0 };
652 switch(parameter.type()) {
653 case MidiCCAutomation:
654 ev[0] += MIDI_CMD_CONTROL;
655 ev[1] = parameter.id();
659 case MidiPgmChangeAutomation:
661 ev[0] += MIDI_CMD_PGM_CHANGE;
665 case MidiChannelPressureAutomation:
667 ev[0] += MIDI_CMD_CHANNEL_PRESSURE;
671 case MidiNotePressureAutomation:
672 ev[0] += MIDI_CMD_NOTE_PRESSURE;
673 ev[1] = parameter.id();
677 case MidiPitchBenderAutomation:
678 ev[0] += MIDI_CMD_BENDER;
679 ev[1] = 0x7F & int(val);
680 ev[2] = 0x7F & (int(val) >> 7);
686 _route->write_immediate_event(size, ev);
689 AutomationControl::actually_set_value(val, group_override);
693 MidiTrack::set_step_editing (bool yn)
695 if (_session.record_status() != Session::Disabled) {
699 if (yn != _step_editing) {
701 StepEditStatusChange (yn);
705 boost::shared_ptr<SMFSource>
706 MidiTrack::write_source (uint32_t)
708 return _disk_writer->midi_write_source ();
712 MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask)
714 if (_playback_filter.set_channel_mode(mode, mask)) {
715 _session.set_dirty();
720 MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask)
722 if (_capture_filter.set_channel_mode(mode, mask)) {
723 _session.set_dirty();
728 MidiTrack::set_playback_channel_mask (uint16_t mask)
730 if (_playback_filter.set_channel_mask(mask)) {
731 _session.set_dirty();
736 MidiTrack::set_capture_channel_mask (uint16_t mask)
738 if (_capture_filter.set_channel_mask(mask)) {
739 _session.set_dirty();
743 boost::shared_ptr<MidiPlaylist>
744 MidiTrack::midi_playlist ()
746 return boost::dynamic_pointer_cast<MidiPlaylist> (_playlists[DataType::MIDI]);
750 MidiTrack::input_active () const
752 return _input_active;
756 MidiTrack::set_input_active (bool yn)
758 if (yn != _input_active) {
760 map_input_active (yn);
761 InputActiveChanged (); /* EMIT SIGNAL */
766 MidiTrack::map_input_active (bool yn)
772 PortSet& ports (_input->ports());
774 for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) {
775 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
776 if (yn != mp->input_active()) {
777 mp->set_input_active (yn);
783 MidiTrack::track_input_active (IOChange change, void* /* src */)
785 if (change.type & IOChange::ConfigurationChanged) {
786 map_input_active (_input_active);
790 boost::shared_ptr<MidiBuffer>
791 MidiTrack::get_gui_feed_buffer () const
793 return _disk_reader->get_gui_feed_buffer ();
797 MidiTrack::act_on_mute ()
799 /* this is called right after our mute status has changed.
800 if we are now muted, send suitable output to shutdown
803 XXX we should should also stop all relevant note trackers.
806 /* If we haven't got a diskstream yet, there's nothing to worry about,
807 and we can't call get_channel_mask() anyway.
813 if (muted() || _mute_master->muted_by_others_soloing_at (MuteMaster::AllPoints)) {
814 /* only send messages for channels we are using */
816 uint16_t mask = _playback_filter.get_channel_mask();
818 for (uint8_t channel = 0; channel <= 0xF; channel++) {
820 if ((1<<channel) & mask) {
822 DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers mute message to channel %2\n", name(), channel+1));
823 uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), MIDI_CTL_SUSTAIN, 0 };
824 write_immediate_event (3, ev);
826 /* Note we do not send MIDI_CTL_ALL_NOTES_OFF here, since this may
827 silence notes that came from another non-muted track. */
831 /* Resolve active notes. */
832 _disk_reader->resolve_tracker(_immediate_events, Port::port_offset());
837 MidiTrack::monitoring_changed (bool self, Controllable::GroupControlDisposition gcd)
839 Track::monitoring_changed (self, gcd);
841 /* monitoring state changed, so flush out any on notes at the
845 PortSet& ports (_output->ports());
847 for (PortSet::iterator p = ports.begin(); p != ports.end(); ++p) {
848 boost::shared_ptr<MidiPort> mp = boost::dynamic_pointer_cast<MidiPort> (*p);
850 mp->require_resolve ();
854 _disk_reader->reset_tracker ();
858 MidiTrack::monitoring_state () const
860 MonitorState ms = Track::monitoring_state();
861 if (ms == MonitoringSilence) {
862 return MonitoringInput;