1 files changed, 88 insertions, 101 deletions

diff --git a/lv2/event/event-helpers.h b/lv2/event/event-helpers.h
index 6b39235..7e3f19c 100644
--- a/lv2/event/event-helpers.h
+++ b/lv2/event/event-helpers.h
@@ -47,96 +47,87 @@ LV2_DISABLE_DEPRECATION_WARNINGS
  * Note that these functions are all static inline which basically means:
  * do not take the address of these functions. */
 
-
 /** Pad a size to 64 bits (for event sizes) */
 static inline uint16_t
 lv2_event_pad_size(uint16_t size)
 {
-	return (uint16_t)(size + 7U) & (uint16_t)(~7U);
+  return (uint16_t)(size + 7U) & (uint16_t)(~7U);
 }
 
-
 /** Initialize (empty, reset..) an existing event buffer.
  * The contents of buf are ignored entirely and overwritten, except capacity
  * which is unmodified. */
 static inline void
-lv2_event_buffer_reset(LV2_Event_Buffer*  buf,
-                       uint16_t           stamp_type,
-                       uint8_t*           data)
+lv2_event_buffer_reset(LV2_Event_Buffer* buf,
+                       uint16_t          stamp_type,
+                       uint8_t*          data)
 {
-	buf->data = data;
-	buf->header_size = sizeof(LV2_Event_Buffer);
-	buf->stamp_type = stamp_type;
-	buf->event_count = 0;
-	buf->size = 0;
+  buf->data        = data;
+  buf->header_size = sizeof(LV2_Event_Buffer);
+  buf->stamp_type  = stamp_type;
+  buf->event_count = 0;
+  buf->size        = 0;
 }
 
-
 /** Allocate a new, empty event buffer. */
 static inline LV2_Event_Buffer*
 lv2_event_buffer_new(uint32_t capacity, uint16_t stamp_type)
 {
-	const size_t      size = sizeof(LV2_Event_Buffer) + capacity;
-	LV2_Event_Buffer* buf  = (LV2_Event_Buffer*)malloc(size);
-	if (buf != NULL) {
-		buf->capacity = capacity;
-		lv2_event_buffer_reset(buf, stamp_type, (uint8_t *)(buf + 1));
-		return buf;
-	}
-	return NULL;
+  const size_t      size = sizeof(LV2_Event_Buffer) + capacity;
+  LV2_Event_Buffer* buf  = (LV2_Event_Buffer*)malloc(size);
+  if (buf != NULL) {
+    buf->capacity = capacity;
+    lv2_event_buffer_reset(buf, stamp_type, (uint8_t*)(buf + 1));
+    return buf;
+  }
+  return NULL;
 }
 
-
 /** An iterator over an LV2_Event_Buffer.
  *
  * Multiple simultaneous read iterators over a single buffer is fine,
  * but changing the buffer invalidates all iterators. */
 typedef struct {
-	LV2_Event_Buffer* buf;
-	uint32_t          offset;
+  LV2_Event_Buffer* buf;
+  uint32_t          offset;
 } LV2_Event_Iterator;
 
-
 /** Reset an iterator to point to the start of `buf`.
  * @return True if `iter` is valid, otherwise false (buffer is empty) */
 static inline bool
-lv2_event_begin(LV2_Event_Iterator* iter,
-                LV2_Event_Buffer*   buf)
+lv2_event_begin(LV2_Event_Iterator* iter, LV2_Event_Buffer* buf)
 {
-	iter->buf = buf;
-	iter->offset = 0;
-	return (buf->size > 0);
+  iter->buf    = buf;
+  iter->offset = 0;
+  return (buf->size > 0);
 }
 
-
 /** Check if `iter` is valid.
  * @return True if `iter` is valid, otherwise false (past end of buffer) */
 static inline bool
 lv2_event_is_valid(LV2_Event_Iterator* iter)
 {
-	return (iter->buf && (iter->offset < iter->buf->size));
+  return (iter->buf && (iter->offset < iter->buf->size));
 }
 
-
 /** Advance `iter` forward one event.
  * `iter` must be valid.
  * @return True if `iter` is valid, otherwise false (reached end of buffer) */
 static inline bool
 lv2_event_increment(LV2_Event_Iterator* iter)
 {
-	if (!lv2_event_is_valid(iter)) {
-		return false;
-	}
+  if (!lv2_event_is_valid(iter)) {
+    return false;
+  }
 
-	LV2_Event* const ev = (LV2_Event*)(iter->buf->data + iter->offset);
+  LV2_Event* const ev = (LV2_Event*)(iter->buf->data + iter->offset);
 
-	iter->offset += lv2_event_pad_size(
-		(uint16_t)((uint16_t)sizeof(LV2_Event) + ev->size));
+  iter->offset +=
+    lv2_event_pad_size((uint16_t)((uint16_t)sizeof(LV2_Event) + ev->size));
 
-	return true;
+  return true;
 }
 
-
 /** Dereference an event iterator (get the event currently pointed at).
  * `iter` must be valid.
  * `data` if non-NULL, will be set to point to the contents of the event
@@ -145,23 +136,21 @@ lv2_event_increment(LV2_Event_Iterator* iter)
  *         if the end of the buffer is reached (in which case `data` is
  *         also set to NULL). */
 static inline LV2_Event*
-lv2_event_get(LV2_Event_Iterator* iter,
-              uint8_t**           data)
+lv2_event_get(LV2_Event_Iterator* iter, uint8_t** data)
 {
-	if (!lv2_event_is_valid(iter)) {
-		return NULL;
-	}
+  if (!lv2_event_is_valid(iter)) {
+    return NULL;
+  }
 
-	LV2_Event* const ev = (LV2_Event*)(iter->buf->data + iter->offset);
+  LV2_Event* const ev = (LV2_Event*)(iter->buf->data + iter->offset);
 
-	if (data) {
-		*data = (uint8_t*)ev + sizeof(LV2_Event);
-	}
+  if (data) {
+    *data = (uint8_t*)ev + sizeof(LV2_Event);
+  }
 
-	return ev;
+  return ev;
 }
 
-
 /** Write an event at `iter`.
  * The event (if any) pointed to by `iter` will be overwritten, and `iter`
  * incremented to point to the following event (i.e. several calls to this
@@ -175,62 +164,60 @@ lv2_event_write(LV2_Event_Iterator* iter,
                 uint16_t            size,
                 const uint8_t*      data)
 {
-	if (!iter->buf) {
-		return false;
-	}
+  if (!iter->buf) {
+    return false;
+  }
 
-	if (iter->buf->capacity - iter->buf->size < sizeof(LV2_Event) + size) {
-		return false;
-	}
+  if (iter->buf->capacity - iter->buf->size < sizeof(LV2_Event) + size) {
+    return false;
+  }
 
-	LV2_Event* const ev = (LV2_Event*)(iter->buf->data + iter->offset);
+  LV2_Event* const ev = (LV2_Event*)(iter->buf->data + iter->offset);
 
-	ev->frames = frames;
-	ev->subframes = subframes;
-	ev->type = type;
-	ev->size = size;
-	memcpy((uint8_t*)ev + sizeof(LV2_Event), data, size);
-	++iter->buf->event_count;
+  ev->frames    = frames;
+  ev->subframes = subframes;
+  ev->type      = type;
+  ev->size      = size;
+  memcpy((uint8_t*)ev + sizeof(LV2_Event), data, size);
+  ++iter->buf->event_count;
 
-	size = lv2_event_pad_size((uint16_t)(sizeof(LV2_Event) + size));
-	iter->buf->size += size;
-	iter->offset    += size;
+  size = lv2_event_pad_size((uint16_t)(sizeof(LV2_Event) + size));
+  iter->buf->size += size;
+  iter->offset += size;
 
-	return true;
+  return true;
 }
 
-
 /** Reserve space for an event in the buffer and return a pointer to
     the memory where the caller can write the event data, or NULL if there
     is not enough room in the buffer. */
 static inline uint8_t*
 lv2_event_reserve(LV2_Event_Iterator* iter,
-                  uint32_t frames,
-                  uint32_t subframes,
-                  uint16_t type,
-                  uint16_t size)
+                  uint32_t            frames,
+                  uint32_t            subframes,
+                  uint16_t            type,
+                  uint16_t            size)
 {
-	const uint16_t total_size = (uint16_t)(sizeof(LV2_Event) + size);
-	if (iter->buf->capacity - iter->buf->size < total_size) {
-		return NULL;
-	}
+  const uint16_t total_size = (uint16_t)(sizeof(LV2_Event) + size);
+  if (iter->buf->capacity - iter->buf->size < total_size) {
+    return NULL;
+  }
 
-	LV2_Event* const ev = (LV2_Event*)(iter->buf->data + iter->offset);
+  LV2_Event* const ev = (LV2_Event*)(iter->buf->data + iter->offset);
 
-	ev->frames = frames;
-	ev->subframes = subframes;
-	ev->type = type;
-	ev->size = size;
-	++iter->buf->event_count;
+  ev->frames    = frames;
+  ev->subframes = subframes;
+  ev->type      = type;
+  ev->size      = size;
+  ++iter->buf->event_count;
 
-	const uint16_t padded_size = lv2_event_pad_size(total_size);
-	iter->buf->size += padded_size;
-	iter->offset    += padded_size;
+  const uint16_t padded_size = lv2_event_pad_size(total_size);
+  iter->buf->size += padded_size;
+  iter->offset += padded_size;
 
-	return (uint8_t*)ev + sizeof(LV2_Event);
+  return (uint8_t*)ev + sizeof(LV2_Event);
 }
 
-
 /** Write an event at `iter`.
  * The event (if any) pointed to by `iter` will be overwritten, and `iter`
  * incremented to point to the following event (i.e. several calls to this
@@ -241,28 +228,28 @@ lv2_event_write_event(LV2_Event_Iterator* iter,
                       const LV2_Event*    ev,
                       const uint8_t*      data)
 {
-	const uint16_t total_size = (uint16_t)(sizeof(LV2_Event) + ev->size);
-	if (iter->buf->capacity - iter->buf->size < total_size) {
-		return false;
-	}
+  const uint16_t total_size = (uint16_t)(sizeof(LV2_Event) + ev->size);
+  if (iter->buf->capacity - iter->buf->size < total_size) {
+    return false;
+  }
 
-	LV2_Event* const write_ev = (LV2_Event*)(iter->buf->data + iter->offset);
+  LV2_Event* const write_ev = (LV2_Event*)(iter->buf->data + iter->offset);
 
-	*write_ev = *ev;
-	memcpy((uint8_t*)write_ev + sizeof(LV2_Event), data, ev->size);
-	++iter->buf->event_count;
+  *write_ev = *ev;
+  memcpy((uint8_t*)write_ev + sizeof(LV2_Event), data, ev->size);
+  ++iter->buf->event_count;
 
-	const uint16_t padded_size = lv2_event_pad_size(total_size);
-	iter->buf->size += padded_size;
-	iter->offset    += padded_size;
+  const uint16_t padded_size = lv2_event_pad_size(total_size);
+  iter->buf->size += padded_size;
+  iter->offset += padded_size;
 
-	return true;
+  return true;
 }
 
 LV2_RESTORE_WARNINGS
 
 #ifdef __cplusplus
-}  /* extern "C" */
+} /* extern "C" */
 #endif
 
 #endif /* LV2_EVENT_HELPERS_H */