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.
3062 Commits
17 Branches
940MB
Tree: e02ad95380
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e02ad95380'
${ noResults }
Carla/source/modules/lilv/custom-patches.diff

741 lines
25KB
Raw Blame History 

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

  2. index e907789..84223c5 100644

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

  4. +++ b/source/modules/lilv/lilv-0.21.3/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. @@ -552,7 +553,7 @@ lilv_world_free(LilvWorld* world);

  18.     with special plugin bundles which are installed to a known location).

  19.  */

  20.  LILV_API void

  21. -lilv_world_load_all(LilvWorld* world);

  22. +lilv_world_load_all(LilvWorld* world, const char* lv2_path);

  23.  

  24.  /**

  25.     Load a specific bundle.

  26. @@ -1199,9 +1200,9 @@ lilv_port_get_scale_points(const LilvPlugin* plugin,

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

  28.  */

  29.  LILV_API LilvState*

  30. -lilv_state_new_from_world(LilvWorld*      world,

  31. -                          LV2_URID_Map*   map,

  32. -                          const LilvNode* subject);

  33. +lilv_state_new_from_world(LilvWorld*          world,

  34. +                          const LV2_URID_Map* map,

  35. +                          const LilvNode*     subject);

  36.  

  37.  /**

  38.     Load a state snapshot from a file.

  39. @@ -1219,18 +1220,18 @@ lilv_state_new_from_world(LilvWorld*      world,

  40.     new memory consumed once this function returns.

  41.  */

  42.  LILV_API LilvState*

  43. -lilv_state_new_from_file(LilvWorld*      world,

  44. -                         LV2_URID_Map*   map,

  45. -                         const LilvNode* subject,

  46. -                         const char*     path);

  47. +lilv_state_new_from_file(LilvWorld*          world,

  48. +                         const LV2_URID_Map* map,

  49. +                         const LilvNode*     subject,

  50. +                         const char*         path);

  51.  

  52.  /**

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

  54.  */

  55.  LILV_API LilvState*

  56. -lilv_state_new_from_string(LilvWorld*    world,

  57. -                           LV2_URID_Map* map,

  58. -                           const char*   str);

  59. +lilv_state_new_from_string(LilvWorld*          world,

  60. +                           const LV2_URID_Map* map,

  61. +                           const char*         str);

  62.  

  63.  /**

  64.     Function to get a port value.

  65. @@ -1425,7 +1426,8 @@ lilv_state_emit_port_values(const LilvState*     state,

  66.  */

  67.  LILV_API void

  68.  lilv_state_restore(const LilvState*           state,

  69. -                   LilvInstance*              instance,

  70. +                   const LV2_State_Interface* iface,

  71. +                   LV2_Handle                 handle,

  72.                     LilvSetPortValueFunc       set_value,

  73.                     void*                      user_data,

  74.                     uint32_t                   flags,

  75. @@ -1786,6 +1788,42 @@ LILV_API const LilvNode*

  76.  lilv_ui_get_binary_uri(const LilvUI* ui);

  77.  

  78.  /**

  79. +  Custom calls

  80. +*/

  81. +LILV_API LilvNode*

  82. +lilv_plugin_get_modgui_resources_directory(const LilvPlugin* plugin);

  83. +

  84. +LILV_API LilvNode*

  85. +lilv_plugin_get_modgui_stylesheet(const LilvPlugin* plugin);

  86. +

  87. +LILV_API LilvNode*

  88. +lilv_plugin_get_modgui_icon_template(const LilvPlugin* plugin);

  89. +

  90. +LILV_API LilvNode*

  91. +lilv_plugin_get_modgui_settings_template(const LilvPlugin* plugin);

  92. +

  93. +LILV_API LilvNode*

  94. +lilv_plugin_get_modgui_template_data(const LilvPlugin* plugin);

  95. +

  96. +LILV_API LilvNode*

  97. +lilv_plugin_get_modgui_screenshot(const LilvPlugin* plugin);

  98. +

  99. +LILV_API LilvNode*

  100. +lilv_plugin_get_modgui_thumbnail(const LilvPlugin* plugin);

  101. +

  102. +LILV_API const LilvNodes*

  103. +lilv_ui_get_supported_features(const LilvUI* ui);

  104. +

  105. +LILV_API const LilvNodes*

  106. +lilv_ui_get_required_features(const LilvUI* ui);

  107. +

  108. +LILV_API const LilvNodes*

  109. +lilv_ui_get_optional_features(const LilvUI* ui);

  110. +

  111. +LILV_API const LilvNodes*

  112. +lilv_ui_get_extension_data(const LilvUI* ui);

  113. +

  114. +/**

  115.     @}

  116.     @}

  117.  */

  118. diff --git a/source/modules/lilv/lilv-0.21.3/lilv/lilvmm.hpp b/source/modules/lilv/lilv-0.21.3/lilv/lilvmm.hpp

  119. index b9b3a69..367b8d8 100644

  120. --- a/source/modules/lilv/lilv-0.21.3/lilv/lilvmm.hpp

  121. +++ b/source/modules/lilv/lilv-0.21.3/lilv/lilvmm.hpp

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

  123.  #ifndef LILV_LILVMM_HPP

  124.  #define LILV_LILVMM_HPP

  125.  

  126. +#include "CarlaDefines.h"

  127. +

  128.  #include "lilv/lilv.h"

  129.  

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

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

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

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

  134.  

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

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

  137. +

  138.  #define LILV_WRAP0_VOID(prefix, name) \

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

  140.  

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

  142.  #endif

  143.  

  144.  struct Node {

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

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

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

  148.  

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

  150.  

  151.  	LILV_WRAP_CONVERSION(LilvNode);

  152.  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  181. +

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

  183. +		lilv_node_free(me);

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

  185. +		return *this;

  186. +	}

  187.  

  188.  	LilvNode* me;

  189.  };

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

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

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

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

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

  195. +	const Lilv ## CT* me

  196.  

  197.  struct PluginClasses {

  198.  	LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes);

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

  200.  struct Nodes {

  201.  	LILV_WRAP_COLL(Nodes, Node, nodes);

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

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

  204. +

  205. +	inline Node get_first() const {

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

  207. +	}

  208.  };

  209.  

  210.  struct UI {

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

  212.  	LILV_WRAP_CONVERSION(const LilvUI);

  213.  

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

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

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

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

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

  219. -	           LilvUISupportedFunc, supported_func,

  220. -	           const LilvNode*,     container_type,

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

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

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

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

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

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

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

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

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

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

  231.  

  232.  	const LilvUI* me;

  233.  };

  234. @@ -220,6 +234,13 @@ struct Plugin {

  235.  	LILV_WRAP0(Nodes,       plugin, get_extension_data);

  236.  	LILV_WRAP0(UIs,         plugin, get_uis);

  237.  	LILV_WRAP1(Nodes,       plugin, get_related, Node, type);

  238. +	LILV_WRAP0(Node,        plugin, get_modgui_resources_directory);

  239. +	LILV_WRAP0(Node,        plugin, get_modgui_stylesheet);

  240. +	LILV_WRAP0(Node,        plugin, get_modgui_icon_template);

  241. +	LILV_WRAP0(Node,        plugin, get_modgui_settings_template);

  242. +	LILV_WRAP0(Node,        plugin, get_modgui_template_data);

  243. +	LILV_WRAP0(Node,        plugin, get_modgui_screenshot);

  244. +	LILV_WRAP0(Node,        plugin, get_modgui_thumbnail);

  245.  

  246.  	inline Port get_port_by_index(unsigned index) {

  247.  		return Port(me, lilv_plugin_get_port_by_index(me, index));

  248. @@ -258,16 +279,14 @@ struct Plugins {

  249.  struct Instance {

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

  251.  

  252. -	LILV_DEPRECATED

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

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

  255. -	}

  256. +	LILV_DEPRECATED

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

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

  259.  

  260. -	LILV_DEPRECATED inline Instance(Plugin              plugin,

  261. -	                                double              sample_rate,

  262. -	                                LV2_Feature* const* features) {

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

  264. -	}

  265. +	LILV_DEPRECATED inline Instance(Plugin              plugin,

  266. +	                                double              sample_rate,

  267. +	                                LV2_Feature* const* features)

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

  269.  

  270.  	static inline Instance* create(Plugin              plugin,

  271.  	                               double              sample_rate,

  272. @@ -304,22 +323,22 @@ struct Instance {

  273.  };

  274.  

  275.  struct World {

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

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

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

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

  280.  

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

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

  283.  		return lilv_new_uri(me, uri);

  284.  	}

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

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

  287.  		return lilv_new_string(me, str);

  288.  	}

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

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

  291.  		return lilv_new_int(me, val);

  292.  	}

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

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

  295.  		return lilv_new_float(me, val);

  296.  	}

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

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

  299.  		return lilv_new_bool(me, val);

  300.  	}

  301.  	inline Nodes find_nodes(const LilvNode* subject,

  302. @@ -329,7 +348,7 @@ struct World {

  303.  	}

  304.  

  305.  	LILV_WRAP2_VOID(world, set_option, const char*, uri, LilvNode*, value);

  306. -	LILV_WRAP0_VOID(world, load_all);

  307. +	LILV_WRAP1_VOID(world, load_all, const char*, lv2_path);

  308.  	LILV_WRAP1_VOID(world, load_bundle, LilvNode*, bundle_uri);

  309.  	LILV_WRAP0(const LilvPluginClass*, world, get_plugin_class);

  310.  	LILV_WRAP0(const LilvPluginClasses*, world, get_plugin_classes);

  311. @@ -337,6 +356,8 @@ struct World {

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

  313.  

  314.  	LilvWorld* me;

  315. +

  316. +	CARLA_DECLARE_NON_COPY_STRUCT(World)

  317.  };

  318.  

  319.  } /* namespace Lilv */

  320. diff --git a/source/modules/lilv/lilv-0.21.3/src/lilv_internal.h b/source/modules/lilv/lilv-0.21.3/src/lilv_internal.h

  321. index e2444d3..4d0a8e5 100644

  322. --- a/source/modules/lilv/lilv-0.21.3/src/lilv_internal.h

  323. +++ b/source/modules/lilv/lilv-0.21.3/src/lilv_internal.h

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

  325.  #include "lilv/lilv.h"

  326.  

  327.  #ifdef LILV_DYN_MANIFEST

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

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

  330.  #endif

  331.  

  332.  /*

  333. diff --git a/source/modules/lilv/lilv-0.21.3/src/plugin.c b/source/modules/lilv/lilv-0.21.3/src/plugin.c

  334. index bf0843b..c711990 100644

  335. --- a/source/modules/lilv/lilv-0.21.3/src/plugin.c

  336. +++ b/source/modules/lilv/lilv-0.21.3/src/plugin.c

  337. @@ -27,10 +27,11 @@

  338.  #include "lilv_config.h"

  339.  #include "lilv_internal.h"

  340.  

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

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

  343.  

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

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

  346. +#define NS_MOD  (const uint8_t*)"http://portalmod.com/ns/modgui#"

  347.  

  348.  /** Ownership of `uri` is taken */

  349.  LilvPlugin*

  350. @@ -908,6 +909,131 @@ lilv_plugin_get_author_homepage(const LilvPlugin* plugin)

  351.  	return NULL;

  352.  }

  353.  

  354. +static const SordNode*

  355. +lilv_plugin_get_modgui(const LilvPlugin* p)

  356. +{

  357. +        lilv_plugin_load_if_necessary(p);

  358. +

  359. +        SordNode* mod_gui = sord_new_uri(

  360. +                p->world->world, NS_MOD "gui");

  361. +

  362. +        SordIter* gui = lilv_world_query_internal(

  363. +                p->world,

  364. +                p->plugin_uri->node,

  365. +                mod_gui,

  366. +                NULL);

  367. +

  368. +        sord_node_free(p->world->world, mod_gui);

  369. +

  370. +        if (sord_iter_end(gui)) {

  371. +                sord_iter_free(gui);

  372. +                return NULL;

  373. +        }

  374. +

  375. +        const SordNode* Gui = sord_iter_get_node(gui, SORD_OBJECT);

  376. +

  377. +        sord_iter_free(gui);

  378. +        return Gui;

  379. +}

  380. +

  381. +LILV_API LilvNode*

  382. +lilv_plugin_get_modgui_resources_directory(const LilvPlugin* plugin)

  383. +{

  384. +        const SordNode* modgui = lilv_plugin_get_modgui(plugin);

  385. +        if (modgui) {

  386. +                SordWorld* sworld     = plugin->world->world;

  387. +                SordNode*  modgui_res = sord_new_uri(sworld, NS_MOD "resourcesDirectory");

  388. +                LilvNode*  ret        = lilv_plugin_get_one(plugin, modgui, modgui_res);

  389. +                sord_node_free(sworld, modgui_res);

  390. +                return ret;

  391. +        }

  392. +        return NULL;

  393. +}

  394. +

  395. +LILV_API LilvNode*

  396. +lilv_plugin_get_modgui_stylesheet(const LilvPlugin* plugin)

  397. +{

  398. +        const SordNode* modgui = lilv_plugin_get_modgui(plugin);

  399. +        if (modgui) {

  400. +                SordWorld* sworld       = plugin->world->world;

  401. +                SordNode*  modgui_style = sord_new_uri(sworld, NS_MOD "stylesheet");

  402. +                LilvNode*  ret          = lilv_plugin_get_one(plugin, modgui, modgui_style);

  403. +                sord_node_free(sworld, modgui_style);

  404. +                return ret;

  405. +        }

  406. +        return NULL;

  407. +}

  408. +

  409. +LILV_API LilvNode*

  410. +lilv_plugin_get_modgui_icon_template(const LilvPlugin* plugin)

  411. +{

  412. +        const SordNode* modgui = lilv_plugin_get_modgui(plugin);

  413. +        if (modgui) {

  414. +                SordWorld* sworld      = plugin->world->world;

  415. +                SordNode*  modgui_tmpl = sord_new_uri(sworld, NS_MOD "iconTemplate");

  416. +                LilvNode*  ret         = lilv_plugin_get_one(plugin, modgui, modgui_tmpl);

  417. +                sord_node_free(sworld, modgui_tmpl);

  418. +                return ret;

  419. +        }

  420. +        return NULL;

  421. +}

  422. +

  423. +LILV_API LilvNode*

  424. +lilv_plugin_get_modgui_settings_template(const LilvPlugin* plugin)

  425. +{

  426. +        const SordNode* modgui = lilv_plugin_get_modgui(plugin);

  427. +        if (modgui) {

  428. +                SordWorld* sworld      = plugin->world->world;

  429. +                SordNode*  modgui_tmpl = sord_new_uri(sworld, NS_MOD "settingsTemplate");

  430. +                LilvNode*  ret         = lilv_plugin_get_one(plugin, modgui, modgui_tmpl);

  431. +                sord_node_free(sworld, modgui_tmpl);

  432. +                return ret;

  433. +        }

  434. +        return NULL;

  435. +}

  436. +

  437. +LILV_API LilvNode*

  438. +lilv_plugin_get_modgui_template_data(const LilvPlugin* plugin)

  439. +{

  440. +        const SordNode* modgui = lilv_plugin_get_modgui(plugin);

  441. +        if (modgui) {

  442. +                SordWorld* sworld      = plugin->world->world;

  443. +                SordNode*  modgui_tmpl = sord_new_uri(sworld, NS_MOD "templateData");

  444. +                LilvNode*  ret         = lilv_plugin_get_one(plugin, modgui, modgui_tmpl);

  445. +                sord_node_free(sworld, modgui_tmpl);

  446. +                return ret;

  447. +        }

  448. +        return NULL;

  449. +}

  450. +

  451. +LILV_API LilvNode*

  452. +lilv_plugin_get_modgui_screenshot(const LilvPlugin* plugin)

  453. +{

  454. +        const SordNode* modgui = lilv_plugin_get_modgui(plugin);

  455. +        if (modgui) {

  456. +                SordWorld* sworld     = plugin->world->world;

  457. +                SordNode*  modgui_scr = sord_new_uri(sworld, NS_MOD "screenshot");

  458. +                LilvNode*  ret        = lilv_plugin_get_one(plugin, modgui, modgui_scr);

  459. +                sord_node_free(sworld, modgui_scr);

  460. +                return ret;

  461. +        }

  462. +        return NULL;

  463. +}

  464. +

  465. +LILV_API LilvNode*

  466. +lilv_plugin_get_modgui_thumbnail(const LilvPlugin* plugin)

  467. +{

  468. +        const SordNode* modgui = lilv_plugin_get_modgui(plugin);

  469. +        if (modgui) {

  470. +                SordWorld* sworld       = plugin->world->world;

  471. +                SordNode*  modgui_thumb = sord_new_uri(sworld, NS_MOD "thumbnail");

  472. +                LilvNode*  ret          = lilv_plugin_get_one(plugin, modgui, modgui_thumb);

  473. +                sord_node_free(sworld, modgui_thumb);

  474. +                return ret;

  475. +        }

  476. +        return NULL;

  477. +}

  478. +

  479.  LILV_API bool

  480.  lilv_plugin_is_replaced(const LilvPlugin* plugin)

  481.  {

  482. diff --git a/source/modules/lilv/lilv-0.21.3/src/port.c b/source/modules/lilv/lilv-0.21.3/src/port.c

  483. index 6bf8fc7..0a50891 100644

  484. --- a/source/modules/lilv/lilv-0.21.3/src/port.c

  485. +++ b/source/modules/lilv/lilv-0.21.3/src/port.c

  486. @@ -20,8 +20,8 @@

  487.  #include <stdlib.h>

  488.  #include <string.h>

  489.  

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

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

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

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

  494.  

  495.  #include "lilv_internal.h"

  496.  

  497. diff --git a/source/modules/lilv/lilv-0.21.3/src/state.c b/source/modules/lilv/lilv-0.21.3/src/state.c

  498. index 79199e4..119dcee 100644

  499. --- a/source/modules/lilv/lilv-0.21.3/src/state.c

  500. +++ b/source/modules/lilv/lilv-0.21.3/src/state.c

  501. @@ -18,10 +18,10 @@

  502.  #include <stdio.h>

  503.  #include <string.h>

  504.  

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

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

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

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

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

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

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

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

  513.  

  514.  #include "lilv_config.h"

  515.  #include "lilv_internal.h"

  516. @@ -411,35 +411,18 @@ lilv_state_emit_port_values(const LilvState*     state,

  517.  

  518.  LILV_API void

  519.  lilv_state_restore(const LilvState*           state,

  520. -                   LilvInstance*              instance,

  521. +                   const LV2_State_Interface* iface,

  522. +                   LV2_Handle                 handle,

  523.                     LilvSetPortValueFunc       set_value,

  524.                     void*                      user_data,

  525.                     uint32_t                   flags,

  526.                     const LV2_Feature *const * features)

  527.  {

  528. -	if (!state) {

  529. -		LILV_ERROR("lilv_state_restore() called on NULL state\n");

  530. -		return;

  531. -	}

  532. -

  533. -	LV2_State_Map_Path map_path = {

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

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

  536. -

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

  538. -

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

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

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

  542. -		: NULL;

  543. -

  544.  	if (iface) {

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

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

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

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

  549.  	}

  550.  

  551. -	free(sfeatures);

  552. -

  553.  	if (set_value) {

  554.  		lilv_state_emit_port_values(state, set_value, user_data);

  555.  	}

  556. @@ -586,9 +569,9 @@ new_state_from_model(LilvWorld*       world,

  557.  }

  558.  

  559.  LILV_API LilvState*

  560. -lilv_state_new_from_world(LilvWorld*      world,

  561. -                          LV2_URID_Map*   map,

  562. -                          const LilvNode* node)

  563. +lilv_state_new_from_world(LilvWorld*          world,

  564. +                          const LV2_URID_Map* map,

  565. +                          const LilvNode*     node)

  566.  {

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

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

  569. @@ -600,10 +583,10 @@ lilv_state_new_from_world(LilvWorld*      world,

  570.  }

  571.  

  572.  LILV_API LilvState*

  573. -lilv_state_new_from_file(LilvWorld*      world,

  574. -                         LV2_URID_Map*   map,

  575. -                         const LilvNode* subject,

  576. -                         const char*     path)

  577. +lilv_state_new_from_file(LilvWorld*          world,

  578. +                         const LV2_URID_Map* map,

  579. +                         const LilvNode*     subject,

  580. +                         const char*         path)

  581.  {

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

  583.  	    && !lilv_node_is_blank(subject)) {

  584. @@ -653,9 +636,9 @@ set_prefixes(SerdEnv* env)

  585.  }

  586.  

  587.  LILV_API LilvState*

  588. -lilv_state_new_from_string(LilvWorld*    world,

  589. -                           LV2_URID_Map* map,

  590. -                           const char*   str)

  591. +lilv_state_new_from_string(LilvWorld*          world,

  592. +                           const LV2_URID_Map* map,

  593. +                           const char*         str)

  594.  {

  595.  	if (!str) {

  596.  		return NULL;

  597. diff --git a/source/modules/lilv/lilv-0.21.3/src/ui.c b/source/modules/lilv/lilv-0.21.3/src/ui.c

  598. index 0f4f2f6..a0dd567 100644

  599. --- a/source/modules/lilv/lilv-0.21.3/src/ui.c

  600. +++ b/source/modules/lilv/lilv-0.21.3/src/ui.c

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

  602.  {

  603.  	return ui->binary_uri;

  604.  }

  605. +

  606. +static LilvNodes*

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

  608. +{

  609. +       assert(ui);

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

  611. +}

  612. +

  613. +LILV_API const LilvNodes*

  614. +lilv_ui_get_supported_features(const LilvUI* ui)

  615. +{

  616. +       assert(ui);

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

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

  619. +       LilvNodes* result   = lilv_nodes_new();

  620. +

  621. +       LILV_FOREACH(nodes, i, optional)

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

  623. +

  624. +       LILV_FOREACH(nodes, i, required)

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

  626. +

  627. +       lilv_nodes_free(optional);

  628. +       lilv_nodes_free(required);

  629. +

  630. +       return result;

  631. +}

  632. +

  633. +LILV_API const LilvNodes*

  634. +lilv_ui_get_required_features(const LilvUI* ui)

  635. +{

  636. +       assert(ui);

  637. +       assert(ui->world);

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

  639. +}

  640. +

  641. +LILV_API const LilvNodes*

  642. +lilv_ui_get_optional_features(const LilvUI* ui)

  643. +{

  644. +       assert(ui);

  645. +       assert(ui->world);

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

  647. +}

  648. +

  649. +LILV_API const LilvNodes*

  650. +lilv_ui_get_extension_data(const LilvUI* ui)

  651. +{

  652. +       assert(ui);

  653. +       assert(ui->world);

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

  655. +}

  656. diff --git a/source/modules/lilv/lilv-0.21.3/src/util.c b/source/modules/lilv/lilv-0.21.3/src/util.c

  657. index 31c9238..5bcdb7e 100644

  658. --- a/source/modules/lilv/lilv-0.21.3/src/util.c

  659. +++ b/source/modules/lilv/lilv-0.21.3/src/util.c

  660. @@ -30,7 +30,6 @@

  661.  #include <string.h>

  662.  

  663.  #ifdef _WIN32

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

  665.  #    include <windows.h>

  666.  #    include <direct.h>

  667.  #    include <io.h>

  668. @@ -446,10 +445,7 @@ lilv_symlink(const char* oldpath, const char* newpath)

  669.  	int ret = 0;

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

  671.  #ifdef _WIN32

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

  673. -		if (ret) {

  674. -			ret = !CreateHardLink(newpath, oldpath, 0);

  675. -		}

  676. +		ret = 1;

  677.  #else

  678.  		ret = symlink(oldpath, newpath);

  679.  #endif

  680. diff --git a/source/modules/lilv/lilv-0.21.3/src/world.c b/source/modules/lilv/lilv-0.21.3/src/world.c

  681. index 02dbeec..8b2db95 100644

  682. --- a/source/modules/lilv/lilv-0.21.3/src/world.c

  683. +++ b/source/modules/lilv/lilv-0.21.3/src/world.c

  684. @@ -19,7 +19,7 @@

  685.  #include <stdlib.h>

  686.  #include <string.h>

  687.  

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

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

  690.  

  691.  #include "lilv_internal.h"

  692.  

  693. @@ -797,12 +797,8 @@ lilv_world_load_plugin_classes(LilvWorld* world)

  694.  }

  695.  

  696.  LILV_API void

  697. -lilv_world_load_all(LilvWorld* world)

  698. +lilv_world_load_all(LilvWorld* world, const char* lv2_path)

  699.  {

  700. -	const char* lv2_path = getenv("LV2_PATH");

  701. -	if (!lv2_path)

  702. -		lv2_path = LILV_DEFAULT_LV2_PATH;

  703. -

  704.  	// Discover bundles and read all manifest files into model

  705.  	lilv_world_load_path(world, lv2_path);

  706.  

  707. diff --git a/source/modules/lilv/sratom-0.4.7/sratom/sratom.h b/source/modules/lilv/sratom-0.4.7/sratom/sratom.h

  708. index a86f67e..f0c12b9 100644

  709. --- a/source/modules/lilv/sratom-0.4.7/sratom/sratom.h

  710. +++ b/source/modules/lilv/sratom-0.4.7/sratom/sratom.h

  711. @@ -23,9 +23,9 @@

  712.  

  713.  #include <stdint.h>

  714.  

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

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

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

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

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

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

  721.  #include "serd/serd.h"

  722.  #include "sord/sord.h"

  723.  

  724. diff --git a/source/modules/lilv/sratom-0.4.7/src/sratom.c b/source/modules/lilv/sratom-0.4.7/src/sratom.c

  725. index 272e6e3..4f9d136 100644

  726. --- a/source/modules/lilv/sratom-0.4.7/src/sratom.c

  727. +++ b/source/modules/lilv/sratom-0.4.7/src/sratom.c

  728. @@ -20,9 +20,9 @@

  729.  #include <stdlib.h>

  730.  #include <string.h>

  731.  

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

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

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

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

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

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

  738.  

  739.  #include "sratom/sratom.h"

  740.