Topics | |
| Nodes | |
| Collections | |
| World | |
| Plugins | |
| Ports | |
| Plugin State | |
| Scale Points | |
| Plugin Classes | |
| Plugin Instances | |
| Plugin UIs | |
Typedefs | |
| typedef struct LilvPluginImpl | LilvPlugin |
| typedef struct LilvPluginClassImpl | LilvPluginClass |
| typedef struct LilvPortImpl | LilvPort |
| typedef struct LilvScalePointImpl | LilvScalePoint |
| typedef struct LilvUIImpl | LilvUI |
| typedef struct LilvNodeImpl | LilvNode |
| typedef struct LilvWorldImpl | LilvWorld |
| typedef struct LilvInstanceImpl | LilvInstance |
| typedef struct LilvStateImpl | LilvState |
| typedef void | LilvIter |
| typedef void | LilvPluginClasses |
| typedef void | LilvPlugins |
| typedef void | LilvScalePoints |
| typedef void | LilvUIs |
| typedef void | LilvNodes |
Functions | |
| LILV_API void | lilv_free (void *ptr) |
Scale Point | |
| LILV_API const LilvNode * | lilv_scale_point_get_label (const LilvScalePoint *point) |
| LILV_API const LilvNode * | lilv_scale_point_get_value (const LilvScalePoint *point) |
Plugin Class | |
| LILV_API const LilvNode * | lilv_plugin_class_get_parent_uri (const LilvPluginClass *plugin_class) |
| LILV_API const LilvNode * | lilv_plugin_class_get_uri (const LilvPluginClass *plugin_class) |
| LILV_API const LilvNode * | lilv_plugin_class_get_label (const LilvPluginClass *plugin_class) |
| LILV_API LilvPluginClasses * | lilv_plugin_class_get_children (const LilvPluginClass *plugin_class) |
Plugin Instance | |
| LILV_API LilvInstance * | lilv_plugin_instantiate (const LilvPlugin *plugin, double sample_rate, const LV2_Feature *const *features) |
| LILV_API void | lilv_instance_free (LilvInstance *instance) |
| static const char * | lilv_instance_get_uri (const LilvInstance *instance) |
| static void | lilv_instance_connect_port (LilvInstance *instance, uint32_t port_index, void *data_location) |
| static void | lilv_instance_activate (LilvInstance *instance) |
| static void | lilv_instance_run (LilvInstance *instance, uint32_t sample_count) |
| static void | lilv_instance_deactivate (LilvInstance *instance) |
| static const void * | lilv_instance_get_extension_data (const LilvInstance *instance, const char *uri) |
| static const LV2_Descriptor * | lilv_instance_get_descriptor (const LilvInstance *instance) |
| static LV2_Handle | lilv_instance_get_handle (const LilvInstance *instance) |
Detailed Description
This is the complete public C API of lilv.
Lilv is a simple yet powerful C API for using LV2 plugins.
For more information about LV2, see http://lv2plug.in. For more information about Lilv, see http://drobilla.net/software/lilv.
Macro Definition Documentation
◆ LILV_FOREACH
| #define LILV_FOREACH | ( | colltype, | |
| iter, | |||
| collection ) |
Iterate over each element of a collection.
◆ LILV_OPTION_DYN_MANIFEST
| #define LILV_OPTION_DYN_MANIFEST "http://drobilla.net/ns/lilv#dyn-manifest" |
Enable/disable dynamic manifest support. Dynamic manifest data will only be loaded if this option is true.
◆ LILV_OPTION_FILTER_LANG
| #define LILV_OPTION_FILTER_LANG "http://drobilla.net/ns/lilv#filter-lang" |
Enable/disable language filtering. Language filtering applies to any functions that return (a) value(s). With filtering enabled, Lilv will automatically return the best value(s) for the current LANG. With filtering disabled, all matching values will be returned regardless of language tag. Filtering is enabled by default.
Typedef Documentation
◆ LilvGetPortValueFunc
| typedef const void *(* LilvGetPortValueFunc) (const char *port_symbol, void *user_data, uint32_t *size, uint32_t *type) |
Function to get a port value.
- Parameters
-
port_symbol The symbol of the port. user_data The user_data passed to lilv_state_new_from_instance(). size (Output) The size of the returned value. type (Output) The URID of the type of the returned value.
- Returns
- A pointer to the port value.
◆ LilvInstance
| typedef struct LilvInstanceImpl LilvInstance |
Plugin instance.
◆ LilvIter
◆ LilvNode
| typedef struct LilvNodeImpl LilvNode |
Typed Value.
◆ LilvNodes
◆ LilvPlugin
| typedef struct LilvPluginImpl LilvPlugin |
LV2 Plugin.
◆ LilvPluginClass
| typedef struct LilvPluginClassImpl LilvPluginClass |
Plugin Class.
◆ LilvPluginClasses
| typedef void LilvPluginClasses |
A set of LilvPluginClass.
set<PluginClass>.
◆ LilvPlugins
| typedef void LilvPlugins |
A set of LilvPlugin.
set<Plugin>.
◆ LilvPort
| typedef struct LilvPortImpl LilvPort |
Port.
◆ LilvScalePoint
| typedef struct LilvScalePointImpl LilvScalePoint |
Scale Point.
◆ LilvScalePoints
| typedef void LilvScalePoints |
A set of LilvScalePoint.
set<ScalePoint>.
◆ LilvSetPortValueFunc
◆ LilvState
| typedef struct LilvStateImpl LilvState |
Plugin state.
◆ LilvUI
| typedef struct LilvUIImpl LilvUI |
Plugin UI.
◆ LilvUIs
◆ LilvUISupportedFunc
Function to determine whether a UI type is supported.
This is provided by the user and must return non-zero iff using a UI of type ui_type_uri in a container of type container_type_uri is supported.
◆ LilvWorld
| typedef struct LilvWorldImpl LilvWorld |
Lilv World.
Function Documentation
◆ lilv_file_uri_parse()
Convert a file URI string to a local path string. For example, "file://foo/bar%20one/baz.ttl" returns "/foo/bar one/baz.ttl". Return value must be freed by caller with lilv_free().
- Parameters
-
uri The file URI to parse. hostname If non-NULL, set to the hostname in the URI, if any.
- Returns
- uri converted to a path, or NULL on failure (URI is not local).
◆ lilv_free()
Free memory allocated by Lilv.
This function exists because some systems require memory allocated by a library to be freed by code in the same library. It is otherwise equivalent to the standard C free() function.
◆ lilv_instance_activate()
|
inlinestatic |
Activate a plugin instance. This resets all state information in the plugin, except for port data locations (as set by lilv_instance_connect_port()). This MUST be called before calling lilv_instance_run().
◆ lilv_instance_connect_port()
|
inlinestatic |
Connect a port to a data location. This may be called regardless of whether the plugin is activated, activation and deactivation does not destroy port connections.
◆ lilv_instance_deactivate()
|
inlinestatic |
Deactivate a plugin instance. Note that to run the plugin after this you must activate it, which will reset all state information (except port connections).
◆ lilv_instance_free()
| LILV_API void lilv_instance_free | ( | LilvInstance * | instance | ) |
Free a plugin instance. It is safe to call this function on NULL. instance is invalid after this call.
◆ lilv_instance_get_descriptor()
|
inlinestatic |
Get the LV2_Descriptor of the plugin instance. Normally hosts should not need to access the LV2_Descriptor directly, use the lilv_instance_* functions.
The returned descriptor is shared and must not be deleted.
◆ lilv_instance_get_extension_data()
|
inlinestatic |
Get extension data from the plugin instance. The type and semantics of the data returned is specific to the particular extension, though in all cases it is shared and must not be deleted.
◆ lilv_instance_get_handle()
|
inlinestatic |
Get the LV2_Handle of the plugin instance. Normally hosts should not need to access the LV2_Handle directly, use the lilv_instance_* functions.
The returned handle is shared and must not be deleted.
◆ lilv_instance_get_uri()
|
inlinestatic |
Get the URI of the plugin which instance is an instance of. Returned string is shared and must not be modified or deleted.
◆ lilv_instance_run()
|
inlinestatic |
Run instance for sample_count frames. If the hint lv2:hardRTCapable is set for this plugin, this function is guaranteed not to block.
◆ lilv_new_bool()
Create a new boolean value. Returned value must be freed by caller with lilv_node_free().
◆ lilv_new_file_uri()
Create a new file URI value.
- Parameters
-
world The world. host Host name, or NULL. path Path on host.
- Returns
- A new node that must be freed by caller.
Relative paths are resolved against the current working directory. Note that this may yield unexpected results if host is another machine.
Create a new file URI value.
Relative paths are resolved against the current working directory. Note that this may yield unexpected results if host is another machine.
- Parameters
-
world The world. host Host name, or NULL. path Path on host.
- Returns
- A new node that must be freed by caller.
◆ lilv_new_float()
Create a new floating point value. Returned value must be freed by caller with lilv_node_free().
◆ lilv_new_int()
Create a new integer value. Returned value must be freed by caller with lilv_node_free().
◆ lilv_new_string()
Create a new string value (with no language). Returned value must be freed by caller with lilv_node_free().
◆ lilv_new_uri()
Create a new URI value. Returned value must be freed by caller with lilv_node_free().
◆ lilv_node_as_blank()
Return this value as a blank node identifier, e.g. "genid03". Valid to call only if lilv_node_is_blank(value) returns true. Returned value is owned by value and must not be freed by caller.
Return this value as a blank node identifier, like "genid03".
Valid to call only if lilv_node_is_blank(value) returns true. Returned value is owned by value and must not be freed by caller.
◆ lilv_node_as_bool()
Return value as a bool. Valid to call only if lilv_node_is_bool(value) returns true.
◆ lilv_node_as_float()
Return value as a float. Valid to call only if lilv_node_is_float(value) or lilv_node_is_int(value) returns true.
◆ lilv_node_as_int()
Return value as an integer. Valid to call only if lilv_node_is_int(value) returns true.
◆ lilv_node_as_string()
◆ lilv_node_as_uri()
Return this value as a URI string, e.g. "http://example.org/foo". Valid to call only if lilv_node_is_uri(value) returns true. Returned value is owned by value and must not be freed by caller.
Return this value as a URI string, like "http://example.org/foo".
Valid to call only if lilv_node_is_uri(value) returns true. Returned value is owned by value and must not be freed by caller.
◆ lilv_node_duplicate()
◆ lilv_node_equals()
Return whether two values are equivalent.
◆ lilv_node_free()
Free a LilvNode. It is safe to call this function on NULL.
◆ lilv_node_get_path()
Return the path of a file URI node. Returns NULL if value is not a file URI. Returned value must be freed by caller with lilv_free().
◆ lilv_node_get_turtle_token()
Return this value as a Turtle/SPARQL token. Returned value must be freed by caller with lilv_free().
| URI | <http://example.org/foo > |
|---|---|
| QName | doap:name |
| String | "this is a string" |
| Float | 1.0 |
| Integer | 1 |
| Boolean | true |
Return this value as a Turtle/SPARQL token.
Returned value must be freed by caller with lilv_free().
Example tokens:
- URI: <http://example.org/foo>
- QName: doap:name
- String: "this is a string"
- Float: 1.0
- Integer: 1
- Boolean: true
◆ lilv_node_is_blank()
Return whether the value is a blank node (resource with no URI).
◆ lilv_node_is_bool()
◆ lilv_node_is_float()
Return whether this value is a decimal literal.
◆ lilv_node_is_int()
Return whether this value is an integer literal.
◆ lilv_node_is_literal()
◆ lilv_node_is_string()
Return whether this value is a string literal. Returns true if value is a string value (and not numeric).
◆ lilv_node_is_uri()
Return whether the value is a URI (resource).
◆ lilv_nodes_begin()
◆ lilv_nodes_contains()
Return whether values contains value.
◆ lilv_nodes_free()
◆ lilv_nodes_get()
◆ lilv_nodes_get_first()
◆ lilv_nodes_is_end()
◆ lilv_nodes_merge()
◆ lilv_nodes_next()
◆ lilv_nodes_size()
◆ lilv_plugin_class_get_children()
| LILV_API LilvPluginClasses * lilv_plugin_class_get_children | ( | const LilvPluginClass * | plugin_class | ) |
Get the subclasses of this plugin class. Returned value must be freed by caller with lilv_plugin_classes_free().
◆ lilv_plugin_class_get_label()
| LILV_API const LilvNode * lilv_plugin_class_get_label | ( | const LilvPluginClass * | plugin_class | ) |
Get the label of this plugin class, ie "Oscillators". Returned value is owned by plugin_class and must not be freed by caller.
Get the label of this plugin class, like "Oscillators".
Returned value is owned by plugin_class and must not be freed by caller.
◆ lilv_plugin_class_get_parent_uri()
| LILV_API const LilvNode * lilv_plugin_class_get_parent_uri | ( | const LilvPluginClass * | plugin_class | ) |
Get the URI of this class' superclass. Returned value is owned by plugin_class and must not be freed by caller. Returned value may be NULL, if class has no parent.
◆ lilv_plugin_class_get_uri()
| LILV_API const LilvNode * lilv_plugin_class_get_uri | ( | const LilvPluginClass * | plugin_class | ) |
Get the URI of this plugin class. Returned value is owned by plugin_class and must not be freed by caller.
◆ lilv_plugin_classes_begin()
| LILV_API LilvIter * lilv_plugin_classes_begin | ( | const LilvPluginClasses * | collection | ) |
◆ lilv_plugin_classes_free()
| LILV_API void lilv_plugin_classes_free | ( | LilvPluginClasses * | collection | ) |
◆ lilv_plugin_classes_get()
| LILV_API const LilvPluginClass * lilv_plugin_classes_get | ( | const LilvPluginClasses * | collection, |
| LilvIter * | i ) |
◆ lilv_plugin_classes_get_by_uri()
| LILV_API const LilvPluginClass * lilv_plugin_classes_get_by_uri | ( | const LilvPluginClasses * | classes, |
| const LilvNode * | uri ) |
Get a plugin class from classes by URI. Return value is shared (stored in classes) and must not be freed or modified by the caller in any way.
- Returns
- NULL if no plugin class with uri is found in classes.
◆ lilv_plugin_classes_is_end()
| LILV_API bool lilv_plugin_classes_is_end | ( | const LilvPluginClasses * | collection, |
| LilvIter * | i ) |
◆ lilv_plugin_classes_next()
| LILV_API LilvIter * lilv_plugin_classes_next | ( | const LilvPluginClasses * | collection, |
| LilvIter * | i ) |
◆ lilv_plugin_classes_size()
| LILV_API unsigned lilv_plugin_classes_size | ( | const LilvPluginClasses * | collection | ) |
◆ lilv_plugin_get_author_email()
| LILV_API LilvNode * lilv_plugin_get_author_email | ( | const LilvPlugin * | plugin | ) |
Get the email address of the plugin's author. Returns NULL if author email address is not present. Returned value must be freed by caller.
◆ lilv_plugin_get_author_homepage()
| LILV_API LilvNode * lilv_plugin_get_author_homepage | ( | const LilvPlugin * | plugin | ) |
Get the address of the plugin author's home page. Returns NULL if author homepage is not present. Returned value must be freed by caller.
◆ lilv_plugin_get_author_name()
| LILV_API LilvNode * lilv_plugin_get_author_name | ( | const LilvPlugin * | plugin | ) |
Get the full name of the plugin's author. Returns NULL if author name is not present. Returned value must be freed by caller.
◆ lilv_plugin_get_bundle_uri()
| LILV_API const LilvNode * lilv_plugin_get_bundle_uri | ( | const LilvPlugin * | plugin | ) |
Get the (resolvable) URI of the plugin's "main" bundle. This returns the URI of the bundle where the plugin itself was found. Note that the data for a plugin may be spread over many bundles, that is, lilv_plugin_get_data_uris() may return URIs which are not within this bundle.
Typical hosts should not need to use this function. Note this always returns a fully qualified URI. If you want a local filesystem path, use lilv_file_uri_parse().
- Returns
- a shared string which must not be modified or freed.
Get the (resolvable) URI of the plugin's "main" bundle.
This returns the URI of the bundle where the plugin itself was found. Note that the data for a plugin may be spread over many bundles, that is, lilv_plugin_get_data_uris() may return URIs which are not within this bundle.
Typical hosts should not need to use this function. Note this always returns a fully qualified URI. If you want a local filesystem path, use lilv_file_uri_parse().
- Returns
- A shared string which must not be modified or freed.
◆ lilv_plugin_get_class()
| LILV_API const LilvPluginClass * lilv_plugin_get_class | ( | const LilvPlugin * | plugin | ) |
Get the class this plugin belongs to (e.g. Filters).
Get the class this plugin belongs to (like "Filters" or "Effects").
◆ lilv_plugin_get_data_uris()
| LILV_API const LilvNodes * lilv_plugin_get_data_uris | ( | const LilvPlugin * | plugin | ) |
Get the (resolvable) URIs of the RDF data files that define a plugin. Typical hosts should not need to use this function. Note this always returns fully qualified URIs. If you want local filesystem paths, use lilv_file_uri_parse().
- Returns
- a list of complete URLs eg. "file:///foo/ABundle.lv2/aplug.ttl", which is shared and must not be modified or freed.
Get the (resolvable) URIs of the RDF data files that define a plugin.
Typical hosts should not need to use this function. Note this always returns fully qualified URIs. If you want local filesystem paths, use lilv_file_uri_parse().
- Returns
- A list of complete URLs eg. "file:///foo/ABundle.lv2/aplug.ttl", which is shared and must not be modified or freed.
◆ lilv_plugin_get_extension_data()
| LILV_API LilvNodes * lilv_plugin_get_extension_data | ( | const LilvPlugin * | p | ) |
Get a sequence of all extension data provided by a plugin. This can be used to find which URIs lilv_instance_get_extension_data() will return a value for without instantiating the plugin.
◆ lilv_plugin_get_latency_port_index()
| LILV_API uint32_t lilv_plugin_get_latency_port_index | ( | const LilvPlugin * | p | ) |
Return the index of the plugin's latency port. It is a fatal error to call this on a plugin without checking if the port exists by first calling lilv_plugin_has_latency().
Any plugin that introduces unwanted latency that should be compensated for (by hosts with the ability/need) MUST provide this port, which is a control rate output port that reports the latency for each cycle in frames.
◆ lilv_plugin_get_library_uri()
| LILV_API const LilvNode * lilv_plugin_get_library_uri | ( | const LilvPlugin * | plugin | ) |
Get the (resolvable) URI of the shared library for plugin. Note this always returns a fully qualified URI. If you want a local filesystem path, use lilv_file_uri_parse().
- Returns
- a shared string which must not be modified or freed.
Get the (resolvable) URI of the shared library for plugin.
Note this always returns a fully qualified URI. If you want a local filesystem path, use lilv_file_uri_parse().
- Returns
- A shared string which must not be modified or freed.
◆ lilv_plugin_get_modgui_icon_template()
| LILV_API LilvNode * lilv_plugin_get_modgui_icon_template | ( | const LilvPlugin * | plugin | ) |
◆ lilv_plugin_get_modgui_resources_directory()
| LILV_API LilvNode * lilv_plugin_get_modgui_resources_directory | ( | const LilvPlugin * | plugin | ) |
Custom calls
◆ lilv_plugin_get_modgui_screenshot()
| LILV_API LilvNode * lilv_plugin_get_modgui_screenshot | ( | const LilvPlugin * | plugin | ) |
◆ lilv_plugin_get_modgui_settings_template()
| LILV_API LilvNode * lilv_plugin_get_modgui_settings_template | ( | const LilvPlugin * | plugin | ) |
◆ lilv_plugin_get_modgui_stylesheet()
| LILV_API LilvNode * lilv_plugin_get_modgui_stylesheet | ( | const LilvPlugin * | plugin | ) |
◆ lilv_plugin_get_modgui_template_data()
| LILV_API LilvNode * lilv_plugin_get_modgui_template_data | ( | const LilvPlugin * | plugin | ) |
◆ lilv_plugin_get_modgui_thumbnail()
| LILV_API LilvNode * lilv_plugin_get_modgui_thumbnail | ( | const LilvPlugin * | plugin | ) |
◆ lilv_plugin_get_name()
| LILV_API LilvNode * lilv_plugin_get_name | ( | const LilvPlugin * | plugin | ) |
Get the name of plugin. This returns the name (doap:name) of the plugin. The name may be translated according to the current locale, this value MUST NOT be used as a plugin identifier (use the URI for that). Returned value must be freed by the caller.
◆ lilv_plugin_get_num_ports()
| LILV_API uint32_t lilv_plugin_get_num_ports | ( | const LilvPlugin * | p | ) |
Get the number of ports on this plugin.
◆ lilv_plugin_get_num_ports_of_class()
| LILV_API uint32_t lilv_plugin_get_num_ports_of_class | ( | const LilvPlugin * | p, |
| const LilvNode * | class_1, | ||
| ... ) |
Get the number of ports on this plugin that are members of some class(es). Note that this is a varargs function so ports fitting any type 'profile' desired can be found quickly. REMEMBER TO TERMINATE THE PARAMETER LIST OF THIS FUNCTION WITH NULL OR VERY NASTY THINGS WILL HAPPEN.
◆ lilv_plugin_get_num_ports_of_class_va()
| LILV_API uint32_t lilv_plugin_get_num_ports_of_class_va | ( | const LilvPlugin * | p, |
| const LilvNode * | class_1, | ||
| va_list | args ) |
Variant of lilv_plugin_get_num_ports_of_class() that takes a va_list.
This function calls va_arg() on args but does not call va_end().
◆ lilv_plugin_get_optional_features()
| LILV_API LilvNodes * lilv_plugin_get_optional_features | ( | const LilvPlugin * | p | ) |
Get the LV2 Features optionally supported by a plugin. Hosts MAY ignore optional plugin features for whatever reasons. Plugins MUST operate (at least somewhat) if they are instantiated without being passed optional features.
Return value must be freed by caller with lilv_nodes_free().
◆ lilv_plugin_get_port_by_designation()
| LILV_API const LilvPort * lilv_plugin_get_port_by_designation | ( | const LilvPlugin * | plugin, |
| const LilvNode * | port_class, | ||
| const LilvNode * | designation ) |
Get a port on plugin by its lv2:designation.
The designation of a port describes the meaning, assignment, allocation or role of the port, e.g. "left channel" or "gain". If found, the port with matching port_class and designation is be returned, otherwise NULL is returned. The port_class can be used to distinguish the input and output ports for a particular designation. If port_class is NULL, any port with the given designation will be returned.
Get a port on plugin by its lv2:designation.
The designation of a port describes the meaning, assignment, allocation or role of the port, like "left channel" or "gain". If found, the port with matching port_class and designation is be returned, otherwise NULL is returned. The port_class can be used to distinguish the input and output ports for a particular designation. If port_class is NULL, any port with the given designation will be returned.
◆ lilv_plugin_get_port_by_index()
| LILV_API const LilvPort * lilv_plugin_get_port_by_index | ( | const LilvPlugin * | plugin, |
| uint32_t | index ) |
Get a port on plugin by index.
◆ lilv_plugin_get_port_by_symbol()
| LILV_API const LilvPort * lilv_plugin_get_port_by_symbol | ( | const LilvPlugin * | plugin, |
| const LilvNode * | symbol ) |
Get a port on plugin by symbol. Note this function is slower than lilv_plugin_get_port_by_index(), especially on plugins with a very large number of ports.
◆ lilv_plugin_get_port_ranges_float()
| LILV_API void lilv_plugin_get_port_ranges_float | ( | const LilvPlugin * | p, |
| float * | min_values, | ||
| float * | max_values, | ||
| float * | def_values ) |
Get the port ranges (minimum, maximum and default values) for all ports. min_values, max_values and def_values must either point to an array of N floats, where N is the value returned by lilv_plugin_get_num_ports() for this plugin, or NULL. The elements of the array will be set to the the minimum, maximum and default values of the ports on this plugin, with array index corresponding to port index. If a port doesn't have a minimum, maximum or default value, or the port's type is not float, the corresponding array element will be set to NAN.
This is a convenience method for the common case of getting the range of all float ports on a plugin, and may be significantly faster than repeated calls to lilv_port_get_range().
◆ lilv_plugin_get_project()
| LILV_API LilvNode * lilv_plugin_get_project | ( | const LilvPlugin * | plugin | ) |
Get the project the plugin is a part of.
More information about the project can be read via lilv_world_find_nodes(), typically using properties from DOAP (e.g. doap:name).
Get the project the plugin is a part of.
More information about the project can be read via lilv_world_find_nodes(), typically using properties from DOAP (such as doap:name).
◆ lilv_plugin_get_related()
Get the resources related to plugin with lv2:appliesTo.
Some plugin-related resources are not linked directly to the plugin with rdfs:seeAlso and thus will not be automatically loaded along with the plugin data (usually for performance reasons). All such resources of the given type related to plugin can be accessed with this function.
If type is NULL, all such resources will be returned, regardless of type.
To actually load the data for each returned resource, use lilv_world_load_resource().
◆ lilv_plugin_get_required_features()
| LILV_API LilvNodes * lilv_plugin_get_required_features | ( | const LilvPlugin * | p | ) |
Get the LV2 Features required by a plugin. If a feature is required by a plugin, hosts MUST NOT use the plugin if they do not understand (or are unable to support) that feature.
All values returned here MUST be passed to the plugin's instantiate method (along with data, if necessary, as defined by the feature specification) or plugin instantiation will fail.
Return value must be freed by caller with lilv_nodes_free().
◆ lilv_plugin_get_supported_features()
| LILV_API LilvNodes * lilv_plugin_get_supported_features | ( | const LilvPlugin * | p | ) |
Get the LV2 Features supported (required or optionally) by a plugin. A feature is "supported" by a plugin if it is required OR optional.
Since required features have special rules the host must obey, this function probably shouldn't be used by normal hosts. Using lilv_plugin_get_optional_features() and lilv_plugin_get_required_features() separately is best in most cases.
Returned value must be freed by caller with lilv_nodes_free().
◆ lilv_plugin_get_uis()
| LILV_API LilvUIs * lilv_plugin_get_uis | ( | const LilvPlugin * | plugin | ) |
Get all UIs for plugin. Returned value must be freed by caller using lilv_uis_free().
◆ lilv_plugin_get_uri()
| LILV_API const LilvNode * lilv_plugin_get_uri | ( | const LilvPlugin * | plugin | ) |
Get the URI of plugin. Any serialization that refers to plugins should refer to them by this. Hosts SHOULD NOT save any filesystem paths, plugin indexes, etc. in saved files; save only the URI.
The URI is a globally unique identifier for one specific plugin. Two plugins with the same URI are compatible in port signature, and should be guaranteed to work in a compatible and consistent way. If a plugin is upgraded in an incompatible way (eg if it has different ports), it MUST have a different URI than it's predecessor.
- Returns
- A shared URI value which must not be modified or freed.
◆ lilv_plugin_get_value()
Get a value associated with the plugin in a plugin's data files. predicate must be either a URI or a QName.
Returns the ?object of all triples found of the form:
<plugin-uri> predicate ?object
May return NULL if the property was not found, or if object(s) is not sensibly represented as a LilvNodes (e.g. blank nodes). Return value must be freed by caller with lilv_nodes_free().
Get a value associated with the plugin in a plugin's data files.
predicate must be either a URI or a QName.
Returns the ?object of all triples found of the form:
<plugin-uri> predicate ?object
May return NULL if the property was not found, or if object(s) is not sensibly represented as a LilvNodes.
Return value must be freed by caller with lilv_nodes_free().
◆ lilv_plugin_has_extension_data()
| LILV_API bool lilv_plugin_has_extension_data | ( | const LilvPlugin * | p, |
| const LilvNode * | uri ) |
Return whether or not a plugin provides a specific extension data.
◆ lilv_plugin_has_feature()
| LILV_API bool lilv_plugin_has_feature | ( | const LilvPlugin * | p, |
| const LilvNode * | feature_uri ) |
Return whether a feature is supported by a plugin. This will return true if the feature is an optional or required feature of the plugin.
◆ lilv_plugin_has_latency()
| LILV_API bool lilv_plugin_has_latency | ( | const LilvPlugin * | p | ) |
Return whether or not the plugin introduces (and reports) latency. The index of the latency port can be found with lilv_plugin_get_latency_port() ONLY if this function returns true.
◆ lilv_plugin_instantiate()
| LILV_API LilvInstance * lilv_plugin_instantiate | ( | const LilvPlugin * | plugin, |
| double | sample_rate, | ||
| const LV2_Feature *const * | features ) |
Instantiate a plugin. The returned value is a lightweight handle for an LV2 plugin instance, it does not refer to plugin, or any other Lilv state. The caller must eventually free it with lilv_instance_free(). features is a NULL-terminated array of features the host supports. NULL may be passed if the host supports no additional features.
- Returns
- NULL if instantiation failed.
◆ lilv_plugin_is_replaced()
| LILV_API bool lilv_plugin_is_replaced | ( | const LilvPlugin * | plugin | ) |
Return true iff plugin has been replaced by another plugin.
The plugin will still be usable, but hosts should hide them from their user interfaces to prevent users from using deprecated plugins.
◆ lilv_plugin_verify()
| LILV_API bool lilv_plugin_verify | ( | const LilvPlugin * | plugin | ) |
Check if plugin is valid. This is not a rigorous validator, but can be used to reject some malformed plugins that could cause bugs (e.g. plugins with missing required fields).
Note that normal hosts do NOT need to use this - lilv does not load invalid plugins into plugin lists. This is included for plugin testing utilities, etc.
- Returns
- true iff plugin is valid.
Check if plugin is valid.
This is not a rigorous validator, but can be used to reject some malformed plugins that could cause bugs (for example, plugins with missing required fields).
Note that normal hosts do NOT need to use this - lilv does not load invalid plugins into plugin lists. This is included for plugin testing utilities, etc.
- Returns
- True iff plugin is valid.
◆ lilv_plugin_write_description()
| LILV_API void lilv_plugin_write_description | ( | LilvWorld * | world, |
| const LilvPlugin * | plugin, | ||
| const LilvNode * | base_uri, | ||
| FILE * | plugin_file ) |
Write the Turtle description of plugin to plugin_file.
This function is particularly useful for porting plugins in conjunction with an LV2 bridge such as NASPRO.
◆ lilv_plugin_write_manifest_entry()
| LILV_API void lilv_plugin_write_manifest_entry | ( | LilvWorld * | world, |
| const LilvPlugin * | plugin, | ||
| const LilvNode * | base_uri, | ||
| FILE * | manifest_file, | ||
| const char * | plugin_file_path ) |
Write a manifest entry for plugin to manifest_file.
This function is intended for use with lilv_plugin_write_description() to write a complete description of a plugin to a bundle.
◆ lilv_plugins_begin()
| LILV_API LilvIter * lilv_plugins_begin | ( | const LilvPlugins * | collection | ) |
◆ lilv_plugins_get()
| LILV_API const LilvPlugin * lilv_plugins_get | ( | const LilvPlugins * | collection, |
| LilvIter * | i ) |
◆ lilv_plugins_get_by_uri()
| LILV_API const LilvPlugin * lilv_plugins_get_by_uri | ( | const LilvPlugins * | plugins, |
| const LilvNode * | uri ) |
Get a plugin from plugins by URI. Return value is shared (stored in plugins) and must not be freed or modified by the caller in any way.
- Returns
- NULL if no plugin with uri is found in plugins.
◆ lilv_plugins_is_end()
| LILV_API bool lilv_plugins_is_end | ( | const LilvPlugins * | collection, |
| LilvIter * | i ) |
◆ lilv_plugins_next()
| LILV_API LilvIter * lilv_plugins_next | ( | const LilvPlugins * | collection, |
| LilvIter * | i ) |
◆ lilv_plugins_size()
| LILV_API unsigned lilv_plugins_size | ( | const LilvPlugins * | collection | ) |
◆ lilv_port_get()
| LILV_API LilvNode * lilv_port_get | ( | const LilvPlugin * | plugin, |
| const LilvPort * | port, | ||
| const LilvNode * | predicate ) |
Get a single property value of a port.
This is equivalent to lilv_nodes_get_first(lilv_port_get_value(...)) but is simpler to use in the common case of only caring about one value. The caller is responsible for freeing the returned node.
◆ lilv_port_get_classes()
| LILV_API const LilvNodes * lilv_port_get_classes | ( | const LilvPlugin * | plugin, |
| const LilvPort * | port ) |
Get all the classes of a port. This can be used to determine if a port is an input, output, audio, control, midi, etc, etc, though it's simpler to use lilv_port_is_a(). The returned list does not include lv2:Port, which is implied. Returned value is shared and must not be destroyed by caller.
◆ lilv_port_get_index()
Get the index of a port. The index is only valid for the life of the plugin and may change between versions. For a stable identifier, use the symbol.
◆ lilv_port_get_name()
Get the name of a port. This is guaranteed to return the untranslated name (the doap:name in the data file without a language tag). Returned value must be freed by the caller.
◆ lilv_port_get_node()
Get the RDF node of port.
Ports nodes may be may be URIs or blank nodes.
- Returns
- A shared node which must not be modified or freed.
◆ lilv_port_get_properties()
Return the LV2 port properties of a port.
◆ lilv_port_get_range()
| LILV_API void lilv_port_get_range | ( | const LilvPlugin * | plugin, |
| const LilvPort * | port, | ||
| LilvNode ** | deflt, | ||
| LilvNode ** | min, | ||
| LilvNode ** | max ) |
Get the default, minimum, and maximum values of a port.
def, min, and max are outputs, pass pointers to uninitialized LilvNode* variables. These will be set to point at new values (which must be freed by the caller using lilv_node_free()), or NULL if the value does not exist.
◆ lilv_port_get_scale_points()
| LILV_API LilvScalePoints * lilv_port_get_scale_points | ( | const LilvPlugin * | plugin, |
| const LilvPort * | port ) |
Get the scale points (enumeration values) of a port. This returns a collection of 'interesting' named values of a port (e.g. appropriate entries for a UI selector associated with this port). Returned value may be NULL if port has no scale points, otherwise it must be freed by caller with lilv_scale_points_free().
Get the scale points (enumeration values) of a port.
This returns a collection of 'interesting' named values of a port, which for example might be appropriate entries for a value selector in a UI.
Returned value may be NULL if port has no scale points, otherwise it must be freed by caller with lilv_scale_points_free().
◆ lilv_port_get_symbol()
Get the symbol of a port. The 'symbol' is a short string, a valid C identifier. Returned value is owned by port and must not be freed.
◆ lilv_port_get_value()
| LILV_API LilvNodes * lilv_port_get_value | ( | const LilvPlugin * | plugin, |
| const LilvPort * | port, | ||
| const LilvNode * | predicate ) |
Port analog of lilv_plugin_get_value().
◆ lilv_port_has_property()
| LILV_API bool lilv_port_has_property | ( | const LilvPlugin * | p, |
| const LilvPort * | port, | ||
| const LilvNode * | property_uri ) |
Return whether a port has a certain property.
◆ lilv_port_is_a()
| LILV_API bool lilv_port_is_a | ( | const LilvPlugin * | plugin, |
| const LilvPort * | port, | ||
| const LilvNode * | port_class ) |
Determine if a port is of a given class (input, output, audio, etc). For convenience/performance/extensibility reasons, hosts are expected to create a LilvNode for each port class they "care about". Well-known type URI strings are defined (e.g. LILV_URI_INPUT_PORT) for convenience, but this function is designed so that Lilv is usable with any port types without requiring explicit support in Lilv.
Determine if a port is of a given class (input, output, audio, etc).
For convenience/performance/extensibility reasons, hosts are expected to create a LilvNode for each port class they "care about". Well-known type URI strings like LILV_URI_INPUT_PORT are defined for convenience, but this function is designed so that Lilv is usable with any port types without requiring explicit support in Lilv.
◆ lilv_port_supports_event()
| LILV_API bool lilv_port_supports_event | ( | const LilvPlugin * | p, |
| const LilvPort * | port, | ||
| const LilvNode * | event_type ) |
Return whether a port supports a certain event type.
More precisely, this returns true iff the port has an atom:supports or an ev:supportsEvent property with event_type as the value.
◆ lilv_scale_point_get_label()
| LILV_API const LilvNode * lilv_scale_point_get_label | ( | const LilvScalePoint * | point | ) |
Get the label of this scale point (enumeration value) Returned value is owned by point and must not be freed.
Get the label of this scale point (enumeration value).
Returned value is owned by point and must not be freed.
◆ lilv_scale_point_get_value()
| LILV_API const LilvNode * lilv_scale_point_get_value | ( | const LilvScalePoint * | point | ) |
Get the value of this scale point (enumeration value) Returned value is owned by point and must not be freed.
Get the value of this scale point (enumeration value).
Returned value is owned by point and must not be freed.
◆ lilv_scale_points_begin()
| LILV_API LilvIter * lilv_scale_points_begin | ( | const LilvScalePoints * | collection | ) |
◆ lilv_scale_points_free()
| LILV_API void lilv_scale_points_free | ( | LilvScalePoints * | collection | ) |
◆ lilv_scale_points_get()
| LILV_API const LilvScalePoint * lilv_scale_points_get | ( | const LilvScalePoints * | collection, |
| LilvIter * | i ) |
◆ lilv_scale_points_is_end()
| LILV_API bool lilv_scale_points_is_end | ( | const LilvScalePoints * | collection, |
| LilvIter * | i ) |
◆ lilv_scale_points_next()
| LILV_API LilvIter * lilv_scale_points_next | ( | const LilvScalePoints * | collection, |
| LilvIter * | i ) |
◆ lilv_scale_points_size()
| LILV_API unsigned lilv_scale_points_size | ( | const LilvScalePoints * | collection | ) |
◆ lilv_state_delete()
Unload a state from the world and delete all associated files.
This function DELETES FILES/DIRECTORIES FROM THE FILESYSTEM! It is intended for removing user-saved presets, but can delete any state the user has permission to delete, including presets shipped with plugins.
The rdfs:seeAlso file for the state will be removed. The entry in the bundle's manifest.ttl is removed, and if this results in an empty manifest, then the manifest file is removed. If this results in an empty bundle, then the bundle directory is removed as well.
Unload a state from the world and delete all associated files.
This function DELETES FILES/DIRECTORIES FROM THE FILESYSTEM! It is intended for removing user-saved presets, but can delete any state the user has permission to delete, including presets shipped with plugins.
The rdfs:seeAlso file for the state will be removed. The entry in the bundle's manifest.ttl is removed, and if this results in an empty manifest, then the manifest file is removed. If this results in an empty bundle, then the bundle directory is removed as well.
◆ lilv_state_emit_port_values()
| LILV_API void lilv_state_emit_port_values | ( | const LilvState * | state, |
| LilvSetPortValueFunc | set_value, | ||
| void * | user_data ) |
Enumerate the port values in a state snapshot.
- Parameters
-
State The state to retrieve port values from. set_value A function to receive port values. user_data User data to pass to set_value.
This function is a subset of lilv_state_restore() that only fires the set_value callback and does not directly affect a plugin instance. This is useful in hosts that need to retrieve the port values in a state snapshot for special handling.
Enumerate the port values in a state snapshot.
This function is a subset of lilv_state_restore() that only fires the set_value callback and does not directly affect a plugin instance. This is useful in hosts that need to retrieve the port values in a state snapshot for special handling.
- Parameters
-
State The state to retrieve port values from. set_value A function to receive port values. user_data User data to pass to set_value.
◆ lilv_state_equals()
◆ lilv_state_free()
◆ lilv_state_get_label()
◆ lilv_state_get_num_properties()
Return the number of properties in State.
◆ lilv_state_get_plugin_uri()
Get the URI of the plugin State applies to.
◆ lilv_state_get_uri()
Get the URI of State.
This may return NULL if the state has not been saved and has no URI.
◆ lilv_state_new_from_file()
| LILV_API LilvState * lilv_state_new_from_file | ( | LilvWorld * | world, |
| const LV2_URID_Map * | map, | ||
| const LilvNode * | subject, | ||
| const char * | path ) |
Load a state snapshot from a file.
- Parameters
-
world The world. map URID mapper. subject The subject of the state description (e.g. a preset URI). path The path of the file containing the state description.
- Returns
- A new LilvState which must be freed with lilv_state_free().
If subject is NULL, it is taken to be the URI of the file (i.e. "<>" in Turtle).
This function parses the file separately to create the state, it does not parse the file into the world model, i.e. the returned state is the only new memory consumed once this function returns.
◆ lilv_state_new_from_instance()
| LILV_API LilvState * lilv_state_new_from_instance | ( | const LilvPlugin * | plugin, |
| LilvInstance * | instance, | ||
| LV2_URID_Map * | map, | ||
| const char * | file_dir, | ||
| const char * | copy_dir, | ||
| const char * | link_dir, | ||
| const char * | save_dir, | ||
| LilvGetPortValueFunc | get_value, | ||
| void * | user_data, | ||
| uint32_t | flags, | ||
| const LV2_Feature *const * | features ) |
Create a new state snapshot from a plugin instance.
- Parameters
-
plugin The plugin this state applies to. instance An instance of plugin. map The map to use for mapping URIs in state. file_dir Directory of files created by the plugin earlier (or NULL). This is for hosts that support file creation at any time with state state:makePath. These files will be copied as necessary to copy_dir and not be referred to directly in state (a temporary directory is appropriate). copy_dir Directory of copies of files in file_dir (or NULL). This directory will have the same structure as file_dir but with possibly modified file names to distinguish different revisions. If you only care about saving one state snapshot, it can be the same as save_dir. Plugin state will refer to files in this directory. save_dir Directory of files created by plugin during save (or NULL). If the state will be saved, this should be the bundle directory later passed to lilv_state_save(). get_value Function to get port values (or NULL). If NULL, the returned state will not represent port values. This should only be NULL in hosts that save and restore port values via some other mechanism. user_data User data to pass to get_value. link_dir Directory of links to external files (or NULL). A link will be made in this directory to any external files referred to in plugin state. In turn, links will be created in the save directory to these links (e.g. save_dir/file => link_dir/file => /foo/bar/file). This allows many state snapshots to share a single link to an external file, so archival (e.g. with tar -h) will not create several copies of the file. If this is not required, it can be the same as save_dir. flags Bitwise OR of LV2_State_Flags values. features Features to pass LV2_State_Interface.save().
- Returns
- A new LilvState which must be freed with lilv_state_free().
This function may be called simultaneously with any instance function (except discovery functions) unless the threading class of that function explicitly disallows this.
To support advanced file functionality, there are several directory parameters. Simple hosts that only wish to save a single plugins state once may simply use the same directory for all of them (or pass NULL to not support files at all). The multiple parameters are necessary to support saving an instances state many times while avoiding any duplication of data.
If supported (via state:makePath passed to LV2_Descriptor::instantiate()), file_dir should be the directory where any files created by the plugin (not during save time, e.g. during instantiation) are stored. These files will be copied to preserve their state at this time.plugin-created files are stored. Lilv will assume any files within this directory (recursively) are created by the plugin and all other files are immutable. Note that this function does not save the state, use lilv_state_save() for that.
See state.h from the LV2 State extension for details on the flags and features parameters.
Create a new state snapshot from a plugin instance.
This function may be called simultaneously with any instance function (except discovery functions) unless the threading class of that function explicitly disallows this.
To support advanced file functionality, there are several directory parameters. The multiple parameters are necessary to support saving an instance's state many times, or saving states from multiple instances, while avoiding any duplication of data. For example, a host could pass the same copy_dir and link_dir for all plugins in a session (for example session/shared/copy/ session/shared/link/), while the save_dir would be unique to each plugin instance (for example session/states/state1.lv2 for one instance and session/states/state2.lv2 for another instance). Simple hosts that only wish to save a single plugin's state once may simply use the same directory for all of them, or pass NULL to not support files at all.
If supported (via state:makePath passed to LV2_Descriptor::instantiate()), scratch_dir should be the directory where any files created by the plugin (for example during instantiation or while running) are stored. Any files here that are referred to in the state will be copied to preserve their contents at the time of the save. Lilv will assume any files within this directory (recursively) are created by the plugin and that all other files are immutable. Note that this function does not completely save the state, use lilv_state_save() for that.
See state.h from the LV2 State extension for details on the flags and features parameters.
- Parameters
-
plugin The plugin this state applies to. instance An instance of plugin. map The map to use for mapping URIs in state. scratch_dir Directory of files created by the plugin earlier, or NULL. This is for hosts that support file creation at any time with state state:makePath. These files will be copied as necessary to copy_dir and not be referred to directly in state (a temporary directory is appropriate). copy_dir Directory of copies of files in scratch_dir, or NULL. This directory will have the same structure as scratch_dir but with possibly modified file names to distinguish revisions. This allows the saved state to contain the exact contents of the scratch file at save time, so that the state is not ruined if the file is later modified (for example, by the plugin continuing to record). This can be the same as save_dir to create a copy in the state bundle, but can also be a separate directory which allows multiple state snapshots to share a single copy if the file has not changed. link_dir Directory of links to external files, or NULL. A link will be made in this directory to any external files referred to in plugin state. In turn, links will be created in the save directory to these links (like save_dir/file => link_dir/file => /foo/bar/file). This allows many state snapshots to share a single link to an external file, so archival (for example, with tar -h) will not create several copies of the file. If this is not required, it can be the same as save_dir. save_dir Directory of files created by plugin during save (or NULL). This is typically the bundle directory later passed to lilv_state_save(). get_value Function to get port values (or NULL). If NULL, the returned state will not represent port values. This should only be NULL in hosts that save and restore port values via some other mechanism. user_data User data to pass to get_value. flags Bitwise OR of LV2_State_Flags values. features Features to pass LV2_State_Interface.save().
- Returns
- A new LilvState which must be freed with lilv_state_free().
◆ lilv_state_new_from_string()
| LILV_API LilvState * lilv_state_new_from_string | ( | LilvWorld * | world, |
| const LV2_URID_Map * | map, | ||
| const char * | str ) |
Load a state snapshot from a string made by lilv_state_to_string().
◆ lilv_state_new_from_world()
| LILV_API LilvState * lilv_state_new_from_world | ( | LilvWorld * | world, |
| const LV2_URID_Map * | map, | ||
| const LilvNode * | subject ) |
Load a state snapshot from the world RDF model. This function can be used to load the default state of a plugin by passing the plugin URI as the subject parameter.
- Parameters
-
world The world. map URID mapper. subject The subject of the state description (e.g. a preset URI).
- Returns
- A new LilvState which must be freed with lilv_state_free(), or NULL.
◆ lilv_state_restore()
| LILV_API void lilv_state_restore | ( | const LilvState * | state, |
| const LV2_State_Interface * | iface, | ||
| LV2_Handle | handle, | ||
| LilvSetPortValueFunc | set_value, | ||
| void * | user_data, | ||
| uint32_t | flags, | ||
| const LV2_Feature *const * | features ) |
Restore a plugin instance from a state snapshot.
- Parameters
-
State The state to restore, which must apply to the correct plugin. instance An instance of the plugin State applies to, or NULL. set_value A function to set a port value (may be NULL). user_data User data to pass to set_value. flags Bitwise OR of LV2_State_Flags values. features Features to pass LV2_State_Interface.restore().
This will set all the properties of instance, if given, to the values stored in State. If set_value is provided, it will be called (with the given user_data) to restore each port value, otherwise the host must restore the port values itself (using lilv_state_get_port_value()) in order to completely restore State.
If the state has properties and instance is given, this function is in the "instantiation" threading class, i.e. it MUST NOT be called simultaneously with any function on the same plugin instance. If the state has no properties, only port values are set via set_value.
See state.h from the LV2 State extension for details on the flags and features parameters.
◆ lilv_state_save()
| LILV_API int lilv_state_save | ( | LilvWorld * | world, |
| LV2_URID_Map * | map, | ||
| LV2_URID_Unmap * | unmap, | ||
| const LilvState * | state, | ||
| const char * | uri, | ||
| const char * | dir, | ||
| const char * | filename ) |
Save state to a file.
- Parameters
-
world The world. map URID mapper. unmap URID unmapper. State State to save. uri URI of state, may be NULL. dir Path of the bundle directory to save into. filename Path of the state file relative to dir.
The format of state on disk is compatible with that defined in the LV2 preset extension, i.e. this function may be used to save presets which can be loaded by any host.
If uri is NULL, the preset URI will be a file URI, but the bundle can safely be moved (i.e. the state file will use "<>" as the subject).
Save state to a file.
The format of state on disk is compatible with that defined in the LV2 preset extension, so this function may be used to save presets which can be loaded by any host.
If uri is NULL, the preset URI will be a file URI, but the bundle can safely be moved (the state file will use <> as the subject).
◆ lilv_state_set_label()
Set the label of State.
◆ lilv_state_set_metadata()
| LILV_API int lilv_state_set_metadata | ( | LilvState * | state, |
| uint32_t | key, | ||
| const void * | value, | ||
| size_t | size, | ||
| uint32_t | type, | ||
| uint32_t | flags ) |
Set a metadata property on State.
- Parameters
-
State The state to set the metadata for. key The key to store value under (URID). value Pointer to the value to be stored. size The size of value in bytes. type The type of value (URID). flags LV2_State_Flags for value.
- Returns
- 0 on success.
This is a generic version of lilv_state_set_label(), which sets metadata properties visible to hosts, but not plugins. This allows storing useful information such as comments or preset banks.
Set a metadata property on State.
This is a generic version of lilv_state_set_label(), which sets metadata properties visible to hosts, but not plugins. This allows storing useful information such as comments or preset banks.
- Parameters
-
State The state to set the metadata for. key The key to store value under (URID). value Pointer to the value to be stored. size The size of value in bytes. type The type of value (URID). flags LV2_State_Flags for value.
- Returns
- Zero on success.
◆ lilv_state_to_string()
| LILV_API char * lilv_state_to_string | ( | LilvWorld * | world, |
| LV2_URID_Map * | map, | ||
| LV2_URID_Unmap * | unmap, | ||
| const LilvState * | state, | ||
| const char * | uri, | ||
| const char * | base_uri ) |
Save state to a string. This function does not use the filesystem.
- Parameters
-
world The world. map URID mapper. unmap URID unmapper. State The state to serialize. uri URI for the state description (mandatory). base_uri Base URI for serialisation. Unless you know what you are doing, pass NULL for this, otherwise the state may not be restorable via lilv_state_new_from_string().
◆ lilv_ui_get_binary_uri()
◆ lilv_ui_get_bundle_uri()
◆ lilv_ui_get_classes()
Get the types (URIs of RDF classes) of a Plugin UI.
- Returns
- a shared value which must not be modified or freed.
Note that in most cases lilv_ui_is_supported() should be used, which avoids the need to use this function (and type specific logic).
Get the types (URIs of RDF classes) of a Plugin UI.
Note that in most cases lilv_ui_is_supported() should be used, which avoids the need to use this function (and type specific logic).
- Returns
- A shared value which must not be modified or freed.
◆ lilv_ui_get_extension_data()
◆ lilv_ui_get_optional_features()
◆ lilv_ui_get_required_features()
◆ lilv_ui_get_supported_features()
◆ lilv_ui_get_uri()
◆ lilv_ui_is_a()
◆ lilv_ui_is_supported()
| LILV_API unsigned lilv_ui_is_supported | ( | const LilvUI * | ui, |
| LilvUISupportedFunc | supported_func, | ||
| const LilvNode * | container_type, | ||
| const LilvNode ** | ui_type ) |
Return true iff a Plugin UI is supported as a given widget type.
- Parameters
-
ui The Plugin UI supported_func User provided supported predicate. container_type The widget type to host the UI within. ui_type (Output) If non-NULL, set to the native type of the UI which is owned by ui and must not be freed by the caller.
- Returns
- The embedding quality level returned by supported_func.
◆ lilv_uis_begin()
◆ lilv_uis_free()
◆ lilv_uis_get()
◆ lilv_uis_get_by_uri()
Get a UI from uis by URI. Return value is shared (stored in uis) and must not be freed or modified by the caller in any way.
- Returns
- NULL if no UI with uri is found in list.
◆ lilv_uis_is_end()
◆ lilv_uis_next()
◆ lilv_uis_size()
◆ lilv_uri_to_path()
| LILV_API LILV_DEPRECATED const char * lilv_uri_to_path | ( | const char * | uri | ) |
Convert a file URI string to a local path string. For example, "file://foo/bar/baz.ttl" returns "/foo/bar/baz.ttl". Return value is shared and must not be deleted by caller. This function does not handle escaping correctly and should not be used for general file URIs. Use lilv_file_uri_parse() instead.
- Returns
- uri converted to a path, or NULL on failure (URI is not local).
◆ lilv_world_ask()
| LILV_API bool lilv_world_ask | ( | LilvWorld * | world, |
| const LilvNode * | subject, | ||
| const LilvNode * | predicate, | ||
| const LilvNode * | object ) |
Return true iff a statement matching a certain pattern exists.
This is useful for checking if particular statement exists without having to bother with collections and memory management.
◆ lilv_world_find_nodes()
| LILV_API LilvNodes * lilv_world_find_nodes | ( | LilvWorld * | world, |
| const LilvNode * | subject, | ||
| const LilvNode * | predicate, | ||
| const LilvNode * | object ) |
Find nodes matching a triple pattern. Either subject or object may be NULL (i.e. a wildcard), but not both.
- Returns
- All matches for the wildcard field, or NULL.
Find nodes matching a triple pattern.
Either subject or object may be NULL (a wildcard), but not both.
- Returns
- All matches for the wildcard field, or NULL.
◆ lilv_world_free()
Destroy the world, mwahaha. It is safe to call this function on NULL. Note that destroying world will destroy all the objects it contains (e.g. instances of LilvPlugin). Do not destroy the world until you are finished with all objects that came from it.
Destroy the world.
It is safe to call this function on NULL. Note that destroying world will destroy all the objects it contains. Do not destroy the world until you are finished with all objects that came from it.
◆ lilv_world_get()
| LILV_API LilvNode * lilv_world_get | ( | LilvWorld * | world, |
| const LilvNode * | subject, | ||
| const LilvNode * | predicate, | ||
| const LilvNode * | object ) |
Find a single node that matches a pattern. Exactly one of subject, predicate, object must be NULL. This function is equivalent to lilv_nodes_get_first(lilv_world_find_nodes(...)) but simplifies the common case of only wanting a single value.
- Returns
- the first matching node, or NULL if no matches are found.
Find a single node that matches a pattern.
Exactly one of subject, predicate, object must be NULL. This function is equivalent to lilv_nodes_get_first(lilv_world_find_nodes(...)) but simplifies the common case of only wanting a single value.
- Returns
- The first matching node, or NULL if no matches are found.
◆ lilv_world_get_all_plugins()
| LILV_API const LilvPlugins * lilv_world_get_all_plugins | ( | const LilvWorld * | world | ) |
Return a list of all found plugins. The returned list contains just enough references to query or instantiate plugins. The data for a particular plugin will not be loaded into memory until a call to an lilv_plugin_* function results in a query (at which time the data is cached with the LilvPlugin so future queries are very fast).
The returned list and the plugins it contains are owned by world and must not be freed by caller.
◆ lilv_world_get_plugin_class()
| LILV_API const LilvPluginClass * lilv_world_get_plugin_class | ( | const LilvWorld * | world | ) |
Get the parent of all other plugin classes, lv2:Plugin.
◆ lilv_world_get_plugin_classes()
| LILV_API const LilvPluginClasses * lilv_world_get_plugin_classes | ( | const LilvWorld * | world | ) |
Return a list of all found plugin classes. Returned list is owned by world and must not be freed by the caller.
◆ lilv_world_get_symbol()
Get an LV2 symbol for some subject.
This will return the lv2:symbol property of the subject if it is given explicitly, and otherwise will attempt to derive a symbol from the URI.
- Returns
- A string node that is a valid LV2 symbol, or NULL on error.
◆ lilv_world_load_all()
Load all installed LV2 bundles on the system. This is the recommended way for hosts to load LV2 data. It implements the established/standard best practice for discovering all LV2 data on the system. The environment variable LV2_PATH may be used to control where this function will look for bundles.
Hosts should use this function rather than explicitly load bundles, except in special circumstances (e.g. development utilities, or hosts that ship with special plugin bundles which are installed to a known location).
◆ lilv_world_load_bundle()
Load a specific bundle. bundle_uri must be a fully qualified URI to the bundle directory, with the trailing slash, eg. file:///usr/lib/lv2/foo.lv2/
Normal hosts should not need this function (use lilv_world_load_all()).
Hosts MUST NOT attach any long-term significance to bundle paths (e.g. in save files), since there are no guarantees they will remain unchanged between (or even during) program invocations. Plugins (among other things) MUST be identified by URIs (not paths) in save files.
Load a specific bundle.
bundle_uri must be a fully qualified URI to the bundle directory, with the trailing slash, eg. file:///usr/lib/lv2/foo.lv2/
Normal hosts should not need this function (use lilv_world_load_all()).
Hosts MUST NOT attach any long-term significance to bundle paths (for example in save files), since there are no guarantees they will remain unchanged between (or even during) program invocations. Plugins (among other things) MUST be identified by URIs (not paths) in save files.
◆ lilv_world_load_plugin_classes()
Load all plugin classes from currently loaded specifications.
Must be called after lilv_world_load_specifications(). This is for hosts that explicitly load specific bundles, its use is not necessary when using lilv_world_load_all().
◆ lilv_world_load_resource()
Load all the data associated with the given resource.
- Parameters
-
world The world. resource Must be a subject (i.e. a URI or a blank node).
- Returns
- The number of files parsed, or -1 on error
All accessible data files linked to resource with rdfs:seeAlso will be loaded into the world model.
Load all the data associated with the given resource.
All accessible data files linked to resource with rdfs:seeAlso will be loaded into the world model.
- Parameters
-
world The world. resource Must be a subject (a URI or a blank node).
- Returns
- The number of files parsed, or -1 on error
◆ lilv_world_load_specifications()
Load all specifications from currently loaded bundles.
This is for hosts that explicitly load specific bundles, its use is not necessary when using lilv_world_load_all(). This function parses the specifications and adds them to the model.
◆ lilv_world_new()
Initialize a new, empty world. If initialization fails, NULL is returned.
◆ lilv_world_set_option()
Set an option option for world.
Currently recognized options: LILV_OPTION_FILTER_LANG LILV_OPTION_DYN_MANIFEST
Set an option for world.
Currently recognized options:
◆ lilv_world_unload_bundle()
Unload a specific bundle.
This unloads statements loaded by lilv_world_load_bundle(). Note that this is not necessarily all information loaded from the bundle. If any resources have been separately loaded with lilv_world_load_resource(), they must be separately unloaded with lilv_world_unload_resource().
◆ lilv_world_unload_resource()
Unload all the data associated with the given resource.
- Parameters
-
world The world. resource Must be a subject (i.e. a URI or a blank node).
This unloads all data loaded by a previous call to lilv_world_load_resource() with the given resource.
Unload all the data associated with the given resource.
This unloads all data loaded by a previous call to lilv_world_load_resource() with the given resource.
- Parameters
-
world The world. resource Must be a subject (a URI or a blank node).
Generated on for LMMS by
1.16.1