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);
lilv_world_free(world);
return 0;
}
bool LV2EffectsModule::IsPluginValid(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;
}
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;
}
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;
}
/**
* 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;
}
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?