/* SLV2 * Copyright (C) 2007-2009 David Robillard * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "slv2-config.h" #ifndef __SLV2_INTERNAL_H__ #define __SLV2_INTERNAL_H__ #ifdef __cplusplus extern "C" { #endif #include #include #include #include #include #include #include "slv2/types.h" #include "slv2/lv2_ui.h" #ifdef SLV2_DYN_MANIFEST #include "lv2/lv2plug.in/ns/ext/dyn-manifest/dyn-manifest.h" #endif #define SLV2_NS_RDFS (const uint8_t*)"http://www.w3.org/2000/01/rdf-schema#" #define SLV2_NS_SLV2 (const uint8_t*)"http://drobilla.net/ns/slv2#" #define SLV2_NS_LV2 (const uint8_t*)"http://lv2plug.in/ns/lv2core#" #define SLV2_NS_XSD (const uint8_t*)"http://www.w3.org/2001/XMLSchema#" #define SLV2_NS_RDF (const uint8_t*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#" #define FOREACH_MATCH(stream) \ for (; !librdf_stream_end(stream); librdf_stream_next(stream)) #define MATCH_SUBJECT(stream) \ librdf_statement_get_subject(librdf_stream_get_object(stream)) #define MATCH_OBJECT(stream) \ librdf_statement_get_object(librdf_stream_get_object(stream)) #define END_MATCH(stream) librdf_free_stream(stream) typedef librdf_node* SLV2Node; ///< RDF node /* ********* PORT ********* */ /** Reference to a port on some plugin. */ struct _SLV2Port { uint32_t index; ///< lv2:index SLV2Value symbol; ///< lv2:symbol SLV2Values classes; ///< rdf:type }; SLV2Port slv2_port_new(SLV2World world, uint32_t index, const char* symbol); void slv2_port_free(SLV2Port port); /* ********* Plugin ********* */ /** 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 _SLV2Plugin { struct _SLV2World* world; SLV2Value plugin_uri; SLV2Value bundle_uri; ///< Bundle directory plugin was loaded from SLV2Value binary_uri; ///< lv2:binary SLV2Value dynman_uri; ///< dynamic manifest binary SLV2PluginClass plugin_class; raptor_sequence* data_uris; ///< rdfs::seeAlso SLV2Port* ports; librdf_storage* storage; librdf_model* rdf; uint32_t num_ports; }; SLV2Plugin slv2_plugin_new(SLV2World world, SLV2Value uri, SLV2Value bundle_uri); void slv2_plugin_load(SLV2Plugin p); void slv2_plugin_load_if_necessary(SLV2Plugin p); void slv2_plugin_load_ports_if_necessary(SLV2Plugin p); void slv2_plugin_free(SLV2Plugin plugin); SLV2Value slv2_plugin_get_unique(SLV2Plugin p, SLV2Node subject, SLV2Node predicate); /* ********* Plugins ********* */ /** Create a new, empty plugin list. * * Returned object must be freed with slv2_plugins_free. */ SLV2Plugins slv2_plugins_new(); /* ********* Instance ********* */ /** Pimpl portion of SLV2Instance */ struct _InstanceImpl { void* lib_handle; }; /* ********* UI Instance ********* */ struct _SLV2UIInstanceImpl { void* lib_handle; const LV2UI_Descriptor* lv2ui_descriptor; LV2UI_Handle lv2ui_handle; LV2UI_Widget widget; }; /* ********* Plugin Class ********* */ struct _SLV2PluginClass { struct _SLV2World* world; SLV2Value parent_uri; SLV2Value uri; SLV2Value label; }; SLV2PluginClass slv2_plugin_class_new(SLV2World world, SLV2Node parent_uri, SLV2Node uri, const char* label); void slv2_plugin_class_free(SLV2PluginClass plugin_class); /* ********* Plugin Classes ********* */ SLV2PluginClasses slv2_plugin_classes_new(); void slv2_plugin_classes_free(); /* ********* World ********* */ /** Model of LV2 (RDF) data loaded from bundles. */ struct _SLV2World { bool local_world; librdf_world* world; librdf_storage* storage; librdf_model* model; librdf_parser* parser; librdf_hash* namespaces; SLV2PluginClass lv2_plugin_class; SLV2PluginClasses plugin_classes; SLV2Plugins plugins; SLV2Node dyn_manifest_node; SLV2Node lv2_specification_node; SLV2Node lv2_plugin_node; SLV2Node lv2_binary_node; SLV2Node lv2_default_node; SLV2Node lv2_minimum_node; SLV2Node lv2_maximum_node; SLV2Node lv2_port_node; SLV2Node lv2_portproperty_node; SLV2Node lv2_reportslatency_node; SLV2Node lv2_index_node; SLV2Node lv2_symbol_node; SLV2Node rdf_a_node; SLV2Node rdf_value_node; SLV2Node rdfs_class_node; SLV2Node rdfs_label_node; SLV2Node rdfs_seealso_node; SLV2Node rdfs_subclassof_node; SLV2Node slv2_bundleuri_node; SLV2Node slv2_dmanifest_node; SLV2Node xsd_integer_node; SLV2Node xsd_decimal_node; }; /** Load all bundles found in \a search_path. * * \param search_path A colon-delimited list of directories. These directories * should contain LV2 bundle directories (ie the search path is a list of * parent directories of bundles, not a list of bundle directories). * * If \a search_path is NULL, \a world will be unmodified. * Use of this function is \b not recommended. Use \ref slv2_world_load_all. */ void slv2_world_load_path(SLV2World world, const char* search_path); void slv2_world_load_specifications(SLV2World world); void slv2_world_load_file(SLV2World world, librdf_uri* file_uri); librdf_storage* slv2_world_new_storage(SLV2World world); /* ********* Plugin UI ********* */ struct _SLV2UI { struct _SLV2World* world; SLV2Value uri; SLV2Value bundle_uri; SLV2Value binary_uri; SLV2Values classes; }; SLV2UIs slv2_uis_new(); SLV2UI slv2_ui_new(SLV2World world, SLV2Value uri, SLV2Value type_uri, SLV2Value binary_uri); void slv2_ui_free(SLV2UI ui); /* ********* Value ********* */ typedef enum _SLV2ValueType { SLV2_VALUE_URI, SLV2_VALUE_QNAME_UNUSED, ///< FIXME: APIBREAK: remove SLV2_VALUE_STRING, SLV2_VALUE_INT, SLV2_VALUE_FLOAT, SLV2_VALUE_BLANK } SLV2ValueType; struct _SLV2Value { SLV2ValueType type; char* str_val; ///< always present union { int int_val; float float_val; SLV2Node uri_val; } val; }; SLV2Value slv2_value_new(SLV2World world, SLV2ValueType type, const char* val); SLV2Value slv2_value_new_librdf_node(SLV2World world, SLV2Node node); SLV2Value slv2_value_new_librdf_uri(SLV2World world, SLV2Node node); librdf_uri* slv2_value_as_librdf_uri(SLV2Value value); static inline SLV2Node slv2_node_copy(SLV2Node node) { return librdf_new_node_from_node(node); } static inline void slv2_node_free(SLV2Node node) { librdf_free_node(node); } /* ********* Values ********* */ void slv2_values_set_at(SLV2Values list, unsigned index, void* value); /* ********* Scale Points ********* */ struct _SLV2ScalePoint { SLV2Value value; SLV2Value label; }; SLV2ScalePoint slv2_scale_point_new(SLV2Value value, SLV2Value label); void slv2_scale_point_free(SLV2ScalePoint point); /* ********* Query Results********* */ typedef librdf_stream* SLV2Matches; SLV2Matches slv2_plugin_find_statements(SLV2Plugin plugin, librdf_node* subject, librdf_node* predicate, librdf_node* object); static inline bool slv2_matches_next(SLV2Matches matches) { return librdf_stream_next(matches); } static inline bool slv2_matches_end(SLV2Matches matches) { return librdf_stream_end(matches); } SLV2Values slv2_values_from_stream_i18n(SLV2Plugin p, SLV2Matches stream); /* ********* Utilities ********* */ char* slv2_strjoin(const char* first, ...); const char* slv2_get_lang(); char* slv2_qname_expand(SLV2Plugin p, const char* qname); /* ********* Dynamic Manifest ********* */ #ifdef SLV2_DYN_MANIFEST static const LV2_Feature* const dman_features = { NULL }; #endif #define SLV2_ERROR(str) fprintf(stderr, "ERROR: %s: " str, __func__) #define SLV2_ERRORF(fmt, ...) fprintf(stderr, "ERROR: %s: " fmt, __func__, __VA_ARGS__) #define SLV2_WARN(str) fprintf(stderr, "WARNING: %s: " str, __func__) #define SLV2_WARNF(fmt, ...) fprintf(stderr, "WARNING: %s: " fmt, __func__, __VA_ARGS__) #ifdef __cplusplus } #endif #endif /* __SLV2_INTERNAL_H__ */