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.
6190 Commits
17 Branches
263MB
Tree: 2c0f941f5b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2c0f941f5b'
${ noResults }
Carla/source/modules/lilv/patches/lilv_custom-changes.patch

712 lines
23KB
Raw Blame History 

  1. diff --git a/lilv/lilv.h b/lilv/lilv.h

  2. index 37dd849..760f7b5 100644

  3. --- a/lilv/lilv.h

  4. +++ b/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. @@ -564,7 +565,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. @@ -1221,9 +1222,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. @@ -1241,18 +1242,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. @@ -1469,7 +1470,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. @@ -1830,6 +1832,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/lilv/lilvmm.hpp b/lilv/lilvmm.hpp

  119. index b9b3a69..1f67e81 100644

  120. --- a/lilv/lilvmm.hpp

  121. +++ b/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. @@ -27,14 +29,12 @@

  132.  

  133.  namespace Lilv {

  134.  

  135. -static inline const char*

  136. -uri_to_path(const char* uri) {

  137. -	return lilv_uri_to_path(uri);

  138. -}

  139. -

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

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

  142.  

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

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

  145. +

  146.  #define LILV_WRAP0_VOID(prefix, name) \

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

  148.  

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

  150.  #endif

  151.  

  152.  struct Node {

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

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

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

  156.  

  157. @@ -78,20 +79,26 @@ struct Node {

  158.  

  159.  	LILV_WRAP_CONVERSION(LilvNode);

  160.  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  189. +

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

  191. +		lilv_node_free(me);

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

  193. +		return *this;

  194. +	}

  195.  

  196.  	LilvNode* me;

  197.  };

  198. @@ -126,7 +133,7 @@ struct PluginClass {

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

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

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

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

  203. +	const Lilv ## CT* me

  204.  

  205.  struct PluginClasses {

  206.  	LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes);

  207. @@ -141,22 +148,24 @@ struct ScalePoints {

  208.  struct Nodes {

  209.  	LILV_WRAP_COLL(Nodes, Node, nodes);

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

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

  212. +

  213. +	inline Node get_first() const {

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

  215. +	}

  216.  };

  217.  

  218.  struct UI {

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

  220.  	LILV_WRAP_CONVERSION(const LilvUI);

  221.  

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

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

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

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

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

  227. -	           LilvUISupportedFunc, supported_func,

  228. -	           const LilvNode*,     container_type,

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

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

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

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

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

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

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

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

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

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

  239.  

  240.  	const LilvUI* me;

  241.  };

  242. @@ -220,6 +229,13 @@ struct Plugin {

  243.  	LILV_WRAP0(Nodes,       plugin, get_extension_data);

  244.  	LILV_WRAP0(UIs,         plugin, get_uis);

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

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

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

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

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

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

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

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

  253.  

  254.  	inline Port get_port_by_index(unsigned index) {

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

  256. @@ -259,15 +275,13 @@ struct Instance {

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

  258.  

  259.  	LILV_DEPRECATED

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

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

  262. -	}

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

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

  265.  

  266.  	LILV_DEPRECATED inline Instance(Plugin              plugin,

  267.  	                                double              sample_rate,

  268. -	                                LV2_Feature* const* features) {

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

  270. -	}

  271. +	                                LV2_Feature* const* features)

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

  273.  

  274.  	static inline Instance* create(Plugin              plugin,

  275.  	                               double              sample_rate,

  276. @@ -304,22 +318,25 @@ struct Instance {

  277.  };

  278.  

  279.  struct World {

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

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

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

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

  284.  

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

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

  287.  		return lilv_new_uri(me, uri);

  288.  	}

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

  290. +	inline LilvNode* new_file_uri(const char* host, const char* path) const {

  291. +		return lilv_new_file_uri(me, host, path);

  292. +	}

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

  294.  		return lilv_new_string(me, str);

  295.  	}

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

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

  298.  		return lilv_new_int(me, val);

  299.  	}

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

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

  302.  		return lilv_new_float(me, val);

  303.  	}

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

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

  306.  		return lilv_new_bool(me, val);

  307.  	}

  308.  	inline Nodes find_nodes(const LilvNode* subject,

  309. @@ -329,7 +346,7 @@ struct World {

  310.  	}

  311.  

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

  313. -	LILV_WRAP0_VOID(world, load_all);

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

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

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

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

  318. @@ -337,6 +354,8 @@ struct World {

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

  320.  

  321.  	LilvWorld* me;

  322. +

  323. +	CARLA_DECLARE_NON_COPY_STRUCT(World)

  324.  };

  325.  

  326.  } /* namespace Lilv */

  327. diff --git a/src/lilv_internal.h b/src/lilv_internal.h

  328. index af8e31a..7b6e84d 100644

  329. --- a/src/lilv_internal.h

  330. +++ b/src/lilv_internal.h

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

  332.  #include "lilv/lilv.h"

  333.  

  334.  #ifdef LILV_DYN_MANIFEST

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

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

  337.  #endif

  338.  

  339.  /*

  340. diff --git a/src/plugin.c b/src/plugin.c

  341. index 5e10d7c..108ee2b 100644

  342. --- a/src/plugin.c

  343. +++ b/src/plugin.c

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

  345.  #include "lilv_config.h"

  346.  #include "lilv_internal.h"

  347.  

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

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

  350.  

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

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

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

  354.  

  355.  static void

  356.  lilv_plugin_init(LilvPlugin* plugin, LilvNode* bundle_uri)

  357. @@ -930,6 +931,131 @@ lilv_plugin_get_author_homepage(const LilvPlugin* plugin)

  358.  	return lilv_plugin_get_author_property(plugin, NS_FOAF "homepage");

  359.  }

  360.  

  361. +static const SordNode*

  362. +lilv_plugin_get_modgui(const LilvPlugin* p)

  363. +{

  364. +        lilv_plugin_load_if_necessary(p);

  365. +

  366. +        SordNode* mod_gui = sord_new_uri(

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

  368. +

  369. +        SordIter* gui = lilv_world_query_internal(

  370. +                p->world,

  371. +                p->plugin_uri->node,

  372. +                mod_gui,

  373. +                NULL);

  374. +

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

  376. +

  377. +        if (sord_iter_end(gui)) {

  378. +                sord_iter_free(gui);

  379. +                return NULL;

  380. +        }

  381. +

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

  383. +

  384. +        sord_iter_free(gui);

  385. +        return Gui;

  386. +}

  387. +

  388. +LILV_API LilvNode*

  389. +lilv_plugin_get_modgui_resources_directory(const LilvPlugin* plugin)

  390. +{

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

  392. +        if (modgui) {

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

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

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

  396. +                sord_node_free(sworld, modgui_res);

  397. +                return ret;

  398. +        }

  399. +        return NULL;

  400. +}

  401. +

  402. +LILV_API LilvNode*

  403. +lilv_plugin_get_modgui_stylesheet(const LilvPlugin* plugin)

  404. +{

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

  406. +        if (modgui) {

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

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

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

  410. +                sord_node_free(sworld, modgui_style);

  411. +                return ret;

  412. +        }

  413. +        return NULL;

  414. +}

  415. +

  416. +LILV_API LilvNode*

  417. +lilv_plugin_get_modgui_icon_template(const LilvPlugin* plugin)

  418. +{

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

  420. +        if (modgui) {

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

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

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

  424. +                sord_node_free(sworld, modgui_tmpl);

  425. +                return ret;

  426. +        }

  427. +        return NULL;

  428. +}

  429. +

  430. +LILV_API LilvNode*

  431. +lilv_plugin_get_modgui_settings_template(const LilvPlugin* plugin)

  432. +{

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

  434. +        if (modgui) {

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

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

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

  438. +                sord_node_free(sworld, modgui_tmpl);

  439. +                return ret;

  440. +        }

  441. +        return NULL;

  442. +}

  443. +

  444. +LILV_API LilvNode*

  445. +lilv_plugin_get_modgui_template_data(const LilvPlugin* plugin)

  446. +{

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

  448. +        if (modgui) {

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

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

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

  452. +                sord_node_free(sworld, modgui_tmpl);

  453. +                return ret;

  454. +        }

  455. +        return NULL;

  456. +}

  457. +

  458. +LILV_API LilvNode*

  459. +lilv_plugin_get_modgui_screenshot(const LilvPlugin* plugin)

  460. +{

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

  462. +        if (modgui) {

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

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

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

  466. +                sord_node_free(sworld, modgui_scr);

  467. +                return ret;

  468. +        }

  469. +        return NULL;

  470. +}

  471. +

  472. +LILV_API LilvNode*

  473. +lilv_plugin_get_modgui_thumbnail(const LilvPlugin* plugin)

  474. +{

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

  476. +        if (modgui) {

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

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

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

  480. +                sord_node_free(sworld, modgui_thumb);

  481. +                return ret;

  482. +        }

  483. +        return NULL;

  484. +}

  485. +

  486.  LILV_API bool

  487.  lilv_plugin_is_replaced(const LilvPlugin* plugin)

  488.  {

  489. diff --git a/src/port.c b/src/port.c

  490. index 6bf8fc7..0a50891 100644

  491. --- a/src/port.c

  492. +++ b/src/port.c

  493. @@ -20,8 +20,8 @@

  494.  #include <stdlib.h>

  495.  #include <string.h>

  496.  

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

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

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

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

  501.  

  502.  #include "lilv_internal.h"

  503.  

  504. diff --git a/src/state.c b/src/state.c

  505. index 4781405..c0173b1 100644

  506. --- a/src/state.c

  507. +++ b/src/state.c

  508. @@ -18,10 +18,10 @@

  509.  #include <stdio.h>

  510.  #include <string.h>

  511.  

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

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

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

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

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

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

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

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

  520.  

  521.  #include "lilv_config.h"

  522.  #include "lilv_internal.h"

  523. @@ -431,40 +431,18 @@ lilv_state_emit_port_values(const LilvState*     state,

  524.  

  525.  LILV_API void

  526.  lilv_state_restore(const LilvState*           state,

  527. -                   LilvInstance*              instance,

  528. +                   const LV2_State_Interface* iface,

  529. +                   LV2_Handle                 handle,

  530.                     LilvSetPortValueFunc       set_value,

  531.                     void*                      user_data,

  532.                     uint32_t                   flags,

  533.                     const LV2_Feature *const * features)

  534.  {

  535. -	if (!state) {

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

  537. -		return;

  538. +	if (iface && iface->restore) {

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

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

  541.  	}

  542.  

  543. -	LV2_State_Map_Path map_path = {

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

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

  546. -

  547. -	if (instance) {

  548. -		const LV2_Descriptor* desc = instance->lv2_descriptor;

  549. -		if (desc->extension_data) {

  550. -			const LV2_State_Interface* iface = (const LV2_State_Interface*)

  551. -				desc->extension_data(LV2_STATE__interface);

  552. -

  553. -			if (iface && iface->restore) {

  554. -				const LV2_Feature** sfeatures = add_features(

  555. -					features, &map_feature, NULL);

  556. -

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

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

  559. -

  560. -				free(sfeatures);

  561. -			}

  562. -		}

  563. -	}

  564. -

  565. -

  566.  	if (set_value) {

  567.  		lilv_state_emit_port_values(state, set_value, user_data);

  568.  	}

  569. @@ -616,9 +594,9 @@ new_state_from_model(LilvWorld*       world,

  570.  }

  571.  

  572.  LILV_API LilvState*

  573. -lilv_state_new_from_world(LilvWorld*      world,

  574. -                          LV2_URID_Map*   map,

  575. -                          const LilvNode* node)

  576. +lilv_state_new_from_world(LilvWorld*          world,

  577. +                          const LV2_URID_Map* map,

  578. +                          const LilvNode*     node)

  579.  {

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

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

  582. @@ -630,10 +608,10 @@ lilv_state_new_from_world(LilvWorld*      world,

  583.  }

  584.  

  585.  LILV_API LilvState*

  586. -lilv_state_new_from_file(LilvWorld*      world,

  587. -                         LV2_URID_Map*   map,

  588. -                         const LilvNode* subject,

  589. -                         const char*     path)

  590. +lilv_state_new_from_file(LilvWorld*          world,

  591. +                         const LV2_URID_Map* map,

  592. +                         const LilvNode*     subject,

  593. +                         const char*         path)

  594.  {

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

  596.  	    && !lilv_node_is_blank(subject)) {

  597. @@ -683,9 +661,9 @@ set_prefixes(SerdEnv* env)

  598.  }

  599.  

  600.  LILV_API LilvState*

  601. -lilv_state_new_from_string(LilvWorld*    world,

  602. -                           LV2_URID_Map* map,

  603. -                           const char*   str)

  604. +lilv_state_new_from_string(LilvWorld*          world,

  605. +                           const LV2_URID_Map* map,

  606. +                           const char*         str)

  607.  {

  608.  	if (!str) {

  609.  		return NULL;

  610. diff --git a/src/ui.c b/src/ui.c

  611. index 0f4f2f6..a3e17da 100644

  612. --- a/src/ui.c

  613. +++ b/src/ui.c

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

  615.  {

  616.  	return ui->binary_uri;

  617.  }

  618. +

  619. +static LilvNodes*

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

  621. +{

  622. +       assert(ui);

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

  624. +}

  625. +

  626. +LILV_API const LilvNodes*

  627. +lilv_ui_get_supported_features(const LilvUI* ui)

  628. +{

  629. +       assert(ui);

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

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

  632. +       LilvNodes* result   = lilv_nodes_new();

  633. +

  634. +       LILV_FOREACH(nodes, i, optional)

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

  636. +

  637. +       LILV_FOREACH(nodes, i, required)

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

  639. +

  640. +       lilv_nodes_free(optional);

  641. +       lilv_nodes_free(required);

  642. +

  643. +       return result;

  644. +}

  645. +

  646. +LILV_API const LilvNodes*

  647. +lilv_ui_get_required_features(const LilvUI* ui)

  648. +{

  649. +       assert(ui);

  650. +       assert(ui->world);

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

  652. +}

  653. +

  654. +LILV_API const LilvNodes*

  655. +lilv_ui_get_optional_features(const LilvUI* ui)

  656. +{

  657. +       assert(ui);

  658. +       assert(ui->world);

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

  660. +}

  661. +

  662. +LILV_API const LilvNodes*

  663. +lilv_ui_get_extension_data(const LilvUI* ui)

  664. +{

  665. +       assert(ui);

  666. +       assert(ui->world);

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

  668. +}

  669. diff --git a/src/util.c b/src/util.c

  670. index 0c1fd5e..239aa78 100644

  671. --- a/src/util.c

  672. +++ b/src/util.c

  673. @@ -453,10 +453,7 @@ lilv_symlink(const char* oldpath, const char* newpath)

  674.  	int ret = 0;

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

  676.  #ifdef _WIN32

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

  678. -		if (ret) {

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

  680. -		}

  681. +		ret = 1;

  682.  #else

  683.  		ret = symlink(oldpath, newpath);

  684.  #endif

  685. diff --git a/src/world.c b/src/world.c

  686. index 622e0a5..04403ca 100644

  687. --- a/src/world.c

  688. +++ b/src/world.c

  689. @@ -19,7 +19,7 @@

  690.  #include <stdlib.h>

  691.  #include <string.h>

  692.  

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

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

  695.  

  696.  #include "lilv_internal.h"

  697.  

  698. @@ -1009,12 +1009,8 @@ lilv_world_load_plugin_classes(LilvWorld* world)

  699.  }

  700.  

  701.  LILV_API void

  702. -lilv_world_load_all(LilvWorld* world)

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

  704.  {

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

  706. -	if (!lv2_path)

  707. -		lv2_path = LILV_DEFAULT_LV2_PATH;

  708. -

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

  710.  	lilv_world_load_path(world, lv2_path);

  711.