From 6d6e2458c3dff83ee6f68a1c7c5f7ed69bb121ab Mon Sep 17 00:00:00 2001 From: David Robillard Date: Fri, 4 Nov 2011 00:54:20 +0000 Subject: Add state extension (a minor improvement to persist). --- ext/state.lv2/manifest.ttl | 9 ++ ext/state.lv2/state.h | 248 +++++++++++++++++++++++++++++++++++++++++++++ ext/state.lv2/state.ttl | 230 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 487 insertions(+) create mode 100644 ext/state.lv2/manifest.ttl create mode 100644 ext/state.lv2/state.h create mode 100644 ext/state.lv2/state.ttl (limited to 'ext') 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: . +@prefix rdfs: . + + + a lv2:Specification ; + lv2:minorVersion 0 ; + lv2:microVersion 1 ; + rdfs:seeAlso . + 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 + Copyright 2010 Leonard Ritter + + 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 . +*/ + +#ifndef LV2_STATE_H +#define LV2_STATE_H + +#include +#include +#include + +#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 +# Copyright 2010 Leonard Ritter +# +# 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: . +@prefix doap: . +@prefix foaf: . +@prefix lv2: . +@prefix rdf: . +@prefix rdfs: . +@prefix xsd: . + + + a lv2:Specification ; + doap:name "LV2 State" ; + doap:license ; + doap:release [ + doap:revision "0.1" ; + doap:created "2011-11-12" + ] ; + doap:developer [ + a foaf:Person ; + foaf:name "Leonard Ritter" ; + foaf:homepage ; + ] ; + doap:maintainer [ + a foaf:Person ; + foaf:name "David Robillard" ; + foaf:homepage ; + rdfs:seeAlso + ] ; + lv2:documentation """ +

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.

+ +

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 entirely 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.

+ +

The state 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.

+ +

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.

+ +

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.

+ +

In pseudo code, a typical use case in a plugin is:

+
+#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;
+    }
+}
+
+ +

Similarly, a typical use case in a host is:

+
+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;
+}
+
+""" . + +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: +
+@prefix state: <http://lv2plug.in/ns/ext/state#> .
+
+<plugin>
+    a lv2:Plugin ;
+    lv2:extensionData state:Interface .
+
+""" . + +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.: +
+@prefix eg: <http://example.org/> .
+
+<plugininstance> state:instanceState [
+    eg:somekey "some value" ;
+    eg:someotherkey "some other value" ;
+    eg:favourite-number 2
+] .
+
+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. +""" . -- cgit v1.2.1