diff options
Diffstat (limited to 'src/lilv_internal.h')
| -rw-r--r-- | src/lilv_internal.h | 407 |
1 files changed, 407 insertions, 0 deletions
diff --git a/src/lilv_internal.h b/src/lilv_internal.h new file mode 100644 index 0000000..f856508 --- /dev/null +++ b/src/lilv_internal.h @@ -0,0 +1,407 @@ +/* + Copyright 2007-2011 David Robillard <http://drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef LILV_INTERNAL_H +#define LILV_INTERNAL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> +#include <stdlib.h> + +#ifdef __WIN32__ +#include <windows.h> +#define dlopen(path, flags) LoadLibrary(path) +#define dlclose(lib) FreeLibrary(lib) +#define dlsym GetProcAddress +static inline char* dlerror(void) { return "Unknown error"; } +#else +#include <dlfcn.h> +#endif + +#include <glib.h> + +#include "serd/serd.h" +#include "sord/sord.h" + +#include "lilv-config.h" + +#ifdef LILV_DYN_MANIFEST +#include "lv2/lv2plug.in/ns/ext/dyn-manifest/dyn-manifest.h" +#endif + +#include "lilv/lilv.h" + +#define LILV_NS_DOAP (const uint8_t*)"http://usefulinc.com/ns/doap#" +#define LILV_NS_RDFS (const uint8_t*)"http://www.w3.org/2000/01/rdf-schema#" +#define LILV_NS_LILV (const uint8_t*)"http://drobilla.net/ns/lilv#" +#define LILV_NS_LV2 (const uint8_t*)"http://lv2plug.in/ns/lv2core#" +#define LILV_NS_XSD (const uint8_t*)"http://www.w3.org/2001/XMLSchema#" +#define LILV_NS_RDF (const uint8_t*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#" + +typedef SordIter* LilvMatches; +typedef const SordNode* LilvNode; + +#define FOREACH_MATCH(iter) \ + for (; !sord_iter_end(iter); sord_iter_next(iter)) + +static inline const SordNode* +lilv_match_subject(LilvMatches iter) { + SordQuad tup; + sord_iter_get(iter, tup); + return tup[SORD_SUBJECT]; +} + +static inline const SordNode* +lilv_match_object(LilvMatches iter) { + SordQuad tup; + sord_iter_get(iter, tup); + return tup[SORD_OBJECT]; +} + +static inline void +lilv_match_end(LilvMatches iter) +{ + sord_iter_free(iter); +} + +/* ********* PORT ********* */ + +/** Reference to a port on some plugin. */ +struct _LilvPort { + uint32_t index; ///< lv2:index + LilvValue symbol; ///< lv2:symbol + LilvValues classes; ///< rdf:type +}; + +LilvPort lilv_port_new(LilvWorld world, uint32_t index, const char* symbol); +void lilv_port_free(LilvPort port); + +/* ********* Spec ********* */ + +struct _LilvSpec { + SordNode* spec; + SordNode* bundle; + LilvValues data_uris; +}; + +typedef struct _LilvSpec* LilvSpec; + +/* ********* Plugin ********* */ + +/** Header of an LilvPlugin, LilvPluginClass, or LilvUI. + * Any of these structs may be safely casted to _LilvHeader, which is used to + * implement sequences without code duplication (see lilv_sequence_get_by_uri). + */ +struct _LilvHeader { + struct _LilvWorld* world; + LilvValue uri; +}; + +/** Record of an installed/available plugin. + * + * A simple reference to a plugin somewhere on the system. This just holds + * paths of relevant files, the actual data therein isn't loaded into memory. + */ +struct _LilvPlugin { + struct _LilvWorld* world; + LilvValue plugin_uri; + LilvValue bundle_uri; ///< Bundle directory plugin was loaded from + LilvValue binary_uri; ///< lv2:binary + LilvValue dynman_uri; ///< dynamic manifest binary + LilvPluginClass plugin_class; + LilvValues data_uris; ///< rdfs::seeAlso + LilvPort* ports; + uint32_t num_ports; + bool loaded; + bool replaced; +}; + +LilvPlugin lilv_plugin_new(LilvWorld world, LilvValue uri, LilvValue bundle_uri); +void lilv_plugin_load_if_necessary(LilvPlugin p); +void lilv_plugin_free(LilvPlugin plugin); + +LilvValue +lilv_plugin_get_unique(LilvPlugin p, + LilvNode subject, + LilvNode predicate); + +/* ********* Plugins ********* */ + +typedef void* LilvCollection; + +LilvPlugins +lilv_plugins_new(); + + +/** + Increment @a i to point at the next element in the collection. +*/ +LilvIter +lilv_iter_next(LilvIter i); + +/** + Return true iff @a i is at the end of the collection. +*/ +bool +lilv_iter_end(LilvIter i); + +LilvIter +lilv_collection_begin(LilvCollection collection); + +void* +lilv_collection_get(LilvCollection collection, + LilvIter i); + +/** + Free @a collection. +*/ +void +lilv_collection_free(LilvCollection collection); + +/** + Get the number of elements in @a collection. +*/ +unsigned +lilv_collection_size(LilvCollection collection); + +LilvValues +lilv_values_new(void); + +LilvScalePoints +lilv_scale_points_new(void); + + +/* ********* Instance ********* */ + +/** Pimpl portion of LilvInstance */ +struct _LilvInstanceImpl { + void* lib_handle; +}; + +/* ********* Plugin Class ********* */ + +struct _LilvPluginClass { + struct _LilvWorld* world; + LilvValue uri; + LilvValue parent_uri; + LilvValue label; +}; + +LilvPluginClass lilv_plugin_class_new(LilvWorld world, + LilvNode parent_uri, + LilvNode uri, + const char* label); + +void lilv_plugin_class_free(LilvPluginClass plugin_class); + +/* ********* Plugin Classes ********* */ + +LilvPluginClasses lilv_plugin_classes_new(); +void lilv_plugin_classes_free(); + +/* ********* World ********* */ + +typedef struct { + bool dyn_manifest; + bool filter_language; +} LilvOptions; + +/** Model of LV2 (RDF) data loaded from bundles. + */ +struct _LilvWorld { + SordWorld* world; + SordModel* model; + SerdReader* reader; + SerdEnv* namespaces; + unsigned n_read_files; + LilvPluginClass lv2_plugin_class; + LilvPluginClasses plugin_classes; + GSList* specs; + LilvPlugins plugins; + SordNode* dc_replaces_node; + SordNode* dyn_manifest_node; + SordNode* lv2_specification_node; + SordNode* lv2_plugin_node; + SordNode* lv2_binary_node; + SordNode* lv2_default_node; + SordNode* lv2_minimum_node; + SordNode* lv2_maximum_node; + SordNode* lv2_port_node; + SordNode* lv2_portproperty_node; + SordNode* lv2_reportslatency_node; + SordNode* lv2_index_node; + SordNode* lv2_symbol_node; + SordNode* rdf_a_node; + SordNode* rdf_value_node; + SordNode* rdfs_class_node; + SordNode* rdfs_label_node; + SordNode* rdfs_seealso_node; + SordNode* rdfs_subclassof_node; + SordNode* lilv_dmanifest_node; + SordNode* xsd_boolean_node; + SordNode* xsd_decimal_node; + SordNode* xsd_double_node; + SordNode* xsd_integer_node; + LilvValue doap_name_val; + LilvValue lv2_name_val; + LilvOptions opt; +}; + +const uint8_t* +lilv_world_blank_node_prefix(LilvWorld world); +void +lilv_world_load_file(LilvWorld world, const char* file_uri); + +/* ********* Plugin UI ********* */ + +struct _LilvUI { + struct _LilvWorld* world; + LilvValue uri; + LilvValue bundle_uri; + LilvValue binary_uri; + LilvValues classes; +}; + +LilvUIs lilv_uis_new(); + +LilvUI +lilv_ui_new(LilvWorld world, + LilvValue uri, + LilvValue type_uri, + LilvValue binary_uri); + +void lilv_ui_free(LilvUI ui); + +/* ********* Value ********* */ + +typedef enum _LilvValueType { + LILV_VALUE_URI, + LILV_VALUE_QNAME_UNUSED, ///< FIXME: APIBREAK: remove + LILV_VALUE_STRING, + LILV_VALUE_INT, + LILV_VALUE_FLOAT, + LILV_VALUE_BOOL, + LILV_VALUE_BLANK +} LilvValueType; + +struct _LilvValue { + LilvWorld world; + char* str_val; ///< always present + union { + int int_val; + float float_val; + bool bool_val; + SordNode* uri_val; + } val; + LilvValueType type; +}; + +LilvValue lilv_value_new(LilvWorld world, LilvValueType type, const char* val); +LilvValue lilv_value_new_from_node(LilvWorld world, LilvNode node); +LilvNode lilv_value_as_node(LilvValue value); + +int +lilv_header_compare_by_uri(const void* a, const void* b, void* user_data); + +static inline void +lilv_sequence_insert(GSequence* seq, void* value) +{ + g_sequence_insert_sorted(seq, value, lilv_header_compare_by_uri, NULL); +} + +static inline void +lilv_array_append(GSequence* seq, void* value) { + g_sequence_append(seq, value); +} + +struct _LilvHeader* +lilv_sequence_get_by_uri(GSequence* seq, LilvValue uri); + +static inline SordNode* lilv_node_copy(LilvNode node) { + return sord_node_copy(node); +} + +static inline void lilv_node_free(LilvWorld world, SordNode* node) { + sord_node_free(world->world, node); +} + +/* ********* Scale Points ********* */ + +struct _LilvScalePoint { + LilvValue value; + LilvValue label; +}; + +LilvScalePoint lilv_scale_point_new(LilvValue value, LilvValue label); +void lilv_scale_point_free(LilvScalePoint point); + +/* ********* Query Results ********* */ + +LilvMatches lilv_plugin_find_statements(LilvPlugin plugin, + LilvNode subject, + LilvNode predicate, + LilvNode object); + +static inline bool lilv_matches_next(LilvMatches matches) { + return sord_iter_next(matches); +} + +static inline bool lilv_matches_end(LilvMatches matches) { + return sord_iter_end(matches); +} + +LilvValues lilv_values_from_stream_objects(LilvPlugin p, + LilvMatches stream); + +/* ********* Utilities ********* */ + +char* lilv_strjoin(const char* first, ...); +char* lilv_strdup(const char* str); +char* lilv_get_lang(); +uint8_t* lilv_qname_expand(LilvPlugin p, const char* qname); + +typedef void (*VoidFunc)(); + +/** dlsym wrapper to return a function pointer (without annoying warning) */ +static inline VoidFunc +lilv_dlfunc(void* handle, const char* symbol) +{ + typedef VoidFunc (*VoidFuncGetter)(void*, const char*); + VoidFuncGetter dlfunc = (VoidFuncGetter)dlsym; + return dlfunc(handle, symbol); +} + +/* ********* Dynamic Manifest ********* */ +#ifdef LILV_DYN_MANIFEST +static const LV2_Feature* const dman_features = { NULL }; +#endif + +#define LILV_ERROR(str) fprintf(stderr, "ERROR: %s: " str, __func__) +#define LILV_ERRORF(fmt, ...) fprintf(stderr, "ERROR: %s: " fmt, __func__, __VA_ARGS__) + +#define LILV_WARN(str) fprintf(stderr, "WARNING: %s: " str, __func__) +#define LILV_WARNF(fmt, ...) fprintf(stderr, "WARNING: %s: " fmt, __func__, __VA_ARGS__) + +#ifdef __cplusplus +} +#endif + +#endif /* LILV_INTERNAL_H */ |