X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fmidi_buffer.h;h=b3ed093df75b592c803b59e6aaff24bd342612dc;hb=2a6dcddcc513fa3ebc1aad4b2e5fede62277aba5;hp=2ba6a0990b116dadac1c9b49121794317e6e3ec7;hpb=6e167cb1a835cb0b44990cc4c2b2a47db9dd2b9e;p=ardour.git diff --git a/libs/ardour/ardour/midi_buffer.h b/libs/ardour/ardour/midi_buffer.h index 2ba6a0990b..b3ed093df7 100644 --- a/libs/ardour/ardour/midi_buffer.h +++ b/libs/ardour/ardour/midi_buffer.h @@ -1,17 +1,17 @@ /* - Copyright (C) 2006 Paul Davis + Copyright (C) 2006-2009 Paul Davis Author: Dave 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. @@ -20,8 +20,10 @@ #ifndef __ardour_midi_buffer_h__ #define __ardour_midi_buffer_h__ -#include -#include +#include "evoral/midi_util.h" +#include "midi++/event.h" +#include "ardour/buffer.h" +#include "ardour/event_type_map.h" namespace ARDOUR { @@ -30,43 +32,64 @@ namespace ARDOUR { class MidiBuffer : public Buffer { public: + typedef nframes_t TimeType; + MidiBuffer(size_t capacity); ~MidiBuffer(); - void silence(nframes_t dur, nframes_t offset=0); - - void read_from(const Buffer& src, nframes_t nframes, nframes_t offset); - + void silence (nframes_t nframes, nframes_t offset = 0); + void read_from (const Buffer& src, nframes_t nframes, nframes_t dst_offset = 0, nframes_t src_offset = 0); + void merge_from (const Buffer& src, nframes_t nframes, nframes_t dst_offset = 0, nframes_t src_offset = 0); + void copy(const MidiBuffer& copy); - bool push_back(const ARDOUR::MidiEvent& event); - bool push_back(const jack_midi_event_t& event); - Byte* reserve(double time, size_t size); - + bool push_back(const Evoral::MIDIEvent& event); + bool push_back(const jack_midi_event_t& event); + bool push_back(TimeType time, size_t size, const uint8_t* data); + uint8_t* reserve(TimeType time, size_t size); + + void resize(size_t); + bool merge(const MidiBuffer& a, const MidiBuffer& b); - - struct iterator { - iterator(MidiBuffer& b, size_t i) : buffer(b), index(i) {} - - inline MidiEvent& operator*() const { return buffer[index]; } - inline iterator& operator++() { ++index; return *this; } // prefix - inline bool operator!=(const iterator& other) const { return index != other.index; } - - MidiBuffer& buffer; - size_t index; - }; - - struct const_iterator { - const_iterator(const MidiBuffer& b, size_t i) : buffer(b), index(i) {} - - inline const MidiEvent& operator*() const { return buffer[index]; } - inline const_iterator& operator++() { ++index; return *this; } // prefix - inline bool operator!=(const const_iterator& other) const { return index != other.index; } - - const MidiBuffer& buffer; - size_t index; + bool merge_in_place(const MidiBuffer &other); + + template + struct iterator_base { + iterator_base(BufferType& b, nframes_t o) : buffer(b), offset(o) {} + inline EventType operator*() const { + uint8_t* ev_start = buffer._data + offset + sizeof(TimeType); + int event_size = Evoral::midi_event_size(ev_start); + assert(event_size >= 0); + return EventType(EventTypeMap::instance().midi_event_type(*ev_start), + *((TimeType*)(buffer._data + offset)), + event_size, ev_start); + } + inline EventType operator*() { + uint8_t* ev_start = buffer._data + offset + sizeof(TimeType); + int event_size = Evoral::midi_event_size(ev_start); + assert(event_size >= 0); + return EventType(EventTypeMap::instance().midi_event_type(*ev_start), + *((TimeType*)(buffer._data + offset)), + event_size, ev_start); + } + + inline iterator_base& operator++() { + uint8_t* ev_start = buffer._data + offset + sizeof(TimeType); + int event_size = Evoral::midi_event_size(ev_start); + assert(event_size >= 0); + offset += sizeof(TimeType) + event_size; + return *this; + } + inline bool operator!=(const iterator_base& other) const { + return (&buffer != &other.buffer) || (offset != other.offset); + } + BufferType& buffer; + size_t offset; }; + typedef iterator_base< MidiBuffer, Evoral::MIDIEvent > iterator; + typedef iterator_base< const MidiBuffer, const Evoral::MIDIEvent > const_iterator; + iterator begin() { return iterator(*this, 0); } iterator end() { return iterator(*this, _size); } @@ -74,24 +97,10 @@ public: const_iterator end() const { return const_iterator(*this, _size); } private: + friend class iterator_base< MidiBuffer, Evoral::MIDIEvent >; + friend class iterator_base< const MidiBuffer, const Evoral::MIDIEvent >; - friend class iterator; - friend class const_iterator; - - const MidiEvent& operator[](size_t i) const { assert(i < _size); return _events[i]; } - MidiEvent& operator[](size_t i) { assert(i < _size); return _events[i]; } - - // FIXME: Eliminate this - static const size_t MAX_EVENT_SIZE = 4; // bytes - - /* We use _size as "number of events", so the size of _data is - * (_size * MAX_EVENT_SIZE) - */ - - /* FIXME: this is utter crap. rewrite as a flat/packed buffer like MidiRingBuffer */ - - MidiEvent* _events; ///< Event structs that point to offsets in _data - Byte* _data; ///< MIDI, straight up. No time stamps. + uint8_t* _data; ///< timestamp, event, timestamp, event, ... };