URISet properties(World* world, SPtr<const Client::ObjectModel> model) { URISet properties; URISet types = RDFS::types(world, model); LilvNode* rdf_type = lilv_new_uri(world->lilv_world(), LILV_NS_RDF "type"); LilvNode* rdf_Property = lilv_new_uri(world->lilv_world(), LILV_NS_RDF "Property"); LilvNode* rdfs_domain = lilv_new_uri(world->lilv_world(), LILV_NS_RDFS "domain"); LilvNodes* props = lilv_world_find_nodes( world->lilv_world(), NULL, rdf_type, rdf_Property); LILV_FOREACH(nodes, p, props) { const LilvNode* prop = lilv_nodes_get(props, p); if (lilv_node_is_uri(prop)) { LilvNodes* domains = lilv_world_find_nodes( world->lilv_world(), prop, rdfs_domain, NULL); unsigned n_matching_domains = 0; LILV_FOREACH(nodes, d, domains) { const LilvNode* domain_node = lilv_nodes_get(domains, d); if (!lilv_node_is_uri(domain_node)) { // TODO: Blank node domains (e.g. unions) continue; } const Raul::URI domain(lilv_node_as_uri(domain_node)); if (types.count(domain)) { ++n_matching_domains; } } if (lilv_nodes_size(domains) == 0 || ( n_matching_domains > 0 && n_matching_domains == lilv_nodes_size(domains))) { properties.insert(Raul::URI(lilv_node_as_uri(prop))); } lilv_nodes_free(domains); } } lilv_node_free(rdfs_domain); lilv_node_free(rdf_Property); lilv_node_free(rdf_type); return properties; }
Objects instances(World* world, const URISet& types) { LilvNode* rdf_type = lilv_new_uri( world->lilv_world(), LILV_NS_RDF "type"); Objects result; for (const auto& t : types) { LilvNode* type = lilv_new_uri(world->lilv_world(), t.c_str()); LilvNodes* objects = lilv_world_find_nodes( world->lilv_world(), NULL, rdf_type, type); LILV_FOREACH(nodes, o, objects) { const LilvNode* object = lilv_nodes_get(objects, o); if (!lilv_node_is_uri(object)) { continue; } const std::string label = RDFS::label(world, object); result.insert( std::make_pair(label, Raul::URI(lilv_node_as_string(object)))); } lilv_node_free(type); } lilv_node_free(rdf_type); return result; }
gboolean gst_lv2_check_required_features (const LilvPlugin * lv2plugin) { LilvNodes *required_features = lilv_plugin_get_required_features (lv2plugin); if (required_features) { LilvIter *i; gint j; gboolean missing = FALSE; for (i = lilv_nodes_begin (required_features); !lilv_nodes_is_end (required_features, i); i = lilv_nodes_next (required_features, i)) { const LilvNode *required_feature = lilv_nodes_get (required_features, i); const char *required_feature_uri = lilv_node_as_uri (required_feature); missing = TRUE; for (j = 0; lv2_features[j]; j++) { if (!strcmp (lv2_features[j]->URI, required_feature_uri)) { missing = FALSE; break; } } if (missing) { GST_FIXME ("lv2 plugin %s needs host feature: %s", lilv_node_as_uri (lilv_plugin_get_uri (lv2plugin)), required_feature_uri); break; } } lilv_nodes_free (required_features); return (!missing); } return TRUE; }
void print_port(const LilvPlugin* p, uint32_t index, float* mins, float* maxes, float* defaults) { const LilvPort* port = lilv_plugin_get_port_by_index(p, index); printf("\n\tPort %d:\n", index); if (!port) { printf("\t\tERROR: Illegal/nonexistent port\n"); return; } bool first = true; const LilvNodes* classes = lilv_port_get_classes(p, port); printf("\t\tType: "); LILV_FOREACH(nodes, i, classes) { const LilvNode* value = lilv_nodes_get(classes, i); if (!first) { printf("\n\t\t "); } printf("%s", lilv_node_as_uri(value)); first = false; } if (lilv_port_is_a(p, port, event_class)) { LilvNodes* supported = lilv_port_get_value( p, port, supports_event_pred); if (lilv_nodes_size(supported) > 0) { printf("\n\t\tSupported events:\n"); LILV_FOREACH(nodes, i, supported) { const LilvNode* value = lilv_nodes_get(supported, i); printf("\t\t\t%s\n", lilv_node_as_uri(value)); } } lilv_nodes_free(supported); }
URISet range(World* world, const LilvNode* prop, bool recursive) { LilvNode* rdfs_range = lilv_new_uri( world->lilv_world(), LILV_NS_RDFS "range"); LilvNodes* nodes = lilv_world_find_nodes( world->lilv_world(), prop, rdfs_range, NULL); URISet ranges; LILV_FOREACH(nodes, n, nodes) { ranges.insert(Raul::URI(lilv_node_as_string(lilv_nodes_get(nodes, n)))); }
LILV_API LilvNodes* lilv_ui_get_supported_features(const LilvUI* ui) { LilvNodes* optional = lilv_ui_get_optional_features(ui); LilvNodes* required = lilv_ui_get_required_features(ui); LilvNodes* result = lilv_nodes_new(); LILV_FOREACH(nodes, i, optional) zix_tree_insert((ZixTree*)result, lilv_node_duplicate(lilv_nodes_get(optional, i)), NULL); LILV_FOREACH(nodes, i, required) zix_tree_insert((ZixTree*)result, lilv_node_duplicate(lilv_nodes_get(required, i)), NULL); lilv_nodes_free(optional); lilv_nodes_free(required); return result; }
Result LV2Module::instantiate (double samplerate) { freeInstance(); currentSampleRate = samplerate; features.clearQuick(); world.getFeatures (features); // check for a worker interface LilvNodes* nodes = lilv_plugin_get_extension_data (plugin); LILV_FOREACH (nodes, iter, nodes) { const LilvNode* node = lilv_nodes_get (nodes, iter); if (lilv_node_equals (node, world.work_interface)) { worker = new LV2Worker (world.getWorkThread(), 1); features.add (worker->getFeature()); } } lilv_nodes_free (nodes); nodes = nullptr; features.add (nullptr); instance = lilv_plugin_instantiate (plugin, samplerate, features.getRawDataPointer()); if (instance == nullptr) { features.clearQuick(); worker = nullptr; return Result::fail ("Could not instantiate plugin."); } if (const void* data = getExtensionData (LV2_WORKER__interface)) { assert (worker != nullptr); worker->setSize (2048); worker->setInterface (lilv_instance_get_handle (instance), (LV2_Worker_Interface*) data); } else if (worker) { features.removeFirstMatchingValue (worker->getFeature()); worker = nullptr; } return Result::ok(); }
LILV_API unsigned lilv_ui_is_supported(const LilvUI* ui, LilvUISupportedFunc supported_func, const LilvNode* container_type, const LilvNode** ui_type) { const LilvNodes* classes = lilv_ui_get_classes(ui); LILV_FOREACH(nodes, c, classes) { const LilvNode* type = lilv_nodes_get(classes, c); const unsigned q = supported_func(lilv_node_as_uri(container_type), lilv_node_as_uri(type)); if (q) { if (ui_type) { *ui_type = type; } return q; } } return 0; }
Lv2Plugin *Lv2PluginCache::getPlugin(const char *uri, const char *preset, Lv2State *state) { // create a unique key for uri/preset/state std::string keyString(uri); if(preset) { keyString.append(":"); keyString.append(preset); } std::size_t hash = std::hash<std::string>()(keyString); if(state) { hash = hash ^ (state->getHash() << 1); } // count tells how many instances of this type of plugin int count = ++instanceCount[hash]; // return cached plugin instance if available int key = hash + count; Lv2Plugin *cachedPlugin = findObject(key); if(cachedPlugin) { cachedPlugin->restore(); return cachedPlugin; } // look in cache for plugin type by uri std::string uriString(uri); const LilvPlugin *lilvPlugin = pluginMap[uriString]; if(!lilvPlugin) { // find lv2 plugin in lilv LilvNode *lilvUri = lilv_new_uri(world, uri); lilvPlugin = lilv_plugins_get_by_uri(plugins, lilvUri); lilv_node_free(lilvUri); if(!lilvPlugin) { throw std::logic_error(std::string("Plugin is not installed on this system: ") + uriString); } // check that required features are supported LilvNodes* features = lilv_plugin_get_required_features(lilvPlugin); for (LilvIter* f = lilv_nodes_begin(features); !lilv_nodes_is_end(features, f); f = lilv_nodes_next(features, f)) { const char* featureUri = lilv_node_as_uri(lilv_nodes_get(features, f)); if(!supported[featureUri]) { throw std::logic_error(std::string("Plugin ") + uriString + " requires unsupported feature: " + featureUri); } } lilv_nodes_free(features); pluginMap[uriString] = lilvPlugin; } // create worker if required Lv2Worker *worker = 0; if (lilv_plugin_has_feature(lilvPlugin, lv2Constants.lv2WorkerSchedule) && lilv_plugin_has_extension_data(lilvPlugin, lv2Constants.lv2WorkerInterface)) { worker = new Lv2Worker(); ((LV2_Worker_Schedule*)lv2Features[5]->data)->handle = worker; } // instantiate LilvInstance *instance = lilv_plugin_instantiate(lilvPlugin, sampleRate, lv2Features); // connect worker with plugin instance if(worker) { worker->setInstance(instance); } // create plugin object Lv2Plugin *plugin = new Lv2Plugin(lilvPlugin, instance, lv2Constants, worker); // restore baseline default state LilvState *defaultState = lilv_state_new_from_world(world, &map, lilv_plugin_get_uri(lilvPlugin)); lilv_state_restore(defaultState, instance, setPortValue, plugin, 0, lv2Features); // find and restore preset if(preset) { LilvNodes* presets = lilv_plugin_get_related(lilvPlugin, lv2Constants.lv2Presets); LilvNode *myPreset = 0; LILV_FOREACH(nodes, i, presets) { const LilvNode* presetNode = lilv_nodes_get(presets, i); lilv_world_load_resource(world, presetNode); LilvNodes* labels = lilv_world_find_nodes(world, presetNode, lv2Constants.lv2RdfsLabel, NULL); if (labels) { const LilvNode* label = lilv_nodes_get_first(labels); const char *labelString = lilv_node_as_string(label); // TODO: free? if(!strcmp(labelString, preset)) { myPreset = lilv_node_duplicate(presetNode); } lilv_nodes_free(labels); } } lilv_nodes_free(presets); if(myPreset) { LilvState* presetState = lilv_state_new_from_world(world, &map, myPreset); lilv_state_restore(presetState, instance, setPortValue, plugin, 0, NULL); // lilv_state_free(state); // TODO } else { throw std::logic_error(std::string("Plugin ") + uriString + " has no such preset: " + preset); } } // restore state else if(state) { // TODO: what if state is requested on a plugin that doesn't support?
static double bench(const LilvPlugin* p, uint32_t sample_count, uint32_t block_size) { URITable uri_table; uri_table_init(&uri_table); LV2_URID_Map map = { &uri_table, uri_table_map }; LV2_Feature map_feature = { LV2_URID_MAP_URI, &map }; LV2_URID_Unmap unmap = { &uri_table, uri_table_unmap }; LV2_Feature unmap_feature = { LV2_URID_UNMAP_URI, &unmap }; const LV2_Feature* features[] = { &map_feature, &unmap_feature, NULL }; float* const buf = (float*)calloc(block_size * 2, sizeof(float)); float* const in = buf; float* const out = buf + block_size; if (!buf) { fprintf(stderr, "Out of memory\n"); return 0.0; } LV2_Atom_Sequence seq = { { sizeof(LV2_Atom_Sequence_Body), uri_table_map(&uri_table, LV2_ATOM__Sequence) }, { 0, 0 } }; const char* uri = lilv_node_as_string(lilv_plugin_get_uri(p)); LilvNodes* required = lilv_plugin_get_required_features(p); LILV_FOREACH(nodes, i, required) { const LilvNode* feature = lilv_nodes_get(required, i); if (!lilv_node_equals(feature, urid_map)) { fprintf(stderr, "<%s> requires feature <%s>, skipping\n", uri, lilv_node_as_uri(feature)); free(buf); uri_table_destroy(&uri_table); return 0.0; } } LilvInstance* instance = lilv_plugin_instantiate(p, 48000.0, features); if (!instance) { fprintf(stderr, "Failed to instantiate <%s>\n", lilv_node_as_uri(lilv_plugin_get_uri(p))); free(buf); uri_table_destroy(&uri_table); return 0.0; } float* controls = (float*)calloc( lilv_plugin_get_num_ports(p), sizeof(float)); lilv_plugin_get_port_ranges_float(p, NULL, NULL, controls); const uint32_t n_ports = lilv_plugin_get_num_ports(p); for (uint32_t index = 0; index < n_ports; ++index) { const LilvPort* port = lilv_plugin_get_port_by_index(p, index); if (lilv_port_is_a(p, port, lv2_ControlPort)) { lilv_instance_connect_port(instance, index, &controls[index]); } else if (lilv_port_is_a(p, port, lv2_AudioPort) || lilv_port_is_a(p, port, lv2_CVPort)) { if (lilv_port_is_a(p, port, lv2_InputPort)) { lilv_instance_connect_port(instance, index, in); } else if (lilv_port_is_a(p, port, lv2_OutputPort)) { lilv_instance_connect_port(instance, index, out); } else { fprintf(stderr, "<%s> port %d neither input nor output, skipping\n", uri, index); lilv_instance_free(instance); free(buf); free(controls); uri_table_destroy(&uri_table); return 0.0; } } else if (lilv_port_is_a(p, port, atom_AtomPort)) { lilv_instance_connect_port(instance, index, &seq); } else { fprintf(stderr, "<%s> port %d has unknown type, skipping\n", uri, index); lilv_instance_free(instance); free(buf); free(controls); uri_table_destroy(&uri_table); return 0.0; } } lilv_instance_activate(instance); struct timespec ts = bench_start(); for (uint32_t i = 0; i < (sample_count / block_size); ++i) { lilv_instance_run(instance, block_size); } const double elapsed = bench_end(&ts); lilv_instance_deactivate(instance); lilv_instance_free(instance); uri_table_destroy(&uri_table); if (full_output) { printf("%d %d ", block_size, sample_count); } printf("%lf %s\n", elapsed, uri); free(buf); free(controls); return elapsed; }
if (port) { sord_node_free(plugin->world->world, port->node); lilv_nodes_free(port->classes); lilv_node_free(port->symbol); free(port); } } LILV_API bool lilv_port_is_a(const LilvPlugin* plugin, const LilvPort* port, const LilvNode* port_class) { LILV_FOREACH(nodes, i, port->classes) if (lilv_node_equals(lilv_nodes_get(port->classes, i), port_class)) return true; return false; } LILV_API bool lilv_port_has_property(const LilvPlugin* p, const LilvPort* port, const LilvNode* property) { return lilv_world_ask_internal( p->world, port->node, p->world->uris.lv2_portProperty,