Lilv  0.14.2
lilv.h
1 /*
2  Copyright 2007-2011 David Robillard <http://drobilla.net>
3 
4  Permission to use, copy, modify, and/or distribute this software for any
5  purpose with or without fee is hereby granted, provided that the above
6  copyright notice and this permission notice appear in all copies.
7 
8  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16 
21 #ifndef LILV_LILV_H
22 #define LILV_LILV_H
23 
24 #include <stddef.h>
25 #include <stdint.h>
26 #include <stdio.h>
27 
28 #include "lv2/lv2plug.in/ns/lv2core/lv2.h"
29 #include "lv2/lv2plug.in/ns/ext/urid/urid.h"
30 
31 #ifdef LILV_SHARED
32 # ifdef _WIN32
33 # define LILV_LIB_IMPORT __declspec(dllimport)
34 # define LILV_LIB_EXPORT __declspec(dllexport)
35 # else
36 # define LILV_LIB_IMPORT __attribute__((visibility("default")))
37 # define LILV_LIB_EXPORT __attribute__((visibility("default")))
38 # endif
39 # ifdef LILV_INTERNAL
40 # define LILV_API LILV_LIB_EXPORT
41 # else
42 # define LILV_API LILV_LIB_IMPORT
43 # endif
44 #else
45 # define LILV_API
46 #endif
47 
48 #ifdef __cplusplus
49 extern "C" {
50 #else
51 # include <stdbool.h>
52 #endif
53 
54 #define LILV_NS_DOAP "http://usefulinc.com/ns/doap#"
55 #define LILV_NS_FOAF "http://xmlns.com/foaf/0.1/"
56 #define LILV_NS_LILV "http://drobilla.net/ns/lilv#"
57 #define LILV_NS_LV2 "http://lv2plug.in/ns/lv2core#"
58 #define LILV_NS_OWL "http://www.w3.org/2002/07/owl#"
59 #define LILV_NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
60 #define LILV_NS_RDFS "http://www.w3.org/2000/01/rdf-schema#"
61 #define LILV_NS_XSD "http://www.w3.org/2001/XMLSchema#"
62 
63 #define LILV_URI_AUDIO_PORT "http://lv2plug.in/ns/lv2core#AudioPort"
64 #define LILV_URI_CONTROL_PORT "http://lv2plug.in/ns/lv2core#ControlPort"
65 #define LILV_URI_EVENT_PORT "http://lv2plug.in/ns/ext/event#EventPort"
66 #define LILV_URI_INPUT_PORT "http://lv2plug.in/ns/lv2core#InputPort"
67 #define LILV_URI_MIDI_EVENT "http://lv2plug.in/ns/ext/midi#MidiEvent"
68 #define LILV_URI_OUTPUT_PORT "http://lv2plug.in/ns/lv2core#OutputPort"
69 #define LILV_URI_PORT "http://lv2plug.in/ns/lv2core#Port"
70 
71 typedef struct LilvPluginImpl LilvPlugin;
72 typedef struct LilvPluginClassImpl LilvPluginClass;
73 typedef struct LilvPortImpl LilvPort;
74 typedef struct LilvScalePointImpl LilvScalePoint;
75 typedef struct LilvUIImpl LilvUI;
76 typedef struct LilvNodeImpl LilvNode;
77 typedef struct LilvWorldImpl LilvWorld;
78 typedef struct LilvInstanceImpl LilvInstance;
79 typedef struct LilvStateImpl LilvState;
81 typedef void LilvIter;
82 typedef void LilvPluginClasses;
83 typedef void LilvPlugins;
84 typedef void LilvScalePoints;
85 typedef void LilvUIs;
86 typedef void LilvNodes;
108 LILV_API
109 const char*
110 lilv_uri_to_path(const char* uri);
111 
116 LILV_API
117 LilvNode*
118 lilv_new_uri(LilvWorld* world, const char* uri);
119 
124 LILV_API
125 LilvNode*
126 lilv_new_string(LilvWorld* world, const char* str);
127 
132 LILV_API
133 LilvNode*
134 lilv_new_int(LilvWorld* world, int val);
135 
140 LILV_API
141 LilvNode*
142 lilv_new_float(LilvWorld* world, float val);
143 
148 LILV_API
149 LilvNode*
150 lilv_new_bool(LilvWorld* world, bool val);
151 
156 LILV_API
157 void
158 lilv_node_free(LilvNode* val);
159 
163 LILV_API
164 LilvNode*
165 lilv_node_duplicate(const LilvNode* val);
166 
170 LILV_API
171 bool
172 lilv_node_equals(const LilvNode* value, const LilvNode* other);
173 
187 LILV_API
188 char*
189 lilv_node_get_turtle_token(const LilvNode* value);
190 
194 LILV_API
195 bool
196 lilv_node_is_uri(const LilvNode* value);
197 
203 LILV_API
204 const char*
205 lilv_node_as_uri(const LilvNode* value);
206 
210 LILV_API
211 bool
212 lilv_node_is_blank(const LilvNode* value);
213 
219 LILV_API
220 const char*
221 lilv_node_as_blank(const LilvNode* value);
222 
227 LILV_API
228 bool
229 lilv_node_is_literal(const LilvNode* value);
230 
235 LILV_API
236 bool
237 lilv_node_is_string(const LilvNode* value);
238 
242 LILV_API
243 const char*
244 lilv_node_as_string(const LilvNode* value);
245 
249 LILV_API
250 bool
251 lilv_node_is_float(const LilvNode* value);
252 
258 LILV_API
259 float
260 lilv_node_as_float(const LilvNode* value);
261 
265 LILV_API
266 bool
267 lilv_node_is_int(const LilvNode* value);
268 
273 LILV_API
274 int
275 lilv_node_as_int(const LilvNode* value);
276 
280 LILV_API
281 bool
282 lilv_node_is_bool(const LilvNode* value);
283 
288 LILV_API
289 bool
290 lilv_node_as_bool(const LilvNode* value);
291 
314 /* Collections */
315 
325 #define LILV_FOREACH(colltype, iter, collection) \
326  for (LilvIter* (iter) = lilv_ ## colltype ## _begin(collection); \
327  !lilv_ ## colltype ## _is_end(collection, iter); \
328  (iter) = lilv_ ## colltype ## _next(collection, iter))
329 
330 /* LilvPluginClasses */
331 
332 LILV_API
333 void
334 lilv_plugin_classes_free(LilvPluginClasses* collection);
335 
336 LILV_API
337 unsigned
338 lilv_plugin_classes_size(const LilvPluginClasses* collection);
339 
340 LILV_API
341 LilvIter*
342 lilv_plugin_classes_begin(const LilvPluginClasses* collection);
343 
344 LILV_API
345 const LilvPluginClass*
346 lilv_plugin_classes_get(const LilvPluginClasses* collection, LilvIter* i);
347 
348 LILV_API
349 LilvIter*
350 lilv_plugin_classes_next(const LilvPluginClasses* collection, LilvIter* i);
351 
352 LILV_API
353 bool
354 lilv_plugin_classes_is_end(const LilvPluginClasses* collection, LilvIter* i);
355 
362 LILV_API
363 const LilvPluginClass*
364 lilv_plugin_classes_get_by_uri(const LilvPluginClasses* classes,
365  const LilvNode* uri);
366 
367 /* ScalePoints */
368 
369 LILV_API
370 void
371 lilv_scale_points_free(LilvScalePoints* collection);
372 
373 LILV_API
374 unsigned
375 lilv_scale_points_size(const LilvScalePoints* collection);
376 
377 LILV_API
378 LilvIter*
379 lilv_scale_points_begin(const LilvScalePoints* collection);
380 
381 LILV_API
382 const LilvScalePoint*
383 lilv_scale_points_get(const LilvScalePoints* collection, LilvIter* i);
384 
385 LILV_API
386 LilvIter*
387 lilv_scale_points_next(const LilvScalePoints* collection, LilvIter* i);
388 
389 LILV_API
390 bool
391 lilv_scale_points_is_end(const LilvScalePoints* collection, LilvIter* i);
392 
393 /* UIs */
394 
395 LILV_API
396 void
397 lilv_uis_free(LilvUIs* collection);
398 
399 LILV_API
400 unsigned
401 lilv_uis_size(const LilvUIs* collection);
402 
403 LILV_API
404 LilvIter*
405 lilv_uis_begin(const LilvUIs* collection);
406 
407 LILV_API
408 const LilvUI*
409 lilv_uis_get(const LilvUIs* collection, LilvIter* i);
410 
411 LILV_API
412 LilvIter*
413 lilv_uis_next(const LilvUIs* collection, LilvIter* i);
414 
415 LILV_API
416 bool
417 lilv_uis_is_end(const LilvUIs* collection, LilvIter* i);
418 
425 LILV_API
426 const LilvUI*
427 lilv_uis_get_by_uri(const LilvUIs* uis,
428  const LilvNode* uri);
429 
430 /* Nodes */
431 
432 LILV_API
433 void
434 lilv_nodes_free(LilvNodes* collection);
435 
436 LILV_API
437 unsigned
438 lilv_nodes_size(const LilvNodes* collection);
439 
440 LILV_API
441 LilvIter*
442 lilv_nodes_begin(const LilvNodes* collection);
443 
444 LILV_API
445 const LilvNode*
446 lilv_nodes_get(const LilvNodes* collection, LilvIter* i);
447 
448 LILV_API
449 LilvIter*
450 lilv_nodes_next(const LilvNodes* collection, LilvIter* i);
451 
452 LILV_API
453 bool
454 lilv_nodes_is_end(const LilvNodes* collection, LilvIter* i);
455 
456 LILV_API
457 LilvNode*
458 lilv_nodes_get_first(const LilvNodes* collection);
459 
463 LILV_API
464 bool
465 lilv_nodes_contains(const LilvNodes* values, const LilvNode* value);
466 
467 /* Plugins */
468 
469 LILV_API
470 unsigned
471 lilv_plugins_size(const LilvPlugins* collection);
472 
473 LILV_API
474 LilvIter*
475 lilv_plugins_begin(const LilvPlugins* collection);
476 
477 LILV_API
478 const LilvPlugin*
479 lilv_plugins_get(const LilvPlugins* collection, LilvIter* i);
480 
481 LILV_API
482 LilvIter*
483 lilv_plugins_next(const LilvPlugins* collection, LilvIter* i);
484 
485 LILV_API
486 bool
487 lilv_plugins_is_end(const LilvPlugins* collection, LilvIter* i);
488 
495 LILV_API
496 const LilvPlugin*
497 lilv_plugins_get_by_uri(const LilvPlugins* plugins,
498  const LilvNode* uri);
499 
514 LILV_API
515 LilvWorld*
516 lilv_world_new(void);
517 
525 #define LILV_OPTION_FILTER_LANG "http://drobilla.net/ns/lilv#filter-lang"
526 
531 #define LILV_OPTION_DYN_MANIFEST "http://drobilla.net/ns/lilv#dyn-manifest"
532 
540 LILV_API
541 void
542 lilv_world_set_option(LilvWorld* world,
543  const char* uri,
544  const LilvNode* value);
545 
553 LILV_API
554 void
555 lilv_world_free(LilvWorld* world);
556 
568 LILV_API
569 void
570 lilv_world_load_all(LilvWorld* world);
571 
584 LILV_API
585 void
586 lilv_world_load_bundle(LilvWorld* world,
587  LilvNode* bundle_uri);
588 
597 LILV_API
598 int
599 lilv_world_load_resource(LilvWorld* world,
600  const LilvNode* resource);
601 
605 LILV_API
606 const LilvPluginClass*
607 lilv_world_get_plugin_class(const LilvWorld* world);
608 
613 LILV_API
614 const LilvPluginClasses*
615 lilv_world_get_plugin_classes(const LilvWorld* world);
616 
628 LILV_API
629 const LilvPlugins*
630 lilv_world_get_all_plugins(const LilvWorld* world);
631 
637 LILV_API
638 LilvNodes*
639 lilv_world_find_nodes(LilvWorld* world,
640  const LilvNode* subject,
641  const LilvNode* predicate,
642  const LilvNode* object);
643 
660 LILV_API
661 bool
662 lilv_plugin_verify(const LilvPlugin* plugin);
663 
678 LILV_API
679 const LilvNode*
680 lilv_plugin_get_uri(const LilvPlugin* plugin);
681 
693 LILV_API
694 const LilvNode*
695 lilv_plugin_get_bundle_uri(const LilvPlugin* plugin);
696 
705 LILV_API
706 const LilvNodes*
707 lilv_plugin_get_data_uris(const LilvPlugin* plugin);
708 
715 LILV_API
716 const LilvNode*
717 lilv_plugin_get_library_uri(const LilvPlugin* plugin);
718 
726 LILV_API
727 LilvNode*
728 lilv_plugin_get_name(const LilvPlugin* plugin);
729 
733 LILV_API
734 const LilvPluginClass*
735 lilv_plugin_get_class(const LilvPlugin* plugin);
736 
749 LILV_API
750 LilvNodes*
751 lilv_plugin_get_value(const LilvPlugin* p,
752  const LilvNode* predicate);
753 
759 LILV_API
760 bool
761 lilv_plugin_has_feature(const LilvPlugin* p,
762  const LilvNode* feature_uri);
763 
774 LILV_API
775 LilvNodes*
776 lilv_plugin_get_supported_features(const LilvPlugin* p);
777 
789 LILV_API
790 LilvNodes*
791 lilv_plugin_get_required_features(const LilvPlugin* p);
792 
801 LILV_API
802 LilvNodes*
803 lilv_plugin_get_optional_features(const LilvPlugin* p);
804 
808 LILV_API
809 bool
810 lilv_plugin_has_extension_data(const LilvPlugin* p,
811  const LilvNode* uri);
812 
818 LILV_API
819 LilvNodes*
820 lilv_plugin_get_extension_data(const LilvPlugin* p);
821 
825 LILV_API
826 uint32_t
827 lilv_plugin_get_num_ports(const LilvPlugin* p);
828 
843 LILV_API
844 void
845 lilv_plugin_get_port_ranges_float(const LilvPlugin* p,
846  float* min_values,
847  float* max_values,
848  float* def_values);
849 
856 LILV_API
857 uint32_t
858 lilv_plugin_get_num_ports_of_class(const LilvPlugin* p,
859  const LilvNode* class_1, ...);
860 
866 LILV_API
867 bool
868 lilv_plugin_has_latency(const LilvPlugin* p);
869 
879 LILV_API
880 uint32_t
881 lilv_plugin_get_latency_port_index(const LilvPlugin* p);
882 
886 LILV_API
887 const LilvPort*
888 lilv_plugin_get_port_by_index(const LilvPlugin* plugin,
889  uint32_t index);
890 
896 LILV_API
897 const LilvPort*
898 lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin,
899  const LilvNode* symbol);
900 
910 LILV_API
911 LilvPort*
912 lilv_plugin_get_port_by_designation(const LilvPlugin* plugin,
913  const LilvNode* port_class,
914  const LilvNode* designation);
915 
922 LILV_API
923 LilvNode*
924 lilv_plugin_get_project(const LilvPlugin* plugin);
925 
931 LILV_API
932 LilvNode*
933 lilv_plugin_get_author_name(const LilvPlugin* plugin);
934 
940 LILV_API
941 LilvNode*
942 lilv_plugin_get_author_email(const LilvPlugin* plugin);
943 
949 LILV_API
950 LilvNode*
951 lilv_plugin_get_author_homepage(const LilvPlugin* plugin);
952 
959 LILV_API
960 bool
961 lilv_plugin_is_replaced(const LilvPlugin* plugin);
962 
969 LILV_API
970 void
971 lilv_plugin_write_description(LilvWorld* world,
972  const LilvPlugin* plugin,
973  const LilvNode* base_uri,
974  FILE* plugin_file);
975 
982 LILV_API
983 void
984 lilv_plugin_write_manifest_entry(LilvWorld* world,
985  const LilvPlugin* plugin,
986  const LilvNode* base_uri,
987  FILE* manifest_file,
988  const char* plugin_file_path);
989 
1003 LILV_API
1004 LilvNodes*
1005 lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type);
1006 
1016 LILV_API
1017 LilvNodes*
1018 lilv_port_get_value(const LilvPlugin* plugin,
1019  const LilvPort* port,
1020  const LilvNode* predicate);
1021 
1025 LILV_API
1026 LilvNodes*
1027 lilv_port_get_properties(const LilvPlugin* plugin,
1028  const LilvPort* port);
1029 
1033 LILV_API
1034 bool
1035 lilv_port_has_property(const LilvPlugin* p,
1036  const LilvPort* port,
1037  const LilvNode* property_uri);
1038 
1042 LILV_API
1043 bool
1044 lilv_port_supports_event(const LilvPlugin* p,
1045  const LilvPort* port,
1046  const LilvNode* event_uri);
1047 
1053 LILV_API
1054 uint32_t
1055 lilv_port_get_index(const LilvPlugin* plugin,
1056  const LilvPort* port);
1057 
1063 LILV_API
1064 const LilvNode*
1065 lilv_port_get_symbol(const LilvPlugin* plugin,
1066  const LilvPort* port);
1067 
1074 LILV_API
1075 LilvNode*
1076 lilv_port_get_name(const LilvPlugin* plugin,
1077  const LilvPort* port);
1078 
1086 LILV_API
1087 const LilvNodes*
1088 lilv_port_get_classes(const LilvPlugin* plugin,
1089  const LilvPort* port);
1090 
1099 LILV_API
1100 bool
1101 lilv_port_is_a(const LilvPlugin* plugin,
1102  const LilvPort* port,
1103  const LilvNode* port_class);
1104 
1113 LILV_API
1114 void
1115 lilv_port_get_range(const LilvPlugin* plugin,
1116  const LilvPort* port,
1117  LilvNode** deflt,
1118  LilvNode** min,
1119  LilvNode** max);
1120 
1128 LILV_API
1129 LilvScalePoints*
1130 lilv_port_get_scale_points(const LilvPlugin* plugin,
1131  const LilvPort* port);
1132 
1144 LILV_API
1145 LilvState*
1146 lilv_state_new_from_world(LilvWorld* world,
1147  LV2_URID_Map* map,
1148  const LilvNode* subject);
1149 
1163 LILV_API
1164 LilvState*
1165 lilv_state_new_from_file(LilvWorld* world,
1166  LV2_URID_Map* map,
1167  const LilvNode* subject,
1168  const char* path);
1169 
1173 LILV_API
1174 LilvState*
1175 lilv_state_new_from_string(LilvWorld* world,
1176  LV2_URID_Map* map,
1177  const char* str);
1178 
1189 typedef const void* (*LilvGetPortValueFunc)(const char* port_symbol,
1190  void* user_data,
1191  uint32_t* size,
1192  uint32_t* type);
1193 
1251 LILV_API
1252 LilvState*
1253 lilv_state_new_from_instance(const LilvPlugin* plugin,
1254  LilvInstance* instance,
1255  LV2_URID_Map* map,
1256  const char* file_dir,
1257  const char* copy_dir,
1258  const char* link_dir,
1259  const char* save_dir,
1260  LilvGetPortValueFunc get_value,
1261  void* user_data,
1262  uint32_t flags,
1263  const LV2_Feature *const * features);
1264 
1268 LILV_API
1269 void
1270 lilv_state_free(LilvState* state);
1271 
1275 LILV_API
1276 bool
1277 lilv_state_equals(const LilvState* a, const LilvState* b);
1278 
1282 LILV_API
1283 unsigned
1284 lilv_state_get_num_properties(const LilvState* state);
1285 
1289 LILV_API
1290 const LilvNode*
1291 lilv_state_get_plugin_uri(const LilvState* state);
1292 
1296 LILV_API
1297 const char*
1298 lilv_state_get_label(const LilvState* state);
1299 
1303 LILV_API
1304 void
1305 lilv_state_set_label(LilvState* state,
1306  const char* label);
1307 
1316 typedef void (*LilvSetPortValueFunc)(const char* port_symbol,
1317  void* user_data,
1318  const void* value,
1319  uint32_t size,
1320  uint32_t type);
1321 
1344 LILV_API
1345 void
1346 lilv_state_restore(const LilvState* state,
1347  LilvInstance* instance,
1348  LilvSetPortValueFunc set_value,
1349  void* user_data,
1350  uint32_t flags,
1351  const LV2_Feature *const * features);
1352 
1368 LILV_API
1369 int
1370 lilv_state_save(LilvWorld* world,
1371  LV2_URID_Map* map,
1372  LV2_URID_Unmap* unmap,
1373  const LilvState* state,
1374  const char* uri,
1375  const char* dir,
1376  const char* filename);
1377 
1381 LILV_API
1382 char*
1383 lilv_state_to_string(LilvWorld* world,
1384  LV2_URID_Map* map,
1385  LV2_URID_Unmap* unmap,
1386  const LilvState* state,
1387  const char* uri,
1388  const char* base_uri);
1389 
1400 LILV_API
1401 const LilvNode*
1402 lilv_scale_point_get_label(const LilvScalePoint* point);
1403 
1408 LILV_API
1409 const LilvNode*
1410 lilv_scale_point_get_value(const LilvScalePoint* point);
1411 
1423 LILV_API
1424 const LilvNode*
1425 lilv_plugin_class_get_parent_uri(const LilvPluginClass* plugin_class);
1426 
1431 LILV_API
1432 const LilvNode*
1433 lilv_plugin_class_get_uri(const LilvPluginClass* plugin_class);
1434 
1439 LILV_API
1440 const LilvNode*
1441 lilv_plugin_class_get_label(const LilvPluginClass* plugin_class);
1442 
1447 LILV_API
1448 LilvPluginClasses*
1449 lilv_plugin_class_get_children(const LilvPluginClass* plugin_class);
1450 
1461 /* Instance of a plugin.
1462  This is exposed in the ABI to allow inlining of performance critical
1463  functions like lilv_instance_run (simple wrappers of functions in lv2.h).
1464  This is for performance reasons, user code should not use this definition
1465  in any way (which is why it is not machine documented).
1466  Truly private implementation details are hidden via @a ref pimpl.
1467 */
1468 struct LilvInstanceImpl {
1469  const LV2_Descriptor* lv2_descriptor;
1470  LV2_Handle lv2_handle;
1471  void* pimpl;
1472 };
1473 
1487 LILV_API
1488 LilvInstance*
1489 lilv_plugin_instantiate(const LilvPlugin* plugin,
1490  double sample_rate,
1491  const LV2_Feature*const* features);
1492 
1498 LILV_API
1499 void
1500 lilv_instance_free(LilvInstance* instance);
1501 
1502 #ifndef LILV_INTERNAL
1503 
1508 static inline const char*
1509 lilv_instance_get_uri(const LilvInstance* instance)
1510 {
1511  return instance->lv2_descriptor->URI;
1512 }
1513 
1519 static inline void
1520 lilv_instance_connect_port(LilvInstance* instance,
1521  uint32_t port_index,
1522  void* data_location)
1523 {
1524  instance->lv2_descriptor->connect_port
1525  (instance->lv2_handle, port_index, data_location);
1526 }
1527 
1534 static inline void
1535 lilv_instance_activate(LilvInstance* instance)
1536 {
1537  if (instance->lv2_descriptor->activate)
1538  instance->lv2_descriptor->activate(instance->lv2_handle);
1539 }
1540 
1546 static inline void
1547 lilv_instance_run(LilvInstance* instance,
1548  uint32_t sample_count)
1549 {
1550  instance->lv2_descriptor->run(instance->lv2_handle, sample_count);
1551 }
1552 
1558 static inline void
1559 lilv_instance_deactivate(LilvInstance* instance)
1560 {
1561  if (instance->lv2_descriptor->deactivate)
1562  instance->lv2_descriptor->deactivate(instance->lv2_handle);
1563 }
1564 
1570 static inline const void*
1571 lilv_instance_get_extension_data(const LilvInstance* instance,
1572  const char* uri)
1573 {
1574  if (instance->lv2_descriptor->extension_data)
1575  return instance->lv2_descriptor->extension_data(uri);
1576  else
1577  return NULL;
1578 }
1579 
1587 static inline const LV2_Descriptor*
1588 lilv_instance_get_descriptor(const LilvInstance* instance)
1589 {
1590  return instance->lv2_descriptor;
1591 }
1592 
1600 static inline LV2_Handle
1601 lilv_instance_get_handle(const LilvInstance* instance)
1602 {
1603  return instance->lv2_handle;
1604 }
1605 
1606 #endif /* LILV_INTERNAL */
1607 
1618 LILV_API
1619 LilvUIs*
1620 lilv_plugin_get_uis(const LilvPlugin* plugin);
1621 
1627 LILV_API
1628 const LilvNode*
1629 lilv_ui_get_uri(const LilvUI* ui);
1630 
1639 LILV_API
1640 const LilvNodes*
1641 lilv_ui_get_classes(const LilvUI* ui);
1642 
1648 LILV_API
1649 bool
1650 lilv_ui_is_a(const LilvUI* ui, const LilvNode* class_uri);
1651 
1658 typedef unsigned (*LilvUISupportedFunc)(const char* container_type_uri,
1659  const char* ui_type_uri);
1660 
1670 LILV_API
1671 unsigned
1672 lilv_ui_is_supported(const LilvUI* ui,
1673  LilvUISupportedFunc supported_func,
1674  const LilvNode* container_type,
1675  const LilvNode** ui_type);
1676 
1682 LILV_API
1683 const LilvNode*
1684 lilv_ui_get_bundle_uri(const LilvUI* ui);
1685 
1691 LILV_API
1692 const LilvNode*
1693 lilv_ui_get_binary_uri(const LilvUI* ui);
1694 
1700 #ifdef __cplusplus
1701 } /* extern "C" */
1702 #endif
1703 
1704 #endif /* LILV_LILV_H */