X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fmidi_buffer.h;h=cc48e28d618fa5b8ee2446a2155b4cbdfa51f618;hb=e0a83a75;hp=9c2ee466d386e3c7a908d0deb264c990465b4544;hpb=e0aaed6d65f160c328cb8b56d7c6552ee15d65e2;p=ardour.git diff --git a/libs/ardour/ardour/midi_buffer.h b/libs/ardour/ardour/midi_buffer.h index 9c2ee466d3..cc48e28d61 100644 --- a/libs/ardour/ardour/midi_buffer.h +++ b/libs/ardour/ardour/midi_buffer.h @@ -1,17 +1,17 @@ /* - Copyright (C) 2006-2009 Paul Davis - Author: Dave Robillard - + Copyright (C) 2006-2009 Paul Davis + Author: David 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,65 +20,111 @@ #ifndef __ardour_midi_buffer_h__ #define __ardour_midi_buffer_h__ +#include "evoral/EventSink.hpp" #include "evoral/midi_util.h" +#include "evoral/types.hpp" + #include "midi++/event.h" + #include "ardour/buffer.h" -#include "ardour/event_type_map.h" +#include "ardour/parameter_types.h" namespace ARDOUR { /** Buffer containing 8-bit unsigned char (MIDI) data. */ -class MidiBuffer : public Buffer +class LIBARDOUR_API MidiBuffer : public Buffer, public Evoral::EventSink { public: - typedef nframes_t TimeType; + typedef framepos_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 (framecnt_t nframes, framecnt_t offset = 0); + void read_from (const Buffer& src, framecnt_t nframes, frameoffset_t dst_offset = 0, frameoffset_t src_offset = 0); + void merge_from (const Buffer& src, framecnt_t nframes, frameoffset_t dst_offset = 0, frameoffset_t src_offset = 0); + void copy(const MidiBuffer& copy); + void copy(MidiBuffer const * const); + + bool push_back(const Evoral::Event& event); + bool push_back(TimeType time, size_t size, const uint8_t* data); - bool push_back(const Evoral::MIDIEvent& event); - bool push_back(const jack_midi_event_t& event); uint8_t* reserve(TimeType time, size_t size); void resize(size_t); + size_t size() const { return _size; } + bool empty() const { return _size == 0; } - bool merge(const MidiBuffer& a, const MidiBuffer& b); + bool insert_event(const Evoral::Event& event); bool merge_in_place(const MidiBuffer &other); - + + /** EventSink interface for non-RT use (export, bounce). */ + uint32_t write(TimeType time, Evoral::EventType type, uint32_t size, const uint8_t* buf); + template - struct iterator_base { - iterator_base(BufferType& b, size_t o) : buffer(b), offset(o) {} + class iterator_base + { + public: + iterator_base(BufferType& b, framecnt_t o) + : buffer(&b), offset(o) {} + + iterator_base(const iterator_base& o) + : buffer (o.buffer), offset(o.offset) {} + + inline iterator_base operator= (const iterator_base& o) { + if (&o != this) { + buffer = o.buffer; + offset = o.offset; + } + return *this; + } + inline EventType operator*() const { - uint8_t* ev_start = buffer._data + offset + sizeof(TimeType); + uint8_t* ev_start = buffer->_data + offset + sizeof(TimeType); + int event_size = Evoral::midi_event_size(ev_start); + assert(event_size >= 0); + return EventType(midi_parameter_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)), + return EventType(Evoral::MIDI_EVENT, + *(reinterpret_cast((uintptr_t)(buffer->_data + offset))), event_size, ev_start); } + + inline TimeType * timeptr() { + return reinterpret_cast((uintptr_t)(buffer->_data + offset)); + } + inline iterator_base& operator++() { - uint8_t* ev_start = buffer._data + offset + sizeof(TimeType); + 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); + return (buffer != other.buffer) || (offset != other.offset); + } + + inline bool operator==(const iterator_base& other) const { + return (buffer == other.buffer) && (offset == other.offset); } - BufferType& buffer; + + BufferType* buffer; size_t offset; }; - - typedef iterator_base< MidiBuffer, Evoral::MIDIEvent > iterator; - typedef iterator_base< const MidiBuffer, const Evoral::MIDIEvent > const_iterator; + + typedef iterator_base< MidiBuffer, Evoral::Event > iterator; + typedef iterator_base< const MidiBuffer, const Evoral::Event > const_iterator; iterator begin() { return iterator(*this, 0); } iterator end() { return iterator(*this, _size); } @@ -86,15 +132,56 @@ public: const_iterator begin() const { return const_iterator(*this, 0); } const_iterator end() const { return const_iterator(*this, _size); } + iterator erase(const iterator& i) { + assert (i.buffer == this); + uint8_t* ev_start = _data + i.offset + sizeof (TimeType); + int event_size = Evoral::midi_event_size (ev_start); + + if (event_size < 0) { + /* unknown size, sysex: return end() */ + return end(); + } + + size_t total_data_deleted = sizeof(TimeType) + event_size; + + if (i.offset + total_data_deleted > _size) { + _size = 0; + return end(); + } + + /* we need to avoid the temporary malloc that memmove would do, + so copy by hand. remember: this is small amounts of data ... + */ + size_t a, b; + for (a = i.offset, b = i.offset + total_data_deleted; b < _size; ++b, ++a) { + _data[a] = _data[b]; + } + + _size -= total_data_deleted; + + /* all subsequent iterators are now invalid, and the one we + * return should refer to the event we copied, which was after + * the one we just erased. + */ + + return iterator (*this, i.offset); + } + + /** + * returns true if the message with the second argument as its MIDI + * status byte should preceed the message with the first argument as + * its MIDI status byte. + */ + static bool second_simultaneous_midi_byte_is_first (uint8_t, uint8_t); + private: - friend class iterator_base< MidiBuffer, Evoral::MIDIEvent >; - friend class iterator_base< const MidiBuffer, const Evoral::MIDIEvent >; - - size_t _size; ///< Size in bytes of used portion of _data + friend class iterator_base< MidiBuffer, Evoral::Event >; + friend class iterator_base< const MidiBuffer, const Evoral::Event >; + uint8_t* _data; ///< timestamp, event, timestamp, event, ... + pframes_t _size; }; - } // namespace ARDOUR #endif // __ardour_midi_buffer_h__