#include "ardour/session.h"
#include "evoral/Parameter.hpp"
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
#include "evoral/Control.hpp"
#include "evoral/midi_util.h"
if (!UIConfiguration::instance().get_never_display_periodic_midi()) {
for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
- const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
- boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::Beats> > (*i);
-
- if (mev) {
- if (mev->is_spp() || mev->is_mtc_quarter() || mev->is_mtc_full()) {
- have_periodic_system_messages = true;
- break;
- }
+ if ((*i)->is_spp() || (*i)->is_mtc_quarter() || (*i)->is_mtc_full()) {
+ have_periodic_system_messages = true;
+ break;
}
}
}
for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
-
- const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
- boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::Beats> > (*i);
-
Evoral::Beats time = (*i)->time();
- if (mev) {
- if (mev->is_spp() || mev->is_mtc_quarter() || mev->is_mtc_full()) {
- if (!display_periodic_messages) {
- continue;
- }
+ if ((*i)->is_spp() || (*i)->is_mtc_quarter() || (*i)->is_mtc_full()) {
+ if (!display_periodic_messages) {
+ continue;
}
}
framepos_t back = max_framepos;
for (MidiBuffer::iterator i = buf->begin(); i != buf->end(); ++i) {
- Evoral::MIDIEvent<MidiBuffer::TimeType> const ev (*i, false);
+ const Evoral::Event<MidiBuffer::TimeType>& ev = *i;
if (ev.is_channel_event()) {
if (get_channel_mode() == FilterChannels) {
return Processor::configure_io (in, out);
}
+static void
+scale_midi_velocity(Evoral::Event<MidiBuffer::TimeType>& ev, float factor)
+{
+ factor = std::max(factor, 0.0f);
+ ev.set_velocity(std::min(127L, lrintf(ev.velocity() * factor)));
+}
+
void
Amp::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_frame*/, double /*speed*/, pframes_t nframes, bool)
{
for (BufferSet::midi_iterator i = bufs.midi_begin(); i != bufs.midi_end(); ++i) {
MidiBuffer& mb (*i);
for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
- Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+ Evoral::Event<MidiBuffer::TimeType> ev = *m;
if (ev.is_note_on()) {
assert(ev.time() >= 0 && ev.time() < nframes);
- ev.scale_velocity (fabsf (gab[ev.time()]));
+ scale_midi_velocity (ev, fabsf (gab[ev.time()]));
}
}
}
MidiBuffer& mb (*i);
for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
- Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+ Evoral::Event<MidiBuffer::TimeType> ev = *m;
if (ev.is_note_on()) {
- ev.scale_velocity (fabsf (_current_gain));
+ scale_midi_velocity (ev, fabsf (_current_gain));
}
}
}
MidiBuffer& mb (*i);
for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
- Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+ Evoral::Event<MidiBuffer::TimeType> ev = *m;
if (ev.is_note_on()) {
const gain_t scale = delta * (ev.time()/(double) nframes);
- ev.scale_velocity (fabsf (initial+scale));
+ scale_midi_velocity (ev, fabsf (initial + scale));
}
}
}
MidiBuffer& mb (*i);
for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
- Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+ Evoral::Event<MidiBuffer::TimeType> ev = *m;
if (ev.is_note_on()) {
ev.set_velocity (0);
}
MidiBuffer& mb (*i);
for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
- Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+ Evoral::Event<MidiBuffer::TimeType> ev = *m;
if (ev.is_note_on()) {
- ev.scale_velocity (fabsf (target));
+ scale_midi_velocity(ev, fabsf (target));
}
}
}
#include "ardour/types.h"
#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT || defined MACVST_SUPPORT
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
struct _VstEvents;
typedef struct _VstEvents VstEvents;
struct _VstMidiEvent;
~VSTBuffer ();
void clear ();
- void push_back (Evoral::MIDIEvent<framepos_t> const &);
+ void push_back (Evoral::Event<framepos_t> const &);
VstEvents* events () const {
return _events;
}
void copy(const MidiBuffer& copy);
void copy(MidiBuffer const * const);
- bool push_back(const Evoral::MIDIEvent<TimeType>& event);
+ bool push_back(const Evoral::Event<TimeType>& event);
bool push_back(TimeType time, size_t size, const uint8_t* data);
uint8_t* reserve(TimeType time, size_t size);
size_t size() const { return _size; }
bool empty() const { return _size == 0; }
- bool insert_event(const Evoral::MIDIEvent<TimeType>& event);
+ bool insert_event(const Evoral::Event<TimeType>& event);
bool merge_in_place(const MidiBuffer &other);
/** EventSink interface for non-RT use (export, bounce). */
size_t offset;
};
- typedef iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> > iterator;
- typedef iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> > const_iterator;
+ typedef iterator_base< MidiBuffer, Evoral::Event<TimeType> > iterator;
+ typedef iterator_base< const MidiBuffer, const Evoral::Event<TimeType> > const_iterator;
iterator begin() { return iterator(*this, 0); }
iterator end() { return iterator(*this, _size); }
static bool second_simultaneous_midi_byte_is_first (uint8_t, uint8_t);
private:
- friend class iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> >;
- friend class iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> >;
+ friend class iterator_base< MidiBuffer, Evoral::Event<TimeType> >;
+ friend class iterator_base< const MidiBuffer, const Evoral::Event<TimeType> >;
uint8_t* _data; ///< timestamp, event, timestamp, event, ...
pframes_t _size;
necessary.
*/
if (!vec.buf[0]->owns_buffer()) {
- vec.buf[0]->set_buffer (0, 0, true);
- }
+ vec.buf[0]->set_buffer (0, 0, true);
+ }
vec.buf[0]->set (msg, msglen, timestamp);
} else {
/* see comment in previous branch of if() statement */
if (!vec.buf[1]->owns_buffer()) {
- vec.buf[1]->set_buffer (0, 0, true);
- }
+ vec.buf[1]->set_buffer (0, 0, true);
+ }
vec.buf[1]->set (msg, msglen, timestamp);
}
/* one MIDI port/buffer only */
MidiBuffer& m = bufs.get_midi (i);
for (MidiBuffer::iterator i = m.begin(); i != m.end(); ++i) {
- Evoral::MIDIEvent<framepos_t> ev (*i);
+ Evoral::Event<framepos_t> ev (*i);
if (ev.is_channel_event()) {
const uint8_t* b = ev.buffer();
DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1: MIDI event %2\n", name(), ev));
}
void
-BufferSet::VSTBuffer::push_back (Evoral::MIDIEvent<framepos_t> const & ev)
+BufferSet::VSTBuffer::push_back (Evoral::Event<framepos_t> const & ev)
{
if (ev.size() > 3) {
/* XXX: this will silently drop MIDI messages longer than 3 bytes, so
// move events from dly-buffer into current-buffer until nsamples
// and remove them from the dly-buffer
for (MidiBuffer::iterator m = dly->begin(); m != dly->end();) {
- const Evoral::MIDIEvent<MidiBuffer::TimeType> ev (*m, false);
+ const Evoral::Event<MidiBuffer::TimeType> ev (*m, false);
if (ev.time() >= nsamples) {
break;
}
// move events after nsamples from current-buffer into dly-buffer
// and trim current-buffer after nsamples
for (MidiBuffer::iterator m = mb.begin(); m != mb.end();) {
- const Evoral::MIDIEvent<MidiBuffer::TimeType> ev (*m, false);
+ const Evoral::Event<MidiBuffer::TimeType> ev (*m, false);
if (ev.time() < nsamples) {
++m;
continue;
.addFunction ("size", &Evoral::Event<framepos_t>::size)
.addFunction ("set_buffer", &Evoral::Event<framepos_t>::set_buffer)
.addFunction ("buffer", (uint8_t*(Evoral::Event<framepos_t>::*)())&Evoral::Event<framepos_t>::buffer)
- .addFunction ("time", (framepos_t (Evoral::Event<framepos_t>::*)())&Evoral::MIDIEvent<framepos_t>::time)
+ .addFunction ("time", (framepos_t (Evoral::Event<framepos_t>::*)())&Evoral::Event<framepos_t>::time)
.endClass ()
.beginClass <Evoral::Beats> ("Beats")
.addFunction ("empty", &MidiBuffer::empty)
.addFunction ("resize", &MidiBuffer::resize)
.addFunction ("copy", (void (MidiBuffer::*)(MidiBuffer const * const))&MidiBuffer::copy)
- .addFunction ("push_event", (bool (MidiBuffer::*)(const Evoral::MIDIEvent<framepos_t>&))&MidiBuffer::push_back)
+ .addFunction ("push_event", (bool (MidiBuffer::*)(const Evoral::Event<framepos_t>&))&MidiBuffer::push_back)
.addFunction ("push_back", (bool (MidiBuffer::*)(framepos_t, size_t, const uint8_t*))&MidiBuffer::push_back)
// TODO iterators..
- .addExtCFunction ("table", &luabridge::CFunc::listToTable<const Evoral::MIDIEvent<framepos_t>, MidiBuffer>)
+ .addExtCFunction ("table", &luabridge::CFunc::listToTable<const Evoral::Event<framepos_t>, MidiBuffer>)
.endClass()
.beginClass <BufferSet> ("BufferSet")
luabridge::getGlobalNamespace (L)
.beginNamespace ("Evoral")
- .deriveClass <Evoral::MIDIEvent<framepos_t>, Evoral::Event<framepos_t> > ("MidiEvent")
+ .deriveClass <Evoral::Event<framepos_t>, Evoral::Event<framepos_t> > ("MidiEvent")
// add Ctor?
- .addFunction ("type", &Evoral::MIDIEvent<framepos_t>::type)
- .addFunction ("channel", &Evoral::MIDIEvent<framepos_t>::channel)
- .addFunction ("set_type", &Evoral::MIDIEvent<framepos_t>::set_type)
- .addFunction ("set_channel", &Evoral::MIDIEvent<framepos_t>::set_channel)
+ .addFunction ("type", &Evoral::Event<framepos_t>::type)
+ .addFunction ("channel", &Evoral::Event<framepos_t>::channel)
+ .addFunction ("set_type", &Evoral::Event<framepos_t>::set_type)
+ .addFunction ("set_channel", &Evoral::Event<framepos_t>::set_channel)
.endClass ()
.endNamespace ();
if (valid) {
for (MidiBuffer::iterator m = bufs.get_midi(idx).begin();
m != bufs.get_midi(idx).end(); ++m, ++e) {
- const Evoral::MIDIEvent<framepos_t> ev(*m, false);
+ const Evoral::Event<framepos_t> ev(*m, false);
luabridge::LuaRef lua_midi_data (luabridge::newTable (L));
const uint8_t* data = ev.buffer();
for (uint32_t i = 0; i < ev.size(); ++i) {
MetricSection* metric = (metric_i != tmap.metrics_end())
? *metric_i : NULL;
if (m != m_end && (!metric || metric->frame() > (*m).time())) {
- const Evoral::MIDIEvent<framepos_t> ev(*m, false);
+ const Evoral::Event<framepos_t> ev(*m, false);
if (ev.time() < nframes) {
LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
const MidiBuffer& buf (bufs.get_midi(i));
for (MidiBuffer::const_iterator e = buf.begin(); e != buf.end(); ++e) {
- const Evoral::MIDIEvent<framepos_t> ev(*e, false);
+ const Evoral::Event<framepos_t> ev(*e, false);
if (ev.is_note_on()) {
const float this_vel = ev.buffer()[2] / 127.0;
if (this_vel > val) {
}
for (MidiBuffer::const_iterator i = msrc.begin(); i != msrc.end(); ++i) {
- const Evoral::MIDIEvent<TimeType> ev(*i, false);
+ const Evoral::Event<TimeType> ev(*i, false);
if (dst_offset >= 0) {
/* Positive offset: shifting events from internal
* @return false if operation failed (not enough room)
*/
bool
-MidiBuffer::push_back(const Evoral::MIDIEvent<TimeType>& ev)
+MidiBuffer::push_back(const Evoral::Event<TimeType>& ev)
{
return push_back (ev.time(), ev.size(), ev.buffer());
}
}
bool
-MidiBuffer::insert_event(const Evoral::MIDIEvent<TimeType>& ev)
+MidiBuffer::insert_event(const Evoral::Event<TimeType>& ev)
{
if (size() == 0) {
return push_back(ev);
uint32_t
MidiBuffer::write(TimeType time, Evoral::EventType type, uint32_t size, const uint8_t* buf)
{
- insert_event(Evoral::MIDIEvent<TimeType>(type, time, size, const_cast<uint8_t*>(buf)));
+ insert_event(Evoral::Event<TimeType>(type, time, size, const_cast<uint8_t*>(buf)));
return size;
}
MidiBuffer& buf = bufs.get_midi(0);
for (MidiBuffer::iterator e = buf.begin(); e != buf.end(); ) {
- Evoral::MIDIEvent<framepos_t> ev(*e, false);
+ Evoral::Event<framepos_t> ev(*e, false);
if (ev.is_channel_event()) {
switch (mode) {
MidiChannelFilter* filter = mt ? &mt->capture_filter() : NULL;
for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
- Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
+ Evoral::Event<MidiBuffer::TimeType> ev(*i, false);
if (ev.time() + rec_offset > rec_nframes) {
break;
}
for (Evoral::Sequence<TimeType>::const_iterator i = begin(TimeType(), true); i != end(); ++i) {
if (i->time() >= begin_time && i->time() < end_time) {
- Evoral::MIDIEvent<TimeType> mev (*i, true); /* copy the event */
+ Evoral::Event<TimeType> mev (*i, true); /* copy the event */
if (offset_events) {
mev.set_time(mev.time() - begin_time);
for (MidiBuffer::iterator i = _buffer->begin(); i != _buffer->end(); ++i) {
- const Evoral::MIDIEvent<MidiBuffer::TimeType> ev (*i, false);
+ const Evoral::Event<MidiBuffer::TimeType> ev (*i, false);
if (sends_output() && _trace_on) {
*/
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
#include "midi++/channel.h"
#include "midi++/parser.h"
#include "midi++/port.h"
for (int note = 0; note < 128; ++note) {
while (_active_notes[note + 128 * channel]) {
uint8_t buffer[3] = { ((uint8_t) (MIDI_CMD_NOTE_OFF | channel)), uint8_t (note), 0 };
- Evoral::MIDIEvent<MidiBuffer::TimeType> noteoff
+ Evoral::Event<MidiBuffer::TimeType> noteoff
(MIDI_CMD_NOTE_OFF, time, 3, buffer, false);
/* note that we do not care about failure from
push_back() ... should we warn someone ?
for (int channel = 0; channel < 16; ++channel) {
for (int note = 0; note < 128; ++note) {
while (_active_notes[note + 128 * channel]) {
- Evoral::MIDIEvent<Evoral::Beats> ev ((MIDI_CMD_NOTE_OFF|channel), time, 3, 0, true);
+ Evoral::Event<Evoral::Beats> ev ((MIDI_CMD_NOTE_OFF|channel), time, 3, 0, true);
ev.set_type (MIDI_CMD_NOTE_OFF);
ev.set_channel (channel);
ev.set_note (note);
{
const MidiBuffer& buf = bufs.get_midi(0);
for (MidiBuffer::const_iterator e = buf.begin(); e != buf.end(); ++e) {
- const Evoral::MIDIEvent<framepos_t>& ev = *e;
+ const Evoral::Event<framepos_t>& ev = *e;
const Evoral::Parameter param = midi_parameter(ev.buffer(), ev.size());
const boost::shared_ptr<Evoral::Control> control = this->control(param);
if (control) {
for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) {
- const Evoral::MIDIEvent<framepos_t> ev(*e, false);
+ const Evoral::Event<framepos_t> ev(*e, false);
/* note on, since for step edit, note length is determined
elsewhere
_model->start_write();
}
- Evoral::MIDIEvent<framepos_t> ev;
+ Evoral::Event<framepos_t> ev;
while (true) {
/* Get the event time, in frames since session start but ignoring looping. */
bool ret;
>
</File>
<File
- RelativePath="..\src\MIDIEvent.cpp"
+ RelativePath="..\src\MIDIXML.cpp"
>
</File>
<File
>
</File>
<File
- RelativePath="..\evoral\MIDIEvent.hpp"
+ RelativePath="..\evoral\MIDIXML.hpp"
>
</File>
<File
/* This file is part of Evoral.
- * Copyright (C) 2008 David Robillard <http://drobilla.net>
+ * Copyright (C) 2008-2016 David Robillard <http://drobilla.net>
* Copyright (C) 2000-2008 Paul Davis
*
* Evoral is free software; you can redistribute it and/or modify it under the
#include <sstream>
#include <stdint.h>
-#include "evoral/visibility.h"
+#include "evoral/midi_events.h"
#include "evoral/types.hpp"
+#include "evoral/visibility.h"
/** If this is not defined, all methods of MidiEvent are RT safe
* but MidiEvent will never deep copy and (depending on the scenario)
LIBEVORAL_API event_id_t event_id_counter();
LIBEVORAL_API event_id_t next_event_id();
-LIBEVORAL_API void init_event_id_counter(event_id_t n);
+LIBEVORAL_API void init_event_id_counter(event_id_t n);
/** An event (much like a type generic jack_midi_event_t)
*
class LIBEVORAL_API Event {
public:
#ifdef EVORAL_EVENT_ALLOC
- Event (EventType type=0, Time time=Time(), uint32_t size=0, uint8_t* buf=NULL, bool alloc=false);
+ Event(EventType type=0, Time time=Time(), uint32_t size=0, uint8_t* buf=NULL, bool alloc=false);
- Event (EventType type, Time time, uint32_t size, const uint8_t* buf);
+ Event(EventType type, Time time, uint32_t size, const uint8_t* buf);
/** Copy \a copy.
*
*/
Event(const Event& copy, bool alloc);
- ~Event();
+ ~Event();
- void assign (const Event& other);
+ void assign(const Event& other);
void set(const uint8_t* buf, uint32_t size, Time t);
inline bool operator==(const Event& other) const {
- if (_type != other._type)
+ if (_type != other._type ||
+ _nominal_time != other._nominal_time ||
+ _original_time != other._original_time ||
+ _size != other._size) {
return false;
-
- if (_nominal_time != other._nominal_time)
- return false;
-
- if (_original_time != other._original_time)
- return false;
-
- if (_size != other._size)
- return false;
-
- if (_buf == other._buf)
- return true;
-
- for (uint32_t i=0; i < _size; ++i)
- if (_buf[i] != other._buf[i])
- return false;
-
- return true;
+ }
+ return !memcmp(_buf, other._buf, _size);
}
inline bool operator!=(const Event& other) const { return ! operator==(other); }
_buf = NULL;
}
-#else
-
- inline void set_buffer(uint8_t* buf) { _buf = buf; }
-
#endif // EVORAL_EVENT_ALLOC
inline EventType event_type() const { return _type; }
inline event_id_t id() const { return _id; }
inline void set_id(event_id_t n) { _id = n; }
+ /* The following methods are type specific and only make sense for the
+ correct event type. It is the caller's responsibility to only call
+ methods which make sense for the given event type. Currently this means
+ they all only make sense for MIDI, but built-in support may be added for
+ other protocols in the future, or the internal representation may change
+ to be protocol agnostic. */
+
+ uint8_t type() const { return _buf[0] & 0xF0; }
+ uint8_t channel() const { return _buf[0] & 0x0F; }
+ bool is_note_on() const { return type() == MIDI_CMD_NOTE_ON; }
+ bool is_note_off() const { return type() == MIDI_CMD_NOTE_OFF; }
+ bool is_note() const { return is_note_on() || is_note_off(); }
+ bool is_poly_pressure() const { return type() == MIDI_CMD_NOTE_PRESSURE; }
+ bool is_channel_pressure() const { return type() == MIDI_CMD_CHANNEL_PRESSURE; }
+ bool is_cc() const { return type() == MIDI_CMD_CONTROL; }
+ bool is_pgm_change() const { return type() == MIDI_CMD_PGM_CHANGE; }
+ bool is_pitch_bender() const { return type() == MIDI_CMD_BENDER; }
+ bool is_channel_event() const { return (0x80 <= type()) && (type() <= 0xE0); }
+ bool is_smf_meta_event() const { return _buf[0] == 0xFF; }
+ bool is_sysex() const { return _buf[0] == 0xF0 || _buf[0] == 0xF7; }
+ bool is_spp() const { return _buf[0] == 0xF2 && size() == 1; }
+ bool is_mtc_quarter() const { return _buf[0] == 0xF1 && size() == 1; }
+ bool is_mtc_full() const { return (size() == 10 &&
+ _buf[0] == 0xF0 && _buf[1] == 0x7F &&
+ _buf[3] == 0x01 && _buf[4] == 0x01); }
+
+ uint8_t note() const { return _buf[1]; }
+ uint8_t velocity() const { return _buf[2]; }
+ uint8_t poly_note() const { return _buf[1]; }
+ uint8_t poly_pressure() const { return _buf[2]; }
+ uint8_t channel_pressure() const { return _buf[1]; }
+ uint8_t cc_number() const { return _buf[1]; }
+ uint8_t cc_value() const { return _buf[2]; }
+ uint8_t pgm_number() const { return _buf[1]; }
+ uint8_t pitch_bender_lsb() const { return _buf[1]; }
+ uint8_t pitch_bender_msb() const { return _buf[2]; }
+ uint16_t pitch_bender_value() const { return ((0x7F & _buf[2]) << 7 | (0x7F & _buf[1])); }
+
+ void set_channel(uint8_t channel) { _buf[0] = (0xF0 & _buf[0]) | (0x0F & channel); }
+ void set_type(uint8_t type) { _buf[0] = (0x0F & _buf[0]) | (0xF0 & type); }
+ void set_note(uint8_t num) { _buf[1] = num; }
+ void set_velocity(uint8_t val) { _buf[2] = val; }
+ void set_cc_number(uint8_t num) { _buf[1] = num; }
+ void set_cc_value(uint8_t val) { _buf[2] = val; }
+ void set_pgm_number(uint8_t num) { _buf[1] = num; }
+
+ uint16_t value() const {
+ switch (type()) {
+ case MIDI_CMD_CONTROL:
+ return cc_value();
+ case MIDI_CMD_BENDER:
+ return pitch_bender_value();
+ case MIDI_CMD_NOTE_PRESSURE:
+ return poly_pressure();
+ case MIDI_CMD_CHANNEL_PRESSURE:
+ return channel_pressure();
+ default:
+ return 0;
+ }
+ }
+
protected:
- EventType _type; /**< Type of event (application relative, NOT MIDI 'type') */
- Time _original_time; /**< Sample index (or beat time) at which event is valid */
- Time _nominal_time; /**< Quantized version of _time, used in preference */
- uint32_t _size; /**< Number of uint8_ts of data in \a buffer */
- uint8_t* _buf; /**< Raw MIDI data */
- event_id_t _id; /** UUID for each event, should probably be 64bit or at least unsigned */
+ EventType _type; ///< Type of event (application relative, NOT MIDI 'type')
+ Time _original_time; ///< Time stamp of event
+ Time _nominal_time; ///< Quantized version of _time, used in preference
+ uint32_t _size; ///< Size of buffer in bytes
+ uint8_t* _buf; ///< Event contents (e.g. raw MIDI data)
+ event_id_t _id; ///< Unique event ID
#ifdef EVORAL_EVENT_ALLOC
- bool _owns_buf; /**< Whether buffer is locally allocated */
+ bool _owns_buf; ///< Whether buffer is locally allocated
#endif
};
+++ /dev/null
-/* This file is part of Evoral.
- * Copyright (C) 2008 David Robillard <http://drobilla.net>
- * Copyright (C) 2000-2008 Paul Davis
- *
- * Evoral 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.
- *
- * Evoral 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 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.,
- * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef EVORAL_MIDI_EVENT_HPP
-#define EVORAL_MIDI_EVENT_HPP
-
-#include <cmath>
-#include <boost/shared_ptr.hpp>
-
-#include "evoral/visibility.h"
-#include "evoral/Event.hpp"
-#include "evoral/midi_events.h"
-
-namespace Evoral {
-
-/** MIDI helper functions for an Event.
- *
- * This class contains no data, an Evoral::Event can be cast to a MIDIEvent
- * but the application must make sure the Event actually contains
- * valid MIDI data for these functions to make sense.
- */
-template<typename Time>
-class /*LIBEVORAL_API*/ MIDIEvent : public Event<Time> {
-public:
- MIDIEvent(EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false)
- : Event<Time>(type, time, size, buf, alloc)
- {}
-
- MIDIEvent(const Event<Time>& copy, bool alloc)
- : Event<Time>(copy, alloc)
- {}
-
- inline uint8_t type() const { return (this->_buf[0] & 0xF0); }
- inline void set_type(uint8_t type) { this->_buf[0] = (0x0F & this->_buf[0])
- | (0xF0 & type); }
-
- inline uint8_t channel() const { return (this->_buf[0] & 0x0F); }
- inline void set_channel(uint8_t channel) { this->_buf[0] = (0xF0 & this->_buf[0])
- | (0x0F & channel); }
-
- inline bool is_note_on() const { return (type() == MIDI_CMD_NOTE_ON); }
- inline bool is_note_off() const { return (type() == MIDI_CMD_NOTE_OFF); }
- inline bool is_cc() const { return (type() == MIDI_CMD_CONTROL); }
- inline bool is_pitch_bender() const { return (type() == MIDI_CMD_BENDER); }
- inline bool is_pgm_change() const { return (type() == MIDI_CMD_PGM_CHANGE); }
- inline bool is_note() const { return (is_note_on() || is_note_off()); }
- inline bool is_poly_pressure() const { return (type() == MIDI_CMD_NOTE_PRESSURE); }
- inline bool is_channel_pressure() const { return (type() == MIDI_CMD_CHANNEL_PRESSURE); }
- inline uint8_t note() const { return (this->_buf[1]); }
- inline void set_note(uint8_t n) { this->_buf[1] = n; }
- inline uint8_t velocity() const { return (this->_buf[2]); }
- inline void set_velocity(uint8_t value) { this->_buf[2] = value; }
- inline void scale_velocity(float factor) {
- if (factor < 0) factor = 0;
- this->_buf[2] = (uint8_t) lrintf (this->_buf[2]*factor);
- if (this->_buf[2] > 127) this->_buf[2] = 127;
- }
- inline uint8_t cc_number() const { return (this->_buf[1]); }
- inline void set_cc_number(uint8_t number) { this->_buf[1] = number; }
- inline uint8_t cc_value() const { return (this->_buf[2]); }
- inline void set_cc_value(uint8_t value) { this->_buf[2] = value; }
- inline uint8_t pitch_bender_lsb() const { return (this->_buf[1]); }
- inline uint8_t pitch_bender_msb() const { return (this->_buf[2]); }
- inline uint16_t pitch_bender_value() const { return ( ((0x7F & this->_buf[2]) << 7)
- | (0x7F & this->_buf[1]) ); }
- inline uint8_t pgm_number() const { return (this->_buf[1]); }
- inline void set_pgm_number(uint8_t number) { this->_buf[1] = number; }
- inline uint8_t poly_note() const { return (this->_buf[1]); }
- inline uint8_t poly_pressure() const { return (this->_buf[2]); }
- inline uint8_t channel_pressure() const { return (this->_buf[1]); }
- inline bool is_channel_event() const { return (0x80 <= type()) && (type() <= 0xE0); }
- inline bool is_smf_meta_event() const { return this->_buf[0] == 0xFF; }
- inline bool is_sysex() const { return this->_buf[0] == 0xF0
- || this->_buf[0] == 0xF7; }
- inline bool is_spp() const { return this->_buf[0] == 0xF2 && this->size() == 1; }
- inline bool is_mtc_quarter() const { return this->_buf[0] == 0xF1 && this->size() == 1; }
- inline bool is_mtc_full() const {
- return this->size() == 10 && this->_buf[0] == 0xf0 && this->_buf[1] == 0x7f &&
- this->_buf[3] == 0x01 && this->_buf[4] == 0x01;
- }
-
- inline uint16_t value() const {
- switch (type()) {
- case MIDI_CMD_CONTROL:
- return cc_value();
- case MIDI_CMD_BENDER:
- return pitch_bender_value();
- case MIDI_CMD_NOTE_PRESSURE:
- return poly_pressure();
- case MIDI_CMD_CHANNEL_PRESSURE:
- return channel_pressure();
- default:
- return 0;
- }
- }
-};
-
-} // namespace Evoral
-
-#endif // EVORAL_MIDI_EVENT_HPP
#ifndef EVORAL_MIDI_XML_HPP
#define EVORAL_MIDI_XML_HPP
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
#include "pbd/xml++.h"
namespace Evoral {
template<typename Time>
bool
-xml_to_midi(const XMLNode& node, Evoral::MIDIEvent<Time>& ev)
+xml_to_midi(const XMLNode& node, Evoral::Event<Time>& ev)
{
if (node.name() == "ControlChange") {
ev.set_type(MIDI_CMD_CONTROL);
template<typename Time>
boost::shared_ptr<XMLNode>
-midi_to_xml(const Evoral::MIDIEvent<Time>& ev)
+midi_to_xml(const Evoral::Event<Time>& ev)
{
XMLNode* result = 0;
#include <stdint.h>
#include "evoral/visibility.h"
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
namespace Evoral {
private:
// Event buffers are self-contained
- MIDIEvent<Time> _on_event;
- MIDIEvent<Time> _off_event;
+ Event<Time> _on_event;
+ Event<Time> _off_event;
};
template<typename Time>
#include "evoral/visibility.h"
#include "evoral/Event.hpp"
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
namespace Evoral {
/** The PatchChange is made up of messages() MIDI messages; this method returns them by index.
* @param i index of message to return.
*/
- MIDIEvent<Time> const & message (int i) const {
+ Event<Time> const & message (int i) const {
switch (i) {
case 0:
return _bank_change_msb;
}
private:
- MIDIEvent<Time> _bank_change_msb;
- MIDIEvent<Time> _bank_change_lsb;
- MIDIEvent<Time> _program_change;
+ Event<Time> _bank_change_msb;
+ Event<Time> _bank_change_lsb;
+ Event<Time> _program_change;
};
}
bool overlaps_unlocked (const NotePtr& ev, const NotePtr& ignore_this_note) const;
bool contains_unlocked (const NotePtr& ev) const;
- void append_note_on_unlocked(const MIDIEvent<Time>& event, Evoral::event_id_t);
- void append_note_off_unlocked(const MIDIEvent<Time>& event);
+ void append_note_on_unlocked(const Event<Time>& event, Evoral::event_id_t);
+ void append_note_off_unlocked(const Event<Time>& event);
void append_control_unlocked(const Parameter& param, Time time, double value, Evoral::event_id_t);
- void append_sysex_unlocked(const MIDIEvent<Time>& ev, Evoral::event_id_t);
+ void append_sysex_unlocked(const Event<Time>& ev, Evoral::event_id_t);
void append_patch_change_unlocked(const PatchChange<Time>&, Evoral::event_id_t);
void get_notes_by_pitch (Notes&, NoteOperator, uint8_t val, int chan_mask = 0) const;
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <cassert>
#include <iostream>
#include <limits>
#include <glib.h>
assert(_event && _event->buffer() && _event->size() > 0);
- const MIDIEvent<Time>& ev = *((const MIDIEvent<Time>*)_event.get());
+ const Event<Time>& ev = *_event.get();
if (!( ev.is_note()
|| ev.is_cc()
*/
template<typename Time>
void
-Sequence<Time>::append(const Event<Time>& event, event_id_t evid)
+Sequence<Time>::append(const Event<Time>& ev, event_id_t evid)
{
WriteLock lock(write_lock());
- const MIDIEvent<Time>& ev = (const MIDIEvent<Time>&)event;
-
assert(_notes.empty() || ev.time() >= (*_notes.rbegin())->time());
assert(_writing);
template<typename Time>
void
-Sequence<Time>::append_note_on_unlocked (const MIDIEvent<Time>& ev, event_id_t evid)
+Sequence<Time>::append_note_on_unlocked (const Event<Time>& ev, event_id_t evid)
{
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n", this,
(int)ev.channel(), (int)ev.note(),
template<typename Time>
void
-Sequence<Time>::append_note_off_unlocked (const MIDIEvent<Time>& ev)
+Sequence<Time>::append_note_off_unlocked (const Event<Time>& ev)
{
DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 OFF @ %4 v=%5\n",
this, (int)ev.channel(),
template<typename Time>
void
-Sequence<Time>::append_sysex_unlocked(const MIDIEvent<Time>& ev, event_id_t /* evid */)
+Sequence<Time>::append_sysex_unlocked(const Event<Time>& ev, event_id_t /* evid */)
{
#ifdef DEBUG_SEQUENCE
cerr << this << " SysEx @ " << ev.time() << " \t= \t [ " << hex;
} cerr << "]" << endl;
#endif
- boost::shared_ptr<MIDIEvent<Time> > event(new MIDIEvent<Time>(ev, true));
+ boost::shared_ptr< Event<Time> > event(new Event<Time>(ev, true));
/* XXX sysex events should use IDs */
_sysexes.insert(event);
}
bool on = true;
for (Sequence<Time>::const_iterator i = seq->begin(Evoral::Beats(600)); i != seq->end(); ++i) {
if (on) {
- CPPUNIT_ASSERT(((const MIDIEvent<Time>&)*i).is_note_on());
+ CPPUNIT_ASSERT((*i)->is_note_on());
CPPUNIT_ASSERT_EQUAL(i->time(), Time((num_notes + 6) * 100));
++num_notes;
on = false;
} else {
- CPPUNIT_ASSERT(((const MIDIEvent<Time>&)*i).is_note_off());
+ CPPUNIT_ASSERT((*i)->is_note_off());
on = true;
}
}
#define EVORAL_EVENT_ALLOC 1
#include "evoral/Event.hpp"
-#include "evoral/MIDIEvent.hpp"
#endif /* __libmidipp_midi_event_h__ */
node->add_property("Name", _name);
/*
- typedef std::list< boost::shared_ptr< Evoral::MIDIEvent<Evoral::Beats> > > PatchMidiCommands;
+ typedef std::list< boost::shared_ptr< Evoral::Event<Evoral::Beats> > > PatchMidiCommands;
XMLNode* commands = node->add_child("PatchMIDICommands");
for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
event != _patch_midi_commands.end();
++event) {
- commands->add_child_copy(*((((Evoral::MIDIEvent&)*event)).to_xml()));
+ commands->add_child_copy(Evoral::MIDIXML::midi_to_xml(*event));
}
*/
projects / ardour.git / commitdiff