Update LV2 persist extension implementation (now named LV2 state).

git-svn-id: svn://localhost/ardour2/branches/3.0@10556 d708f5d6-7413-0410-9779-e7cbd77b26cf

5 files changed, 340 insertions, 296 deletions

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<bool> _port_is_input;
 
 	std::map<std::string,uint32_t> _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 <http://drobilla.net>
-  Copyright 2010 Leonard Ritter <paniq@paniq.org>
-
-  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 <http://lv2plug.in/ns/ext/persist>.
-*/
-
-#ifndef LV2_PERSIST_H
-#define LV2_PERSIST_H
-
-#include <stdbool.h>
-#include <stdint.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 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 <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"
+
+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 <lilv/lilv.h>
 
 #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 <suil/suil.h>
 #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());
 		}
 	}