URIs::Quark::Quark(Forge& forge, URIMap* map, LilvWorld* lworld, const char* c_str) : Raul::URI(c_str) , urid(forge.make_urid(Raul::URI(c_str))) , uri(forge.alloc_uri(c_str)) , lnode(lilv_new_uri(lworld, c_str)) {}
const LilvPlugin* LV2World::getPlugin (const String& uri) const { LilvNode* p (lilv_new_uri (world, uri.toUTF8())); const LilvPlugin* plugin = lilv_plugins_get_by_uri (getAllPlugins(), p); lilv_node_free (p); return plugin; }
bool LV2EffectsModule::IsPluginValid(const PluginID & ID, const wxString & path) { LilvNode *uri = lilv_new_uri(gWorld, path.ToUTF8()); const LilvPlugin *plugin = lilv_plugins_get_by_uri(lilv_world_get_all_plugins(gWorld), uri); lilv_node_free(uri); return plugin != NULL; }
void classes(World* world, URISet& types, bool super) { LilvNode* rdfs_subClassOf = lilv_new_uri( world->lilv_world(), LILV_NS_RDFS "subClassOf"); closure(world, rdfs_subClassOf, types, super); lilv_node_free(rdfs_subClassOf); }
void datatypes(World* world, URISet& types, bool super) { LilvNode* owl_onDatatype = lilv_new_uri( world->lilv_world(), LILV_NS_OWL "onDatatype"); closure(world, owl_onDatatype, types, super); lilv_node_free(owl_onDatatype); }
LV2World::LV2World() { world = lilv_world_new(); lilv_world_load_all (world); lv2_InputPort = lilv_new_uri (world, LV2_CORE__InputPort); lv2_OutputPort = lilv_new_uri (world, LV2_CORE__OutputPort); lv2_AudioPort = lilv_new_uri (world, LV2_CORE__AudioPort); lv2_AtomPort = lilv_new_uri (world, LV2_ATOM__AtomPort); lv2_ControlPort = lilv_new_uri (world, LV2_CORE__ControlPort); lv2_EventPort = lilv_new_uri (world, LV2_EVENT__EventPort); lv2_CVPort = lilv_new_uri (world, LV2_CORE__CVPort); midi_MidiEvent = lilv_new_uri (world, LV2_MIDI__MidiEvent); work_schedule = lilv_new_uri (world, LV2_WORKER__schedule); work_interface = lilv_new_uri (world, LV2_WORKER__interface); currentThread = 0; numThreads = 2; }
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)))); }
int main(int argc, char** argv) { if (argc != 2) { fprintf(stderr, "USAGE: %s BUNDLE\n", argv[0]); return 1; } const char* bundle_path = argv[1]; LilvWorld* world = lilv_world_new(); // Load test plugin bundle uint8_t* abs_bundle = (uint8_t*)lilv_path_absolute(bundle_path); SerdNode bundle = serd_node_new_file_uri(abs_bundle, 0, 0, true); LilvNode* bundle_uri = lilv_new_uri(world, (const char*)bundle.buf); lilv_world_load_bundle(world, bundle_uri); free(abs_bundle); serd_node_free(&bundle); LilvNode* plugin_uri = lilv_new_uri(world, PLUGIN_URI); const LilvPlugins* plugins = lilv_world_get_all_plugins(world); const LilvPlugin* plugin = lilv_plugins_get_by_uri(plugins, plugin_uri); TEST_ASSERT(plugin); LilvInstance* instance = lilv_plugin_instantiate(plugin, 48000.0, NULL); TEST_ASSERT(instance); LilvNode* eg_blob = lilv_new_uri(world, "http://example.org/blob"); LilvNode* blob = lilv_world_get(world, plugin_uri, eg_blob, NULL); TEST_ASSERT(lilv_node_is_literal(blob)); LilvNode* eg_junk = lilv_new_uri(world, "http://example.org/junk"); LilvNode* junk = lilv_world_get(world, plugin_uri, eg_junk, NULL); TEST_ASSERT(lilv_node_is_literal(junk)); lilv_world_free(world); return 0; }
const LilvPlugin *LV2EffectsModule::GetPlugin(const wxString & path) { LilvNode *uri = lilv_new_uri(gWorld, path.ToUTF8()); if (!uri) { return NULL; } const LilvPlugin *plug = lilv_plugins_get_by_uri(lilv_world_get_all_plugins(gWorld), uri); lilv_node_free(uri); return plug; }
int main(int argc, char** argv) { uint32_t block_size = 512; uint32_t sample_count = (1 << 19); for (int i = 1; i < argc; ++i) { if (!strcmp(argv[i], "--version")) { print_version(); return 0; } else if (!strcmp(argv[i], "--help")) { print_usage(); return 0; } else if (!strcmp(argv[i], "-f")) { full_output = true; } else if (!strcmp(argv[i], "-n") && (i + 1 < argc)) { sample_count = atoi(argv[++i]); } else if (!strcmp(argv[i], "-b") && (i + 1 < argc)) { block_size = atoi(argv[++i]); } else { print_usage(); return 1; } } LilvWorld* world = lilv_world_new(); lilv_world_load_all(world); atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort); atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence); lv2_AudioPort = lilv_new_uri(world, LV2_CORE__AudioPort); lv2_CVPort = lilv_new_uri(world, LV2_CORE__CVPort); lv2_ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort); lv2_InputPort = lilv_new_uri(world, LV2_CORE__InputPort); lv2_OutputPort = lilv_new_uri(world, LV2_CORE__OutputPort); urid_map = lilv_new_uri(world, LV2_URID__map); if (full_output) { printf("# Block Samples Time Plugin\n"); } const LilvPlugins* plugins = lilv_world_get_all_plugins(world); LILV_FOREACH(plugins, i, plugins) { bench(lilv_plugins_get(plugins, i), sample_count, block_size); }
bool LV2EffectsModule::Initialize() { // Try to initialise Lilv, or return. gWorld = lilv_world_new(); if (!gWorld) { return false; } gAudioPortClass = lilv_new_uri(gWorld, LV2_CORE__AudioPort); gControlPortClass = lilv_new_uri(gWorld, LV2_CORE__ControlPort); gMidiPortClass = lilv_new_uri(gWorld, LV2_EVENT__EventPort); gInputPortClass = lilv_new_uri(gWorld, LV2_CORE__InputPort); gOutputPortClass = lilv_new_uri(gWorld, LV2_CORE__OutputPort); gPortToggled = lilv_new_uri(gWorld, LV2_CORE__toggled); gPortIsInteger = lilv_new_uri(gWorld, LV2_CORE__integer); gPortIsSampleRate = lilv_new_uri(gWorld, LV2_CORE__sampleRate); gPortIsEnumeration = lilv_new_uri(gWorld, LV2_CORE__enumeration); gPortIsLatency = lilv_new_uri(gWorld, LV2_CORE__reportsLatency); gPortIsOptional = lilv_new_uri(gWorld, LV2_CORE__connectionOptional); gName = lilv_new_uri(gWorld, LV2_CORE__name); gPortGroup = lilv_new_uri(gWorld, LV2_PORT_GROUPS__group); gSubGroupOf = lilv_new_uri(gWorld, LV2_PORT_GROUPS__subGroupOf); lilv_world_load_all(gWorld); return true; }
/** * Get livl plugin by uri */ const LilvPlugin * get_livl_plugin(const char *uri, Lv2Lib * lv2Lib) { LilvNode *plugin_uri = lilv_new_uri(lv2Lib->world, uri); const LilvPlugin *plugin = lilv_plugins_get_by_uri(lv2Lib->plugins, plugin_uri); lilv_node_free(plugin_uri); return plugin; }
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) { const LV2_Feature** sfeatures = NULL; LilvWorld* const world = plugin->world; LilvState* const state = (LilvState*)malloc(sizeof(LilvState)); memset(state, '\0', sizeof(LilvState)); state->plugin_uri = lilv_node_duplicate(lilv_plugin_get_uri(plugin)); state->abs2rel = zix_tree_new(false, abs_cmp, NULL, path_rel_free); state->rel2abs = zix_tree_new(false, rel_cmp, NULL, NULL); state->file_dir = file_dir ? absolute_dir(file_dir) : NULL; state->copy_dir = copy_dir ? absolute_dir(copy_dir) : NULL; state->link_dir = link_dir ? absolute_dir(link_dir) : NULL; state->dir = save_dir ? absolute_dir(save_dir) : NULL; state->atom_Path = map->map(map->handle, LV2_ATOM__Path); LV2_State_Map_Path pmap = { state, abstract_path, absolute_path }; LV2_Feature pmap_feature = { LV2_STATE__mapPath, &pmap }; LV2_State_Make_Path pmake = { state, make_path }; LV2_Feature pmake_feature = { LV2_STATE__makePath, &pmake }; features = sfeatures = add_features(features, &pmap_feature, save_dir ? &pmake_feature : NULL); // Store port values if (get_value) { LilvNode* lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT); LilvNode* lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT); for (uint32_t i = 0; i < plugin->num_ports; ++i) { const LilvPort* const port = plugin->ports[i]; if (lilv_port_is_a(plugin, port, lv2_ControlPort) && lilv_port_is_a(plugin, port, lv2_InputPort)) { uint32_t size, type; const char* sym = lilv_node_as_string(port->symbol); const void* value = get_value(sym, user_data, &size, &type); append_port_value(state, sym, value, size, type); } } lilv_node_free(lv2_ControlPort); lilv_node_free(lv2_InputPort); } // Store properties const LV2_Descriptor* desc = instance->lv2_descriptor; const LV2_State_Interface* iface = (desc->extension_data) ? (LV2_State_Interface*)desc->extension_data(LV2_STATE__interface) : NULL; if (iface) { LV2_State_Status st = iface->save( instance->lv2_handle, store_callback, state, flags, features); if (st) { LILV_ERRORF("Error saving plugin state: %s\n", state_strerror(st)); free(state->props); state->props = NULL; state->num_props = 0; } else { qsort(state->props, state->num_props, sizeof(Property), property_cmp); } } qsort(state->values, state->num_values, sizeof(PortValue), value_cmp); free(sfeatures); return state; }
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?
Lv2Constants::Lv2Constants(LilvWorld *world) { lv2AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort); lv2AudioPort = lilv_new_uri(world, LV2_CORE__AudioPort); lv2InputPort = lilv_new_uri(world, LV2_CORE__InputPort); lv2OutputPort = lilv_new_uri(world, LV2_CORE__OutputPort); lv2ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort); lv2MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT); lv2AtomSequence = lilv_new_uri(world, LV2_ATOM__Sequence); lv2AtomSupports = lilv_new_uri(world, LV2_ATOM__supports); lv2AtomBufferType = lilv_new_uri(world, LV2_ATOM__bufferType); lv2Presets = lilv_new_uri(world, LV2_PRESETS__Preset); lv2WorkerSchedule = lilv_new_uri(world, LV2_WORKER__schedule); lv2WorkerInterface = lilv_new_uri(world, LV2_WORKER__interface); lv2RdfsLabel = lilv_new_uri(world, LILV_NS_RDFS "label"); }