Patch lilv sources

source/modules/lilv/lilv-0.20.0/lilv/lilv.h

@@ -26,8 +26,9 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
-#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
+#include "lv2/lv2.h"
+#include "lv2/state.h"
+#include "lv2/urid.h"
 
 #ifdef LILV_SHARED
 #    ifdef _WIN32
@@ -1152,9 +1153,9 @@ lilv_port_get_scale_points(const LilvPlugin* plugin,
    @return A new LilvState which must be freed with lilv_state_free(), or NULL.
 */
 LILV_API LilvState*
-lilv_state_new_from_world(LilvWorld*      world,
-                          LV2_URID_Map*   map,
-                          const LilvNode* subject);
+lilv_state_new_from_world(LilvWorld*          world,
+                          const LV2_URID_Map* map,
+                          const LilvNode*     subject);
 
 /**
    Load a state snapshot from a file.
@@ -1172,18 +1173,18 @@ lilv_state_new_from_world(LilvWorld*      world,
    new memory consumed once this function returns.
 */
 LILV_API LilvState*
-lilv_state_new_from_file(LilvWorld*      world,
-                         LV2_URID_Map*   map,
-                         const LilvNode* subject,
-                         const char*     path);
+lilv_state_new_from_file(LilvWorld*          world,
+                         const LV2_URID_Map* map,
+                         const LilvNode*     subject,
+                         const char*         path);
 
 /**
    Load a state snapshot from a string made by lilv_state_to_string().
 */
 LILV_API LilvState*
-lilv_state_new_from_string(LilvWorld*    world,
-                           LV2_URID_Map* map,
-                           const char*   str);
+lilv_state_new_from_string(LilvWorld*          world,
+                           const LV2_URID_Map* map,
+                           const char*         str);
 
 /**
    Function to get a port value.
@@ -1352,7 +1353,8 @@ typedef void (*LilvSetPortValueFunc)(const char* port_symbol,
 */
 LILV_API void
 lilv_state_restore(const LilvState*           state,
-                   LilvInstance*              instance,
+                   const LV2_State_Interface* iface,
+                   LV2_Handle                 handle,
                    LilvSetPortValueFunc       set_value,
                    void*                      user_data,
                    uint32_t                   flags,
@@ -1694,6 +1696,21 @@ lilv_ui_get_bundle_uri(const LilvUI* ui);
 LILV_API const LilvNode*
 lilv_ui_get_binary_uri(const LilvUI* ui);
 
+/**
+  Custom calls
+*/
+LILV_API const LilvNodes*
+lilv_ui_get_supported_features(const LilvUI* ui);
+
+LILV_API const LilvNodes*
+lilv_ui_get_required_features(const LilvUI* ui);
+
+LILV_API const LilvNodes*
+lilv_ui_get_optional_features(const LilvUI* ui);
+
+LILV_API const LilvNodes*
+lilv_ui_get_extension_data(const LilvUI* ui);
+
 /**
    @}
    @}

source/modules/lilv/lilv-0.20.0/lilv/lilvmm.hpp

@@ -17,6 +17,8 @@
 #ifndef LILV_LILVMM_HPP
 #define LILV_LILVMM_HPP
 
+#include "CarlaDefines.h"
+
 #include "lilv/lilv.h"
 
 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
@@ -35,6 +37,9 @@ uri_to_path(const char* uri) {
 #define LILV_WRAP0(RT, prefix, name) \
 	inline RT name() { return lilv_ ## prefix ## _ ## name (me); }
 
+#define LILV_WRAP0_CONST(RT, prefix, name) \
+        inline RT name() const { return lilv_ ## prefix ## _ ## name (me); }
+
 #define LILV_WRAP0_VOID(prefix, name) \
 	inline void name() { lilv_ ## prefix ## _ ## name(me); }
 
@@ -65,6 +70,7 @@ uri_to_path(const char* uri) {
 #endif
 
 struct Node {
+        inline Node(LilvNode* node)       : me(node) {}
 	inline Node(const LilvNode* node) : me(lilv_node_duplicate(node)) {}
 	inline Node(const Node& copy)     : me(lilv_node_duplicate(copy.me)) {}
 
@@ -78,20 +84,26 @@ struct Node {
 
 	LILV_WRAP_CONVERSION(LilvNode);
 
-	LILV_WRAP0(char*,       node, get_turtle_token);
-	LILV_WRAP0(bool,        node, is_uri);
-	LILV_WRAP0(const char*, node, as_uri);
-	LILV_WRAP0(bool,        node, is_blank);
-	LILV_WRAP0(const char*, node, as_blank);
-	LILV_WRAP0(bool,        node, is_literal);
-	LILV_WRAP0(bool,        node, is_string);
-	LILV_WRAP0(const char*, node, as_string);
-	LILV_WRAP0(bool,        node, is_float);
-	LILV_WRAP0(float,       node, as_float);
-	LILV_WRAP0(bool,        node, is_int);
-	LILV_WRAP0(int,         node, as_int);
-	LILV_WRAP0(bool,        node, is_bool);
-	LILV_WRAP0(bool,        node, as_bool);
+	LILV_WRAP0_CONST(char*,       node, get_turtle_token);
+	LILV_WRAP0_CONST(bool,        node, is_uri);
+	LILV_WRAP0_CONST(const char*, node, as_uri);
+	LILV_WRAP0_CONST(bool,        node, is_blank);
+	LILV_WRAP0_CONST(const char*, node, as_blank);
+	LILV_WRAP0_CONST(bool,        node, is_literal);
+	LILV_WRAP0_CONST(bool,        node, is_string);
+	LILV_WRAP0_CONST(const char*, node, as_string);
+	LILV_WRAP0_CONST(bool,        node, is_float);
+	LILV_WRAP0_CONST(float,       node, as_float);
+	LILV_WRAP0_CONST(bool,        node, is_int);
+	LILV_WRAP0_CONST(int,         node, as_int);
+	LILV_WRAP0_CONST(bool,        node, is_bool);
+	LILV_WRAP0_CONST(bool,        node, as_bool);
+
+        Node& operator=(const Node& copy) {
+                lilv_node_free(me);
+                me = lilv_node_duplicate(copy.me);
+                return *this;
+        }
 
 	LilvNode* me;
 };
@@ -126,7 +138,7 @@ struct PluginClass {
 	LILV_WRAP0(LilvIter*, prefix, begin); \
 	LILV_WRAP1(LilvIter*, prefix, next, LilvIter*, i); \
 	LILV_WRAP1(bool, prefix, is_end, LilvIter*, i); \
-	const Lilv ## CT* me; \
+	const Lilv ## CT* me
 
 struct PluginClasses {
 	LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes);
@@ -141,22 +153,24 @@ struct ScalePoints {
 struct Nodes {
 	LILV_WRAP_COLL(Nodes, Node, nodes);
 	LILV_WRAP1(bool, nodes, contains, const Node, node);
-	LILV_WRAP0(Node, nodes, get_first);
+
+        inline Node get_first() const {
+              return Node((const LilvNode*)lilv_nodes_get_first(me));
+        }
 };
 
 struct UI {
 	inline UI(const LilvUI* c_obj) : me(c_obj) {}
 	LILV_WRAP_CONVERSION(const LilvUI);
 
-	LILV_WRAP0(const LilvNode*, ui, get_uri);
-	LILV_WRAP0(const LilvNode*, ui, get_bundle_uri);
-	LILV_WRAP0(const LilvNode*, ui, get_binary_uri);
-	LILV_WRAP0(const LilvNodes*, ui, get_classes);
-	/*LILV_WRAP3(bool, ui, is_supported,
-	           LilvUISupportedFunc, supported_func,
-	           const LilvNode*,     container_type,
-	           const LilvNode**,    ui_type);*/
-	LILV_WRAP1(bool, ui, is_a, const LilvNode*, class_uri);
+        LILV_WRAP0(Node,  ui, get_uri);
+        LILV_WRAP1(bool,  ui, is_a, LilvNode*, ui_class);
+        LILV_WRAP0(Node,  ui, get_bundle_uri);
+        LILV_WRAP0(Node,  ui, get_binary_uri);
+        LILV_WRAP0(Nodes, ui, get_supported_features);
+        LILV_WRAP0(Nodes, ui, get_required_features);
+        LILV_WRAP0(Nodes, ui, get_optional_features);
+        LILV_WRAP0(Nodes, ui, get_extension_data);
 
 	const LilvUI* me;
 };
@@ -258,16 +272,14 @@ struct Plugins {
 struct Instance {
 	inline Instance(LilvInstance* instance) : me(instance) {}
 
-	LILV_DEPRECATED
-	inline Instance(Plugin plugin, double sample_rate) {
-		me = lilv_plugin_instantiate(plugin, sample_rate, NULL);
-	}
+        LILV_DEPRECATED
+        inline Instance(Plugin plugin, double sample_rate)
+                : me(lilv_plugin_instantiate(plugin, sample_rate, NULL)) {}
 
-	LILV_DEPRECATED inline Instance(Plugin              plugin,
-	                                double              sample_rate,
-	                                LV2_Feature* const* features) {
-		me = lilv_plugin_instantiate(plugin, sample_rate, features);
-	}
+        LILV_DEPRECATED inline Instance(Plugin              plugin,
+                                        double              sample_rate,
+                                        LV2_Feature* const* features)
+                : me(lilv_plugin_instantiate(plugin, sample_rate, features)) {}
 
 	static inline Instance* create(Plugin              plugin,
 	                               double              sample_rate,
@@ -304,22 +316,22 @@ struct Instance {
 };
 
 struct World {
-	inline World() : me(lilv_world_new()) {}
-	inline ~World() { lilv_world_free(me); }
+	inline          World() : me(lilv_world_new()) {}
+	inline virtual ~World() { lilv_world_free(me); }
 
-	inline LilvNode* new_uri(const char* uri) {
+	inline LilvNode* new_uri(const char* uri) const {
 		return lilv_new_uri(me, uri);
 	}
-	inline LilvNode* new_string(const char* str) {
+	inline LilvNode* new_string(const char* str) const {
 		return lilv_new_string(me, str);
 	}
-	inline LilvNode* new_int(int val) {
+	inline LilvNode* new_int(int val) const {
 		return lilv_new_int(me, val);
 	}
-	inline LilvNode* new_float(float val) {
+	inline LilvNode* new_float(float val) const {
 		return lilv_new_float(me, val);
 	}
-	inline LilvNode* new_bool(bool val) {
+	inline LilvNode* new_bool(bool val) const {
 		return lilv_new_bool(me, val);
 	}
 	inline Nodes find_nodes(const LilvNode* subject,
@@ -337,6 +349,8 @@ struct World {
 	LILV_WRAP1(int, world, load_resource, const LilvNode*, resource);
 
 	LilvWorld* me;
+
+        CARLA_DECLARE_NON_COPY_STRUCT(World)
 };
 
 } /* namespace Lilv */

source/modules/lilv/lilv-0.20.0/src/lilv_internal.h

@@ -50,7 +50,7 @@ static inline char* dlerror(void) { return "Unknown error"; }
 #include "lilv/lilv.h"
 
 #ifdef LILV_DYN_MANIFEST
-#    include "lv2/lv2plug.in/ns/ext/dynmanifest/dynmanifest.h"
+#    include "lv2/dynmanifest.h"
 #endif
 
 /*

source/modules/lilv/lilv-0.20.0/src/plugin.c

@@ -27,7 +27,7 @@
 #include "lilv_config.h"
 #include "lilv_internal.h"
 
-#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
+#include "lv2/ui.h"
 
 #define NS_DOAP (const uint8_t*)"http://usefulinc.com/ns/doap#"
 #define NS_FOAF (const uint8_t*)"http://xmlns.com/foaf/0.1/"

source/modules/lilv/lilv-0.20.0/src/port.c

@@ -20,8 +20,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
-#include "lv2/lv2plug.in/ns/ext/event/event.h"
+#include "lv2/atom.h"
+#include "lv2/event.h"
 
 #include "lilv_internal.h"
 

source/modules/lilv/lilv-0.20.0/src/state.c

@@ -18,10 +18,10 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
-#include "lv2/lv2plug.in/ns/ext/atom/forge.h"
-#include "lv2/lv2plug.in/ns/ext/presets/presets.h"
-#include "lv2/lv2plug.in/ns/ext/state/state.h"
+#include "lv2/atom.h"
+#include "lv2/atom-forge.h"
+#include "lv2/presets.h"
+#include "lv2/state.h"
 
 #include "lilv_config.h"
 #include "lilv_internal.h"
@@ -397,30 +397,18 @@ lilv_state_new_from_instance(const LilvPlugin*          plugin,
 
 LILV_API void
 lilv_state_restore(const LilvState*           state,
-                   LilvInstance*              instance,
+                   const LV2_State_Interface* iface,
+                   LV2_Handle                 handle,
                    LilvSetPortValueFunc       set_value,
                    void*                      user_data,
                    uint32_t                   flags,
                    const LV2_Feature *const * features)
 {
-	LV2_State_Map_Path map_path = {
-		(LilvState*)state, abstract_path, absolute_path };
-	LV2_Feature map_feature = { LV2_STATE__mapPath, &map_path };
-
-	const LV2_Feature** sfeatures = add_features(features, &map_feature, NULL);
-
-	const LV2_Descriptor*      desc  = instance ? instance->lv2_descriptor : NULL;
-	const LV2_State_Interface* iface = (desc && desc->extension_data)
-		? (const LV2_State_Interface*)desc->extension_data(LV2_STATE__interface)
-		: NULL;
-
 	if (iface) {
-		iface->restore(instance->lv2_handle, retrieve_callback,
-		               (LV2_State_Handle)state, flags, sfeatures);
+		iface->restore(handle, retrieve_callback,
+		               (LV2_State_Handle)state, flags, features);
 	}
 
-	free(sfeatures);
-
 	if (set_value) {
 		for (uint32_t i = 0; i < state->num_values; ++i) {
 			const PortValue* val = &state->values[i];
@@ -571,9 +559,9 @@ new_state_from_model(LilvWorld*       world,
 }
 
 LILV_API LilvState*
-lilv_state_new_from_world(LilvWorld*      world,
-                          LV2_URID_Map*   map,
-                          const LilvNode* node)
+lilv_state_new_from_world(LilvWorld*          world,
+                          const LV2_URID_Map* map,
+                          const LilvNode*     node)
 {
 	if (!lilv_node_is_uri(node) && !lilv_node_is_blank(node)) {
 		LILV_ERRORF("Subject `%s' is not a URI or blank node.\n",
@@ -588,10 +576,10 @@ lilv_state_new_from_world(LilvWorld*      world,
 }
 
 LILV_API LilvState*
-lilv_state_new_from_file(LilvWorld*      world,
-                         LV2_URID_Map*   map,
-                         const LilvNode* subject,
-                         const char*     path)
+lilv_state_new_from_file(LilvWorld*          world,
+                         const LV2_URID_Map* map,
+                         const LilvNode*     subject,
+                         const char*         path)
 {
 	if (subject && !lilv_node_is_uri(subject)
 	    && !lilv_node_is_blank(subject)) {
@@ -641,9 +629,9 @@ set_prefixes(SerdEnv* env)
 }
 
 LILV_API LilvState*
-lilv_state_new_from_string(LilvWorld*    world,
-                           LV2_URID_Map* map,
-                           const char*   str)
+lilv_state_new_from_string(LilvWorld*          world,
+                           const LV2_URID_Map* map,
+                           const char*         str)
 {
 	if (!str) {
 		return NULL;

source/modules/lilv/lilv-0.20.0/src/ui.c

@@ -109,3 +109,54 @@ lilv_ui_get_binary_uri(const LilvUI* ui)
 {
 	return ui->binary_uri;
 }
+
+static LilvNodes*
+lilv_ui_get_value_internal(const LilvUI* ui, const SordNode* predicate)
+{
+       assert(ui);
+       return lilv_world_find_nodes_internal(ui->world, ui->uri->node, predicate, NULL);
+}
+
+LILV_API const LilvNodes*
+lilv_ui_get_supported_features(const LilvUI* ui)
+{
+       assert(ui);
+       LilvNodes* optional = lilv_ui_get_optional_features(ui);
+       LilvNodes* required = lilv_ui_get_required_features(ui);
+       LilvNodes* result   = lilv_nodes_new();
+
+       LILV_FOREACH(nodes, i, optional)
+               zix_tree_insert((ZixTree*)result, lilv_node_duplicate(lilv_nodes_get(optional, i)), NULL);
+
+       LILV_FOREACH(nodes, i, required)
+               zix_tree_insert((ZixTree*)result, lilv_node_duplicate(lilv_nodes_get(required, i)), NULL);
+
+       lilv_nodes_free(optional);
+       lilv_nodes_free(required);
+
+       return result;
+}
+
+LILV_API const LilvNodes*
+lilv_ui_get_required_features(const LilvUI* ui)
+{
+       assert(ui);
+       assert(ui->world);
+       return lilv_ui_get_value_internal(ui, ui->world->uris.lv2_requiredFeature);
+}
+
+LILV_API const LilvNodes*
+lilv_ui_get_optional_features(const LilvUI* ui)
+{
+       assert(ui);
+       assert(ui->world);
+       return lilv_ui_get_value_internal(ui, ui->world->uris.lv2_optionalFeature);
+}
+
+LILV_API const LilvNodes*
+lilv_ui_get_extension_data(const LilvUI* ui)
+{
+       assert(ui);
+       assert(ui->world);
+       return lilv_ui_get_value_internal(ui, ui->world->uris.lv2_extensionData);
+}

source/modules/lilv/lilv-0.20.0/src/util.c

@@ -29,7 +29,6 @@
 #include <string.h>
 
 #ifdef _WIN32
-#    define _WIN32_WINNT 0x0600  /* for CreateSymbolicLink */
 #    include <windows.h>
 #    include <direct.h>
 #    include <io.h>
@@ -426,7 +425,7 @@ lilv_symlink(const char* oldpath, const char* newpath)
 	int ret = 0;
 	if (strcmp(oldpath, newpath)) {
 #ifdef _WIN32
-		ret = !CreateSymbolicLink(newpath, oldpath, 0);
+		ret = 0;
 #else
 		ret = symlink(oldpath, newpath);
 #endif

source/modules/lilv/lilv-0.20.0/src/world.c

@@ -19,7 +19,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "lv2/lv2plug.in/ns/ext/presets/presets.h"
+#include "lv2/presets.h"
 
 #include "lilv_internal.h"
 

source/modules/lilv/sratom-0.4.6/sratom/sratom.h

@@ -23,9 +23,9 @@
 
 #include <stdint.h>
 
-#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
-#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
-#include "lv2/lv2plug.in/ns/ext/atom/forge.h"
+#include "lv2/atom.h"
+#include "lv2/atom-forge.h"
+#include "lv2/urid.h"
 #include "serd/serd.h"
 #include "sord/sord.h"
 

source/modules/lilv/sratom-0.4.6/src/sratom.c

@@ -22,9 +22,9 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "lv2/lv2plug.in/ns/ext/atom/forge.h"
-#include "lv2/lv2plug.in/ns/ext/atom/util.h"
-#include "lv2/lv2plug.in/ns/ext/midi/midi.h"
+#include "lv2/atom-forge.h"
+#include "lv2/atom-util.h"
+#include "lv2/midi.h"
 
 #include "sratom/sratom.h"