#include "ardour/debug.h"
#include "ardour/midi_buffer.h"
+#include "ardour/port.h"
using namespace std;
using namespace ARDOUR;
MidiBuffer::MidiBuffer(size_t capacity)
: Buffer (DataType::MIDI)
, _data (0)
+ , _size (0)
{
if (capacity) {
resize (capacity);
MidiBuffer::~MidiBuffer()
{
- free(_data);
+ cache_aligned_free(_data);
}
void
return;
}
- free (_data);
+ cache_aligned_free (_data);
cache_aligned_malloc ((void**) &_data, size);
memcpy(_data, copy._data, copy._size);
}
+void
+MidiBuffer::copy(MidiBuffer const * const copy)
+{
+ assert(_capacity >= copy->size ());
+ _size = copy->size ();
+ memcpy(_data, copy->data(), _size);
+}
+
/** Read events from @a src starting at time @a offset into the START of this buffer, for
* time duration @a nframes. Relative time, where 0 = start of buffer.
* Note that offset and nframes refer to sample time, NOT buffer offsets or event counts.
*/
void
-MidiBuffer::read_from (const Buffer& src, framecnt_t nframes, framecnt_t dst_offset, framecnt_t src_offset)
+MidiBuffer::read_from (const Buffer& src, framecnt_t nframes, framecnt_t dst_offset, framecnt_t /* src_offset*/)
{
assert (src.type() == DataType::MIDI);
assert (&src != this);
assert (_size == 0);
}
- /* XXX use dst_offset somehow */
+ framecnt_t offset = Port::port_offset();
for (MidiBuffer::const_iterator i = msrc.begin(); i != msrc.end(); ++i) {
const Evoral::MIDIEvent<TimeType> ev(*i, false);
- if (ev.time() >= src_offset && ev.time() < (nframes+src_offset)) {
+ if (ev.time() >= offset && ev.time() < (nframes + offset)) {
push_back (ev);
} else {
cerr << "MIDI event @ " << ev.time() << " skipped, not within range "
- << src_offset << " .. " << (nframes + src_offset) << endl;
+ << offset << " .. " << (nframes + offset) << ":";
+ for (size_t xx = 0; xx < ev.size(); ++xx) {
+ cerr << ' ' << hex << (int) ev.buffer()[xx];
+ }
+ cerr << dec << endl;
}
}
bool
MidiBuffer::push_back(const Evoral::MIDIEvent<TimeType>& ev)
{
- const size_t stamp_size = sizeof(TimeType);
-
- if (_size + stamp_size + ev.size() >= _capacity) {
- cerr << "MidiBuffer::push_back failed (buffer is full)" << endl;
- PBD::stacktrace (cerr, 20);
- return false;
- }
-
- if (!Evoral::midi_event_is_valid(ev.buffer(), ev.size())) {
- cerr << "WARNING: MidiBuffer ignoring illegal MIDI event" << endl;
- return false;
- }
-
- push_back(ev.time(), ev.size(), ev.buffer());
-
- return true;
+ return push_back (ev.time(), ev.size(), ev.buffer());
}
-/** Push an event into the buffer.
+/** Push MIDI data into the buffer.
+ *
+ * Note that the raw MIDI pointed to by @param data will be COPIED and unmodified.
+ * That is, the caller still owns it, if it needs freeing it's Not My Problem(TM).
+ * Realtime safe.
* @return false if operation failed (not enough room)
*/
bool
const size_t stamp_size = sizeof(TimeType);
#ifndef NDEBUG
- if (DEBUG::MidiIO & PBD::debug_bits) {
+ if (DEBUG_ENABLED(DEBUG::MidiIO)) {
DEBUG_STR_DECL(a);
DEBUG_STR_APPEND(a, string_compose ("midibuffer %1 push event @ %2 sz %3 ", this, time, size));
for (size_t i=0; i < size; ++i) {
#endif
if (_size + stamp_size + size >= _capacity) {
- cerr << "MidiBuffer::push_back2 failed (buffer is full; _size = " << _size << " capacity "
- << _capacity << " stamp " << stamp_size << " size = " << size << ")" << endl;
- PBD::stacktrace (cerr, 20);
return false;
}
if (!Evoral::midi_event_is_valid(data, size)) {
- cerr << "WARNING: MidiBuffer ignoring illegal MIDI event" << endl;
return false;
}
uint8_t* const write_loc = _data + _size;
- *((TimeType*)write_loc) = time;
+ *(reinterpret_cast<TimeType*>((uintptr_t)write_loc)) = time;
memcpy(write_loc + stamp_size, data, size);
_size += stamp_size + size;
return true;
}
+bool
+MidiBuffer::insert_event(const Evoral::MIDIEvent<TimeType>& ev)
+{
+ if (size() == 0) {
+ return push_back(ev);
+ }
+
+ const size_t stamp_size = sizeof(TimeType);
+ const size_t bytes_to_merge = stamp_size + ev.size();
+
+ if (_size + bytes_to_merge >= _capacity) {
+ cerr << "MidiBuffer::push_back failed (buffer is full)" << endl;
+ PBD::stacktrace (cerr, 20);
+ return false;
+ }
+
+ TimeType t = ev.time();
+
+ ssize_t insert_offset = -1;
+ for (MidiBuffer::iterator m = begin(); m != end(); ++m) {
+ if ((*m).time() < t) {
+ continue;
+ }
+ if ((*m).time() == t) {
+ const uint8_t our_midi_status_byte = *(_data + m.offset + sizeof (TimeType));
+ if (second_simultaneous_midi_byte_is_first (ev.type(), our_midi_status_byte)) {
+ continue;
+ }
+ }
+ insert_offset = m.offset;
+ break;
+ }
+ if (insert_offset == -1) {
+ return push_back(ev);
+ }
+
+ // don't use memmove - it may use malloc(!)
+ // memmove (_data + insert_offset + bytes_to_merge, _data + insert_offset, _size - insert_offset);
+ for (ssize_t a = _size + bytes_to_merge - 1, b = _size - 1; b >= insert_offset; --b, --a) {
+ _data[a] = _data[b];
+ }
+
+ uint8_t* const write_loc = _data + insert_offset;
+ *(reinterpret_cast<TimeType*>((uintptr_t)write_loc)) = t;
+ memcpy(write_loc + stamp_size, ev.buffer(), ev.size());
+
+ _size += bytes_to_merge;
+
+ return true;
+}
+
+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)));
+ return size;
+}
+
/** Reserve space for a new event in the buffer.
*
* This call is for copying MIDI directly into the buffer, the data location
// write timestamp
uint8_t* write_loc = _data + _size;
- *((TimeType*)write_loc) = time;
+ *(reinterpret_cast<TimeType*>((uintptr_t)write_loc)) = time;
// move write_loc to begin of MIDI buffer data to write to
write_loc += stamp_size;
/* two events at identical times. we need to determine
the order in which they should occur.
-
+
the rule is:
-
+
Controller messages
Program Change
Note Off
Channel Pressure
Pitch Bend
*/
-
+
if ((a) >= 0xf0 || (b) >= 0xf0 || ((a & 0xf) != (b & 0xf))) {
-
+
/* if either message is not a channel message, or if the channels are
* different, we don't care about the type.
*/
-
+
b_first = true;
-
+
} else {
-
+
switch (b & 0xf0) {
case MIDI_CMD_CONTROL:
b_first = true;
break;
-
+
case MIDI_CMD_PGM_CHANGE:
switch (a & 0xf0) {
case MIDI_CMD_CONTROL:
b_first = true;
}
break;
-
+
case MIDI_CMD_NOTE_OFF:
switch (a & 0xf0) {
case MIDI_CMD_CONTROL:
b_first = true;
}
break;
-
+
case MIDI_CMD_NOTE_ON:
switch (a & 0xf0) {
case MIDI_CMD_CONTROL:
b_first = true;
}
break;
-
+
case MIDI_CMD_CHANNEL_PRESSURE:
switch (a & 0xf0) {
case MIDI_CMD_CONTROL:
break;
}
}
-
+
return b_first;
}
-
+
/** Merge \a other into this buffer. Realtime safe. */
bool
MidiBuffer::merge_in_place (const MidiBuffer &other)
* if "sz" is non-zero, there is data to be merged from "other"
* into this buffer before we do anything else, corresponding
* to the events from "other" that we skipped while advancing
- * "them".
+ * "them".
*/
if (bytes_to_merge) {
memcpy (_data + us.offset, other._data + merge_offset, bytes_to_merge);
/* update iterator to our own events. this is a miserable hack */
us.offset += bytes_to_merge;
- }
+ }
/* if we're at the end of the other buffer, we're done */
if ((*us).time() == (*them).time()) {
- DEBUG_TRACE (DEBUG::MidiIO,
+ DEBUG_TRACE (DEBUG::MidiIO,
string_compose ("simultaneous MIDI events discovered during merge, times %1/%2 status %3/%4\n",
(*us).time(), (*them).time(),
(int) *(_data + us.offset + sizeof (TimeType)),
(int) *(other._data + them.offset + sizeof (TimeType))));
-
+
uint8_t our_midi_status_byte = *(_data + us.offset + sizeof (TimeType));
uint8_t their_midi_status_byte = *(other._data + them.offset + sizeof (TimeType));
bool them_first = second_simultaneous_midi_byte_is_first (our_midi_status_byte, their_midi_status_byte);
-
+
DEBUG_TRACE (DEBUG::MidiIO, string_compose ("other message came first ? %1\n", them_first));
-
+
if (!them_first) {
/* skip past our own event */
++us;
}
-
+
bytes_to_merge = sizeof (TimeType) + (*them).size();
-
+
/* move our remaining events later in the buffer by
* enough to fit the one message we're going to merge
*/
if (them_first) {
/* need to skip the event pointed to by 'us'
since its at the same time as 'them'
- (still), and we'll enter
+ (still), and we'll enter
*/
if (us != end()) {
++them;
} else {
-
+
/* advance past our own events to get to the correct insertion
point for the next event(s) from "other"
*/
-
+
while (us != end() && (*us).time() <= (*them).time()) {
++us;
}
if (us == end()) {
/* just append the rest of other and we're done*/
-
+
memcpy (_data + us.offset, other._data + them.offset, other._size - them.offset);
_size += other._size - them.offset;
assert(_size <= _capacity);
break;
- }
+ }
}
return true;
projects / ardour.git / blobdiff