#include "gui_thread.h"
#include "lv2_plugin_ui.h"
-#include "lv2_ui.h"
+#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
#include <lilv/lilv.h>
#include <suil/suil.h>
ui_host = suil_host_new(LV2PluginUI::write_from_ui,
LV2PluginUI::port_index,
NULL, NULL);
-#ifdef HAVE_NEW_SUIL
suil_host_set_touch_func(ui_host, LV2PluginUI::touch);
-#endif
}
const char* container_type = (is_external_ui)
? NS_UI "external"
+++ /dev/null
-/*
- LV2 UI Extension
- Copyright 2009-2012 David Robillard <d@drobilla.net>
- Copyright 2006-2011 Lars Luthman <lars.luthman@gmail.com>
-
- 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 ui.h
- C header for the LV2 UI extension <http://lv2plug.in/ns/extensions/ui>.
-*/
-
-#ifndef LV2_UI_H
-#define LV2_UI_H
-
-#include <stdint.h>
-
-#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
-
-#define LV2_UI_URI "http://lv2plug.in/ns/extensions/ui"
-#define LV2_UI_PREFIX LV2_UI_URI "#"
-
-#define LV2_UI__GtkUI LV2_UI_PREFIX "GtkUI"
-#define LV2_UI__PortNotification LV2_UI_PREFIX "PortNotification"
-#define LV2_UI__Qt4UI LV2_UI_PREFIX "Qt4UI"
-#define LV2_UI__UI LV2_UI_PREFIX "UI"
-#define LV2_UI__X11UI LV2_UI_PREFIX "X11UI"
-#define LV2_UI__fixedSize LV2_UI_PREFIX "fixedSize"
-#define LV2_UI__noUserResize LV2_UI_PREFIX "noUserResize"
-#define LV2_UI__notifyType LV2_UI_PREFIX "notifyType"
-#define LV2_UI__parent LV2_UI_PREFIX "parent"
-#define LV2_UI__plugin LV2_UI_PREFIX "plugin"
-#define LV2_UI__portIndex LV2_UI_PREFIX "portIndex"
-#define LV2_UI__portMap LV2_UI_PREFIX "portMap"
-#define LV2_UI__portNotification LV2_UI_PREFIX "portNotification"
-#define LV2_UI__portSubscribe LV2_UI_PREFIX "portSubscribe"
-#define LV2_UI__resize LV2_UI_PREFIX "resize"
-#define LV2_UI__touch LV2_UI_PREFIX "touch"
-
-/**
- The index returned by LV2_UI_Port_Port::port_index() for unknown ports.
-*/
-#define LV2UI_INVALID_PORT_INDEX ((uint32_t)-1)
-
-#ifdef __cplusplus
-extern "C" {
-#else
-# include <stdbool.h>
-#endif
-
-/**
- A pointer to some widget or other type of UI handle.
-
- The actual type is defined by the type of the UI.
-*/
-typedef void* LV2UI_Widget;
-
-/**
- A pointer to an instance of a UI.
-
- It is valid to compare this to NULL (0 for C++) but otherwise the host MUST
- not attempt to interpret it. The UI plugin may use it to reference internal
- instance data.
-*/
-typedef void* LV2UI_Handle;
-
-/**
- A pointer to a controller provided by the host.
-
- It is valid to compare this to NULL (0 for C++) but otherwise the UI plugin
- MUST NOT attempt to interpret it. The host may use it to reference internal
- instance data.
-*/
-typedef void* LV2UI_Controller;
-
-/**
- A pointer to opaque data for a feature.
-*/
-typedef void* LV2UI_Feature_Handle;
-
-/**
- The type of the host-provided function that the UI can use to
- send data to a plugin's input ports.
-
- The @c buffer parameter must point to a block of data, @c buffer_size bytes
- large. The format of this data and how the host should use it is defined by
- the @c port_protocol. This buffer is owned by the UI and is only valid for
- the duration of this call.
-
- The @c port_protocol parameter should either be 0 or the URID for a
- ui:PortProtocol. If it is 0, the protocol is implicitly ui:floatProtocol,
- the port must be an lv2:ControlPort input, @c buffer must point to a single
- float value, and @c buffer_size must be sizeof(float).
-
- The UI SHOULD NOT use a PortProtocol not supported by the host (i.e. one not
- passed by the host as a feature), but the host MUST gracefully ignore any
- port_protocol it does not understand.
-*/
-typedef void (*LV2UI_Write_Function)(LV2UI_Controller controller,
- uint32_t port_index,
- uint32_t buffer_size,
- uint32_t port_protocol,
- const void* buffer);
-
-/**
- The implementation of a UI.
-
- A pointer to an object of this type is returned by the lv2ui_descriptor()
- function.
-*/
-typedef struct _LV2UI_Descriptor {
- /**
- The URI for this UI (not for the plugin it controls).
- */
- const char* URI;
-
- /**
- Create a new UI object and return a handle to it. This function works
- similarly to the instantiate() member in LV2_Descriptor.
-
- @param descriptor The descriptor for the UI that you want to instantiate.
-
- @param plugin_uri The URI of the plugin that this UI will control.
-
- @param bundle_path The path to the bundle containing the RDF data file
- that references this shared object file, including the trailing '/'.
-
- @param write_function A function provided by the host that the UI can use
- to send data to the plugin's input ports.
-
- @param controller A handle for the plugin instance that should be passed
- as the first parameter of @c write_function.
-
- @param widget A pointer to an LV2UI_Widget. The UI will write a widget
- pointer to this location (what type of widget depends on the RDF class of
- the UI) that will be the main UI widget.
-
- @param features An array of LV2_Feature pointers. The host must pass all
- feature URIs that it and the UI supports and any additional data, just
- like in the LV2 plugin instantiate() function. Note that UI features and
- plugin features are NOT necessarily the same, they just share the same
- data structure - this will probably not be the same array as the one the
- plugin host passes to a plugin.
-
- */
- LV2UI_Handle (*instantiate)(const struct _LV2UI_Descriptor* descriptor,
- const char* plugin_uri,
- const char* bundle_path,
- LV2UI_Write_Function write_function,
- LV2UI_Controller controller,
- LV2UI_Widget* widget,
- const LV2_Feature* const* features);
-
-
- /**
- Destroy the UI object and the associated widget. The host must not try
- to access the widget after calling this function.
- */
- void (*cleanup)(LV2UI_Handle ui);
-
- /**
- Tell the UI that something interesting has happened at a plugin port.
-
- What is interesting and how it is written to the buffer passed to this
- function is defined by the @c format parameter, which has the same
- meaning as in LV2UI_Write_Function. The only exception is ports of the
- class lv2:ControlPort, for which this function should be called when the
- port value changes (it does not have to be called for every single change
- if the host's UI thread has problems keeping up with the thread the
- plugin is running in), @c buffer_size should be 4, the buffer should
- contain a single IEEE-754 float, and @c format should be 0.
-
- By default, the host should only call this function for input ports of
- the lv2:ControlPort class. However, this can be modified by using
- ui:portNotification in the UI data, or the ui:portSubscribe feature.
-
- The @c buffer is only valid during the time of this function call, so if
- the UI wants to keep it for later use it has to copy the contents to an
- internal buffer.
-
- This member may be set to NULL if the UI is not interested in any
- port events.
- */
- void (*port_event)(LV2UI_Handle ui,
- uint32_t port_index,
- uint32_t buffer_size,
- uint32_t format,
- const void* buffer);
-
- /**
- Return a data structure associated with an extension URI, for example
- a struct containing additional function pointers.
-
- Avoid returning function pointers directly since standard C/C++ has no
- valid way of casting a void* to a function pointer. This member may be set
- to NULL if the UI is not interested in supporting any extensions. This is
- similar to the extension_data() member in LV2_Descriptor.
- */
- const void* (*extension_data)(const char* uri);
-} LV2UI_Descriptor;
-
-/**
- UI Resize Feature (LV2_UI__resize)
-
- This structure may be used in two ways: as a feature passed by the host via
- LV2UI_Descriptor::instantiate(), or as extension data provided by a UI via
- LV2UI_Descriptor::extension_data()).
-*/
-typedef struct _LV2UI_Resize {
- /**
- Pointer to opaque data which must be passed to ui_resize().
- */
- LV2UI_Feature_Handle handle;
-
- /**
- Request or advertise a size change.
-
- When this struct is provided by the host, the UI may call this
- function to inform the host about the size of the UI.
-
- When this struct is provided by the UI, the host may call this
- function to notify the UI that it should change its size accordingly.
-
- @return 0 on success.
- */
- int (*ui_resize)(LV2UI_Feature_Handle handle, int width, int height);
-} LV2UI_Resize;
-
-/**
- Port Map Feature (LV2_UI__portMap).
-
- This feature can be used by the UI to get the index for a port with the
- given symbol. This makes it possible to implement and distribute a UI
- separately from the plugin (since symbol is a guaranteed stable port
- identifier while index is not).
-*/
-typedef struct _LV2UI_Port_Map {
- /**
- Pointer to opaque data which must be passed to ui_resize().
- */
- LV2UI_Feature_Handle handle;
-
- /**
- Get the index for the port with the given @p symbol.
-
- @return The index of the port, or LV2_UI_INVALID_PORT_INDEX if no such
- port is found.
- */
- uint32_t (*port_index)(LV2UI_Feature_Handle handle, const char* symbol);
-} LV2UI_Port_Map;
-
-/**
- Port subscription feature (LV2_UI__portSubscribe);
-*/
-typedef struct _LV2UI_Port_Subscribe {
- /**
- Pointer to opaque data which must be passed to ui_resize().
- */
- LV2UI_Feature_Handle handle;
-
- /**
- Subscribe to updates for a port.
-
- This means that the host will call the UI's port_event() function when
- the port value changes (as defined by protocol).
-
- Calling this function with the same @c port_index and @c port_protocol
- as an already active subscription has no effect.
-
- @param handle The handle field of this struct.
- @param port_index The index of the port.
- @param port_protocol The URID of the ui:PortProtocol.
- @param features Features for this subscription.
- @return 0 on success.
- */
- uint32_t (*subscribe)(LV2UI_Feature_Handle handle,
- uint32_t port_index,
- uint32_t port_protocol,
- const LV2_Feature* const* features);
-
- /**
- Unsubscribe from updates for a port.
-
- This means that the host will cease calling calling port_event() when
- the port value changes.
-
- Calling this function with a @c port_index and @c port_protocol that
- does not refer to an active port subscription has no effect.
-
- @param handle The handle field of this struct.
- @param port_index The index of the port.
- @param port_protocol The URID of the ui:PortProtocol.
- @param features Features for this subscription.
- @return 0 on success.
- */
- uint32_t (*unsubscribe)(LV2UI_Feature_Handle handle,
- uint32_t port_index,
- uint32_t port_protocol,
- const LV2_Feature* const* features);
-} LV2UI_Port_Subscribe;
-
-/**
- A feature to notify the host the user has grabbed a UI control.
-*/
-typedef struct _LV2UI_Touch {
- /**
- Pointer to opaque data which must be passed to ui_resize().
- */
- LV2UI_Feature_Handle handle;
-
- /**
- Notify the host that a control has been grabbed or released.
-
- @param handle The handle field of this struct.
- @param port_index The index of the port associated with the control.
- @param grabbed If true, the control has been grabbed, otherwise the
- control has been released.
- */
- void (*touch)(LV2UI_Feature_Handle handle,
- uint32_t port_index,
- bool grabbed);
-} LV2UI_Touch;
-
-/**
- Peak data for a slice of time, the update format for ui:peakProtocol.
-*/
-typedef struct _LV2UI_Peak_Data {
- /**
- The start of the measurement period. This is just a running counter
- that is only meaningful in comparison to previous values and must not be
- interpreted as an absolute time.
- */
- uint32_t period_start;
-
- /**
- The size of the measurement period, in the same units as period_start.
- */
- uint32_t period_size;
-
- /**
- The peak value for the measurement period. This should be the maximal
- value for abs(sample) over all the samples in the period.
- */
- float peak;
-} LV2UI_Peak_Data;
-
-/**
- A plugin UI programmer must include a function called "lv2ui_descriptor"
- with the following function prototype within the shared object file. This
- function will have C-style linkage (if you are using C++ this is taken care
- of by the 'extern "C"' clause at the top of the file). This function is
- loaded from the library by the UI host and called to get a
- LV2UI_Descriptor for the wanted plugin.
-
- Just like lv2_descriptor(), this function takes an index parameter. The
- index should only be used for enumeration and not as any sort of ID number -
- the host should just iterate from 0 and upwards until the function returns
- NULL or a descriptor with an URI matching the one the host is looking for.
-*/
-const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index);
-
-/**
- The type of the lv2ui_descriptor() function.
-*/
-typedef const LV2UI_Descriptor* (*LV2UI_DescriptorFunction)(uint32_t index);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LV2_UI_H */
+++ /dev/null
-/*
- Copyright 2008-2012 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 atom.h C header for the LV2 Atom extension
- <http://lv2plug.in/ns/ext/atom>.
-*/
-
-#ifndef LV2_ATOM_H
-#define LV2_ATOM_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-#define LV2_ATOM_URI "http://lv2plug.in/ns/ext/atom"
-#define LV2_ATOM_PREFIX LV2_ATOM_URI "#"
-
-#define LV2_ATOM__Atom LV2_ATOM_PREFIX "Atom"
-#define LV2_ATOM__AtomPort LV2_ATOM_PREFIX "AtomPort"
-#define LV2_ATOM__AudioFrames LV2_ATOM_PREFIX "AudioFrames"
-#define LV2_ATOM__Beats LV2_ATOM_PREFIX "Beats"
-#define LV2_ATOM__Blank LV2_ATOM_PREFIX "Blank"
-#define LV2_ATOM__Bool LV2_ATOM_PREFIX "Bool"
-#define LV2_ATOM__Chunk LV2_ATOM_PREFIX "Chunk"
-#define LV2_ATOM__Double LV2_ATOM_PREFIX "Double"
-#define LV2_ATOM__Event LV2_ATOM_PREFIX "Event"
-#define LV2_ATOM__Float LV2_ATOM_PREFIX "Float"
-#define LV2_ATOM__Int LV2_ATOM_PREFIX "Int"
-#define LV2_ATOM__Long LV2_ATOM_PREFIX "Long"
-#define LV2_ATOM__Literal LV2_ATOM_PREFIX "Literal"
-#define LV2_ATOM__Number LV2_ATOM_PREFIX "Number"
-#define LV2_ATOM__Object LV2_ATOM_PREFIX "Object"
-#define LV2_ATOM__Path LV2_ATOM_PREFIX "Path"
-#define LV2_ATOM__Property LV2_ATOM_PREFIX "Property"
-#define LV2_ATOM__Resource LV2_ATOM_PREFIX "Resource"
-#define LV2_ATOM__Sequence LV2_ATOM_PREFIX "Sequence"
-#define LV2_ATOM__Sound LV2_ATOM_PREFIX "Sound"
-#define LV2_ATOM__String LV2_ATOM_PREFIX "String"
-#define LV2_ATOM__TimeUnit LV2_ATOM_PREFIX "TimeUnit"
-#define LV2_ATOM__Tuple LV2_ATOM_PREFIX "Tuple"
-#define LV2_ATOM__URI LV2_ATOM_PREFIX "URI"
-#define LV2_ATOM__URID LV2_ATOM_PREFIX "URID"
-#define LV2_ATOM__Vector LV2_ATOM_PREFIX "Vector"
-#define LV2_ATOM__beatTime LV2_ATOM_PREFIX "beatTime"
-#define LV2_ATOM__bufferType LV2_ATOM_PREFIX "bufferType"
-#define LV2_ATOM__childType LV2_ATOM_PREFIX "childType"
-#define LV2_ATOM__eventTransfer LV2_ATOM_PREFIX "eventTransfer"
-#define LV2_ATOM__frameTime LV2_ATOM_PREFIX "frameTime"
-#define LV2_ATOM__supports LV2_ATOM_PREFIX "supports"
-#define LV2_ATOM__timeUnit LV2_ATOM_PREFIX "timeUnit"
-
-#define LV2_ATOM_REFERENCE_TYPE 0
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** 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];
-
-/**
- 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)))
-
-/**
- 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)
-
-/** 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 (atom:Resource) or blank ID (atom: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 atom:AudioFrames, i.e.
- LV2_Atom_Audio_Time.
-
- 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 */
+++ /dev/null
-/*
- Copyright 2008-2012 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.
-*/
-
-#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"
-
-#ifdef __cplusplus
-extern "C" {
-#else
-# include <stdbool.h>
-#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_URID Bool;
- LV2_URID Double;
- LV2_URID Float;
- LV2_URID Int;
- LV2_URID Long;
- LV2_URID Literal;
- LV2_URID Path;
- LV2_URID Property;
- LV2_URID Resource;
- 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 @p forge.
-
- URIs will be mapped using @p map and stored, a reference to @p 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->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->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);
-}
-
-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 &&
- lv2_atom_forge_deref(forge, forge->stack->ref)->type == type;
-}
-
-/**
- @}
- @name Output Configuration
- @{
-*/
-
-/** Set the output buffer where @p 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 = size;
- forge->offset = 0;
- forge->deref = NULL;
- forge->sink = NULL;
- forge->handle = NULL;
- forge->stack = NULL;
-}
-
-/**
- Set the sink function where @p 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(a), a->size);
- } else {
- return lv2_atom_forge_write(forge, a, 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 @p 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 @p 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 @p 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 = {
- { 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 = {
- { 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:Resource.
-
- 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");
-
- // Write object header
- LV2_Atom_Forge_Frame frame;
- lv2_atom_forge_resource(forge, &frame, 1, eg_Cat);
-
- // Write property: eg:name = "Hobbes"
- lv2_atom_forge_property_head(forge, eg_name, 0);
- 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_resource(LV2_Atom_Forge* forge,
- LV2_Atom_Forge_Frame* frame,
- LV2_URID id,
- LV2_URID otype)
-{
- const LV2_Atom_Object a = {
- { sizeof(LV2_Atom_Object) - sizeof(LV2_Atom), forge->Resource },
- { id, otype }
- };
- LV2_Atom_Forge_Ref out = lv2_atom_forge_write(forge, &a, sizeof(a));
- return lv2_atom_forge_push(forge, frame, out);
-}
-
-/**
- The same as lv2_atom_forge_resource(), but for object:Blank.
-*/
-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 = {
- { sizeof(LV2_Atom_Object) - sizeof(LV2_Atom), forge->Blank },
- { id, otype }
- };
- LV2_Atom_Forge_Ref out = lv2_atom_forge_write(forge, &a, sizeof(a));
- return lv2_atom_forge_push(forge, frame, out);
-}
-
-/**
- Write the header for a property body (likely in an Object).
- See lv2_atom_forge_object() documentation for an example.
-*/
-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 * sizeof(uint32_t));
-}
-
-/**
- Write the header for a Sequence.
- The size of the returned sequence will be 0, so passing it as the parent
- parameter to other forge methods will do the right thing.
-*/
-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 = {
- { sizeof(LV2_Atom_Sequence) - sizeof(LV2_Atom), forge->Sequence },
- { unit, 0 }
- };
- LV2_Atom_Forge_Ref out = lv2_atom_forge_write(forge, &a, sizeof(a));
- return lv2_atom_forge_push(forge, frame, out);
-}
-
-/**
- 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, passing
- the same @p parent parameter. Note the returned LV2_Event 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, passing
- the same @p parent parameter. Note the returned LV2_Event 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));
-}
-
-/**
- @}
-*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* LV2_ATOM_FORGE_H */
+++ /dev/null
-/*
- Copyright 2008-2012 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.
-*/
-
-#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 + 7) & (~7);
-}
-
-/** Return the total size of @p atom, including the header. */
-static inline uint32_t
-lv2_atom_total_size(const LV2_Atom* atom)
-{
- return sizeof(LV2_Atom) + atom->size;
-}
-
-/** Return true iff @p 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 @p a is equal to @p 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
- @{
-*/
-
-/** An iterator over the elements of an LV2_Atom_Sequence. */
-typedef LV2_Atom_Event* LV2_Atom_Sequence_Iter;
-
-/** Get an iterator pointing to the first element in a Sequence body. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_body_begin(const LV2_Atom_Sequence_Body* body)
-{
- return (LV2_Atom_Sequence_Iter)(body + 1);
-}
-
-/** Get an iterator pointing to the first element in a Sequence. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_begin(const LV2_Atom_Sequence* seq)
-{
- return (LV2_Atom_Sequence_Iter)(seq + 1);
-}
-
-/** Return true iff @p i has reached the end of @p body. */
-static inline bool
-lv2_sequence_body_is_end(const LV2_Atom_Sequence_Body* body,
- uint32_t size,
- LV2_Atom_Sequence_Iter i)
-{
- return (uint8_t*)i >= ((uint8_t*)body + size);
-}
-
-/** Return true iff @p i has reached the end of @p seq. */
-static inline bool
-lv2_sequence_is_end(const LV2_Atom_Sequence* seq, LV2_Atom_Sequence_Iter i)
-{
- return (uint8_t*)i >= ((uint8_t*)seq + sizeof(LV2_Atom) + seq->atom.size);
-}
-
-/** Return an iterator to the element following @p i. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_iter_next(const LV2_Atom_Sequence_Iter i)
-{
- return (LV2_Atom_Sequence_Iter)((uint8_t*)i
- + sizeof(LV2_Atom_Event)
- + lv2_atom_pad_size(i->body.size));
-}
-
-/** Return the element pointed to by @p i. */
-static inline LV2_Atom_Event*
-lv2_sequence_iter_get(LV2_Atom_Sequence_Iter i)
-{
- return (LV2_Atom_Event*)i;
-}
-
-/**
- A macro for iterating over all events in a Sequence.
- @param sequence 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_SEQUENCE_FOREACH(sequence, i) {
- LV2_Atom_Event* ev = lv2_sequence_iter_get(i);
- // Do something with ev here...
- }
- @endcode
-*/
-#define LV2_SEQUENCE_FOREACH(sequence, iter) \
- for (LV2_Atom_Sequence_Iter (iter) = lv2_sequence_begin(sequence); \
- !lv2_sequence_is_end(sequence, (iter)); \
- (iter) = lv2_sequence_iter_next(iter))
-
-/** A version of LV2_SEQUENCE_FOREACH for when only the body is available. */
-#define LV2_SEQUENCE_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom_Sequence_Iter (iter) = lv2_sequence_body_begin(body); \
- !lv2_sequence_body_is_end(body, size, (iter)); \
- (iter) = lv2_sequence_iter_next(iter))
-
-/**
- @}
- @name Tuple Iterator
- @{
-*/
-
-/** An iterator over the elements of an LV2_Atom_Tuple. */
-typedef LV2_Atom* LV2_Atom_Tuple_Iter;
-
-/** Get an iterator pointing to the first element in @p tup. */
-static inline LV2_Atom_Tuple_Iter
-lv2_tuple_begin(const LV2_Atom_Tuple* tup)
-{
- return (LV2_Atom_Tuple_Iter)(LV2_ATOM_BODY(tup));
-}
-
-/** Return true iff @p i has reached the end of @p body. */
-static inline bool
-lv2_atom_tuple_body_is_end(const void* body,
- uint32_t size,
- LV2_Atom_Tuple_Iter i)
-{
- return (uint8_t*)i >= ((uint8_t*)body + size);
-}
-
-/** Return true iff @p i has reached the end of @p tup. */
-static inline bool
-lv2_tuple_is_end(const LV2_Atom_Tuple* tup, LV2_Atom_Tuple_Iter i)
-{
- return lv2_atom_tuple_body_is_end(LV2_ATOM_BODY(tup), tup->atom.size, i);
-}
-
-/** Return an iterator to the element following @p i. */
-static inline LV2_Atom_Tuple_Iter
-lv2_tuple_iter_next(const LV2_Atom_Tuple_Iter i)
-{
- return (LV2_Atom_Tuple_Iter)(
- (uint8_t*)i + sizeof(LV2_Atom) + lv2_atom_pad_size(i->size));
-}
-
-/** Return the element pointed to by @p i. */
-static inline LV2_Atom*
-lv2_tuple_iter_get(LV2_Atom_Tuple_Iter i)
-{
- return (LV2_Atom*)i;
-}
-
-/**
- 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_TUPLE_FOREACH(tuple, i) {
- LV2_Atom* elem = lv2_tuple_iter_get(i);
- // Do something with elem here...
- }
- @endcode
-*/
-#define LV2_TUPLE_FOREACH(tuple, iter) \
- for (LV2_Atom_Tuple_Iter (iter) = lv2_tuple_begin(tuple); \
- !lv2_tuple_is_end(tuple, (iter)); \
- (iter) = lv2_tuple_iter_next(iter))
-
-/** A version of LV2_TUPLE_FOREACH for when only the body is available. */
-#define LV2_TUPLE_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom_Tuple_Iter (iter) = (LV2_Atom_Tuple_Iter)body; \
- !lv2_atom_tuple_body_is_end(body, size, (iter)); \
- (iter) = lv2_tuple_iter_next(iter))
-
-/**
- @}
- @name Object Iterator
- @{
-*/
-
-/** An iterator over the properties of an LV2_Atom_Object. */
-typedef LV2_Atom_Property_Body* LV2_Atom_Object_Iter;
-
-static inline LV2_Atom_Object_Iter
-lv2_object_body_begin(const LV2_Atom_Object_Body* body)
-{
- return (LV2_Atom_Object_Iter)(body + 1);
-}
-
-/** Get an iterator pointing to the first property in @p obj. */
-static inline LV2_Atom_Object_Iter
-lv2_object_begin(const LV2_Atom_Object* obj)
-{
- return (LV2_Atom_Object_Iter)(obj + 1);
-}
-
-static inline bool
-lv2_atom_object_body_is_end(const LV2_Atom_Object_Body* body,
- uint32_t size,
- LV2_Atom_Object_Iter i)
-{
- return (uint8_t*)i >= ((uint8_t*)body + size);
-}
-
-/** Return true iff @p i has reached the end of @p obj. */
-static inline bool
-lv2_object_is_end(const LV2_Atom_Object* obj, LV2_Atom_Object_Iter i)
-{
- return (uint8_t*)i >= ((uint8_t*)obj + sizeof(LV2_Atom) + obj->atom.size);
-}
-
-/** Return an iterator to the property following @p i. */
-static inline LV2_Atom_Object_Iter
-lv2_object_iter_next(const LV2_Atom_Object_Iter i)
-{
- const LV2_Atom* const value = (LV2_Atom*)((uint8_t*)i + sizeof(i));
- return (LV2_Atom_Object_Iter)((uint8_t*)i
- + sizeof(LV2_Atom_Property_Body)
- + lv2_atom_pad_size(value->size));
-}
-
-/** Return the property pointed to by @p i. */
-static inline LV2_Atom_Property_Body*
-lv2_object_iter_get(LV2_Atom_Object_Iter i)
-{
- return (LV2_Atom_Property_Body*)i;
-}
-
-/**
- A macro for iterating over all properties of an Object.
- @param object 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_OBJECT_FOREACH(object, i) {
- LV2_Atom_Property_Body* prop = lv2_object_iter_get(i);
- // Do something with prop here...
- }
- @endcode
-*/
-#define LV2_OBJECT_FOREACH(object, iter) \
- for (LV2_Atom_Object_Iter (iter) = lv2_object_begin(object); \
- !lv2_object_is_end(object, (iter)); \
- (iter) = lv2_object_iter_next(iter))
-
-/** A version of LV2_OBJECT_FOREACH for when only the body is available. */
-#define LV2_OBJECT_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom_Object_Iter (iter) = lv2_object_body_begin(body); \
- !lv2_atom_object_body_is_end(body, size, (iter)); \
- (iter) = lv2_object_iter_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_OBJECT_QUERY_END = { 0, NULL };
-
-/**
- Get an object's values for various keys.
-
- The value pointer of each item in @p query will be set to the location of
- the corresponding value in @p object. Every value pointer in @p query MUST
- be initialised to NULL. This function reads @p object in a single linear
- sweep. By allocating @p 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_OBJECT_QUERY_END
- };
- lv2_object_query(obj, q);
- // name and age are now set to the appropriate values in obj, or NULL.
- @endcode
-*/
-static inline int
-lv2_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_OBJECT_FOREACH(object, o) {
- const LV2_Atom_Property_Body* prop = lv2_object_iter_get(o);
- 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;
-}
-
-/**
- Variable argument version of lv2_object_get().
-
- 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_object_get(obj,
- uris.name_key, &name,
- uris.age_key, &age,
- 0);
- @endcode
-*/
-static inline int
-lv2_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_OBJECT_FOREACH(object, o) {
- const LV2_Atom_Property_Body* prop = lv2_object_iter_get(o);
- 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;
-}
-
-/**
- @}
-*/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* LV2_ATOM_UTIL_H */
+++ /dev/null
-/* lv2_event_helpers.h - Helper functions for the LV2 events extension.
- *
- * Copyright (C) 2008 David Robillard <d@drobilla.net>
- *
- * This header is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This header is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this header; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307 USA
- */
-
-#ifndef LV2_EVENT_HELPERS_H
-#define LV2_EVENT_HELPERS_H
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-#include "lv2/lv2plug.in/ns/ext/event/event.h"
-
-/** @file
- * This header defines some helper functions for the the LV2 events extension
- * with URI <http://lv2plug.in/ns/ext/event> ('lv2ev').
- *
- * These functions are provided for convenience only, use of them is not
- * required for supporting lv2ev (i.e. the events extension is defined by the
- * raw buffer format described in lv2_event.h and NOT by this API).
- *
- * Note that these functions are all static inline which basically means:
- * do not take the address of these functions. */
-
-
-/** Pad a size to 64 bits (for event sizes) */
-static inline uint16_t
-lv2_event_pad_size(uint16_t size)
-{
- return (size + 7) & (~7);
-}
-
-
-/** Initialize (empty, reset..) an existing event buffer.
- * The contents of buf are ignored entirely and overwritten, except capacity
- * which is unmodified. */
-static inline void
-lv2_event_buffer_reset(LV2_Event_Buffer* buf, uint16_t stamp_type, uint8_t *data)
-{
- buf->data = data;
- buf->header_size = sizeof(LV2_Event_Buffer);
- buf->stamp_type = stamp_type;
- buf->event_count = 0;
- buf->size = 0;
-}
-
-
-/** Allocate a new, empty event buffer. */
-static inline LV2_Event_Buffer*
-lv2_event_buffer_new(uint32_t capacity, uint16_t stamp_type)
-{
- LV2_Event_Buffer* buf = (LV2_Event_Buffer*)malloc(sizeof(LV2_Event_Buffer) + capacity);
- if (buf != NULL) {
- buf->capacity = capacity;
- lv2_event_buffer_reset(buf, stamp_type, (uint8_t *)(buf + 1));
- return buf;
- } else {
- return NULL;
- }
-}
-
-
-/** An iterator over an LV2_Event_Buffer.
- *
- * Multiple simultaneous read iterators over a single buffer is fine,
- * but changing the buffer invalidates all iterators (e.g. RW Lock). */
-typedef struct {
- LV2_Event_Buffer* buf;
- uint32_t offset;
-} LV2_Event_Iterator;
-
-
-/** Reset an iterator to point to the start of @a buf.
- * @return True if @a iter is valid, otherwise false (buffer is empty) */
-static inline bool
-lv2_event_begin(LV2_Event_Iterator* iter,
- LV2_Event_Buffer* buf)
-{
- iter->buf = buf;
- iter->offset = 0;
- return (buf->size > 0);
-}
-
-
-/** Check if @a iter is valid..
- * @return True if @a iter is valid, otherwise false (past end of buffer) */
-static inline bool
-lv2_event_is_valid(LV2_Event_Iterator* iter)
-{
- return (iter->offset < iter->buf->size);
-}
-
-
-/** Advance @a iter forward one event.
- * @a iter must be valid.
- * @return True if @a iter is valid, otherwise false (reached end of buffer) */
-static inline bool
-lv2_event_increment(LV2_Event_Iterator* iter)
-{
- assert(lv2_event_is_valid(iter));
-
- LV2_Event* const ev = (LV2_Event*)(
- (uint8_t*)iter->buf->data + iter->offset);
-
- iter->offset += lv2_event_pad_size(sizeof(LV2_Event) + ev->size);
-
- return true;
-}
-
-
-/** Dereference an event iterator (get the event currently pointed at).
- * @a iter must be valid.
- * @a data if non-NULL, will be set to point to the contents of the event
- * returned.
- * @return A Pointer to the event @a iter is currently pointing at, or NULL
- * if the end of the buffer is reached (in which case @a data is
- * also set to NULL). */
-static inline LV2_Event*
-lv2_event_get(LV2_Event_Iterator* iter,
- uint8_t** data)
-{
- assert(lv2_event_is_valid(iter));
-
- LV2_Event* const ev = (LV2_Event*)(
- (uint8_t*)iter->buf->data + iter->offset);
-
- if (data)
- *data = (uint8_t*)ev + sizeof(LV2_Event);
-
- return ev;
-}
-
-
-/** Write an event at @a iter.
- * The event (if any) pointed to by @iter will be overwritten, and @a iter
- * incremented to point to the following event (i.e. several calls to this
- * function can be done in sequence without twiddling iter in-between).
- * @return True if event was written, otherwise false (buffer is full). */
-static inline bool
-lv2_event_write(LV2_Event_Iterator* iter,
- uint32_t frames,
- uint32_t subframes,
- uint16_t type,
- uint16_t size,
- const uint8_t* data)
-{
- if (iter->buf->capacity - iter->buf->size < sizeof(LV2_Event) + size)
- return false;
-
- LV2_Event* const ev = (LV2_Event*)(
- (uint8_t*)iter->buf->data + iter->offset);
-
- ev->frames = frames;
- ev->subframes = subframes;
- ev->type = type;
- ev->size = size;
- memcpy((uint8_t*)ev + sizeof(LV2_Event), data, size);
- ++iter->buf->event_count;
-
- size = lv2_event_pad_size(sizeof(LV2_Event) + size);
- iter->buf->size += size;
- iter->offset += size;
-
- return true;
-}
-
-
-/** Reserve space for an event in the buffer and return a pointer to
- the memory where the caller can write the event data, or NULL if there
- is not enough room in the buffer. */
-static inline uint8_t*
-lv2_event_reserve(LV2_Event_Iterator* iter,
- uint32_t frames,
- uint32_t subframes,
- uint16_t type,
- uint16_t size)
-{
- size = lv2_event_pad_size(size);
- if (iter->buf->capacity - iter->buf->size < sizeof(LV2_Event) + size)
- return NULL;
-
- LV2_Event* const ev = (LV2_Event*)((uint8_t*)iter->buf->data +
- iter->offset);
-
- ev->frames = frames;
- ev->subframes = subframes;
- ev->type = type;
- ev->size = size;
- ++iter->buf->event_count;
-
- size = lv2_event_pad_size(sizeof(LV2_Event) + size);
- iter->buf->size += size;
- iter->offset += size;
-
- return (uint8_t*)ev + sizeof(LV2_Event);
-}
-
-
-/** Write an event at @a iter.
- * The event (if any) pointed to by @iter will be overwritten, and @a iter
- * incremented to point to the following event (i.e. several calls to this
- * function can be done in sequence without twiddling iter in-between).
- * @return True if event was written, otherwise false (buffer is full). */
-static inline bool
-lv2_event_write_event(LV2_Event_Iterator* iter,
- const LV2_Event* ev,
- const uint8_t* data)
-{
- if (iter->buf->capacity - iter->buf->size < sizeof(LV2_Event) + ev->size)
- return false;
-
- LV2_Event* const write_ev = (LV2_Event*)(
- (uint8_t*)iter->buf->data + iter->offset);
-
- *write_ev = *ev;
- memcpy((uint8_t*)write_ev + sizeof(LV2_Event), data, ev->size);
- ++iter->buf->event_count;
-
- const uint16_t size = lv2_event_pad_size(sizeof(LV2_Event) + ev->size);
- iter->buf->size += size;
- iter->offset += size;
-
- return true;
-}
-
-#endif // LV2_EVENT_HELPERS_H
-
+++ /dev/null
-/* lv2_event.h - C header file for the LV2 events extension.
- *
- * Copyright (C) 2006-2007 Lars Luthman <lars.luthman@gmail.com>
- * Copyright (C) 2008 David Robillard <d@drobilla.net>
- *
- * This header is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This header is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this header; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307 USA
- */
-
-#ifndef LV2_EVENT_H
-#define LV2_EVENT_H
-
-#define LV2_EVENT_URI "http://lv2plug.in/ns/ext/event"
-#define LV2_EVENT_AUDIO_STAMP 0
-
-#include <stdint.h>
-
-/** @file
- * This header defines the code portion of the LV2 events extension with URI
- * <http://lv2plug.in/ns/ext/event> ('lv2ev').
- *
- * This extension is a generic transport mechanism for time stamped events
- * of any type (e.g. MIDI, OSC, ramps, etc). Each port can transport mixed
- * events of any type; the type of events and timestamps are defined by a URI
- * which is mapped to an integer by the host for performance reasons.
- *
- * This extension requires the host to support the LV2 URI Map extension.
- * Any host which supports this extension MUST guarantee that any call to
- * the LV2 URI Map uri_to_id function with the URI of this extension as the
- * 'map' argument returns a value within the range of uint16_t.
- */
-
-
-/** The best Pulses Per Quarter Note for tempo-based uint32_t timestmaps.
- * Equal to 2^12 * 5 * 7 * 9 * 11 * 13 * 17, which is evenly divisble
- * by all integers from 1 through 18 inclusive, and powers of 2 up to 2^12.
- */
-static const uint32_t LV2_EVENT_PPQN = 3136573440U;
-
-
-/** An LV2 event (header only).
- *
- * LV2 events are generic time-stamped containers for any type of event.
- * The type field defines the format of a given event's contents.
- *
- * This struct defines the header of an LV2 event. An LV2 event is a single
- * chunk of POD (plain old data), usually contained in a flat buffer
- * (see LV2_EventBuffer below). Unless a required feature says otherwise,
- * hosts may assume a deep copy of an LV2 event can be created safely
- * using a simple:
- *
- * memcpy(ev_copy, ev, sizeof(LV2_Event) + ev->size); (or equivalent)
- */
-typedef struct {
-
- /** The frames portion of timestamp. The units used here can optionally be
- * set for a port (with the lv2ev:timeUnits property), otherwise this
- * is audio frames, corresponding to the sample_count parameter of the
- * LV2 run method (e.g. frame 0 is the first frame for that call to run).
- */
- uint32_t frames;
-
- /** The sub-frames portion of timestamp. The units used here can
- * optionally be set for a port (with the lv2ev:timeUnits property),
- * otherwise this is 1/(2^32) of an audio frame.
- */
- uint32_t subframes;
-
- /** The type of this event, as a number which represents some URI
- * defining an event type. This value MUST be some value previously
- * returned from a call to the uri_to_id function defined in the LV2
- * URI map extension (see lv2_uri_map.h).
- * There are special rules which must be followed depending on the type
- * of an event. If the plugin recognizes an event type, the definition
- * of that event type will describe how to interpret the event, and
- * any required behaviour. Otherwise, if the type is 0, this event is a
- * non-POD event and lv2_event_unref MUST be called if the event is
- * 'dropped' (see above). Even if the plugin does not understand an event,
- * it may pass the event through to an output by simply copying (and NOT
- * calling lv2_event_unref). These rules are designed to allow for generic
- * event handling plugins and large non-POD events, but with minimal hassle
- * on simple plugins that "don't care" about these more advanced features.
- */
- uint16_t type;
-
- /** The size of the data portion of this event in bytes, which immediately
- * follows. The header size (12 bytes) is not included in this value.
- */
- uint16_t size;
-
- /* size bytes of data follow here */
-
-} LV2_Event;
-
-
-
-/** A buffer of LV2 events (header only).
- *
- * Like events (which this contains) an event buffer is a single chunk of POD:
- * the entire buffer (including contents) can be copied with a single memcpy.
- * The first contained event begins sizeof(LV2_EventBuffer) bytes after
- * the start of this struct.
- *
- * After this header, the buffer contains an event header (defined by struct
- * LV2_Event), followed by that event's contents (padded to 64 bits), followed by
- * another header, etc:
- *
- * | | | | | | |
- * | | | | | | | | | | | | | | | | | | | | | | | | |
- * |FRAMES |SUBFRMS|TYP|LEN|DATA..DATA..PAD|FRAMES | ...
- */
-typedef struct {
-
- /** The contents of the event buffer. This may or may not reside in the
- * same block of memory as this header, plugins must not assume either.
- * The host guarantees this points to at least capacity bytes of allocated
- * memory (though only size bytes of that are valid events).
- */
- uint8_t* data;
-
- /** The size of this event header in bytes (including everything).
- *
- * This is to allow for extending this header in the future without
- * breaking binary compatibility. Whenever this header is copied,
- * it MUST be done using this field (and NOT the sizeof this struct).
- */
- uint16_t header_size;
-
- /** The type of the time stamps for events in this buffer.
- * As a special exception, '0' always means audio frames and subframes
- * (1/UINT32_MAX'th of a frame) in the sample rate passed to instantiate.
- * INPUTS: The host must set this field to the numeric ID of some URI
- * defining the meaning of the frames/subframes fields of contained
- * events (obtained by the LV2 URI Map uri_to_id function with the URI
- * of this extension as the 'map' argument, see lv2_uri_map.h).
- * The host must never pass a plugin a buffer which uses a stamp type
- * the plugin does not 'understand'. The value of this field must
- * never change, except when connect_port is called on the input
- * port, at which time the host MUST have set the stamp_type field to
- * the value that will be used for all subsequent run calls.
- * OUTPUTS: The plugin may set this to any value that has been returned
- * from uri_to_id with the URI of this extension for a 'map' argument.
- * When connected to a buffer with connect_port, output ports MUST set
- * this field to the type of time stamp they will be writing. On any
- * call to connect_port on an event input port, the plugin may change
- * this field on any output port, it is the responsibility of the host
- * to check if any of these values have changed and act accordingly.
- */
- uint16_t stamp_type;
-
- /** The number of events in this buffer.
- * INPUTS: The host must set this field to the number of events
- * contained in the data buffer before calling run().
- * The plugin must not change this field.
- * OUTPUTS: The plugin must set this field to the number of events it
- * has written to the buffer before returning from run().
- * Any initial value should be ignored by the plugin.
- */
- uint32_t event_count;
-
- /** The size of the data buffer in bytes.
- * This is set by the host and must not be changed by the plugin.
- * The host is allowed to change this between run() calls.
- */
- uint32_t capacity;
-
- /** The size of the initial portion of the data buffer containing data.
- * INPUTS: The host must set this field to the number of bytes used
- * by all events it has written to the buffer (including headers)
- * before calling the plugin's run().
- * The plugin must not change this field.
- * OUTPUTS: The plugin must set this field to the number of bytes
- * used by all events it has written to the buffer (including headers)
- * before returning from run().
- * Any initial value should be ignored by the plugin.
- */
- uint32_t size;
-
-} LV2_Event_Buffer;
-
-
-/** Opaque pointer to host data. */
-typedef void* LV2_Event_Callback_Data;
-
-
-/** The data field of the LV2_Feature for this extension.
- *
- * To support this feature the host must pass an LV2_Feature struct to the
- * plugin's instantiate method with URI "http://lv2plug.in/ns/ext/event"
- * and data pointed to an instance of this struct.
- */
-typedef struct {
-
- /** Opaque pointer to host data.
- *
- * The plugin MUST pass this to any call to functions in this struct.
- * Otherwise, it must not be interpreted in any way.
- */
- LV2_Event_Callback_Data callback_data;
-
- /** Take a reference to a non-POD event.
- *
- * If a plugin receives an event with type 0, it means the event is a
- * pointer to some object in memory and not a flat sequence of bytes
- * in the buffer. When receiving a non-POD event, the plugin already
- * has an implicit reference to the event. If the event is stored AND
- * passed to an output, lv2_event_ref MUST be called on that event.
- * If the event is only stored OR passed through, this is not necessary
- * (as the plugin already has 1 implicit reference).
- *
- * @param event An event received at an input that will not be copied to
- * an output or stored in any way.
- * @param context The calling context. (Like event types) this is a mapped
- * URI, see lv2_context.h. Simple plugin with just a run()
- * method should pass 0 here (the ID of the 'standard' LV2
- * run context). The host guarantees that this function is
- * realtime safe iff @a context is realtime safe.
- *
- * PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
- */
- uint32_t (*lv2_event_ref)(LV2_Event_Callback_Data callback_data,
- LV2_Event* event);
-
- /** Drop a reference to a non-POD event.
- *
- * If a plugin receives an event with type 0, it means the event is a
- * pointer to some object in memory and not a flat sequence of bytes
- * in the buffer. If the plugin does not pass the event through to
- * an output or store it internally somehow, it MUST call this function
- * on the event (more information on using non-POD events below).
- *
- * @param event An event received at an input that will not be copied to
- * an output or stored in any way.
- * @param context The calling context. (Like event types) this is a mapped
- * URI, see lv2_context.h. Simple plugin with just a run()
- * method should pass 0 here (the ID of the 'standard' LV2
- * run context). The host guarantees that this function is
- * realtime safe iff @a context is realtime safe.
- *
- * PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
- */
- uint32_t (*lv2_event_unref)(LV2_Event_Callback_Data callback_data,
- LV2_Event* event);
-
-} LV2_Event_Feature;
-
-
-#endif // LV2_EVENT_H
-
+++ /dev/null
-/*
- Copyright 2010-2012 David Robillard <http://drobilla.net>
- Copyright 2010 Leonard Ritter <paniq@paniq.org>
-
- 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 state.h
- C API for the LV2 State extension <http://lv2plug.in/ns/ext/state>.
-*/
-
-#ifndef LV2_STATE_H
-#define LV2_STATE_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
-
-#define LV2_STATE_URI "http://lv2plug.in/ns/ext/state"
-#define LV2_STATE_PREFIX LV2_STATE_URI "#"
-
-#define LV2_STATE__State LV2_STATE_PREFIX "State"
-#define LV2_STATE__interface LV2_STATE_PREFIX "interface"
-#define LV2_STATE__makePath LV2_STATE_PREFIX "makePath"
-#define LV2_STATE__mapPath LV2_STATE_PREFIX "mapPath"
-#define LV2_STATE__state LV2_STATE_PREFIX "state"
-
-#ifdef __cplusplus
-extern "C" {
-#else
-# include <stdbool.h>
-#endif
-
-typedef void* LV2_State_Handle;
-typedef void* LV2_State_Map_Path_Handle;
-typedef void* LV2_State_Make_Path_Handle;
-
-/**
- Flags describing value characteristics.
-
- These flags are used along with the value's type URI to determine how to
- (de-)serialise the value data, or whether it is even possible to do so.
-*/
-typedef enum {
-
- /**
- Plain Old Data.
-
- Values with this flag contain no pointers or references to other areas
- of memory. It is safe to copy POD values with a simple memcpy and store
- them for the duration of the process. A POD value is not necessarily
- safe to trasmit between processes or machines (e.g. filenames are POD),
- see LV2_STATE_IS_PORTABLE for details.
-
- Implementations MUST NOT attempt to copy or serialise a non-POD value if
- they do not understand its type (and thus know how to correctly do so).
- */
- LV2_STATE_IS_POD = 1,
-
- /**
- Portable (architecture independent) data.
-
- Values with this flag are in a format that is usable on any
- architecture. A portable value saved on one machine can be restored on
- another machine regardless of architecture. The format of portable
- values MUST NOT depend on architecture-specific properties like
- endianness or alignment. Portable values MUST NOT contain filenames.
- */
- LV2_STATE_IS_PORTABLE = 1 << 1,
-
- /**
- Native data.
-
- This flag is used by the host to indicate that the saved data is only
- going to be used locally in the currently running process (e.g. for
- instance duplication or snapshots), so the plugin should use the most
- efficient representation possible and not worry about serialisation
- and portability.
- */
- LV2_STATE_IS_NATIVE = 1 << 2
-
-} LV2_State_Flags;
-
-/** A status code for state functions. */
-typedef enum {
- LV2_STATE_SUCCESS = 0, /**< Completed successfully. */
- LV2_STATE_ERR_UNKNOWN = 1, /**< Unknown error. */
- LV2_STATE_ERR_BAD_TYPE = 2, /**< Failed due to unsupported type. */
- LV2_STATE_ERR_BAD_FLAGS = 3, /**< Failed due to unsupported flags. */
- LV2_STATE_ERR_NO_FEATURE = 4, /**< Failed due to missing features. */
- LV2_STATE_ERR_NO_PROPERTY = 5 /**< Failed due to missing property. */
-} LV2_State_Status;
-
-/**
- A host-provided function to store a property.
- @param handle Must be the handle passed to LV2_State_Interface.save().
- @param key The key to store @p value under (URID).
- @param value Pointer to the value to be stored.
- @param size The size of @p value in bytes.
- @param type The type of @p value (URID).
- @param flags LV2_State_Flags for @p value.
- @return 0 on success, otherwise a non-zero error code.
-
- The host passes a callback of this type to LV2_State_Interface.save(). This
- callback is called repeatedly by the plugin to store all the properties that
- describe its current state.
-
- DO NOT INVENT NONSENSE URI SCHEMES FOR THE KEY. Best is to use keys from
- existing vocabularies. If nothing appropriate is available, use http URIs
- that point to somewhere you can host documents so documentation can be made
- resolvable (e.g. a child of the plugin or project URI). If this is not
- possible, invent a URN scheme, e.g. urn:myproj:whatever. The plugin MUST
- NOT pass an invalid URI key.
-
- The host MAY fail to store a property for whatever reason, but SHOULD
- store any property that is LV2_STATE_IS_POD and LV2_STATE_IS_PORTABLE.
- Implementations SHOULD use the types from the LV2 Atom extension
- (http://lv2plug.in/ns/ext/atom) wherever possible. The plugin SHOULD
- attempt to fall-back and avoid the error if possible.
-
- Note that @p size MUST be > 0, and @p value MUST point to a valid region of
- memory @p size bytes long (this is required to make restore unambiguous).
-
- The plugin MUST NOT attempt to use this function outside of the
- LV2_State_Interface.restore() context.
-*/
-typedef LV2_State_Status (*LV2_State_Store_Function)(
- LV2_State_Handle handle,
- uint32_t key,
- const void* value,
- size_t size,
- uint32_t type,
- uint32_t flags);
-
-/**
- A host-provided function to retrieve a property.
- @param handle Must be the handle passed to LV2_State_Interface.restore().
- @param key The key of the property to retrieve (URID).
- @param size (Output) If non-NULL, set to the size of the restored value.
- @param type (Output) If non-NULL, set to the type of the restored value.
- @param flags (Output) If non-NULL, set to the flags for the restored value.
- @return A pointer to the restored value (object), or NULL if no value
- has been stored under @p key.
-
- A callback of this type is passed by the host to
- LV2_State_Interface.restore(). This callback is called repeatedly by the
- plugin to retrieve any properties it requires to restore its state.
-
- The returned value MUST remain valid until LV2_State_Interface.restore()
- returns. The plugin MUST NOT attempt to use this function, or any value
- returned from it, outside of the LV2_State_Interface.restore() context.
-*/
-typedef const void* (*LV2_State_Retrieve_Function)(
- LV2_State_Handle handle,
- uint32_t key,
- size_t* size,
- uint32_t* type,
- uint32_t* flags);
-
-/**
- LV2 Plugin State Interface.
-
- When the plugin's extension_data is called with argument
- LV2_STATE__interface, the plugin MUST return an LV2_State_Interface
- structure, which remains valid for the lifetime of the plugin.
-
- The host can use the contained function pointers to save and restore the
- state of a plugin instance at any time, provided the threading restrictions
- of the functions are met.
-
- Stored data is only guaranteed to be compatible between instances of plugins
- with the same URI (i.e. if a change to a plugin would cause a fatal error
- when restoring state saved by a previous version of that plugin, the plugin
- URI MUST change just as it must when ports change incompatibly). Plugin
- authors should consider this possibility, and always store sensible data
- with meaningful types to avoid such problems in the future.
-*/
-typedef struct _LV2_State_Interface {
-
- /**
- Save plugin state using a host-provided @p store callback.
-
- @param instance The instance handle of the plugin.
- @param store The host-provided store callback.
- @param handle An opaque pointer to host data which MUST be passed as the
- handle parameter to @p store if it is called.
- @param flags Flags describing desired properties of this save. These
- flags may be used to determine the most appropriate values to store.
- @param features Extensible parameter for passing any additional
- features to be used for this save.
-
- The plugin is expected to store everything necessary to completely
- restore its state later. Plugins SHOULD store simple POD data whenever
- possible, and consider the possibility of state being restored much
- later on a different machine.
-
- The @p handle pointer and @p store function MUST NOT be used
- beyond the scope of save().
-
- This function has its own special threading class: it may not be called
- concurrently with any "Instantiation" function, but it may be called
- concurrently with functions in any other class, unless the definition of
- that class prohibits it (e.g. it may not be called concurrently with a
- "Discovery" function, but it may be called concurrently with an "Audio"
- function. The plugin is responsible for any locking or lock-free
- techniques necessary to make this possible.
-
- Note that in the simple case where state is only modified by restore(),
- there are no synchronization issues since save() is never called
- concurrently with restore() (though run() may read it during a save).
-
- Plugins that dynamically modify state while running, however, must take
- care to do so in such a way that a concurrent call to save() will save a
- consistent representation of plugin state for a single instant in time.
- */
- LV2_State_Status (*save)(LV2_Handle instance,
- LV2_State_Store_Function store,
- LV2_State_Handle handle,
- uint32_t flags,
- const LV2_Feature *const * features);
-
- /**
- Restore plugin state using a host-provided @p retrieve callback.
-
- @param instance The instance handle of the plugin.
- @param retrieve The host-provided retrieve callback.
- @param handle An opaque pointer to host data which MUST be passed as the
- handle parameter to @p retrieve if it is called.
- @param flags Currently unused.
- @param features Extensible parameter for passing any additional
- features to be used for this restore.
-
- The plugin MAY assume a restored value was set by a previous call to
- LV2_State_Interface.save() by a plugin with the same URI.
-
- The plugin MUST gracefully fall back to a default value when a value can
- not be retrieved. This allows the host to reset the plugin state with
- an empty map.
-
- The @p handle pointer and @p store function MUST NOT be used
- beyond the scope of restore().
-
- This function is in the "Instantiation" threading class as defined by
- LV2. This means it MUST NOT be called concurrently with any other
- function on the same plugin instance.
- */
- LV2_State_Status (*restore)(LV2_Handle instance,
- LV2_State_Retrieve_Function retrieve,
- LV2_State_Handle handle,
- uint32_t flags,
- const LV2_Feature *const * features);
-
-} LV2_State_Interface;
-
-/**
- Feature data for state:mapPath (LV2_STATE__mapPath).
-*/
-typedef struct {
-
- /**
- Opaque host data.
- */
- LV2_State_Map_Path_Handle handle;
-
- /**
- Map an absolute path to an abstract path for use in plugin state.
- @param handle MUST be the @p handle member of this struct.
- @param absolute_path The absolute path of a file.
- @return An abstract path suitable for use in plugin state.
-
- The plugin MUST use this function to map any paths that will be stored
- in plugin state. The returned value is an abstract path which MAY not
- be an actual file system path; @ref absolute_path() MUST be used to map
- it to an actual path in order to use the file.
-
- Plugins MUST NOT make any assumptions about abstract paths except that
- they can be mapped back to the absolute path of the "same" file (though
- not necessarily the same original path) using @ref absolute_path().
-
- This function may only be called within the context of
- LV2_State_Interface methods. The caller is responsible for freeing the
- returned value with free().
- */
- char* (*abstract_path)(LV2_State_Map_Path_Handle handle,
- const char* absolute_path);
-
- /**
- Map an abstract path from plugin state to an absolute path.
- @param handle MUST be the @p handle member of this struct.
- @param abstract_path An abstract path (e.g. a path from plugin state).
- @return An absolute file system path.
-
- The plugin MUST use this function in order to actually open or otherwise
- use any paths loaded from plugin state.
-
- This function may only be called within the context of
- LV2_State_Interface methods. The caller is responsible for freeing the
- returned value with free().
- */
- char* (*absolute_path)(LV2_State_Map_Path_Handle handle,
- const char* abstract_path);
-
-} LV2_State_Map_Path;
-
-/**
- Feature data for state:makePath (@ref LV2_STATE__makePath).
-*/
-typedef struct {
-
- /**
- Opaque host data.
- */
- LV2_State_Make_Path_Handle handle;
-
- /**
- Return a path the plugin may use to create a new file.
- @param handle MUST be the @p handle member of this struct.
- @param path The path of the new file within a namespace unique to this
- plugin instance.
- @return The absolute path to use for the new file.
-
- This function can be used by plugins to create files and directories,
- either at state saving time (if this feature is passed to
- LV2_State_Interface.save()) or any time (if this feature is passed to
- LV2_Descriptor.instantiate()).
-
- The host MUST do whatever is necessary for the plugin to be able to
- create a file at the returned path (e.g. using fopen), including
- creating any leading directories.
-
- If this function is passed to LV2_Descriptor.instantiate(), it may be
- called from any non-realtime context. If it is passed to
- LV2_State_Interface.save(), it may only be called within the dynamic
- scope of that function call.
-
- The caller is responsible for freeing the returned value with free().
- */
- char* (*path)(LV2_State_Make_Path_Handle handle,
- const char* path);
-
-} LV2_State_Make_Path;
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* LV2_STATE_H */
+++ /dev/null
-/* lv2_uri_map.h - C header file for the LV2 URI Map extension.
- *
- * Copyright (C) 2008 David Robillard <d@drobilla.net>
- *
- * This header is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This header is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this header; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307 USA
- */
-
-#ifndef LV2_URI_MAP_H
-#define LV2_URI_MAP_H
-
-#define LV2_URI_MAP_URI "http://lv2plug.in/ns/ext/uri-map"
-
-#include <stdint.h>
-
-/** @file
- * This header defines the LV2 URI Map extension with the URI
- * <http://lv2plug.in/ns/ext/uri-map> (preferred prefix 'lv2urimap').
- *
- * This extension defines a simple mechanism for plugins to map URIs to
- * integers, usually for performance reasons (e.g. processing events
- * typed by URIs in real time). The expected use case is for plugins to
- * map URIs to integers for things they 'understand' at instantiation time,
- * and store those values for use in the audio thread without doing any string
- * comparison. This allows the extensibility of RDF with the performance of
- * integers (or centrally defined enumerations).
- */
-
-
-/** Opaque pointer to host data. */
-typedef void* LV2_URI_Map_Callback_Data;
-
-
-/** The data field of the LV2_Feature for this extension.
- *
- * To support this feature the host must pass an LV2_Feature struct to the
- * plugin's instantiate method with URI "http://lv2plug.in/ns/ext/uri-map"
- * and data pointed to an instance of this struct.
- */
-typedef struct {
-
- /** Opaque pointer to host data.
- *
- * The plugin MUST pass this to any call to functions in this struct.
- * Otherwise, it must not be interpreted in any way.
- */
- LV2_URI_Map_Callback_Data callback_data;
-
- /** Get the numeric ID of a URI from the host.
- *
- * @param callback_data Must be the callback_data member of this struct.
- * @param map The 'context' of this URI. Certain extensions may define a
- * URI that must be passed here with certain restrictions on the
- * return value (e.g. limited range). This value may be NULL if
- * the plugin needs an ID for a URI in general.
- * @param uri The URI to be mapped to an integer ID.
- *
- * This function is referentially transparent - any number of calls with
- * the same arguments is guaranteed to return the same value over the life
- * of a plugin instance (though the same URI may return different values
- * with a different map parameter). However, this function is not
- * necessarily very fast: plugins should cache any IDs they might need in
- * performance critical situations.
- * The return value 0 is reserved and means an ID for that URI could not
- * be created for whatever reason. Extensions may define more precisely
- * what this means, but in general plugins should gracefully handle 0
- * and consider whatever they wanted the URI for "unsupported".
- */
- uint32_t (*uri_to_id)(LV2_URI_Map_Callback_Data callback_data,
- const char* map,
- const char* uri);
-
-} LV2_URI_Map_Feature;
-
-
-#endif // LV2_URI_MAP_H
-
+++ /dev/null
-/*
- Copyright 2011 Gabriel M. Beddingfield <gabrbedd@gmail.com>
- 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
- C header for the LV2 URID extension <http://lv2plug.in/ns/ext/urid>
-*/
-
-#ifndef LV2_URID_H
-#define LV2_URID_H
-
-#define LV2_URID_URI "http://lv2plug.in/ns/ext/urid"
-#define LV2_URID_MAP_URI LV2_URID_URI "#map"
-#define LV2_URID_UNMAP_URI LV2_URID_URI "#unmap"
-
-#include <stdint.h>
-
-/**
- Opaque pointer to host data for LV2_URID_Map.
-*/
-typedef void* LV2_URID_Map_Handle;
-
-/**
- Opaque pointer to host data for LV2_URID_Unmap.
-*/
-typedef void* LV2_URID_Unmap_Handle;
-
-/**
- URI mapped to an integer.
-*/
-typedef uint32_t LV2_URID;
-
-/**
- URI Map (http://lv2plug.in/ns/ext/urid#map).
-*/
-typedef struct {
- /**
- Opaque pointer to host data.
-
- This MUST be passed to map_uri() whenever it is called.
- Otherwise, it must not be interpreted in any way.
- */
- LV2_URID_Map_Handle handle;
-
- /**
- Get the numeric ID of a URI.
-
- If the ID does not already exist, it will be created.
-
- This function is referentially transparent; any number of calls with the
- same arguments is guaranteed to return the same value over the life of a
- plugin instance. Note, however, that several URIs MAY resolve to the
- same ID if the host considers those URIs equivalent.
-
- This function is not necessarily very fast or RT-safe: plugins SHOULD
- cache any IDs they might need in performance critical situations.
-
- The return value 0 is reserved and indicates that an ID for that URI
- could not be created for whatever reason. However, hosts SHOULD NOT
- return 0 from this function in non-exceptional circumstances (i.e. the
- URI map SHOULD be dynamic).
-
- @param handle Must be the callback_data member of this struct.
- @param uri The URI to be mapped to an integer ID.
- */
- LV2_URID (*map)(LV2_URID_Map_Handle handle,
- const char* uri);
-} LV2_URID_Map;
-
-/**
- URI Unmap (http://lv2plug.in/ns/ext/urid#unmap).
-*/
-typedef struct {
- /**
- Opaque pointer to host data.
-
- This MUST be passed to unmap() whenever it is called.
- Otherwise, it must not be interpreted in any way.
- */
- LV2_URID_Unmap_Handle handle;
-
- /**
- Get the URI for a previously mapped numeric ID.
-
- Returns NULL if @c urid is not yet mapped. Otherwise, the corresponding
- URI is returned in a canonical form. This MAY not be the exact same
- string that was originally passed to LV2_URID_Map::map(), but it MUST be
- an identical URI according to the URI syntax specification (RFC3986). A
- non-NULL return for a given @c urid will always be the same for the life
- of the plugin. Plugins that intend to perform string comparison on
- unmapped URIs SHOULD first canonicalise URI strings with a call to
- map_uri() followed by a call to unmap_uri().
-
- @param handle Must be the callback_data member of this struct.
- @param urid The ID to be mapped back to the URI string.
- */
- const char* (*unmap)(LV2_URID_Unmap_Handle handle,
- LV2_URID urid);
-} LV2_URID_Unmap;
-
-#endif /* LV2_URID_H */
+++ /dev/null
-/*
- Copyright 2012 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 worker.h C header for the LV2 Worker extension
- <http://lv2plug.in/ns/ext/worker>.
-*/
-
-#ifndef LV2_WORKER_H
-#define LV2_WORKER_H
-
-#include <stdint.h>
-
-#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
-
-#define LV2_WORKER_URI "http://lv2plug.in/ns/ext/worker"
-#define LV2_WORKER_PREFIX LV2_WORKER_URI "#"
-
-#define LV2_WORKER__interface LV2_WORKER_PREFIX "interface"
-#define LV2_WORKER__schedule LV2_WORKER_PREFIX "schedule"
-
-/**
- A status code for worker functions.
-*/
-typedef enum {
- LV2_WORKER_SUCCESS = 0, /**< Completed successfully. */
- LV2_WORKER_ERR_UNKNOWN = 1, /**< Unknown error. */
- LV2_WORKER_ERR_NO_SPACE = 2 /**< Failed due to lack of space. */
-} LV2_Worker_Status;
-
-typedef void* LV2_Worker_Respond_Handle;
-
-/**
- A function to respond to run() from the worker method.
-
- The @p data MUST be safe for the host to copy and later pass to
- work_response(), and the host MUST guarantee that it will be eventually
- passed to work_response() if this function returns LV2_WORKER_SUCCESS.
-*/
-typedef LV2_Worker_Status (*LV2_Worker_Respond_Function)(
- LV2_Worker_Respond_Handle handle,
- uint32_t size,
- const void* data);
-
-/**
- LV2 Plugin Worker Interface.
-
- This is the interface provided by the plugin to implement a worker method.
- The plugin's extension_data() method should return an LV2_Worker_Interface
- when called with LV2_WORKER__interface as its argument.
-*/
-typedef struct _LV2_Worker_Interface {
- /**
- The worker method. This is called by the host in a non-realtime context
- as requested, possibly with an arbitrary message to handle.
-
- A response can be sent to run() using @p respond. The plugin MUST NOT
- make any assumptions about which thread calls this method, other than
- the fact that there are no real-time requirements.
-
- @param instance The LV2 instance this is a method on.
- @param respond A function for sending a response to run().
- @param handle Must be passed to @p respond if it is called.
- @param size The size of @p data.
- @param data Data from run(), or NULL.
- */
- LV2_Worker_Status (*work)(LV2_Handle instance,
- LV2_Worker_Respond_Function respond,
- LV2_Worker_Respond_Handle handle,
- uint32_t size,
- const void* data);
-
- /**
- Handle a response from the worker. This is called by the host in the
- run() context when a response from the worker is ready.
-
- @param instance The LV2 instance this is a method on.
- @param size The size of @p body.
- @param body Message body, or NULL.
- */
- LV2_Worker_Status (*work_response)(LV2_Handle instance,
- uint32_t size,
- const void* body);
-
- /**
- Called when all responses for this cycle have been delivered.
-
- Since work_response() may be called after run() finished, this provides
- a hook for code that must run after the cycle is completed.
-
- This field may be NULL if the plugin has no use for it. Otherwise, the
- host MUST call it after every run(), regardless of whether or not any
- responses were sent that cycle.
- */
- LV2_Worker_Status (*end_run)(LV2_Handle instance);
-} LV2_Worker_Interface;
-
-typedef void* LV2_Worker_Schedule_Handle;
-
-typedef struct _LV2_Worker_Schedule {
- /**
- Opaque host data.
- */
- LV2_Worker_Schedule_Handle handle;
-
- /**
- Request from run() that the host call the worker.
-
- This function is in the audio threading class. It should be called from
- run() to request that the host call the work() method in a non-realtime
- context with the given arguments.
-
- This function is always safe to call from run(), but it is not
- guaranteed that the worker is actually called from a different thread.
- In particular, when free-wheeling (e.g. for offline rendering), the
- worker may be executed immediately. This allows single-threaded
- processing with sample accuracy and avoids timing problems when run() is
- executing much faster or slower than real-time.
-
- Plugins SHOULD be written in such a way that if the worker runs
- immediately, and responses from the worker are delivered immediately,
- the effect of the work takes place immediately with sample accuracy.
-
- The @p data MUST be safe for the host to copy and later pass to work(),
- and the host MUST guarantee that it will be eventually passed to work()
- if this function returns LV2_WORKER_SUCCESS.
-
- @param handle The handle field of this struct.
- @param size The size of @p data.
- @param data Message to pass to work(), or NULL.
- */
- LV2_Worker_Status (*schedule_work)(LV2_Worker_Schedule_Handle handle,
- uint32_t size,
- const void* data);
-} LV2_Worker_Schedule;
-
-#endif /* LV2_WORKER_H */
struct LV2Plugin::Impl {
Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
, work_iface(0)
-#ifdef HAVE_NEW_LILV
, state(0)
-#endif
{}
/** Find the LV2 input port with the given designation.
LilvNode* author;
LilvInstance* instance;
LV2_Worker_Interface* work_iface;
-#ifdef HAVE_NEW_LILV
LilvState* state;
-#endif
};
LV2Plugin::LV2Plugin (AudioEngine& engine,
LilvPlugin* plugin = _impl->plugin;
-#ifdef HAVE_NEW_LILV
LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
_has_state_interface =
|| lilv_plugin_has_feature(plugin, state_uri);
lilv_node_free(state_uri);
lilv_node_free(state_iface_uri);
-#endif
_features = (LV2_Feature**)malloc(sizeof(LV2_Feature*) * 8);
_features[0] = &_instance_access_feature;
if (_has_state_interface) {
cout << "LV2 " << name() << " has state interface" << endl;
-#ifdef HAVE_NEW_LILV
// Provisionally increment state version and create directory
const std::string new_dir = state_dir(++_state_version);
g_mkdir_with_parents(new_dir.c_str(), 0744);
}
root->add_property("state-dir", string_compose("state%1", _state_version));
-
-#else /* !HAVE_NEW_LILV */
- warning << string_compose(
- _("Plugin \"%1\" has state, but Lilv is too old to save it"),
- unique_id()) << endmsg;
-#endif /* HAVE_NEW_LILV */
} else {
cout << "LV2 " << name() << " has no state interface." << endl;
}
void
LV2Plugin::find_presets()
{
-#ifdef HAVE_NEW_LILV
LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LILV_NS_LV2 "appliesTo");
LilvNode* pset_Preset = lilv_new_uri(_world.world, NS_PSET "Preset");
LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
lilv_node_free(rdfs_label);
lilv_node_free(pset_Preset);
lilv_node_free(lv2_appliesTo);
-#endif /* HAVE_NEW_LILV */
}
bool
set_parameter(port_id, atof(value));
}
-#ifdef HAVE_NEW_LILV
_state_version = 0;
if ((prop = node.property("state-dir")) != 0) {
if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
}
-#endif
latency_compute_run();
LilvPort*
LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
{
- LilvPort* port = NULL;
-#ifdef HAVE_NEW_LILV
+ LilvPort* port = NULL;
LilvNode* designation = lilv_new_uri(_world.world, uri);
port = lilv_plugin_get_port_by_designation(
plugin, _world.lv2_InputPort, designation);
if (port) {
bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
}
-#endif
return port;
}
atleast_version='2.0')
if Options.options.lv2:
autowaf.check_pkg(conf, 'lilv-0', uselib_store='LILV',
- atleast_version='0.0.0', mandatory=False)
- autowaf.check_pkg(conf, 'lilv-0', uselib_store='NEW_LILV',
atleast_version='0.14.0', mandatory=False)
if conf.is_defined('HAVE_LILV'):
autowaf.check_pkg(conf, 'suil-0', uselib_store='SUIL',
- atleast_version='0.2.0', mandatory=False)
- autowaf.check_pkg(conf, 'suil-0', uselib_store='NEW_SUIL',
- atleast_version='0.5.0', mandatory=False)
+ atleast_version='0.6.0', mandatory=False)
# autowaf.check_pkg(conf, 'soundtouch-1.0', uselib_store='SOUNDTOUCH',
# mandatory=False)
write_config_text('JACK session support', conf.is_defined('JACK_SESSION'))
write_config_text('LV2 UI embedding', conf.is_defined('HAVE_SUIL'))
write_config_text('LV2 support', conf.is_defined('LV2_SUPPORT'))
- write_config_text('LV2 state support', conf.is_defined('HAVE_NEW_LILV'))
write_config_text('LXVST support', conf.is_defined('LXVST_SUPPORT'))
write_config_text('OGG', conf.is_defined('HAVE_OGG'))
write_config_text('Phone home', conf.is_defined('PHONE_HOME'))
projects / ardour.git / commitdiff