diff options
| -rw-r--r-- | ext/atom.lv2/atom-buffer.h | 21 | ||||
| -rw-r--r-- | ext/atom.lv2/atom-helpers.h | 72 | ||||
| -rw-r--r-- | ext/atom.lv2/atom.h | 138 | ||||
| -rw-r--r-- | ext/atom.lv2/forge.h | 75 |
4 files changed, 170 insertions, 136 deletions
diff --git a/ext/atom.lv2/atom-buffer.h b/ext/atom.lv2/atom-buffer.h index 2ac71e3..f4b90dd 100644 --- a/ext/atom.lv2/atom-buffer.h +++ b/ext/atom.lv2/atom-buffer.h @@ -28,20 +28,10 @@ #include <stdbool.h> #include <string.h> #include <stdlib.h> -#include <assert.h> #include "lv2/lv2plug.in/ns/ext/atom/atom.h" /** - Pad a size to 64 bits. -*/ -static inline uint32_t -lv2_atom_pad_size(uint32_t size) -{ - return (size + 7) & (~7); -} - -/** Initialize an existing atom buffer. All fields of @c buf are reset, except capacity which is unmodified. */ @@ -111,9 +101,10 @@ lv2_atom_buffer_is_valid(LV2_Atom_Buffer_Iterator i) static inline LV2_Atom_Buffer_Iterator lv2_atom_buffer_next(LV2_Atom_Buffer_Iterator i) { - assert(lv2_atom_buffer_is_valid(i)); - const LV2_Atom_Event* const ev = (LV2_Atom_Event*)( - i.buf->data + i.offset); + if (!lv2_atom_buffer_is_valid(i)) { + return i; + } + const LV2_Atom_Event* const ev = (LV2_Atom_Event*)(i.buf->data + i.offset); i.offset += lv2_atom_pad_size(sizeof(LV2_Atom_Event) + ev->body.size); return i; } @@ -124,7 +115,9 @@ lv2_atom_buffer_next(LV2_Atom_Buffer_Iterator i) static inline LV2_Atom_Event* lv2_atom_buffer_get(LV2_Atom_Buffer_Iterator i) { - assert(lv2_event_is_valid(i)); + if (!lv2_atom_buffer_is_valid(i)) { + return NULL; + } return (LV2_Atom_Event*)(i.buf->data + i.offset); } diff --git a/ext/atom.lv2/atom-helpers.h b/ext/atom.lv2/atom-helpers.h index ae4bc6f..9d48a29 100644 --- a/ext/atom.lv2/atom-helpers.h +++ b/ext/atom.lv2/atom-helpers.h @@ -34,27 +34,20 @@ #include "lv2/lv2plug.in/ns/ext/atom/atom.h" -/** Pad a size to 4 bytes (32 bits) */ -static inline uint16_t -lv2_atom_pad_size(uint16_t size) -{ - return (size + 3) & (~3); -} - typedef LV2_Atom_Property* LV2_Object_Iter; /** Get an iterator pointing to @c prop in some LV2_Object */ static inline LV2_Object_Iter -lv2_object_begin(const LV2_Atom* obj) +lv2_object_begin(const LV2_Object* obj) { - return (LV2_Object_Iter)(((const LV2_Object*)obj->body)->properties); + return (LV2_Object_Iter)(obj->properties); } /** Return true iff @c iter has reached the end of @c object */ static inline bool -lv2_object_iter_is_end(const LV2_Atom* object, LV2_Object_Iter iter) +lv2_object_iter_is_end(const LV2_Object* obj, LV2_Object_Iter iter) { - return (uint8_t*)iter >= ((uint8_t*)object->body + object->size); + return (uint8_t*)iter >= ((uint8_t*)obj + sizeof(LV2_Atom) + obj->size); } /** Return true iff @c l points to the same property as @c r */ @@ -113,14 +106,15 @@ lv2_object_iter_get(LV2_Object_Iter iter) Atom type that contains headerless 32-bit aligned properties. */ static inline LV2_Atom_Property* -lv2_atom_append_property(LV2_Atom* object, - uint32_t key, - uint16_t value_type, - uint16_t value_size, - const uint8_t* value_body) +lv2_object_append(LV2_Object* object, + uint32_t key, + uint32_t value_type, + uint32_t value_size, + const void* value_body) { object->size = lv2_atom_pad_size(object->size); - LV2_Atom_Property* prop = (LV2_Atom_Property*)(object->body + object->size); + LV2_Atom_Property* prop = (LV2_Atom_Property*)( + (uint8_t*)object + sizeof(LV2_Atom) + object->size); prop->key = key; prop->value.type = value_type; prop->value.size = value_size; @@ -136,44 +130,14 @@ lv2_atom_is_null(LV2_Atom* atom) return !atom || (atom->type == 0 && atom->size == 0); } -/** Return true iff @c object has rdf:type @c type */ -static inline bool -lv2_atom_is_a(LV2_Atom* object, - uint32_t rdf_type, - uint32_t atom_URIInt, - uint32_t atom_Object, - uint32_t type) -{ - if (lv2_atom_is_null(object)) - return false; - - if (object->type == type) - return true; - - if (object->type == atom_Object) { - LV2_OBJECT_FOREACH(object, o) { - LV2_Atom_Property* prop = lv2_object_iter_get(o); - if (prop->key == rdf_type) { - if (prop->value.type == atom_URIInt) { - const uint32_t object_type = *(uint32_t*)prop->value.body; - if (object_type == type) - return true; - } else { - fprintf(stderr, "error: rdf:type is not a URIInt\n"); - } - } - } - } - - return false; -} - /** A single entry in an Object query. */ typedef struct { - uint32_t key; /**< Key to query (input set by user) */ - const LV2_Atom* value; /**< Found value (output set by query function) */ + uint32_t key; /**< Key to query (input set by user) */ + const LV2_Atom** value; /**< Found value (output set by query function) */ } LV2_Object_Query; +static const LV2_Object_Query LV2_OBJECT_QUERY_END = { 0, NULL }; + /** "Query" an object, getting a pointer to the values for various keys. @@ -184,7 +148,7 @@ typedef struct { quickly without allocating any memory. This function is realtime safe. */ static inline int -lv2_object_query(const LV2_Atom* object, LV2_Object_Query* query) +lv2_object_query(const LV2_Object* object, LV2_Object_Query* query) { int matches = 0; int n_queries = 0; @@ -196,8 +160,8 @@ lv2_object_query(const LV2_Atom* object, LV2_Object_Query* query) LV2_OBJECT_FOREACH(object, o) { const LV2_Atom_Property* prop = lv2_object_iter_get(o); for (LV2_Object_Query* q = query; q->key; ++q) { - if (q->key == prop->key && !q->value) { - q->value = &prop->value; + if (q->key == prop->key && !*q->value) { + *q->value = &prop->value; if (++matches == n_queries) return matches; break; diff --git a/ext/atom.lv2/atom.h b/ext/atom.lv2/atom.h index 61482c7..d617435 100644 --- a/ext/atom.lv2/atom.h +++ b/ext/atom.lv2/atom.h @@ -18,11 +18,8 @@ @file atom.h C header for the LV2 Atom extension <http://lv2plug.in/ns/ext/atom>. - This extension defines convenience structs that should match the definition - of the built-in types of the atom extension. The layout of atoms in this - header must match the description in RDF. The RDF description of an atom - type should be considered normative. This header is a non-normative (but - hopefully accurate) implementation of that specification. + This header describes the binary layout of various types defined in the + atom extension. */ #ifndef LV2_ATOM_H @@ -35,6 +32,10 @@ #include <stdint.h> #include <stddef.h> +#ifdef __cplusplus +extern "C" { +#endif + /** An LV2 Atom. @@ -45,70 +46,76 @@ (e.g. with memcpy) using the size field, except atoms with type 0. An atom with type 0 is a reference, and may only be used via the functions provided in LV2_Blob_Support (e.g. it MUST NOT be manually copied). - - Note that an LV2_Atom is the latter two fields of an LV2_Event as defined by - the <a href="http://lv2plug.in/ns/ext/event">LV2 events extension</a>. The - host MAY marshal an LV2_Event to an LV2_Atom by simply pointing to the - offset of <code>type</code>. The macro LV2_ATOM_FROM_EVENT is provided in - this header for this purpose. */ typedef struct { - - /** - The type of this atom. - - This number is mapped from a URI using the extension - <http://lv2plug.in/ns/ext/uri-map> with 'map' = - "http://lv2plug.in/ns/ext/atom". Type 0 is a special case which - indicates this atom is a reference and MUST NOT be copied manually. - */ - uint16_t type; - - /** - The size of this atom, not including this header, in bytes. - */ - uint16_t size; - - /** - Size bytes of data follow here. - */ - uint8_t body[]; - + uint32_t type; /**< Type of this atom (mapped URI). */ + uint32_t size; /**< Size in bytes, not including type and size. */ + uint8_t body[]; /**< Body of length @ref size bytes. */ } LV2_Atom; /** - The body of an atom:Literal. + An atom:String. + This type may safely be cast to LV2_Atom. */ typedef struct { - uint32_t datatype; /**< The ID of the datatype of this literal */ - uint32_t lang; /**< The ID of the language of this literal */ - uint8_t str[]; /**< Null-terminated string data in UTF-8 encoding */ + uint32_t type; /**< Type of this atom (mapped URI). */ + uint32_t size; /**< Size in bytes, not including type and size. */ + uint8_t str[]; /**< Null-terminated string data in UTF-8 encoding. */ +} LV2_Atom_String; + +/** + An atom:Literal. + This type may safely be cast to LV2_Atom. +*/ +typedef struct { + uint32_t type; /**< Type of this atom (mapped URI). */ + uint32_t size; /**< Size in bytes, not including type and size. */ + uint32_t datatype; /**< The ID of the datatype of this literal. */ + uint32_t lang; /**< The ID of the language of this literal. */ + uint8_t str[]; /**< Null-terminated string data in UTF-8 encoding. */ } LV2_Atom_Literal; /** - The body of an atom:Vector. + An atom:ID. + This type may safely be cast to LV2_Atom. */ typedef struct { - uint16_t elem_count; /**< The number of elements in the vector */ - uint16_t elem_type; /**< The type of each element in the vector */ - uint8_t elems[]; /**< Sequence of element bodies */ + uint32_t type; /**< Type of this atom (mapped URI). */ + uint32_t size; /**< Size in bytes, not including type and size. */ + uint32_t id; /**< Value, a URI mapped to an integer. */ +} LV2_Atom_ID; + +/** + An atom:Vector. + This type may safely be cast to LV2_Atom. +*/ +typedef struct { + uint32_t type; /**< Type of this atom (mapped URI). */ + uint32_t size; /**< Size in bytes, not including type and size. */ + uint32_t elem_count; /**< The number of elements in the vector */ + uint32_t elem_type; /**< The type of each element in the vector */ + uint8_t elems[]; /**< Sequence of element bodies */ } LV2_Atom_Vector; /** The body of an atom:Property. + Note this type is not an LV2_Atom. */ typedef struct _LV2_Atom_Property { - uint32_t key; /**< ID of key (predicate) */ - LV2_Atom value; /**< Value (object) */ + uint32_t key; /**< Key (predicate) (mapped URI). */ + LV2_Atom value; /**< Value (object) */ } LV2_Atom_Property; /** - The body of an atom:Resource or atom:Blank. + An atom:Object (atom:Resource or atom:Blank). + This type may safely be cast to LV2_Atom. */ typedef struct { - uint32_t context; /**< ID of context graph, or 0 for default */ - uint32_t id; /**< URID (for Resource) or blank ID (for Blank) */ - uint8_t properties[]; /**< Sequence of LV2_Atom_Property */ + uint32_t type; /**< Type of this atom (mapped URI). */ + uint32_t size; /**< Size in bytes, not including type and size. */ + uint32_t context; /**< ID of context graph, or 0 for default */ + uint32_t id; /**< URID (for Resource) or blank ID (for Blank) */ + uint8_t properties[]; /**< Sequence of LV2_Atom_Property */ } LV2_Object; /** @@ -121,27 +128,9 @@ typedef struct { the @ref body field of the Event. */ typedef struct { - - /** - The frames portion of timestamp. The unit of this value may depend on - context, but for events processed by LV2_Descriptor::run() the unit is - audio frames relative to this block (e.g. frame 0 is the first frame in - this call to run()) - */ - uint32_t frames; - - /** - The sub-frames portion of timestamp. The unit of this value may depend - on context, but for events processed by LV2_Descriptor::run() the unit - is 1/(2^32) of an audio frame. - */ - uint32_t subframes; - - /** - The body of this event. - */ - LV2_Atom body; - + uint32_t frames; /**< Time in frames relative to this block. */ + uint32_t subframes; /**< Fractional time in 1/(2^32)ths of a frame. */ + LV2_Atom body; /**< Event body. */ } LV2_Atom_Event; /** @@ -208,4 +197,17 @@ typedef struct { } LV2_Atom_Buffer; -#endif /* LV2_ATOM_H */ +/** + Pad a size to 64 bits. +*/ +static inline uint32_t +lv2_atom_pad_size(uint32_t size) +{ + return (size + 7) & (~7); +} + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* LV2_ATOM_H */ diff --git a/ext/atom.lv2/forge.h b/ext/atom.lv2/forge.h new file mode 100644 index 0000000..f1ffb03 --- /dev/null +++ b/ext/atom.lv2/forge.h @@ -0,0 +1,75 @@ +/* + Copyright 2008-2011 David Robillard <http://drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +/** + @file forge.h Helper constructor functions for LV2 atoms. +*/ + +#ifndef LV2_ATOM_FORGE_H +#define LV2_ATOM_FORGE_H + +#include "lv2/lv2plug.in/ns/ext/atom/atom.h" +#include "lv2/lv2plug.in/ns/ext/urid/urid.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + uint32_t ID; + uint32_t Message; + uint32_t Property; +} LV2_Atom_Forge; + +static inline LV2_Atom_Forge* +lv2_atom_forge_new(LV2_URID_Mapper* mapper) +{ + LV2_Atom_Forge* forge = (LV2_Atom_Forge*)malloc(sizeof(LV2_Atom_Forge)); + forge->ID = mapper->map_uri(mapper->handle, LV2_ATOM_URI "#ID"); + forge->Message = mapper->map_uri(mapper->handle, LV2_ATOM_URI "#Message"); + forge->Property = mapper->map_uri(mapper->handle, LV2_ATOM_URI "#Property"); + return forge; +} + +static inline void +lv2_atom_forge_free(LV2_Atom_Forge* forge) +{ + free(forge); +} + +static inline LV2_Atom_ID +lv2_atom_forge_make_id(LV2_Atom_Forge* forge, uint32_t id) +{ + const LV2_Atom_ID atom = { forge->ID, sizeof(uint32_t), id }; + return atom; +} + +static inline void +lv2_atom_forge_set_message(LV2_Atom_Forge* forge, + LV2_Object* msg, + uint32_t id) +{ + msg->type = forge->Message; + msg->size = sizeof(LV2_Object) - sizeof(LV2_Atom); + msg->context = 0; + msg->id = id; +} + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* LV2_ATOM_FORGE_H */ |