X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplugin.cc;h=57198475d72f9ad81d355924e91a19da7acd4ea5;hb=07112b55e0bb7ceb9e5c05ab4df167ecaf7edd9b;hp=8ea95b89037db9333fdd1713fe32d667fc67ff1e;hpb=79986643c0c904f6574bb5323e2233a43a9e622e;p=ardour.git

diff --git a/libs/ardour/plugin.cc b/libs/ardour/plugin.cc
index 8ea95b8903..57198475d7 100644
--- a/libs/ardour/plugin.cc
+++ b/libs/ardour/plugin.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000-2002 Paul Davis 
+    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
@@ -15,9 +15,12 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
+#ifdef WAF_BUILD
+#include "libardour-config.h"
+#endif
+
 #include <vector>
 #include <string>
 
@@ -27,258 +30,360 @@
 #include <dirent.h>
 #include <sys/stat.h>
 #include <cerrno>
+#include <utility>
 
 #include <lrdf.h>
 
-#include <pbd/compose.h>
-#include <pbd/error.h>
-#include <pbd/pathscanner.h>
-#include <pbd/xml++.h>
+#include "pbd/compose.h"
+#include "pbd/error.h"
+#include "pbd/xml++.h"
+
+#include "ardour/buffer_set.h"
+#include "ardour/chan_count.h"
+#include "ardour/chan_mapping.h"
+#include "ardour/data_type.h"
+#include "ardour/midi_buffer.h"
+#include "ardour/midi_state_tracker.h"
+#include "ardour/plugin.h"
+#include "ardour/plugin_manager.h"
+#include "ardour/session.h"
+#include "ardour/types.h"
+
+#ifdef AUDIOUNIT_SUPPORT
+#include "ardour/audio_unit.h"
+#endif
 
-#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 LV2_SUPPORT
+#include "ardour/lv2_plugin.h"
+#endif
 
-#include <pbd/stl_delete.h>
+#include "pbd/stl_delete.h"
 
 #include "i18n.h"
 #include <locale.h>
 
+using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
+namespace ARDOUR { class AudioEngine; }
+
+bool
+PluginInfo::is_instrument () const
+{
+	return (n_inputs.n_midi() != 0) && (n_outputs.n_audio() > 0);
+}
+
 Plugin::Plugin (AudioEngine& e, Session& s)
-	: _engine (e), _session (s)
+	: _engine (e)
+	, _session (s)
+	, _cycles (0)
+	, _have_presets (false)
+	, _have_pending_stop_events (false)
+	, _parameter_changed_since_last_preset (false)
 {
+	_pending_stop_events.ensure_buffers (DataType::MIDI, 1, 4096);
 }
 
 Plugin::Plugin (const Plugin& other)
-	: _engine (other._engine), _session (other._session), _info (other._info)
+	: StatefulDestructible()
+	, Latent()
+	, _engine (other._engine)
+	, _session (other._session)
+	, _info (other._info)
+	, _cycles (0)
+	, _have_presets (false)
+	, _have_pending_stop_events (false)
+	, _parameter_changed_since_last_preset (false)
+{
+	_pending_stop_events.ensure_buffers (DataType::MIDI, 1, 4096);
+}
+
+Plugin::~Plugin ()
 {
 }
 
 void
-Plugin::setup_controls ()
+Plugin::remove_preset (string name)
 {
-	uint32_t port_cnt = parameter_count();
+	do_remove_preset (name);
+	_presets.erase (preset_by_label (name)->uri);
 
-	/* set up a vector of null pointers for the controls.
-	   we'll fill this in on an as-needed basis.
-	*/
+	_last_preset.uri = "";
+	_parameter_changed_since_last_preset = false;
+	PresetRemoved (); /* EMIT SIGNAL */
+}
+
+/** @return PresetRecord with empty URI on failure */
+Plugin::PresetRecord
+Plugin::save_preset (string name)
+{
+	string const uri = do_save_preset (name);
 
-	for (uint32_t i = 0; i < port_cnt; ++i) {
-		controls.push_back (0);
+	if (!uri.empty()) {
+		_presets.insert (make_pair (uri, PresetRecord (uri, name)));
+		PresetAdded (); /* EMIT SIGNAL */
 	}
+
+	return PresetRecord (uri, name);
 }
 
-Plugin::~Plugin ()
+PluginPtr
+ARDOUR::find_plugin(Session& session, string identifier, PluginType type)
 {
-	for (vector<PortControllable*>::iterator i = controls.begin(); i != controls.end(); ++i) {
-		if (*i) {
-			delete *i;
+	PluginManager& mgr (PluginManager::instance());
+	PluginInfoList plugs;
+
+	switch (type) {
+	case ARDOUR::LADSPA:
+		plugs = mgr.ladspa_plugin_info();
+		break;
+
+#ifdef LV2_SUPPORT
+	case ARDOUR::LV2:
+		plugs = mgr.lv2_plugin_info();
+		break;
+#endif
+
+#ifdef WINDOWS_VST_SUPPORT
+	case ARDOUR::Windows_VST:
+		plugs = mgr.windows_vst_plugin_info();
+		break;
+#endif
+
+#ifdef LXVST_SUPPORT
+	case ARDOUR::LXVST:
+		plugs = mgr.lxvst_plugin_info();
+		break;
+#endif
+
+#ifdef AUDIOUNIT_SUPPORT
+	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);
 		}
 	}
-}
 
-Controllable *
-Plugin::get_nth_control (uint32_t n)
-{
-	if (n >= parameter_count()) {
-		return 0;
+#ifdef WINDOWS_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
 
-	if (controls[n] == 0) {
+#ifdef LXVST_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.
+	*/
 
-		Plugin::ParameterDescriptor desc;
+	for (i = plugs.begin(); i != plugs.end(); ++i) {
+		if (identifier == (*i)->name){
+			return (*i)->load (session);
+		}
+	}
+#endif
 
-		get_parameter_descriptor (n, desc);
-		
-		controls[n] = new PortControllable (*this, n, desc.lower, desc.upper, desc.toggled, desc.logarithmic);
-	} 
+	return PluginPtr ((Plugin*) 0);
+}
 
-	return controls[n];
+ChanCount
+Plugin::output_streams () const
+{
+	/* LADSPA & VST should not get here because they do not
+	   return "infinite" i/o counts.
+	*/
+	return ChanCount::ZERO;
 }
 
-Plugin::PortControllable::PortControllable (Plugin& p, uint32_t port_id, float low, float up, bool t, bool loga)
-	: plugin (p), absolute_port (port_id)
+ChanCount
+Plugin::input_streams () const
 {
-	toggled = t;
-	logarithmic = loga;
-	lower = low;
-	upper = up;
-	range = upper - lower;
+	/* LADSPA & VST should not get here because they do not
+	   return "infinite" i/o counts.
+	*/
+	return ChanCount::ZERO;
 }
 
-void
-Plugin::PortControllable::set_value (float value)
+const Plugin::PresetRecord *
+Plugin::preset_by_label (const string& label)
 {
-	if (toggled) {
-		if (value > 0.5) {
-			value = 1.0;
-		} else {
-			value = 0.0;
+	// 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 0;
+}
+
+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 0;
+	}
+}
+
+int
+Plugin::connect_and_run (BufferSet& bufs,
+			 ChanMapping /*in_map*/, ChanMapping /*out_map*/,
+			 pframes_t /* nframes */, framecnt_t /*offset*/)
+{
+	if (bufs.count().n_midi() > 0) {
+
+		/* Track notes that we are sending to the plugin */
+
+		MidiBuffer& b = bufs.get_midi (0);
 
-		if (!logarithmic) {
-			value = lower + (range * value);
-		} else {
-			float _lower = 0.0f;
-			if (lower > 0.0f) {
-				_lower = log(lower);
-			}
+		_tracker.track (b.begin(), b.end());
 
-			value = exp(_lower + log(range) * value);
+		if (_have_pending_stop_events) {
+			/* Transmit note-offs that are pending from the last transport stop */
+			bufs.merge_from (_pending_stop_events, 0);
+			_have_pending_stop_events = false;
 		}
 	}
 
-	plugin.set_parameter (absolute_port, value);
+	return 0;
 }
 
-float
-Plugin::PortControllable::get_value (void) const
+void
+Plugin::realtime_handle_transport_stopped ()
 {
-	float val = plugin.get_parameter (absolute_port);
+	resolve_midi ();
+}
 
-	if (toggled) {
-		
-		return val;
-		
-	} else {
-		
-		if (logarithmic) {
-			val = log(val);
-		}
-		
-		return ((val - lower) / range);
-	}
-}	
+void
+Plugin::realtime_locate ()
+{
+	resolve_midi ();
+}
 
-vector<string>
-Plugin::get_presets()
+void
+Plugin::monitoring_changed ()
 {
-	vector<string> labels;
-	lrdf_uris* set_uris = lrdf_get_setting_uris(unique_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])) {
-				labels.push_back(label);
-				presets[label] = set_uris->items[i];
-			}
-		}
-		lrdf_free_uris(set_uris);
+	resolve_midi ();
+}
+
+void
+Plugin::resolve_midi ()
+{
+	/* Create note-offs for any active notes and put them in _pending_stop_events, to be picked
+	   up on the next call to connect_and_run ().
+	*/
+
+	_pending_stop_events.get_midi(0).clear ();
+	_tracker.resolve_notes (_pending_stop_events.get_midi (0), 0);
+	_have_pending_stop_events = true;
+}
+
+vector<Plugin::PresetRecord>
+Plugin::get_presets ()
+{
+	if (!_have_presets) {
+		find_presets ();
+		_have_presets = true;
 	}
 
-	// GTK2FIX find an equivalent way to do this with a vector (needed by GUI apis)
-	// labels.unique();
+	vector<PresetRecord> p;
+	for (map<string, PresetRecord>::const_iterator i = _presets.begin(); i != _presets.end(); ++i) {
+		p.push_back (i->second);
+	}
 
-	return labels;
+	return p;
 }
 
+/** Set parameters using a preset */
 bool
-Plugin::load_preset(const string preset_label)
+Plugin::load_preset (PresetRecord r)
 {
-	lrdf_defaults* defs = lrdf_get_setting_values(presets[preset_label].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);
-	}
+	_last_preset = r;
+	_parameter_changed_since_last_preset = false;
 
+	PresetLoaded (); /* EMIT SIGNAL */
 	return true;
 }
 
-bool
-Plugin::save_preset (string name, string domain)
+void
+Plugin::clear_preset ()
 {
-	lrdf_portvalue portvalues[parameter_count()];
-	lrdf_defaults defaults;
-	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);
-		}
-	}
+	_last_preset.uri = "";
+	_last_preset.label = "";
+	_parameter_changed_since_last_preset = false;
 
-	char* envvar;
-	if ((envvar = getenv ("HOME")) == 0) {
-		warning << _("Could not locate HOME.  Preset not saved.") << endmsg;
-		return false;
-	}
-	
-	string source(string_compose("file:%1/.%2/rdf/ardour-presets.n3", envvar, domain));
+	PresetLoaded (); /* EMIT SIGNAL */
+}
 
-	free(lrdf_add_preset(source.c_str(), name.c_str(), unique_id(), &defaults));
+/** @param val `plugin' value */
+void
+Plugin::set_parameter (uint32_t which, float)
+{
+	_parameter_changed_since_last_preset = true;
+	_session.set_dirty ();
+	ParameterChanged (which, get_parameter (which)); /* EMIT SIGNAL */
+}
 
-	string path = string_compose("%1/.%2", envvar, domain);
-	if (mkdir(path.c_str(), 0775) && errno != EEXIST) {
-		warning << string_compose(_("Could not create %1.  Preset not saved. (%2)"), path, strerror(errno)) << endmsg;
-		return false;
+int
+Plugin::set_state (const XMLNode& node, int /*version*/)
+{
+	XMLProperty const * p = node.property (X_("last-preset-uri"));
+	if (p) {
+		_last_preset.uri = p->value ();
 	}
-	
-	path += "/rdf";
-	if (mkdir(path.c_str(), 0775) && errno != EEXIST) {
-		warning << string_compose(_("Could not create %1.  Preset not saved. (%2)"), path, strerror(errno)) << endmsg;
-		return false;
+
+	p = node.property (X_("last-preset-label"));
+	if (p) {
+		_last_preset.label = p->value ();
 	}
-	
-	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;
+
+	p = node.property (X_("parameter-changed-since-last-preset"));
+	if (p) {
+		_parameter_changed_since_last_preset = string_is_affirmative (p->value ());
 	}
 
-	return true;
+	return 0;
 }
 
-PluginPtr
-ARDOUR::find_plugin(Session& session, string name, long unique_id, PluginInfo::Type type)
+XMLNode &
+Plugin::get_state ()
 {
-	PluginManager *mgr = PluginManager::the_manager();
-	PluginInfoList plugs;
+	XMLNode* root = new XMLNode (state_node_name ());
+	LocaleGuard lg (X_("POSIX"));
 
-	switch (type) {
-	case PluginInfo::LADSPA:
-		plugs = mgr->ladspa_plugin_info();
-		break;
+	root->add_property (X_("last-preset-uri"), _last_preset.uri);
+	root->add_property (X_("last-preset-label"), _last_preset.label);
+	root->add_property (X_("parameter-changed-since-last-preset"), _parameter_changed_since_last_preset ? X_("yes") : X_("no"));
 
-#ifdef VST_SUPPORT
-	case PluginInfo::VST:
-		plugs = mgr->vst_plugin_info();
-		unique_id = 0; // VST plugins don't have a unique id.
-		break;
-#endif
+	add_state (root);
+	return *root;
+}
 
-#ifdef HAVE_COREAUDIO
-	case PluginInfo::AudioUnit:
-		plugs = AUPluginInfo::discover ();
-		unique_id = 0; // Neither do AU.
-		break;
-#endif
+void
+Plugin::set_info (PluginInfoPtr info)
+{
+	_info = info;
+}
 
-	default:
-		return PluginPtr ((Plugin *) 0);
-	}
 
-	PluginInfoList::iterator i;
-	for (i = plugs.begin(); i != plugs.end(); ++i) {
-		if ((name == "" || (*i)->name == name) &&
-			(unique_id == 0 || (*i)->unique_id == unique_id)) {
-				return (*i)->load (session);
-		}
-	}
-	
-	return PluginPtr ((Plugin*) 0);
-}