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");
}
