aboutsummaryrefslogtreecommitdiffstats
path: root/lv2/lv2plug.in/ns/ext/atom
diff options
context:
space:
mode:
Diffstat (limited to 'lv2/lv2plug.in/ns/ext/atom')
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/atom-test.c397
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/atom.h256
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/atom.ttl602
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/forge.h710
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/lv2-atom.doap.ttl102
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/manifest.ttl8
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/util.h509
7 files changed, 0 insertions, 2584 deletions
diff --git a/lv2/lv2plug.in/ns/ext/atom/atom-test.c b/lv2/lv2plug.in/ns/ext/atom/atom-test.c
deleted file mode 100644
index 72bf4ea..0000000
--- a/lv2/lv2plug.in/ns/ext/atom/atom-test.c
+++ /dev/null
@@ -1,397 +0,0 @@
-/*
- Copyright 2012-2015 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.
-*/
-
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "lv2/lv2plug.in/ns/ext/atom/forge.h"
-#include "lv2/lv2plug.in/ns/ext/atom/util.h"
-
-char** uris = NULL;
-uint32_t n_uris = 0;
-
-static char*
-copy_string(const char* str)
-{
- const size_t len = strlen(str);
- char* dup = (char*)malloc(len + 1);
- memcpy(dup, str, len + 1);
- return dup;
-}
-
-static LV2_URID
-urid_map(LV2_URID_Map_Handle handle, const char* uri)
-{
- for (uint32_t i = 0; i < n_uris; ++i) {
- if (!strcmp(uris[i], uri)) {
- return i + 1;
- }
- }
-
- uris = (char**)realloc(uris, ++n_uris * sizeof(char*));
- uris[n_uris - 1] = copy_string(uri);
- return n_uris;
-}
-
-static int
-test_fail(const char* fmt, ...)
-{
- va_list args;
- va_start(args, fmt);
- fprintf(stderr, "error: ");
- vfprintf(stderr, fmt, args);
- va_end(args);
- return 1;
-}
-
-int
-main(void)
-{
- LV2_URID_Map map = { NULL, urid_map };
- LV2_Atom_Forge forge;
- lv2_atom_forge_init(&forge, &map);
-
- LV2_URID eg_Object = urid_map(NULL, "http://example.org/Object");
- LV2_URID eg_one = urid_map(NULL, "http://example.org/one");
- LV2_URID eg_two = urid_map(NULL, "http://example.org/two");
- LV2_URID eg_three = urid_map(NULL, "http://example.org/three");
- LV2_URID eg_four = urid_map(NULL, "http://example.org/four");
- LV2_URID eg_true = urid_map(NULL, "http://example.org/true");
- LV2_URID eg_false = urid_map(NULL, "http://example.org/false");
- LV2_URID eg_path = urid_map(NULL, "http://example.org/path");
- LV2_URID eg_uri = urid_map(NULL, "http://example.org/uri");
- LV2_URID eg_urid = urid_map(NULL, "http://example.org/urid");
- LV2_URID eg_string = urid_map(NULL, "http://example.org/string");
- LV2_URID eg_literal = urid_map(NULL, "http://example.org/literal");
- LV2_URID eg_tuple = urid_map(NULL, "http://example.org/tuple");
- LV2_URID eg_vector = urid_map(NULL, "http://example.org/vector");
- LV2_URID eg_vector2 = urid_map(NULL, "http://example.org/vector2");
- LV2_URID eg_seq = urid_map(NULL, "http://example.org/seq");
-
-#define BUF_SIZE 1024
-#define NUM_PROPS 15
-
- uint8_t buf[BUF_SIZE];
- lv2_atom_forge_set_buffer(&forge, buf, BUF_SIZE);
-
- LV2_Atom_Forge_Frame obj_frame;
- LV2_Atom* obj = lv2_atom_forge_deref(
- &forge, lv2_atom_forge_object(&forge, &obj_frame, 0, eg_Object));
-
- // eg_one = (Int)1
- lv2_atom_forge_key(&forge, eg_one);
- LV2_Atom_Int* one = (LV2_Atom_Int*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_int(&forge, 1));
- if (one->body != 1) {
- return test_fail("%d != 1\n", one->body);
- }
-
- // eg_two = (Long)2
- lv2_atom_forge_key(&forge, eg_two);
- LV2_Atom_Long* two = (LV2_Atom_Long*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_long(&forge, 2));
- if (two->body != 2) {
- return test_fail("%ld != 2\n", two->body);
- }
-
- // eg_three = (Float)3.0
- lv2_atom_forge_key(&forge, eg_three);
- LV2_Atom_Float* three = (LV2_Atom_Float*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_float(&forge, 3.0f));
- if (three->body != 3) {
- return test_fail("%f != 3\n", three->body);
- }
-
- // eg_four = (Double)4.0
- lv2_atom_forge_key(&forge, eg_four);
- LV2_Atom_Double* four = (LV2_Atom_Double*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_double(&forge, 4.0));
- if (four->body != 4) {
- return test_fail("%ld != 4\n", four->body);
- }
-
- // eg_true = (Bool)1
- lv2_atom_forge_key(&forge, eg_true);
- LV2_Atom_Bool* t = (LV2_Atom_Bool*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_bool(&forge, true));
- if (t->body != 1) {
- return test_fail("%ld != 1 (true)\n", t->body);
- }
-
- // eg_false = (Bool)0
- lv2_atom_forge_key(&forge, eg_false);
- LV2_Atom_Bool* f = (LV2_Atom_Bool*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_bool(&forge, false));
- if (f->body != 0) {
- return test_fail("%ld != 0 (false)\n", f->body);
- }
-
- // eg_path = (Path)"/foo/bar"
- const char* pstr = "/foo/bar";
- const uint32_t pstr_len = (uint32_t)strlen(pstr);
- lv2_atom_forge_key(&forge, eg_path);
- LV2_Atom_String* path = (LV2_Atom_String*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_uri(&forge, pstr, pstr_len));
- char* pbody = (char*)LV2_ATOM_BODY(path);
- if (strcmp(pbody, pstr)) {
- return test_fail("%s != \"%s\"\n", pbody, pstr);
- }
-
- // eg_uri = (URI)"http://example.org/value"
- const char* ustr = "http://example.org/value";
- const uint32_t ustr_len = (uint32_t)strlen(ustr);
- lv2_atom_forge_key(&forge, eg_uri);
- LV2_Atom_String* uri = (LV2_Atom_String*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_uri(&forge, ustr, ustr_len));
- char* ubody = (char*)LV2_ATOM_BODY(uri);
- if (strcmp(ubody, ustr)) {
- return test_fail("%s != \"%s\"\n", ubody, ustr);
- }
-
- // eg_urid = (URID)"http://example.org/value"
- LV2_URID eg_value = urid_map(NULL, "http://example.org/value");
- lv2_atom_forge_key(&forge, eg_urid);
- LV2_Atom_URID* urid = (LV2_Atom_URID*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_urid(&forge, eg_value));
- if (urid->body != eg_value) {
- return test_fail("%u != %u\n", urid->body, eg_value);
- }
-
- // eg_string = (String)"hello"
- lv2_atom_forge_key(&forge, eg_string);
- LV2_Atom_String* string = (LV2_Atom_String*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_string(
- &forge, "hello", strlen("hello")));
- char* sbody = (char*)LV2_ATOM_BODY(string);
- if (strcmp(sbody, "hello")) {
- return test_fail("%s != \"hello\"\n", sbody);
- }
-
- // eg_literal = (Literal)"hello"@fr
- lv2_atom_forge_key(&forge, eg_literal);
- LV2_Atom_Literal* literal = (LV2_Atom_Literal*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_literal(
- &forge, "bonjour", strlen("bonjour"),
- 0, urid_map(NULL, "http://lexvo.org/id/term/fr")));
- char* lbody = (char*)LV2_ATOM_CONTENTS(LV2_Atom_Literal, literal);
- if (strcmp(lbody, "bonjour")) {
- return test_fail("%s != \"bonjour\"\n", lbody);
- }
-
- // eg_tuple = "foo",true
- lv2_atom_forge_key(&forge, eg_tuple);
- LV2_Atom_Forge_Frame tuple_frame;
- LV2_Atom_Tuple* tuple = (LV2_Atom_Tuple*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_tuple(&forge, &tuple_frame));
- LV2_Atom_String* tup0 = (LV2_Atom_String*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_string(
- &forge, "foo", strlen("foo")));
- LV2_Atom_Bool* tup1 = (LV2_Atom_Bool*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_bool(&forge, true));
- lv2_atom_forge_pop(&forge, &tuple_frame);
- LV2_Atom* i = lv2_atom_tuple_begin(tuple);
- if (lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
- return test_fail("Tuple iterator is empty\n");
- }
- LV2_Atom* tup0i = i;
- if (!lv2_atom_equals((LV2_Atom*)tup0, tup0i)) {
- return test_fail("Corrupt tuple element 0\n");
- }
- i = lv2_atom_tuple_next(i);
- if (lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
- return test_fail("Premature end of tuple iterator\n");
- }
- LV2_Atom* tup1i = i;
- if (!lv2_atom_equals((LV2_Atom*)tup1, tup1i)) {
- return test_fail("Corrupt tuple element 1\n");
- }
- i = lv2_atom_tuple_next(i);
- if (!lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
- return test_fail("Tuple iter is not at end\n");
- }
-
- // eg_vector = (Vector<Int>)1,2,3,4
- lv2_atom_forge_key(&forge, eg_vector);
- int32_t elems[] = { 1, 2, 3, 4 };
- LV2_Atom_Vector* vector = (LV2_Atom_Vector*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_vector(
- &forge, sizeof(int32_t), forge.Int, 4, elems));
- void* vec_body = LV2_ATOM_CONTENTS(LV2_Atom_Vector, vector);
- if (memcmp(elems, vec_body, sizeof(elems))) {
- return test_fail("Corrupt vector\n");
- }
-
- // eg_vector2 = (Vector<Int>)1,2,3,4
- lv2_atom_forge_key(&forge, eg_vector2);
- LV2_Atom_Forge_Frame vec_frame;
- LV2_Atom_Vector* vector2 = (LV2_Atom_Vector*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_vector_head(
- &forge, &vec_frame, sizeof(int32_t), forge.Int));
- for (unsigned e = 0; e < sizeof(elems) / sizeof(int32_t); ++e) {
- lv2_atom_forge_int(&forge, elems[e]);
- }
- lv2_atom_forge_pop(&forge, &vec_frame);
- if (!lv2_atom_equals(&vector->atom, &vector2->atom)) {
- return test_fail("Vector != Vector2\n");
- }
-
- // eg_seq = (Sequence)1, 2
- lv2_atom_forge_key(&forge, eg_seq);
- LV2_Atom_Forge_Frame seq_frame;
- LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)lv2_atom_forge_deref(
- &forge, lv2_atom_forge_sequence_head(&forge, &seq_frame, 0));
- lv2_atom_forge_frame_time(&forge, 0);
- lv2_atom_forge_int(&forge, 1);
- lv2_atom_forge_frame_time(&forge, 1);
- lv2_atom_forge_int(&forge, 2);
- lv2_atom_forge_pop(&forge, &seq_frame);
-
- lv2_atom_forge_pop(&forge, &obj_frame);
-
- // Test equality
- LV2_Atom_Int itwo = { { forge.Int, sizeof(int32_t) }, 2 };
- if (lv2_atom_equals((LV2_Atom*)one, (LV2_Atom*)two)) {
- return test_fail("1 == 2.0\n");
- } else if (lv2_atom_equals((LV2_Atom*)one, (LV2_Atom*)&itwo)) {
- return test_fail("1 == 2\n");
- } else if (!lv2_atom_equals((LV2_Atom*)one, (LV2_Atom*)one)) {
- return test_fail("1 != 1\n");
- }
-
- unsigned n_events = 0;
- LV2_ATOM_SEQUENCE_FOREACH(seq, ev) {
- if (ev->time.frames != n_events) {
- return test_fail("Corrupt event %u has bad time\n", n_events);
- } else if (ev->body.type != forge.Int) {
- return test_fail("Corrupt event %u has bad type\n", n_events);
- } else if (((LV2_Atom_Int*)&ev->body)->body != (int)n_events + 1) {
- return test_fail("Event %u != %d\n", n_events, n_events + 1);
- }
- ++n_events;
- }
-
- int n_props = 0;
- LV2_ATOM_OBJECT_FOREACH((LV2_Atom_Object*)obj, prop) {
- if (!prop->key) {
- return test_fail("Corrupt property %u has no key\n", n_props);
- } else if (prop->context) {
- return test_fail("Corrupt property %u has context\n", n_props);
- }
- ++n_props;
- }
-
- if (n_props != NUM_PROPS) {
- return test_fail("Corrupt object has %u properties != %u\n",
- n_props, NUM_PROPS);
- }
-
- struct {
- const LV2_Atom* one;
- const LV2_Atom* two;
- const LV2_Atom* three;
- const LV2_Atom* four;
- const LV2_Atom* affirmative;
- const LV2_Atom* negative;
- const LV2_Atom* path;
- const LV2_Atom* uri;
- const LV2_Atom* urid;
- const LV2_Atom* string;
- const LV2_Atom* literal;
- const LV2_Atom* tuple;
- const LV2_Atom* vector;
- const LV2_Atom* vector2;
- const LV2_Atom* seq;
- } matches;
-
- memset(&matches, 0, sizeof(matches));
-
- LV2_Atom_Object_Query q[] = {
- { eg_one, &matches.one },
- { eg_two, &matches.two },
- { eg_three, &matches.three },
- { eg_four, &matches.four },
- { eg_true, &matches.affirmative },
- { eg_false, &matches.negative },
- { eg_path, &matches.path },
- { eg_uri, &matches.uri },
- { eg_urid, &matches.urid },
- { eg_string, &matches.string },
- { eg_literal, &matches.literal },
- { eg_tuple, &matches.tuple },
- { eg_vector, &matches.vector },
- { eg_vector2, &matches.vector2 },
- { eg_seq, &matches.seq },
- LV2_ATOM_OBJECT_QUERY_END
- };
-
- int n_matches = lv2_atom_object_query((LV2_Atom_Object*)obj, q);
- for (int n = 0; n < 2; ++n) {
- if (n_matches != n_props) {
- return test_fail("Query failed, %u matches != %u\n",
- n_matches, n_props);
- } else if (!lv2_atom_equals((LV2_Atom*)one, matches.one)) {
- return test_fail("Bad match one\n");
- } else if (!lv2_atom_equals((LV2_Atom*)two, matches.two)) {
- return test_fail("Bad match two\n");
- } else if (!lv2_atom_equals((LV2_Atom*)three, matches.three)) {
- return test_fail("Bad match three\n");
- } else if (!lv2_atom_equals((LV2_Atom*)four, matches.four)) {
- return test_fail("Bad match four\n");
- } else if (!lv2_atom_equals((LV2_Atom*)t, matches.affirmative)) {
- return test_fail("Bad match true\n");
- } else if (!lv2_atom_equals((LV2_Atom*)f, matches.negative)) {
- return test_fail("Bad match false\n");
- } else if (!lv2_atom_equals((LV2_Atom*)path, matches.path)) {
- return test_fail("Bad match path\n");
- } else if (!lv2_atom_equals((LV2_Atom*)uri, matches.uri)) {
- return test_fail("Bad match URI\n");
- } else if (!lv2_atom_equals((LV2_Atom*)string, matches.string)) {
- return test_fail("Bad match string\n");
- } else if (!lv2_atom_equals((LV2_Atom*)literal, matches.literal)) {
- return test_fail("Bad match literal\n");
- } else if (!lv2_atom_equals((LV2_Atom*)tuple, matches.tuple)) {
- return test_fail("Bad match tuple\n");
- } else if (!lv2_atom_equals((LV2_Atom*)vector, matches.vector)) {
- return test_fail("Bad match vector\n");
- } else if (!lv2_atom_equals((LV2_Atom*)vector, matches.vector2)) {
- return test_fail("Bad match vector2\n");
- } else if (!lv2_atom_equals((LV2_Atom*)seq, matches.seq)) {
- return test_fail("Bad match sequence\n");
- }
- memset(&matches, 0, sizeof(matches));
- n_matches = lv2_atom_object_get((LV2_Atom_Object*)obj,
- eg_one, &matches.one,
- eg_two, &matches.two,
- eg_three, &matches.three,
- eg_four, &matches.four,
- eg_true, &matches.affirmative,
- eg_false, &matches.negative,
- eg_path, &matches.path,
- eg_uri, &matches.uri,
- eg_urid, &matches.urid,
- eg_string, &matches.string,
- eg_literal, &matches.literal,
- eg_tuple, &matches.tuple,
- eg_vector, &matches.vector,
- eg_vector2, &matches.vector2,
- eg_seq, &matches.seq,
- 0);
- }
-
- return 0;
-}
diff --git a/lv2/lv2plug.in/ns/ext/atom/atom.h b/lv2/lv2plug.in/ns/ext/atom/atom.h
deleted file mode 100644
index cb5c067..0000000
--- a/lv2/lv2plug.in/ns/ext/atom/atom.h
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- Copyright 2008-2016 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.
-*/
-
-/**
- @defgroup atom Atom
-
- A generic value container and several data types, see
- <http://lv2plug.in/ns/ext/atom> for details.
-
- @{
-*/
-
-#ifndef LV2_ATOM_H
-#define LV2_ATOM_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-#define LV2_ATOM_URI "http://lv2plug.in/ns/ext/atom" ///< http://lv2plug.in/ns/ext/atom
-#define LV2_ATOM_PREFIX LV2_ATOM_URI "#" ///< http://lv2plug.in/ns/ext/atom#
-
-#define LV2_ATOM__Atom LV2_ATOM_PREFIX "Atom" ///< http://lv2plug.in/ns/ext/atom#Atom
-#define LV2_ATOM__AtomPort LV2_ATOM_PREFIX "AtomPort" ///< http://lv2plug.in/ns/ext/atom#AtomPort
-#define LV2_ATOM__Blank LV2_ATOM_PREFIX "Blank" ///< http://lv2plug.in/ns/ext/atom#Blank
-#define LV2_ATOM__Bool LV2_ATOM_PREFIX "Bool" ///< http://lv2plug.in/ns/ext/atom#Bool
-#define LV2_ATOM__Chunk LV2_ATOM_PREFIX "Chunk" ///< http://lv2plug.in/ns/ext/atom#Chunk
-#define LV2_ATOM__Double LV2_ATOM_PREFIX "Double" ///< http://lv2plug.in/ns/ext/atom#Double
-#define LV2_ATOM__Event LV2_ATOM_PREFIX "Event" ///< http://lv2plug.in/ns/ext/atom#Event
-#define LV2_ATOM__Float LV2_ATOM_PREFIX "Float" ///< http://lv2plug.in/ns/ext/atom#Float
-#define LV2_ATOM__Int LV2_ATOM_PREFIX "Int" ///< http://lv2plug.in/ns/ext/atom#Int
-#define LV2_ATOM__Literal LV2_ATOM_PREFIX "Literal" ///< http://lv2plug.in/ns/ext/atom#Literal
-#define LV2_ATOM__Long LV2_ATOM_PREFIX "Long" ///< http://lv2plug.in/ns/ext/atom#Long
-#define LV2_ATOM__Number LV2_ATOM_PREFIX "Number" ///< http://lv2plug.in/ns/ext/atom#Number
-#define LV2_ATOM__Object LV2_ATOM_PREFIX "Object" ///< http://lv2plug.in/ns/ext/atom#Object
-#define LV2_ATOM__Path LV2_ATOM_PREFIX "Path" ///< http://lv2plug.in/ns/ext/atom#Path
-#define LV2_ATOM__Property LV2_ATOM_PREFIX "Property" ///< http://lv2plug.in/ns/ext/atom#Property
-#define LV2_ATOM__Resource LV2_ATOM_PREFIX "Resource" ///< http://lv2plug.in/ns/ext/atom#Resource
-#define LV2_ATOM__Sequence LV2_ATOM_PREFIX "Sequence" ///< http://lv2plug.in/ns/ext/atom#Sequence
-#define LV2_ATOM__Sound LV2_ATOM_PREFIX "Sound" ///< http://lv2plug.in/ns/ext/atom#Sound
-#define LV2_ATOM__String LV2_ATOM_PREFIX "String" ///< http://lv2plug.in/ns/ext/atom#String
-#define LV2_ATOM__Tuple LV2_ATOM_PREFIX "Tuple" ///< http://lv2plug.in/ns/ext/atom#Tuple
-#define LV2_ATOM__URI LV2_ATOM_PREFIX "URI" ///< http://lv2plug.in/ns/ext/atom#URI
-#define LV2_ATOM__URID LV2_ATOM_PREFIX "URID" ///< http://lv2plug.in/ns/ext/atom#URID
-#define LV2_ATOM__Vector LV2_ATOM_PREFIX "Vector" ///< http://lv2plug.in/ns/ext/atom#Vector
-#define LV2_ATOM__atomTransfer LV2_ATOM_PREFIX "atomTransfer" ///< http://lv2plug.in/ns/ext/atom#atomTransfer
-#define LV2_ATOM__beatTime LV2_ATOM_PREFIX "beatTime" ///< http://lv2plug.in/ns/ext/atom#beatTime
-#define LV2_ATOM__bufferType LV2_ATOM_PREFIX "bufferType" ///< http://lv2plug.in/ns/ext/atom#bufferType
-#define LV2_ATOM__childType LV2_ATOM_PREFIX "childType" ///< http://lv2plug.in/ns/ext/atom#childType
-#define LV2_ATOM__eventTransfer LV2_ATOM_PREFIX "eventTransfer" ///< http://lv2plug.in/ns/ext/atom#eventTransfer
-#define LV2_ATOM__frameTime LV2_ATOM_PREFIX "frameTime" ///< http://lv2plug.in/ns/ext/atom#frameTime
-#define LV2_ATOM__supports LV2_ATOM_PREFIX "supports" ///< http://lv2plug.in/ns/ext/atom#supports
-#define LV2_ATOM__timeUnit LV2_ATOM_PREFIX "timeUnit" ///< http://lv2plug.in/ns/ext/atom#timeUnit
-
-#define LV2_ATOM_REFERENCE_TYPE 0 ///< The special type for a reference atom
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @cond */
-/** This expression will fail to compile if double does not fit in 64 bits. */
-typedef char lv2_atom_assert_double_fits_in_64_bits[
- ((sizeof(double) <= sizeof(uint64_t)) * 2) - 1];
-/** @endcond */
-
-/**
- Return a pointer to the contents of an Atom. The "contents" of an atom
- is the data past the complete type-specific header.
- @param type The type of the atom, e.g. LV2_Atom_String.
- @param atom A variable-sized atom.
-*/
-#define LV2_ATOM_CONTENTS(type, atom) \
- ((void*)((uint8_t*)(atom) + sizeof(type)))
-
-/**
- Const version of LV2_ATOM_CONTENTS.
-*/
-#define LV2_ATOM_CONTENTS_CONST(type, atom) \
- ((const void*)((const uint8_t*)(atom) + sizeof(type)))
-
-/**
- Return a pointer to the body of an Atom. The "body" of an atom is the
- data just past the LV2_Atom head (i.e. the same offset for all types).
-*/
-#define LV2_ATOM_BODY(atom) LV2_ATOM_CONTENTS(LV2_Atom, atom)
-
-/**
- Const version of LV2_ATOM_BODY.
-*/
-#define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
-
-/** The header of an atom:Atom. */
-typedef struct {
- uint32_t size; /**< Size in bytes, not including type and size. */
- uint32_t type; /**< Type of this atom (mapped URI). */
-} LV2_Atom;
-
-/** An atom:Int or atom:Bool. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- int32_t body; /**< Integer value. */
-} LV2_Atom_Int;
-
-/** An atom:Long. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- int64_t body; /**< Integer value. */
-} LV2_Atom_Long;
-
-/** An atom:Float. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- float body; /**< Floating point value. */
-} LV2_Atom_Float;
-
-/** An atom:Double. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- double body; /**< Floating point value. */
-} LV2_Atom_Double;
-
-/** An atom:Bool. May be cast to LV2_Atom. */
-typedef LV2_Atom_Int LV2_Atom_Bool;
-
-/** An atom:URID. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- uint32_t body; /**< URID. */
-} LV2_Atom_URID;
-
-/** An atom:String. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- /* Contents (a null-terminated UTF-8 string) follow here. */
-} LV2_Atom_String;
-
-/** The body of an atom:Literal. */
-typedef struct {
- uint32_t datatype; /**< Datatype URID. */
- uint32_t lang; /**< Language URID. */
- /* Contents (a null-terminated UTF-8 string) follow here. */
-} LV2_Atom_Literal_Body;
-
-/** An atom:Literal. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- LV2_Atom_Literal_Body body; /**< Body. */
-} LV2_Atom_Literal;
-
-/** An atom:Tuple. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- /* Contents (a series of complete atoms) follow here. */
-} LV2_Atom_Tuple;
-
-/** The body of an atom:Vector. */
-typedef struct {
- uint32_t child_size; /**< The size of each element in the vector. */
- uint32_t child_type; /**< The type of each element in the vector. */
- /* Contents (a series of packed atom bodies) follow here. */
-} LV2_Atom_Vector_Body;
-
-/** An atom:Vector. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- LV2_Atom_Vector_Body body; /**< Body. */
-} LV2_Atom_Vector;
-
-/** The body of an atom:Property (e.g. in an atom:Object). */
-typedef struct {
- uint32_t key; /**< Key (predicate) (mapped URI). */
- uint32_t context; /**< Context URID (may be, and generally is, 0). */
- LV2_Atom value; /**< Value atom header. */
- /* Value atom body follows here. */
-} LV2_Atom_Property_Body;
-
-/** An atom:Property. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- LV2_Atom_Property_Body body; /**< Body. */
-} LV2_Atom_Property;
-
-/** The body of an atom:Object. May be cast to LV2_Atom. */
-typedef struct {
- uint32_t id; /**< URID, or 0 for blank. */
- uint32_t otype; /**< Type URID (same as rdf:type, for fast dispatch). */
- /* Contents (a series of property bodies) follow here. */
-} LV2_Atom_Object_Body;
-
-/** An atom:Object. May be cast to LV2_Atom. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- LV2_Atom_Object_Body body; /**< Body. */
-} LV2_Atom_Object;
-
-/** The header of an atom:Event. Note this type is NOT an LV2_Atom. */
-typedef struct {
- /** Time stamp. Which type is valid is determined by context. */
- union {
- int64_t frames; /**< Time in audio frames. */
- double beats; /**< Time in beats. */
- } time;
- LV2_Atom body; /**< Event body atom header. */
- /* Body atom contents follow here. */
-} LV2_Atom_Event;
-
-/**
- The body of an atom:Sequence (a sequence of events).
-
- The unit field is either a URID that described an appropriate time stamp
- type, or may be 0 where a default stamp type is known. For
- LV2_Descriptor::run(), the default stamp type is audio frames.
-
- The contents of a sequence is a series of LV2_Atom_Event, each aligned
- to 64-bits, e.g.:
- <pre>
- | Event 1 (size 6) | Event 2
- | | | | | | | | |
- | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
- |FRAMES |SUBFRMS|TYPE |SIZE |DATADATADATAPAD|FRAMES |SUBFRMS|...
- </pre>
-*/
-typedef struct {
- uint32_t unit; /**< URID of unit of event time stamps. */
- uint32_t pad; /**< Currently unused. */
- /* Contents (a series of events) follow here. */
-} LV2_Atom_Sequence_Body;
-
-/** An atom:Sequence. */
-typedef struct {
- LV2_Atom atom; /**< Atom header. */
- LV2_Atom_Sequence_Body body; /**< Body. */
-} LV2_Atom_Sequence;
-
-/**
- @}
-*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* LV2_ATOM_H */
diff --git a/lv2/lv2plug.in/ns/ext/atom/atom.ttl b/lv2/lv2plug.in/ns/ext/atom/atom.ttl
deleted file mode 100644
index 891cd1f..0000000
--- a/lv2/lv2plug.in/ns/ext/atom/atom.ttl
+++ /dev/null
@@ -1,602 +0,0 @@
-@prefix atom: <http://lv2plug.in/ns/ext/atom#> .
-@prefix lv2: <http://lv2plug.in/ns/lv2core#> .
-@prefix owl: <http://www.w3.org/2002/07/owl#> .
-@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-@prefix ui: <http://lv2plug.in/ns/extensions/ui#> .
-@prefix units: <http://lv2plug.in/ns/extensions/units#> .
-@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
-
-<http://lv2plug.in/ns/ext/atom>
- a owl:Ontology ;
- rdfs:seeAlso <atom.h> ,
- <util.h> ,
- <forge.h> ,
- <lv2-atom.doap.ttl> ;
- lv2:documentation """
-
-<p>An #Atom is a simple generic data container for holding any type of Plain
-Old Data (POD). An #Atom can contain simple primitive types like integers,
-floating point numbers, and strings; as well as structured data like lists and
-dictionary-like <q>Objects</q>. Since Atoms are POD, they can be easily copied
-(e.g. using <code>memcpy</code>) anywhere and are suitable for use in real-time
-code.</p>
-
-<p>Every atom starts with an LV2_Atom header, followed by the contents. This
-allows code to process atoms without requiring special code for every type of
-data. For example, plugins that mutually understand a type can be used
-together in a host that does not understand that type, because the host is only
-required to copy atoms, not interpret their contents. Similarly, plugins (such
-as routers, delays, or data structures) can meaningfully process atoms of a
-type unknown to them.</p>
-
-<p>Atoms should be used anywhere values of various types must be stored or
-transmitted. The port type #AtomPort can be used to transmit atoms via ports.
-An #AtomPort that contains an #Sequence can be used for sample accurate event
-communication, such as MIDI, and replaces the earlier event extension.</p>
-
-<h3>Serialisation</h3>
-
-<p>Each Atom type defines a binary format for use at runtime, but also a
-serialisation that is natural to express in Turtle format. Thus, this
-specification defines a powerful real-time appropriate data model, as well as a
-portable way to serialise any data in that model. This is particularly useful
-for inter-process communication, saving/restoring state, and describing values
-in plugin data files.</p>
-
-<h3>Custom Atom Types</h3>
-
-<p>While it is possible to define new Atom types for any binary format, the
-standard types defined here are powerful enough to describe almost anything.
-Implementations SHOULD build structures out of the types provided here, rather
-than define new binary formats (e.g. use #Tuple or #Object rather than
-a new C <code>struct</code> type). Current implementations have support for
-serialising all standard types, so new binary formats are an implementation
-burden which harms interoperabilty. In particular, plugins SHOULD NOT expect
-UI communication or state saving with custom Atom types to work. In general,
-new Atom types should only be defined where absolutely necessary due to
-performance reasons and serialisation is not a concern.</p>
-""" .
-
-atom:cType
- a rdf:Property ,
- owl:DatatypeProperty ,
- owl:FunctionalProperty ;
- rdfs:label "C type" ;
- rdfs:domain rdfs:Class ;
- rdfs:range lv2:Symbol ;
- rdfs:comment """The identifier for a C type describing the binary representation of an Atom of this type.""" .
-
-atom:Atom
- a rdfs:Class ;
- rdfs:label "Atom" ;
- atom:cType "LV2_Atom" ;
- lv2:documentation """
-<p>Abstract base class for all atoms. An LV2_Atom has a 32-bit
-<code>size</code> and <code>type</code> followed by a body of <code>size</code>
-bytes. Atoms MUST be 64-bit aligned.</p>
-
-<p>All concrete Atom types (subclasses of this class) MUST define a precise
-binary layout for their body.</p>
-
-<p>The <code>type</code> field is the URI of an Atom type mapped to an integer.
-Implementations SHOULD gracefully pass through, or ignore, atoms with unknown
-types.</p>
-
-<p>All atoms are POD by definition except references, which as a special case
-have <code>type = 0</code>. An Atom MUST NOT contain a Reference. It is safe
-to copy any non-reference Atom with a simple <code>memcpy</code>, even if the
-implementation does not understand <code>type</code>. Though this extension
-reserves the type 0 for references, the details of reference handling are
-currently unspecified. A future revision of this extension, or a different
-extension, may define how to use non-POD data and references. Implementations
-MUST NOT send references to another implementation unless the receiver is
-explicitly known to support references (e.g. by supporting a feature).</p>
-
-<p>The atom with both <code>type</code> <em>and</em> <code>size</code> 0 is
-<q>null</q>, which is not considered a Reference.</p>
-""" .
-
-atom:Chunk
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Chunk of memory" ;
- owl:onDatatype xsd:base64Binary ;
- lv2:documentation """
-<p>A chunk of memory with undefined contents. This type is used to indicate a
-certain amount of space is available. For example, output ports with a
-variably sized type are connected to a Chunk so the plugin knows the size of
-the buffer available for writing.</p>
-
-<p>The use of a Chunk should be constrained to a local scope, since
-interpreting it is impossible without context. However, if serialised to RDF,
-a Chunk may be represented directly as an xsd:base64Binary string, e.g.:</p>
-
-<pre class="turtle-code">
-[] eg:someChunk "vu/erQ=="^^xsd:base64Binary .
-</pre>
-""" .
-
-atom:Number
- a rdfs:Class ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Number" .
-
-atom:Int
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:Number ;
- rdfs:label "Signed 32-bit integer" ;
- atom:cType "LV2_Atom_Int" ;
- owl:onDatatype xsd:int .
-
-atom:Long
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:Number ;
- rdfs:label "Signed 64-bit integer" ;
- atom:cType "LV2_Atom_Long" ;
- owl:onDatatype xsd:long .
-
-atom:Float
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:Number ;
- rdfs:label "32-bit floating point number" ;
- atom:cType "LV2_Atom_Float" ;
- owl:onDatatype xsd:float .
-
-atom:Double
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:Number ;
- rdfs:label "64-bit floating point number" ;
- atom:cType "LV2_Atom_Double" ;
- owl:onDatatype xsd:double .
-
-atom:Bool
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Boolean" ;
- atom:cType "LV2_Atom_Bool" ;
- owl:onDatatype xsd:boolean ;
- rdfs:comment "An Int where 0 is false and any other value is true." .
-
-atom:String
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "String" ;
- atom:cType "LV2_Atom_String" ;
- owl:onDatatype xsd:string ;
- lv2:documentation """
-<p>A UTF-8 encoded string.</p>
-
-<p>The body of an LV2_Atom_String is a C string in UTF-8 encoding, i.e. an
-array of bytes (<code>uint8_t</code>) terminated with a NULL byte
-(<code>'\\0'</code>).</p>
-
-<p>This type is for free-form strings, but SHOULD NOT be used for typed data or
-text in any language. Use atom:Literal unless translating the string does not
-make sense and the string has no meaningful datatype.</p>
-""" .
-
-atom:Literal
- a rdfs:Class ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "String Literal" ;
- atom:cType "LV2_Atom_Literal" ;
- lv2:documentation """
-<p>A UTF-8 encoded string literal, with an optional datatype or language.</p>
-
-<p>This type is compatible with rdfs:Literal and is capable of expressing a
-string in any language or a value of any type. A Literal has a
-<code>datatype</code> and <code>lang</code> followed by string data in UTF-8
-encoding. The length of the string data in bytes is <code>size -
-sizeof(LV2_Atom_Literal)</code>, including the terminating NULL character. The
-<code>lang</code> field SHOULD be a URI of the form
-&lt;http://lexvo.org/id/iso639-3/LANG&gt; or
-&lt;http://lexvo.org/id/iso639-1/LANG&gt; where LANG is a 3-character ISO 693-3
-language code, or a 2-character ISO 693-1 language code, respectively.</p>
-
-<p>A Literal may have a <code>datatype</code> OR a <code>lang</code>, but never
-both.</p>
-
-<p>For example, a Literal can be "Hello" in English:</p>
-<pre class="c-code">
-void set_to_hello_in_english(LV2_Atom_Literal* lit) {
- lit->atom.type = map(expand("atom:Literal"));
- lit->atom.size = 14;
- lit->body.datatype = 0;
- lit->body.lang = map("http://lexvo.org/id/iso639-1/en");
- memcpy(LV2_ATOM_CONTENTS(LV2_Atom_Literal, lit),
- "Hello",
- sizeof("Hello")); // Assumes enough space
-}
-</pre>
-
-<p>or a Turtle string:</p>
-<pre class="c-code">
-void set_to_turtle_string(LV2_Atom_Literal* lit, const char* ttl) {
- lit->atom.type = map(expand("atom:Literal"));
- lit->atom.size = 64;
- lit->body.datatype = map("http://www.w3.org/2008/turtle#turtle");
- lit->body.lang = 0;
- memcpy(LV2_ATOM_CONTENTS(LV2_Atom_Literal, lit),
- ttl,
- strlen(ttl) + 1); // Assumes enough space
-}
-</pre>
-""" .
-
-atom:Path
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:URI ;
- owl:onDatatype atom:URI ;
- rdfs:label "File path string" ;
- lv2:documentation """
-<p>A local file path.</p>
-
-<p>A Path is a URI reference with only a path component: no scheme, authority,
-query, or fragment. In particular, paths to files in the same bundle may be
-cleanly written in Turtle files as a relative URI. However, implementations
-may assume any binary Path (e.g. in an event payload) is a valid file path
-which can passed to system functions like fopen() directly, without any
-character encoding or escape expansion required.</p>
-
-<p>Any implemenation that creates a Path atom to transmit to another is
-responsible for ensuring it is valid. A Path SHOULD always be absolute, unless
-there is some mechanism in place that defines a base path. Since this is not
-the case for plugin instances, effectively any Path sent to or received from a
-plugin instance MUST be absolute.</p>
-""" .
-
-atom:URI
- a rdfs:Class ,
- rdfs:Datatype ;
- rdfs:subClassOf atom:String ;
- owl:onDatatype xsd:anyURI ;
- rdfs:label "URI string" ;
- lv2:documentation """
-<p>A URI string. This is useful when a URI is needed but mapping is
-inappropriate, for example with temporary or relative URIs. Since the ability
-to distinguish URIs from plain strings is often necessary, URIs MUST NOT be
-transmitted as atom:String.</p>
-
-<p>This is not strictly a URI, since UTF-8 is allowed. Escaping and related
-issues are the host's responsibility.</p>
-""" .
-
-atom:URID
- a rdfs:Class ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Integer URID" ;
- atom:cType "LV2_Atom_URID" ;
- lv2:documentation """
-<p>An unsigned 32-bit integer mapped from a URI (e.g. with LV2_URID_Map).</p>
-""" .
-
-atom:Vector
- a rdfs:Class ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Vector" ;
- atom:cType "LV2_Atom_Vector" ;
- lv2:documentation """
-<p>A homogeneous series of atom bodies with equivalent type and size.</p>
-
-<p>An LV2_Atom_Vector is a 32-bit <code>child_size</code> and
-<code>child_type</code> followed by <code>size / child_size</code> atom
-bodies.</p>
-
-<p>For example, an atom:Vector containing 42 elements of type atom:Float:</p>
-<pre class="c-code">
-struct VectorOf42Floats {
- uint32_t size; // sizeof(LV2_Atom_Vector_Body) + (42 * sizeof(float);
- uint32_t type; // map(expand("atom:Vector"))
- uint32_t child_size; // sizeof(float)
- uint32_t child_type; // map(expand("atom:Float"))
- float elems[42];
-};
-</pre>
-
-<p>Note that it is possible to construct a valid Atom for each element
-of the vector, even by an implementation which does not understand
-<code>child_type</code>.</p>
-
-<p>If serialised to RDF, a Vector SHOULD have the form:</p>
-
-<pre class="turtle-code">
-eg:someVector
- a atom:Vector ;
- atom:childType atom:Int ;
- rdf:value (
- "1"^^xsd:int
- "2"^^xsd:int
- "3"^^xsd:int
- "4"^^xsd:int
- ) .
-</pre>
-""" .
-
-atom:Tuple
- a rdfs:Class ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Tuple" ;
- lv2:documentation """
-<p>A series of Atoms with varying <code>type</code> and <code>size</code>.</p>
-
-<p>The body of a Tuple is simply a series of complete atoms, each aligned to
-64 bits.</p>
-
-<p>If serialised to RDF, a Tuple SHOULD have the form:</p>
-
-<pre class="turtle-code">
-eg:someVector
- a atom:Tuple ;
- rdf:value (
- "1"^^xsd:int
- "3.5"^^xsd:float
- "etc"
- ) .
-</pre>
-
-""" .
-
-atom:Property
- a rdfs:Class ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Property" ;
- atom:cType "LV2_Atom_Property" ;
- lv2:documentation """
-<p>A property of an atom:Object. An LV2_Atom_Property has a URID
-<code>key</code> and <code>context</code>, and an Atom <code>value</code>.
-This corresponds to an RDF Property, where the <q>key</q> is the <q>predicate</q>
-and the <q>value</q> is the object.</p>
-
-<p>The <code>context</code> field can be used to specify a different context
-for each property, where this is useful. Otherwise, it may be 0.</p>
-
-<p>Properties generally only exist as part of an atom:Object. Accordingly,
-they will typically be represented directly as properties in RDF (see
-atom:Object). If this is not possible, they may be expressed as partial
-reified statements, e.g.:</p>
-
-<pre class="turtle-code">
-eg:someProperty
- rdf:predicate eg:theKey ;
- rdf:object eg:theValue .
-</pre>
-""" .
-
-atom:Object
- a rdfs:Class ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Object" ;
- atom:cType "LV2_Atom_Object" ;
- lv2:documentation """
-<p>An <q>Object</q> is an atom with a set of properties. This corresponds to
-an RDF Resource, and can be thought of as a dictionary with URID keys.</p>
-
-<p>An LV2_Atom_Object body has a uint32_t <code>id</code> and
-<code>type</code>, followed by a series of atom:Property bodies
-(LV2_Atom_Property_Body). The LV2_Atom_Object_Body::otype field is equivalent
-to a property with key rdf:type, but is included in the structure to allow for
-fast dispatching.</p>
-
-<p>Code SHOULD check for objects using lv2_atom_forge_is_object() or
-lv2_atom_forge_is_blank() if a forge is available, rather than checking the
-atom type directly. This will correctly handle the deprecated atom:Resource
-and atom:Blank types.</p>
-
-<p>When serialised to RDF, an Object is represented as a resource, e.g.:</p>
-
-<pre class="turtle-code">
-eg:someObject
- eg:firstPropertyKey "first property value" ;
- eg:secondPropertyKey "first loser" ;
- eg:andSoOn "and so on" .
-</pre>
-""" .
-
-atom:Resource
- a rdfs:Class ;
- rdfs:subClassOf atom:Object ;
- rdfs:label "Resource" ;
- owl:deprecated "true"^^xsd:boolean ;
- atom:cType "LV2_Atom_Object" ;
- lv2:documentation """
-<p>This class is deprecated. Use atom:Object instead.</p>
-
-<p>An atom:Object where the <code>id</code> field is a URID, i.e. an Object
-with a URI.</p>
-""" .
-
-atom:Blank
- a rdfs:Class ;
- rdfs:subClassOf atom:Object ;
- rdfs:label "Blank" ;
- owl:deprecated "true"^^xsd:boolean ;
- atom:cType "LV2_Atom_Object" ;
- lv2:documentation """
-<p>This class is deprecated. Use atom:Object with ID 0 instead.</p>
-
-<p>An atom:Object where the LV2_Atom_Object::id is a blank node ID (NOT a URI).
-The ID of a Blank is valid only within the context the Blank appears in. For
-ports this is the context of the associated run() call, i.e. all ports share
-the same context so outputs can contain IDs that correspond to IDs of blanks in
-the input.</p>
-""" .
-
-atom:Sound
- a rdfs:Class ;
- rdfs:subClassOf atom:Vector ;
- rdfs:label "Sound" ;
- atom:cType "LV2_Atom_Sound" ;
- lv2:documentation """
-<p>An atom:Vector of atom:Float which represents an audio waveform. The format
-is the same as the buffer format for lv2:AudioPort (except the size may be
-arbitrary). An atom:Sound inherently depends on the sample rate, which is
-assumed to be known from context. Because of this, directly serialising an
-atom:Sound is probably a bad idea, use a standard format like WAV instead.</p>
-""" .
-
-atom:frameTime
- a rdf:Property ,
- owl:DatatypeProperty ,
- owl:FunctionalProperty ;
- rdfs:range xsd:decimal ;
- rdfs:label "frame time" ;
- lv2:documentation """
-<p>Time stamp in audio frames. Typically used for events.</p>
-""" .
-
-atom:beatTime
- a rdf:Property ,
- owl:DatatypeProperty ,
- owl:FunctionalProperty ;
- rdfs:range xsd:decimal ;
- rdfs:label "beat time" ;
- lv2:documentation """
-<p>Time stamp in beats. Typically used for events.</p>
-""" .
-
-atom:Event
- a rdfs:Class ;
- rdfs:label "Event" ;
- atom:cType "LV2_Atom_Event" ;
- lv2:documentation """
-<p>An atom with a time stamp prefix, typically an element of an atom:Sequence.
-Note this is not an Atom type.</p>
-""" .
-
-atom:Sequence
- a rdfs:Class ;
- rdfs:subClassOf atom:Atom ;
- rdfs:label "Sequence" ;
- atom:cType "LV2_Atom_Sequence" ;
- lv2:documentation """
-<p>A sequence of atom:Event, i.e. a series of time-stamped Atoms.</p>
-
-<p>LV2_Atom_Sequence_Body.unit describes the time unit for the contained atoms.
-If the unit is known from context (e.g. run() stamps are always audio frames),
-this field may be zero. Otherwise, it SHOULD be either units:frame or
-units:beat, in which case ev.time.frames or ev.time.beats is valid,
-respectively.</p>
-
-<p>If serialised to RDF, a Sequence has a similar form to atom:Vector, but for
-brevity the elements may be assumed to be atom:Event, e.g.:</p>
-
-<pre class="turtle-code">
-eg:someSequence
- a atom:Sequence ;
- rdf:value (
- [
- atom:frameTime 1 ;
- rdf:value "901A01"^^midi:MidiEvent
- ] [
- atom:frameTime 3 ;
- rdf:value "902B02"^^midi:MidiEvent
- ]
- ) .
-</pre>
-""" .
-
-atom:AtomPort
- a rdfs:Class ;
- rdfs:subClassOf lv2:Port ;
- rdfs:label "Atom Port" ;
- lv2:documentation """
-<p>A port which contains an atom:Atom. Ports of this type are connected to an
-LV2_Atom with a type specified by atom:bufferType.</p>
-
-<p>Output ports with a variably sized type MUST be initialised by the host
-before every run() to an atom:Chunk with size set to the available space. The
-plugin reads this size to know how much space is available for writing. In all
-cases, the plugin MUST write a complete atom (including header) to outputs.
-However, to be robust, hosts SHOULD initialise output ports to a safe sentinel
-(e.g. the null Atom) before calling run().</p>
-""" .
-
-atom:bufferType
- a rdf:Property ,
- owl:ObjectProperty ;
- rdfs:domain atom:AtomPort ;
- rdfs:range rdfs:Class ;
- rdfs:label "buffer type" ;
- lv2:documentation """
-<p>Indicates that an AtomPort may be connected to a certain Atom type. A port
-MAY support several buffer types. The host MUST NOT connect a port to an Atom
-with a type not explicitly listed with this property. The value of this
-property MUST be a sub-class of atom:Atom. For example, an input port that is
-connected directly to an LV2_Atom_Double value is described like so:</p>
-
-<pre class="turtle-code">
-&lt;plugin&gt;
- lv2:port [
- a lv2:InputPort , atom:AtomPort ;
- atom:bufferType atom:Double ;
- ] .
-</pre>
-
-<p>This property only describes the types a port may be <em>directly</em>
-connected to. It says nothing about the expected contents of containers. For
-that, use atom:supports.</p>
-""" .
-
-atom:childType
- a rdf:Property ,
- owl:ObjectProperty ;
- rdfs:label "child type" ;
- rdfs:comment "The type of a container's children." .
-
-atom:supports
- a rdf:Property ;
- rdfs:label "supports" ;
- rdfs:range rdfs:Class ;
- lv2:documentation """
-<p>Indicates that a particular Atom type is supported.</p>
-
-<p>This property is defined loosely, it may be used to indicate that anything
-<q>supports</q> an Atom type, wherever that may be useful. It applies
-<q>recursively</q> where collections are involved.</p>
-
-<p>In particular, this property can be used to describe which event types are
-expected by a port. For example, a port that receives MIDI events is described
-like so:</p>
-
-<pre class="turtle-code">
-&lt;plugin&gt;
- lv2:port [
- a lv2:InputPort , atom:AtomPort ;
- atom:bufferType atom:Sequence ;
- atom:supports midi:MidiEvent ;
- ] .
-</pre>
-""" .
-
-atom:eventTransfer
- a ui:PortProtocol ;
- rdfs:label "event transfer" ;
- lv2:documentation """
-<p>Transfer of individual events in a port buffer. Useful as the
-<code>format</code> for a LV2UI_Write_Function.</p>
-
-<p>This protocol applies to ports which contain events, usually in an
-atom:Sequence. The host must transfer each individual event to the recipient.
-The format of the received data is an LV2_Atom, there is no timestamp
-header.</p>
-""" .
-
-atom:atomTransfer
- a ui:PortProtocol ;
- rdfs:label "atom transfer" ;
- lv2:documentation """
-<p>Transfer of the complete atom in a port buffer. Useful as the
-<code>format</code> for a LV2UI_Write_Function.</p>
-
-<p>This protocol applies to atom ports. The host must transfer the complete
-atom contained in the port, including header.</p>
-""" .
diff --git a/lv2/lv2plug.in/ns/ext/atom/forge.h b/lv2/lv2plug.in/ns/ext/atom/forge.h
deleted file mode 100644
index bcdbf9e..0000000
--- a/lv2/lv2plug.in/ns/ext/atom/forge.h
+++ /dev/null
@@ -1,710 +0,0 @@
-/*
- Copyright 2008-2016 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 An API for constructing LV2 atoms.
-
- This file provides an API for constructing Atoms which makes it relatively
- simple to build nested atoms of arbitrary complexity without requiring
- dynamic memory allocation.
-
- The API is based on successively appending the appropriate pieces to build a
- complete Atom. The size of containers is automatically updated. Functions
- that begin a container return (via their frame argument) a stack frame which
- must be popped when the container is finished.
-
- All output is written to a user-provided buffer or sink function. This
- makes it popssible to create create atoms on the stack, on the heap, in LV2
- port buffers, in a ringbuffer, or elsewhere, all using the same API.
-
- This entire API is realtime safe if used with a buffer or a realtime safe
- sink, except lv2_atom_forge_init() which is only realtime safe if the URI
- map function is.
-
- Note these functions are all static inline, do not take their address.
-
- This header is non-normative, it is provided for convenience.
-*/
-
-/**
- @defgroup forge Forge
- @ingroup atom
- @{
-*/
-
-#ifndef LV2_ATOM_FORGE_H
-#define LV2_ATOM_FORGE_H
-
-#include <assert.h>
-
-#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
-#include "lv2/lv2plug.in/ns/ext/atom/util.h"
-#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
-
-#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
-# define LV2_ATOM_FORGE_DEPRECATED __attribute__((__deprecated__))
-#else
-# define LV2_ATOM_FORGE_DEPRECATED
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#else
-# include <stdbool.h>
-#endif
-
-// Disable deprecation warnings for Blank and Resource
-#if defined(__clang__)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-/** Handle for LV2_Atom_Forge_Sink. */
-typedef void* LV2_Atom_Forge_Sink_Handle;
-
-/** A reference to a chunk of written output. */
-typedef intptr_t LV2_Atom_Forge_Ref;
-
-/** Sink function for writing output. See lv2_atom_forge_set_sink(). */
-typedef LV2_Atom_Forge_Ref
-(*LV2_Atom_Forge_Sink)(LV2_Atom_Forge_Sink_Handle handle,
- const void* buf,
- uint32_t size);
-
-/** Function for resolving a reference. See lv2_atom_forge_set_sink(). */
-typedef LV2_Atom*
-(*LV2_Atom_Forge_Deref_Func)(LV2_Atom_Forge_Sink_Handle handle,
- LV2_Atom_Forge_Ref ref);
-
-/** A stack frame used for keeping track of nested Atom containers. */
-typedef struct _LV2_Atom_Forge_Frame {
- struct _LV2_Atom_Forge_Frame* parent;
- LV2_Atom_Forge_Ref ref;
-} LV2_Atom_Forge_Frame;
-
-/** A "forge" for creating atoms by appending to a buffer. */
-typedef struct {
- uint8_t* buf;
- uint32_t offset;
- uint32_t size;
-
- LV2_Atom_Forge_Sink sink;
- LV2_Atom_Forge_Deref_Func deref;
- LV2_Atom_Forge_Sink_Handle handle;
-
- LV2_Atom_Forge_Frame* stack;
-
- LV2_URID Blank LV2_ATOM_FORGE_DEPRECATED;
- LV2_URID Bool;
- LV2_URID Chunk;
- LV2_URID Double;
- LV2_URID Float;
- LV2_URID Int;
- LV2_URID Long;
- LV2_URID Literal;
- LV2_URID Object;
- LV2_URID Path;
- LV2_URID Property;
- LV2_URID Resource LV2_ATOM_FORGE_DEPRECATED;
- LV2_URID Sequence;
- LV2_URID String;
- LV2_URID Tuple;
- LV2_URID URI;
- LV2_URID URID;
- LV2_URID Vector;
-} LV2_Atom_Forge;
-
-static inline void
-lv2_atom_forge_set_buffer(LV2_Atom_Forge* forge, uint8_t* buf, size_t size);
-
-/**
- Initialise `forge`.
-
- URIs will be mapped using `map` and stored, a reference to `map` itself is
- not held.
-*/
-static inline void
-lv2_atom_forge_init(LV2_Atom_Forge* forge, LV2_URID_Map* map)
-{
- lv2_atom_forge_set_buffer(forge, NULL, 0);
- forge->Blank = map->map(map->handle, LV2_ATOM__Blank);
- forge->Bool = map->map(map->handle, LV2_ATOM__Bool);
- forge->Chunk = map->map(map->handle, LV2_ATOM__Chunk);
- forge->Double = map->map(map->handle, LV2_ATOM__Double);
- forge->Float = map->map(map->handle, LV2_ATOM__Float);
- forge->Int = map->map(map->handle, LV2_ATOM__Int);
- forge->Long = map->map(map->handle, LV2_ATOM__Long);
- forge->Literal = map->map(map->handle, LV2_ATOM__Literal);
- forge->Object = map->map(map->handle, LV2_ATOM__Object);
- forge->Path = map->map(map->handle, LV2_ATOM__Path);
- forge->Property = map->map(map->handle, LV2_ATOM__Property);
- forge->Resource = map->map(map->handle, LV2_ATOM__Resource);
- forge->Sequence = map->map(map->handle, LV2_ATOM__Sequence);
- forge->String = map->map(map->handle, LV2_ATOM__String);
- forge->Tuple = map->map(map->handle, LV2_ATOM__Tuple);
- forge->URI = map->map(map->handle, LV2_ATOM__URI);
- forge->URID = map->map(map->handle, LV2_ATOM__URID);
- forge->Vector = map->map(map->handle, LV2_ATOM__Vector);
-}
-
-/** Access the Atom pointed to by a reference. */
-static inline LV2_Atom*
-lv2_atom_forge_deref(LV2_Atom_Forge* forge, LV2_Atom_Forge_Ref ref)
-{
- if (forge->buf) {
- return (LV2_Atom*)ref;
- } else {
- return forge->deref(forge->handle, ref);
- }
-}
-
-/**
- @name Object Stack
- @{
-*/
-
-/**
- Push a stack frame.
- This is done automatically by container functions (which take a stack frame
- pointer), but may be called by the user to push the top level container when
- writing to an existing Atom.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_push(LV2_Atom_Forge* forge,
- LV2_Atom_Forge_Frame* frame,
- LV2_Atom_Forge_Ref ref)
-{
- frame->parent = forge->stack;
- frame->ref = ref;
- forge->stack = frame;
- return ref;
-}
-
-/** Pop a stack frame. This must be called when a container is finished. */
-static inline void
-lv2_atom_forge_pop(LV2_Atom_Forge* forge, LV2_Atom_Forge_Frame* frame)
-{
- assert(frame == forge->stack);
- forge->stack = frame->parent;
-}
-
-/** Return true iff the top of the stack has the given type. */
-static inline bool
-lv2_atom_forge_top_is(LV2_Atom_Forge* forge, uint32_t type)
-{
- return forge->stack && forge->stack->ref &&
- (lv2_atom_forge_deref(forge, forge->stack->ref)->type == type);
-}
-
-/** Return true iff `type` is an atom:Object. */
-static inline bool
-lv2_atom_forge_is_object_type(const LV2_Atom_Forge* forge, uint32_t type)
-{
- return (type == forge->Object ||
- type == forge->Blank ||
- type == forge->Resource);
-}
-
-/** Return true iff `type` is an atom:Object with a blank ID. */
-static inline bool
-lv2_atom_forge_is_blank(const LV2_Atom_Forge* forge,
- uint32_t type,
- const LV2_Atom_Object_Body* body)
-{
- return (type == forge->Blank ||
- (type == forge->Object && body->id == 0));
-}
-
-/**
- @}
- @name Output Configuration
- @{
-*/
-
-/** Set the output buffer where `forge` will write atoms. */
-static inline void
-lv2_atom_forge_set_buffer(LV2_Atom_Forge* forge, uint8_t* buf, size_t size)
-{
- forge->buf = buf;
- forge->size = (uint32_t)size;
- forge->offset = 0;
- forge->deref = NULL;
- forge->sink = NULL;
- forge->handle = NULL;
- forge->stack = NULL;
-}
-
-/**
- Set the sink function where `forge` will write output.
-
- The return value of forge functions is an LV2_Atom_Forge_Ref which is an
- integer type safe to use as a pointer but is otherwise opaque. The sink
- function must return a ref that can be dereferenced to access as least
- sizeof(LV2_Atom) bytes of the written data, so sizes can be updated. For
- ringbuffers, this should be possible as long as the size of the buffer is a
- multiple of sizeof(LV2_Atom), since atoms are always aligned.
-
- Note that 0 is an invalid reference, so if you are using a buffer offset be
- sure to offset it such that 0 is never a valid reference. You will get
- confusing errors otherwise.
-*/
-static inline void
-lv2_atom_forge_set_sink(LV2_Atom_Forge* forge,
- LV2_Atom_Forge_Sink sink,
- LV2_Atom_Forge_Deref_Func deref,
- LV2_Atom_Forge_Sink_Handle handle)
-{
- forge->buf = NULL;
- forge->size = forge->offset = 0;
- forge->deref = deref;
- forge->sink = sink;
- forge->handle = handle;
- forge->stack = NULL;
-}
-
-/**
- @}
- @name Low Level Output
- @{
-*/
-
-/**
- Write raw output. This is used internally, but is also useful for writing
- atom types not explicitly supported by the forge API. Note the caller is
- responsible for ensuring the output is approriately padded.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_raw(LV2_Atom_Forge* forge, const void* data, uint32_t size)
-{
- LV2_Atom_Forge_Ref out = 0;
- if (forge->sink) {
- out = forge->sink(forge->handle, data, size);
- } else {
- out = (LV2_Atom_Forge_Ref)forge->buf + forge->offset;
- uint8_t* mem = forge->buf + forge->offset;
- if (forge->offset + size > forge->size) {
- return 0;
- }
- forge->offset += size;
- memcpy(mem, data, size);
- }
- for (LV2_Atom_Forge_Frame* f = forge->stack; f; f = f->parent) {
- lv2_atom_forge_deref(forge, f->ref)->size += size;
- }
- return out;
-}
-
-/** Pad output accordingly so next write is 64-bit aligned. */
-static inline void
-lv2_atom_forge_pad(LV2_Atom_Forge* forge, uint32_t written)
-{
- const uint64_t pad = 0;
- const uint32_t pad_size = lv2_atom_pad_size(written) - written;
- lv2_atom_forge_raw(forge, &pad, pad_size);
-}
-
-/** Write raw output, padding to 64-bits as necessary. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_write(LV2_Atom_Forge* forge, const void* data, uint32_t size)
-{
- LV2_Atom_Forge_Ref out = lv2_atom_forge_raw(forge, data, size);
- if (out) {
- lv2_atom_forge_pad(forge, size);
- }
- return out;
-}
-
-/** Write a null-terminated string body. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_string_body(LV2_Atom_Forge* forge,
- const char* str,
- uint32_t len)
-{
- LV2_Atom_Forge_Ref out = lv2_atom_forge_raw(forge, str, len);
- if (out && (out = lv2_atom_forge_raw(forge, "", 1))) {
- lv2_atom_forge_pad(forge, len + 1);
- }
- return out;
-}
-
-/**
- @}
- @name Atom Output
- @{
-*/
-
-/** Write an atom:Atom header. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_atom(LV2_Atom_Forge* forge, uint32_t size, uint32_t type)
-{
- const LV2_Atom a = { size, type };
- return lv2_atom_forge_raw(forge, &a, sizeof(a));
-}
-
-/** Write a primitive (fixed-size) atom. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_primitive(LV2_Atom_Forge* forge, const LV2_Atom* a)
-{
- if (lv2_atom_forge_top_is(forge, forge->Vector)) {
- return lv2_atom_forge_raw(forge, LV2_ATOM_BODY_CONST(a), a->size);
- } else {
- return lv2_atom_forge_write(
- forge, a, (uint32_t)sizeof(LV2_Atom) + a->size);
- }
-}
-
-/** Write an atom:Int. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_int(LV2_Atom_Forge* forge, int32_t val)
-{
- const LV2_Atom_Int a = { { sizeof(val), forge->Int }, val };
- return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:Long. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_long(LV2_Atom_Forge* forge, int64_t val)
-{
- const LV2_Atom_Long a = { { sizeof(val), forge->Long }, val };
- return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:Float. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_float(LV2_Atom_Forge* forge, float val)
-{
- const LV2_Atom_Float a = { { sizeof(val), forge->Float }, val };
- return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:Double. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_double(LV2_Atom_Forge* forge, double val)
-{
- const LV2_Atom_Double a = { { sizeof(val), forge->Double }, val };
- return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:Bool. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_bool(LV2_Atom_Forge* forge, bool val)
-{
- const LV2_Atom_Bool a = { { sizeof(int32_t), forge->Bool }, val ? 1 : 0 };
- return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:URID. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_urid(LV2_Atom_Forge* forge, LV2_URID id)
-{
- const LV2_Atom_URID a = { { sizeof(id), forge->URID }, id };
- return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom compatible with atom:String. Used internally. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_typed_string(LV2_Atom_Forge* forge,
- uint32_t type,
- const char* str,
- uint32_t len)
-{
- const LV2_Atom_String a = { { len + 1, type } };
- LV2_Atom_Forge_Ref out = lv2_atom_forge_raw(forge, &a, sizeof(a));
- if (out) {
- if (!lv2_atom_forge_string_body(forge, str, len)) {
- LV2_Atom* atom = lv2_atom_forge_deref(forge, out);
- atom->size = atom->type = 0;
- out = 0;
- }
- }
- return out;
-}
-
-/** Write an atom:String. Note that `str` need not be NULL terminated. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_string(LV2_Atom_Forge* forge, const char* str, uint32_t len)
-{
- return lv2_atom_forge_typed_string(forge, forge->String, str, len);
-}
-
-/**
- Write an atom:URI. Note that `uri` need not be NULL terminated.
- This does not map the URI, but writes the complete URI string. To write
- a mapped URI, use lv2_atom_forge_urid().
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_uri(LV2_Atom_Forge* forge, const char* uri, uint32_t len)
-{
- return lv2_atom_forge_typed_string(forge, forge->URI, uri, len);
-}
-
-/** Write an atom:Path. Note that `path` need not be NULL terminated. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_path(LV2_Atom_Forge* forge, const char* path, uint32_t len)
-{
- return lv2_atom_forge_typed_string(forge, forge->Path, path, len);
-}
-
-/** Write an atom:Literal. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_literal(LV2_Atom_Forge* forge,
- const char* str,
- uint32_t len,
- uint32_t datatype,
- uint32_t lang)
-{
- const LV2_Atom_Literal a = {
- { (uint32_t)(sizeof(LV2_Atom_Literal) - sizeof(LV2_Atom) + len + 1),
- forge->Literal },
- { datatype,
- lang }
- };
- LV2_Atom_Forge_Ref out = lv2_atom_forge_raw(forge, &a, sizeof(a));
- if (out) {
- if (!lv2_atom_forge_string_body(forge, str, len)) {
- LV2_Atom* atom = lv2_atom_forge_deref(forge, out);
- atom->size = atom->type = 0;
- out = 0;
- }
- }
- return out;
-}
-
-/** Start an atom:Vector. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_vector_head(LV2_Atom_Forge* forge,
- LV2_Atom_Forge_Frame* frame,
- uint32_t child_size,
- uint32_t child_type)
-{
- const LV2_Atom_Vector a = {
- { sizeof(LV2_Atom_Vector_Body), forge->Vector },
- { child_size, child_type }
- };
- return lv2_atom_forge_push(
- forge, frame, lv2_atom_forge_write(forge, &a, sizeof(a)));
-}
-
-/** Write a complete atom:Vector. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_vector(LV2_Atom_Forge* forge,
- uint32_t child_size,
- uint32_t child_type,
- uint32_t n_elems,
- const void* elems)
-{
- const LV2_Atom_Vector a = {
- { (uint32_t)(sizeof(LV2_Atom_Vector_Body) + n_elems * child_size),
- forge->Vector },
- { child_size, child_type }
- };
- LV2_Atom_Forge_Ref out = lv2_atom_forge_write(forge, &a, sizeof(a));
- if (out) {
- lv2_atom_forge_write(forge, elems, child_size * n_elems);
- }
- return out;
-}
-
-/**
- Write the header of an atom:Tuple.
-
- The passed frame will be initialised to represent this tuple. To complete
- the tuple, write a sequence of atoms, then pop the frame with
- lv2_atom_forge_pop().
-
- For example:
- @code
- // Write tuple (1, 2.0)
- LV2_Atom_Forge_Frame frame;
- LV2_Atom* tup = (LV2_Atom*)lv2_atom_forge_tuple(forge, &frame);
- lv2_atom_forge_int32(forge, 1);
- lv2_atom_forge_float(forge, 2.0);
- lv2_atom_forge_pop(forge, &frame);
- @endcode
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_tuple(LV2_Atom_Forge* forge, LV2_Atom_Forge_Frame* frame)
-{
- const LV2_Atom_Tuple a = { { 0, forge->Tuple } };
- return lv2_atom_forge_push(
- forge, frame, lv2_atom_forge_write(forge, &a, sizeof(a)));
-}
-
-/**
- Write the header of an atom:Object.
-
- The passed frame will be initialised to represent this object. To complete
- the object, write a sequence of properties, then pop the frame with
- lv2_atom_forge_pop().
-
- For example:
- @code
- LV2_URID eg_Cat = map("http://example.org/Cat");
- LV2_URID eg_name = map("http://example.org/name");
-
- // Start object with type eg_Cat and blank ID
- LV2_Atom_Forge_Frame frame;
- lv2_atom_forge_object(forge, &frame, 0, eg_Cat);
-
- // Append property eg:name = "Hobbes"
- lv2_atom_forge_key(forge, eg_name);
- lv2_atom_forge_string(forge, "Hobbes", strlen("Hobbes"));
-
- // Finish object
- lv2_atom_forge_pop(forge, &frame);
- @endcode
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_object(LV2_Atom_Forge* forge,
- LV2_Atom_Forge_Frame* frame,
- LV2_URID id,
- LV2_URID otype)
-{
- const LV2_Atom_Object a = {
- { (uint32_t)sizeof(LV2_Atom_Object_Body), forge->Object },
- { id, otype }
- };
- return lv2_atom_forge_push(
- forge, frame, lv2_atom_forge_write(forge, &a, sizeof(a)));
-}
-
-/**
- The same as lv2_atom_forge_object(), but for object:Resource.
-
- This function is deprecated and should not be used in new code.
- Use lv2_atom_forge_object() directly instead.
-*/
-LV2_ATOM_FORGE_DEPRECATED
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_resource(LV2_Atom_Forge* forge,
- LV2_Atom_Forge_Frame* frame,
- LV2_URID id,
- LV2_URID otype)
-{
- const LV2_Atom_Object a = {
- { (uint32_t)sizeof(LV2_Atom_Object_Body), forge->Resource },
- { id, otype }
- };
- return lv2_atom_forge_push(
- forge, frame, lv2_atom_forge_write(forge, &a, sizeof(a)));
-}
-
-/**
- The same as lv2_atom_forge_object(), but for object:Blank.
-
- This function is deprecated and should not be used in new code.
- Use lv2_atom_forge_object() directly instead.
-*/
-LV2_ATOM_FORGE_DEPRECATED
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_blank(LV2_Atom_Forge* forge,
- LV2_Atom_Forge_Frame* frame,
- uint32_t id,
- LV2_URID otype)
-{
- const LV2_Atom_Object a = {
- { (uint32_t)sizeof(LV2_Atom_Object_Body), forge->Blank },
- { id, otype }
- };
- return lv2_atom_forge_push(
- forge, frame, lv2_atom_forge_write(forge, &a, sizeof(a)));
-}
-
-/**
- Write a property key in an Object, to be followed by the value.
-
- See lv2_atom_forge_object() documentation for an example.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_key(LV2_Atom_Forge* forge,
- LV2_URID key)
-{
- const LV2_Atom_Property_Body a = { key, 0, { 0, 0 } };
- return lv2_atom_forge_write(forge, &a, 2 * (uint32_t)sizeof(uint32_t));
-}
-
-/**
- Write the header for a property body in an object, with context.
-
- If you do not need the context, which is almost certainly the case,
- use the simpler lv2_atom_forge_key() instead.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_property_head(LV2_Atom_Forge* forge,
- LV2_URID key,
- LV2_URID context)
-{
- const LV2_Atom_Property_Body a = { key, context, { 0, 0 } };
- return lv2_atom_forge_write(forge, &a, 2 * (uint32_t)sizeof(uint32_t));
-}
-
-/**
- Write the header for a Sequence.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_sequence_head(LV2_Atom_Forge* forge,
- LV2_Atom_Forge_Frame* frame,
- uint32_t unit)
-{
- const LV2_Atom_Sequence a = {
- { (uint32_t)sizeof(LV2_Atom_Sequence_Body), forge->Sequence },
- { unit, 0 }
- };
- return lv2_atom_forge_push(
- forge, frame, lv2_atom_forge_write(forge, &a, sizeof(a)));
-}
-
-/**
- Write the time stamp header of an Event (in a Sequence) in audio frames.
- After this, call the appropriate forge method(s) to write the body. Note
- the returned reference is to an LV2_Event which is NOT an Atom.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_frame_time(LV2_Atom_Forge* forge, int64_t frames)
-{
- return lv2_atom_forge_write(forge, &frames, sizeof(frames));
-}
-
-/**
- Write the time stamp header of an Event (in a Sequence) in beats. After
- this, call the appropriate forge method(s) to write the body. Note the
- returned reference is to an LV2_Event which is NOT an Atom.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_beat_time(LV2_Atom_Forge* forge, double beats)
-{
- return lv2_atom_forge_write(forge, &beats, sizeof(beats));
-}
-
-/**
- @}
- @}
-*/
-
-#if defined(__clang__)
-# pragma clang diagnostic pop
-#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-# pragma GCC diagnostic pop
-#endif
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* LV2_ATOM_FORGE_H */
diff --git a/lv2/lv2plug.in/ns/ext/atom/lv2-atom.doap.ttl b/lv2/lv2plug.in/ns/ext/atom/lv2-atom.doap.ttl
deleted file mode 100644
index 681ff77..0000000
--- a/lv2/lv2plug.in/ns/ext/atom/lv2-atom.doap.ttl
+++ /dev/null
@@ -1,102 +0,0 @@
-@prefix dcs: <http://ontologi.es/doap-changeset#> .
-@prefix doap: <http://usefulinc.com/ns/doap#> .
-@prefix foaf: <http://xmlns.com/foaf/0.1/> .
-@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-
-<http://lv2plug.in/ns/ext/atom>
- a doap:Project ;
- doap:name "LV2 Atom" ;
- doap:shortdesc "A generic value container and several data types." ;
- doap:license <http://opensource.org/licenses/isc> ;
- doap:created "2007-00-00" ;
- doap:developer <http://drobilla.net/drobilla#me> ;
- doap:release [
- doap:revision "2.1" ;
- doap:created "2016-10-03" ;
- dcs:blame <http://drobilla.net/drobilla#me> ;
- dcs:changeset [
- dcs:item [
- rdfs:label "Add lv2_atom_object_get_typed() for easy type-safe access to object properties."
- ]
- ]
- ] , [
- doap:revision "2.0" ;
- doap:created "2014-08-08" ;
- doap:file-release <http://lv2plug.in/spec/lv2-1.10.0.tar.bz2> ;
- dcs:blame <http://drobilla.net/drobilla#me> ;
- dcs:changeset [
- dcs:item [
- rdfs:label "Deprecate Blank and Resource in favour of just Object."
- ] , [
- rdfs:label "Add lv2_atom_forge_is_object_type() and lv2_atom_forge_is_blank() to ease backwards compatibility."
- ] , [
- rdfs:label "Add lv2_atom_forge_key() for terser object writing."
- ] , [
- rdfs:label "Add lv2_atom_sequence_clear() and lv2_atom_sequence_append_event() helper functions."
- ]
- ]
- ] , [
- doap:revision "1.8" ;
- doap:created "2014-01-04" ;
- doap:file-release <http://lv2plug.in/spec/lv2-1.8.0.tar.bz2> ;
- dcs:blame <http://drobilla.net/drobilla#me> ;
- dcs:changeset [
- dcs:item [
- rdfs:label "Make lv2_atom_*_is_end() arguments const."
- ]
- ]
- ] , [
- doap:revision "1.6" ;
- doap:created "2013-05-26" ;
- doap:file-release <http://lv2plug.in/spec/lv2-1.6.0.tar.bz2> ;
- dcs:blame <http://drobilla.net/drobilla#me> ;
- dcs:changeset [
- dcs:item [
- rdfs:label "Fix crash in forge.h when pushing atoms to a full buffer."
- ]
- ]
- ] , [
- doap:revision "1.4" ;
- doap:created "2013-01-27" ;
- doap:file-release <http://lv2plug.in/spec/lv2-1.4.0.tar.bz2> ;
- dcs:blame <http://drobilla.net/drobilla#me> ;
- dcs:changeset [
- dcs:item [
- rdfs:label "Fix lv2_atom_sequence_end()."
- ] , [
- rdfs:label "Remove atom:stringType in favour of owl:onDatatype so generic tools can understand and validate atom literals."
- ] , [
- rdfs:label "Improve atom documentation."
- ]
- ]
- ] , [
- doap:revision "1.2" ;
- doap:created "2012-10-14" ;
- doap:file-release <http://lv2plug.in/spec/lv2-1.2.0.tar.bz2> ;
- dcs:blame <http://drobilla.net/drobilla#me> ;
- dcs:changeset [
- dcs:item [
- rdfs:label "Fix implicit conversions in forge.h that are invalid in C++11."
- ] , [
- rdfs:label "Fix lv2_atom_object_next() on 32-bit platforms."
- ] , [
- rdfs:label "Add lv2_atom_object_body_get()."
- ] , [
- rdfs:label "Fix outdated documentation in forge.h."
- ] , [
- rdfs:label "Use consistent label style."
- ] , [
- rdfs:label "Add LV2_ATOM_CONTENTS_CONST and LV2_ATOM_BODY_CONST."
- ]
- ]
- ] , [
- doap:revision "1.0" ;
- doap:created "2012-04-17" ;
- doap:file-release <http://lv2plug.in/spec/lv2-1.0.0.tar.bz2> ;
- dcs:blame <http://drobilla.net/drobilla#me> ;
- dcs:changeset [
- dcs:item [
- rdfs:label "Initial release."
- ]
- ]
- ] .
diff --git a/lv2/lv2plug.in/ns/ext/atom/manifest.ttl b/lv2/lv2plug.in/ns/ext/atom/manifest.ttl
deleted file mode 100644
index ebdf111..0000000
--- a/lv2/lv2plug.in/ns/ext/atom/manifest.ttl
+++ /dev/null
@@ -1,8 +0,0 @@
-@prefix lv2: <http://lv2plug.in/ns/lv2core#> .
-@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-
-<http://lv2plug.in/ns/ext/atom>
- a lv2:Specification ;
- lv2:minorVersion 2 ;
- lv2:microVersion 1 ;
- rdfs:seeAlso <atom.ttl> .
diff --git a/lv2/lv2plug.in/ns/ext/atom/util.h b/lv2/lv2plug.in/ns/ext/atom/util.h
deleted file mode 100644
index 5574e9b..0000000
--- a/lv2/lv2plug.in/ns/ext/atom/util.h
+++ /dev/null
@@ -1,509 +0,0 @@
-/*
- Copyright 2008-2015 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 util.h Helper functions for the LV2 Atom extension.
-
- Note these functions are all static inline, do not take their address.
-
- This header is non-normative, it is provided for convenience.
-*/
-
-/**
- @defgroup util Utilities
- @ingroup atom
- @{
-*/
-
-#ifndef LV2_ATOM_UTIL_H
-#define LV2_ATOM_UTIL_H
-
-#include <stdarg.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
-
-#ifdef __cplusplus
-extern "C" {
-#else
-# include <stdbool.h>
-#endif
-
-/** Pad a size to 64 bits. */
-static inline uint32_t
-lv2_atom_pad_size(uint32_t size)
-{
- return (size + 7U) & (~7U);
-}
-
-/** Return the total size of `atom`, including the header. */
-static inline uint32_t
-lv2_atom_total_size(const LV2_Atom* atom)
-{
- return (uint32_t)sizeof(LV2_Atom) + atom->size;
-}
-
-/** Return true iff `atom` is null. */
-static inline bool
-lv2_atom_is_null(const LV2_Atom* atom)
-{
- return !atom || (atom->type == 0 && atom->size == 0);
-}
-
-/** Return true iff `a` is equal to `b`. */
-static inline bool
-lv2_atom_equals(const LV2_Atom* a, const LV2_Atom* b)
-{
- return (a == b) || ((a->type == b->type) &&
- (a->size == b->size) &&
- !memcmp(a + 1, b + 1, a->size));
-}
-
-/**
- @name Sequence Iterator
- @{
-*/
-
-/** Get an iterator pointing to the first event in a Sequence body. */
-static inline LV2_Atom_Event*
-lv2_atom_sequence_begin(const LV2_Atom_Sequence_Body* body)
-{
- return (LV2_Atom_Event*)(body + 1);
-}
-
-/** Get an iterator pointing to the end of a Sequence body. */
-static inline LV2_Atom_Event*
-lv2_atom_sequence_end(const LV2_Atom_Sequence_Body* body, uint32_t size)
-{
- return (LV2_Atom_Event*)((const uint8_t*)body + lv2_atom_pad_size(size));
-}
-
-/** Return true iff `i` has reached the end of `body`. */
-static inline bool
-lv2_atom_sequence_is_end(const LV2_Atom_Sequence_Body* body,
- uint32_t size,
- const LV2_Atom_Event* i)
-{
- return (const uint8_t*)i >= ((const uint8_t*)body + size);
-}
-
-/** Return an iterator to the element following `i`. */
-static inline LV2_Atom_Event*
-lv2_atom_sequence_next(const LV2_Atom_Event* i)
-{
- return (LV2_Atom_Event*)((const uint8_t*)i
- + sizeof(LV2_Atom_Event)
- + lv2_atom_pad_size(i->body.size));
-}
-
-/**
- A macro for iterating over all events in a Sequence.
- @param seq The sequence to iterate over
- @param iter The name of the iterator
-
- This macro is used similarly to a for loop (which it expands to), e.g.:
- @code
- LV2_ATOM_SEQUENCE_FOREACH(sequence, ev) {
- // Do something with ev (an LV2_Atom_Event*) here...
- }
- @endcode
-*/
-#define LV2_ATOM_SEQUENCE_FOREACH(seq, iter) \
- for (LV2_Atom_Event* (iter) = lv2_atom_sequence_begin(&(seq)->body); \
- !lv2_atom_sequence_is_end(&(seq)->body, (seq)->atom.size, (iter)); \
- (iter) = lv2_atom_sequence_next(iter))
-
-/** Like LV2_ATOM_SEQUENCE_FOREACH but for a headerless sequence body. */
-#define LV2_ATOM_SEQUENCE_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom_Event* (iter) = lv2_atom_sequence_begin(body); \
- !lv2_atom_sequence_is_end(body, size, (iter)); \
- (iter) = lv2_atom_sequence_next(iter))
-
-/**
- @}
- @name Sequence Utilities
- @{
-*/
-
-/**
- Clear all events from `sequence`.
-
- This simply resets the size field, the other fields are left untouched.
-*/
-static inline void
-lv2_atom_sequence_clear(LV2_Atom_Sequence* seq)
-{
- seq->atom.size = sizeof(LV2_Atom_Sequence_Body);
-}
-
-/**
- Append an event at the end of `sequence`.
-
- @param seq Sequence to append to.
- @param capacity Total capacity of the sequence atom
- (e.g. as set by the host for sequence output ports).
- @param event Event to write.
-
- @return A pointer to the newly written event in `seq`,
- or NULL on failure (insufficient space).
-*/
-static inline LV2_Atom_Event*
-lv2_atom_sequence_append_event(LV2_Atom_Sequence* seq,
- uint32_t capacity,
- const LV2_Atom_Event* event)
-{
- const uint32_t total_size = (uint32_t)sizeof(*event) + event->body.size;
- if (capacity - seq->atom.size < total_size) {
- return NULL;
- }
-
- LV2_Atom_Event* e = lv2_atom_sequence_end(&seq->body, seq->atom.size);
- memcpy(e, event, total_size);
-
- seq->atom.size += lv2_atom_pad_size(total_size);
-
- return e;
-}
-
-/**
- @}
- @name Tuple Iterator
- @{
-*/
-
-/** Get an iterator pointing to the first element in `tup`. */
-static inline LV2_Atom*
-lv2_atom_tuple_begin(const LV2_Atom_Tuple* tup)
-{
- return (LV2_Atom*)(LV2_ATOM_BODY(tup));
-}
-
-/** Return true iff `i` has reached the end of `body`. */
-static inline bool
-lv2_atom_tuple_is_end(const void* body, uint32_t size, const LV2_Atom* i)
-{
- return (const uint8_t*)i >= ((const uint8_t*)body + size);
-}
-
-/** Return an iterator to the element following `i`. */
-static inline LV2_Atom*
-lv2_atom_tuple_next(const LV2_Atom* i)
-{
- return (LV2_Atom*)(
- (const uint8_t*)i + sizeof(LV2_Atom) + lv2_atom_pad_size(i->size));
-}
-
-/**
- A macro for iterating over all properties of a Tuple.
- @param tuple The tuple to iterate over
- @param iter The name of the iterator
-
- This macro is used similarly to a for loop (which it expands to), e.g.:
- @code
- LV2_ATOM_TUPLE_FOREACH(tuple, elem) {
- // Do something with elem (an LV2_Atom*) here...
- }
- @endcode
-*/
-#define LV2_ATOM_TUPLE_FOREACH(tuple, iter) \
- for (LV2_Atom* (iter) = lv2_atom_tuple_begin(tuple); \
- !lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), (tuple)->atom.size, (iter)); \
- (iter) = lv2_atom_tuple_next(iter))
-
-/** Like LV2_ATOM_TUPLE_FOREACH but for a headerless tuple body. */
-#define LV2_ATOM_TUPLE_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom* (iter) = (LV2_Atom*)body; \
- !lv2_atom_tuple_is_end(body, size, (iter)); \
- (iter) = lv2_atom_tuple_next(iter))
-
-/**
- @}
- @name Object Iterator
- @{
-*/
-
-/** Return a pointer to the first property in `body`. */
-static inline LV2_Atom_Property_Body*
-lv2_atom_object_begin(const LV2_Atom_Object_Body* body)
-{
- return (LV2_Atom_Property_Body*)(body + 1);
-}
-
-/** Return true iff `i` has reached the end of `obj`. */
-static inline bool
-lv2_atom_object_is_end(const LV2_Atom_Object_Body* body,
- uint32_t size,
- const LV2_Atom_Property_Body* i)
-{
- return (const uint8_t*)i >= ((const uint8_t*)body + size);
-}
-
-/** Return an iterator to the property following `i`. */
-static inline LV2_Atom_Property_Body*
-lv2_atom_object_next(const LV2_Atom_Property_Body* i)
-{
- const LV2_Atom* const value = (const LV2_Atom*)(
- (const uint8_t*)i + 2 * sizeof(uint32_t));
- return (LV2_Atom_Property_Body*)(
- (const uint8_t*)i + lv2_atom_pad_size(
- (uint32_t)sizeof(LV2_Atom_Property_Body) + value->size));
-}
-
-/**
- A macro for iterating over all properties of an Object.
- @param obj The object to iterate over
- @param iter The name of the iterator
-
- This macro is used similarly to a for loop (which it expands to), e.g.:
- @code
- LV2_ATOM_OBJECT_FOREACH(object, i) {
- // Do something with prop (an LV2_Atom_Property_Body*) here...
- }
- @endcode
-*/
-#define LV2_ATOM_OBJECT_FOREACH(obj, iter) \
- for (LV2_Atom_Property_Body* (iter) = lv2_atom_object_begin(&(obj)->body); \
- !lv2_atom_object_is_end(&(obj)->body, (obj)->atom.size, (iter)); \
- (iter) = lv2_atom_object_next(iter))
-
-/** Like LV2_ATOM_OBJECT_FOREACH but for a headerless object body. */
-#define LV2_ATOM_OBJECT_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom_Property_Body* (iter) = lv2_atom_object_begin(body); \
- !lv2_atom_object_is_end(body, size, (iter)); \
- (iter) = lv2_atom_object_next(iter))
-
-/**
- @}
- @name Object Query
- @{
-*/
-
-/** 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) */
-} LV2_Atom_Object_Query;
-
-static const LV2_Atom_Object_Query LV2_ATOM_OBJECT_QUERY_END = { 0, NULL };
-
-/**
- Get an object's values for various keys.
-
- The value pointer of each item in `query` will be set to the location of
- the corresponding value in `object`. Every value pointer in `query` MUST
- be initialised to NULL. This function reads `object` in a single linear
- sweep. By allocating `query` on the stack, objects can be "queried"
- quickly without allocating any memory. This function is realtime safe.
-
- This function can only do "flat" queries, it is not smart enough to match
- variables in nested objects.
-
- For example:
- @code
- const LV2_Atom* name = NULL;
- const LV2_Atom* age = NULL;
- LV2_Atom_Object_Query q[] = {
- { urids.eg_name, &name },
- { urids.eg_age, &age },
- LV2_ATOM_OBJECT_QUERY_END
- };
- lv2_atom_object_query(obj, q);
- // name and age are now set to the appropriate values in obj, or NULL.
- @endcode
-*/
-static inline int
-lv2_atom_object_query(const LV2_Atom_Object* object,
- LV2_Atom_Object_Query* query)
-{
- int matches = 0;
- int n_queries = 0;
-
- /* Count number of query keys so we can short-circuit when done */
- for (LV2_Atom_Object_Query* q = query; q->key; ++q) {
- ++n_queries;
- }
-
- LV2_ATOM_OBJECT_FOREACH(object, prop) {
- for (LV2_Atom_Object_Query* q = query; q->key; ++q) {
- if (q->key == prop->key && !*q->value) {
- *q->value = &prop->value;
- if (++matches == n_queries) {
- return matches;
- }
- break;
- }
- }
- }
- return matches;
-}
-
-/**
- Body only version of lv2_atom_object_get().
-*/
-static inline int
-lv2_atom_object_body_get(uint32_t size, const LV2_Atom_Object_Body* body, ...)
-{
- int matches = 0;
- int n_queries = 0;
-
- /* Count number of keys so we can short-circuit when done */
- va_list args;
- va_start(args, body);
- for (n_queries = 0; va_arg(args, uint32_t); ++n_queries) {
- if (!va_arg(args, const LV2_Atom**)) {
- return -1;
- }
- }
- va_end(args);
-
- LV2_ATOM_OBJECT_BODY_FOREACH(body, size, prop) {
- va_start(args, body);
- for (int i = 0; i < n_queries; ++i) {
- uint32_t qkey = va_arg(args, uint32_t);
- const LV2_Atom** qval = va_arg(args, const LV2_Atom**);
- if (qkey == prop->key && !*qval) {
- *qval = &prop->value;
- if (++matches == n_queries) {
- return matches;
- }
- break;
- }
- }
- va_end(args);
- }
- return matches;
-}
-
-/**
- Variable argument version of lv2_atom_object_query().
-
- This is nicer-looking in code, but a bit more error-prone since it is not
- type safe and the argument list must be terminated.
-
- The arguments should be a series of uint32_t key and const LV2_Atom** value
- pairs, terminated by a zero key. The value pointers MUST be initialized to
- NULL. For example:
-
- @code
- const LV2_Atom* name = NULL;
- const LV2_Atom* age = NULL;
- lv2_atom_object_get(obj,
- uris.name_key, &name,
- uris.age_key, &age,
- 0);
- @endcode
-*/
-static inline int
-lv2_atom_object_get(const LV2_Atom_Object* object, ...)
-{
- int matches = 0;
- int n_queries = 0;
-
- /* Count number of keys so we can short-circuit when done */
- va_list args;
- va_start(args, object);
- for (n_queries = 0; va_arg(args, uint32_t); ++n_queries) {
- if (!va_arg(args, const LV2_Atom**)) {
- return -1;
- }
- }
- va_end(args);
-
- LV2_ATOM_OBJECT_FOREACH(object, prop) {
- va_start(args, object);
- for (int i = 0; i < n_queries; ++i) {
- uint32_t qkey = va_arg(args, uint32_t);
- const LV2_Atom** qval = va_arg(args, const LV2_Atom**);
- if (qkey == prop->key && !*qval) {
- *qval = &prop->value;
- if (++matches == n_queries) {
- return matches;
- }
- break;
- }
- }
- va_end(args);
- }
- return matches;
-}
-
-/**
- Variable argument version of lv2_atom_object_query() with types.
-
- This is like lv2_atom_object_get(), but each entry has an additional
- parameter to specify the required type. Only atoms with a matching type
- will be selected.
-
- The arguments should be a series of uint32_t key, const LV2_Atom**, uint32_t
- type triples, terminated by a zero key. The value pointers MUST be
- initialized to NULL. For example:
-
- @code
- const LV2_Atom_String* name = NULL;
- const LV2_Atom_Int* age = NULL;
- lv2_atom_object_get(obj,
- uris.name_key, &name, uris.atom_String,
- uris.age_key, &age, uris.atom_Int
- 0);
- @endcode
-*/
-static inline int
-lv2_atom_object_get_typed(const LV2_Atom_Object* object, ...)
-{
- int matches = 0;
- int n_queries = 0;
-
- /* Count number of keys so we can short-circuit when done */
- va_list args;
- va_start(args, object);
- for (n_queries = 0; va_arg(args, uint32_t); ++n_queries) {
- if (!va_arg(args, const LV2_Atom**) ||
- !va_arg(args, uint32_t)) {
- return -1;
- }
- }
- va_end(args);
-
- LV2_ATOM_OBJECT_FOREACH(object, prop) {
- va_start(args, object);
- for (int i = 0; i < n_queries; ++i) {
- const uint32_t qkey = va_arg(args, uint32_t);
- const LV2_Atom** qval = va_arg(args, const LV2_Atom**);
- const uint32_t qtype = va_arg(args, uint32_t);
- if (!*qval && qkey == prop->key && qtype == prop->value.type) {
- *qval = &prop->value;
- if (++matches == n_queries) {
- return matches;
- }
- break;
- }
- }
- va_end(args);
- }
- return matches;
-}
-
-/**
- @}
- @}
-*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* LV2_ATOM_UTIL_H */