From: David Robillard Date: Fri, 11 Nov 2011 22:54:45 +0000 (+0000) Subject: Update LV2 persist extension implementation (now named LV2 state). X-Git-Tag: 3.0-beta1~55 X-Git-Url: https://main.carlh.net/gitweb/?a=commitdiff_plain;h=c4bec7f098640cc1f7425f54bb1cf5cd8541dcbf;p=ardour.git Update LV2 persist extension implementation (now named LV2 state). git-svn-id: svn://localhost/ardour2/branches/3.0@10556 d708f5d6-7413-0410-9779-e7cbd77b26cf --- diff --git a/libs/ardour/ardour/lv2_plugin.h b/libs/ardour/ardour/lv2_plugin.h index 3f49a8c9f4..95f730a43e 100644 --- a/libs/ardour/ardour/lv2_plugin.h +++ b/libs/ardour/ardour/lv2_plugin.h @@ -129,7 +129,7 @@ class LV2Plugin : public ARDOUR::Plugin float* _defaults; float* _latency_control_port; bool _was_activated; - bool _supports_persist; + bool _has_state_interface; std::vector _port_is_input; std::map _port_indices; @@ -145,22 +145,25 @@ class LV2Plugin : public ARDOUR::Plugin LV2_Feature _instance_access_feature; LV2_Feature _path_support_feature; LV2_Feature _new_file_support_feature; - LV2_Feature _persist_feature; static URIMap _uri_map; static uint32_t _midi_event_type; - static int lv2_persist_store_callback (void* host_data, - uint32_t key, - const void* value, - size_t size, - uint32_t type, - uint32_t flags); - static const void* lv2_persist_retrieve_callback (void* host_data, - uint32_t key, - size_t* size, - uint32_t* type, - uint32_t* flags); + static int + lv2_state_store_callback (void* handle, + uint32_t key, + const void* value, + size_t size, + uint32_t type, + uint32_t flags); + + static const void* + lv2_state_retrieve_callback (void* handle, + uint32_t key, + size_t* size, + uint32_t* type, + uint32_t* flags); + static char* lv2_files_abstract_path (void* host_data, const char* absolute_path); static char* lv2_files_absolute_path (void* host_data, diff --git a/libs/ardour/ardour/lv2_state.h b/libs/ardour/ardour/lv2_state.h index 5311efd049..a6c00a753c 100644 --- a/libs/ardour/ardour/lv2_state.h +++ b/libs/ardour/ardour/lv2_state.h @@ -34,8 +34,8 @@ namespace ARDOUR { -struct LV2PersistState { - LV2PersistState(URIMap& map) : uri_map(map) {} +struct LV2State { + LV2State(URIMap& map) : uri_map(map) {} struct Value { inline Value(uint32_t k, const void* v, size_t s, uint32_t t, uint32_t f) @@ -122,8 +122,8 @@ struct LV2PersistState { // Write all values to state file for (Values::const_iterator i = values.begin(); i != values.end(); ++i) { - const uint32_t key = i->first; - const LV2PersistState::Value& val = i->second; + const uint32_t key = i->first; + const LV2State::Value& val = i->second; rdff_write_triple(file, 0, key, diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/persist/persist.h b/libs/ardour/lv2/lv2plug.in/ns/ext/persist/persist.h deleted file mode 100644 index 6879a865ba..0000000000 --- a/libs/ardour/lv2/lv2plug.in/ns/ext/persist/persist.h +++ /dev/null @@ -1,228 +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 - -#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 plugin instance 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 */ diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/state/state.h b/libs/ardour/lv2/lv2plug.in/ns/ext/state/state.h new file mode 100644 index 0000000000..cb6f2fcfd3 --- /dev/null +++ b/libs/ardour/lv2/lv2plug.in/ns/ext/state/state.h @@ -0,0 +1,256 @@ +/* + 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" + +typedef void* LV2_State_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 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 handle Must be the handle 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)(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 (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)(LV2_State_Handle handle, + 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 handle 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 handle 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. + @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 (possibly much later, in a different process, on + a completely different machine, etc.) + + The @c handle 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, + LV2_State_Handle handle, + uint32_t flags, + const LV2_Feature *const * features); + + + /** + 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 handle 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 handle parameter. + @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 @c handle 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, + LV2_State_Handle handle, + uint32_t flags, + const LV2_Feature *const * features); + +} LV2_State_Interface; + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* LV2_STATE_H */ diff --git a/libs/ardour/lv2_plugin_lilv.cc b/libs/ardour/lv2_plugin_lilv.cc index e4c14383f6..0d2500b607 100644 --- a/libs/ardour/lv2_plugin_lilv.cc +++ b/libs/ardour/lv2_plugin_lilv.cc @@ -52,16 +52,17 @@ #include #include "lv2/lv2plug.in/ns/ext/files/files.h" -#include "lv2/lv2plug.in/ns/ext/persist/persist.h" +#include "lv2/lv2plug.in/ns/ext/state/state.h" #include "rdff.h" #ifdef HAVE_SUIL #include #endif -#define NS_DC "http://dublincore.org/documents/dcmi-namespace/" -#define NS_LV2 "http://lv2plug.in/ns/lv2core#" -#define NS_PSET "http://lv2plug.in/ns/dev/presets#" -#define NS_UI "http://lv2plug.in/ns/extensions/ui#" +#define NS_DC "http://dublincore.org/documents/dcmi-namespace/" +#define NS_LV2 "http://lv2plug.in/ns/lv2core#" +#define NS_STATE "http://lv2plug.in/ns/ext/state#" +#define NS_PSET "http://lv2plug.in/ns/dev/presets#" +#define NS_UI "http://lv2plug.in/ns/extensions/ui#" using namespace std; using namespace ARDOUR; @@ -148,23 +149,31 @@ LV2Plugin::init(void* c_plugin, framecnt_t rate) _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access"; _path_support_feature.URI = LV2_FILES_PATH_SUPPORT_URI; _new_file_support_feature.URI = LV2_FILES_NEW_FILE_SUPPORT_URI; - _persist_feature.URI = "http://lv2plug.in/ns/ext/persist"; - _persist_feature.data = NULL; LilvPlugin* plugin = _impl->plugin; - LilvNode* persist_uri = lilv_new_uri(_world.world, _persist_feature.URI); - _supports_persist = lilv_plugin_has_feature(plugin, persist_uri); - lilv_node_free(persist_uri); + LilvNode* state_iface_uri = lilv_new_uri(_world.world, NS_STATE "Interface"); +#ifdef lilv_plugin_has_extension_data + _has_state_interface = lilv_plugin_has_extension_data(plugin, state_iface_uri); + lilv_node_free(state_iface_uri); +#else + LilvNode* lv2_extensionData = lilv_new_uri(_world.world, NS_LV2 "extensionData"); + LilvNodes* extdatas = lilv_plugin_get_value(plugin, lv2_extensionData); + LILV_FOREACH(nodes, i, extdatas) { + if (lilv_node_equals(lilv_nodes_get(extdatas, i), state_iface_uri)) { + _has_state_interface = true; + break; + } + } +#endif - _features = (LV2_Feature**)malloc(sizeof(LV2_Feature*) * 7); + _features = (LV2_Feature**)malloc(sizeof(LV2_Feature*) * 6); _features[0] = &_instance_access_feature; _features[1] = &_data_access_feature; _features[2] = &_path_support_feature; _features[3] = &_new_file_support_feature; - _features[4] = &_persist_feature; - _features[5] = _uri_map.feature(); - _features[6] = NULL; + _features[4] = _uri_map.feature(); + _features[5] = NULL; LV2_Files_Path_Support* path_support = (LV2_Files_Path_Support*)malloc( sizeof(LV2_Files_Path_Support)); @@ -444,34 +453,34 @@ LV2Plugin::c_ui_type () } int -LV2Plugin::lv2_persist_store_callback(void* host_data, - uint32_t key, - const void* value, - size_t size, - uint32_t type, - uint32_t flags) +LV2Plugin::lv2_state_store_callback(LV2_State_Handle handle, + uint32_t key, + const void* value, + size_t size, + uint32_t type, + uint32_t flags) { DEBUG_TRACE(DEBUG::LV2, string_compose( - "persist store %1 (size: %2, type: %3)\n", + "state store %1 (size: %2, type: %3)\n", _uri_map.id_to_uri(NULL, key), size, _uri_map.id_to_uri(NULL, type))); - LV2PersistState* state = (LV2PersistState*)host_data; + LV2State* state = (LV2State*)handle; state->add_uri(key, _uri_map.id_to_uri(NULL, key)); state->add_uri(type, _uri_map.id_to_uri(NULL, type)); return state->add_value(key, value, size, type, flags); } const void* -LV2Plugin::lv2_persist_retrieve_callback(void* host_data, - uint32_t key, - size_t* size, - uint32_t* type, - uint32_t* flags) +LV2Plugin::lv2_state_retrieve_callback(LV2_State_Handle host_data, + uint32_t key, + size_t* size, + uint32_t* type, + uint32_t* flags) { - LV2PersistState* state = (LV2PersistState*)host_data; - LV2PersistState::Values::const_iterator i = state->values.find(key); + LV2State* state = (LV2State*)host_data; + LV2State::Values::const_iterator i = state->values.find(key); if (i == state->values.end()) { warning << "LV2 plugin attempted to retrieve nonexistent key: " << _uri_map.id_to_uri(NULL, key) << endmsg; @@ -479,9 +488,9 @@ LV2Plugin::lv2_persist_retrieve_callback(void* host_data, } *size = i->second.size; *type = i->second.type; - *flags = LV2_PERSIST_IS_POD | LV2_PERSIST_IS_PORTABLE; // FIXME + *flags = LV2_STATE_IS_POD | LV2_STATE_IS_PORTABLE; // FIXME DEBUG_TRACE(DEBUG::LV2, string_compose( - "persist retrieve %1 = %2 (size: %3, type: %4)\n", + "state retrieve %1 = %2 (size: %3, type: %4)\n", _uri_map.id_to_uri(NULL, key), i->second.value, *size, *type)); return i->second.value; @@ -583,7 +592,7 @@ LV2Plugin::add_state(XMLNode* root) const } } - if (_supports_persist) { + if (_has_state_interface) { // Create state directory for this plugin instance cerr << "Create statefile name from ID " << _insert_id << endl; const std::string state_filename = _insert_id.to_s() + ".rdff"; @@ -592,21 +601,23 @@ LV2Plugin::add_state(XMLNode* root) const cout << "Saving LV2 plugin state to " << state_path << endl; - // Get LV2 Persist extension data from plugin instance - LV2_Persist* persist = (LV2_Persist*)extension_data( - "http://lv2plug.in/ns/ext/persist"); - if (!persist) { + // Get LV2 State extension data from plugin instance + LV2_State_Interface* state_iface = (LV2_State_Interface*)extension_data( + "http://lv2plug.in/ns/ext/state#Interface"); + if (!state_iface) { warning << string_compose( - _("Plugin \"%1\% failed to return LV2 persist data"), + _("Plugin \"%1\% failed to return LV2 state interface"), unique_id()); return; } // Save plugin state to state object - LV2PersistState state(_uri_map); - persist->save(_impl->instance->lv2_handle, - &LV2Plugin::lv2_persist_store_callback, - &state); + LV2State state(_uri_map); + state_iface->save(_impl->instance->lv2_handle, + &LV2Plugin::lv2_state_store_callback, + &state, + LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, + NULL); // Write state object to RDFF file RDFF file = rdff_open(state_path.c_str(), true); @@ -762,21 +773,23 @@ LV2Plugin::set_state(const XMLNode& node, int version) cout << "LV2 state path " << state_path << endl; - // Get LV2 Persist extension data from plugin instance - LV2_Persist* persist = (LV2_Persist*)extension_data( - "http://lv2plug.in/ns/ext/persist"); - if (persist) { + // Get LV2 State extension data from plugin instance + LV2_State_Interface* state_iface = (LV2_State_Interface*)extension_data( + "http://lv2plug.in/ns/ext/state#Interface"); + if (state_iface) { cout << "Loading LV2 state from " << state_path << endl; - RDFF file = rdff_open(state_path.c_str(), false); - LV2PersistState state(_uri_map); + RDFF file = rdff_open(state_path.c_str(), false); + LV2State state(_uri_map); state.read(file); - persist->restore(_impl->instance->lv2_handle, - &LV2Plugin::lv2_persist_retrieve_callback, - &state); + state_iface->restore(_impl->instance->lv2_handle, + &LV2Plugin::lv2_state_retrieve_callback, + &state, + LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, + NULL); rdff_close(file); } else { warning << string_compose( - _("Plugin \"%1\% failed to return LV2 persist data"), + _("Plugin \"%1\% failed to return LV2 state interface"), unique_id()); } }