#endif
using namespace std;
-
-namespace ARDOUR {
+using namespace ARDOUR;
// FIXME: mirroring for MIDI buffers?
MidiBuffer::MidiBuffer(size_t capacity)
: Buffer(DataType::MIDI, capacity)
-// , _owns_data(true)
- , _events(NULL)
- , _data(NULL)
+ , _events(0)
+ , _data(0)
+// , _owns_data(false)
+{
+ if (capacity) {
+ resize (_capacity);
+ silence(_capacity);
+ }
+}
+
+MidiBuffer::~MidiBuffer()
+{
+ if (_events) {
+ free(_events);
+ }
+ if (_data) {
+ free(_data);
+ }
+}
+
+void
+MidiBuffer::resize (size_t size)
{
- assert(capacity > 0);
+ assert(size > 0);
+
+ if (size < _capacity) {
+ return;
+ }
+
+ if (_data) {
+ free (_data);
+ }
+
+ if (_events) {
+ free (_events);
+ }
_size = 0;
+ _capacity = size;
#ifdef NO_POSIX_MEMALIGN
- _events = (MidiEvent *) malloc(sizeof(MidiEvent) * capacity);
- _data = (Byte *) malloc(sizeof(Byte) * capacity * MAX_EVENT_SIZE);
+ _events = (MIDI::Event *) malloc(sizeof(MIDI::Event) * _capacity);
+ _data = (uint8_t *) malloc(sizeof(uint8_t) * _capacity * MAX_EVENT_SIZE);
#else
- posix_memalign((void**)&_events, CPU_CACHE_ALIGN, sizeof(MidiEvent) * capacity);
- posix_memalign((void**)&_data, CPU_CACHE_ALIGN, sizeof(Byte) * capacity * MAX_EVENT_SIZE);
+ posix_memalign((void**)&_events, CPU_CACHE_ALIGN, sizeof(MIDI::Event) * _capacity);
+ posix_memalign((void**)&_data, CPU_CACHE_ALIGN, sizeof(uint8_t) * _capacity * MAX_EVENT_SIZE);
#endif
assert(_data);
assert(_events);
- silence(_capacity);
}
void
assert(_capacity >= copy._capacity);
_size = 0;
- for (size_t i=0; i < copy.size(); ++i)
+ for (size_t i = 0; i < copy.size(); ++i)
push_back(copy[i]);
}
-MidiBuffer::~MidiBuffer()
-{
- free(_events);
- free(_data);
-}
-
/** Read events from @a src starting at time @a offset into the START of this buffer, for
* time direction @a nframes. Relative time, where 0 = start of buffer.
MidiBuffer::read_from(const Buffer& src, nframes_t nframes, nframes_t offset)
{
assert(src.type() == DataType::MIDI);
- const MidiBuffer& msrc = (MidiBuffer&)src;
+ assert(&src != this);
- assert(_capacity >= src.size());
+ const MidiBuffer& msrc = (MidiBuffer&)src;
+
+ assert(_capacity >= msrc.size());
clear();
assert(_size == 0);
-
+
// FIXME: slow
- for (size_t i=0; i < src.size(); ++i) {
- const MidiEvent& ev = msrc[i];
- if (ev.time >= offset && ev.time < offset+nframes) {
- //cerr << "MidiBuffer::read_from got event, " << ev.time << endl;
+ for (size_t i=0; i < msrc.size(); ++i) {
+ const MIDI::Event& ev = msrc[i];
+ if (ev.time() >= offset && ev.time() < offset+nframes) {
+ //cout << "MidiBuffer::read_from got event, " << int(ev.type()) << " time: " << ev.time() << " buffer size: " << _size << endl;
push_back(ev);
} else {
- //cerr << "MidiBuffer event out of range, " << ev.time << endl;
+ cerr << "MidiBuffer event out of range, " << ev.time() << endl;
}
}
* @return false if operation failed (not enough room)
*/
bool
-MidiBuffer::push_back(const MidiEvent& ev)
+MidiBuffer::push_back(const MIDI::Event& ev)
{
if (_size == _capacity)
return false;
- Byte* const write_loc = _data + (_size * MAX_EVENT_SIZE);
+ uint8_t* const write_loc = _data + (_size * MAX_EVENT_SIZE);
- memcpy(write_loc, ev.buffer, ev.size);
+ memcpy(write_loc, ev.buffer(), ev.size());
_events[_size] = ev;
- _events[_size].buffer = write_loc;
+ _events[_size].set_buffer(ev.size(), write_loc, false);
++_size;
//cerr << "MidiBuffer: pushed, size = " << _size << endl;
if (_size == _capacity)
return false;
- Byte* const write_loc = _data + (_size * MAX_EVENT_SIZE);
+ uint8_t* const write_loc = _data + (_size * MAX_EVENT_SIZE);
memcpy(write_loc, ev.buffer, ev.size);
- _events[_size].time = (double)ev.time;
- _events[_size].size = ev.size;
- _events[_size].buffer = write_loc;
+ _events[_size].time() = (double)ev.time;
+ _events[_size].set_buffer(ev.size, write_loc, false);
++_size;
//cerr << "MidiBuffer: pushed, size = " << _size << endl;
/** Reserve space for a new event in the buffer.
*
* This call is for copying MIDI directly into the buffer, the data location
- * (of sufficient size to write \a size bytes) is returned, or NULL on failure.
+ * (of sufficient size to write \a size bytes) is returned, or 0 on failure.
* This call MUST be immediately followed by a write to the returned data
* location, or the buffer will be corrupted and very nasty things will happen.
*/
-Byte*
+uint8_t*
MidiBuffer::reserve(double time, size_t size)
{
- assert(size <= MAX_EVENT_SIZE);
+ if (size > MAX_EVENT_SIZE) {
+ cerr << "WARNING: Failed to reserve " << size << " bytes for event";
+ return 0;
+ }
if (_size == _capacity)
- return NULL;
+ return 0;
- Byte* const write_loc = _data + (_size * MAX_EVENT_SIZE);
+ uint8_t* const write_loc = _data + (_size * MAX_EVENT_SIZE);
- _events[_size].time = time;
- _events[_size].size = size;
- _events[_size].buffer = write_loc;
+ _events[_size].time() = time;
+ _events[_size].set_buffer(size, write_loc, false);
++_size;
//cerr << "MidiBuffer: reserved, size = " << _size << endl;
MidiBuffer::silence(nframes_t dur, nframes_t offset)
{
// FIXME use parameters
- assert(offset == 0);
- //assert(dur == _capacity);
+ if (offset != 0)
+ cerr << "WARNING: MidiBuffer::silence w/ offset != 0 (not implemented)" << endl;
- memset(_events, 0, sizeof(MidiEvent) * _capacity);
- memset(_data, 0, sizeof(Byte) * _capacity * MAX_EVENT_SIZE);
+ memset(_events, 0, sizeof(MIDI::Event) * _capacity);
+ memset(_data, 0, sizeof(uint8_t) * _capacity * MAX_EVENT_SIZE);
_size = 0;
_silent = true;
}
push_back(b[b_index]);
++b_index;
} else {
- const MidiEvent& a_ev = a[a_index];
- const MidiEvent& b_ev = b[b_index];
+ const MIDI::Event& a_ev = a[a_index];
+ const MIDI::Event& b_ev = b[b_index];
- if (a_ev.time <= b_ev.time) {
+ if (a_ev.time() <= b_ev.time()) {
push_back(a_ev);
++a_index;
} else {
return true;
}
-
-} // namespace ARDOUR
-