#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);
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, frameoffset_t dst_offset, frameoffset_t /* src_offset*/)
{
assert (src.type() == DataType::MIDI);
assert (&src != this);
assert (_size == 0);
}
- /* XXX use dst_offset somehow */
-
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)) {
- push_back (ev);
+ const Evoral::Event<TimeType> ev(*i, false);
+
+ if (dst_offset >= 0) {
+ /* Positive offset: shifting events from internal
+ buffer view of time (always relative to to start of
+ current possibly split cycle) to from global/port
+ view of time (always relative to start of process
+ cycle).
+
+ Check it is within range of this (split) cycle, then shift.
+ */
+ if (ev.time() >= 0 && ev.time() < nframes) {
+ push_back (ev.time() + dst_offset, ev.size(), ev.buffer());
+ } else {
+ cerr << "\t!!!! MIDI event @ " << ev.time() << " skipped, not within range 0 .. " << nframes << ": ";
+ }
} else {
- cerr << "MIDI event @ " << ev.time() << " skipped, not within range "
- << src_offset << " .. " << (nframes + src_offset) << endl;
+ /* Negative offset: shifting events from global/port
+ view of time (always relative to start of process
+ cycle) back to internal buffer view of time (always
+ relative to to start of current possibly split
+ cycle.
+
+ Shift first, then check it is within range of this
+ (split) cycle.
+ */
+ const framepos_t evtime = ev.time() + dst_offset;
+
+ if (evtime >= 0 && evtime < nframes) {
+ push_back (evtime, ev.size(), ev.buffer());
+ } else {
+ cerr << "\t!!!! MIDI event @ " << evtime << " (based on " << ev.time() << " + " << dst_offset << ") skipped, not within range 0 .. " << nframes << ": ";
+ }
}
}
}
void
-MidiBuffer::merge_from (const Buffer& src, framecnt_t /*nframes*/, framecnt_t /*dst_offset*/, framecnt_t /*src_offset*/)
+MidiBuffer::merge_from (const Buffer& src, framecnt_t /*nframes*/, frameoffset_t /*dst_offset*/, frameoffset_t /*src_offset*/)
{
const MidiBuffer* mbuf = dynamic_cast<const MidiBuffer*>(&src);
assert (mbuf);
* @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)
{
- 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
#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;
}
}
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;
}
return true;
}
-