X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmidi_track.cc;h=f88c331c2ca8a0e7b171b7f1a4aea9a5f9ac7ba9;hb=d90e2b42211ead2a38afd5590e2937992312795e;hp=3be722d62045073f8fcf5d4df21a105fcdc6c284;hpb=be75d43bd0e6a5ced684e95bf7e753f42d88bd21;p=ardour.git diff --git a/libs/ardour/midi_track.cc b/libs/ardour/midi_track.cc index 3be722d620..f88c331c2c 100644 --- a/libs/ardour/midi_track.cc +++ b/libs/ardour/midi_track.cc @@ -1,6 +1,6 @@ /* - Copyright (C) 2006 Paul Davis - By Dave Robillard, 2006 + Copyright (C) 2006 Paul Davis + Author: David Robillard This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -16,31 +16,36 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#include -#include -#include -#include - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include // for ffs(3) + +#include "pbd/enumwriter.h" +#include "pbd/convert.h" +#include "evoral/midi_util.h" + +#include "ardour/buffer_set.h" +#include "ardour/debug.h" +#include "ardour/delivery.h" +#include "ardour/meter.h" +#include "ardour/midi_diskstream.h" +#include "ardour/midi_playlist.h" +#include "ardour/midi_port.h" +#include "ardour/midi_track.h" +#include "ardour/port.h" +#include "ardour/processor.h" +#include "ardour/session.h" +#include "ardour/session_playlists.h" +#include "ardour/utils.h" #include "i18n.h" +namespace ARDOUR { +class InterThreadInfo; +class MidiSource; +class Region; +class SMFSource; +} + using namespace std; using namespace ARDOUR; using namespace PBD; @@ -48,98 +53,81 @@ using namespace PBD; MidiTrack::MidiTrack (Session& sess, string name, Route::Flag flag, TrackMode mode) : Track (sess, name, flag, mode, DataType::MIDI) , _immediate_events(1024) // FIXME: size? + , _step_edit_ring_buffer(64) // FIXME: size? , _note_mode(Sustained) + , _step_editing (false) + , _input_active (true) + , _playback_channel_mask(0x0000ffff) + , _capture_channel_mask(0x0000ffff) +{ +} + +MidiTrack::~MidiTrack () +{ +} + +int +MidiTrack::init () +{ + if (Track::init ()) { + return -1; + } + + _input->changed.connect_same_thread (*this, boost::bind (&MidiTrack::track_input_active, this, _1, _2)); + + return 0; +} + +boost::shared_ptr +MidiTrack::create_diskstream () { MidiDiskstream::Flag dflags = MidiDiskstream::Flag (0); - if (_flags & Hidden) { + if (_flags & Auditioner) { dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Hidden); } else { dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Recordable); } - assert(mode != Destructive); + assert(_mode != Destructive); - boost::shared_ptr ds (new MidiDiskstream (_session, name, dflags)); - _session.add_diskstream (ds); + return boost::shared_ptr (new MidiDiskstream (_session, name(), dflags)); +} - set_diskstream (boost::dynamic_pointer_cast (ds)); - - _declickable = true; - _freeze_record.state = NoFreeze; - _saved_meter_point = _meter_point; - _mode = mode; - set_input_minimum(ChanCount(DataType::MIDI, 1)); - set_input_maximum(ChanCount(DataType::MIDI, 1)); - set_output_minimum(ChanCount(DataType::MIDI, 1)); - set_output_maximum(ChanCount(DataType::MIDI, 1)); +void +MidiTrack::set_record_enabled (bool yn, void *src) +{ + if (_step_editing) { + return; + } - PortCountChanged(ChanCount(DataType::MIDI, 2)); /* EMIT SIGNAL */ + Track::set_record_enabled (yn, src); } -MidiTrack::MidiTrack (Session& sess, const XMLNode& node) - : Track (sess, node, DataType::MIDI ) - , _immediate_events(1024) // FIXME: size? - , _note_mode(Sustained) +void +MidiTrack::set_diskstream (boost::shared_ptr ds) { - _set_state(node, false); - - set_input_minimum(ChanCount(DataType::MIDI, 1)); - set_input_maximum(ChanCount(DataType::MIDI, 1)); - set_output_minimum(ChanCount(DataType::MIDI, 1)); - set_output_maximum(ChanCount(DataType::MIDI, 1)); + /* We have to do this here, as Track::set_diskstream will cause a buffer refill, + and the diskstream must be set up to fill its buffers using the correct _note_mode. + */ + boost::shared_ptr mds = boost::dynamic_pointer_cast (ds); + mds->set_note_mode (_note_mode); - PortCountChanged(ChanCount(DataType::MIDI, 2)); /* EMIT SIGNAL */ -} - -MidiTrack::~MidiTrack () -{ -} + Track::set_diskstream (ds); + mds->reset_tracker (); -int -MidiTrack::set_diskstream (boost::shared_ptr ds) -{ - _diskstream = ds; - _diskstream->set_io (*this); + _diskstream->set_track (this); _diskstream->set_destructive (_mode == Destructive); - _diskstream->set_record_enabled (false); - //_diskstream->monitor_input (false); - ic_connection.disconnect(); - ic_connection = input_changed.connect (mem_fun (*_diskstream, &MidiDiskstream::handle_input_change)); + _diskstream_data_recorded_connection.disconnect (); + mds->DataRecorded.connect_same_thread ( + _diskstream_data_recorded_connection, + boost::bind (&MidiTrack::diskstream_data_recorded, this, _1)); DiskstreamChanged (); /* EMIT SIGNAL */ - - return 0; -} - -int -MidiTrack::use_diskstream (string name) -{ - boost::shared_ptr dstream; - - if ((dstream = boost::dynamic_pointer_cast(_session.diskstream_by_name (name))) == 0) { - error << string_compose(_("MidiTrack: midi diskstream \"%1\" not known by session"), name) << endmsg; - return -1; - } - - return set_diskstream (dstream); -} - -int -MidiTrack::use_diskstream (const PBD::ID& id) -{ - boost::shared_ptr dstream; - - if ((dstream = boost::dynamic_pointer_cast (_session.diskstream_by_id (id))) == 0) { - error << string_compose(_("MidiTrack: midi diskstream \"%1\" not known by session"), id) << endmsg; - return -1; - } - - return set_diskstream (dstream); } boost::shared_ptr @@ -149,79 +137,79 @@ MidiTrack::midi_diskstream() const } int -MidiTrack::set_state (const XMLNode& node) -{ - return _set_state (node, true); -} - -int -MidiTrack::_set_state (const XMLNode& node, bool call_base) +MidiTrack::set_state (const XMLNode& node, int version) { const XMLProperty *prop; - XMLNodeConstIterator iter; - if (Route::_set_state (node, call_base)) { - return -1; - } - - // No destructive MIDI tracks (yet?) - _mode = Normal; - + /* This must happen before Track::set_state(), as there will be a buffer + fill during that call, and we must fill buffers using the correct + _note_mode. + */ if ((prop = node.property (X_("note-mode"))) != 0) { _note_mode = NoteMode (string_2_enum (prop->value(), _note_mode)); } else { _note_mode = Sustained; } - if ((prop = node.property ("diskstream-id")) == 0) { - - /* some old sessions use the diskstream name rather than the ID */ - - if ((prop = node.property ("diskstream")) == 0) { - fatal << _("programming error: MidiTrack given state without diskstream!") << endmsg; - /*NOTREACHED*/ - return -1; - } + if (Track::set_state (node, version)) { + return -1; + } - if (use_diskstream (prop->value())) { - return -1; - } + // No destructive MIDI tracks (yet?) + _mode = Normal; - } else { - - PBD::ID id (prop->value()); - - if (use_diskstream (id)) { - return -1; - } + if ((prop = node.property ("input-active")) != 0) { + set_input_active (string_is_affirmative (prop->value())); } + ChannelMode playback_channel_mode = AllChannels; + ChannelMode capture_channel_mode = AllChannels; - XMLNodeList nlist; - XMLNodeConstIterator niter; - XMLNode *child; + if ((prop = node.property ("playback-channel-mode")) != 0) { + playback_channel_mode = ChannelMode (string_2_enum(prop->value(), playback_channel_mode)); + } + if ((prop = node.property ("capture-channel-mode")) != 0) { + capture_channel_mode = ChannelMode (string_2_enum(prop->value(), capture_channel_mode)); + } + if ((prop = node.property ("channel-mode")) != 0) { + /* 3.0 behaviour where capture and playback modes were not separated */ + playback_channel_mode = ChannelMode (string_2_enum(prop->value(), playback_channel_mode)); + capture_channel_mode = playback_channel_mode; + } - nlist = node.children(); - for (niter = nlist.begin(); niter != nlist.end(); ++niter){ - child = *niter; + unsigned int playback_channel_mask = 0xffff; + unsigned int capture_channel_mask = 0xffff; - if (child->name() == X_("recenable")) { - _rec_enable_control->set_state (*child); - _session.add_controllable (_rec_enable_control); - } + if ((prop = node.property ("playback-channel-mask")) != 0) { + sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask); + } + if ((prop = node.property ("capture-channel-mask")) != 0) { + sscanf (prop->value().c_str(), "0x%x", &capture_channel_mask); + } + if ((prop = node.property ("channel-mask")) != 0) { + sscanf (prop->value().c_str(), "0x%x", &playback_channel_mask); + capture_channel_mask = playback_channel_mask; } + set_playback_channel_mode (playback_channel_mode, playback_channel_mask); + set_capture_channel_mode (capture_channel_mode, capture_channel_mask); + pending_state = const_cast (&node); - _session.StateReady.connect (mem_fun (*this, &MidiTrack::set_state_part_two)); + if (_session.state_of_the_state() & Session::Loading) { + _session.StateReady.connect_same_thread ( + *this, boost::bind (&MidiTrack::set_state_part_two, this)); + } else { + set_state_part_two (); + } return 0; } -XMLNode& +XMLNode& MidiTrack::state(bool full_state) { - XMLNode& root (Route::state(full_state)); + XMLNode& root (Track::state(full_state)); XMLNode* freeze_node; char buf[64]; @@ -237,32 +225,23 @@ MidiTrack::state(bool full_state) (*i)->id.print (buf, sizeof(buf)); inode->add_property (X_("id"), buf); inode->add_child_copy ((*i)->state); - + freeze_node->add_child_nocopy (*inode); } root.add_child_nocopy (*freeze_node); } - /* Alignment: act as a proxy for the diskstream */ - - XMLNode* align_node = new XMLNode (X_("alignment")); - AlignStyle as = _diskstream->alignment_style (); - align_node->add_property (X_("style"), enum_2_string (as)); - root.add_child_nocopy (*align_node); + root.add_property("playback_channel-mode", enum_2_string(get_playback_channel_mode())); + root.add_property("capture_channel-mode", enum_2_string(get_capture_channel_mode())); + snprintf (buf, sizeof(buf), "0x%x", get_playback_channel_mask()); + root.add_property("playback-channel-mask", buf); + snprintf (buf, sizeof(buf), "0x%x", get_capture_channel_mask()); + root.add_property("capture-channel-mask", buf); - root.add_property (X_("note-mode"), enum_2_string (_note_mode)); - - /* we don't return diskstream state because we don't - own the diskstream exclusively. control of the diskstream - state is ceded to the Session, even if we create the - diskstream. - */ - - _diskstream->id().print (buf, sizeof(buf)); - root.add_property ("diskstream-id", buf); - - root.add_child_nocopy (_rec_enable_control->get_state()); + root.add_property ("note-mode", enum_2_string (_note_mode)); + root.add_property ("step-editing", (_step_editing ? "yes" : "no")); + root.add_property ("input-active", (_input_active ? "yes" : "no")); return root; } @@ -284,17 +263,15 @@ MidiTrack::set_state_part_two () if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) { - - _freeze_record.have_mementos = false; _freeze_record.state = Frozen; - + for (vector::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) { delete *i; } _freeze_record.processor_info.clear (); - + if ((prop = fnode->property (X_("playlist"))) != 0) { - boost::shared_ptr pl = _session.playlist_by_name (prop->value()); + boost::shared_ptr pl = _session.playlists->by_name (prop->value()); if (pl) { _freeze_record.playlist = boost::dynamic_pointer_cast (pl); } else { @@ -303,23 +280,23 @@ MidiTrack::set_state_part_two () return; } } - + if ((prop = fnode->property (X_("state"))) != 0) { _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state)); } - + XMLNodeConstIterator citer; XMLNodeList clist = fnode->children(); - + for (citer = clist.begin(); citer != clist.end(); ++citer) { if ((*citer)->name() != X_("processor")) { continue; } - + if ((prop = (*citer)->property (X_("id"))) == 0) { continue; } - + FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()), boost::shared_ptr()); frii->id = prop->value (); @@ -327,370 +304,281 @@ MidiTrack::set_state_part_two () } } - /* Alignment: act as a proxy for the diskstream */ - - if ((fnode = find_named_node (*pending_state, X_("alignment"))) != 0) { - - if ((prop = fnode->property (X_("style"))) != 0) { - - /* fix for older sessions from before EnumWriter */ - - string pstr; - - if (prop->value() == "capture") { - pstr = "CaptureTime"; - } else if (prop->value() == "existing") { - pstr = "ExistingMaterial"; - } else { - pstr = prop->value(); - } - - AlignStyle as = AlignStyle (string_2_enum (pstr, as)); - _diskstream->set_persistent_align_style (as); - } - } - return; -} - -int -MidiTrack::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, - bool session_state_changing, bool can_record, bool rec_monitors_input) -{ - if (n_outputs().n_midi() == 0) { - return 0; - } - - if (!_active) { - silence (nframes, offset); - } - - if (session_state_changing) { - - /* XXX is this safe to do against transport state changes? */ - - passthru_silence (start_frame, end_frame, nframes, offset, 0, false); - return 0; - } - - midi_diskstream()->check_record_status (start_frame, nframes, can_record); - - bool send_silence; - - if (_have_internal_generator) { - /* since the instrument has no input streams, - there is no reason to send any signal - into the route. - */ - send_silence = true; - } else { - - if (Config->get_auto_input()) { - if (Config->get_monitoring_model() == SoftwareMonitoring) { - send_silence = false; - } else { - send_silence = true; - } - } else { - if (_diskstream->record_enabled()) { - if (Config->get_monitoring_model() == SoftwareMonitoring) { - send_silence = false; - } else { - send_silence = true; - } - } else { - send_silence = true; - } - } - } - - apply_gain_automation = false; - - if (send_silence) { - - /* if we're sending silence, but we want the meters to show levels for the signal, - meter right here. - */ - - if (_have_internal_generator) { - passthru_silence (start_frame, end_frame, nframes, offset, 0, true); - } else { - if (_meter_point == MeterInput) { - just_meter_input (start_frame, end_frame, nframes, offset); - } - passthru_silence (start_frame, end_frame, nframes, offset, 0, false); - } - - } else { - - /* we're sending signal, but we may still want to meter the input. - */ - - passthru (start_frame, end_frame, nframes, offset, 0, (_meter_point == MeterInput)); + if (midi_diskstream ()) { + midi_diskstream()->set_block_size (_session.get_block_size ()); } - return 0; + return; } +/** @param need_butler to be set to true if this track now needs the butler, otherwise it can be left alone + * or set to false. + */ int -MidiTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick, - bool can_record, bool rec_monitors_input) +MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler) { - int dret; - boost::shared_ptr diskstream = midi_diskstream(); - - // I guess this is the right place to call cycle_start for our ports. - // but it actually sucks, to directly mess with the IO.... oh well. - - prepare_inputs( nframes, offset ); - - { - Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK); - if (lm.locked()) { - // automation snapshot can also be called from the non-rt context - // and it uses the redirect list, so we take the lock out here - automation_snapshot (start_frame); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + if (!lm.locked()) { + boost::shared_ptr diskstream = midi_diskstream(); + framecnt_t playback_distance = diskstream->calculate_playback_distance(nframes); + if (can_internal_playback_seek(llabs(playback_distance))) { + /* TODO should declick, and/or note-off */ + internal_playback_seek(playback_distance); } + return 0; } + boost::shared_ptr diskstream = midi_diskstream(); + if (n_outputs().n_total() == 0 && _processors.empty()) { return 0; } if (!_active) { - silence (nframes, offset); + silence (nframes); + if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) { + _meter->reset(); + } return 0; } - nframes_t transport_frame = _session.transport_frame(); + framepos_t transport_frame = _session.transport_frame(); - - if ((nframes = check_initial_delay (nframes, offset, transport_frame)) == 0) { + int dret; + framecnt_t playback_distance; + + if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) { /* need to do this so that the diskstream sets its playback distance to zero, thus causing diskstream::commit to do nothing. */ - return diskstream->process (transport_frame, 0, 0, can_record, rec_monitors_input); - } + BufferSet bufs; /* empty set - is OK, since nothing will happen */ - _silent = false; + dret = diskstream->process (bufs, transport_frame, 0, playback_distance, false); + need_butler = diskstream->commit (playback_distance); + return dret; + } - if ((dret = diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) { + BufferSet& bufs = _session.get_route_buffers (n_process_buffers()); - silence (nframes, offset); + fill_buffers_with_input (bufs, _input, nframes); - return dret; + if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) { + _meter->run (bufs, start_frame, end_frame, nframes, true); } - /* special condition applies */ + /* filter captured data before the diskstream sees it */ - if (_meter_point == MeterInput) { - just_meter_input (start_frame, end_frame, nframes, offset); - } + filter_channels (bufs, get_capture_channel_mode(), get_capture_channel_mask()); - if (diskstream->record_enabled() && !can_record && !Config->get_auto_input()) { + _silent = false; - /* not actually recording, but we want to hear the input material anyway, - at least potentially (depending on monitoring options) - */ + if ((dret = diskstream->process (bufs, transport_frame, nframes, playback_distance, (monitoring_state() == MonitoringDisk))) != 0) { + need_butler = diskstream->commit (playback_distance); + silence (nframes); + return dret; + } - passthru (start_frame, end_frame, nframes, offset, 0, true); + /* filter playback data before we do anything else */ + + filter_channels (bufs, get_playback_channel_mode(), get_playback_channel_mask ()); - } else { - /* - XXX is it true that the earlier test on n_outputs() - means that we can avoid checking it again here? i think - so, because changing the i/o configuration of an IO - requires holding the AudioEngine lock, which we hold - while in the process() tree. - */ + if (monitoring_state() == MonitoringInput) { + /* not actually recording, but we want to hear the input material anyway, + at least potentially (depending on monitoring options) + */ - /* copy the diskstream data to all output buffers */ + /* because the playback buffer is event based and not a + * continuous stream, we need to make sure that we empty + * it of events every cycle to avoid it filling up with events + * read from disk, while we are actually monitoring input + */ - //const size_t limit = n_process_buffers().n_audio(); - BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers()); + diskstream->flush_playback (start_frame, end_frame); - diskstream->get_playback(bufs.get_midi(0), start_frame, end_frame, offset); + } - process_output_buffers (bufs, start_frame, end_frame, nframes, offset, - (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput)); - } + /* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */ + + write_out_of_band_data (bufs, start_frame, end_frame, nframes); + + /* final argument: don't waste time with automation if we're not recording or rolling */ + + process_output_buffers (bufs, start_frame, end_frame, nframes, + declick, (!diskstream->record_enabled() && !_session.transport_stopped())); - flush_outputs( nframes, offset ); + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + boost::shared_ptr d = boost::dynamic_pointer_cast (*i); + if (d) { + d->flush_buffers (nframes); + } + } + need_butler = diskstream->commit (playback_distance); + return 0; } int -MidiTrack::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, - bool can_record, bool rec_monitors_input) +MidiTrack::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool state_changing) { - if (n_outputs().n_midi() == 0 && _processors.empty()) { - return 0; - } + int ret = Track::no_roll (nframes, start_frame, end_frame, state_changing); - if (!_active) { - silence (nframes, offset); - return 0; + if (ret == 0 && _step_editing) { + push_midi_input_to_step_edit_ringbuffer (nframes); } - _silent = true; - apply_gain_automation = false; - - silence (nframes, offset); - - return midi_diskstream()->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input); + return ret; } void -MidiTrack::process_output_buffers (BufferSet& bufs, - nframes_t start_frame, nframes_t end_frame, - nframes_t nframes, nframes_t offset, bool with_processors, int declick, - bool meter) -{ - /* There's no such thing as a MIDI bus for the time being. - * We'll do all the MIDI route work here for now, but the long-term goal is to have - * Route::process_output_buffers handle everything */ - - if (meter && (_meter_point == MeterInput || _meter_point == MeterPreFader)) { - _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset); +MidiTrack::realtime_locate () +{ + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + + if (!lm.locked ()) { + return; } - // Run all processors - if (with_processors) { - Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK); - if (rm.locked()) { - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset); - } - } + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + (*i)->realtime_locate (); } - - if (meter && (_meter_point == MeterPostFader)) { - _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset); + + midi_diskstream()->reset_tracker (); +} + +void +MidiTrack::realtime_handle_transport_stopped () +{ + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + + if (!lm.locked ()) { + return; } - - // Main output stage - if (muted()) { - IO::silence(nframes, offset); - } else { - // Write 'automation' controllers (e.g. CC events from a UI slider) - write_controller_messages(bufs.get_midi(0), start_frame, end_frame, nframes, offset); - - deliver_output(bufs, start_frame, end_frame, nframes, offset); + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + (*i)->realtime_handle_transport_stopped (); } } void -MidiTrack::write_controller_messages(MidiBuffer& output_buf, nframes_t start_frame, nframes_t end_frame, - nframes_t nframes, nframes_t offset) +MidiTrack::push_midi_input_to_step_edit_ringbuffer (framecnt_t nframes) { -#if 0 - BufferSet& mix_buffers = _session.get_mix_buffers(ChanCount(DataType::MIDI, 2)); + PortSet& ports (_input->ports()); - /* FIXME: this could be more realtimey */ + for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) { - // Write immediate events (UI controls) - MidiBuffer& cc_buf = mix_buffers.get_midi(0); - cc_buf.silence(nframes, offset); - - uint8_t buf[3]; // CC = 3 bytes - buf[0] = MIDI_CMD_CONTROL; - Evoral::Event ev(0, 3, buf, false); - - // Write track controller automation - // This now lives in MidiModel. Any need for track automation like this? - // Relative Velocity? - if (_session.transport_rolling()) { - for (Controls::const_iterator i = _controls.begin(); i != _controls.end(); ++i) { - const boost::shared_ptr list = (*i).second->list(); - - if ( (!list->automation_playback()) - || (list->parameter().type() != MidiCCAutomation)) - continue; + Buffer& b (p->get_buffer (nframes)); + const MidiBuffer* const mb = dynamic_cast(&b); + assert (mb); - double start = start_frame; - double x, y; - while ((*i).second->list()->rt_safe_earliest_event(start, end_frame, x, y)) { - assert(x >= start_frame); - assert(x <= end_frame); + for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) { - const nframes_t stamp = (nframes_t)floor(x - start_frame); - assert(stamp < nframes); + const Evoral::MIDIEvent ev(*e, false); - assert(y >= 0.0); - assert(y <= 127.0); + /* note on, since for step edit, note length is determined + elsewhere + */ - ev.time() = stamp; - ev.buffer()[1] = (uint8_t)list->parameter().id(); - ev.buffer()[2] = (uint8_t)y; + if (ev.is_note_on()) { + /* we don't care about the time for this purpose */ + _step_edit_ring_buffer.write (0, ev.type(), ev.size(), ev.buffer()); + } + } + } +} - cc_buf.push_back(ev); +void +MidiTrack::filter_channels (BufferSet& bufs, ChannelMode mode, uint32_t mask) +{ + if (mode == AllChannels) { + return; + } + + MidiBuffer& buf (bufs.get_midi (0)); + + for (MidiBuffer::iterator e = buf.begin(); e != buf.end(); ) { + + Evoral::MIDIEvent ev(*e, false); - start = x + 1; // FIXME? maybe? + if (ev.is_channel_event()) { + switch (mode) { + case FilterChannels: + if (0 == ((1< 0) { + if (_immediate_events.read_space()) { - // Both CC and route, must merge - if (output_buf.size() > 0) { + DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 has %2 of immediate events to deliver\n", + name(), _immediate_events.read_space())); - MidiBuffer& mix_buf = mix_buffers.get_midi(1); - mix_buf.merge(output_buf, cc_buf); - output_buf.copy(mix_buf); + /* write as many of the immediate events as we can, but give "true" as + * the last argument ("stop on overflow in destination") so that we'll + * ship the rest out next time. + * + * the (nframes-1) argument puts all these events at the last + * possible position of the output buffer, so that we do not + * violate monotonicity when writing. + */ - } else { - output_buf.copy(cc_buf); - } + _immediate_events.read (buf, 0, 1, nframes-1, true); } -#endif - - // Append immediate events (UI controls) - _immediate_events.read(output_buf, 0, 0, offset + nframes-1); // all stamps = 0 } int -MidiTrack::export_stuff (BufferSet& bufs, nframes_t nframes, nframes_t end_frame) +MidiTrack::export_stuff (BufferSet& /*bufs*/, framepos_t /*start_frame*/, framecnt_t /*nframes*/, + boost::shared_ptr /*endpoint*/, bool /*include_endpoint*/, bool /*forexport*/) { return -1; } -void -MidiTrack::set_latency_delay (nframes_t longest_session_latency) -{ - Route::set_latency_delay (longest_session_latency); - _diskstream->set_roll_delay (_roll_delay); -} - boost::shared_ptr -MidiTrack::bounce (InterThreadInfo& itt) +MidiTrack::bounce (InterThreadInfo& /*itt*/) { - throw; - // vector srcs; - // return _session.write_one_track (*this, 0, _session.current_end_frame(), false, srcs, itt); + std::cerr << "MIDI bounce currently unsupported" << std::endl; return boost::shared_ptr (); } boost::shared_ptr -MidiTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt) +MidiTrack::bounce_range (framepos_t /*start*/, framepos_t /*end*/, InterThreadInfo& /*itt*/, + boost::shared_ptr /*endpoint*/, bool /*include_endpoint*/) { - throw; - //vector srcs; - //return _session.write_one_track (*this, start, end, false, srcs, itt); + std::cerr << "MIDI bounce range currently unsupported" << std::endl; return boost::shared_ptr (); } void -MidiTrack::freeze (InterThreadInfo& itt) +MidiTrack::freeze_me (InterThreadInfo& /*itt*/) { + std::cerr << "MIDI freeze currently unsupported" << std::endl; } void @@ -703,16 +591,23 @@ MidiTrack::unfreeze () void MidiTrack::set_note_mode (NoteMode m) { - cout << _name << " SET NOTE MODE " << m << endl; _note_mode = m; midi_diskstream()->set_note_mode(m); } +std::string +MidiTrack::describe_parameter (Evoral::Parameter param) +{ + const std::string str(instrument_info().get_controller_name(param)); + return str.empty() ? Automatable::describe_parameter(param) : str; +} + void -MidiTrack::midi_panic() +MidiTrack::midi_panic() { + DEBUG_TRACE (DEBUG::MidiIO, string_compose ("%1 delivers panic data\n", name())); for (uint8_t channel = 0; channel <= 0xF; channel++) { - uint8_t ev[3] = { MIDI_CMD_CONTROL | channel, MIDI_CTL_SUSTAIN, 0 }; + uint8_t ev[3] = { ((uint8_t) (MIDI_CMD_CONTROL | channel)), ((uint8_t) MIDI_CTL_SUSTAIN), 0 }; write_immediate_event(3, ev); ev[1] = MIDI_CTL_ALL_NOTES_OFF; write_immediate_event(3, ev); @@ -726,22 +621,21 @@ MidiTrack::midi_panic() bool MidiTrack::write_immediate_event(size_t size, const uint8_t* buf) { - printf("Write immediate event: "); - for (size_t i=0; i < size; ++i) { - printf("%X ", buf[i]); + if (!Evoral::midi_event_is_valid(buf, size)) { + cerr << "WARNING: Ignoring illegal immediate MIDI event" << endl; + return false; } - printf("\n"); const uint32_t type = EventTypeMap::instance().midi_event_type(buf[0]); return (_immediate_events.write(0, type, size, buf) == size); } void -MidiTrack::MidiControl::set_value(float val) +MidiTrack::MidiControl::set_value(double val) { bool valid = false; - if (isinf(val)) { + if (std::isinf(val)) { cerr << "MIDIControl value is infinity" << endl; - } else if (isnan(val)) { + } else if (std::isnan(val)) { cerr << "MIDIControl value is NaN" << endl; } else if (val < _list->parameter().min()) { cerr << "MIDIControl value is < " << _list->parameter().min() << endl; @@ -750,41 +644,40 @@ MidiTrack::MidiControl::set_value(float val) } else { valid = true; } - + if (!valid) { return; } assert(val <= _list->parameter().max()); - size_t size = 3; - if ( ! automation_playback()) { - uint8_t ev[3] = { _list->parameter().channel(), int(val), 0 }; + size_t size = 3; + uint8_t ev[3] = { _list->parameter().channel(), uint8_t (val), 0 }; switch(_list->parameter().type()) { case MidiCCAutomation: ev[0] += MIDI_CMD_CONTROL; ev[1] = _list->parameter().id(); ev[2] = int(val); break; - + case MidiPgmChangeAutomation: size = 2; ev[0] += MIDI_CMD_PGM_CHANGE; ev[1] = int(val); break; - + case MidiChannelPressureAutomation: size = 2; ev[0] += MIDI_CMD_CHANNEL_PRESSURE; ev[1] = int(val); break; - + case MidiPitchBenderAutomation: ev[0] += MIDI_CMD_BENDER; ev[1] = 0x7F & int(val); ev[2] = 0x7F & (int(val) >> 7); break; - + default: assert(false); } @@ -792,5 +685,213 @@ MidiTrack::MidiControl::set_value(float val) } AutomationControl::set_value(val); -} +} + +void +MidiTrack::set_step_editing (bool yn) +{ + if (_session.record_status() != Session::Disabled) { + return; + } + + if (yn != _step_editing) { + _step_editing = yn; + StepEditStatusChange (yn); + } +} + +boost::shared_ptr +MidiTrack::write_source (uint32_t) +{ + return midi_diskstream()->write_source (); +} + +void +MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask) +{ + ChannelMode old = get_playback_channel_mode (); + uint16_t old_mask = get_playback_channel_mask (); + + if (old != mode || mask != old_mask) { + _set_playback_channel_mode (mode, mask); + PlaybackChannelModeChanged (); + _session.set_dirty (); + } +} + +void +MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask) +{ + ChannelMode old = get_capture_channel_mode (); + uint16_t old_mask = get_capture_channel_mask (); + + if (old != mode || mask != old_mask) { + _set_capture_channel_mode (mode, mask); + CaptureChannelModeChanged (); + _session.set_dirty (); + } +} + +void +MidiTrack::set_playback_channel_mask (uint16_t mask) +{ + uint16_t old = get_playback_channel_mask(); + + if (old != mask) { + _set_playback_channel_mask (mask); + PlaybackChannelMaskChanged (); + _session.set_dirty (); + } +} + +void +MidiTrack::set_capture_channel_mask (uint16_t mask) +{ + uint16_t old = get_capture_channel_mask(); + + if (old != mask) { + _set_capture_channel_mask (mask); + CaptureChannelMaskChanged (); + _session.set_dirty (); + } +} + +boost::shared_ptr +MidiTrack::midi_playlist () +{ + return midi_diskstream()->midi_playlist (); +} + +void +MidiTrack::diskstream_data_recorded (boost::weak_ptr src) +{ + DataRecorded (src); /* EMIT SIGNAL */ +} + +bool +MidiTrack::input_active () const +{ + return _input_active; +} + +void +MidiTrack::set_input_active (bool yn) +{ + if (yn != _input_active) { + _input_active = yn; + map_input_active (yn); + InputActiveChanged (); /* EMIT SIGNAL */ + } +} + +void +MidiTrack::map_input_active (bool yn) +{ + if (!_input) { + return; + } + + PortSet& ports (_input->ports()); + + for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) { + boost::shared_ptr mp = boost::dynamic_pointer_cast (*p); + if (yn != mp->input_active()) { + mp->set_input_active (yn); + } + } +} + +void +MidiTrack::track_input_active (IOChange change, void* /* src */) +{ + if (change.type & IOChange::ConfigurationChanged) { + map_input_active (_input_active); + } +} + +boost::shared_ptr +MidiTrack::diskstream_factory (XMLNode const & node) +{ + return boost::shared_ptr (new MidiDiskstream (_session, node)); +} + +boost::shared_ptr +MidiTrack::get_gui_feed_buffer () const +{ + return midi_diskstream()->get_gui_feed_buffer (); +} + +void +MidiTrack::act_on_mute () +{ + /* this is called right after our mute status has changed. + if we are now muted, send suitable output to shutdown + all our notes. + + XXX we should should also stop all relevant note trackers. + */ + + /* If we haven't got a diskstream yet, there's nothing to worry about, + and we can't call get_channel_mask() anyway. + */ + if (!midi_diskstream()) { + return; + } + + if (muted()) { + /* only send messages for channels we are using */ + + uint16_t mask = get_playback_channel_mask(); + + for (uint8_t channel = 0; channel <= 0xF; channel++) { + + if ((1<ports()); + + for (PortSet::iterator p = ports.begin(); p != ports.end(); ++p) { + boost::shared_ptr mp = boost::dynamic_pointer_cast (*p); + if (mp) { + mp->require_resolve (); + } + } + + boost::shared_ptr md (midi_diskstream()); + + if (md) { + md->reset_tracker (); + } + } +} + +MonitorState +MidiTrack::monitoring_state () const +{ + MonitorState ms = Track::monitoring_state(); + if (ms == MonitoringSilence) { + return MonitoringInput; + } + return ms; +}