aboutsummaryrefslogtreecommitdiffstats
path: root/lv2/event
diff options
context:
space:
mode:
Diffstat (limited to 'lv2/event')
-rw-r--r--lv2/event/event-helpers.h189
-rw-r--r--lv2/event/event.h349
2 files changed, 261 insertions, 277 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 */
diff --git a/lv2/event/event.h b/lv2/event/event.h
index ff91e3b..a0afd6c 100644
--- a/lv2/event/event.h
+++ b/lv2/event/event.h
@@ -47,7 +47,7 @@
// clang-format on
-#define LV2_EVENT_AUDIO_STAMP 0 ///< Special timestamp type for audio frames
+#define LV2_EVENT_AUDIO_STAMP 0 ///< Special timestamp type for audio frames
#include "lv2/core/attributes.h"
@@ -82,49 +82,48 @@ static const uint32_t LV2_EVENT_PPQN = 3136573440U;
*/
LV2_DEPRECATED
typedef struct {
- /**
- The frames portion of timestamp. The units used here can optionally be
- set for a port (with the lv2ev:timeUnits property), otherwise this is
- audio frames, corresponding to the sample_count parameter of the LV2 run
- method (frame 0 is the first frame for that call to run).
- */
- uint32_t frames;
-
- /**
- The sub-frames portion of timestamp. The units used here can optionally
- be set for a port (with the lv2ev:timeUnits property), otherwise this is
- 1/(2^32) of an audio frame.
- */
- uint32_t subframes;
-
- /**
- The type of this event, as a number which represents some URI
- defining an event type. This value MUST be some value previously
- returned from a call to the uri_to_id function defined in the LV2
- URI map extension (see lv2_uri_map.h).
- There are special rules which must be followed depending on the type
- of an event. If the plugin recognizes an event type, the definition
- of that event type will describe how to interpret the event, and
- any required behaviour. Otherwise, if the type is 0, this event is a
- non-POD event and lv2_event_unref MUST be called if the event is
- 'dropped' (see above). Even if the plugin does not understand an event,
- it may pass the event through to an output by simply copying (and NOT
- calling lv2_event_unref). These rules are designed to allow for generic
- event handling plugins and large non-POD events, but with minimal hassle
- on simple plugins that "don't care" about these more advanced features.
- */
- uint16_t type;
-
- /**
- The size of the data portion of this event in bytes, which immediately
- follows. The header size (12 bytes) is not included in this value.
- */
- uint16_t size;
-
- /* size bytes of data follow here */
+ /**
+ The frames portion of timestamp. The units used here can optionally be
+ set for a port (with the lv2ev:timeUnits property), otherwise this is
+ audio frames, corresponding to the sample_count parameter of the LV2 run
+ method (frame 0 is the first frame for that call to run).
+ */
+ uint32_t frames;
+
+ /**
+ The sub-frames portion of timestamp. The units used here can optionally
+ be set for a port (with the lv2ev:timeUnits property), otherwise this is
+ 1/(2^32) of an audio frame.
+ */
+ uint32_t subframes;
+
+ /**
+ The type of this event, as a number which represents some URI
+ defining an event type. This value MUST be some value previously
+ returned from a call to the uri_to_id function defined in the LV2
+ URI map extension (see lv2_uri_map.h).
+ There are special rules which must be followed depending on the type
+ of an event. If the plugin recognizes an event type, the definition
+ of that event type will describe how to interpret the event, and
+ any required behaviour. Otherwise, if the type is 0, this event is a
+ non-POD event and lv2_event_unref MUST be called if the event is
+ 'dropped' (see above). Even if the plugin does not understand an event,
+ it may pass the event through to an output by simply copying (and NOT
+ calling lv2_event_unref). These rules are designed to allow for generic
+ event handling plugins and large non-POD events, but with minimal hassle
+ on simple plugins that "don't care" about these more advanced features.
+ */
+ uint16_t type;
+
+ /**
+ The size of the data portion of this event in bytes, which immediately
+ follows. The header size (12 bytes) is not included in this value.
+ */
+ uint16_t size;
+
+ /* size bytes of data follow here */
} LV2_Event;
-
/**
A buffer of LV2 events (header only).
@@ -143,92 +142,90 @@ typedef struct {
*/
LV2_DEPRECATED
typedef struct {
- /**
- The contents of the event buffer. This may or may not reside in the
- same block of memory as this header, plugins must not assume either.
- The host guarantees this points to at least capacity bytes of allocated
- memory (though only size bytes of that are valid events).
- */
- uint8_t* data;
-
- /**
- The size of this event header in bytes (including everything).
-
- This is to allow for extending this header in the future without
- breaking binary compatibility. Whenever this header is copied,
- it MUST be done using this field (and NOT the sizeof this struct).
- */
- uint16_t header_size;
-
- /**
- The type of the time stamps for events in this buffer.
- As a special exception, '0' always means audio frames and subframes
- (1/UINT32_MAX'th of a frame) in the sample rate passed to instantiate.
-
- INPUTS: The host must set this field to the numeric ID of some URI
- defining the meaning of the frames/subframes fields of contained events
- (obtained by the LV2 URI Map uri_to_id function with the URI of this
- extension as the 'map' argument, see lv2_uri_map.h). The host must
- never pass a plugin a buffer which uses a stamp type the plugin does not
- 'understand'. The value of this field must never change, except when
- connect_port is called on the input port, at which time the host MUST
- have set the stamp_type field to the value that will be used for all
- subsequent run calls.
-
- OUTPUTS: The plugin may set this to any value that has been returned
- from uri_to_id with the URI of this extension for a 'map' argument.
- When connected to a buffer with connect_port, output ports MUST set this
- field to the type of time stamp they will be writing. On any call to
- connect_port on an event input port, the plugin may change this field on
- any output port, it is the responsibility of the host to check if any of
- these values have changed and act accordingly.
- */
- uint16_t stamp_type;
-
- /**
- The number of events in this buffer.
-
- INPUTS: The host must set this field to the number of events contained
- in the data buffer before calling run(). The plugin must not change
- this field.
-
- OUTPUTS: The plugin must set this field to the number of events it has
- written to the buffer before returning from run(). Any initial value
- should be ignored by the plugin.
- */
- uint32_t event_count;
-
- /**
- The size of the data buffer in bytes.
- This is set by the host and must not be changed by the plugin.
- The host is allowed to change this between run() calls.
- */
- uint32_t capacity;
-
- /**
- The size of the initial portion of the data buffer containing data.
-
- INPUTS: The host must set this field to the number of bytes used
- by all events it has written to the buffer (including headers)
- before calling the plugin's run().
- The plugin must not change this field.
-
- OUTPUTS: The plugin must set this field to the number of bytes
- used by all events it has written to the buffer (including headers)
- before returning from run().
- Any initial value should be ignored by the plugin.
- */
- uint32_t size;
+ /**
+ The contents of the event buffer. This may or may not reside in the
+ same block of memory as this header, plugins must not assume either.
+ The host guarantees this points to at least capacity bytes of allocated
+ memory (though only size bytes of that are valid events).
+ */
+ uint8_t* data;
+
+ /**
+ The size of this event header in bytes (including everything).
+
+ This is to allow for extending this header in the future without
+ breaking binary compatibility. Whenever this header is copied,
+ it MUST be done using this field (and NOT the sizeof this struct).
+ */
+ uint16_t header_size;
+
+ /**
+ The type of the time stamps for events in this buffer.
+ As a special exception, '0' always means audio frames and subframes
+ (1/UINT32_MAX'th of a frame) in the sample rate passed to instantiate.
+
+ INPUTS: The host must set this field to the numeric ID of some URI
+ defining the meaning of the frames/subframes fields of contained events
+ (obtained by the LV2 URI Map uri_to_id function with the URI of this
+ extension as the 'map' argument, see lv2_uri_map.h). The host must
+ never pass a plugin a buffer which uses a stamp type the plugin does not
+ 'understand'. The value of this field must never change, except when
+ connect_port is called on the input port, at which time the host MUST
+ have set the stamp_type field to the value that will be used for all
+ subsequent run calls.
+
+ OUTPUTS: The plugin may set this to any value that has been returned
+ from uri_to_id with the URI of this extension for a 'map' argument.
+ When connected to a buffer with connect_port, output ports MUST set this
+ field to the type of time stamp they will be writing. On any call to
+ connect_port on an event input port, the plugin may change this field on
+ any output port, it is the responsibility of the host to check if any of
+ these values have changed and act accordingly.
+ */
+ uint16_t stamp_type;
+
+ /**
+ The number of events in this buffer.
+
+ INPUTS: The host must set this field to the number of events contained
+ in the data buffer before calling run(). The plugin must not change
+ this field.
+
+ OUTPUTS: The plugin must set this field to the number of events it has
+ written to the buffer before returning from run(). Any initial value
+ should be ignored by the plugin.
+ */
+ uint32_t event_count;
+
+ /**
+ The size of the data buffer in bytes.
+ This is set by the host and must not be changed by the plugin.
+ The host is allowed to change this between run() calls.
+ */
+ uint32_t capacity;
+
+ /**
+ The size of the initial portion of the data buffer containing data.
+
+ INPUTS: The host must set this field to the number of bytes used
+ by all events it has written to the buffer (including headers)
+ before calling the plugin's run().
+ The plugin must not change this field.
+
+ OUTPUTS: The plugin must set this field to the number of bytes
+ used by all events it has written to the buffer (including headers)
+ before returning from run().
+ Any initial value should be ignored by the plugin.
+ */
+ uint32_t size;
} LV2_Event_Buffer;
-
/**
Opaque pointer to host data.
*/
LV2_DEPRECATED
typedef void* LV2_Event_Callback_Data;
-
/**
Non-POD events feature.
@@ -239,67 +236,67 @@ typedef void* LV2_Event_Callback_Data;
*/
LV2_DEPRECATED
typedef struct {
- /**
- Opaque pointer to host data.
-
- The plugin MUST pass this to any call to functions in this struct.
- Otherwise, it must not be interpreted in any way.
- */
- LV2_Event_Callback_Data callback_data;
-
- /**
- Take a reference to a non-POD event.
-
- If a plugin receives an event with type 0, it means the event is a
- pointer to some object in memory and not a flat sequence of bytes
- in the buffer. When receiving a non-POD event, the plugin already
- has an implicit reference to the event. If the event is stored AND
- passed to an output, lv2_event_ref MUST be called on that event.
- If the event is only stored OR passed through, this is not necessary
- (as the plugin already has 1 implicit reference).
-
- @param event An event received at an input that will not be copied to
- an output or stored in any way.
-
- @param context The calling context. Like event types, this is a mapped
- URI, see lv2_context.h. Simple plugin with just a run() method should
- pass 0 here (the ID of the 'standard' LV2 run context). The host
- guarantees that this function is realtime safe iff the context is
- realtime safe.
-
- PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
- */
- uint32_t (*lv2_event_ref)(LV2_Event_Callback_Data callback_data,
- LV2_Event* event);
-
- /**
- Drop a reference to a non-POD event.
-
- If a plugin receives an event with type 0, it means the event is a
- pointer to some object in memory and not a flat sequence of bytes
- in the buffer. If the plugin does not pass the event through to
- an output or store it internally somehow, it MUST call this function
- on the event (more information on using non-POD events below).
-
- @param event An event received at an input that will not be copied to an
- output or stored in any way.
-
- @param context The calling context. Like event types, this is a mapped
- URI, see lv2_context.h. Simple plugin with just a run() method should
- pass 0 here (the ID of the 'standard' LV2 run context). The host
- guarantees that this function is realtime safe iff the context is
- realtime safe.
-
- PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
- */
- uint32_t (*lv2_event_unref)(LV2_Event_Callback_Data callback_data,
- LV2_Event* event);
+ /**
+ Opaque pointer to host data.
+
+ The plugin MUST pass this to any call to functions in this struct.
+ Otherwise, it must not be interpreted in any way.
+ */
+ LV2_Event_Callback_Data callback_data;
+
+ /**
+ Take a reference to a non-POD event.
+
+ If a plugin receives an event with type 0, it means the event is a
+ pointer to some object in memory and not a flat sequence of bytes
+ in the buffer. When receiving a non-POD event, the plugin already
+ has an implicit reference to the event. If the event is stored AND
+ passed to an output, lv2_event_ref MUST be called on that event.
+ If the event is only stored OR passed through, this is not necessary
+ (as the plugin already has 1 implicit reference).
+
+ @param event An event received at an input that will not be copied to
+ an output or stored in any way.
+
+ @param context The calling context. Like event types, this is a mapped
+ URI, see lv2_context.h. Simple plugin with just a run() method should
+ pass 0 here (the ID of the 'standard' LV2 run context). The host
+ guarantees that this function is realtime safe iff the context is
+ realtime safe.
+
+ PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
+ */
+ uint32_t (*lv2_event_ref)(LV2_Event_Callback_Data callback_data,
+ LV2_Event* event);
+
+ /**
+ Drop a reference to a non-POD event.
+
+ If a plugin receives an event with type 0, it means the event is a
+ pointer to some object in memory and not a flat sequence of bytes
+ in the buffer. If the plugin does not pass the event through to
+ an output or store it internally somehow, it MUST call this function
+ on the event (more information on using non-POD events below).
+
+ @param event An event received at an input that will not be copied to an
+ output or stored in any way.
+
+ @param context The calling context. Like event types, this is a mapped
+ URI, see lv2_context.h. Simple plugin with just a run() method should
+ pass 0 here (the ID of the 'standard' LV2 run context). The host
+ guarantees that this function is realtime safe iff the context is
+ realtime safe.
+
+ PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
+ */
+ uint32_t (*lv2_event_unref)(LV2_Event_Callback_Data callback_data,
+ LV2_Event* event);
} LV2_Event_Feature;
LV2_RESTORE_WARNINGS
#ifdef __cplusplus
-} /* extern "C" */
+} /* extern "C" */
#endif
/**