X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmidi_track.cc;h=745fa75688104116ace649ad74cca3baa02f3cda;hb=56469c195640b561119852fd6d27a4b56e5af7e2;hp=281bce658f11af434a8b6a8b257eea06662358f2;hpb=55a367837a5770091fa6a46175a30a71d848e98c;p=ardour.git diff --git a/libs/ardour/midi_track.cc b/libs/ardour/midi_track.cc index 281bce658f..745fa75688 100644 --- a/libs/ardour/midi_track.cc +++ b/libs/ardour/midi_track.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2006 Paul Davis + Copyright (C) 2006 Paul Davis By Dave Robillard, 2006 This program is free software; you can redistribute it and/or modify @@ -17,28 +17,30 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "pbd/error.h" -#include -#include -#include #include "pbd/enumwriter.h" +#include "pbd/convert.h" #include "midi++/events.h" #include "evoral/midi_util.h" -#include "ardour/midi_track.h" -#include "ardour/midi_diskstream.h" -#include "ardour/session.h" +#include "ardour/amp.h" +#include "ardour/buffer_set.h" +#include "ardour/delivery.h" #include "ardour/io_processor.h" +#include "ardour/meter.h" +#include "ardour/midi_diskstream.h" +#include "ardour/midi_playlist.h" +#include "ardour/midi_port.h" #include "ardour/midi_region.h" #include "ardour/midi_source.h" -#include "ardour/route_group_specialized.h" -#include "ardour/processor.h" -#include "ardour/midi_playlist.h" +#include "ardour/midi_track.h" #include "ardour/panner.h" +#include "ardour/port.h" +#include "ardour/processor.h" +#include "ardour/route_group_specialized.h" +#include "ardour/session.h" +#include "ardour/session_playlists.h" #include "ardour/utils.h" -#include "ardour/buffer_set.h" -#include "ardour/meter.h" - #include "i18n.h" @@ -49,36 +51,12 @@ 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) + , _default_channel (0) + , _midi_thru (true) { - use_new_diskstream (); - - _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)); - - PortCountChanged(ChanCount(DataType::MIDI, 2)); /* EMIT SIGNAL */ -} - -MidiTrack::MidiTrack (Session& sess, const XMLNode& node) - : Track (sess, node, DataType::MIDI ) - , _immediate_events(1024) // FIXME: size? - , _note_mode(Sustained) -{ - _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)); - - PortCountChanged(ChanCount(DataType::MIDI, 2)); /* EMIT SIGNAL */ } MidiTrack::~MidiTrack () @@ -99,53 +77,24 @@ MidiTrack::use_new_diskstream () assert(_mode != Destructive); boost::shared_ptr ds (new MidiDiskstream (_session, name(), dflags)); - _session.add_diskstream (ds); + ds->do_refill_with_alloc (); + ds->set_block_size (_session.get_block_size ()); - set_diskstream (boost::dynamic_pointer_cast (ds)); -} + set_diskstream (ds); +} -int -MidiTrack::set_diskstream (boost::shared_ptr ds) +void +MidiTrack::set_diskstream (boost::shared_ptr ds) { - _diskstream = ds; - _diskstream->set_io (*this); + Track::set_diskstream (ds); + + _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)); - 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 @@ -155,62 +104,36 @@ MidiTrack::midi_diskstream() const } int -MidiTrack::set_state (const XMLNode& node) +MidiTrack::set_state (const XMLNode& node, int version) { - return _set_state (node, true); + return _set_state (node, version, true); } int -MidiTrack::_set_state (const XMLNode& node, bool call_base) +MidiTrack::_set_state (const XMLNode& node, int version, bool call_base) { const XMLProperty *prop; XMLNodeConstIterator iter; - if (Route::_set_state (node, call_base)) { + if (Route::_set_state (node, version, call_base)) { return -1; } - + // No destructive MIDI tracks (yet?) _mode = Normal; - + 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 (use_diskstream (prop->value())) { - return -1; - } + if ((prop = node.property ("midi-thru")) != 0) { + set_midi_thru (prop->value() == "yes"); + } - } else { - - PBD::ID id (prop->value()); - PBD::ID zero ("0"); - - /* this wierd hack is used when creating tracks from a template. there isn't - a particularly good time to interpose between setting the first part of - the track state (notably Route::set_state() and the track mode), and the - second part (diskstream stuff). So, we have a special ID for the diskstream - that means "you should create a new diskstream here, not look for - an old one. - */ - - if (id == zero) { - use_new_diskstream (); - } else if (use_diskstream (id)) { - return -1; - } + if ((prop = node.property ("default-channel")) != 0) { + set_default_channel ((uint8_t) atoi (prop->value())); } XMLNodeList nlist; @@ -222,15 +145,23 @@ MidiTrack::_set_state (const XMLNode& node, bool call_base) child = *niter; if (child->name() == X_("recenable")) { - _rec_enable_control->set_state (*child); + _rec_enable_control->set_state (*child, version); _session.add_controllable (_rec_enable_control); } } + if (version >= 3000) { + if ((child = find_named_node (node, X_("Diskstream"))) != 0) { + boost::shared_ptr ds (new MidiDiskstream (_session, *child)); + ds->do_refill_with_alloc (); + set_diskstream (ds); + } + } + pending_state = const_cast (&node); if (_session.state_of_the_state() & Session::Loading) { - _session.StateReady.connect (mem_fun (*this, &MidiTrack::set_state_part_two)); + _session.StateReady.connect_same_thread (*this, boost::bind (&MidiTrack::set_state_part_two, this)); } else { set_state_part_two (); } @@ -238,7 +169,7 @@ MidiTrack::_set_state (const XMLNode& node, bool call_base) return 0; } -XMLNode& +XMLNode& MidiTrack::state(bool full_state) { XMLNode& root (Route::state(full_state)); @@ -257,32 +188,22 @@ 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 (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_child_nocopy (_diskstream->get_state ()); + + root.add_property ("step-editing", (_step_editing ? "yes" : "no")); + root.add_property ("note-mode", enum_2_string (_note_mode)); + root.add_property ("midi-thru", (_midi_thru ? "yes" : "no")); + snprintf (buf, sizeof (buf), "%d", (int) _default_channel); + root.add_property ("default-channel", buf); return root; } @@ -305,14 +226,14 @@ MidiTrack::set_state_part_two () if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) { _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 { @@ -321,23 +242,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 (); @@ -345,123 +266,22 @@ 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 ((fnode = find_named_node (*pending_state, X_("Diskstream"))) != 0) { + boost::shared_ptr ds (new MidiDiskstream (_session, *fnode)); + ds->do_refill_with_alloc (); + ds->set_block_size (_session.get_block_size ()); + set_diskstream (ds); } - - flush_outputs( nframes, offset ); - return 0; + return; } 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 (nframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, + bool can_record, bool rec_monitors_input, bool& needs_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); @@ -477,43 +297,41 @@ MidiTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, } if (!_active) { - silence (nframes, offset); + silence (nframes); return 0; } nframes_t transport_frame = _session.transport_frame(); - - if ((nframes = check_initial_delay (nframes, offset, transport_frame)) == 0) { + + 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); - } + return diskstream->process (transport_frame, 0, can_record, rec_monitors_input, needs_butler); + } _silent = false; - if ((dret = diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) { - - silence (nframes, offset); - + if ((dret = diskstream->process (transport_frame, nframes, can_record, rec_monitors_input, needs_butler)) != 0) { + silence (nframes); return dret; } /* special condition applies */ if (_meter_point == MeterInput) { - just_meter_input (start_frame, end_frame, nframes, offset); + _input->process_input (_meter, start_frame, end_frame, nframes); } - if (diskstream->record_enabled() && !can_record && !Config->get_auto_input()) { + if (diskstream->record_enabled() && !can_record && !_session.config.get_auto_input()) { /* not actually recording, but we want to hear the input material anyway, at least potentially (depending on monitoring options) - */ + */ - passthru (start_frame, end_frame, nframes, offset, 0, true); + passthru (start_frame, end_frame, nframes, 0); } else { /* @@ -529,90 +347,83 @@ MidiTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, //const size_t limit = n_process_buffers().n_audio(); BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers()); + MidiBuffer& mbuf (bufs.get_midi (0)); - diskstream->get_playback(bufs.get_midi(0), start_frame, end_frame, offset); + diskstream->get_playback (mbuf, start_frame, end_frame); + + /* 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); + + process_output_buffers (bufs, start_frame, end_frame, nframes, + (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick); - process_output_buffers (bufs, start_frame, end_frame, nframes, offset, - (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput)); - } - flush_outputs( nframes, offset ); + _main_outs->flush (nframes, end_frame - start_frame - 1); 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 (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, + bool state_changing, bool can_record, bool rec_monitors_input) { - if (n_outputs().n_midi() == 0 && _processors.empty()) { - return 0; - } + int ret = Track::no_roll (nframes, start_frame, end_frame, state_changing, can_record, rec_monitors_input); - if (!_active) { - silence (nframes, offset); - return 0; + if (ret == 0 && _diskstream->record_enabled() && _step_editing) { + push_midi_input_to_step_edit_ringbuffer (nframes); } - _silent = true; - apply_gain_automation = false; + return ret; +} - silence (nframes, offset); +void +MidiTrack::handle_transport_stopped (bool abort, bool did_locate, bool flush_processors) +{ - return midi_diskstream()->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input); + _main_outs->transport_stopped (); + Route::handle_transport_stopped (abort, did_locate, flush_processors); } + 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::push_midi_input_to_step_edit_ringbuffer (nframes_t nframes) +{ + PortSet& ports (_input->ports()); - // 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); - } - } - } - - if (meter && (_meter_point == MeterPostFader)) { - _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset); - } - - // Main output stage - if (muted()) { - IO::silence(nframes, offset); - } else { + for (PortSet::iterator p = ports.begin(DataType::MIDI); p != ports.end(DataType::MIDI); ++p) { - // 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); + Buffer& b (p->get_buffer (nframes)); + const MidiBuffer* const mb = dynamic_cast(&b); + assert (mb); + + for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) { + + const Evoral::MIDIEvent ev(*e, false); + + /* we don't care about the time for this purpose */ + + _step_edit_ring_buffer.write (0, ev.type(), ev.size(), ev.buffer()); + } } } void -MidiTrack::write_controller_messages(MidiBuffer& output_buf, nframes_t start, nframes_t end, - nframes_t nframes, nframes_t offset) +MidiTrack::write_out_of_band_data (BufferSet& bufs, sframes_t /*start*/, sframes_t /*end*/, nframes_t nframes) { - // Append immediate events (UI controls) - _immediate_events.read(output_buf, 0, 0, offset + nframes - 1); // all stamps = 0 + // Append immediate events + MidiBuffer& buf (bufs.get_midi (0)); + _immediate_events.read (buf, 0, 0, nframes - 1); // all stamps = 0 + + // MIDI thru: send incoming data "through" output + if (_midi_thru && _session.transport_speed() != 0.0f && _input->n_ports().n_midi()) { + buf.merge_in_place (_input->midi(0)->get_midi_buffer(nframes)); + } } int -MidiTrack::export_stuff (BufferSet& bufs, nframes_t nframes, nframes_t end_frame) +MidiTrack::export_stuff (BufferSet& /*bufs*/, nframes_t /*nframes*/, sframes_t /*end_frame*/) { return -1; } @@ -625,7 +436,7 @@ MidiTrack::set_latency_delay (nframes_t longest_session_latency) } boost::shared_ptr -MidiTrack::bounce (InterThreadInfo& itt) +MidiTrack::bounce (InterThreadInfo& /*itt*/) { throw; // vector srcs; @@ -635,7 +446,7 @@ MidiTrack::bounce (InterThreadInfo& itt) boost::shared_ptr -MidiTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt) +MidiTrack::bounce_range (nframes_t /*start*/, nframes_t /*end*/, InterThreadInfo& /*itt*/, bool /*enable_processing*/) { throw; //vector srcs; @@ -644,7 +455,7 @@ MidiTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt) } void -MidiTrack::freeze (InterThreadInfo& itt) +MidiTrack::freeze_me (InterThreadInfo& /*itt*/) { } @@ -663,7 +474,7 @@ MidiTrack::set_note_mode (NoteMode m) } void -MidiTrack::midi_panic() +MidiTrack::midi_panic() { for (uint8_t channel = 0; channel <= 0xF; channel++) { uint8_t ev[3] = { MIDI_CMD_CONTROL | channel, MIDI_CTL_SUSTAIN, 0 }; @@ -703,15 +514,14 @@ MidiTrack::MidiControl::set_value(float val) } else { valid = true; } - + if (!valid) { return; } assert(val <= _list->parameter().max()); - size_t size = 3; - if ( ! automation_playback()) { + size_t size = 3; uint8_t ev[3] = { _list->parameter().channel(), int(val), 0 }; switch(_list->parameter().type()) { case MidiCCAutomation: @@ -719,25 +529,25 @@ MidiTrack::MidiControl::set_value(float val) 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); } @@ -745,5 +555,52 @@ MidiTrack::MidiControl::set_value(float val) } AutomationControl::set_value(val); -} +} +void +MidiTrack::set_step_editing (bool yn) +{ + _step_editing = yn; +} + +void +MidiTrack::set_default_channel (uint8_t chn) +{ + _default_channel = std::min ((unsigned int) chn, 15U); +} + +void +MidiTrack::set_midi_thru (bool yn) +{ + _midi_thru = yn; +} + +boost::shared_ptr +MidiTrack::write_source (uint32_t n) +{ + return midi_diskstream()->write_source (); +} + +void +MidiTrack::set_channel_mode (ChannelMode mode, uint16_t mask) +{ + midi_diskstream()->set_channel_mode (mode, mask); +} + +ChannelMode +MidiTrack::get_channel_mode () +{ + return midi_diskstream()->get_channel_mode (); +} + +uint16_t +MidiTrack::get_channel_mask () +{ + return midi_diskstream()->get_channel_mask (); +} + +boost::shared_ptr +MidiTrack::midi_playlist () +{ + return midi_diskstream()->midi_playlist (); +}