X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fmidi_buffer.h;h=8593a4ebb2ad778ce0ccfe7987e01f7383c6f1c5;hb=71a90399fe8561310b848fbfb8d28a65a395a6c1;hp=611e890304c1d8a0147e67d58c24af588bb49e22;hpb=8480cf69ce693e7effeb677d791fbe1d5ea004cb;p=ardour.git

diff --git a/libs/ardour/ardour/midi_buffer.h b/libs/ardour/ardour/midi_buffer.h
index 611e890304..8593a4ebb2 100644
--- a/libs/ardour/ardour/midi_buffer.h
+++ b/libs/ardour/ardour/midi_buffer.h
@@ -21,15 +21,18 @@
 #define __ardour_midi_buffer_h__
 
 #include "evoral/midi_util.h"
+#include "evoral/EventSink.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<framepos_t>
 {
 public:
 	typedef framepos_t TimeType;
@@ -44,49 +47,77 @@ public:
 	void copy(const MidiBuffer& copy);
 
 	bool     push_back(const Evoral::MIDIEvent<TimeType>& 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);
+	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::MIDIEvent<TimeType>& 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<typename BufferType, typename EventType>
-	struct iterator_base {
-		iterator_base<BufferType, EventType>(BufferType& b, framecnt_t o) : buffer(b), offset(o) {}
+		class iterator_base
+	{
+	public:
+		iterator_base<BufferType, EventType>(BufferType& b, framecnt_t o)
+			: buffer(&b), offset(o) {}
+
+		iterator_base<BufferType, EventType>(const iterator_base<BufferType,EventType>& o)
+			: buffer (o.buffer), offset(o.offset) {}
+
+		inline iterator_base<BufferType,EventType> operator= (const iterator_base<BufferType,EventType>& 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(EventTypeMap::instance().midi_event_type(*ev_start),
-					*((TimeType*)(buffer._data + offset)),
+			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);
+			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(midi_parameter_type(*ev_start),
+					*(reinterpret_cast<TimeType*>((uintptr_t)(buffer->_data + offset))),
 					event_size, ev_start);
 		}
 
+		inline TimeType * timeptr() {
+			return reinterpret_cast<TimeType*>((uintptr_t)(buffer->_data + offset));
+		}
+
 		inline iterator_base<BufferType, EventType>& 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<BufferType, EventType>& other) const {
-			return (&buffer != &other.buffer) || (offset != other.offset);
+			return (buffer != other.buffer) || (offset != other.offset);
 		}
+
 		inline bool operator==(const iterator_base<BufferType, EventType>& other) const {
-			return (&buffer == &other.buffer) && (offset == other.offset);
+			return (buffer == other.buffer) && (offset == other.offset);
 		}
-		BufferType&     buffer;
+
+		BufferType*     buffer;
 		size_t          offset;
 	};
 
@@ -99,6 +130,41 @@ 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);
+	}
+
 	uint8_t* data() const { return _data; }
 
 	/**
@@ -107,15 +173,15 @@ public:
 	 * its MIDI status byte.
 	 */
 	static bool second_simultaneous_midi_byte_is_first (uint8_t, uint8_t);
-	
+
 private:
 	friend class iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> >;
 	friend class iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> >;
 
 	uint8_t* _data; ///< timestamp, event, timestamp, event, ...
+	pframes_t _size;
 };
 
-
 } // namespace ARDOUR
 
 #endif // __ardour_midi_buffer_h__