X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fmidi_buffer.h;h=781396a598778fc6977e97c005e1840e4f2c17e5;hb=5cf1f7f3b28abd36f9390014016def94f4e1468d;hp=db02344249ff8c8f7319fb08fbaca235ee51e243;hpb=ed2beaffeef72ddce8ac628cced672851ec5668d;p=ardour.git

diff --git a/libs/ardour/ardour/midi_buffer.h b/libs/ardour/ardour/midi_buffer.h
index db02344249..781396a598 100644
--- a/libs/ardour/ardour/midi_buffer.h
+++ b/libs/ardour/ardour/midi_buffer.h
@@ -44,7 +44,6 @@ 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);
 
@@ -53,39 +52,52 @@ public:
 	bool merge_in_place(const MidiBuffer &other);
 
 	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)),
+					*((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)),
+					*((TimeType*)(buffer->_data + offset)),
 					event_size, ev_start);
 		}
 
 		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;
 	};
 
@@ -98,6 +110,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; }
 
 	/**