Remove support for old and/or experimental LV2 stuff.

Ardour 3 now simply depends on the latest version of Lilv, which depends on the LV2 package (which contains all the LV2 headers).

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

14 files changed, 3 insertions, 2906 deletions

diff --git a/gtk2_ardour/lv2_plugin_ui.cc b/gtk2_ardour/lv2_plugin_ui.cc
index 5f9f024636..7699f394d0 100644
--- a/gtk2_ardour/lv2_plugin_ui.cc
+++ b/gtk2_ardour/lv2_plugin_ui.cc
@@ -26,7 +26,7 @@
 #include "gui_thread.h"
 #include "lv2_plugin_ui.h"
 
-#include "lv2_ui.h"
+#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
 
 #include <lilv/lilv.h>
 #include <suil/suil.h>
@@ -223,9 +223,7 @@ LV2PluginUI::lv2ui_instantiate(const std::string& title)
 		ui_host = suil_host_new(LV2PluginUI::write_from_ui,
 		                        LV2PluginUI::port_index,
 		                        NULL, NULL);
-#ifdef HAVE_NEW_SUIL
 		suil_host_set_touch_func(ui_host, LV2PluginUI::touch);
-#endif
 	}
 	const char* container_type = (is_external_ui)
 		? NS_UI "external"
diff --git a/gtk2_ardour/lv2_ui.h b/gtk2_ardour/lv2_ui.h
deleted file mode 100644
index 7526a5a287..0000000000
--- a/gtk2_ardour/lv2_ui.h
+++ /dev/null
@@ -1,382 +0,0 @@
-/*
-  LV2 UI Extension
-  Copyright 2009-2012 David Robillard <d@drobilla.net>
-  Copyright 2006-2011 Lars Luthman <lars.luthman@gmail.com>
-
-  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 ui.h
-   C header for the LV2 UI extension <http://lv2plug.in/ns/extensions/ui>.
-*/
-
-#ifndef LV2_UI_H
-#define LV2_UI_H
-
-#include <stdint.h>
-
-#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
-
-#define LV2_UI_URI    "http://lv2plug.in/ns/extensions/ui"
-#define LV2_UI_PREFIX LV2_UI_URI "#"
-
-#define LV2_UI__GtkUI            LV2_UI_PREFIX "GtkUI"
-#define LV2_UI__PortNotification LV2_UI_PREFIX "PortNotification"
-#define LV2_UI__Qt4UI            LV2_UI_PREFIX "Qt4UI"
-#define LV2_UI__UI               LV2_UI_PREFIX "UI"
-#define LV2_UI__X11UI            LV2_UI_PREFIX "X11UI"
-#define LV2_UI__fixedSize        LV2_UI_PREFIX "fixedSize"
-#define LV2_UI__noUserResize     LV2_UI_PREFIX "noUserResize"
-#define LV2_UI__notifyType       LV2_UI_PREFIX "notifyType"
-#define LV2_UI__parent           LV2_UI_PREFIX "parent"
-#define LV2_UI__plugin           LV2_UI_PREFIX "plugin"
-#define LV2_UI__portIndex        LV2_UI_PREFIX "portIndex"
-#define LV2_UI__portMap          LV2_UI_PREFIX "portMap"
-#define LV2_UI__portNotification LV2_UI_PREFIX "portNotification"
-#define LV2_UI__portSubscribe    LV2_UI_PREFIX "portSubscribe"
-#define LV2_UI__resize           LV2_UI_PREFIX "resize"
-#define LV2_UI__touch            LV2_UI_PREFIX "touch"
-
-/**
-   The index returned by LV2_UI_Port_Port::port_index() for unknown ports.
-*/
-#define LV2UI_INVALID_PORT_INDEX ((uint32_t)-1)
-
-#ifdef __cplusplus
-extern "C" {
-#else
-#    include <stdbool.h>
-#endif
-
-/**
-   A pointer to some widget or other type of UI handle.
-
-   The actual type is defined by the type of the UI.
-*/
-typedef void* LV2UI_Widget;
-
-/**
-   A pointer to an instance of a UI.
-
-   It is valid to compare this to NULL (0 for C++) but otherwise the host MUST
-   not attempt to interpret it.  The UI plugin may use it to reference internal
-   instance data.
-*/
-typedef void* LV2UI_Handle;
-
-/**
-   A pointer to a controller provided by the host.
-
-   It is valid to compare this to NULL (0 for C++) but otherwise the UI plugin
-   MUST NOT attempt to interpret it.  The host may use it to reference internal
-   instance data.
-*/
-typedef void* LV2UI_Controller;
-
-/**
-   A pointer to opaque data for a feature.
-*/
-typedef void* LV2UI_Feature_Handle;
-
-/**
-   The type of the host-provided function that the UI can use to
-   send data to a plugin's input ports.
-
-   The @c buffer parameter must point to a block of data, @c buffer_size bytes
-   large.  The format of this data and how the host should use it is defined by
-   the @c port_protocol.  This buffer is owned by the UI and is only valid for
-   the duration of this call.
-
-   The @c port_protocol parameter should either be 0 or the URID for a
-   ui:PortProtocol.  If it is 0, the protocol is implicitly ui:floatProtocol,
-   the port must be an lv2:ControlPort input, @c buffer must point to a single
-   float value, and @c buffer_size must be sizeof(float).
-
-   The UI SHOULD NOT use a PortProtocol not supported by the host (i.e. one not
-   passed by the host as a feature), but the host MUST gracefully ignore any
-   port_protocol it does not understand.
-*/
-typedef void (*LV2UI_Write_Function)(LV2UI_Controller controller,
-                                     uint32_t         port_index,
-                                     uint32_t         buffer_size,
-                                     uint32_t         port_protocol,
-                                     const void*      buffer);
-
-/**
-   The implementation of a UI.
-
-   A pointer to an object of this type is returned by the lv2ui_descriptor()
-   function.
-*/
-typedef struct _LV2UI_Descriptor {
-	/**
-	   The URI for this UI (not for the plugin it controls).
-	*/
-	const char* URI;
-
-	/**
-	   Create a new UI object and return a handle to it.  This function works
-	   similarly to the instantiate() member in LV2_Descriptor.
-
-	   @param descriptor The descriptor for the UI that you want to instantiate.
-
-	   @param plugin_uri The URI of the plugin that this UI will control.
-
-	   @param bundle_path The path to the bundle containing the RDF data file
-	   that references this shared object file, including the trailing '/'.
-
-	   @param write_function A function provided by the host that the UI can use
-	   to send data to the plugin's input ports.
-
-	   @param controller A handle for the plugin instance that should be passed
-	   as the first parameter of @c write_function.
-
-	   @param widget A pointer to an LV2UI_Widget.  The UI will write a widget
-	   pointer to this location (what type of widget depends on the RDF class of
-	   the UI) that will be the main UI widget.
-
-	   @param features An array of LV2_Feature pointers.  The host must pass all
-	   feature URIs that it and the UI supports and any additional data, just
-	   like in the LV2 plugin instantiate() function.  Note that UI features and
-	   plugin features are NOT necessarily the same, they just share the same
-	   data structure - this will probably not be the same array as the one the
-	   plugin host passes to a plugin.
-
-	*/
-	LV2UI_Handle (*instantiate)(const struct _LV2UI_Descriptor* descriptor,
-	                            const char*                     plugin_uri,
-	                            const char*                     bundle_path,
-	                            LV2UI_Write_Function            write_function,
-	                            LV2UI_Controller                controller,
-	                            LV2UI_Widget*                   widget,
-	                            const LV2_Feature* const*       features);
-
-
-	/**
-	   Destroy the UI object and the associated widget. The host must not try
-	   to access the widget after calling this function.
-	*/
-	void (*cleanup)(LV2UI_Handle ui);
-
-	/**
-	   Tell the UI that something interesting has happened at a plugin port.
-
-	   What is interesting and how it is written to the buffer passed to this
-	   function is defined by the @c format parameter, which has the same
-	   meaning as in LV2UI_Write_Function.  The only exception is ports of the
-	   class lv2:ControlPort, for which this function should be called when the
-	   port value changes (it does not have to be called for every single change
-	   if the host's UI thread has problems keeping up with the thread the
-	   plugin is running in), @c buffer_size should be 4, the buffer should
-	   contain a single IEEE-754 float, and @c format should be 0.
-
-	   By default, the host should only call this function for input ports of
-	   the lv2:ControlPort class.  However, this can be modified by using
-	   ui:portNotification in the UI data, or the ui:portSubscribe feature.
-
-	   The @c buffer is only valid during the time of this function call, so if
-	   the UI wants to keep it for later use it has to copy the contents to an
-	   internal buffer.
-
-	   This member may be set to NULL if the UI is not interested in any
-	   port events.
-	*/
-	void (*port_event)(LV2UI_Handle ui,
-	                   uint32_t     port_index,
-	                   uint32_t     buffer_size,
-	                   uint32_t     format,
-	                   const void*  buffer);
-
-	/**
-	   Return a data structure associated with an extension URI, for example
-	   a struct containing additional function pointers.
-
-	   Avoid returning function pointers directly since standard C/C++ has no
-	   valid way of casting a void* to a function pointer. This member may be set
-	   to NULL if the UI is not interested in supporting any extensions. This is
-	   similar to the extension_data() member in LV2_Descriptor.
-	*/
-	const void* (*extension_data)(const char* uri);
-} LV2UI_Descriptor;
-
-/**
-   UI Resize Feature (LV2_UI__resize)
-
-   This structure may be used in two ways: as a feature passed by the host via
-   LV2UI_Descriptor::instantiate(), or as extension data provided by a UI via
-   LV2UI_Descriptor::extension_data()).
-*/
-typedef struct _LV2UI_Resize {
-	/**
-	   Pointer to opaque data which must be passed to ui_resize().
-	*/
-	LV2UI_Feature_Handle handle;
-
-	/**
-	   Request or advertise a size change.
-
-	   When this struct is provided by the host, the UI may call this
-	   function to inform the host about the size of the UI.
-
-	   When this struct is provided by the UI, the host may call this
-	   function to notify the UI that it should change its size accordingly.
-
-	   @return 0 on success.
-	*/
-	int (*ui_resize)(LV2UI_Feature_Handle handle, int width, int height);
-} LV2UI_Resize;
-
-/**
-   Port Map Feature (LV2_UI__portMap).
-
-   This feature can be used by the UI to get the index for a port with the
-   given symbol.  This makes it possible to implement and distribute a UI
-   separately from the plugin (since symbol is a guaranteed stable port
-   identifier while index is not).
-*/
-typedef struct _LV2UI_Port_Map {
-	/**
-	   Pointer to opaque data which must be passed to ui_resize().
-	*/
-	LV2UI_Feature_Handle handle;
-
-	/**
-	   Get the index for the port with the given @p symbol.
-
-	   @return The index of the port, or LV2_UI_INVALID_PORT_INDEX if no such
-	   port is found.
-	*/
-	uint32_t (*port_index)(LV2UI_Feature_Handle handle, const char* symbol);
-} LV2UI_Port_Map;
-
-/**
-   Port subscription feature (LV2_UI__portSubscribe);
-*/
-typedef struct _LV2UI_Port_Subscribe {
-	/**
-	   Pointer to opaque data which must be passed to ui_resize().
-	*/
-	LV2UI_Feature_Handle handle;
-
-	/**
-	   Subscribe to updates for a port.
-
-	   This means that the host will call the UI's port_event() function when
-	   the port value changes (as defined by protocol).
-
-	   Calling this function with the same @c port_index and @c port_protocol
-	   as an already active subscription has no effect.
-
-	   @param handle The handle field of this struct.
-	   @param port_index The index of the port.
-	   @param port_protocol The URID of the ui:PortProtocol.
-	   @param features Features for this subscription.
-	   @return 0 on success.
-	*/
-	uint32_t (*subscribe)(LV2UI_Feature_Handle      handle,
-	                      uint32_t                  port_index,
-	                      uint32_t                  port_protocol,
-	                      const LV2_Feature* const* features);
-
-	/**
-	   Unsubscribe from updates for a port.
-
-	   This means that the host will cease calling calling port_event() when
-	   the port value changes.
-
-	   Calling this function with a @c port_index and @c port_protocol that
-	   does not refer to an active port subscription has no effect.
-
-	   @param handle The handle field of this struct.
-	   @param port_index The index of the port.
-	   @param port_protocol The URID of the ui:PortProtocol.
-	   @param features Features for this subscription.
-	   @return 0 on success.
-	*/
-	uint32_t (*unsubscribe)(LV2UI_Feature_Handle      handle,
-	                        uint32_t                  port_index,
-	                        uint32_t                  port_protocol,
-	                        const LV2_Feature* const* features);
-} LV2UI_Port_Subscribe;
-
-/**
-   A feature to notify the host the user has grabbed a UI control.
-*/
-typedef struct _LV2UI_Touch {
-	/**
-	   Pointer to opaque data which must be passed to ui_resize().
-	*/
-	LV2UI_Feature_Handle handle;
-
-	/**
-	   Notify the host that a control has been grabbed or released.
-
-	   @param handle The handle field of this struct.
-	   @param port_index The index of the port associated with the control.
-	   @param grabbed If true, the control has been grabbed, otherwise the
-	   control has been released.
-	*/
-	void (*touch)(LV2UI_Feature_Handle handle,
-	              uint32_t             port_index,
-	              bool                 grabbed);
-} LV2UI_Touch;
-
-/**
-   Peak data for a slice of time, the update format for ui:peakProtocol.
-*/
-typedef struct _LV2UI_Peak_Data {
-	/**
-	   The start of the measurement period.  This is just a running counter
-	   that is only meaningful in comparison to previous values and must not be
-	   interpreted as an absolute time.
-	*/
-	uint32_t period_start;
-
-	/**
-	   The size of the measurement period, in the same units as period_start.
-	*/
-	uint32_t period_size;
-
-	/**
-	   The peak value for the measurement period. This should be the maximal
-	   value for abs(sample) over all the samples in the period.
-	*/
-	float peak;
-} LV2UI_Peak_Data;
-
-/**
-   A plugin UI programmer must include a function called "lv2ui_descriptor"
-   with the following function prototype within the shared object file.  This
-   function will have C-style linkage (if you are using C++ this is taken care
-   of by the 'extern "C"' clause at the top of the file).  This function is
-   loaded from the library by the UI host and called to get a
-   LV2UI_Descriptor for the wanted plugin.
-
-   Just like lv2_descriptor(), this function takes an index parameter.  The
-   index should only be used for enumeration and not as any sort of ID number -
-   the host should just iterate from 0 and upwards until the function returns
-   NULL or a descriptor with an URI matching the one the host is looking for.
-*/
-const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index);
-
-/**
-   The type of the lv2ui_descriptor() function.
-*/
-typedef const LV2UI_Descriptor* (*LV2UI_DescriptorFunction)(uint32_t index);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LV2_UI_H */
diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/atom/atom.h b/libs/ardour/lv2/lv2plug.in/ns/ext/atom/atom.h
deleted file mode 100644
index 3c7bee812b..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/atom/atom.h
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
-  Copyright 2008-2012 David Robillard <http://drobilla.net>
-
-  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 atom.h C header for the LV2 Atom extension
-   <http://lv2plug.in/ns/ext/atom>.
-*/
-
-#ifndef LV2_ATOM_H
-#define LV2_ATOM_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-#define LV2_ATOM_URI    "http://lv2plug.in/ns/ext/atom"
-#define LV2_ATOM_PREFIX LV2_ATOM_URI "#"
-
-#define LV2_ATOM__Atom          LV2_ATOM_PREFIX "Atom"
-#define LV2_ATOM__AtomPort      LV2_ATOM_PREFIX "AtomPort"
-#define LV2_ATOM__AudioFrames   LV2_ATOM_PREFIX "AudioFrames"
-#define LV2_ATOM__Beats         LV2_ATOM_PREFIX "Beats"
-#define LV2_ATOM__Blank         LV2_ATOM_PREFIX "Blank"
-#define LV2_ATOM__Bool          LV2_ATOM_PREFIX "Bool"
-#define LV2_ATOM__Chunk         LV2_ATOM_PREFIX "Chunk"
-#define LV2_ATOM__Double        LV2_ATOM_PREFIX "Double"
-#define LV2_ATOM__Event         LV2_ATOM_PREFIX "Event"
-#define LV2_ATOM__Float         LV2_ATOM_PREFIX "Float"
-#define LV2_ATOM__Int           LV2_ATOM_PREFIX "Int"
-#define LV2_ATOM__Long          LV2_ATOM_PREFIX "Long"
-#define LV2_ATOM__Literal       LV2_ATOM_PREFIX "Literal"
-#define LV2_ATOM__Number        LV2_ATOM_PREFIX "Number"
-#define LV2_ATOM__Object        LV2_ATOM_PREFIX "Object"
-#define LV2_ATOM__Path          LV2_ATOM_PREFIX "Path"
-#define LV2_ATOM__Property      LV2_ATOM_PREFIX "Property"
-#define LV2_ATOM__Resource      LV2_ATOM_PREFIX "Resource"
-#define LV2_ATOM__Sequence      LV2_ATOM_PREFIX "Sequence"
-#define LV2_ATOM__Sound         LV2_ATOM_PREFIX "Sound"
-#define LV2_ATOM__String        LV2_ATOM_PREFIX "String"
-#define LV2_ATOM__TimeUnit      LV2_ATOM_PREFIX "TimeUnit"
-#define LV2_ATOM__Tuple         LV2_ATOM_PREFIX "Tuple"
-#define LV2_ATOM__URI           LV2_ATOM_PREFIX "URI"
-#define LV2_ATOM__URID          LV2_ATOM_PREFIX "URID"
-#define LV2_ATOM__Vector        LV2_ATOM_PREFIX "Vector"
-#define LV2_ATOM__beatTime      LV2_ATOM_PREFIX "beatTime"
-#define LV2_ATOM__bufferType    LV2_ATOM_PREFIX "bufferType"
-#define LV2_ATOM__childType     LV2_ATOM_PREFIX "childType"
-#define LV2_ATOM__eventTransfer LV2_ATOM_PREFIX "eventTransfer"
-#define LV2_ATOM__frameTime     LV2_ATOM_PREFIX "frameTime"
-#define LV2_ATOM__supports      LV2_ATOM_PREFIX "supports"
-#define LV2_ATOM__timeUnit      LV2_ATOM_PREFIX "timeUnit"
-
-#define LV2_ATOM_REFERENCE_TYPE 0
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** This expression will fail to compile if double does not fit in 64 bits. */
-typedef char lv2_atom_assert_double_fits_in_64_bits[
-	((sizeof(double) <= sizeof(uint64_t)) * 2) - 1];
-
-/**
-   Return a pointer to the contents of an Atom.  The "contents" of an atom
-   is the data past the complete type-specific header.
-   @param type The type of the atom, e.g. LV2_Atom_String.
-   @param atom A variable-sized atom.
-*/
-#define LV2_ATOM_CONTENTS(type, atom) \
-	((void*)((uint8_t*)(atom) + sizeof(type)))
-
-/**
-   Return a pointer to the body of an Atom.  The "body" of an atom is the
-   data just past the LV2_Atom head (i.e. the same offset for all types).
-*/
-#define LV2_ATOM_BODY(atom) LV2_ATOM_CONTENTS(LV2_Atom, atom)
-
-/** The header of an atom:Atom. */
-typedef struct {
-	uint32_t size;  /**< Size in bytes, not including type and size. */
-	uint32_t type;  /**< Type of this atom (mapped URI). */
-} LV2_Atom;
-
-/** An atom:Int or atom:Bool.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom atom;  /**< Atom header. */
-	int32_t  body;  /**< Integer value. */
-} LV2_Atom_Int;
-
-/** An atom:Long.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom atom;  /**< Atom header. */
-	int64_t  body;  /**< Integer value. */
-} LV2_Atom_Long;
-
-/** An atom:Float.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom atom;  /**< Atom header. */
-	float    body;  /**< Floating point value. */
-} LV2_Atom_Float;
-
-/** An atom:Double.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom atom;  /**< Atom header. */
-	double   body;  /**< Floating point value. */
-} LV2_Atom_Double;
-
-/** An atom:Bool.  May be cast to LV2_Atom. */
-typedef LV2_Atom_Int LV2_Atom_Bool;
-
-/** An atom:URID.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom atom;  /**< Atom header. */
-	uint32_t body;  /**< URID. */
-} LV2_Atom_URID;
-
-/** An atom:String.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom atom;  /**< Atom header. */
-	/* Contents (a null-terminated UTF-8 string) follow here. */
-} LV2_Atom_String;
-
-/** The body of an atom:Literal. */
-typedef struct {
-	uint32_t datatype;  /**< Datatype URID. */
-	uint32_t lang;      /**< Language URID. */
-	/* Contents (a null-terminated UTF-8 string) follow here. */
-} LV2_Atom_Literal_Body;
-
-/** An atom:Literal.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom              atom;  /**< Atom header. */
-	LV2_Atom_Literal_Body body;  /**< Body. */
-} LV2_Atom_Literal;
-
-/** An atom:Tuple.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom atom;  /**< Atom header. */
-	/* Contents (a series of complete atoms) follow here. */
-} LV2_Atom_Tuple;
-
-/** The body of an atom:Vector. */
-typedef struct {
-	uint32_t child_size;  /**< The size of each element in the vector. */
-	uint32_t child_type;  /**< The type of each element in the vector. */
-	/* Contents (a series of packed atom bodies) follow here. */
-} LV2_Atom_Vector_Body;
-
-/** An atom:Vector.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom             atom;  /**< Atom header. */
-	LV2_Atom_Vector_Body body;  /**< Body. */
-} LV2_Atom_Vector;
-
-/** The body of an atom:Property (e.g. in an atom:Object). */
-typedef struct {
-	uint32_t key;      /**< Key (predicate) (mapped URI). */
-	uint32_t context;  /**< Context URID (may be, and generally is, 0). */
-	LV2_Atom value;    /**< Value atom header. */
-	/* Value atom body follows here. */
-} LV2_Atom_Property_Body;
-
-/** An atom:Property.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom               atom;  /**< Atom header. */
-	LV2_Atom_Property_Body body;  /**< Body. */
-} LV2_Atom_Property;
-
-/** The body of an atom:Object. May be cast to LV2_Atom. */
-typedef struct {
-	uint32_t id;     /**< URID (atom:Resource) or blank ID (atom:Blank). */
-	uint32_t otype;  /**< Type URID (same as rdf:type, for fast dispatch). */
-	/* Contents (a series of property bodies) follow here. */
-} LV2_Atom_Object_Body;
-
-/** An atom:Object.  May be cast to LV2_Atom. */
-typedef struct {
-	LV2_Atom             atom;  /**< Atom header. */
-	LV2_Atom_Object_Body body;  /**< Body. */
-} LV2_Atom_Object;
-
-/** The header of an atom:Event.  Note this type is NOT an LV2_Atom. */
-typedef struct {
-	/** Time stamp.  Which type is valid is determined by context. */
-	union {
-		int64_t frames;  /**< Time in audio frames. */
-		double  beats;   /**< Time in beats. */
-	} time;
-	LV2_Atom body;  /**< Event body atom header. */
-	/* Body atom contents follow here. */
-} LV2_Atom_Event;
-
-/**
-   The body of an atom:Sequence (a sequence of events).
-
-   The unit field is either a URID that described an appropriate time stamp
-   type, or may be 0 where a default stamp type is known.  For
-   LV2_Descriptor::run(), the default stamp type is atom:AudioFrames, i.e.
-   LV2_Atom_Audio_Time.
-
-   The contents of a sequence is a series of LV2_Atom_Event, each aligned
-   to 64-bits, e.g.:
-   <pre>
-   | Event 1 (size 6)                              | Event 2
-   |       |       |       |       |       |       |       |       |
-   | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
-   |FRAMES |SUBFRMS|TYPE   |SIZE   |DATADATADATAPAD|FRAMES |SUBFRMS|...
-   </pre>
-*/
-typedef struct {
-	uint32_t unit;  /**< URID of unit of event time stamps. */
-	uint32_t pad;   /**< Currently unused. */
-	/* Contents (a series of events) follow here. */
-} LV2_Atom_Sequence_Body;
-
-/** An atom:Sequence. */
-typedef struct {
-	LV2_Atom               atom;  /**< Atom header. */
-	LV2_Atom_Sequence_Body body;  /**< Body. */
-} LV2_Atom_Sequence;
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif
-
-#endif  /* LV2_ATOM_H */
diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/atom/forge.h b/libs/ardour/lv2/lv2plug.in/ns/ext/atom/forge.h
deleted file mode 100644
index ea5977e500..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/atom/forge.h
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
-  Copyright 2008-2012 David Robillard <http://drobilla.net>
-
-  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 forge.h An API for constructing LV2 atoms.
-
-   This file provides an API for constructing Atoms which makes it relatively
-   simple to build nested atoms of arbitrary complexity without requiring
-   dynamic memory allocation.
-
-   The API is based on successively appending the appropriate pieces to build a
-   complete Atom.  The size of containers is automatically updated.  Functions
-   that begin a container return (via their frame argument) a stack frame which
-   must be popped when the container is finished.
-
-   All output is written to a user-provided buffer or sink function.  This
-   makes it popssible to create create atoms on the stack, on the heap, in LV2
-   port buffers, in a ringbuffer, or elsewhere, all using the same API.
-
-   This entire API is realtime safe if used with a buffer or a realtime safe
-   sink, except lv2_atom_forge_init() which is only realtime safe if the URI
-   map function is.
-
-   Note these functions are all static inline, do not take their address.
-
-   This header is non-normative, it is provided for convenience.
-*/
-
-#ifndef LV2_ATOM_FORGE_H
-#define LV2_ATOM_FORGE_H
-
-#include <assert.h>
-
-#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
-#include "lv2/lv2plug.in/ns/ext/atom/util.h"
-#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
-
-#ifdef __cplusplus
-extern "C" {
-#else
-#    include <stdbool.h>
-#endif
-
-/** Handle for LV2_Atom_Forge_Sink. */
-typedef void* LV2_Atom_Forge_Sink_Handle;
-
-/** A reference to a chunk of written output. */
-typedef intptr_t LV2_Atom_Forge_Ref;
-
-/** Sink function for writing output.  See lv2_atom_forge_set_sink(). */
-typedef LV2_Atom_Forge_Ref
-(*LV2_Atom_Forge_Sink)(LV2_Atom_Forge_Sink_Handle handle,
-                       const void*                buf,
-                       uint32_t                   size);
-
-/** Function for resolving a reference.  See lv2_atom_forge_set_sink(). */
-typedef LV2_Atom*
-(*LV2_Atom_Forge_Deref_Func)(LV2_Atom_Forge_Sink_Handle handle,
-                             LV2_Atom_Forge_Ref         ref);
-
-/** A stack frame used for keeping track of nested Atom containers. */
-typedef struct _LV2_Atom_Forge_Frame {
-	struct _LV2_Atom_Forge_Frame* parent;
-	LV2_Atom_Forge_Ref            ref;
-} LV2_Atom_Forge_Frame;
-
-/** A "forge" for creating atoms by appending to a buffer. */
-typedef struct {
-	uint8_t* buf;
-	uint32_t offset;
-	uint32_t size;
-
-	LV2_Atom_Forge_Sink        sink;
-	LV2_Atom_Forge_Deref_Func  deref;
-	LV2_Atom_Forge_Sink_Handle handle;
-
-	LV2_Atom_Forge_Frame* stack;
-
-	LV2_URID Blank;
-	LV2_URID Bool;
-	LV2_URID Double;
-	LV2_URID Float;
-	LV2_URID Int;
-	LV2_URID Long;
-	LV2_URID Literal;
-	LV2_URID Path;
-	LV2_URID Property;
-	LV2_URID Resource;
-	LV2_URID Sequence;
-	LV2_URID String;
-	LV2_URID Tuple;
-	LV2_URID URI;
-	LV2_URID URID;
-	LV2_URID Vector;
-} LV2_Atom_Forge;
-
-static inline void
-lv2_atom_forge_set_buffer(LV2_Atom_Forge* forge, uint8_t* buf, size_t size);
-
-/**
-   Initialise @p forge.
-
-   URIs will be mapped using @p map and stored, a reference to @p map itself is
-   not held.
-*/
-static inline void
-lv2_atom_forge_init(LV2_Atom_Forge* forge, LV2_URID_Map* map)
-{
-	lv2_atom_forge_set_buffer(forge, NULL, 0);
-	forge->Blank    = map->map(map->handle, LV2_ATOM__Blank);
-	forge->Bool     = map->map(map->handle, LV2_ATOM__Bool);
-	forge->Double   = map->map(map->handle, LV2_ATOM__Double);
-	forge->Float    = map->map(map->handle, LV2_ATOM__Float);
-	forge->Int      = map->map(map->handle, LV2_ATOM__Int);
-	forge->Long     = map->map(map->handle, LV2_ATOM__Long);
-	forge->Literal  = map->map(map->handle, LV2_ATOM__Literal);
-	forge->Path     = map->map(map->handle, LV2_ATOM__Path);
-	forge->Property = map->map(map->handle, LV2_ATOM__Property);
-	forge->Resource = map->map(map->handle, LV2_ATOM__Resource);
-	forge->Sequence = map->map(map->handle, LV2_ATOM__Sequence);
-	forge->String   = map->map(map->handle, LV2_ATOM__String);
-	forge->Tuple    = map->map(map->handle, LV2_ATOM__Tuple);
-	forge->URI      = map->map(map->handle, LV2_ATOM__URI);
-	forge->URID     = map->map(map->handle, LV2_ATOM__URID);
-	forge->Vector   = map->map(map->handle, LV2_ATOM__Vector);
-}
-
-static inline LV2_Atom*
-lv2_atom_forge_deref(LV2_Atom_Forge* forge, LV2_Atom_Forge_Ref ref)
-{
-	if (forge->buf) {
-		return (LV2_Atom*)ref;
-	} else {
-		return forge->deref(forge->handle, ref);
-	}
-}
-
-/**
-   @name Object Stack
-   @{
-*/
-
-/**
-   Push a stack frame.
-   This is done automatically by container functions (which take a stack frame
-   pointer), but may be called by the user to push the top level container when
-   writing to an existing Atom.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_push(LV2_Atom_Forge*       forge,
-                    LV2_Atom_Forge_Frame* frame,
-                    LV2_Atom_Forge_Ref    ref)
-{
-	frame->parent = forge->stack;
-	frame->ref    = ref;
-	forge->stack  = frame;
-	return ref;
-}
-
-/** Pop a stack frame.  This must be called when a container is finished. */
-static inline void
-lv2_atom_forge_pop(LV2_Atom_Forge* forge, LV2_Atom_Forge_Frame* frame)
-{
-	assert(frame == forge->stack);
-	forge->stack = frame->parent;
-}
-
-/** Return true iff the top of the stack has the given type. */
-static inline bool
-lv2_atom_forge_top_is(LV2_Atom_Forge* forge, uint32_t type)
-{
-	return forge->stack &&
-		lv2_atom_forge_deref(forge, forge->stack->ref)->type == type;
-}
-
-/**
-   @}
-   @name Output Configuration
-   @{
-*/
-
-/** Set the output buffer where @p forge will write atoms. */
-static inline void
-lv2_atom_forge_set_buffer(LV2_Atom_Forge* forge, uint8_t* buf, size_t size)
-{
-	forge->buf    = buf;
-	forge->size   = size;
-	forge->offset = 0;
-	forge->deref  = NULL;
-	forge->sink   = NULL;
-	forge->handle = NULL;
-	forge->stack  = NULL;
-}
-
-/**
-   Set the sink function where @p forge will write output.
-
-   The return value of forge functions is an LV2_Atom_Forge_Ref which is an
-   integer type safe to use as a pointer but is otherwise opaque.  The sink
-   function must return a ref that can be dereferenced to access as least
-   sizeof(LV2_Atom) bytes of the written data, so sizes can be updated.  For
-   ringbuffers, this should be possible as long as the size of the buffer is a
-   multiple of sizeof(LV2_Atom), since atoms are always aligned.
-
-   Note that 0 is an invalid reference, so if you are using a buffer offset be
-   sure to offset it such that 0 is never a valid reference.  You will get
-   confusing errors otherwise.
-*/
-static inline void
-lv2_atom_forge_set_sink(LV2_Atom_Forge*            forge,
-                        LV2_Atom_Forge_Sink        sink,
-                        LV2_Atom_Forge_Deref_Func  deref,
-                        LV2_Atom_Forge_Sink_Handle handle)
-{
-	forge->buf    = NULL;
-	forge->size   = forge->offset = 0;
-	forge->deref  = deref;
-	forge->sink   = sink;
-	forge->handle = handle;
-	forge->stack  = NULL;
-}
-
-/**
-   @}
-   @name Low Level Output
-   @{
-*/
-
-/**
-   Write raw output.  This is used internally, but is also useful for writing
-   atom types not explicitly supported by the forge API.  Note the caller is
-   responsible for ensuring the output is approriately padded.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_raw(LV2_Atom_Forge* forge, const void* data, uint32_t size)
-{
-	LV2_Atom_Forge_Ref out = 0;
-	if (forge->sink) {
-		out = forge->sink(forge->handle, data, size);
-	} else {
-		out = (LV2_Atom_Forge_Ref)forge->buf + forge->offset;
-		uint8_t* mem = forge->buf + forge->offset;
-		if (forge->offset + size > forge->size) {
-			return 0;
-		}
-		forge->offset += size;
-		memcpy(mem, data, size);
-	}
-	for (LV2_Atom_Forge_Frame* f = forge->stack; f; f = f->parent) {
-		lv2_atom_forge_deref(forge, f->ref)->size += size;
-	}
-	return out;
-}
-
-/** Pad output accordingly so next write is 64-bit aligned. */
-static inline void
-lv2_atom_forge_pad(LV2_Atom_Forge* forge, uint32_t written)
-{
-	const uint64_t pad      = 0;
-	const uint32_t pad_size = lv2_atom_pad_size(written) - written;
-	lv2_atom_forge_raw(forge, &pad, pad_size);
-}
-
-/** Write raw output, padding to 64-bits as necessary. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_write(LV2_Atom_Forge* forge, const void* data, uint32_t size)
-{
-	LV2_Atom_Forge_Ref out = lv2_atom_forge_raw(forge, data, size);
-	if (out) {
-		lv2_atom_forge_pad(forge, size);
-	}
-	return out;
-}
-
-/** Write a null-terminated string body. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_string_body(LV2_Atom_Forge* forge,
-                           const char*     str,
-                           uint32_t        len)
-{
-	LV2_Atom_Forge_Ref out = lv2_atom_forge_raw(forge, str, len);
-	if (out && (out = lv2_atom_forge_raw(forge, "", 1))) {
-		lv2_atom_forge_pad(forge, len + 1);
-	}
-	return out;
-}
-
-/**
-   @}
-   @name Atom Output
-   @{
-*/
-
-/** Write an atom:Atom header. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_atom(LV2_Atom_Forge* forge, uint32_t size, uint32_t type)
-{
-	const LV2_Atom a = { size, type };
-	return lv2_atom_forge_raw(forge, &a, sizeof(a));
-}
-
-/** Write a primitive (fixed-size) atom. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_primitive(LV2_Atom_Forge* forge, const LV2_Atom* a)
-{
-	if (lv2_atom_forge_top_is(forge, forge->Vector)) {
-		return lv2_atom_forge_raw(forge, LV2_ATOM_BODY(a), a->size);
-	} else {
-		return lv2_atom_forge_write(forge, a, sizeof(LV2_Atom) + a->size);
-	}
-}
-
-/** Write an atom:Int. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_int(LV2_Atom_Forge* forge, int32_t val)
-{
-	const LV2_Atom_Int a = { { sizeof(val), forge->Int }, val };
-	return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:Long. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_long(LV2_Atom_Forge* forge, int64_t val)
-{
-	const LV2_Atom_Long a = { { sizeof(val), forge->Long }, val };
-	return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:Float. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_float(LV2_Atom_Forge* forge, float val)
-{
-	const LV2_Atom_Float a = { { sizeof(val), forge->Float }, val };
-	return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:Double. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_double(LV2_Atom_Forge* forge, double val)
-{
-	const LV2_Atom_Double a = { { sizeof(val), forge->Double }, val };
-	return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:Bool. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_bool(LV2_Atom_Forge* forge, bool val)
-{
-	const LV2_Atom_Bool a = { { sizeof(int32_t), forge->Bool }, val ? 1 : 0 };
-	return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom:URID. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_urid(LV2_Atom_Forge* forge, LV2_URID id)
-{
-	const LV2_Atom_URID a = { { sizeof(id), forge->URID }, id };
-	return lv2_atom_forge_primitive(forge, &a.atom);
-}
-
-/** Write an atom compatible with atom:String.  Used internally. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_typed_string(LV2_Atom_Forge* forge,
-                            uint32_t        type,
-                            const char*     str,
-                            uint32_t        len)
-{
-	const LV2_Atom_String a   = { { len + 1, type } };
-	LV2_Atom_Forge_Ref    out = lv2_atom_forge_raw(forge, &a, sizeof(a));
-	if (out) {
-		if (!lv2_atom_forge_string_body(forge, str, len)) {
-			LV2_Atom* atom = lv2_atom_forge_deref(forge, out);
-			atom->size = atom->type = 0;
-			out = 0;
-		}
-	}
-	return out;
-}
-
-/** Write an atom:String.  Note that @p str need not be NULL terminated. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_string(LV2_Atom_Forge* forge, const char* str, uint32_t len)
-{
-	return lv2_atom_forge_typed_string(forge, forge->String, str, len);
-}
-
-/**
-   Write an atom:URI.  Note that @p uri need not be NULL terminated.
-   This does not map the URI, but writes the complete URI string.  To write
-   a mapped URI, use lv2_atom_forge_urid().
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_uri(LV2_Atom_Forge* forge, const char* uri, uint32_t len)
-{
-	return lv2_atom_forge_typed_string(forge, forge->URI, uri, len);
-}
-
-/** Write an atom:Path.  Note that @p path need not be NULL terminated. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_path(LV2_Atom_Forge* forge, const char* path, uint32_t len)
-{
-	return lv2_atom_forge_typed_string(forge, forge->Path, path, len);
-}
-
-/** Write an atom:Literal. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_literal(LV2_Atom_Forge* forge,
-                       const char*     str,
-                       uint32_t        len,
-                       uint32_t        datatype,
-                       uint32_t        lang)
-{
-	const LV2_Atom_Literal a = {
-		{ sizeof(LV2_Atom_Literal) - sizeof(LV2_Atom) + len + 1,
-		  forge->Literal },
-		{ datatype,
-		  lang }
-	};
-	LV2_Atom_Forge_Ref out = lv2_atom_forge_raw(forge, &a, sizeof(a));
-	if (out) {
-		if (!lv2_atom_forge_string_body(forge, str, len)) {
-			LV2_Atom* atom = lv2_atom_forge_deref(forge, out);
-			atom->size = atom->type = 0;
-			out = 0;
-		}
-	}
-	return out;
-}
-
-/** Start an atom:Vector. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_vector_head(LV2_Atom_Forge*       forge,
-                           LV2_Atom_Forge_Frame* frame,
-                           uint32_t              child_size,
-                           uint32_t              child_type)
-{
-	const LV2_Atom_Vector a = {
-		{ sizeof(LV2_Atom_Vector_Body), forge->Vector },
-		{ child_size, child_type }
-	};
-	return lv2_atom_forge_push(
-		forge, frame, lv2_atom_forge_write(forge, &a, sizeof(a)));
-}
-
-/** Write a complete atom:Vector. */
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_vector(LV2_Atom_Forge* forge,
-                      uint32_t        child_size,
-                      uint32_t        child_type,
-                      uint32_t        n_elems,
-                      const void*     elems)
-{
-	const LV2_Atom_Vector a = {
-		{ sizeof(LV2_Atom_Vector_Body) + n_elems * child_size, forge->Vector },
-		{ child_size, child_type }
-	};
-	LV2_Atom_Forge_Ref out = lv2_atom_forge_write(forge, &a, sizeof(a));
-	if (out) {
-		lv2_atom_forge_write(forge, elems, child_size * n_elems);
-	}
-	return out;
-}
-
-/**
-   Write the header of an atom:Tuple.
-
-   The passed frame will be initialised to represent this tuple.  To complete
-   the tuple, write a sequence of atoms, then pop the frame with
-   lv2_atom_forge_pop().
-
-   For example:
-   @code
-   // Write tuple (1, 2.0)
-   LV2_Atom_Forge_Frame frame;
-   LV2_Atom* tup = (LV2_Atom*)lv2_atom_forge_tuple(forge, &frame);
-   lv2_atom_forge_int32(forge, 1);
-   lv2_atom_forge_float(forge, 2.0);
-   lv2_atom_forge_pop(forge, &frame);
-   @endcode
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_tuple(LV2_Atom_Forge* forge, LV2_Atom_Forge_Frame* frame)
-{
-	const LV2_Atom_Tuple a = { { 0, forge->Tuple } };
-	return lv2_atom_forge_push(
-		forge, frame, lv2_atom_forge_write(forge, &a, sizeof(a)));
-}
-
-/**
-   Write the header of an atom:Resource.
-
-   The passed frame will be initialised to represent this object.  To complete
-   the object, write a sequence of properties, then pop the frame with
-   lv2_atom_forge_pop().
-
-   For example:
-   @code
-   LV2_URID eg_Cat  = map("http://example.org/Cat");
-   LV2_URID eg_name = map("http://example.org/name");
-
-   // Write object header
-   LV2_Atom_Forge_Frame frame;
-   lv2_atom_forge_resource(forge, &frame, 1, eg_Cat);
-
-   // Write property: eg:name = "Hobbes"
-   lv2_atom_forge_property_head(forge, eg_name, 0);
-   lv2_atom_forge_string(forge, "Hobbes", strlen("Hobbes"));
-
-   // Finish object
-   lv2_atom_forge_pop(forge, &frame);
-   @endcode
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_resource(LV2_Atom_Forge*       forge,
-                        LV2_Atom_Forge_Frame* frame,
-                        LV2_URID              id,
-                        LV2_URID              otype)
-{
-	const LV2_Atom_Object a = {
-		{ sizeof(LV2_Atom_Object) - sizeof(LV2_Atom), forge->Resource },
-		{ id, otype }
-	};
-	LV2_Atom_Forge_Ref out = lv2_atom_forge_write(forge, &a, sizeof(a));
-	return lv2_atom_forge_push(forge, frame, out);
-}
-
-/**
-   The same as lv2_atom_forge_resource(), but for object:Blank.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_blank(LV2_Atom_Forge*       forge,
-                     LV2_Atom_Forge_Frame* frame,
-                     uint32_t              id,
-                     LV2_URID              otype)
-{
-	const LV2_Atom_Object a = {
-		{ sizeof(LV2_Atom_Object) - sizeof(LV2_Atom), forge->Blank },
-		{ id, otype }
-	};
-	LV2_Atom_Forge_Ref out = lv2_atom_forge_write(forge, &a, sizeof(a));
-	return lv2_atom_forge_push(forge, frame, out);
-}
-
-/**
-   Write the header for a property body (likely in an Object).
-   See lv2_atom_forge_object() documentation for an example.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_property_head(LV2_Atom_Forge* forge,
-                             LV2_URID        key,
-                             LV2_URID        context)
-{
-	const LV2_Atom_Property_Body a = { key, context, { 0, 0 } };
-	return lv2_atom_forge_write(forge, &a, 2 * sizeof(uint32_t));
-}
-
-/**
-   Write the header for a Sequence.
-   The size of the returned sequence will be 0, so passing it as the parent
-   parameter to other forge methods will do the right thing.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_sequence_head(LV2_Atom_Forge*       forge,
-                             LV2_Atom_Forge_Frame* frame,
-                             uint32_t              unit)
-{
-	const LV2_Atom_Sequence a = {
-		{ sizeof(LV2_Atom_Sequence) - sizeof(LV2_Atom), forge->Sequence },
-		{ unit, 0 }
-	};
-	LV2_Atom_Forge_Ref out = lv2_atom_forge_write(forge, &a, sizeof(a));
-	return lv2_atom_forge_push(forge, frame, out);
-}
-
-/**
-   Write the time stamp header of an Event (in a Sequence) in audio frames.
-   After this, call the appropriate forge method(s) to write the body, passing
-   the same @p parent parameter.  Note the returned LV2_Event is NOT an Atom.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_frame_time(LV2_Atom_Forge* forge, int64_t frames)
-{
-	return lv2_atom_forge_write(forge, &frames, sizeof(frames));
-}
-
-/**
-   Write the time stamp header of an Event (in a Sequence) in beats.
-   After this, call the appropriate forge method(s) to write the body, passing
-   the same @p parent parameter.  Note the returned LV2_Event is NOT an Atom.
-*/
-static inline LV2_Atom_Forge_Ref
-lv2_atom_forge_beat_time(LV2_Atom_Forge* forge, double beats)
-{
-	return lv2_atom_forge_write(forge, &beats, sizeof(beats));
-}
-
-/**
-   @}
-*/
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif
-
-#endif  /* LV2_ATOM_FORGE_H */
diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/atom/util.h b/libs/ardour/lv2/lv2plug.in/ns/ext/atom/util.h
deleted file mode 100644
index 6b46a676f8..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/atom/util.h
+++ /dev/null
@@ -1,424 +0,0 @@
-/*
-  Copyright 2008-2012 David Robillard <http://drobilla.net>
-
-  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 util.h Helper functions for the LV2 Atom extension.
-
-   Note these functions are all static inline, do not take their address.
-
-   This header is non-normative, it is provided for convenience.
-*/
-
-#ifndef LV2_ATOM_UTIL_H
-#define LV2_ATOM_UTIL_H
-
-#include <stdarg.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
-
-#ifdef __cplusplus
-extern "C" {
-#else
-#    include <stdbool.h>
-#endif
-
-/** Pad a size to 64 bits. */
-static inline uint32_t
-lv2_atom_pad_size(uint32_t size)
-{
-	return (size + 7) & (~7);
-}
-
-/** Return the total size of @p atom, including the header. */
-static inline uint32_t
-lv2_atom_total_size(const LV2_Atom* atom)
-{
-	return sizeof(LV2_Atom) + atom->size;
-}
-
-/** Return true iff @p atom is null. */
-static inline bool
-lv2_atom_is_null(const LV2_Atom* atom)
-{
-	return !atom || (atom->type == 0 && atom->size == 0);
-}
-
-/** Return true iff @p a is equal to @p b. */
-static inline bool
-lv2_atom_equals(const LV2_Atom* a, const LV2_Atom* b)
-{
-	return (a == b) || ((a->type == b->type) &&
-	                    (a->size == b->size) &&
-	                    !memcmp(a + 1, b + 1, a->size));
-}
-
-/**
-   @name Sequence Iterator
-   @{
-*/
-
-/** An iterator over the elements of an LV2_Atom_Sequence. */
-typedef LV2_Atom_Event* LV2_Atom_Sequence_Iter;
-
-/** Get an iterator pointing to the first element in a Sequence body. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_body_begin(const LV2_Atom_Sequence_Body* body)
-{
-	return (LV2_Atom_Sequence_Iter)(body + 1);
-}
-
-/** Get an iterator pointing to the first element in a Sequence. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_begin(const LV2_Atom_Sequence* seq)
-{
-	return (LV2_Atom_Sequence_Iter)(seq + 1);
-}
-
-/** Return true iff @p i has reached the end of @p body. */
-static inline bool
-lv2_sequence_body_is_end(const LV2_Atom_Sequence_Body* body,
-                         uint32_t                      size,
-                         LV2_Atom_Sequence_Iter        i)
-{
-	return (uint8_t*)i >= ((uint8_t*)body + size);
-}
-
-/** Return true iff @p i has reached the end of @p seq. */
-static inline bool
-lv2_sequence_is_end(const LV2_Atom_Sequence* seq, LV2_Atom_Sequence_Iter i)
-{
-	return (uint8_t*)i >= ((uint8_t*)seq + sizeof(LV2_Atom) + seq->atom.size);
-}
-
-/** Return an iterator to the element following @p i. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_iter_next(const LV2_Atom_Sequence_Iter i)
-{
-	return (LV2_Atom_Sequence_Iter)((uint8_t*)i
-	                                + sizeof(LV2_Atom_Event)
-	                                + lv2_atom_pad_size(i->body.size));
-}
-
-/** Return the element pointed to by @p i. */
-static inline LV2_Atom_Event*
-lv2_sequence_iter_get(LV2_Atom_Sequence_Iter i)
-{
-	return (LV2_Atom_Event*)i;
-}
-
-/**
-   A macro for iterating over all events in a Sequence.
-   @param sequence The sequence to iterate over
-   @param iter The name of the iterator
-
-   This macro is used similarly to a for loop (which it expands to), e.g.:
-   @code
-   LV2_SEQUENCE_FOREACH(sequence, i) {
-       LV2_Atom_Event* ev = lv2_sequence_iter_get(i);
-       // Do something with ev here...
-   }
-   @endcode
-*/
-#define LV2_SEQUENCE_FOREACH(sequence, iter) \
-	for (LV2_Atom_Sequence_Iter (iter) = lv2_sequence_begin(sequence); \
-	     !lv2_sequence_is_end(sequence, (iter)); \
-	     (iter) = lv2_sequence_iter_next(iter))
-
-/** A version of LV2_SEQUENCE_FOREACH for when only the body is available. */
-#define LV2_SEQUENCE_BODY_FOREACH(body, size, iter) \
-	for (LV2_Atom_Sequence_Iter (iter) = lv2_sequence_body_begin(body); \
-	     !lv2_sequence_body_is_end(body, size, (iter)); \
-	     (iter) = lv2_sequence_iter_next(iter))
-
-/**
-   @}
-   @name Tuple Iterator
-   @{
-*/
-
-/** An iterator over the elements of an LV2_Atom_Tuple. */
-typedef LV2_Atom* LV2_Atom_Tuple_Iter;
-
-/** Get an iterator pointing to the first element in @p tup. */
-static inline LV2_Atom_Tuple_Iter
-lv2_tuple_begin(const LV2_Atom_Tuple* tup)
-{
-	return (LV2_Atom_Tuple_Iter)(LV2_ATOM_BODY(tup));
-}
-
-/** Return true iff @p i has reached the end of @p body. */
-static inline bool
-lv2_atom_tuple_body_is_end(const void*         body,
-                           uint32_t            size,
-                           LV2_Atom_Tuple_Iter i)
-{
-	return (uint8_t*)i >= ((uint8_t*)body + size);
-}
-
-/** Return true iff @p i has reached the end of @p tup. */
-static inline bool
-lv2_tuple_is_end(const LV2_Atom_Tuple* tup, LV2_Atom_Tuple_Iter i)
-{
-	return lv2_atom_tuple_body_is_end(LV2_ATOM_BODY(tup), tup->atom.size, i);
-}
-
-/** Return an iterator to the element following @p i. */
-static inline LV2_Atom_Tuple_Iter
-lv2_tuple_iter_next(const LV2_Atom_Tuple_Iter i)
-{
-	return (LV2_Atom_Tuple_Iter)(
-		(uint8_t*)i + sizeof(LV2_Atom) + lv2_atom_pad_size(i->size));
-}
-
-/** Return the element pointed to by @p i. */
-static inline LV2_Atom*
-lv2_tuple_iter_get(LV2_Atom_Tuple_Iter i)
-{
-	return (LV2_Atom*)i;
-}
-
-/**
-   A macro for iterating over all properties of a Tuple.
-   @param tuple The tuple to iterate over
-   @param iter The name of the iterator
-
-   This macro is used similarly to a for loop (which it expands to), e.g.:
-   @code
-   LV2_TUPLE_FOREACH(tuple, i) {
-       LV2_Atom* elem = lv2_tuple_iter_get(i);
-       // Do something with elem here...
-   }
-   @endcode
-*/
-#define LV2_TUPLE_FOREACH(tuple, iter) \
-	for (LV2_Atom_Tuple_Iter (iter) = lv2_tuple_begin(tuple); \
-	     !lv2_tuple_is_end(tuple, (iter)); \
-	     (iter) = lv2_tuple_iter_next(iter))
-
-/** A version of LV2_TUPLE_FOREACH for when only the body is available. */
-#define LV2_TUPLE_BODY_FOREACH(body, size, iter) \
-	for (LV2_Atom_Tuple_Iter (iter) = (LV2_Atom_Tuple_Iter)body; \
-	     !lv2_atom_tuple_body_is_end(body, size, (iter)); \
-	     (iter) = lv2_tuple_iter_next(iter))
-
-/**
-   @}
-   @name Object Iterator
-   @{
-*/
-
-/** An iterator over the properties of an LV2_Atom_Object. */
-typedef LV2_Atom_Property_Body* LV2_Atom_Object_Iter;
-
-static inline LV2_Atom_Object_Iter
-lv2_object_body_begin(const LV2_Atom_Object_Body* body)
-{
-	return (LV2_Atom_Object_Iter)(body + 1);
-}
-
-/** Get an iterator pointing to the first property in @p obj. */
-static inline LV2_Atom_Object_Iter
-lv2_object_begin(const LV2_Atom_Object* obj)
-{
-	return (LV2_Atom_Object_Iter)(obj + 1);
-}
-
-static inline bool
-lv2_atom_object_body_is_end(const LV2_Atom_Object_Body* body,
-                            uint32_t                    size,
-                            LV2_Atom_Object_Iter        i)
-{
-	return (uint8_t*)i >= ((uint8_t*)body + size);
-}
-
-/** Return true iff @p i has reached the end of @p obj. */
-static inline bool
-lv2_object_is_end(const LV2_Atom_Object* obj, LV2_Atom_Object_Iter i)
-{
-	return (uint8_t*)i >= ((uint8_t*)obj + sizeof(LV2_Atom) + obj->atom.size);
-}
-
-/** Return an iterator to the property following @p i. */
-static inline LV2_Atom_Object_Iter
-lv2_object_iter_next(const LV2_Atom_Object_Iter i)
-{
-	const LV2_Atom* const value = (LV2_Atom*)((uint8_t*)i + sizeof(i));
-	return (LV2_Atom_Object_Iter)((uint8_t*)i
-	                              + sizeof(LV2_Atom_Property_Body)
-	                              + lv2_atom_pad_size(value->size));
-}
-
-/** Return the property pointed to by @p i. */
-static inline LV2_Atom_Property_Body*
-lv2_object_iter_get(LV2_Atom_Object_Iter i)
-{
-	return (LV2_Atom_Property_Body*)i;
-}
-
-/**
-   A macro for iterating over all properties of an Object.
-   @param object The object to iterate over
-   @param iter The name of the iterator
-
-   This macro is used similarly to a for loop (which it expands to), e.g.:
-   @code
-   LV2_OBJECT_FOREACH(object, i) {
-       LV2_Atom_Property_Body* prop = lv2_object_iter_get(i);
-       // Do something with prop here...
-   }
-   @endcode
-*/
-#define LV2_OBJECT_FOREACH(object, iter) \
-	for (LV2_Atom_Object_Iter (iter) = lv2_object_begin(object); \
-	     !lv2_object_is_end(object, (iter)); \
-	     (iter) = lv2_object_iter_next(iter))
-
-/** A version of LV2_OBJECT_FOREACH for when only the body is available. */
-#define LV2_OBJECT_BODY_FOREACH(body, size, iter) \
-	for (LV2_Atom_Object_Iter (iter) = lv2_object_body_begin(body); \
-	     !lv2_atom_object_body_is_end(body, size, (iter)); \
-	     (iter) = lv2_object_iter_next(iter))
-
-/**
-   @}
-   @name Object Query
-   @{
-*/
-
-/** A single entry in an Object query. */
-typedef struct {
-	uint32_t         key;    /**< Key to query (input set by user) */
-	const LV2_Atom** value;  /**< Found value (output set by query function) */
-} LV2_Atom_Object_Query;
-
-static const LV2_Atom_Object_Query LV2_OBJECT_QUERY_END = { 0, NULL };
-
-/**
-   Get an object's values for various keys.
-
-   The value pointer of each item in @p query will be set to the location of
-   the corresponding value in @p object.  Every value pointer in @p query MUST
-   be initialised to NULL.  This function reads @p object in a single linear
-   sweep.  By allocating @p query on the stack, objects can be "queried"
-   quickly without allocating any memory.  This function is realtime safe.
-
-   This function can only do "flat" queries, it is not smart enough to match
-   variables in nested objects.
-
-   For example:
-   @code
-   const LV2_Atom* name = NULL;
-   const LV2_Atom* age  = NULL;
-   LV2_Atom_Object_Query q[] = {
-       { urids.eg_name, &name },
-       { urids.eg_age,  &age },
-       LV2_OBJECT_QUERY_END
-   };
-   lv2_object_query(obj, q);
-   // name and age are now set to the appropriate values in obj, or NULL.
-   @endcode
-*/
-static inline int
-lv2_object_query(const LV2_Atom_Object* object, LV2_Atom_Object_Query* query)
-{
-	int matches   = 0;
-	int n_queries = 0;
-
-	/* Count number of query keys so we can short-circuit when done */
-	for (LV2_Atom_Object_Query* q = query; q->key; ++q) {
-		++n_queries;
-	}
-
-	LV2_OBJECT_FOREACH(object, o) {
-		const LV2_Atom_Property_Body* prop = lv2_object_iter_get(o);
-		for (LV2_Atom_Object_Query* q = query; q->key; ++q) {
-			if (q->key == prop->key && !*q->value) {
-				*q->value = &prop->value;
-				if (++matches == n_queries) {
-					return matches;
-				}
-				break;
-			}
-		}
-	}
-	return matches;
-}
-
-/**
-   Variable argument version of lv2_object_get().
-
-   This is nicer-looking in code, but a bit more error-prone since it is not
-   type safe and the argument list must be terminated.
-
-   The arguments should be a series of uint32_t key and const LV2_Atom** value
-   pairs, terminated by a zero key.  The value pointers MUST be initialized to
-   NULL.  For example:
-
-   @code
-   const LV2_Atom* name = NULL;
-   const LV2_Atom* age  = NULL;
-   lv2_object_get(obj,
-                  uris.name_key, &name,
-                  uris.age_key,  &age,
-                  0);
-   @endcode
-*/
-static inline int
-lv2_object_get(const LV2_Atom_Object* object, ...)
-{
-	int matches   = 0;
-	int n_queries = 0;
-
-	/* Count number of keys so we can short-circuit when done */
-	va_list args;
-	va_start(args, object);
-	for (n_queries = 0; va_arg(args, uint32_t); ++n_queries) {
-		if (!va_arg(args, const LV2_Atom**)) {
-			return -1;
-		}
-	}
-	va_end(args);
-
-	LV2_OBJECT_FOREACH(object, o) {
-		const LV2_Atom_Property_Body* prop = lv2_object_iter_get(o);
-		va_start(args, object);
-		for (int i = 0; i < n_queries; ++i) {
-			uint32_t         qkey = va_arg(args, uint32_t);
-			const LV2_Atom** qval = va_arg(args, const LV2_Atom**);
-			if (qkey == prop->key && !*qval) {
-				*qval = &prop->value;
-				if (++matches == n_queries) {
-					return matches;
-				}
-				break;
-			}
-		}
-		va_end(args);
-	}
-	return matches;
-}
-
-/**
-   @}
-*/
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif
-
-#endif /* LV2_ATOM_UTIL_H */
diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/event/event-helpers.h b/libs/ardour/lv2/lv2plug.in/ns/ext/event/event-helpers.h
deleted file mode 100644
index 79f8a35fe8..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/event/event-helpers.h
+++ /dev/null
@@ -1,243 +0,0 @@
-/* lv2_event_helpers.h - Helper functions for the LV2 events extension.
- *
- * Copyright (C) 2008 David Robillard <d@drobilla.net>
- *
- * 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_EVENT_HELPERS_H
-#define LV2_EVENT_HELPERS_H
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-#include "lv2/lv2plug.in/ns/ext/event/event.h"
-
-/** @file
- * This header defines some helper functions for the the LV2 events extension
- * with URI <http://lv2plug.in/ns/ext/event> ('lv2ev').
- *
- * These functions are provided for convenience only, use of them is not
- * required for supporting lv2ev (i.e. the events extension is defined by the
- * raw buffer format described in lv2_event.h and NOT by this API).
- *
- * Note that these functions are all static inline which basically means:
- * do not take the address of these functions. */
-
-
-/** Pad a size to 64 bits (for event sizes) */
-static inline uint16_t
-lv2_event_pad_size(uint16_t size)
-{
-	return (size + 7) & (~7);
-}
-
-
-/** Initialize (empty, reset..) an existing event buffer.
- * The contents of buf are ignored entirely and overwritten, except capacity
- * which is unmodified. */
-static inline void
-lv2_event_buffer_reset(LV2_Event_Buffer* buf, uint16_t stamp_type, uint8_t *data)
-{
-	buf->data = data;
-	buf->header_size = sizeof(LV2_Event_Buffer);
-	buf->stamp_type = stamp_type;
-	buf->event_count = 0;
-	buf->size = 0;
-}
-
-
-/** Allocate a new, empty event buffer. */
-static inline LV2_Event_Buffer*
-lv2_event_buffer_new(uint32_t capacity, uint16_t stamp_type)
-{
-	LV2_Event_Buffer* buf = (LV2_Event_Buffer*)malloc(sizeof(LV2_Event_Buffer) + capacity);
-	if (buf != NULL) {
-		buf->capacity = capacity;
-		lv2_event_buffer_reset(buf, stamp_type, (uint8_t *)(buf + 1));
-		return buf;
-	} else {
-		return NULL;
-	}
-}
-
-
-/** An iterator over an LV2_Event_Buffer.
- *
- * Multiple simultaneous read iterators over a single buffer is fine,
- * but changing the buffer invalidates all iterators (e.g. RW Lock). */
-typedef struct {
-	LV2_Event_Buffer* buf;
-	uint32_t          offset;
-} LV2_Event_Iterator;
-
-
-/** Reset an iterator to point to the start of @a buf.
- * @return True if @a iter is valid, otherwise false (buffer is empty) */
-static inline bool
-lv2_event_begin(LV2_Event_Iterator* iter,
-                LV2_Event_Buffer*   buf)
-{
-	iter->buf = buf;
-	iter->offset = 0;
-	return (buf->size > 0);
-}
-
-
-/** Check if @a iter is valid..
- * @return True if @a iter is valid, otherwise false (past end of buffer) */
-static inline bool
-lv2_event_is_valid(LV2_Event_Iterator* iter)
-{
-	return (iter->offset < iter->buf->size);
-}
-
-
-/** Advance @a iter forward one event.
- * @a iter must be valid.
- * @return True if @a iter is valid, otherwise false (reached end of buffer) */
-static inline bool
-lv2_event_increment(LV2_Event_Iterator* iter)
-{
-	assert(lv2_event_is_valid(iter));
-
-	LV2_Event* const ev = (LV2_Event*)(
-			(uint8_t*)iter->buf->data + iter->offset);
-
-	iter->offset += lv2_event_pad_size(sizeof(LV2_Event) + ev->size);	
-	
-	return true;
-}
-
-
-/** Dereference an event iterator (get the event currently pointed at).
- * @a iter must be valid.
- * @a data if non-NULL, will be set to point to the contents of the event
- *         returned.
- * @return A Pointer to the event @a iter is currently pointing at, or NULL
- *         if the end of the buffer is reached (in which case @a data is
- *         also set to NULL). */
-static inline LV2_Event*
-lv2_event_get(LV2_Event_Iterator* iter,
-              uint8_t**           data)
-{
-	assert(lv2_event_is_valid(iter));
-
-	LV2_Event* const ev = (LV2_Event*)(
-			(uint8_t*)iter->buf->data + iter->offset);
-
-	if (data)
-		*data = (uint8_t*)ev + sizeof(LV2_Event);
-
-	return ev;
-}
-
-
-/** Write an event at @a iter.
- * The event (if any) pointed to by @iter will be overwritten, and @a iter
- * incremented to point to the following event (i.e. several calls to this
- * function can be done in sequence without twiddling iter in-between).
- * @return True if event was written, otherwise false (buffer is full). */
-static inline bool
-lv2_event_write(LV2_Event_Iterator* iter,
-                uint32_t            frames,
-                uint32_t            subframes,
-                uint16_t            type,
-                uint16_t            size,
-                const uint8_t*      data)
-{
-	if (iter->buf->capacity - iter->buf->size < sizeof(LV2_Event) + size)
-		return false;
-
-	LV2_Event* const ev = (LV2_Event*)(
-			(uint8_t*)iter->buf->data + iter->offset);
-	
-	ev->frames = frames;
-	ev->subframes = subframes;
-	ev->type = type;
-	ev->size = size;
-	memcpy((uint8_t*)ev + sizeof(LV2_Event), data, size);
-	++iter->buf->event_count;
-	
-	size = lv2_event_pad_size(sizeof(LV2_Event) + size);
-	iter->buf->size += size;
-	iter->offset    += size;
-	
-	return true;
-}
-
-
-/** Reserve space for an event in the buffer and return a pointer to
-    the memory where the caller can write the event data, or NULL if there
-    is not enough room in the buffer. */
-static inline uint8_t*
-lv2_event_reserve(LV2_Event_Iterator* iter,
-		  uint32_t frames,
-		  uint32_t subframes,
-		  uint16_t type,
-		  uint16_t size) 
-{
-	size = lv2_event_pad_size(size);
-	if (iter->buf->capacity - iter->buf->size < sizeof(LV2_Event) + size)
-		return NULL;
-
-	LV2_Event* const ev = (LV2_Event*)((uint8_t*)iter->buf->data + 
-					   iter->offset);
-	
-	ev->frames = frames;
-	ev->subframes = subframes;
-	ev->type = type;
-	ev->size = size;
-	++iter->buf->event_count;
-	
-	size = lv2_event_pad_size(sizeof(LV2_Event) + size);
-	iter->buf->size += size;
-	iter->offset    += size;
-	
-	return (uint8_t*)ev + sizeof(LV2_Event);
-}
-
-
-/** Write an event at @a iter.
- * The event (if any) pointed to by @iter will be overwritten, and @a iter
- * incremented to point to the following event (i.e. several calls to this
- * function can be done in sequence without twiddling iter in-between).
- * @return True if event was written, otherwise false (buffer is full). */
-static inline bool
-lv2_event_write_event(LV2_Event_Iterator* iter,
-                      const LV2_Event*    ev,
-                      const uint8_t*      data)
-{
-	if (iter->buf->capacity - iter->buf->size < sizeof(LV2_Event) + ev->size)
-		return false;
-
-	LV2_Event* const write_ev = (LV2_Event*)(
-			(uint8_t*)iter->buf->data + iter->offset);
-	
-	*write_ev = *ev;
-	memcpy((uint8_t*)write_ev + sizeof(LV2_Event), data, ev->size);
-	++iter->buf->event_count;
-	
-	const uint16_t size = lv2_event_pad_size(sizeof(LV2_Event) + ev->size);
-	iter->buf->size += size;
-	iter->offset    += size;
-	
-	return true;
-}
-
-#endif // LV2_EVENT_HELPERS_H
-
diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/event/event.h b/libs/ardour/lv2/lv2plug.in/ns/ext/event/event.h
deleted file mode 100644
index 701fecb534..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/event/event.h
+++ /dev/null
@@ -1,260 +0,0 @@
-/* lv2_event.h - C header file for the LV2 events extension.
- * 
- * Copyright (C) 2006-2007 Lars Luthman <lars.luthman@gmail.com>
- * Copyright (C) 2008 David Robillard <d@drobilla.net>
- * 
- * 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_EVENT_H
-#define LV2_EVENT_H
- 
-#define LV2_EVENT_URI "http://lv2plug.in/ns/ext/event"
-#define LV2_EVENT_AUDIO_STAMP 0
-
-#include <stdint.h>
-
-/** @file
- * This header defines the code portion of the LV2 events extension with URI
- * <http://lv2plug.in/ns/ext/event> ('lv2ev').
- *
- * This extension is a generic transport mechanism for time stamped events
- * of any type (e.g. MIDI, OSC, ramps, etc).  Each port can transport mixed
- * events of any type; the type of events and timestamps are defined by a URI
- * which is mapped to an integer by the host for performance reasons.
- *
- * This extension requires the host to support the LV2 URI Map extension.
- * Any host which supports this extension MUST guarantee that any call to
- * the LV2 URI Map uri_to_id function with the URI of this extension as the
- * 'map' argument returns a value within the range of uint16_t.
- */
-
-
-/** The best Pulses Per Quarter Note for tempo-based uint32_t timestmaps.
- * Equal to 2^12 * 5 * 7 * 9 * 11 * 13 * 17, which is evenly divisble
- * by all integers from 1 through 18 inclusive, and powers of 2 up to 2^12.
- */
-static const uint32_t LV2_EVENT_PPQN = 3136573440U;
-
-
-/** An LV2 event (header only).
- *
- * LV2 events are generic time-stamped containers for any type of event.
- * The type field defines the format of a given event's contents.
- *
- * This struct defines the header of an LV2 event.  An LV2 event is a single
- * chunk of POD (plain old data), usually contained in a flat buffer
- * (see LV2_EventBuffer below).  Unless a required feature says otherwise,
- * hosts may assume a deep copy of an LV2 event can be created safely
- * using a simple:
- *
- * memcpy(ev_copy, ev, sizeof(LV2_Event) + ev->size);  (or equivalent)
- */
-typedef struct {
-
-	/** The frames portion of timestamp.  The units used here can optionally be
-	 * set for a port (with the lv2ev:timeUnits property), otherwise this
-	 * is audio frames, corresponding to the sample_count parameter of the
-	 * LV2 run method (e.g. frame 0 is the first frame for that call to run).
-	 */
-	uint32_t frames;
-
-	/** The sub-frames portion of timestamp.  The units used here can
-	 * optionally be set for a port (with the lv2ev:timeUnits property),
-	 * otherwise this is 1/(2^32) of an audio frame.
-	 */
-	uint32_t subframes;
-	
-	/** The type of this event, as a number which represents some URI
-	 * defining an event type.  This value MUST be some value previously
-	 * returned from a call to the uri_to_id function defined in the LV2
-	 * URI map extension (see lv2_uri_map.h).
-	 * There are special rules which must be followed depending on the type
-	 * of an event.  If the plugin recognizes an event type, the definition
-	 * of that event type will describe how to interpret the event, and
-	 * any required behaviour.  Otherwise, if the type is 0, this event is a
-	 * non-POD event and lv2_event_unref MUST be called if the event is
-	 * 'dropped' (see above).  Even if the plugin does not understand an event,
-	 * it may pass the event through to an output by simply copying (and NOT
-	 * calling lv2_event_unref).  These rules are designed to allow for generic
-	 * event handling plugins and large non-POD events, but with minimal hassle
-	 * on simple plugins that "don't care" about these more advanced features.
-	 */
-	uint16_t type;
-
-	/** The size of the data portion of this event in bytes, which immediately
-	 * follows.  The header size (12 bytes) is not included in this value.
-	 */
-	uint16_t size;
-
-	/* size bytes of data follow here */
-
-} LV2_Event;
-
-
-
-/** A buffer of LV2 events (header only).
- *
- * Like events (which this contains) an event buffer is a single chunk of POD:
- * the entire buffer (including contents) can be copied with a single memcpy.
- * The first contained event begins sizeof(LV2_EventBuffer) bytes after
- * the start of this struct.
- *
- * After this header, the buffer contains an event header (defined by struct
- * LV2_Event), followed by that event's contents (padded to 64 bits), followed by
- * another header, etc:
- *
- * |       |       |       |       |       |       |
- * | | | | | | | | | | | | | | | | | | | | | | | | |
- * |FRAMES |SUBFRMS|TYP|LEN|DATA..DATA..PAD|FRAMES | ...
- */
-typedef struct {
-	
-	/** The contents of the event buffer.  This may or may not reside in the
-	 * same block of memory as this header, plugins must not assume either.
-	 * The host guarantees this points to at least capacity bytes of allocated
-	 * memory (though only size bytes of that are valid events).
-	 */
-	uint8_t* data;
-
-	/** The size of this event header in bytes (including everything).
-	 *
-	 * This is to allow for extending this header in the future without
-	 * breaking binary compatibility.  Whenever this header is copied,
-	 * it MUST be done using this field (and NOT the sizeof this struct).
-	 */
-	uint16_t header_size;
-
-	/** The type of the time stamps for events in this buffer.
-	 * As a special exception, '0' always means audio frames and subframes
-	 * (1/UINT32_MAX'th of a frame) in the sample rate passed to instantiate.
-	 * INPUTS: The host must set this field to the numeric ID of some URI
-	 *     defining the meaning of the frames/subframes fields of contained
-	 *     events (obtained by the LV2 URI Map uri_to_id function with the URI
-	 *     of this extension as the 'map' argument, see lv2_uri_map.h).
-	 *     The host must never pass a plugin a buffer which uses a stamp type
-	 *     the plugin does not 'understand'.  The value of this field must
-	 *     never change, except when connect_port is called on the input
-	 *     port, at which time the host MUST have set the stamp_type field to
-	 *     the value that will be used for all subsequent run calls.
-	 * OUTPUTS: The plugin may set this to any value that has been returned
-	 *     from uri_to_id with the URI of this extension for a 'map' argument.
-	 *     When connected to a buffer with connect_port, output ports MUST set
-	 *     this field to the type of time stamp they will be writing.  On any
-	 *     call to connect_port on an event input port, the plugin may change
-	 *     this field on any output port, it is the responsibility of the host
-	 *     to check if any of these values have changed and act accordingly.
-	 */
-	uint16_t stamp_type;
-
-	/** The number of events in this buffer.
-	 * INPUTS: The host must set this field to the number of events
-	 *     contained in the data buffer before calling run().
-	 *     The plugin must not change this field.
-	 * OUTPUTS: The plugin must set this field to the number of events it
-	 *     has written to the buffer before returning from run().
-	 *     Any initial value should be ignored by the plugin.
-	 */
-	uint32_t event_count;
-
-	/** The size of the data buffer in bytes.
-	 * This is set by the host and must not be changed by the plugin.
-	 * The host is allowed to change this between run() calls.
-	 */
-	uint32_t capacity;
-
-	/** The size of the initial portion of the data buffer containing data.
-	 * INPUTS: The host must set this field to the number of bytes used
-	 *     by all events it has written to the buffer (including headers)
-	 *     before calling the plugin's run().
-	 *     The plugin must not change this field.
-	 * OUTPUTS: The plugin must set this field to the number of bytes
-	 *     used by all events it has written to the buffer (including headers)
-	 *     before returning from run().
-	 *     Any initial value should be ignored by the plugin.
-	 */
-	uint32_t size;
-
-} LV2_Event_Buffer;
-
-
-/** Opaque pointer to host data. */
-typedef void* LV2_Event_Callback_Data;
-
-
-/** The data field of the LV2_Feature for this extension.
- *
- * To support this feature the host must pass an LV2_Feature struct to the
- * plugin's instantiate method with URI "http://lv2plug.in/ns/ext/event"
- * and data pointed to an instance of this struct.
- */
-typedef struct {
-	
-	/** Opaque pointer to host data.
-	 *
-	 * The plugin MUST pass this to any call to functions in this struct.
-	 * Otherwise, it must not be interpreted in any way.
-	 */
-	LV2_Event_Callback_Data callback_data;
-	
-	/** Take a reference to a non-POD event.
-	 *
-	 * If a plugin receives an event with type 0, it means the event is a
-	 * pointer to some object in memory and not a flat sequence of bytes
-	 * in the buffer.  When receiving a non-POD event, the plugin already
-	 * has an implicit reference to the event.  If the event is stored AND
-	 * passed to an output, lv2_event_ref MUST be called on that event.
-	 * If the event is only stored OR passed through, this is not necessary
-	 * (as the plugin already has 1 implicit reference).
-	 *
-	 * @param event An event received at an input that will not be copied to
-	 *              an output or stored in any way.
-	 * @param context The calling context.  (Like event types) this is a mapped
-	 *                URI, see lv2_context.h. Simple plugin with just a run()
-	 *                method should pass 0 here (the ID of the 'standard' LV2
-	 *                run context).  The host guarantees that this function is
-	 *                realtime safe iff @a context is realtime safe.
-	 *
-	 * PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
-	 */
-	uint32_t (*lv2_event_ref)(LV2_Event_Callback_Data callback_data,
-	                          LV2_Event*              event);
-	
-	/** Drop a reference to a non-POD event.
-	 *
-	 * If a plugin receives an event with type 0, it means the event is a
-	 * pointer to some object in memory and not a flat sequence of bytes
-	 * in the buffer.  If the plugin does not pass the event through to
-	 * an output or store it internally somehow, it MUST call this function
-	 * on the event (more information on using non-POD events below).
-	 *
-	 * @param event An event received at an input that will not be copied to
-	 *              an output or stored in any way.
-	 * @param context The calling context.  (Like event types) this is a mapped
-	 *                URI, see lv2_context.h. Simple plugin with just a run()
-	 *                method should pass 0 here (the ID of the 'standard' LV2
-	 *                run context).  The host guarantees that this function is
-	 *                realtime safe iff @a context is realtime safe.
-	 *
-	 * PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
-	 */
-	uint32_t (*lv2_event_unref)(LV2_Event_Callback_Data callback_data,
-	                            LV2_Event*              event);
-
-} LV2_Event_Feature;
-
-
-#endif // LV2_EVENT_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
deleted file mode 100644
index d8a5407bda..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/state/state.h
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
-  Copyright 2010-2012 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 state.h
-   C API for the LV2 State extension <http://lv2plug.in/ns/ext/state>.
-*/
-
-#ifndef LV2_STATE_H
-#define LV2_STATE_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
-
-#define LV2_STATE_URI    "http://lv2plug.in/ns/ext/state"
-#define LV2_STATE_PREFIX LV2_STATE_URI "#"
-
-#define LV2_STATE__State     LV2_STATE_PREFIX "State"
-#define LV2_STATE__interface LV2_STATE_PREFIX "interface"
-#define LV2_STATE__makePath  LV2_STATE_PREFIX "makePath"
-#define LV2_STATE__mapPath   LV2_STATE_PREFIX "mapPath"
-#define LV2_STATE__state     LV2_STATE_PREFIX "state"
-
-#ifdef __cplusplus
-extern "C" {
-#else
-#    include <stdbool.h>
-#endif
-
-typedef void* LV2_State_Handle;
-typedef void* LV2_State_Map_Path_Handle;
-typedef void* LV2_State_Make_Path_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 pointers or references to other areas
-	   of memory.  It is safe to copy POD values with a simple memcpy and store
-	   them for the duration of the process.  A POD value is not necessarily
-	   safe to trasmit between processes or machines (e.g. filenames are POD),
-	   see LV2_STATE_IS_PORTABLE for details.
-
-	   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.  A portable value saved on one machine can be restored on
-	   another machine regardless of architecture.  The format of portable
-	   values MUST NOT depend on architecture-specific properties like
-	   endianness or alignment.  Portable values MUST NOT contain filenames.
-	*/
-	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 status code for state functions. */
-typedef enum {
-	LV2_STATE_SUCCESS         = 0, /**< Completed successfully. */
-	LV2_STATE_ERR_UNKNOWN     = 1, /**< Unknown error. */
-	LV2_STATE_ERR_BAD_TYPE    = 2, /**< Failed due to unsupported type. */
-	LV2_STATE_ERR_BAD_FLAGS   = 3, /**< Failed due to unsupported flags. */
-	LV2_STATE_ERR_NO_FEATURE  = 4, /**< Failed due to missing features. */
-	LV2_STATE_ERR_NO_PROPERTY = 5  /**< Failed due to missing property. */
-} LV2_State_Status;
-
-/**
-   A host-provided function to store a property.
-   @param handle Must be the handle passed to LV2_State_Interface.save().
-   @param key The key to store @p value under (URID).
-   @param value Pointer to the value to be stored.
-   @param size The size of @p value in bytes.
-   @param type The type of @p value (URID).
-   @param flags LV2_State_Flags for @p 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 to store all the properties that
-   describe its current state.
-
-   DO NOT INVENT NONSENSE URI SCHEMES FOR THE KEY.  Best is to use keys from
-   existing vocabularies.  If nothing appropriate is available, use http URIs
-   that point to somewhere you can host documents so documentation can be made
-   resolvable (e.g. a child of the plugin or project URI).  If this is not
-   possible, invent a URN scheme, e.g. urn:myproj:whatever.  The plugin MUST
-   NOT pass an invalid URI key.
-
-   The host MAY fail to store a property for whatever reason, but SHOULD
-   store any property that is LV2_STATE_IS_POD and LV2_STATE_IS_PORTABLE.
-   Implementations SHOULD use the types from the LV2 Atom extension
-   (http://lv2plug.in/ns/ext/atom) wherever possible.  The plugin SHOULD
-   attempt to fall-back and avoid the error if possible.
-
-   Note that @p size MUST be > 0, and @p value MUST point to a valid region of
-   memory @p 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 LV2_State_Status (*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 of the property to retrieve (URID).
-   @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 flags for the restored value.
-   @return A pointer to the restored value (object), or NULL if no value
-   has been stored under @p key.
-
-   A callback of this type is passed by the host to
-   LV2_State_Interface.restore().  This callback is called repeatedly by the
-   plugin 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.
-*/
-typedef const void* (*LV2_State_Retrieve_Function)(
-	LV2_State_Handle handle,
-	uint32_t         key,
-	size_t*          size,
-	uint32_t*        type,
-	uint32_t*        flags);
-
-/**
-   LV2 Plugin State Interface.
-
-   When the plugin's extension_data is called with argument
-   LV2_STATE__interface, the plugin MUST return an LV2_State_Interface
-   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
-   of the functions are met.
-
-   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 problems in the future.
-*/
-typedef struct _LV2_State_Interface {
-
-	/**
-	   Save plugin state using a host-provided @p 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 which MUST be passed as the
-	   handle parameter to @p store if it is called.
-	   @param flags Flags describing desired properties of this save.  These
-	   flags may be used to determine the most appropriate values to store.
-	   @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.  Plugins SHOULD store simple POD data whenever
-	   possible, and consider the possibility of state being restored much
-	   later on a different machine.
-
-	   The @p handle pointer and @p 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.
-	*/
-	LV2_State_Status (*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 @p 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 which MUST be passed as the
-	   handle parameter to @p retrieve if it is called.
-	   @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 @p handle pointer and @p 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.
-	*/
-	LV2_State_Status (*restore)(LV2_Handle                  instance,
-	                            LV2_State_Retrieve_Function retrieve,
-	                            LV2_State_Handle            handle,
-	                            uint32_t                    flags,
-	                            const LV2_Feature *const *  features);
-
-} LV2_State_Interface;
-
-/**
-   Feature data for state:mapPath (LV2_STATE__mapPath).
-*/
-typedef struct {
-
-	/**
-	   Opaque host data.
-	*/
-	LV2_State_Map_Path_Handle handle;
-
-	/**
-	   Map an absolute path to an abstract path for use in plugin state.
-	   @param handle MUST be the @p handle member of this struct.
-	   @param absolute_path The absolute path of a file.
-	   @return An abstract path suitable for use in plugin state.
-
-	   The plugin MUST use this function to map any paths that will be stored
-	   in plugin state.  The returned value is an abstract path which MAY not
-	   be an actual file system path; @ref absolute_path() MUST be used to map
-	   it to an actual path in order to use the file.
-
-	   Plugins MUST NOT make any assumptions about abstract paths except that
-	   they can be mapped back to the absolute path of the "same" file (though
-	   not necessarily the same original path) using @ref absolute_path().
-
-	   This function may only be called within the context of
-	   LV2_State_Interface methods.  The caller is responsible for freeing the
-	   returned value with free().
-	*/
-	char* (*abstract_path)(LV2_State_Map_Path_Handle handle,
-	                       const char*               absolute_path);
-
-	/**
-	   Map an abstract path from plugin state to an absolute path.
-	   @param handle MUST be the @p handle member of this struct.
-	   @param abstract_path An abstract path (e.g. a path from plugin state).
-	   @return An absolute file system path.
-
-	   The plugin MUST use this function in order to actually open or otherwise
-	   use any paths loaded from plugin state.
-
-	   This function may only be called within the context of
-	   LV2_State_Interface methods.  The caller is responsible for freeing the
-	   returned value with free().
-	*/
-	char* (*absolute_path)(LV2_State_Map_Path_Handle handle,
-	                       const char*               abstract_path);
-
-} LV2_State_Map_Path;
-
-/**
-   Feature data for state:makePath (@ref LV2_STATE__makePath).
-*/
-typedef struct {
-
-	/**
-	   Opaque host data.
-	*/
-	LV2_State_Make_Path_Handle handle;
-
-	/**
-	   Return a path the plugin may use to create a new file.
-	   @param handle MUST be the @p handle member of this struct.
-	   @param path The path of the new file within a namespace unique to this
-	   plugin instance.
-	   @return The absolute path to use for the new file.
-
-	   This function can be used by plugins to create files and directories,
-	   either at state saving time (if this feature is passed to
-	   LV2_State_Interface.save()) or any time (if this feature is passed to
-	   LV2_Descriptor.instantiate()).
-
-	   The host MUST do whatever is necessary for the plugin to be able to
-	   create a file at the returned path (e.g. using fopen), including
-	   creating any leading directories.
-
-	   If this function is passed to LV2_Descriptor.instantiate(), it may be
-	   called from any non-realtime context.  If it is passed to
-	   LV2_State_Interface.save(), it may only be called within the dynamic
-	   scope of that function call.
-
-	   The caller is responsible for freeing the returned value with free().
-	*/
-	char* (*path)(LV2_State_Make_Path_Handle handle,
-	              const char*                path);
-
-} LV2_State_Make_Path;
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* LV2_STATE_H */
diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/uri-map/uri-map.h b/libs/ardour/lv2/lv2plug.in/ns/ext/uri-map/uri-map.h
deleted file mode 100644
index 4066a2f468..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/uri-map/uri-map.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/* lv2_uri_map.h - C header file for the LV2 URI Map extension.
- * 
- * Copyright (C) 2008 David Robillard <d@drobilla.net>
- * 
- * 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_URI_MAP_H
-#define LV2_URI_MAP_H
-
-#define LV2_URI_MAP_URI "http://lv2plug.in/ns/ext/uri-map"
-
-#include <stdint.h>
-
-/** @file
- * This header defines the LV2 URI Map extension with the URI
- * <http://lv2plug.in/ns/ext/uri-map> (preferred prefix 'lv2urimap').
- *
- * This extension defines a simple mechanism for plugins to map URIs to
- * integers, usually for performance reasons (e.g. processing events
- * typed by URIs in real time).  The expected use case is for plugins to
- * map URIs to integers for things they 'understand' at instantiation time,
- * and store those values for use in the audio thread without doing any string
- * comparison.  This allows the extensibility of RDF with the performance of
- * integers (or centrally defined enumerations).
- */
-	
-
-/** Opaque pointer to host data. */
-typedef void* LV2_URI_Map_Callback_Data;
-
-
-/** The data field of the LV2_Feature for this extension.
- *
- * To support this feature the host must pass an LV2_Feature struct to the
- * plugin's instantiate method with URI "http://lv2plug.in/ns/ext/uri-map"
- * and data pointed to an instance of this struct.
- */
-typedef struct {
-	
-	/** Opaque pointer to host data.
-	 *
-	 * The plugin MUST pass this to any call to functions in this struct.
-	 * Otherwise, it must not be interpreted in any way.
-	 */
-	LV2_URI_Map_Callback_Data callback_data;
-	
-	/** Get the numeric ID of a URI from the host.
-	 *
-	 * @param callback_data Must be the callback_data member of this struct.
-	 * @param map The 'context' of this URI.  Certain extensions may define a
-	 *        URI that must be passed here with certain restrictions on the
-	 *        return value (e.g. limited range).  This value may be NULL if
-	 *        the plugin needs an ID for a URI in general.
-	 * @param uri The URI to be mapped to an integer ID.
-	 *
-	 * This function is referentially transparent - any number of calls with
-	 * the same arguments is guaranteed to return the same value over the life
-	 * of a plugin instance (though the same URI may return different values
-	 * with a different map parameter).  However, this function is not
-	 * necessarily very fast: plugins should cache any IDs they might need in
-	 * performance critical situations.
-	 * The return value 0 is reserved and means an ID for that URI could not
-	 * be created for whatever reason.  Extensions may define more precisely
-	 * what this means, but in general plugins should gracefully handle 0
-	 * and consider whatever they wanted the URI for "unsupported".
-	 */
-	uint32_t (*uri_to_id)(LV2_URI_Map_Callback_Data callback_data,
-	                      const char*               map,
-	                      const char*               uri);
-
-} LV2_URI_Map_Feature;
-
-
-#endif // LV2_URI_MAP_H
-
diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/urid/urid.h b/libs/ardour/lv2/lv2plug.in/ns/ext/urid/urid.h
deleted file mode 100644
index 22c9a66ae4..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/urid/urid.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-  Copyright 2011 Gabriel M. Beddingfield <gabrbedd@gmail.com>
-  Copyright 2008-2011 David Robillard <http://drobilla.net>
-
-  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 header for the LV2 URID extension <http://lv2plug.in/ns/ext/urid>
-*/
-
-#ifndef LV2_URID_H
-#define LV2_URID_H
-
-#define LV2_URID_URI       "http://lv2plug.in/ns/ext/urid"
-#define LV2_URID_MAP_URI   LV2_URID_URI "#map"
-#define LV2_URID_UNMAP_URI LV2_URID_URI "#unmap"
-
-#include <stdint.h>
-
-/**
-   Opaque pointer to host data for LV2_URID_Map.
-*/
-typedef void* LV2_URID_Map_Handle;
-
-/**
-   Opaque pointer to host data for LV2_URID_Unmap.
-*/
-typedef void* LV2_URID_Unmap_Handle;
-
-/**
-   URI mapped to an integer.
-*/
-typedef uint32_t LV2_URID;
-
-/**
-   URI Map (http://lv2plug.in/ns/ext/urid#map).
-*/
-typedef struct {
-	/**
-	   Opaque pointer to host data.
-
-	   This MUST be passed to map_uri() whenever it is called.
-	   Otherwise, it must not be interpreted in any way.
-	*/
-	LV2_URID_Map_Handle handle;
-
-	/**
-	   Get the numeric ID of a URI.
-
-	   If the ID does not already exist, it will be created.
-
-	   This function is referentially transparent; any number of calls with the
-	   same arguments is guaranteed to return the same value over the life of a
-	   plugin instance.  Note, however, that several URIs MAY resolve to the
-	   same ID if the host considers those URIs equivalent.
-
-	   This function is not necessarily very fast or RT-safe: plugins SHOULD
-	   cache any IDs they might need in performance critical situations.
-
-	   The return value 0 is reserved and indicates that an ID for that URI
-	   could not be created for whatever reason.  However, hosts SHOULD NOT
-	   return 0 from this function in non-exceptional circumstances (i.e. the
-	   URI map SHOULD be dynamic).
-
-	   @param handle Must be the callback_data member of this struct.
-	   @param uri The URI to be mapped to an integer ID.
-	*/
-	LV2_URID (*map)(LV2_URID_Map_Handle handle,
-	                const char*         uri);
-} LV2_URID_Map;
-
-/**
-   URI Unmap (http://lv2plug.in/ns/ext/urid#unmap).
-*/
-typedef struct {
-	/**
-	   Opaque pointer to host data.
-
-	   This MUST be passed to unmap() whenever it is called.
-	   Otherwise, it must not be interpreted in any way.
-	*/
-	LV2_URID_Unmap_Handle handle;
-
-	/**
-	   Get the URI for a previously mapped numeric ID.
-
-	   Returns NULL if @c urid is not yet mapped.  Otherwise, the corresponding
-	   URI is returned in a canonical form.  This MAY not be the exact same
-	   string that was originally passed to LV2_URID_Map::map(), but it MUST be
-	   an identical URI according to the URI syntax specification (RFC3986).  A
-	   non-NULL return for a given @c urid will always be the same for the life
-	   of the plugin.  Plugins that intend to perform string comparison on
-	   unmapped URIs SHOULD first canonicalise URI strings with a call to
-	   map_uri() followed by a call to unmap_uri().
-
-	   @param handle Must be the callback_data member of this struct.
-	   @param urid The ID to be mapped back to the URI string.
-	*/
-	const char* (*unmap)(LV2_URID_Unmap_Handle handle,
-	                     LV2_URID              urid);
-} LV2_URID_Unmap;
-
-#endif /* LV2_URID_H */
diff --git a/libs/ardour/lv2/lv2plug.in/ns/ext/worker/worker.h b/libs/ardour/lv2/lv2plug.in/ns/ext/worker/worker.h
deleted file mode 100644
index 74ac45bc1e..0000000000
--- a/libs/ardour/lv2/lv2plug.in/ns/ext/worker/worker.h
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
-  Copyright 2012 David Robillard <http://drobilla.net>
-
-  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 worker.h C header for the LV2 Worker extension
-   <http://lv2plug.in/ns/ext/worker>.
-*/
-
-#ifndef LV2_WORKER_H
-#define LV2_WORKER_H
-
-#include <stdint.h>
-
-#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
-
-#define LV2_WORKER_URI    "http://lv2plug.in/ns/ext/worker"
-#define LV2_WORKER_PREFIX LV2_WORKER_URI "#"
-
-#define LV2_WORKER__interface LV2_WORKER_PREFIX "interface"
-#define LV2_WORKER__schedule  LV2_WORKER_PREFIX "schedule"
-
-/**
-   A status code for worker functions.
-*/
-typedef enum {
-	LV2_WORKER_SUCCESS       = 0,  /**< Completed successfully. */
-	LV2_WORKER_ERR_UNKNOWN   = 1,  /**< Unknown error. */
-	LV2_WORKER_ERR_NO_SPACE  = 2   /**< Failed due to lack of space. */
-} LV2_Worker_Status;
-
-typedef void* LV2_Worker_Respond_Handle;
-
-/**
-   A function to respond to run() from the worker method.
-
-   The @p data MUST be safe for the host to copy and later pass to
-   work_response(), and the host MUST guarantee that it will be eventually
-   passed to work_response() if this function returns LV2_WORKER_SUCCESS.
-*/
-typedef LV2_Worker_Status (*LV2_Worker_Respond_Function)(
-	LV2_Worker_Respond_Handle handle,
-	uint32_t                  size,
-	const void*               data);
-
-/**
-   LV2 Plugin Worker Interface.
-
-   This is the interface provided by the plugin to implement a worker method.
-   The plugin's extension_data() method should return an LV2_Worker_Interface
-   when called with LV2_WORKER__interface as its argument.
-*/
-typedef struct _LV2_Worker_Interface {
-	/**
-	   The worker method.  This is called by the host in a non-realtime context
-	   as requested, possibly with an arbitrary message to handle.
-
-	   A response can be sent to run() using @p respond.  The plugin MUST NOT
-	   make any assumptions about which thread calls this method, other than
-	   the fact that there are no real-time requirements.
-
-	   @param instance The LV2 instance this is a method on.
-	   @param respond  A function for sending a response to run().
-	   @param handle   Must be passed to @p respond if it is called.
-	   @param size     The size of @p data.
-	   @param data     Data from run(), or NULL.
-	*/
-	LV2_Worker_Status (*work)(LV2_Handle                  instance,
-	                          LV2_Worker_Respond_Function respond,
-	                          LV2_Worker_Respond_Handle   handle,
-	                          uint32_t                    size,
-	                          const void*                 data);
-
-	/**
-	   Handle a response from the worker.  This is called by the host in the
-	   run() context when a response from the worker is ready.
-
-	   @param instance The LV2 instance this is a method on.
-	   @param size     The size of @p body.
-	   @param body     Message body, or NULL.
-	*/
-	LV2_Worker_Status (*work_response)(LV2_Handle  instance,
-	                                   uint32_t    size,
-	                                   const void* body);
-
-	/**
-	   Called when all responses for this cycle have been delivered.
-
-	   Since work_response() may be called after run() finished, this provides
-	   a hook for code that must run after the cycle is completed.
-
-	   This field may be NULL if the plugin has no use for it.  Otherwise, the
-	   host MUST call it after every run(), regardless of whether or not any
-	   responses were sent that cycle.
-	*/
-	LV2_Worker_Status (*end_run)(LV2_Handle instance);
-} LV2_Worker_Interface;
-
-typedef void* LV2_Worker_Schedule_Handle;
-
-typedef struct _LV2_Worker_Schedule {
-	/**
-	   Opaque host data.
-	*/
-	LV2_Worker_Schedule_Handle handle;
-
-	/**
-	   Request from run() that the host call the worker.
-
-	   This function is in the audio threading class.  It should be called from
-	   run() to request that the host call the work() method in a non-realtime
-	   context with the given arguments.
-
-	   This function is always safe to call from run(), but it is not
-	   guaranteed that the worker is actually called from a different thread.
-	   In particular, when free-wheeling (e.g. for offline rendering), the
-	   worker may be executed immediately.  This allows single-threaded
-	   processing with sample accuracy and avoids timing problems when run() is
-	   executing much faster or slower than real-time.
-
-	   Plugins SHOULD be written in such a way that if the worker runs
-	   immediately, and responses from the worker are delivered immediately,
-	   the effect of the work takes place immediately with sample accuracy.
-
-	   The @p data MUST be safe for the host to copy and later pass to work(),
-	   and the host MUST guarantee that it will be eventually passed to work()
-	   if this function returns LV2_WORKER_SUCCESS.
-
-	   @param handle The handle field of this struct.
-	   @param size   The size of @p data.
-	   @param data   Message to pass to work(), or NULL.
-	*/
-	LV2_Worker_Status (*schedule_work)(LV2_Worker_Schedule_Handle handle,
-	                                   uint32_t                   size,
-	                                   const void*                data);
-} LV2_Worker_Schedule;
-
-#endif  /* LV2_WORKER_H */
diff --git a/libs/ardour/lv2_plugin.cc b/libs/ardour/lv2_plugin.cc
index 71c126cb41..dc312a099b 100644
--- a/libs/ardour/lv2_plugin.cc
+++ b/libs/ardour/lv2_plugin.cc
@@ -151,9 +151,7 @@ work_respond(LV2_Worker_Respond_Handle handle,
 struct LV2Plugin::Impl {
 	Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
 	       , work_iface(0)
-#ifdef HAVE_NEW_LILV
 	       , state(0)
-#endif
 	{}
 	
 	/** Find the LV2 input port with the given designation.
@@ -168,9 +166,7 @@ struct LV2Plugin::Impl {
 	LilvNode*             author;
 	LilvInstance*         instance;
 	LV2_Worker_Interface* work_iface;
-#ifdef HAVE_NEW_LILV
 	LilvState*            state;
-#endif
 };
 
 LV2Plugin::LV2Plugin (AudioEngine& engine,
@@ -228,7 +224,6 @@ LV2Plugin::init(void* c_plugin, framecnt_t rate)
 
 	LilvPlugin* plugin = _impl->plugin;
 
-#ifdef HAVE_NEW_LILV
 	LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
 	LilvNode* state_uri       = lilv_new_uri(_world.world, LV2_STATE_URI);
 	_has_state_interface =
@@ -238,7 +233,6 @@ LV2Plugin::init(void* c_plugin, framecnt_t rate)
 		|| lilv_plugin_has_feature(plugin, state_uri);
 	lilv_node_free(state_uri);
 	lilv_node_free(state_iface_uri);
-#endif
 
 	_features    = (LV2_Feature**)malloc(sizeof(LV2_Feature*) * 8);
 	_features[0] = &_instance_access_feature;
@@ -727,7 +721,6 @@ LV2Plugin::add_state(XMLNode* root) const
 
 	if (_has_state_interface) {
 		cout << "LV2 " << name() << " has state interface" << endl;
-#ifdef HAVE_NEW_LILV
 		// Provisionally increment state version and create directory
 		const std::string new_dir = state_dir(++_state_version);
 		g_mkdir_with_parents(new_dir.c_str(), 0744);
@@ -769,12 +762,6 @@ LV2Plugin::add_state(XMLNode* root) const
 		}
 
 		root->add_property("state-dir", string_compose("state%1", _state_version));
-
-#else  /* !HAVE_NEW_LILV */
-		warning << string_compose(
-			_("Plugin \"%1\" has state, but Lilv is too old to save it"),
-			unique_id()) << endmsg;
-#endif  /* HAVE_NEW_LILV */
 	} else {
 		cout << "LV2 " << name() << " has no state interface." << endl;
 	}
@@ -790,7 +777,6 @@ get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
 void
 LV2Plugin::find_presets()
 {
-#ifdef HAVE_NEW_LILV
 	LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LILV_NS_LV2  "appliesTo");
 	LilvNode* pset_Preset   = lilv_new_uri(_world.world, NS_PSET "Preset");
 	LilvNode* rdfs_label    = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
@@ -817,7 +803,6 @@ LV2Plugin::find_presets()
 	lilv_node_free(rdfs_label);
 	lilv_node_free(pset_Preset);
 	lilv_node_free(lv2_appliesTo);
-#endif  /* HAVE_NEW_LILV */
 }
 
 bool
@@ -1037,7 +1022,6 @@ LV2Plugin::set_state(const XMLNode& node, int version)
 		set_parameter(port_id, atof(value));
 	}
 
-#ifdef HAVE_NEW_LILV
 	_state_version = 0;
 	if ((prop = node.property("state-dir")) != 0) {
 		if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
@@ -1056,7 +1040,6 @@ LV2Plugin::set_state(const XMLNode& node, int version)
 
 		lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
 	}
-#endif
 
 	latency_compute_run();
 
@@ -1451,8 +1434,7 @@ LV2Plugin::latency_compute_run()
 LilvPort*
 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
 {
-	LilvPort* port = NULL;
-#ifdef HAVE_NEW_LILV
+	LilvPort* port        = NULL;
 	LilvNode* designation = lilv_new_uri(_world.world, uri);
 	port = lilv_plugin_get_port_by_designation(
 		plugin, _world.lv2_InputPort, designation);
@@ -1460,7 +1442,6 @@ LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** buf
 	if (port) {
 		bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
 	}
-#endif
 	return port;
 }
 
diff --git a/libs/ardour/wscript b/libs/ardour/wscript
index b6dca5f376..bf32599630 100644
--- a/libs/ardour/wscript
+++ b/libs/ardour/wscript
@@ -257,14 +257,10 @@ def configure(conf):
                       atleast_version='2.0')
     if Options.options.lv2:
         autowaf.check_pkg(conf, 'lilv-0', uselib_store='LILV',
-                          atleast_version='0.0.0', mandatory=False)
-        autowaf.check_pkg(conf, 'lilv-0', uselib_store='NEW_LILV',
                           atleast_version='0.14.0', mandatory=False)
         if conf.is_defined('HAVE_LILV'):
             autowaf.check_pkg(conf, 'suil-0', uselib_store='SUIL',
-                              atleast_version='0.2.0', mandatory=False)
-            autowaf.check_pkg(conf, 'suil-0', uselib_store='NEW_SUIL',
-                              atleast_version='0.5.0', mandatory=False)
+                              atleast_version='0.6.0', mandatory=False)
 
 #    autowaf.check_pkg(conf, 'soundtouch-1.0', uselib_store='SOUNDTOUCH',
 #                      mandatory=False)
diff --git a/wscript b/wscript
index 08a3827f47..6f58ceb67a 100644
--- a/wscript
+++ b/wscript
@@ -643,7 +643,6 @@ const char* const ardour_config_info = "\\n\\
     write_config_text('JACK session support',  conf.is_defined('JACK_SESSION'))
     write_config_text('LV2 UI embedding',      conf.is_defined('HAVE_SUIL'))
     write_config_text('LV2 support',           conf.is_defined('LV2_SUPPORT'))
-    write_config_text('LV2 state support',     conf.is_defined('HAVE_NEW_LILV'))
     write_config_text('LXVST support',         conf.is_defined('LXVST_SUPPORT'))
     write_config_text('OGG',                   conf.is_defined('HAVE_OGG'))
     write_config_text('Phone home',            conf.is_defined('PHONE_HOME'))