Remove redundant LV2EventBuffer class and merge with EventBuffer.

Refactor mixing from an in-place Buffer method (which doesn't work with EventBuffer) to a single function that takes an out of place destination and an array of sources.
Fix audio buffer mixing for control<->audio.


git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@2333 a436a847-0d15-0410-975c-d299462d15a1

1 files changed, 40 insertions, 39 deletions

diff --git a/src/engine/EventBuffer.hpp b/src/engine/EventBuffer.hpp
index e82585d6..c2ba555e 100644
--- a/src/engine/EventBuffer.hpp
+++ b/src/engine/EventBuffer.hpp
@@ -20,9 +20,9 @@
 
 #include "event.lv2/event.h"
 #include "event.lv2/event-helpers.h"
+#include "object.lv2/object.h"
 #include "interface/PortType.hpp"
 #include "Buffer.hpp"
-#include "LV2EventBuffer.hpp"
 
 namespace Ingen {
 
@@ -30,58 +30,59 @@ namespace Ingen {
 class EventBuffer : public Buffer {
 public:
 	EventBuffer(size_t capacity);
+	~EventBuffer();
 
-	void clear() { _buf->reset(); }
+	void*       port_data(Shared::PortType port_type)       { return _data; }
+	const void* port_data(Shared::PortType port_type) const { return _data; }
 
-	void*       port_data(Shared::PortType port_type)       { return _buf; }
-	const void* port_data(Shared::PortType port_type) const { return _buf; }
+	inline void rewind() const { lv2_event_begin(&_iter, _data); }
 
-	void rewind() const { _buf->rewind(); }
+	inline void clear() {
+		_latest_frames = 0;
+		_latest_subframes = 0;
+		_data->event_count = 0;
+		_data->size = 0;
+		rewind();
+	}
 
 	void prepare_read(Context& context);
 	void prepare_write(Context& context);
 
 	void copy(Context& context, const Buffer* src);
-	void mix(Context& contect, const Buffer* src);
-	bool merge(const EventBuffer& a, const EventBuffer& b);
-
-	bool increment() const { return _buf->increment(); }
-	bool is_valid()  const { return _buf->is_valid(); }
-
-	inline uint32_t latest_frames()    const { return _buf->latest_frames(); }
-	inline uint32_t latest_subframes() const { return _buf->latest_subframes(); }
-	inline uint32_t event_count()      const { return _buf->event_count(); }
-
-	inline bool get_event(uint32_t* frames,
-	                      uint32_t* subframes,
-	                      uint16_t* type,
-	                      uint16_t* size,
-	                      uint8_t** data) const {
-		return _buf->get_event(frames, subframes, type, size, data);
-	}
+	//void mix(Context& contect, const Buffer* src);
+	//bool merge(const EventBuffer& a, const EventBuffer& b);
 
-	LV2_Object* get_object() const {
-		return _buf->get_object();
-	}
+	inline size_t   event_count()      const { return _data->event_count; }
+	inline uint32_t capacity()         const { return _data->capacity; }
+	//inline uint32_t size()             const { return _data->size; }
+	inline uint32_t latest_frames()    const { return _latest_frames; }
+	inline uint32_t latest_subframes() const { return _latest_subframes; }
 
-	LV2_Event* get_event() const {
-		return _buf->get_event();
-	}
+	bool increment() const;
+	bool is_valid()  const;
 
-	inline bool append(uint32_t       frames,
-	                   uint32_t       subframes,
-	                   uint16_t       type,
-	                   uint16_t       size,
-	                   const uint8_t* data) {
-		return _buf->append(frames, subframes, type, size, data);
-	}
+	bool get_event(uint32_t* frames,
+	               uint32_t* subframes,
+	               uint16_t* type,
+	               uint16_t* size,
+	               uint8_t** data) const;
 
-	inline bool append(const LV2_Event_Buffer* buf) {
-		return _buf->append(buf);
-	}
+	LV2_Object* get_object() const;
+	LV2_Event*  get_event() const;
+
+	bool append(uint32_t       frames,
+	            uint32_t       subframes,
+	            uint16_t       type,
+	            uint16_t       size,
+	            const uint8_t* data);
+
+	bool append(const EventBuffer* buf);
 
 private:
-	LV2EventBuffer* _buf; ///< Contents
+	LV2_Event_Buffer*          _data;             ///< Contents
+	mutable LV2_Event_Iterator _iter;             ///< Iterator into _data
+	uint32_t                   _latest_frames;    ///< Latest time of all events (frames)
+	uint32_t                   _latest_subframes; ///< Latest time of all events (subframes)
 };