path: root/libs/ardour/plugin.cc

/*
    Copyright (C) 2000-2002 Paul Davis

    This program 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 program 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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifdef WAF_BUILD
#include "libardour-config.h"
#endif

#include <vector>
#include <string>

#include <cstdlib>
#include <cstdio> // so libraptor doesn't complain
#include <cmath>
#include <dirent.h>
#include <sys/stat.h>
#include <cerrno>
#include <utility>

#include <lrdf.h>

#include "pbd/compose.h"
#include "pbd/error.h"
#include "pbd/xml++.h"

#include "ardour/ardour.h"
#include "ardour/session.h"
#include "ardour/audioengine.h"
#include "ardour/plugin.h"
#include "ardour/ladspa_plugin.h"
#include "ardour/plugin_manager.h"

#ifdef HAVE_AUDIOUNITS
#include "ardour/audio_unit.h"
#endif

#ifdef HAVE_SLV2
#include "ardour/lv2_plugin.h"
#endif

#include "pbd/stl_delete.h"

#include "i18n.h"
#include <locale.h>

using namespace std;
using namespace ARDOUR;
using namespace PBD;

PBD::Signal0<bool> Plugin::PresetFileExists;

Plugin::Plugin (AudioEngine& e, Session& s)
	: _engine (e)
	, _session (s)
	, _cycles (0)
{
}

Plugin::Plugin (const Plugin& other)
	: StatefulDestructible()
	, Latent()
	, _engine (other._engine)
	, _session (other._session)
	, _info (other._info)
	, _cycles (0)
	, presets (other.presets)
{
}

Plugin::~Plugin ()
{
}

const Plugin::PresetRecord*
Plugin::preset_by_label(const string& label)
{
	// FIXME: O(n)
	for (map<string,PresetRecord>::const_iterator i = presets.begin(); i != presets.end(); ++i) {
		if (i->second.label == label) {
			return &i->second;
		}
	}
	return NULL;
}

const Plugin::PresetRecord*
Plugin::preset_by_uri(const string& uri)
{
	map<string,PresetRecord>::const_iterator pr = presets.find(uri);
	if (pr != presets.end()) {
		return &pr->second;
	} else {
		return NULL;
	}
}

vector<Plugin::PresetRecord>
Plugin::get_presets()
{
	vector<PresetRecord> result;
	uint32_t id;
	std::string unique (unique_id());

	/* XXX problem: AU plugins don't have numeric ID's.
	   Solution: they have a different method of providing presets.
	   XXX sub-problem: implement it.
	*/

	if (!isdigit (unique[0])) {
		return result;
	}

	id = atol (unique.c_str());

	lrdf_uris* set_uris = lrdf_get_setting_uris(id);

	if (set_uris) {
		for (uint32_t i = 0; i < (uint32_t) set_uris->count; ++i) {
			if (char* label = lrdf_get_label(set_uris->items[i])) {
				PresetRecord rec(set_uris->items[i], label);
				result.push_back(rec);
				presets.insert(std::make_pair(set_uris->items[i], rec));
			}
		}
		lrdf_free_uris(set_uris);
	}

	return result;
}

bool
Plugin::load_preset(const string& preset_uri)
{
	lrdf_defaults* defs = lrdf_get_setting_values(preset_uri.c_str());

	if (defs) {
		for (uint32_t i = 0; i < (uint32_t) defs->count; ++i) {
			// The defs->items[i].pid < defs->count check is to work around
			// a bug in liblrdf that saves invalid values into the presets file.
			if (((uint32_t) defs->items[i].pid < (uint32_t) defs->count) && parameter_is_input (defs->items[i].pid)) {
				set_parameter(defs->items[i].pid, defs->items[i].value);
			}
		}
		lrdf_free_setting_values(defs);
	}

	return true;
}

/* XXX: should be in liblrdf */
static void
lrdf_remove_preset (const char *source, const char *setting_uri)
{
	lrdf_statement p;
	lrdf_statement *q;
	lrdf_statement *i;
	char setting_uri_copy[64];
	char buf[64];
	
	strncpy(setting_uri_copy, setting_uri, sizeof(setting_uri_copy));

	p.subject = setting_uri_copy;
	strncpy(buf, LADSPA_BASE "hasPortValue", sizeof(buf));
	p.predicate = buf;
	p.object = NULL;
	q = lrdf_matches(&p);

	p.predicate = NULL;
	p.object = NULL;
	for (i = q; i; i = i->next) {
		p.subject = i->object;
		lrdf_remove_matches(&p);
	}

	lrdf_free_statements(q);

	p.subject = NULL;
	strncpy(buf, LADSPA_BASE "hasSetting", sizeof(buf));
	p.predicate = buf;
	p.object = setting_uri_copy;
	lrdf_remove_matches(&p);

	p.subject = setting_uri_copy;
	p.predicate = NULL;
	p.object = NULL;
	lrdf_remove_matches (&p);
}

void
Plugin::remove_preset (string name, string domain)
{
	string const envvar = preset_envvar ();
	if (envvar.empty()) {
		warning << _("Could not locate HOME.  Preset not removed.") << endmsg;
		return;
	}

	Plugin::PresetRecord const * p = preset_by_label (name);
	if (!p) {
		return;
	}
	
	string const source = preset_source (envvar, domain);
	lrdf_remove_preset (source.c_str(), p->uri.c_str ());

	presets.erase (p->uri);

	write_preset_file (envvar, domain);
}

string
Plugin::preset_envvar () const
{
	char* envvar;
	if ((envvar = getenv ("HOME")) == 0) {
		return "";
	}
	
	return envvar;
}

string
Plugin::preset_source (string envvar, string domain) const
{
	return string_compose ("file:%1/.%2/rdf/ardour-presets.n3", envvar, domain);
}

bool
Plugin::write_preset_file (string envvar, string domain)
{
	string path = string_compose("%1/.%2", envvar, domain);
	if (g_mkdir_with_parents (path.c_str(), 0775)) {
		warning << string_compose(_("Could not create %1.  Preset not saved. (%2)"), path, strerror(errno)) << endmsg;
		return false;
	}

	path += "/rdf";
	if (g_mkdir_with_parents (path.c_str(), 0775)) {
		warning << string_compose(_("Could not create %1.  Preset not saved. (%2)"), path, strerror(errno)) << endmsg;
		return false;
	}

	string const source = preset_source (envvar, domain);

	if (lrdf_export_by_source (source.c_str(), source.substr(5).c_str())) {
		warning << string_compose(_("Error saving presets file %1."), source) << endmsg;
		return false;
	}

	return true;
}

bool
Plugin::save_preset (string name, string domain)
{
	lrdf_portvalue portvalues[parameter_count()];
	lrdf_defaults defaults;
	uint32_t id;
	std::string unique (unique_id());

	/* XXX problem: AU plugins don't have numeric ID's.
	   Solution: they have a different method of providing/saving presets.
	   XXX sub-problem: implement it.
	*/

	if (!isdigit (unique[0])) {
		return false;
	}

	id = atol (unique.c_str());

	defaults.count = parameter_count();
	defaults.items = portvalues;

	for (uint32_t i = 0; i < parameter_count(); ++i) {
		if (parameter_is_input (i)) {
			portvalues[i].pid = i;
			portvalues[i].value = get_parameter(i);
		}
	}

	string const envvar = preset_envvar ();
	if (envvar.empty()) {
		warning << _("Could not locate HOME.  Preset not saved.") << endmsg;
		return false;
	}

	string const source = preset_source (envvar, domain);

	char* uri = lrdf_add_preset (source.c_str(), name.c_str(), id, &defaults);
	
	/* XXX: why is the uri apparently kept as the key in the `presets' map and also in the PresetRecord? */

	presets.insert (make_pair (uri, PresetRecord (uri, name)));
	free (uri);

	return write_preset_file (envvar, domain);
}

PluginPtr
ARDOUR::find_plugin(Session& session, string identifier, PluginType type)
{
	PluginManager *mgr = PluginManager::the_manager();
	PluginInfoList plugs;

	switch (type) {
	case ARDOUR::LADSPA:
		plugs = mgr->ladspa_plugin_info();
		break;

#ifdef HAVE_SLV2
	case ARDOUR::LV2:
		plugs = mgr->lv2_plugin_info();
		break;
#endif

#ifdef VST_SUPPORT
	case ARDOUR::VST:
		plugs = mgr->vst_plugin_info();
		break;
#endif

#ifdef HAVE_AUDIOUNITS
	case ARDOUR::AudioUnit:
		plugs = mgr->au_plugin_info();
		break;
#endif

	default:
		return PluginPtr ((Plugin *) 0);
	}

	PluginInfoList::iterator i;

	for (i = plugs.begin(); i != plugs.end(); ++i) {
		if (identifier == (*i)->unique_id){
			return (*i)->load (session);
		}
	}

#ifdef VST_SUPPORT
	/* hmm, we didn't find it. could be because in older versions of Ardour.
	   we used to store the name of a VST plugin, not its unique ID. so try
	   again.
	*/

	for (i = plugs.begin(); i != plugs.end(); ++i) {
		if (identifier == (*i)->name){
			return (*i)->load (session);
		}
	}
#endif

	return PluginPtr ((Plugin*) 0);
}

ChanCount
Plugin::output_streams () const
{
	/* LADSPA & VST should not get here because they do not
	   return "infinite" i/o counts.
	*/
	return ChanCount::ZERO;
}

ChanCount
Plugin::input_streams () const
{
	/* LADSPA & VST should not get here because they do not
	   return "infinite" i/o counts.
	*/
	return ChanCount::ZERO;
}