From 4a4d0a84bb1b80555052f59c1a4addc870ce5fda Mon Sep 17 00:00:00 2001 From: Bent Bisballe Nyeng Date: Mon, 23 Jan 2012 20:37:20 +0100 Subject: Make plugin store its state. Connect state and GUI (and use GUI) --- lv2/lv2_data_access.h | 59 ++++++++++++ lv2/lv2_instance-access.h | 38 ++++++++ lv2/lv2_persist.h | 231 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 328 insertions(+) create mode 100644 lv2/lv2_data_access.h create mode 100644 lv2/lv2_instance-access.h create mode 100644 lv2/lv2_persist.h (limited to 'lv2') diff --git a/lv2/lv2_data_access.h b/lv2/lv2_data_access.h new file mode 100644 index 0000000..d6403b4 --- /dev/null +++ b/lv2/lv2_data_access.h @@ -0,0 +1,59 @@ +/* lv2_data_access.h - C header file for the LV2 Data Access extension. + * Copyright (C) 2008 Dave Robillard + * + * 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_DATA_ACCESS_H +#define LV2_DATA_ACCESS_H + +#define LV2_DATA_ACCESS_URI "http://lv2plug.in/ns/ext/data-access" + + +/** @file + * This header defines the LV2 Extension Data extension with the URI + * . + * + * This extension defines a method for (e.g.) plugin UIs to have (possibly + * marshalled) access to the extension_data function on a plugin instance. + */ + + +/** The data field of the LV2_Feature for this extension. + * + * To support this feature the host must pass an LV2_Feature struct to the + * instantiate method with URI "http://lv2plug.in/ns/ext/data-access" + * and data pointed to an instance of this struct. + */ +typedef struct { + + /** A pointer to a method the UI can call to get data (of a type specified + * by some other extension) from the plugin. + * + * This call never is never guaranteed to return anything, UIs should + * degrade gracefully if direct access to the plugin data is not possible + * (in which case this function will return NULL). + * + * This is for access to large data that can only possibly work if the UI + * and plugin are running in the same process. For all other things, use + * the normal LV2 UI communication system. + */ + const void* (*data_access)(const char* uri); + +} LV2_Extension_Data_Feature; + + +#endif // LV2_DATA_ACCESS_H + diff --git a/lv2/lv2_instance-access.h b/lv2/lv2_instance-access.h new file mode 100644 index 0000000..7e18ee4 --- /dev/null +++ b/lv2/lv2_instance-access.h @@ -0,0 +1,38 @@ +/* + LV2 Instance Access Extension + Copyright 2008-2011 David Robillard + + 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. +*/ + +#ifndef LV2_INSTANCE_ACCESS_H +#define LV2_INSTANCE_ACCESS_H + +#define LV2_INSTANCE_ACCESS_URI "http://lv2plug.in/ns/ext/instance-access" + + +/** @file + * C header for the LV2 Instance Access extension + * . + * + * This extension defines a method for (e.g.) plugin UIs to get a direct + * handle to an LV2 plugin instance (LV2_Handle), if possible. + * + * To support this feature the host must pass an LV2_Feature struct to the + * UI instantiate method with URI "http://lv2plug.in/ns/ext/instance-access" + * and data pointed directly to the LV2_Handle of the plugin instance. + */ + + +#endif /* LV2_INSTANCE_ACCESS_H */ + diff --git a/lv2/lv2_persist.h b/lv2/lv2_persist.h new file mode 100644 index 0000000..69f1181 --- /dev/null +++ b/lv2/lv2_persist.h @@ -0,0 +1,231 @@ +/* + Copyright 2010-2011 David Robillard + Copyright 2010 Leonard Ritter + + 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 +*/ + +/** + @file + C API for the LV2 Persist extension . +*/ + +#ifndef LV2_PERSIST_H +#define LV2_PERSIST_H + +#include +#include +#include + +#include "lv2/lv2plug.in/ns/lv2core/lv2.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define LV2_PERSIST_URI "http://lv2plug.in/ns/ext/persist" + +/** + 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-persistent 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_PERSIST_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_PERSIST_IS_PORTABLE = 1 << 1 + +} LV2_Persist_Flags; + +/** + A host-provided function to store a property. + @param callback_data Must be the callback_data passed to LV2_Persist.save(). + @param key The key (predicate) to store @a value under (URI mapped integer). + @param value Pointer to the value (object) to be stored. + @param size The size of the data at @a value in bytes. + @param type The type of @a value (URI). + @param flags LV2_Persist_Flags for @a value. + @return 0 on success, otherwise a non-zero error code. + + The host passes a callback of this type to LV2_Persist.save(). This callback + is called repeatedly by the plugin within LV2_Persist.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_PERSIST_IS_POD and/or LV2_PERSIST_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 @a size MUST be > 0, and @a value MUST point to a valid region of + memory @a size bytes long (this is required to make restore unambiguous). + + The plugin MUST NOT attempt to use this function outside of the + LV2_Persist.restore() context. +*/ +typedef int (*LV2_Persist_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_Persist.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_Persist_Flags for + the returned value. + @return A pointer to the restored value (object), or NULL if no value + has been stored under @a key. + + A callback of this type is passed by the host to LV2_Persist.restore(). This + callback is called repeatedly by the plugin within LV2_Persist.restore() to + retrieve any properties it requires to restore its state. + + The returned value MUST remain valid until LV2_Persist.restore() returns. + + The plugin MUST NOT attempt to use this function, or any value returned from + it, outside of the LV2_Persist.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_Persist_Retrieve_Function)( + void* callback_data, + uint32_t key, + size_t* size, + uint32_t* type, + uint32_t* flags); + +/** + Persist Extension Data. + + When the plugin's extension_data is called with argument LV2_PERSIST_URI, + the plugin MUST return an LV2_Persist 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_Persist { + + /** + Save plugin state using a host-provided @a 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 @a store is called, + this MUST be passed as its callback_data parameter. + + 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 @a callback_data pointer and @a 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_Persist_Store_Function store, + void* callback_data); + + /** + Restore plugin state using a host-provided @a 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 @a retrieve is + called, this MUST be passed as its callback_data parameter. + + The plugin MAY assume a restored value was set by a previous call to + LV2_Persist.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 @a callback_data pointer and @a 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_Persist_Retrieve_Function retrieve, + void* callback_data); + +} LV2_Persist; + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* LV2_PERSIST_H */ -- cgit v1.2.3