#include <gtkmm/table.h>
#include "pbd/compose.h"
+#include "pbd/ffs.h"
#include "gtkmm2ext/gtk_ui.h"
#include "gtkmm2ext/gui_thread.h"
playback_mask_changed ();
capture_mask_changed ();
- track->PlaybackChannelMaskChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::playback_mask_changed, this), gui_context());
- track->PlaybackChannelModeChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::playback_mode_changed, this), gui_context());
- track->CaptureChannelMaskChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::capture_mask_changed, this), gui_context());
- track->CaptureChannelModeChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::capture_mode_changed, this), gui_context());
+ track->playback_filter().ChannelMaskChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::playback_mask_changed, this), gui_context());
+ track->playback_filter().ChannelModeChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::playback_mode_changed, this), gui_context());
+ track->capture_filter().ChannelMaskChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::capture_mask_changed, this), gui_context());
+ track->capture_filter().ChannelModeChanged.connect (*this, MISSING_INVALIDATOR, boost::bind (&MidiChannelSelectorWindow::capture_mode_changed, this), gui_context());
}
MidiChannelSelectorWindow::~MidiChannelSelectorWindow()
group->raise_to_top();
- midi_view()->midi_track()->PlaybackChannelModeChanged.connect (_channel_mode_changed_connection, invalidator (*this),
+ midi_view()->midi_track()->playback_filter().ChannelModeChanged.connect (_channel_mode_changed_connection, invalidator (*this),
boost::bind (&MidiRegionView::midi_channel_mode_changed, this),
gui_context ());
_view->RegionViewAdded.connect (
sigc::mem_fun(*this, &MidiTimeAxisView::region_view_added));
- midi_track()->PlaybackChannelModeChanged.connect (*this, invalidator (*this),
- boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this),
- gui_context());
- midi_track()->PlaybackChannelMaskChanged.connect (*this, invalidator (*this),
- boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this),
- gui_context());
- midi_track()->CaptureChannelModeChanged.connect (*this, invalidator (*this),
- boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this),
- gui_context());
- midi_track()->CaptureChannelMaskChanged.connect (*this, invalidator (*this),
- boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this),
- gui_context());
+ midi_track()->playback_filter().ChannelModeChanged.connect (
+ *this, invalidator (*this),
+ boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this),
+ gui_context());
+ midi_track()->playback_filter().ChannelMaskChanged.connect (
+ *this, invalidator (*this),
+ boost::bind (&MidiTimeAxisView::playback_channel_mode_changed, this),
+ gui_context());
+ midi_track()->capture_filter().ChannelModeChanged.connect (
+ *this, invalidator (*this),
+ boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this),
+ gui_context());
+ midi_track()->capture_filter().ChannelMaskChanged.connect (
+ *this, invalidator (*this),
+ boost::bind (&MidiTimeAxisView::capture_channel_mode_changed, this),
+ gui_context());
playback_channel_mode_changed ();
capture_channel_mode_changed ();
--- /dev/null
+/*
+ Copyright (C) 2006-2015 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
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_channel_filter_h__
+#define __ardour_channel_filter_h__
+
+#include <stdint.h>
+
+#include <glib.h>
+
+#include "ardour/types.h"
+#include "pbd/signals.h"
+
+namespace ARDOUR
+{
+
+class BufferSet;
+
+/** Filter/mapper for MIDI channels.
+ *
+ * Channel mapping is configured by setting a mode and "mask", where the
+ * meaning of the mask depends on the mode.
+ *
+ * If mode is FilterChannels, each mask bit represents a midi channel (bit 0 =
+ * channel 0, bit 1 = channel 1, ...). Only events whose channel corresponds
+ * to a 1 bit will be passed.
+ *
+ * If mode is ForceChannel, mask is simply a channel number which all events
+ * will be forced to.
+ */
+class LIBARDOUR_API MidiChannelFilter
+{
+public:
+ MidiChannelFilter();
+
+ /** Filter `bufs` in-place. */
+ void filter(BufferSet& bufs);
+
+ /** Filter/map a MIDI message by channel.
+ *
+ * May modify the channel in `buf` if necessary.
+ *
+ * @return true if this event should be filtered out.
+ */
+ bool filter(uint8_t* buf, uint32_t len);
+
+ /** Atomically set the channel mode and corresponding mask.
+ * @return true iff configuration changed.
+ */
+ bool set_channel_mode(ChannelMode mode, uint16_t mask);
+
+ /** Atomically set the channel mask for the current mode.
+ * @return true iff configuration changed.
+ */
+ bool set_channel_mask(uint16_t mask);
+
+ /** Atomically get both the channel mode and mask. */
+ void get_mode_and_mask(ChannelMode* mode, uint16_t* mask) const {
+ const uint32_t mm = g_atomic_int_get(&_mode_mask);
+ *mode = static_cast<ChannelMode>((mm & 0xFFFF0000) >> 16);
+ *mask = (mm & 0x0000FFFF);
+ }
+
+ ChannelMode get_channel_mode() const {
+ return static_cast<ChannelMode>((g_atomic_int_get(&_mode_mask) & 0xFFFF0000) >> 16);
+ }
+
+ uint16_t get_channel_mask() const {
+ return g_atomic_int_get(&_mode_mask) & 0x0000FFFF;
+ }
+
+ PBD::Signal0<void> ChannelMaskChanged;
+ PBD::Signal0<void> ChannelModeChanged;
+
+private:
+ uint32_t _mode_mask; ///< 16 bits mode, 16 bits mask
+};
+
+} /* namespace ARDOUR */
+
+#endif /* __ardour_channel_filter_h__ */
{
class BeatsFramesConverter;
+class MidiChannelFilter;
class MidiRegion;
class Session;
class Source;
framecnt_t read (Evoral::EventSink<framepos_t>& buf,
framepos_t start,
framecnt_t cnt,
- uint32_t chan_n = 0);
+ uint32_t chan_n = 0,
+ MidiChannelFilter* filter = NULL);
int set_state (const XMLNode&, int version);
framepos_t position,
framepos_t start,
framecnt_t cnt,
- MidiStateTracker* tracker) const;
+ MidiStateTracker* tracker,
+ MidiChannelFilter* filter) const;
framecnt_t write_unlocked (const Lock& lock,
MidiRingBuffer<framepos_t>& dst,
namespace ARDOUR {
-class Route;
-class Playlist;
-class Session;
+class MidiChannelFilter;
class MidiFilter;
class MidiModel;
class MidiSource;
class MidiStateTracker;
+class Playlist;
+class Route;
+class Session;
template<typename T> class MidiRingBuffer;
framecnt_t dur,
uint32_t chan_n = 0,
NoteMode mode = Sustained,
- MidiStateTracker* tracker = 0) const;
+ MidiStateTracker* tracker = 0,
+ MidiChannelFilter* filter = 0) const;
framecnt_t master_read_at (MidiRingBuffer<framepos_t>& dst,
framepos_t position,
framecnt_t dur,
uint32_t chan_n = 0,
NoteMode mode = Sustained,
- MidiStateTracker* tracker = 0) const;
+ MidiStateTracker* tracker = 0,
+ MidiChannelFilter* filter = 0) const;
void register_properties ();
void post_set (const PBD::PropertyChange&);
namespace ARDOUR {
+class MidiChannelFilter;
class MidiStateTracker;
class MidiModel;
framepos_t start,
framecnt_t cnt,
MidiStateTracker* tracker,
+ MidiChannelFilter* filter,
const std::set<Evoral::Parameter>& filtered) const;
/** Write data from a MidiRingBuffer to this source.
framepos_t position,
framepos_t start,
framecnt_t cnt,
- MidiStateTracker* tracker) const = 0;
+ MidiStateTracker* tracker,
+ MidiChannelFilter* filter) const = 0;
/** Write data to this source from a MidiRingBuffer.
* @param source Buffer to read from.
#ifndef __ardour_midi_track_h__
#define __ardour_midi_track_h__
-#include "pbd/ffs.h"
-
-#include "ardour/track.h"
+#include "ardour/midi_channel_filter.h"
#include "ardour/midi_ring_buffer.h"
+#include "ardour/track.h"
namespace ARDOUR
{
boost::shared_ptr<SMFSource> write_source (uint32_t n = 0);
- /** Channel filtering mode.
- * @param mask If mode is FilterChannels, each bit represents a midi channel:
- * bit 0 = channel 0, bit 1 = channel 1 etc. the read and write methods will only
- * process events whose channel bit is 1.
- * If mode is ForceChannel, mask is simply a channel number which all events will
- * be forced to while reading.
- */
+ /* Configure capture/playback channels (see MidiChannelFilter). */
void set_capture_channel_mode (ChannelMode mode, uint16_t mask);
void set_playback_channel_mode (ChannelMode mode, uint16_t mask);
void set_playback_channel_mask (uint16_t mask);
void set_capture_channel_mask (uint16_t mask);
- ChannelMode get_playback_channel_mode() const {
- return static_cast<ChannelMode>((g_atomic_int_get(&_playback_channel_mask) & 0xffff0000) >> 16);
- }
- uint16_t get_playback_channel_mask() const {
- return g_atomic_int_get(&_playback_channel_mask) & 0x0000ffff;
- }
- ChannelMode get_capture_channel_mode() const {
- return static_cast<ChannelMode>((g_atomic_int_get(&_capture_channel_mask) & 0xffff0000) >> 16);
- }
- uint16_t get_capture_channel_mask() const {
- return g_atomic_int_get(&_capture_channel_mask) & 0x0000ffff;
- }
+ ChannelMode get_playback_channel_mode() const { return _playback_filter.get_channel_mode(); }
+ ChannelMode get_capture_channel_mode() const { return _capture_filter.get_channel_mode(); }
+ uint16_t get_playback_channel_mask() const { return _playback_filter.get_channel_mask(); }
+ uint16_t get_capture_channel_mask() const { return _capture_filter.get_channel_mask(); }
+
+ MidiChannelFilter& playback_filter() { return _playback_filter; }
+ MidiChannelFilter& capture_filter() { return _capture_filter; }
boost::shared_ptr<MidiPlaylist> midi_playlist ();
- PBD::Signal0<void> PlaybackChannelMaskChanged;
- PBD::Signal0<void> PlaybackChannelModeChanged;
- PBD::Signal0<void> CaptureChannelMaskChanged;
- PBD::Signal0<void> CaptureChannelModeChanged;
-
PBD::Signal1<void, boost::weak_ptr<MidiSource> > DataRecorded;
boost::shared_ptr<MidiBuffer> get_gui_feed_buffer () const;
NoteMode _note_mode;
bool _step_editing;
bool _input_active;
- uint32_t _playback_channel_mask; // 16 bits mode, 16 bits mask
- uint32_t _capture_channel_mask; // 16 bits mode, 16 bits mask
+ MidiChannelFilter _playback_filter;
+ MidiChannelFilter _capture_filter;
virtual boost::shared_ptr<Diskstream> diskstream_factory (XMLNode const &);
/** Update automation controls to reflect any changes in buffers. */
void update_controls (const BufferSet& bufs);
-
- void filter_channels (BufferSet& bufs, ChannelMode mode, uint32_t mask);
-
-/* if mode is ForceChannel, force mask to the lowest set channel or 1 if no
- * channels are set.
- */
-#define force_mask(mode,mask) (((mode) == ForceChannel) ? (((mask) ? (1<<(PBD::ffs((mask))-1)) : 1)) : mask)
-
- void _set_playback_channel_mode(ChannelMode mode, uint16_t mask) {
- mask = force_mask (mode, mask);
- g_atomic_int_set(&_playback_channel_mask, (uint32_t(mode) << 16) | uint32_t(mask));
- }
- void _set_playback_channel_mask (uint16_t mask) {
- mask = force_mask (get_playback_channel_mode(), mask);
- g_atomic_int_set(&_playback_channel_mask, (uint32_t(get_playback_channel_mode()) << 16) | uint32_t(mask));
- }
- void _set_capture_channel_mode(ChannelMode mode, uint16_t mask) {
- mask = force_mask (mode, mask);
- g_atomic_int_set(&_capture_channel_mask, (uint32_t(mode) << 16) | uint32_t(mask));
- }
- void _set_capture_channel_mask (uint16_t mask) {
- mask = force_mask (get_capture_channel_mode(), mask);
- g_atomic_int_set(&_capture_channel_mask, (uint32_t(get_capture_channel_mode()) << 16) | uint32_t(mask));
- }
-
-#undef force_mask
};
} /* namespace ARDOUR*/
framepos_t position,
framepos_t start,
framecnt_t cnt,
- MidiStateTracker* tracker) const;
+ MidiStateTracker* tracker,
+ MidiChannelFilter* filter) const;
framecnt_t write_unlocked (const Lock& lock,
MidiRingBuffer<framepos_t>& src,
--- /dev/null
+/*
+ Copyright (C) 2006-2015 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
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "ardour/buffer_set.h"
+#include "ardour/midi_buffer.h"
+#include "ardour/midi_channel_filter.h"
+#include "pbd/ffs.h"
+
+namespace ARDOUR {
+
+MidiChannelFilter::MidiChannelFilter()
+ : _mode_mask(0x0000FFFF)
+{}
+
+void
+MidiChannelFilter::filter(BufferSet& bufs)
+{
+ ChannelMode mode;
+ uint16_t mask;
+ get_mode_and_mask(&mode, &mask);
+
+ if (mode == AllChannels) {
+ return;
+ }
+
+ MidiBuffer& buf = bufs.get_midi(0);
+
+ for (MidiBuffer::iterator e = buf.begin(); e != buf.end(); ) {
+ Evoral::MIDIEvent<framepos_t> ev(*e, false);
+
+ if (ev.is_channel_event()) {
+ switch (mode) {
+ case FilterChannels:
+ if (0 == ((1 << ev.channel()) & mask)) {
+ e = buf.erase (e);
+ } else {
+ ++e;
+ }
+ break;
+ case ForceChannel:
+ ev.set_channel(PBD::ffs(mask) - 1);
+ ++e;
+ break;
+ case AllChannels:
+ /* handled by the opening if() */
+ ++e;
+ break;
+ }
+ } else {
+ ++e;
+ }
+ }
+}
+
+bool
+MidiChannelFilter::filter(uint8_t* buf, uint32_t len)
+{
+ ChannelMode mode;
+ uint16_t mask;
+ get_mode_and_mask(&mode, &mask);
+
+ const uint8_t type = buf[0] & 0xF0;
+ const bool is_channel_event = (0x80 <= type) && (type <= 0xE0);
+ if (!is_channel_event) {
+ return false;
+ }
+
+ const uint8_t channel = buf[0] & 0x0F;
+ switch (mode) {
+ case AllChannels:
+ return false;
+ case FilterChannels:
+ return !((1 << channel) & mask);
+ case ForceChannel:
+ buf[0] = (0xF0 & buf[0]) | (0x0F & (PBD::ffs(mask) - 1));
+ return false;
+ }
+
+ return false;
+}
+
+/** If mode is ForceChannel, force mask to the lowest set channel or 1 if no
+ * channels are set.
+ */
+static inline uint16_t
+force_mask(const ChannelMode mode, const uint16_t mask)
+{
+ return ((mode == ForceChannel)
+ ? (mask ? (1 << (PBD::ffs(mask) - 1)) : 1)
+ : mask);
+}
+
+bool
+MidiChannelFilter::set_channel_mode(ChannelMode mode, uint16_t mask)
+{
+ ChannelMode old_mode;
+ uint16_t old_mask;
+ get_mode_and_mask(&old_mode, &old_mask);
+
+ if (old_mode != mode || old_mask != mask) {
+ mask = force_mask(mode, mask);
+ g_atomic_int_set(&_mode_mask, (uint32_t(mode) << 16) | uint32_t(mask));
+ ChannelModeChanged();
+ return true;
+ }
+
+ return false;
+}
+
+bool
+MidiChannelFilter::set_channel_mask(uint16_t mask)
+{
+ ChannelMode mode;
+ uint16_t old_mask;
+ get_mode_and_mask(&mode, &old_mask);
+
+ if (old_mask != mask) {
+ mask = force_mask(mode, mask);
+ g_atomic_int_set(&_mode_mask, (uint32_t(mode) << 16) | uint32_t(mask));
+ ChannelMaskChanged();
+ return true;
+ }
+
+ return false;
+}
+
+} /* namespace ARDOUR */
}
if (nominally_recording || rec_nframes) {
-
- // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
- MidiBuffer& buf = sp->get_midi_buffer(nframes);
- ChannelMode mode = AllChannels;
- uint32_t mask = 0xffff;
-
- MidiTrack * mt = dynamic_cast<MidiTrack*> (_track);
- if (mt) {
- mode = mt->get_capture_channel_mode ();
- mask = mt->get_capture_channel_mask ();
- }
+ // Pump entire port buffer into the ring buffer (TODO: split cycles?)
+ MidiBuffer& buf = sp->get_midi_buffer(nframes);
+ MidiTrack* mt = dynamic_cast<MidiTrack*>(_track);
+ MidiChannelFilter* filter = mt ? &mt->capture_filter() : NULL;
for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
const framecnt_t loop_offset = _num_captured_loops * loop_length;
const framepos_t event_time = transport_frame + loop_offset - _accumulated_capture_offset + ev.time();
if (event_time < 0 || event_time < first_recordable_frame) {
+ /* Event out of range, skip */
continue;
}
- switch (mode) {
- case AllChannels:
- _capture_buf->write(event_time,
- ev.type(), ev.size(), ev.buffer());
- break;
- case FilterChannels:
- if (ev.is_channel_event()) {
- if ((1<<ev.channel()) & mask) {
- _capture_buf->write(event_time,
- ev.type(), ev.size(), ev.buffer());
- }
- } else {
- _capture_buf->write(event_time,
- ev.type(), ev.size(), ev.buffer());
- }
- break;
- case ForceChannel:
- if (ev.is_channel_event()) {
- ev.set_channel (PBD::ffs(mask) - 1);
- }
- _capture_buf->write(event_time,
- ev.type(), ev.size(), ev.buffer());
- break;
+
+ if (!filter || !filter->filter(ev.buffer(), ev.size())) {
+ _capture_buf->write(event_time, ev.type(), ev.size(), ev.buffer());
}
}
g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
framecnt_t loop_length = 0;
Location* loc = 0;
+ MidiTrack* mt = dynamic_cast<MidiTrack*>(_track);
+ MidiChannelFilter* filter = mt ? &mt->playback_filter() : NULL;
+
if (!reversed) {
loc = loop_location;
this_read = min(dur,this_read);
- if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
+ if (midi_playlist()->read (*_playback_buf, start, this_read, 0, filter) != this_read) {
error << string_compose(
_("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
id(), this_read, start) << endmsg;
};
framecnt_t
-MidiPlaylist::read (Evoral::EventSink<framepos_t>& dst, framepos_t start, framecnt_t dur, unsigned chan_n)
+MidiPlaylist::read (Evoral::EventSink<framepos_t>& dst,
+ framepos_t start,
+ framecnt_t dur,
+ unsigned chan_n,
+ MidiChannelFilter* filter)
{
typedef pair<MidiStateTracker*,framepos_t> TrackerInfo;
}
/* Read from region into target. */
- mr->read_at (tgt, start, dur, chan_n, _note_mode, &tracker->tracker);
+ mr->read_at (tgt, start, dur, chan_n, _note_mode, &tracker->tracker, filter);
DEBUG_TRACE (DEBUG::MidiPlaylistIO,
string_compose ("\tPost-read: %1 active notes\n", tracker->tracker.on()));
Evoral::EventSink<framepos_t>& dst,
framepos_t /*position*/,
framepos_t start, framecnt_t cnt,
- MidiStateTracker*) const
+ MidiStateTracker*,
+ MidiChannelFilter*) const
{
boost::shared_ptr<MidiPlaylist> mp = boost::dynamic_pointer_cast<MidiPlaylist> (_playlist);
}
framecnt_t
-MidiRegion::read_at (Evoral::EventSink<framepos_t>& out, framepos_t position, framecnt_t dur, uint32_t chan_n, NoteMode mode, MidiStateTracker* tracker) const
+MidiRegion::read_at (Evoral::EventSink<framepos_t>& out,
+ framepos_t position,
+ framecnt_t dur,
+ uint32_t chan_n,
+ NoteMode mode,
+ MidiStateTracker* tracker,
+ MidiChannelFilter* filter) const
{
- return _read_at (_sources, out, position, dur, chan_n, mode, tracker);
+ return _read_at (_sources, out, position, dur, chan_n, mode, tracker, filter);
}
framecnt_t
framecnt_t dur,
uint32_t chan_n,
NoteMode mode,
- MidiStateTracker* tracker) const
+ MidiStateTracker* tracker,
+ MidiChannelFilter* filter) const
{
frameoffset_t internal_offset = 0;
framecnt_t to_read = 0;
_start + internal_offset, // where to start reading in the source
to_read, // read duration in frames
tracker,
+ filter,
_filtered_parameters
) != to_read) {
return 0; /* "read nothing" */
#include "evoral/EventSink.hpp"
#include "ardour/debug.h"
+#include "ardour/file_source.h"
+#include "ardour/midi_channel_filter.h"
#include "ardour/midi_model.h"
-#include "ardour/midi_state_tracker.h"
#include "ardour/midi_source.h"
-#include "ardour/file_source.h"
+#include "ardour/midi_state_tracker.h"
#include "ardour/session.h"
#include "ardour/session_directory.h"
#include "ardour/source_factory.h"
framepos_t start,
framecnt_t cnt,
MidiStateTracker* tracker,
+ MidiChannelFilter* filter,
const std::set<Evoral::Parameter>& filtered) const
{
BeatsFramesConverter converter(_session.tempo_map(), source_start);
for (; i != _model->end(); ++i) {
const framecnt_t time_frames = converter.to(i->time());
if (time_frames < start + cnt) {
+ if (filter && filter->filter(i->buffer(), i->size())) {
+ DEBUG_TRACE (DEBUG::MidiSourceIO,
+ string_compose ("%1: filter event @ %2 type %3 size %4\n",
+ _name, time_frames + source_start, i->event_type(), i->size()));
+ continue;
+ }
+
// Offset by source start to convert event time to session time
dst.write (time_frames + source_start, i->event_type(), i->size(), i->buffer());
}
return cnt;
} else {
- return read_unlocked (lm, dst, source_start, start, cnt, tracker);
+ return read_unlocked (lm, dst, source_start, start, cnt, tracker, filter);
}
}
#define isnan_local std::isnan
#endif
-#include "pbd/ffs.h"
#include "pbd/enumwriter.h"
#include "pbd/convert.h"
#include "evoral/midi_util.h"
, _note_mode(Sustained)
, _step_editing (false)
, _input_active (true)
- , _playback_channel_mask(0x0000ffff)
- , _capture_channel_mask(0x0000ffff)
{
}
fill_buffers_with_input (bufs, _input, nframes);
/* filter captured data before meter sees it */
- filter_channels (bufs, get_capture_channel_mode(), get_capture_channel_mask());
+ _capture_filter.filter (bufs);
if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
_meter->run (bufs, start_frame, end_frame, nframes, true);
return dret;
}
- /* filter playback data before we do anything else */
-
- filter_channels (bufs, get_playback_channel_mode(), get_playback_channel_mask ());
+ /* note diskstream uses our filter to filter/map playback channels appropriately. */
if (monitoring_state() == MonitoringInput) {
}
}
-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<framepos_t> ev(*e, false);
-
- if (ev.is_channel_event()) {
- switch (mode) {
- case FilterChannels:
- if (0 == ((1<<ev.channel()) & mask)) {
- e = buf.erase (e);
- } else {
- ++e;
- }
- break;
- case ForceChannel:
- ev.set_channel (PBD::ffs (mask) - 1);
- ++e;
- break;
- case AllChannels:
- /* handled by the opening if() */
- ++e;
- break;
- }
- } else {
- ++e;
- }
- }
-}
-
void
MidiTrack::write_out_of_band_data (BufferSet& bufs, framepos_t /*start*/, framepos_t /*end*/, framecnt_t nframes)
{
}
void
-MidiTrack::set_playback_channel_mode(ChannelMode mode, uint16_t mask)
+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 ();
+ if (_playback_filter.set_channel_mode(mode, mask)) {
+ _session.set_dirty();
}
}
void
-MidiTrack::set_capture_channel_mode(ChannelMode mode, uint16_t mask)
+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 ();
+ if (_capture_filter.set_channel_mode(mode, mask)) {
+ _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 ();
+ if (_playback_filter.set_channel_mask(mask)) {
+ _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 ();
+ if (_capture_filter.set_channel_mask(mask)) {
+ _session.set_dirty();
}
}
if (muted() || _mute_master->muted_by_others_at(MuteMaster::AllPoints)) {
/* only send messages for channels we are using */
- uint16_t mask = get_playback_channel_mask();
+ uint16_t mask = _playback_filter.get_channel_mask();
for (uint8_t channel = 0; channel <= 0xF; channel++) {
#include "evoral/Control.hpp"
#include "evoral/SMF.hpp"
+#include "ardour/debug.h"
+#include "ardour/midi_channel_filter.h"
#include "ardour/midi_model.h"
#include "ardour/midi_ring_buffer.h"
#include "ardour/midi_state_tracker.h"
#include "ardour/parameter_types.h"
#include "ardour/session.h"
#include "ardour/smf_source.h"
-#include "ardour/debug.h"
#include "i18n.h"
framepos_t const source_start,
framepos_t start,
framecnt_t duration,
- MidiStateTracker* tracker) const
+ MidiStateTracker* tracker,
+ MidiChannelFilter* filter) const
{
int ret = 0;
uint64_t time = 0; // in SMF ticks, 1 tick per _ppqn
const framepos_t ev_frame_time = converter.to(Evoral::Beats::ticks_at_rate(time, ppqn())) + source_start;
if (ev_frame_time < start + duration) {
- destination.write (ev_frame_time, ev_type, ev_size, ev_buffer);
- if (tracker) {
- tracker->track(ev_buffer);
+ if (!filter || !filter->filter(ev_buffer, ev_size)) {
+ destination.write (ev_frame_time, ev_type, ev_size, ev_buffer);
+ if (tracker) {
+ tracker->track(ev_buffer);
+ }
}
} else {
break;
'meter.cc',
'midi_automation_list_binder.cc',
'midi_buffer.cc',
+ 'midi_channel_filter.cc',
'midi_clock_slave.cc',
'midi_diskstream.cc',
'midi_model.cc',
projects / ardour.git / commitdiff