diff options
| -rw-r--r-- | Doxyfile | 3 | ||||
| -rw-r--r-- | ext/state.lv2/manifest.ttl | 9 | ||||
| -rw-r--r-- | ext/state.lv2/state.h | 248 | ||||
| -rw-r--r-- | ext/state.lv2/state.ttl | 230 |
4 files changed, 489 insertions, 1 deletions
@@ -565,8 +565,8 @@ WARN_LOGFILE = # with spaces. INPUT = \ - doc/mainpage.dox \ core.lv2/lv2.h \ + doc/mainpage.dox \ ext/atom.lv2/atom-helpers.h \ ext/atom.lv2/atom.h \ ext/contexts.lv2/contexts.h \ @@ -582,6 +582,7 @@ INPUT = \ ext/pui-event.lv2/pui-event.h \ ext/pui-gtk.lv2/pui-gtk.h \ ext/pui.lv2/pui.h \ + ext/state.lv2/state.h \ ext/string-port.lv2/string-port.h \ ext/time.lv2/time.h \ ext/ui-resize.lv2/ui-resize.h \ diff --git a/ext/state.lv2/manifest.ttl b/ext/state.lv2/manifest.ttl new file mode 100644 index 0000000..ce76fd9 --- /dev/null +++ b/ext/state.lv2/manifest.ttl @@ -0,0 +1,9 @@ +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . + +<http://lv2plug.in/ns/ext/state> + a lv2:Specification ; + lv2:minorVersion 0 ; + lv2:microVersion 1 ; + rdfs:seeAlso <state.ttl> . + diff --git a/ext/state.lv2/state.h b/ext/state.lv2/state.h new file mode 100644 index 0000000..56ebfda --- /dev/null +++ b/ext/state.lv2/state.h @@ -0,0 +1,248 @@ +/* + Copyright 2010-2011 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 + C API for the LV2 State extension <http://lv2plug.in/ns/ext/state>. +*/ + +#ifndef LV2_STATE_H +#define LV2_STATE_H + +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> + +#include "lv2/lv2plug.in/ns/lv2core/lv2.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define LV2_STATE_URI "http://lv2plug.in/ns/ext/state" + +/** + 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 references to non-stateent or + non-global resources (e.g. pointers, handles, local paths, etc.). It is + safe to copy POD values with a simple memcpy and store them for use at + any time in the future on a machine with a compatible architecture + (e.g. the same endianness and alignment). + + 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, i.e. if the value is saved on one machine it can safely be + restored on another machine regardless of endianness, alignment, etc. + */ + 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 host-provided function to store a property. + @param callback_data Must be the callback_data passed to LV2_State_Interface.save(). + @param key The key (predicate) to store @c value under (URI mapped integer). + @param value Pointer to the value (object) to be stored. + @param size The size of the data at @c value in bytes. + @param type The type of @c value (URI). + @param flags LV2_State_Flags for @c 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 within LV2_State_Interface.save() to store all + the statements that describe its current state. + + The host MAY fail to store a property if the type is not understood and is + not LV2_STATE_IS_POD and/or LV2_STATE_IS_PORTABLE. Implementations are + encouraged to use POD and portable values (e.g. string literals) wherever + possible, and use common types (e.g. types from + http://lv2plug.in/ns/ext/atom) regardless, since hosts are likely to already + contain the necessary implementation. + + Note that @c size MUST be > 0, and @c value MUST point to a valid region of + memory @c 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 int (*LV2_State_Store_Function)( + void* callback_data, + uint32_t key, + const void* value, + size_t size, + uint32_t type, + uint32_t flags); + +/** + A host-provided function to retrieve a property. + @param callback_data Must be the callback_data passed to + LV2_State_Interface.restore(). + @param key The key (predicate) of the property to retrieve (URI). + @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 LV2_State_Flags for + the returned value. + @return A pointer to the restored value (object), or NULL if no value + has been stored under @c key. + + A callback of this type is passed by the host to + LV2_State_Interface.restore(). This callback is called repeatedly by the + plugin within LV2_State_Interface.restore() 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. Returned values MAY be + copied for later use if necessary, assuming the plugin knows how to do so + correctly (e.g. the value is POD, or the plugin understands the type). +*/ +typedef const void* (*LV2_State_Retrieve_Function)( + void* callback_data, + uint32_t key, + size_t* size, + uint32_t* type, + uint32_t* flags); + +/** + State Extension Data. + + When the plugin's extension_data is called with argument LV2_STATE_URI, + the plugin MUST return an LV2_State 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 + for the given function are met). + + The typical use case is to save the plugin's state when a project is saved, + and to restore the state when a project has been loaded. Other uses are + possible (e.g. cloning plugin instances or taking a snapshot of plugin + state). + + 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 compatibility issues in the future. +*/ +typedef struct _LV2_State_Interface { + + /** + Save plugin state using a host-provided @c store callback. + + @param instance The instance handle of the plugin. + @param store The host-provided store callback. + @param callback_data An opaque pointer to host data, e.g. the map or + file where the values are to be stored. If @c store is called, this MUST + be passed as its callback_data parameter. + @param flags Flags describing desires properties of this save. The + plugin SHOULD use these values to determine the most appropriate and/or + efficient serialisation, but is not required to do so. + + The plugin is expected to store everything necessary to completely + restore its state later (possibly much later, in a different process, on + a completely different machine, etc.) + + The @c callback_data pointer and @c 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. + */ + void (*save)(LV2_Handle instance, + LV2_State_Store_Function store, + void* callback_data, + uint32_t flags); + + /** + Restore plugin state using a host-provided @c retrieve callback. + + @param instance The instance handle of the plugin. + @param retrieve The host-provided retrieve callback. + @param callback_data An opaque pointer to host data, e.g. the map or + file from which the values are to be restored. If @c retrieve is + called, this MUST be passed as its callback_data parameter. + @param flags Currently unused. + + 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 @c callback_data pointer and @c 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. + */ + void (*restore)(LV2_Handle instance, + LV2_State_Retrieve_Function retrieve, + void* callback_data, + uint32_t flags); + +} LV2_State_Interface; + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* LV2_STATE_H */ diff --git a/ext/state.lv2/state.ttl b/ext/state.lv2/state.ttl new file mode 100644 index 0000000..70b0b5d --- /dev/null +++ b/ext/state.lv2/state.ttl @@ -0,0 +1,230 @@ +# LV2 State Extension +# Copyright 2010-2011 David Robillard <d@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. + +@prefix state: <http://lv2plug.in/ns/ext/state#> . +@prefix doap: <http://usefulinc.com/ns/doap#> . +@prefix foaf: <http://xmlns.com/foaf/0.1/> . +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . +@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . +@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . + +<http://lv2plug.in/ns/ext/state> + a lv2:Specification ; + doap:name "LV2 State" ; + doap:license <http://opensource.org/licenses/isc-license> ; + doap:release [ + doap:revision "0.1" ; + doap:created "2011-11-12" + ] ; + doap:developer [ + a foaf:Person ; + foaf:name "Leonard Ritter" ; + foaf:homepage <http://paniq.org> ; + ] ; + doap:maintainer [ + a foaf:Person ; + foaf:name "David Robillard" ; + foaf:homepage <http://drobilla.net/> ; + rdfs:seeAlso <http://drobilla.net/drobilla.rdf> + ] ; + lv2:documentation """ +<p>This extension provides a mechanism for plugins to save and restore state +across instances, allowing hosts to save configuration/state/data with a +project or fully clone (i.e. make a deep copy of) a plugin instance.</p> + +<p>This extension allows plugins to save private state data, i.e. data that is +not contained in input ports. The motivating ideal is for the state of a +plugin instance to be <em>entirely</em> described by port values (as with all +LV2 plugins) and a key/value dictionary as defined by this extension. This +mechanism is simple, yet sufficiently powerful to describe very advanced and +complex state.</p> + +<p>The <q>state</q> described by this extension is conceptually a single +key/value dictionary. Keys are URIs, and values are type-tagged blobs of any +type. The plugin provides a save and restore method for saving and restoring +state. To initiate a save or restore, the host calls these methods, passing a +callback to be used for handling a single key/value pair. The host is free to +implement saving and restoring in any way; the actual mechanism is completely +abstract from the plugin's perspective.</p> + +<p>Because the state is a simple dictionary, hosts and plugins can work with +state easily from many languages and protocols. Additionally, this format is +simple and terse to serialise in many formats (e.g. any RDF syntax, JSON, XML, +key/value databases such as BDB, etc.). In particular, state can be elegantly +described in a plugin's Turtle description, which is useful for e.g. presets or +default state.</p> + +<p>This extension defines a conceptual model of state and a mechanism for +saving and restoring it, but no interface for manipulating that state +dynamically. It is intended that a generic way to modify this state (e.g. +with messages sent via ports) is the preferred way to achieve more advanced +plugin control than control ports provide, but the details of this mechanism +should be addressed by a separate extension.</p> + +<p>In pseudo code, a typical use case in a plugin is:</p> +<pre class="c-code"> +#define NS_EG "http://example.org/" +#define NS_ATOM "http://lv2plug.in/ns/ext/atom#" + +LV2_Handle my_instantiate(...) +{ + MyPlugin* plugin = ...; + LV2_URI_Map_Feature* map = ...; + plugin->uri_greeting_key = map->uri_to_id(..., NULL, NS_EG "greeting"); + plugin->uri_xsd_string = map->uri_to_id(..., NULL, NS_ATOM "String"); + plugin->state->greeting = strdup("Hello"); + return plugin; +} + +void my_save(LV2_Handle instance, + LV2_State_Store_Function store, + void* callback_data, + uint32_t flags) +{ + MyPlugin* plugin = (MyPlugin*)instance; + const char* greeting = plugin->state->greeting; + + store(callback_data, + plugin->uri_greeting_key, + greeting, + strlen(greeting) + 1, + plugin->uri_xsd_string, + LV2_STATE_IS_POD | LV2_STATE_IS_PORTABLE); +} + +void my_restore(LV2_Handle instance, + LV2_State_Retrieve_Function retrieve, + void* callback_data, + uint32_t flags) +{ + MyPlugin* plugin = (MyPlugin*)instance; + + size_t size; + uint32_t type; + uint32_t flags; + const char* greeting = retrieve(callback_data, + plugin->uri_greeting_key, + &size, + &type, + &flags); + + if (greeting) { + free(plugin->state->greeting); + plugin->state->greeting = strdup(greeting); + } else { + plugin->state->greeting = strdup("Hello"); + } +} + +const void* my_extension_data(const char* uri) +{ + static const LV2_State_Interface state_iface = { my_save, my_restore }; + if (!strcmp(uri, "http://lv2plug.in/ns/ext/state#Interface")) { + return &state_iface; + } +} +</pre> + +<p>Similarly, a typical use case in a host is:</p> +<pre class="c-code"> +int store_callback(void* callback_data, + uint32_t key, + const void* value, + size_t size, + uint32_t type, + uint32_t flags) +{ + if ((flags & LV2_STATE_IS_POD)) { + /* We only care about POD since we're keeping state in memory only. + If this was for disk or network storage/transmission, + LV2_STATE_IS_PORTABLE would have to be checked as well. + */ + Map* state_map = (Map*)callback_data; + state_map->insert(key, Value(copy(value), size, type, pod)); + return 0; + } else { + return 1; /* Non-POD events are unsupported. */ + } +} + +Map get_plugin_state(LV2_Handle instance) +{ + LV2_State* state = instance.extension_data("http://lv2plug.in/ns/ext/state"); + Map state_map; + /** Request a fast/native/POD save, since we're just copying in memory */ + state.save(instance, store_callback, &state_map, + LV2_STATE_IS_POD|LV2_STATE_IS_NATIVE); + return state_map; +} +</pre> +""" . + +state:Interface + a rdfs:Class ; + rdfs:subClassOf lv2:ExtensionData ; + lv2:documentation """ +A structure (LV2_State_Interface) which contains functions to be called by the +host to save and restore state. In order to support this extension, the plugin +must return a valid LV2_State_Interface from LV2_Descriptor::extension_data() +when it is called with URI "http://lv2plug.in/ns/ext/state#StateInterface". + +The plugin data file should describe this like so: +<pre class="turtle-code"> +@prefix state: <http://lv2plug.in/ns/ext/state#> . + +<plugin> + a lv2:Plugin ; + lv2:extensionData state:Interface . +</pre> +""" . + +state:InstanceState + a rdfs:Class ; + rdfs:label "Plugin Instance State" ; + rdfs:comment """ +This class is used to express a plugin instance's state in RDF. The key/value +properties of the instance form the predicate/object (respectively) of triples +with a state:InstanceState as the subject (see state:instanceState for an +example). This may be used wherever it is useful to express a plugin instance's +state in RDF (e.g. for serialisation, storing in a model, or transmitting over +a network). Note that this class is provided because it may be useful for +hosts, plugins, or extensions that work with instance state, but its use is not +required to support the LV2 State extension. +""" . + +state:instanceState + a rdf:Property ; + rdfs:range state:InstanceState ; + lv2:documentation """ +Predicate to relate a plugin instance to an InstanceState. This may be used +wherever the state of a particular plugin instance needs to be represented. +Note that the domain of this property is unspecified, since LV2 does not define +any RDF class for plugin instance. This predicate may be used wherever it makes +sense to do so, e.g.: +<pre class="turtle-code"> +@prefix eg: <http://example.org/> . + +<plugininstance> state:instanceState [ + eg:somekey "some value" ; + eg:someotherkey "some other value" ; + eg:favourite-number 2 +] . +</pre> +Note that this property is provided because it may be useful for hosts, +plugins, or extensions that work with instance state, but its use is not +required to support the LV2 State extension. +""" . |