From fa10bccb322dedee6b72d6f8c1834de8b194d3ca Mon Sep 17 00:00:00 2001 From: Bent Bisballe Nyeng Date: Mon, 11 Jun 2012 19:15:09 +0200 Subject: Port to new LV2 state interface. Use new lv2-1.0 header files (from system) and remove local copies of same. --- lv2/lv2_persist.h | 231 ------------------------------------------------------ 1 file changed, 231 deletions(-) delete mode 100644 lv2/lv2_persist.h (limited to 'lv2/lv2_persist.h') diff --git a/lv2/lv2_persist.h b/lv2/lv2_persist.h deleted file mode 100644 index 69f1181..0000000 --- a/lv2/lv2_persist.h +++ /dev/null @@ -1,231 +0,0 @@ -/* - 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