Lilv  0.14.2
lilv.h
00001 /*
00002   Copyright 2007-2011 David Robillard <http://drobilla.net>
00003 
00004   Permission to use, copy, modify, and/or distribute this software for any
00005   purpose with or without fee is hereby granted, provided that the above
00006   copyright notice and this permission notice appear in all copies.
00007 
00008   THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
00009   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
00010   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
00011   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
00012   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
00013   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
00014   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
00015 */
00016 
00021 #ifndef LILV_LILV_H
00022 #define LILV_LILV_H
00023 
00024 #include <stddef.h>
00025 #include <stdint.h>
00026 #include <stdio.h>
00027 
00028 #include "lv2/lv2plug.in/ns/lv2core/lv2.h"
00029 #include "lv2/lv2plug.in/ns/ext/urid/urid.h"
00030 
00031 #ifdef LILV_SHARED
00032 #    ifdef _WIN32
00033 #        define LILV_LIB_IMPORT __declspec(dllimport)
00034 #        define LILV_LIB_EXPORT __declspec(dllexport)
00035 #    else
00036 #        define LILV_LIB_IMPORT __attribute__((visibility("default")))
00037 #        define LILV_LIB_EXPORT __attribute__((visibility("default")))
00038 #    endif
00039 #    ifdef LILV_INTERNAL
00040 #        define LILV_API LILV_LIB_EXPORT
00041 #    else
00042 #        define LILV_API LILV_LIB_IMPORT
00043 #    endif
00044 #else
00045 #    define LILV_API
00046 #endif
00047 
00048 #ifdef __cplusplus
00049 extern "C" {
00050 #else
00051 #   include <stdbool.h>
00052 #endif
00053 
00054 #define LILV_NS_DOAP "http://usefulinc.com/ns/doap#"
00055 #define LILV_NS_FOAF "http://xmlns.com/foaf/0.1/"
00056 #define LILV_NS_LILV "http://drobilla.net/ns/lilv#"
00057 #define LILV_NS_LV2  "http://lv2plug.in/ns/lv2core#"
00058 #define LILV_NS_OWL  "http://www.w3.org/2002/07/owl#"
00059 #define LILV_NS_RDF  "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
00060 #define LILV_NS_RDFS "http://www.w3.org/2000/01/rdf-schema#"
00061 #define LILV_NS_XSD  "http://www.w3.org/2001/XMLSchema#"
00062 
00063 #define LILV_URI_AUDIO_PORT   "http://lv2plug.in/ns/lv2core#AudioPort"
00064 #define LILV_URI_CONTROL_PORT "http://lv2plug.in/ns/lv2core#ControlPort"
00065 #define LILV_URI_EVENT_PORT   "http://lv2plug.in/ns/ext/event#EventPort"
00066 #define LILV_URI_INPUT_PORT   "http://lv2plug.in/ns/lv2core#InputPort"
00067 #define LILV_URI_MIDI_EVENT   "http://lv2plug.in/ns/ext/midi#MidiEvent"
00068 #define LILV_URI_OUTPUT_PORT  "http://lv2plug.in/ns/lv2core#OutputPort"
00069 #define LILV_URI_PORT         "http://lv2plug.in/ns/lv2core#Port"
00070 
00071 typedef struct LilvPluginImpl      LilvPlugin;       
00072 typedef struct LilvPluginClassImpl LilvPluginClass;  
00073 typedef struct LilvPortImpl        LilvPort;         
00074 typedef struct LilvScalePointImpl  LilvScalePoint;   
00075 typedef struct LilvUIImpl          LilvUI;           
00076 typedef struct LilvNodeImpl        LilvNode;         
00077 typedef struct LilvWorldImpl       LilvWorld;        
00078 typedef struct LilvInstanceImpl    LilvInstance;     
00079 typedef struct LilvStateImpl       LilvState;        
00081 typedef void LilvIter;           
00082 typedef void LilvPluginClasses;  
00083 typedef void LilvPlugins;        
00084 typedef void LilvScalePoints;    
00085 typedef void LilvUIs;            
00086 typedef void LilvNodes;          
00108 LILV_API
00109 const char*
00110 lilv_uri_to_path(const char* uri);
00111 
00116 LILV_API
00117 LilvNode*
00118 lilv_new_uri(LilvWorld* world, const char* uri);
00119 
00124 LILV_API
00125 LilvNode*
00126 lilv_new_string(LilvWorld* world, const char* str);
00127 
00132 LILV_API
00133 LilvNode*
00134 lilv_new_int(LilvWorld* world, int val);
00135 
00140 LILV_API
00141 LilvNode*
00142 lilv_new_float(LilvWorld* world, float val);
00143 
00148 LILV_API
00149 LilvNode*
00150 lilv_new_bool(LilvWorld* world, bool val);
00151 
00156 LILV_API
00157 void
00158 lilv_node_free(LilvNode* val);
00159 
00163 LILV_API
00164 LilvNode*
00165 lilv_node_duplicate(const LilvNode* val);
00166 
00170 LILV_API
00171 bool
00172 lilv_node_equals(const LilvNode* value, const LilvNode* other);
00173 
00187 LILV_API
00188 char*
00189 lilv_node_get_turtle_token(const LilvNode* value);
00190 
00194 LILV_API
00195 bool
00196 lilv_node_is_uri(const LilvNode* value);
00197 
00203 LILV_API
00204 const char*
00205 lilv_node_as_uri(const LilvNode* value);
00206 
00210 LILV_API
00211 bool
00212 lilv_node_is_blank(const LilvNode* value);
00213 
00219 LILV_API
00220 const char*
00221 lilv_node_as_blank(const LilvNode* value);
00222 
00227 LILV_API
00228 bool
00229 lilv_node_is_literal(const LilvNode* value);
00230 
00235 LILV_API
00236 bool
00237 lilv_node_is_string(const LilvNode* value);
00238 
00242 LILV_API
00243 const char*
00244 lilv_node_as_string(const LilvNode* value);
00245 
00249 LILV_API
00250 bool
00251 lilv_node_is_float(const LilvNode* value);
00252 
00258 LILV_API
00259 float
00260 lilv_node_as_float(const LilvNode* value);
00261 
00265 LILV_API
00266 bool
00267 lilv_node_is_int(const LilvNode* value);
00268 
00273 LILV_API
00274 int
00275 lilv_node_as_int(const LilvNode* value);
00276 
00280 LILV_API
00281 bool
00282 lilv_node_is_bool(const LilvNode* value);
00283 
00288 LILV_API
00289 bool
00290 lilv_node_as_bool(const LilvNode* value);
00291 
00314 /* Collections */
00315 
00325 #define LILV_FOREACH(colltype, iter, collection) \
00326     for (LilvIter* (iter) = lilv_ ## colltype ## _begin(collection); \
00327          !lilv_ ## colltype ## _is_end(collection, iter); \
00328          (iter) = lilv_ ## colltype ## _next(collection, iter))
00329 
00330 /* LilvPluginClasses */
00331 
00332 LILV_API
00333 void
00334 lilv_plugin_classes_free(LilvPluginClasses* collection);
00335 
00336 LILV_API
00337 unsigned
00338 lilv_plugin_classes_size(const LilvPluginClasses* collection);
00339 
00340 LILV_API
00341 LilvIter*
00342 lilv_plugin_classes_begin(const LilvPluginClasses* collection);
00343 
00344 LILV_API
00345 const LilvPluginClass*
00346 lilv_plugin_classes_get(const LilvPluginClasses* collection, LilvIter* i);
00347 
00348 LILV_API
00349 LilvIter*
00350 lilv_plugin_classes_next(const LilvPluginClasses* collection, LilvIter* i);
00351 
00352 LILV_API
00353 bool
00354 lilv_plugin_classes_is_end(const LilvPluginClasses* collection, LilvIter* i);
00355 
00362 LILV_API
00363 const LilvPluginClass*
00364 lilv_plugin_classes_get_by_uri(const LilvPluginClasses* classes,
00365                                const LilvNode*          uri);
00366 
00367 /* ScalePoints */
00368 
00369 LILV_API
00370 void
00371 lilv_scale_points_free(LilvScalePoints* collection);
00372 
00373 LILV_API
00374 unsigned
00375 lilv_scale_points_size(const LilvScalePoints* collection);
00376 
00377 LILV_API
00378 LilvIter*
00379 lilv_scale_points_begin(const LilvScalePoints* collection);
00380 
00381 LILV_API
00382 const LilvScalePoint*
00383 lilv_scale_points_get(const LilvScalePoints* collection, LilvIter* i);
00384 
00385 LILV_API
00386 LilvIter*
00387 lilv_scale_points_next(const LilvScalePoints* collection, LilvIter* i);
00388 
00389 LILV_API
00390 bool
00391 lilv_scale_points_is_end(const LilvScalePoints* collection, LilvIter* i);
00392 
00393 /* UIs */
00394 
00395 LILV_API
00396 void
00397 lilv_uis_free(LilvUIs* collection);
00398 
00399 LILV_API
00400 unsigned
00401 lilv_uis_size(const LilvUIs* collection);
00402 
00403 LILV_API
00404 LilvIter*
00405 lilv_uis_begin(const LilvUIs* collection);
00406 
00407 LILV_API
00408 const LilvUI*
00409 lilv_uis_get(const LilvUIs* collection, LilvIter* i);
00410 
00411 LILV_API
00412 LilvIter*
00413 lilv_uis_next(const LilvUIs* collection, LilvIter* i);
00414 
00415 LILV_API
00416 bool
00417 lilv_uis_is_end(const LilvUIs* collection, LilvIter* i);
00418 
00425 LILV_API
00426 const LilvUI*
00427 lilv_uis_get_by_uri(const LilvUIs*  uis,
00428                     const LilvNode* uri);
00429 
00430 /* Nodes */
00431 
00432 LILV_API
00433 void
00434 lilv_nodes_free(LilvNodes* collection);
00435 
00436 LILV_API
00437 unsigned
00438 lilv_nodes_size(const LilvNodes* collection);
00439 
00440 LILV_API
00441 LilvIter*
00442 lilv_nodes_begin(const LilvNodes* collection);
00443 
00444 LILV_API
00445 const LilvNode*
00446 lilv_nodes_get(const LilvNodes* collection, LilvIter* i);
00447 
00448 LILV_API
00449 LilvIter*
00450 lilv_nodes_next(const LilvNodes* collection, LilvIter* i);
00451 
00452 LILV_API
00453 bool
00454 lilv_nodes_is_end(const LilvNodes* collection, LilvIter* i);
00455 
00456 LILV_API
00457 LilvNode*
00458 lilv_nodes_get_first(const LilvNodes* collection);
00459 
00463 LILV_API
00464 bool
00465 lilv_nodes_contains(const LilvNodes* values, const LilvNode* value);
00466 
00467 /* Plugins */
00468 
00469 LILV_API
00470 unsigned
00471 lilv_plugins_size(const LilvPlugins* collection);
00472 
00473 LILV_API
00474 LilvIter*
00475 lilv_plugins_begin(const LilvPlugins* collection);
00476 
00477 LILV_API
00478 const LilvPlugin*
00479 lilv_plugins_get(const LilvPlugins* collection, LilvIter* i);
00480 
00481 LILV_API
00482 LilvIter*
00483 lilv_plugins_next(const LilvPlugins* collection, LilvIter* i);
00484 
00485 LILV_API
00486 bool
00487 lilv_plugins_is_end(const LilvPlugins* collection, LilvIter* i);
00488 
00495 LILV_API
00496 const LilvPlugin*
00497 lilv_plugins_get_by_uri(const LilvPlugins* plugins,
00498                         const LilvNode*    uri);
00499 
00514 LILV_API
00515 LilvWorld*
00516 lilv_world_new(void);
00517 
00525 #define LILV_OPTION_FILTER_LANG "http://drobilla.net/ns/lilv#filter-lang"
00526 
00531 #define LILV_OPTION_DYN_MANIFEST "http://drobilla.net/ns/lilv#dyn-manifest"
00532 
00540 LILV_API
00541 void
00542 lilv_world_set_option(LilvWorld*      world,
00543                       const char*     uri,
00544                       const LilvNode* value);
00545 
00553 LILV_API
00554 void
00555 lilv_world_free(LilvWorld* world);
00556 
00568 LILV_API
00569 void
00570 lilv_world_load_all(LilvWorld* world);
00571 
00584 LILV_API
00585 void
00586 lilv_world_load_bundle(LilvWorld* world,
00587                        LilvNode*  bundle_uri);
00588 
00597 LILV_API
00598 int
00599 lilv_world_load_resource(LilvWorld*      world,
00600                          const LilvNode* resource);
00601 
00605 LILV_API
00606 const LilvPluginClass*
00607 lilv_world_get_plugin_class(const LilvWorld* world);
00608 
00613 LILV_API
00614 const LilvPluginClasses*
00615 lilv_world_get_plugin_classes(const LilvWorld* world);
00616 
00628 LILV_API
00629 const LilvPlugins*
00630 lilv_world_get_all_plugins(const LilvWorld* world);
00631 
00637 LILV_API
00638 LilvNodes*
00639 lilv_world_find_nodes(LilvWorld*      world,
00640                       const LilvNode* subject,
00641                       const LilvNode* predicate,
00642                       const LilvNode* object);
00643 
00660 LILV_API
00661 bool
00662 lilv_plugin_verify(const LilvPlugin* plugin);
00663 
00678 LILV_API
00679 const LilvNode*
00680 lilv_plugin_get_uri(const LilvPlugin* plugin);
00681 
00693 LILV_API
00694 const LilvNode*
00695 lilv_plugin_get_bundle_uri(const LilvPlugin* plugin);
00696 
00705 LILV_API
00706 const LilvNodes*
00707 lilv_plugin_get_data_uris(const LilvPlugin* plugin);
00708 
00715 LILV_API
00716 const LilvNode*
00717 lilv_plugin_get_library_uri(const LilvPlugin* plugin);
00718 
00726 LILV_API
00727 LilvNode*
00728 lilv_plugin_get_name(const LilvPlugin* plugin);
00729 
00733 LILV_API
00734 const LilvPluginClass*
00735 lilv_plugin_get_class(const LilvPlugin* plugin);
00736 
00749 LILV_API
00750 LilvNodes*
00751 lilv_plugin_get_value(const LilvPlugin* p,
00752                       const LilvNode*   predicate);
00753 
00759 LILV_API
00760 bool
00761 lilv_plugin_has_feature(const LilvPlugin* p,
00762                         const LilvNode*   feature_uri);
00763 
00774 LILV_API
00775 LilvNodes*
00776 lilv_plugin_get_supported_features(const LilvPlugin* p);
00777 
00789 LILV_API
00790 LilvNodes*
00791 lilv_plugin_get_required_features(const LilvPlugin* p);
00792 
00801 LILV_API
00802 LilvNodes*
00803 lilv_plugin_get_optional_features(const LilvPlugin* p);
00804 
00808 LILV_API
00809 bool
00810 lilv_plugin_has_extension_data(const LilvPlugin* p,
00811                                const LilvNode*   uri);
00812 
00818 LILV_API
00819 LilvNodes*
00820 lilv_plugin_get_extension_data(const LilvPlugin* p);
00821 
00825 LILV_API
00826 uint32_t
00827 lilv_plugin_get_num_ports(const LilvPlugin* p);
00828 
00843 LILV_API
00844 void
00845 lilv_plugin_get_port_ranges_float(const LilvPlugin* p,
00846                                   float*            min_values,
00847                                   float*            max_values,
00848                                   float*            def_values);
00849 
00856 LILV_API
00857 uint32_t
00858 lilv_plugin_get_num_ports_of_class(const LilvPlugin* p,
00859                                    const LilvNode*   class_1, ...);
00860 
00866 LILV_API
00867 bool
00868 lilv_plugin_has_latency(const LilvPlugin* p);
00869 
00879 LILV_API
00880 uint32_t
00881 lilv_plugin_get_latency_port_index(const LilvPlugin* p);
00882 
00886 LILV_API
00887 const LilvPort*
00888 lilv_plugin_get_port_by_index(const LilvPlugin* plugin,
00889                               uint32_t          index);
00890 
00896 LILV_API
00897 const LilvPort*
00898 lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin,
00899                                const LilvNode*   symbol);
00900 
00910 LILV_API
00911 LilvPort*
00912 lilv_plugin_get_port_by_designation(const LilvPlugin* plugin,
00913                                     const LilvNode*   port_class,
00914                                     const LilvNode*   designation);
00915 
00922 LILV_API
00923 LilvNode*
00924 lilv_plugin_get_project(const LilvPlugin* plugin);
00925 
00931 LILV_API
00932 LilvNode*
00933 lilv_plugin_get_author_name(const LilvPlugin* plugin);
00934 
00940 LILV_API
00941 LilvNode*
00942 lilv_plugin_get_author_email(const LilvPlugin* plugin);
00943 
00949 LILV_API
00950 LilvNode*
00951 lilv_plugin_get_author_homepage(const LilvPlugin* plugin);
00952 
00959 LILV_API
00960 bool
00961 lilv_plugin_is_replaced(const LilvPlugin* plugin);
00962 
00969 LILV_API
00970 void
00971 lilv_plugin_write_description(LilvWorld*        world,
00972                               const LilvPlugin* plugin,
00973                               const LilvNode*   base_uri,
00974                               FILE*             plugin_file);
00975 
00982 LILV_API
00983 void
00984 lilv_plugin_write_manifest_entry(LilvWorld*        world,
00985                                  const LilvPlugin* plugin,
00986                                  const LilvNode*   base_uri,
00987                                  FILE*             manifest_file,
00988                                  const char*       plugin_file_path);
00989 
01003 LILV_API
01004 LilvNodes*
01005 lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type);
01006 
01016 LILV_API
01017 LilvNodes*
01018 lilv_port_get_value(const LilvPlugin* plugin,
01019                     const LilvPort*   port,
01020                     const LilvNode*   predicate);
01021 
01025 LILV_API
01026 LilvNodes*
01027 lilv_port_get_properties(const LilvPlugin* plugin,
01028                          const LilvPort*   port);
01029 
01033 LILV_API
01034 bool
01035 lilv_port_has_property(const LilvPlugin* p,
01036                        const LilvPort*   port,
01037                        const LilvNode*   property_uri);
01038 
01042 LILV_API
01043 bool
01044 lilv_port_supports_event(const LilvPlugin* p,
01045                          const LilvPort*   port,
01046                          const LilvNode*   event_uri);
01047 
01053 LILV_API
01054 uint32_t
01055 lilv_port_get_index(const LilvPlugin* plugin,
01056                     const LilvPort*   port);
01057 
01063 LILV_API
01064 const LilvNode*
01065 lilv_port_get_symbol(const LilvPlugin* plugin,
01066                      const LilvPort*   port);
01067 
01074 LILV_API
01075 LilvNode*
01076 lilv_port_get_name(const LilvPlugin* plugin,
01077                    const LilvPort*   port);
01078 
01086 LILV_API
01087 const LilvNodes*
01088 lilv_port_get_classes(const LilvPlugin* plugin,
01089                       const LilvPort*   port);
01090 
01099 LILV_API
01100 bool
01101 lilv_port_is_a(const LilvPlugin* plugin,
01102                const LilvPort*   port,
01103                const LilvNode*   port_class);
01104 
01113 LILV_API
01114 void
01115 lilv_port_get_range(const LilvPlugin* plugin,
01116                     const LilvPort*   port,
01117                     LilvNode**        deflt,
01118                     LilvNode**        min,
01119                     LilvNode**        max);
01120 
01128 LILV_API
01129 LilvScalePoints*
01130 lilv_port_get_scale_points(const LilvPlugin* plugin,
01131                            const LilvPort*   port);
01132 
01144 LILV_API
01145 LilvState*
01146 lilv_state_new_from_world(LilvWorld*      world,
01147                           LV2_URID_Map*   map,
01148                           const LilvNode* subject);
01149 
01163 LILV_API
01164 LilvState*
01165 lilv_state_new_from_file(LilvWorld*      world,
01166                          LV2_URID_Map*   map,
01167                          const LilvNode* subject,
01168                          const char*     path);
01169 
01173 LILV_API
01174 LilvState*
01175 lilv_state_new_from_string(LilvWorld*    world,
01176                            LV2_URID_Map* map,
01177                            const char*   str);
01178 
01189 typedef const void* (*LilvGetPortValueFunc)(const char* port_symbol,
01190                                             void*       user_data,
01191                                             uint32_t*   size,
01192                                             uint32_t*   type);
01193 
01251 LILV_API
01252 LilvState*
01253 lilv_state_new_from_instance(const LilvPlugin*          plugin,
01254                              LilvInstance*              instance,
01255                              LV2_URID_Map*              map,
01256                              const char*                file_dir,
01257                              const char*                copy_dir,
01258                              const char*                link_dir,
01259                              const char*                save_dir,
01260                              LilvGetPortValueFunc       get_value,
01261                              void*                      user_data,
01262                              uint32_t                   flags,
01263                              const LV2_Feature *const * features);
01264 
01268 LILV_API
01269 void
01270 lilv_state_free(LilvState* state);
01271 
01275 LILV_API
01276 bool
01277 lilv_state_equals(const LilvState* a, const LilvState* b);
01278 
01282 LILV_API
01283 unsigned
01284 lilv_state_get_num_properties(const LilvState* state);
01285 
01289 LILV_API
01290 const LilvNode*
01291 lilv_state_get_plugin_uri(const LilvState* state);
01292 
01296 LILV_API
01297 const char*
01298 lilv_state_get_label(const LilvState* state);
01299 
01303 LILV_API
01304 void
01305 lilv_state_set_label(LilvState*  state,
01306                      const char* label);
01307 
01316 typedef void (*LilvSetPortValueFunc)(const char* port_symbol,
01317                                      void*       user_data,
01318                                      const void* value,
01319                                      uint32_t    size,
01320                                      uint32_t    type);
01321 
01344 LILV_API
01345 void
01346 lilv_state_restore(const LilvState*           state,
01347                    LilvInstance*              instance,
01348                    LilvSetPortValueFunc       set_value,
01349                    void*                      user_data,
01350                    uint32_t                   flags,
01351                    const LV2_Feature *const * features);
01352 
01368 LILV_API
01369 int
01370 lilv_state_save(LilvWorld*                 world,
01371                 LV2_URID_Map*              map,
01372                 LV2_URID_Unmap*            unmap,
01373                 const LilvState*           state,
01374                 const char*                uri,
01375                 const char*                dir,
01376                 const char*                filename);
01377 
01381 LILV_API
01382 char*
01383 lilv_state_to_string(LilvWorld*       world,
01384                      LV2_URID_Map*    map,
01385                      LV2_URID_Unmap*  unmap,
01386                      const LilvState* state,
01387                      const char*      uri,
01388                      const char*      base_uri);
01389 
01400 LILV_API
01401 const LilvNode*
01402 lilv_scale_point_get_label(const LilvScalePoint* point);
01403 
01408 LILV_API
01409 const LilvNode*
01410 lilv_scale_point_get_value(const LilvScalePoint* point);
01411 
01423 LILV_API
01424 const LilvNode*
01425 lilv_plugin_class_get_parent_uri(const LilvPluginClass* plugin_class);
01426 
01431 LILV_API
01432 const LilvNode*
01433 lilv_plugin_class_get_uri(const LilvPluginClass* plugin_class);
01434 
01439 LILV_API
01440 const LilvNode*
01441 lilv_plugin_class_get_label(const LilvPluginClass* plugin_class);
01442 
01447 LILV_API
01448 LilvPluginClasses*
01449 lilv_plugin_class_get_children(const LilvPluginClass* plugin_class);
01450 
01461 /* Instance of a plugin.
01462    This is exposed in the ABI to allow inlining of performance critical
01463    functions like lilv_instance_run (simple wrappers of functions in lv2.h).
01464    This is for performance reasons, user code should not use this definition
01465    in any way (which is why it is not machine documented).
01466    Truly private implementation details are hidden via @a ref pimpl.
01467 */
01468 struct LilvInstanceImpl {
01469     const LV2_Descriptor* lv2_descriptor;
01470     LV2_Handle            lv2_handle;
01471     void*                 pimpl;
01472 };
01473 
01487 LILV_API
01488 LilvInstance*
01489 lilv_plugin_instantiate(const LilvPlugin*        plugin,
01490                         double                   sample_rate,
01491                         const LV2_Feature*const* features);
01492 
01498 LILV_API
01499 void
01500 lilv_instance_free(LilvInstance* instance);
01501 
01502 #ifndef LILV_INTERNAL
01503 
01508 static inline const char*
01509 lilv_instance_get_uri(const LilvInstance* instance)
01510 {
01511     return instance->lv2_descriptor->URI;
01512 }
01513 
01519 static inline void
01520 lilv_instance_connect_port(LilvInstance* instance,
01521                            uint32_t      port_index,
01522                            void*         data_location)
01523 {
01524     instance->lv2_descriptor->connect_port
01525         (instance->lv2_handle, port_index, data_location);
01526 }
01527 
01534 static inline void
01535 lilv_instance_activate(LilvInstance* instance)
01536 {
01537     if (instance->lv2_descriptor->activate)
01538         instance->lv2_descriptor->activate(instance->lv2_handle);
01539 }
01540 
01546 static inline void
01547 lilv_instance_run(LilvInstance* instance,
01548                   uint32_t      sample_count)
01549 {
01550     instance->lv2_descriptor->run(instance->lv2_handle, sample_count);
01551 }
01552 
01558 static inline void
01559 lilv_instance_deactivate(LilvInstance* instance)
01560 {
01561     if (instance->lv2_descriptor->deactivate)
01562         instance->lv2_descriptor->deactivate(instance->lv2_handle);
01563 }
01564 
01570 static inline const void*
01571 lilv_instance_get_extension_data(const LilvInstance* instance,
01572                                  const char*         uri)
01573 {
01574     if (instance->lv2_descriptor->extension_data)
01575         return instance->lv2_descriptor->extension_data(uri);
01576     else
01577         return NULL;
01578 }
01579 
01587 static inline const LV2_Descriptor*
01588 lilv_instance_get_descriptor(const LilvInstance* instance)
01589 {
01590     return instance->lv2_descriptor;
01591 }
01592 
01600 static inline LV2_Handle
01601 lilv_instance_get_handle(const LilvInstance* instance)
01602 {
01603     return instance->lv2_handle;
01604 }
01605 
01606 #endif /* LILV_INTERNAL */
01607 
01618 LILV_API
01619 LilvUIs*
01620 lilv_plugin_get_uis(const LilvPlugin* plugin);
01621 
01627 LILV_API
01628 const LilvNode*
01629 lilv_ui_get_uri(const LilvUI* ui);
01630 
01639 LILV_API
01640 const LilvNodes*
01641 lilv_ui_get_classes(const LilvUI* ui);
01642 
01648 LILV_API
01649 bool
01650 lilv_ui_is_a(const LilvUI* ui, const LilvNode* class_uri);
01651 
01658 typedef unsigned (*LilvUISupportedFunc)(const char* container_type_uri,
01659                                         const char* ui_type_uri);
01660 
01670 LILV_API
01671 unsigned
01672 lilv_ui_is_supported(const LilvUI*       ui,
01673                      LilvUISupportedFunc supported_func,
01674                      const LilvNode*     container_type,
01675                      const LilvNode**    ui_type);
01676 
01682 LILV_API
01683 const LilvNode*
01684 lilv_ui_get_bundle_uri(const LilvUI* ui);
01685 
01691 LILV_API
01692 const LilvNode*
01693 lilv_ui_get_binary_uri(const LilvUI* ui);
01694 
01700 #ifdef __cplusplus
01701 } /* extern "C" */
01702 #endif
01703 
01704 #endif /* LILV_LILV_H */