falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2625 Commits
17 Branches
263MB
Tree: a37ff5ceff
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a37ff5ceff'
${ noResults }
Carla/source/modules/lilv/custom-patches.diff

530 lines
18KB
Raw Blame History 

  1. diff --git a/source/modules/lilv/lilv-0.20.0/lilv/lilv.h b/source/modules/lilv/lilv-0.20.0/lilv/lilv.h

  2. index 5c26681..ca673e4 100644

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

  4. +++ b/source/modules/lilv/lilv-0.20.0/lilv/lilv.h

  5. @@ -26,8 +26,9 @@

  6.  #include <stdint.h>

  7.  #include <stdio.h>

  8.  

  9. -#include "lv2/lv2plug.in/ns/lv2core/lv2.h"

  10. -#include "lv2/lv2plug.in/ns/ext/urid/urid.h"

  11. +#include "lv2/lv2.h"

  12. +#include "lv2/state.h"

  13. +#include "lv2/urid.h"

  14.  

  15.  #ifdef LILV_SHARED

  16.  #    ifdef _WIN32

  17. @@ -1152,9 +1153,9 @@ lilv_port_get_scale_points(const LilvPlugin* plugin,

  18.     @return A new LilvState which must be freed with lilv_state_free(), or NULL.

  19.  */

  20.  LILV_API LilvState*

  21. -lilv_state_new_from_world(LilvWorld*      world,

  22. -                          LV2_URID_Map*   map,

  23. -                          const LilvNode* subject);

  24. +lilv_state_new_from_world(LilvWorld*          world,

  25. +                          const LV2_URID_Map* map,

  26. +                          const LilvNode*     subject);

  27.  

  28.  /**

  29.     Load a state snapshot from a file.

  30. @@ -1172,18 +1173,18 @@ lilv_state_new_from_world(LilvWorld*      world,

  31.     new memory consumed once this function returns.

  32.  */

  33.  LILV_API LilvState*

  34. -lilv_state_new_from_file(LilvWorld*      world,

  35. -                         LV2_URID_Map*   map,

  36. -                         const LilvNode* subject,

  37. -                         const char*     path);

  38. +lilv_state_new_from_file(LilvWorld*          world,

  39. +                         const LV2_URID_Map* map,

  40. +                         const LilvNode*     subject,

  41. +                         const char*         path);

  42.  

  43.  /**

  44.     Load a state snapshot from a string made by lilv_state_to_string().

  45.  */

  46.  LILV_API LilvState*

  47. -lilv_state_new_from_string(LilvWorld*    world,

  48. -                           LV2_URID_Map* map,

  49. -                           const char*   str);

  50. +lilv_state_new_from_string(LilvWorld*          world,

  51. +                           const LV2_URID_Map* map,

  52. +                           const char*         str);

  53.  

  54.  /**

  55.     Function to get a port value.

  56. @@ -1352,7 +1353,8 @@ typedef void (*LilvSetPortValueFunc)(const char* port_symbol,

  57.  */

  58.  LILV_API void

  59.  lilv_state_restore(const LilvState*           state,

  60. -                   LilvInstance*              instance,

  61. +                   const LV2_State_Interface* iface,

  62. +                   LV2_Handle                 handle,

  63.                     LilvSetPortValueFunc       set_value,

  64.                     void*                      user_data,

  65.                     uint32_t                   flags,

  66. @@ -1695,6 +1697,21 @@ LILV_API const LilvNode*

  67.  lilv_ui_get_binary_uri(const LilvUI* ui);

  68.  

  69.  /**

  70. +  Custom calls

  71. +*/

  72. +LILV_API const LilvNodes*

  73. +lilv_ui_get_supported_features(const LilvUI* ui);

  74. +

  75. +LILV_API const LilvNodes*

  76. +lilv_ui_get_required_features(const LilvUI* ui);

  77. +

  78. +LILV_API const LilvNodes*

  79. +lilv_ui_get_optional_features(const LilvUI* ui);

  80. +

  81. +LILV_API const LilvNodes*

  82. +lilv_ui_get_extension_data(const LilvUI* ui);

  83. +

  84. +/**

  85.     @}

  86.     @}

  87.  */

  88. diff --git a/source/modules/lilv/lilv-0.20.0/lilv/lilvmm.hpp b/source/modules/lilv/lilv-0.20.0/lilv/lilvmm.hpp

  89. index b9b3a69..0d82f3f 100644

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

  91. +++ b/source/modules/lilv/lilv-0.20.0/lilv/lilvmm.hpp

  92. @@ -17,6 +17,8 @@

  93.  #ifndef LILV_LILVMM_HPP

  94.  #define LILV_LILVMM_HPP

  95.  

  96. +#include "CarlaDefines.h"

  97. +

  98.  #include "lilv/lilv.h"

  99.  

  100.  #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)

  101. @@ -35,6 +37,9 @@ uri_to_path(const char* uri) {

  102.  #define LILV_WRAP0(RT, prefix, name) \

  103.  	inline RT name() { return lilv_ ## prefix ## _ ## name (me); }

  104.  

  105. +#define LILV_WRAP0_CONST(RT, prefix, name) \

  106. +        inline RT name() const { return lilv_ ## prefix ## _ ## name (me); }

  107. +

  108.  #define LILV_WRAP0_VOID(prefix, name) \

  109.  	inline void name() { lilv_ ## prefix ## _ ## name(me); }

  110.  

  111. @@ -65,6 +70,7 @@ uri_to_path(const char* uri) {

  112.  #endif

  113.  

  114.  struct Node {

  115. +        inline Node(LilvNode* node)       : me(node) {}

  116.  	inline Node(const LilvNode* node) : me(lilv_node_duplicate(node)) {}

  117.  	inline Node(const Node& copy)     : me(lilv_node_duplicate(copy.me)) {}

  118.  

  119. @@ -78,20 +84,26 @@ struct Node {

  120.  

  121.  	LILV_WRAP_CONVERSION(LilvNode);

  122.  

  123. -	LILV_WRAP0(char*,       node, get_turtle_token);

  124. -	LILV_WRAP0(bool,        node, is_uri);

  125. -	LILV_WRAP0(const char*, node, as_uri);

  126. -	LILV_WRAP0(bool,        node, is_blank);

  127. -	LILV_WRAP0(const char*, node, as_blank);

  128. -	LILV_WRAP0(bool,        node, is_literal);

  129. -	LILV_WRAP0(bool,        node, is_string);

  130. -	LILV_WRAP0(const char*, node, as_string);

  131. -	LILV_WRAP0(bool,        node, is_float);

  132. -	LILV_WRAP0(float,       node, as_float);

  133. -	LILV_WRAP0(bool,        node, is_int);

  134. -	LILV_WRAP0(int,         node, as_int);

  135. -	LILV_WRAP0(bool,        node, is_bool);

  136. -	LILV_WRAP0(bool,        node, as_bool);

  137. +	LILV_WRAP0_CONST(char*,       node, get_turtle_token);

  138. +	LILV_WRAP0_CONST(bool,        node, is_uri);

  139. +	LILV_WRAP0_CONST(const char*, node, as_uri);

  140. +	LILV_WRAP0_CONST(bool,        node, is_blank);

  141. +	LILV_WRAP0_CONST(const char*, node, as_blank);

  142. +	LILV_WRAP0_CONST(bool,        node, is_literal);

  143. +	LILV_WRAP0_CONST(bool,        node, is_string);

  144. +	LILV_WRAP0_CONST(const char*, node, as_string);

  145. +	LILV_WRAP0_CONST(bool,        node, is_float);

  146. +	LILV_WRAP0_CONST(float,       node, as_float);

  147. +	LILV_WRAP0_CONST(bool,        node, is_int);

  148. +	LILV_WRAP0_CONST(int,         node, as_int);

  149. +	LILV_WRAP0_CONST(bool,        node, is_bool);

  150. +	LILV_WRAP0_CONST(bool,        node, as_bool);

  151. +

  152. +        Node& operator=(const Node& copy) {

  153. +                lilv_node_free(me);

  154. +                me = lilv_node_duplicate(copy.me);

  155. +                return *this;

  156. +        }

  157.  

  158.  	LilvNode* me;

  159.  };

  160. @@ -126,7 +138,7 @@ struct PluginClass {

  161.  	LILV_WRAP0(LilvIter*, prefix, begin); \

  162.  	LILV_WRAP1(LilvIter*, prefix, next, LilvIter*, i); \

  163.  	LILV_WRAP1(bool, prefix, is_end, LilvIter*, i); \

  164. -	const Lilv ## CT* me; \

  165. +	const Lilv ## CT* me

  166.  

  167.  struct PluginClasses {

  168.  	LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes);

  169. @@ -141,22 +153,24 @@ struct ScalePoints {

  170.  struct Nodes {

  171.  	LILV_WRAP_COLL(Nodes, Node, nodes);

  172.  	LILV_WRAP1(bool, nodes, contains, const Node, node);

  173. -	LILV_WRAP0(Node, nodes, get_first);

  174. +

  175. +        inline Node get_first() const {

  176. +              return Node((const LilvNode*)lilv_nodes_get_first(me));

  177. +        }

  178.  };

  179.  

  180.  struct UI {

  181.  	inline UI(const LilvUI* c_obj) : me(c_obj) {}

  182.  	LILV_WRAP_CONVERSION(const LilvUI);

  183.  

  184. -	LILV_WRAP0(const LilvNode*, ui, get_uri);

  185. -	LILV_WRAP0(const LilvNode*, ui, get_bundle_uri);

  186. -	LILV_WRAP0(const LilvNode*, ui, get_binary_uri);

  187. -	LILV_WRAP0(const LilvNodes*, ui, get_classes);

  188. -	/*LILV_WRAP3(bool, ui, is_supported,

  189. -	           LilvUISupportedFunc, supported_func,

  190. -	           const LilvNode*,     container_type,

  191. -	           const LilvNode**,    ui_type);*/

  192. -	LILV_WRAP1(bool, ui, is_a, const LilvNode*, class_uri);

  193. +        LILV_WRAP0(Node,  ui, get_uri);

  194. +        LILV_WRAP1(bool,  ui, is_a, LilvNode*, ui_class);

  195. +        LILV_WRAP0(Node,  ui, get_bundle_uri);

  196. +        LILV_WRAP0(Node,  ui, get_binary_uri);

  197. +        LILV_WRAP0(Nodes, ui, get_supported_features);

  198. +        LILV_WRAP0(Nodes, ui, get_required_features);

  199. +        LILV_WRAP0(Nodes, ui, get_optional_features);

  200. +        LILV_WRAP0(Nodes, ui, get_extension_data);

  201.  

  202.  	const LilvUI* me;

  203.  };

  204. @@ -258,16 +272,14 @@ struct Plugins {

  205.  struct Instance {

  206.  	inline Instance(LilvInstance* instance) : me(instance) {}

  207.  

  208. -	LILV_DEPRECATED

  209. -	inline Instance(Plugin plugin, double sample_rate) {

  210. -		me = lilv_plugin_instantiate(plugin, sample_rate, NULL);

  211. -	}

  212. +        LILV_DEPRECATED

  213. +        inline Instance(Plugin plugin, double sample_rate)

  214. +                : me(lilv_plugin_instantiate(plugin, sample_rate, NULL)) {}

  215.  

  216. -	LILV_DEPRECATED inline Instance(Plugin              plugin,

  217. -	                                double              sample_rate,

  218. -	                                LV2_Feature* const* features) {

  219. -		me = lilv_plugin_instantiate(plugin, sample_rate, features);

  220. -	}

  221. +        LILV_DEPRECATED inline Instance(Plugin              plugin,

  222. +                                        double              sample_rate,

  223. +                                        LV2_Feature* const* features)

  224. +                : me(lilv_plugin_instantiate(plugin, sample_rate, features)) {}

  225.  

  226.  	static inline Instance* create(Plugin              plugin,

  227.  	                               double              sample_rate,

  228. @@ -304,22 +316,22 @@ struct Instance {

  229.  };

  230.  

  231.  struct World {

  232. -	inline World() : me(lilv_world_new()) {}

  233. -	inline ~World() { lilv_world_free(me); }

  234. +	inline          World() : me(lilv_world_new()) {}

  235. +	inline virtual ~World() { lilv_world_free(me); }

  236.  

  237. -	inline LilvNode* new_uri(const char* uri) {

  238. +	inline LilvNode* new_uri(const char* uri) const {

  239.  		return lilv_new_uri(me, uri);

  240.  	}

  241. -	inline LilvNode* new_string(const char* str) {

  242. +	inline LilvNode* new_string(const char* str) const {

  243.  		return lilv_new_string(me, str);

  244.  	}

  245. -	inline LilvNode* new_int(int val) {

  246. +	inline LilvNode* new_int(int val) const {

  247.  		return lilv_new_int(me, val);

  248.  	}

  249. -	inline LilvNode* new_float(float val) {

  250. +	inline LilvNode* new_float(float val) const {

  251.  		return lilv_new_float(me, val);

  252.  	}

  253. -	inline LilvNode* new_bool(bool val) {

  254. +	inline LilvNode* new_bool(bool val) const {

  255.  		return lilv_new_bool(me, val);

  256.  	}

  257.  	inline Nodes find_nodes(const LilvNode* subject,

  258. @@ -337,6 +349,8 @@ struct World {

  259.  	LILV_WRAP1(int, world, load_resource, const LilvNode*, resource);

  260.  

  261.  	LilvWorld* me;

  262. +

  263. +        CARLA_DECLARE_NON_COPY_STRUCT(World)

  264.  };

  265.  

  266.  } /* namespace Lilv */

  267. diff --git a/source/modules/lilv/lilv-0.20.0/src/lilv_internal.h b/source/modules/lilv/lilv-0.20.0/src/lilv_internal.h

  268. index ed2c13a..8d30b39 100644

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

  270. +++ b/source/modules/lilv/lilv-0.20.0/src/lilv_internal.h

  271. @@ -50,7 +50,7 @@ static inline char* dlerror(void) { return "Unknown error"; }

  272.  #include "lilv/lilv.h"

  273.  

  274.  #ifdef LILV_DYN_MANIFEST

  275. -#    include "lv2/lv2plug.in/ns/ext/dynmanifest/dynmanifest.h"

  276. +#    include "lv2/dynmanifest.h"

  277.  #endif

  278.  

  279.  /*

  280. diff --git a/source/modules/lilv/lilv-0.20.0/src/plugin.c b/source/modules/lilv/lilv-0.20.0/src/plugin.c

  281. index 9c966b6..7bd6e60 100644

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

  283. +++ b/source/modules/lilv/lilv-0.20.0/src/plugin.c

  284. @@ -27,7 +27,7 @@

  285.  #include "lilv_config.h"

  286.  #include "lilv_internal.h"

  287.  

  288. -#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"

  289. +#include "lv2/ui.h"

  290.  

  291.  #define NS_DOAP (const uint8_t*)"http://usefulinc.com/ns/doap#"

  292.  #define NS_FOAF (const uint8_t*)"http://xmlns.com/foaf/0.1/"

  293. diff --git a/source/modules/lilv/lilv-0.20.0/src/port.c b/source/modules/lilv/lilv-0.20.0/src/port.c

  294. index 6bf8fc7..0a50891 100644

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

  296. +++ b/source/modules/lilv/lilv-0.20.0/src/port.c

  297. @@ -20,8 +20,8 @@

  298.  #include <stdlib.h>

  299.  #include <string.h>

  300.  

  301. -#include "lv2/lv2plug.in/ns/ext/atom/atom.h"

  302. -#include "lv2/lv2plug.in/ns/ext/event/event.h"

  303. +#include "lv2/atom.h"

  304. +#include "lv2/event.h"

  305.  

  306.  #include "lilv_internal.h"

  307.  

  308. diff --git a/source/modules/lilv/lilv-0.20.0/src/state.c b/source/modules/lilv/lilv-0.20.0/src/state.c

  309. index 68d48f1..fa54484 100644

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

  311. +++ b/source/modules/lilv/lilv-0.20.0/src/state.c

  312. @@ -18,10 +18,10 @@

  313.  #include <stdio.h>

  314.  #include <string.h>

  315.  

  316. -#include "lv2/lv2plug.in/ns/ext/atom/atom.h"

  317. -#include "lv2/lv2plug.in/ns/ext/atom/forge.h"

  318. -#include "lv2/lv2plug.in/ns/ext/presets/presets.h"

  319. -#include "lv2/lv2plug.in/ns/ext/state/state.h"

  320. +#include "lv2/atom.h"

  321. +#include "lv2/atom-forge.h"

  322. +#include "lv2/presets.h"

  323. +#include "lv2/state.h"

  324.  

  325.  #include "lilv_config.h"

  326.  #include "lilv_internal.h"

  327. @@ -397,30 +397,18 @@ lilv_state_new_from_instance(const LilvPlugin*          plugin,

  328.  

  329.  LILV_API void

  330.  lilv_state_restore(const LilvState*           state,

  331. -                   LilvInstance*              instance,

  332. +                   const LV2_State_Interface* iface,

  333. +                   LV2_Handle                 handle,

  334.                     LilvSetPortValueFunc       set_value,

  335.                     void*                      user_data,

  336.                     uint32_t                   flags,

  337.                     const LV2_Feature *const * features)

  338.  {

  339. -	LV2_State_Map_Path map_path = {

  340. -		(LilvState*)state, abstract_path, absolute_path };

  341. -	LV2_Feature map_feature = { LV2_STATE__mapPath, &map_path };

  342. -

  343. -	const LV2_Feature** sfeatures = add_features(features, &map_feature, NULL);

  344. -

  345. -	const LV2_Descriptor*      desc  = instance ? instance->lv2_descriptor : NULL;

  346. -	const LV2_State_Interface* iface = (desc && desc->extension_data)

  347. -		? (const LV2_State_Interface*)desc->extension_data(LV2_STATE__interface)

  348. -		: NULL;

  349. -

  350.  	if (iface) {

  351. -		iface->restore(instance->lv2_handle, retrieve_callback,

  352. -		               (LV2_State_Handle)state, flags, sfeatures);

  353. +		iface->restore(handle, retrieve_callback,

  354. +		               (LV2_State_Handle)state, flags, features);

  355.  	}

  356.  

  357. -	free(sfeatures);

  358. -

  359.  	if (set_value) {

  360.  		for (uint32_t i = 0; i < state->num_values; ++i) {

  361.  			const PortValue* val = &state->values[i];

  362. @@ -571,9 +559,9 @@ new_state_from_model(LilvWorld*       world,

  363.  }

  364.  

  365.  LILV_API LilvState*

  366. -lilv_state_new_from_world(LilvWorld*      world,

  367. -                          LV2_URID_Map*   map,

  368. -                          const LilvNode* node)

  369. +lilv_state_new_from_world(LilvWorld*          world,

  370. +                          const LV2_URID_Map* map,

  371. +                          const LilvNode*     node)

  372.  {

  373.  	if (!lilv_node_is_uri(node) && !lilv_node_is_blank(node)) {

  374.  		LILV_ERRORF("Subject `%s' is not a URI or blank node.\n",

  375. @@ -588,10 +576,10 @@ lilv_state_new_from_world(LilvWorld*      world,

  376.  }

  377.  

  378.  LILV_API LilvState*

  379. -lilv_state_new_from_file(LilvWorld*      world,

  380. -                         LV2_URID_Map*   map,

  381. -                         const LilvNode* subject,

  382. -                         const char*     path)

  383. +lilv_state_new_from_file(LilvWorld*          world,

  384. +                         const LV2_URID_Map* map,

  385. +                         const LilvNode*     subject,

  386. +                         const char*         path)

  387.  {

  388.  	if (subject && !lilv_node_is_uri(subject)

  389.  	    && !lilv_node_is_blank(subject)) {

  390. @@ -641,9 +629,9 @@ set_prefixes(SerdEnv* env)

  391.  }

  392.  

  393.  LILV_API LilvState*

  394. -lilv_state_new_from_string(LilvWorld*    world,

  395. -                           LV2_URID_Map* map,

  396. -                           const char*   str)

  397. +lilv_state_new_from_string(LilvWorld*          world,

  398. +                           const LV2_URID_Map* map,

  399. +                           const char*         str)

  400.  {

  401.  	if (!str) {

  402.  		return NULL;

  403. diff --git a/source/modules/lilv/lilv-0.20.0/src/ui.c b/source/modules/lilv/lilv-0.20.0/src/ui.c

  404. index 0f4f2f6..a3e17da 100644

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

  406. +++ b/source/modules/lilv/lilv-0.20.0/src/ui.c

  407. @@ -109,3 +109,54 @@ lilv_ui_get_binary_uri(const LilvUI* ui)

  408.  {

  409.  	return ui->binary_uri;

  410.  }

  411. +

  412. +static LilvNodes*

  413. +lilv_ui_get_value_internal(const LilvUI* ui, const SordNode* predicate)

  414. +{

  415. +       assert(ui);

  416. +       return lilv_world_find_nodes_internal(ui->world, ui->uri->node, predicate, NULL);

  417. +}

  418. +

  419. +LILV_API const LilvNodes*

  420. +lilv_ui_get_supported_features(const LilvUI* ui)

  421. +{

  422. +       assert(ui);

  423. +       LilvNodes* optional = lilv_ui_get_optional_features(ui);

  424. +       LilvNodes* required = lilv_ui_get_required_features(ui);

  425. +       LilvNodes* result   = lilv_nodes_new();

  426. +

  427. +       LILV_FOREACH(nodes, i, optional)

  428. +               zix_tree_insert((ZixTree*)result, lilv_node_duplicate(lilv_nodes_get(optional, i)), NULL);

  429. +

  430. +       LILV_FOREACH(nodes, i, required)

  431. +               zix_tree_insert((ZixTree*)result, lilv_node_duplicate(lilv_nodes_get(required, i)), NULL);

  432. +

  433. +       lilv_nodes_free(optional);

  434. +       lilv_nodes_free(required);

  435. +

  436. +       return result;

  437. +}

  438. +

  439. +LILV_API const LilvNodes*

  440. +lilv_ui_get_required_features(const LilvUI* ui)

  441. +{

  442. +       assert(ui);

  443. +       assert(ui->world);

  444. +       return lilv_ui_get_value_internal(ui, ui->world->uris.lv2_requiredFeature);

  445. +}

  446. +

  447. +LILV_API const LilvNodes*

  448. +lilv_ui_get_optional_features(const LilvUI* ui)

  449. +{

  450. +       assert(ui);

  451. +       assert(ui->world);

  452. +       return lilv_ui_get_value_internal(ui, ui->world->uris.lv2_optionalFeature);

  453. +}

  454. +

  455. +LILV_API const LilvNodes*

  456. +lilv_ui_get_extension_data(const LilvUI* ui)

  457. +{

  458. +       assert(ui);

  459. +       assert(ui->world);

  460. +       return lilv_ui_get_value_internal(ui, ui->world->uris.lv2_extensionData);

  461. +}

  462. diff --git a/source/modules/lilv/lilv-0.20.0/src/util.c b/source/modules/lilv/lilv-0.20.0/src/util.c

  463. index f1c9c1c..7ca7ca0 100644

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

  465. +++ b/source/modules/lilv/lilv-0.20.0/src/util.c

  466. @@ -29,7 +29,6 @@

  467.  #include <string.h>

  468.  

  469.  #ifdef _WIN32

  470. -#    define _WIN32_WINNT 0x0600  /* for CreateSymbolicLink */

  471.  #    include <windows.h>

  472.  #    include <direct.h>

  473.  #    include <io.h>

  474. @@ -426,7 +425,7 @@ lilv_symlink(const char* oldpath, const char* newpath)

  475.  	int ret = 0;

  476.  	if (strcmp(oldpath, newpath)) {

  477.  #ifdef _WIN32

  478. -		ret = !CreateSymbolicLink(newpath, oldpath, 0);

  479. +		ret = 0;

  480.  #else

  481.  		ret = symlink(oldpath, newpath);

  482.  #endif

  483. diff --git a/source/modules/lilv/lilv-0.20.0/src/world.c b/source/modules/lilv/lilv-0.20.0/src/world.c

  484. index 41fe16f..76db7fc 100644

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

  486. +++ b/source/modules/lilv/lilv-0.20.0/src/world.c

  487. @@ -19,7 +19,7 @@

  488.  #include <stdlib.h>

  489.  #include <string.h>

  490.  

  491. -#include "lv2/lv2plug.in/ns/ext/presets/presets.h"

  492. +#include "lv2/presets.h"

  493.  

  494.  #include "lilv_internal.h"

  495.  

  496. diff --git a/source/modules/lilv/sratom-0.4.6/sratom/sratom.h b/source/modules/lilv/sratom-0.4.6/sratom/sratom.h

  497. index bb1af95..67855d5 100644

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

  499. +++ b/source/modules/lilv/sratom-0.4.6/sratom/sratom.h

  500. @@ -23,9 +23,9 @@

  501.  

  502.  #include <stdint.h>

  503.  

  504. -#include "lv2/lv2plug.in/ns/ext/urid/urid.h"

  505. -#include "lv2/lv2plug.in/ns/ext/atom/atom.h"

  506. -#include "lv2/lv2plug.in/ns/ext/atom/forge.h"

  507. +#include "lv2/atom.h"

  508. +#include "lv2/atom-forge.h"

  509. +#include "lv2/urid.h"

  510.  #include "serd/serd.h"

  511.  #include "sord/sord.h"

  512.  

  513. diff --git a/source/modules/lilv/sratom-0.4.6/src/sratom.c b/source/modules/lilv/sratom-0.4.6/src/sratom.c

  514. index 4d8add7..555bbda 100644

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

  516. +++ b/source/modules/lilv/sratom-0.4.6/src/sratom.c

  517. @@ -22,9 +22,9 @@

  518.  #include <stdlib.h>

  519.  #include <string.h>

  520.  

  521. -#include "lv2/lv2plug.in/ns/ext/atom/forge.h"

  522. -#include "lv2/lv2plug.in/ns/ext/atom/util.h"

  523. -#include "lv2/lv2plug.in/ns/ext/midi/midi.h"

  524. +#include "lv2/atom-forge.h"

  525. +#include "lv2/atom-util.h"

  526. +#include "lv2/midi.h"

  527.  

  528.  #include "sratom/sratom.h"

  529.