2 Copyright (C) 2000 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "libardour-config.h"
26 #include "pbd/failed_constructor.h"
27 #include "pbd/xml++.h"
28 #include "pbd/convert.h"
30 #include "ardour/audio_buffer.h"
31 #include "ardour/automation_list.h"
32 #include "ardour/buffer_set.h"
33 #include "ardour/debug.h"
34 #include "ardour/event_type_map.h"
35 #include "ardour/ladspa_plugin.h"
36 #include "ardour/plugin.h"
37 #include "ardour/plugin_insert.h"
40 #include "ardour/lv2_plugin.h"
43 #ifdef WINDOWS_VST_SUPPORT
44 #include "ardour/windows_vst_plugin.h"
48 #include "ardour/lxvst_plugin.h"
51 #ifdef AUDIOUNIT_SUPPORT
52 #include "ardour/audio_unit.h"
55 #include "ardour/session.h"
56 #include "ardour/types.h"
61 using namespace ARDOUR;
64 const string PluginInsert::port_automation_node_name = "PortAutomation";
66 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
67 : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
68 , _signal_analysis_collected_nframes(0)
69 , _signal_analysis_collect_nframes_max(0)
71 /* the first is the master */
75 create_automatable_parameters ();
80 PluginInsert::set_count (uint32_t num)
82 bool require_state = !_plugins.empty();
84 /* this is a bad idea.... we shouldn't do this while active.
85 only a route holding their redirect_lock should be calling this
90 } else if (num > _plugins.size()) {
91 uint32_t diff = num - _plugins.size();
93 for (uint32_t n = 0; n < diff; ++n) {
94 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
101 /* XXX do something */
105 } else if (num < _plugins.size()) {
106 uint32_t diff = _plugins.size() - num;
107 for (uint32_t n= 0; n < diff; ++n) {
115 PluginInsert::~PluginInsert ()
120 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
122 if (which.type() != PluginAutomation)
125 boost::shared_ptr<AutomationControl> c
126 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
129 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
134 PluginInsert::output_streams() const
136 assert (!_plugins.empty());
138 PluginInfoPtr info = _plugins.front()->get_info();
140 if (info->reconfigurable_io()) {
141 ChanCount out = _plugins.front()->output_streams ();
142 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
145 ChanCount out = info->n_outputs;
146 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
147 out.set_audio (out.n_audio() * _plugins.size());
148 out.set_midi (out.n_midi() * _plugins.size() + midi_bypass.n_midi());
154 PluginInsert::input_streams() const
156 assert (!_plugins.empty());
160 PluginInfoPtr info = _plugins.front()->get_info();
162 if (info->reconfigurable_io()) {
163 assert (_plugins.size() == 1);
164 in = _plugins.front()->input_streams();
169 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
171 if (_match.method == Split) {
173 /* we are splitting 1 processor input to multiple plugin inputs,
174 so we have a maximum of 1 stream of each type.
176 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
177 if (in.get (*t) > 1) {
183 } else if (_match.method == Hide) {
185 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
186 in.set (*t, in.get (*t) - _match.hide.get (*t));
192 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
193 in.set (*t, in.get (*t) * _plugins.size ());
201 PluginInsert::natural_output_streams() const
203 return _plugins[0]->get_info()->n_outputs;
207 PluginInsert::natural_input_streams() const
209 return _plugins[0]->get_info()->n_inputs;
213 PluginInsert::has_no_inputs() const
215 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
219 PluginInsert::has_no_audio_inputs() const
221 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
225 PluginInsert::is_midi_instrument() const
227 /* XXX more finesse is possible here. VST plugins have a
228 a specific "instrument" flag, for example.
230 PluginInfoPtr pi = _plugins[0]->get_info();
232 return pi->n_inputs.n_midi() != 0 &&
233 pi->n_outputs.n_audio() > 0;
237 PluginInsert::create_automatable_parameters ()
239 assert (!_plugins.empty());
241 set<Evoral::Parameter> a = _plugins.front()->automatable ();
243 Plugin::ParameterDescriptor desc;
245 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
246 if (i->type() == PluginAutomation) {
248 Evoral::Parameter param(*i);
250 _plugins.front()->get_parameter_descriptor(i->id(), desc);
252 /* the Parameter belonging to the actual plugin doesn't have its range set
253 but we want the Controllable related to this Parameter to have those limits.
256 param.set_range (desc.lower, desc.upper, _plugins.front()->default_value(i->id()), desc.toggled);
257 can_automate (param);
258 boost::shared_ptr<AutomationList> list(new AutomationList(param));
259 add_control (boost::shared_ptr<AutomationControl> (new PluginControl(this, param, list)));
265 PluginInsert::parameter_changed (uint32_t which, float val)
267 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
272 Plugins::iterator i = _plugins.begin();
274 /* don't set the first plugin, just all the slaves */
276 if (i != _plugins.end()) {
278 for (; i != _plugins.end(); ++i) {
279 (*i)->set_parameter (which, val);
286 PluginInsert::set_block_size (pframes_t nframes)
289 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
290 if ((*i)->set_block_size (nframes) != 0) {
298 PluginInsert::activate ()
300 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
304 Processor::activate ();
308 PluginInsert::deactivate ()
310 Processor::deactivate ();
312 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
318 PluginInsert::flush ()
320 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
326 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
328 // Calculate if, and how many frames we need to collect for analysis
329 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
330 _signal_analysis_collected_nframes);
331 if (nframes < collect_signal_nframes) { // we might not get all frames now
332 collect_signal_nframes = nframes;
335 ChanCount const in_streams = input_streams ();
336 ChanCount const out_streams = output_streams ();
338 ChanMapping in_map (in_streams);
339 ChanMapping out_map (out_streams);
341 if (_match.method == Split) {
342 /* fix the input mapping so that we have maps for each of the plugin's inputs */
343 in_map = ChanMapping (natural_input_streams ());
345 /* copy the first stream's buffer contents to the others */
346 /* XXX: audio only */
347 uint32_t first_idx = in_map.get (DataType::AUDIO, 0, &valid);
349 for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
350 bufs.get_audio(in_map.get (DataType::AUDIO, i, &valid)).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
355 /* Note that we've already required that plugins
356 be able to handle in-place processing.
363 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
365 boost::shared_ptr<AutomationControl> c
366 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
368 if (c->parameter().type() == PluginAutomation && c->automation_playback()) {
371 const float val = c->list()->rt_safe_eval (now, valid);
381 if (collect_signal_nframes > 0) {
383 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
384 //std::cerr << " streams " << input_streams().n_audio() << std::endl;
385 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
387 _signal_analysis_inputs.set_count(input_streams());
389 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
390 _signal_analysis_inputs.get_audio(i).read_from(
392 collect_signal_nframes,
393 _signal_analysis_collected_nframes); // offset is for target buffer
398 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
399 (*i)->connect_and_run(bufs, in_map, out_map, nframes, offset);
400 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
401 in_map.offset_to(*t, natural_input_streams().get(*t));
402 out_map.offset_to(*t, natural_output_streams().get(*t));
406 if (collect_signal_nframes > 0) {
408 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
409 //std::cerr << " streams " << output_streams().n_audio() << std::endl;
411 _signal_analysis_outputs.set_count(output_streams());
413 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
414 _signal_analysis_outputs.get_audio(i).read_from(
416 collect_signal_nframes,
417 _signal_analysis_collected_nframes); // offset is for target buffer
420 _signal_analysis_collected_nframes += collect_signal_nframes;
421 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
423 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
424 _signal_analysis_collect_nframes_max = 0;
425 _signal_analysis_collected_nframes = 0;
427 AnalysisDataGathered(&_signal_analysis_inputs,
428 &_signal_analysis_outputs);
431 /* leave remaining channel buffers alone */
435 PluginInsert::silence (framecnt_t nframes)
441 ChanMapping in_map(input_streams());
442 ChanMapping out_map(output_streams());
444 if (_match.method == Split) {
445 /* fix the input mapping so that we have maps for each of the plugin's inputs */
446 in_map = ChanMapping (natural_input_streams ());
449 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
450 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
455 PluginInsert::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_frame*/, pframes_t nframes, bool)
457 if (_pending_active) {
458 /* run as normal if we are active or moving from inactive to active */
460 if (_session.transport_rolling()) {
461 automation_run (bufs, nframes);
463 connect_and_run (bufs, nframes, 0, false);
467 uint32_t in = input_streams ().n_audio ();
468 uint32_t out = output_streams().n_audio ();
470 if (has_no_audio_inputs() || in == 0) {
472 /* silence all (audio) outputs. Should really declick
473 * at the transitions of "active"
476 for (uint32_t n = 0; n < out; ++n) {
477 bufs.get_audio (n).silence (nframes);
480 } else if (out > in) {
482 /* not active, but something has make up for any channel count increase */
484 // TODO: option round-robin (n % in) or silence additional buffers ??
485 // for now , simply replicate last buffer
486 for (uint32_t n = in; n < out; ++n) {
487 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
491 bufs.count().set_audio (out);
494 _active = _pending_active;
496 /* we have no idea whether the plugin generated silence or not, so mark
497 * all buffers appropriately.
503 PluginInsert::set_parameter (Evoral::Parameter param, float val)
505 if (param.type() != PluginAutomation) {
509 /* the others will be set from the event triggered by this */
511 _plugins[0]->set_parameter (param.id(), val);
513 boost::shared_ptr<AutomationControl> ac
514 = boost::dynamic_pointer_cast<AutomationControl>(control(param));
519 warning << "set_parameter called for nonexistant parameter "
520 << EventTypeMap::instance().to_symbol(param) << endmsg;
523 _session.set_dirty();
527 PluginInsert::get_parameter (Evoral::Parameter param)
529 if (param.type() != PluginAutomation) {
532 assert (!_plugins.empty ());
533 return _plugins[0]->get_parameter (param.id());
538 PluginInsert::automation_run (BufferSet& bufs, pframes_t nframes)
540 Evoral::ControlEvent next_event (0, 0.0f);
541 framepos_t now = _session.transport_frame ();
542 framepos_t end = now + nframes;
543 framecnt_t offset = 0;
545 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
548 connect_and_run (bufs, nframes, offset, false);
552 if (!find_next_event (now, end, next_event) || requires_fixed_sized_buffers()) {
554 /* no events have a time within the relevant range */
556 connect_and_run (bufs, nframes, offset, true, now);
562 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
564 connect_and_run (bufs, cnt, offset, true, now);
570 if (!find_next_event (now, end, next_event)) {
575 /* cleanup anything that is left to do */
578 connect_and_run (bufs, nframes, offset, true, now);
583 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
585 if (param.type() != PluginAutomation)
588 if (_plugins.empty()) {
589 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
594 return _plugins[0]->default_value (param.id());
597 boost::shared_ptr<Plugin>
598 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
600 boost::shared_ptr<LadspaPlugin> lp;
602 boost::shared_ptr<LV2Plugin> lv2p;
604 #ifdef WINDOWS_VST_SUPPORT
605 boost::shared_ptr<WindowsVSTPlugin> vp;
608 boost::shared_ptr<LXVSTPlugin> lxvp;
610 #ifdef AUDIOUNIT_SUPPORT
611 boost::shared_ptr<AUPlugin> ap;
614 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
615 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
617 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
618 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
620 #ifdef WINDOWS_VST_SUPPORT
621 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
622 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
625 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
626 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
628 #ifdef AUDIOUNIT_SUPPORT
629 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
630 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
634 fatal << string_compose (_("programming error: %1"),
635 X_("unknown plugin type in PluginInsert::plugin_factory"))
638 return boost::shared_ptr<Plugin> ((Plugin*) 0);
642 PluginInsert::configure_io (ChanCount in, ChanCount out)
644 Match old_match = _match;
645 ChanCount old_in = input_streams ();
646 ChanCount old_out = output_streams ();
648 /* set the matching method and number of plugins that we will use to meet this configuration */
649 _match = private_can_support_io_configuration (in, out);
650 if (set_count (_match.plugins) == false) {
654 if ( (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
659 PluginIoReConfigure (); /* EMIT SIGNAL */
662 /* configure plugins */
663 switch (_match.method) {
666 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out)) {
672 if (_plugins.front()->configure_io (in, out) == false) {
678 // we don't know the analysis window size, so we must work with the
679 // current buffer size here. each request for data fills in these
680 // buffers and the analyser makes sure it gets enough data for the
682 session().ensure_buffer_set (_signal_analysis_inputs, in);
683 //_signal_analysis_inputs.set_count (in);
685 session().ensure_buffer_set (_signal_analysis_outputs, out);
686 //_signal_analysis_outputs.set_count (out);
688 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
690 return Processor::configure_io (in, out);
693 /** Decide whether this PluginInsert can support a given IO configuration.
694 * To do this, we run through a set of possible solutions in rough order of
697 * @param in Required input channel count.
698 * @param out Filled in with the output channel count if we return true.
699 * @return true if the given IO configuration can be supported.
702 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
704 return private_can_support_io_configuration (in, out).method != Impossible;
707 /** A private version of can_support_io_configuration which returns the method
708 * by which the configuration can be matched, rather than just whether or not
712 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
714 if (_plugins.empty()) {
718 PluginInfoPtr info = _plugins.front()->get_info();
719 ChanCount in; in += inx;
722 if (info->reconfigurable_io()) {
723 /* Plugin has flexible I/O, so delegate to it */
724 bool const r = _plugins.front()->can_support_io_configuration (in, out);
726 return Match (Impossible, 0);
729 return Match (Delegate, 1);
732 ChanCount inputs = info->n_inputs;
733 ChanCount outputs = info->n_outputs;
735 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
736 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
737 midi_bypass.set(DataType::MIDI, 1);
739 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
740 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
741 in.set(DataType::MIDI, 0);
744 bool no_inputs = true;
745 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
746 if (inputs.get (*t) != 0) {
753 /* no inputs so we can take any input configuration since we throw it away */
754 out = outputs + midi_bypass;
755 return Match (NoInputs, 1);
758 /* Plugin inputs match requested inputs exactly */
760 out = outputs + midi_bypass;
761 return Match (ExactMatch, 1);
764 /* We may be able to run more than one copy of the plugin within this insert
765 to cope with the insert having more inputs than the plugin.
766 We allow replication only for plugins with either zero or 1 inputs and outputs
767 for every valid data type.
771 bool can_replicate = true;
772 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
774 uint32_t nin = inputs.get (*t);
776 // No inputs of this type
777 if (nin == 0 && in.get(*t) == 0) {
781 if (nin != 1 || outputs.get (*t) != 1) {
782 can_replicate = false;
786 // Potential factor not set yet
788 f = in.get(*t) / nin;
791 // Factor for this type does not match another type, can not replicate
792 if (f != (in.get(*t) / nin)) {
793 can_replicate = false;
799 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
800 out.set (*t, outputs.get(*t) * f);
803 return Match (Replicate, f);
806 /* If the processor has exactly one input of a given type, and
807 the plugin has more, we can feed the single processor input
808 to some or all of the plugin inputs. This is rather
809 special-case-y, but the 1-to-many case is by far the
810 simplest. How do I split thy 2 processor inputs to 3
811 plugin inputs? Let me count the ways ...
814 bool can_split = true;
815 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
817 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
818 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
820 if (!can_split_type && !nothing_to_do_for_type) {
826 out = outputs + midi_bypass;
827 return Match (Split, 1);
830 /* If the plugin has more inputs than we want, we can `hide' some of them
831 by feeding them silence.
834 bool could_hide = false;
835 bool cannot_hide = false;
836 ChanCount hide_channels;
838 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
839 if (inputs.get(*t) > in.get(*t)) {
840 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
841 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
843 } else if (inputs.get(*t) < in.get(*t)) {
844 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
849 if (could_hide && !cannot_hide) {
850 out = outputs + midi_bypass;
851 return Match (Hide, 1, hide_channels);
855 return Match (Impossible, 0);
859 PluginInsert::get_state ()
865 PluginInsert::state (bool full)
867 XMLNode& node = Processor::state (full);
869 node.add_property("type", _plugins[0]->state_node_name());
870 node.add_property("unique-id", _plugins[0]->unique_id());
871 node.add_property("count", string_compose("%1", _plugins.size()));
872 node.add_child_nocopy (_plugins[0]->get_state());
874 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
875 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
877 node.add_child_nocopy (ac->get_state());
885 PluginInsert::set_control_ids (const XMLNode& node, int version)
887 const XMLNodeList& nlist = node.children();
888 XMLNodeConstIterator iter;
889 set<Evoral::Parameter>::const_iterator p;
891 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
892 if ((*iter)->name() == Controllable::xml_node_name) {
893 const XMLProperty* prop;
895 if ((prop = (*iter)->property (X_("parameter"))) != 0) {
896 uint32_t p = atoi (prop->value());
898 /* this may create the new controllable */
900 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
902 #ifndef NO_PLUGIN_STATE
906 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
908 ac->set_state (**iter, version);
917 PluginInsert::set_state(const XMLNode& node, int version)
919 XMLNodeList nlist = node.children();
920 XMLNodeIterator niter;
921 XMLPropertyList plist;
922 const XMLProperty *prop;
923 ARDOUR::PluginType type;
925 if ((prop = node.property ("type")) == 0) {
926 error << _("XML node describing plugin is missing the `type' field") << endmsg;
930 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
931 type = ARDOUR::LADSPA;
932 } else if (prop->value() == X_("lv2")) {
934 } else if (prop->value() == X_("windows-vst")) {
935 type = ARDOUR::Windows_VST;
936 } else if (prop->value() == X_("lxvst")) {
937 type = ARDOUR::LXVST;
938 } else if (prop->value() == X_("audiounit")) {
939 type = ARDOUR::AudioUnit;
941 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
947 prop = node.property ("unique-id");
950 #ifdef WINDOWS_VST_SUPPORT
951 /* older sessions contain VST plugins with only an "id" field.
954 if (type == ARDOUR::Windows_VST) {
955 prop = node.property ("id");
960 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
962 if (type == ARDOUR::LXVST) {
963 prop = node.property ("id");
969 error << _("Plugin has no unique ID field") << endmsg;
974 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
977 error << string_compose(
978 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
979 "Perhaps it was removed or moved since it was last used."),
985 // The name of the PluginInsert comes from the plugin, nothing else
986 _name = plugin->get_info()->name;
990 // Processor::set_state() will set this, but too late
991 // for it to be available when setting up plugin
992 // state. We can't call Processor::set_state() until
993 // the plugins themselves are created and added.
997 if (_plugins.empty()) {
998 /* if we are adding the first plugin, we will need to set
999 up automatable controls.
1001 add_plugin (plugin);
1002 create_automatable_parameters ();
1003 set_control_ids (node, version);
1006 if ((prop = node.property ("count")) != 0) {
1007 sscanf (prop->value().c_str(), "%u", &count);
1010 if (_plugins.size() != count) {
1011 for (uint32_t n = 1; n < count; ++n) {
1012 add_plugin (plugin_factory (plugin));
1016 Processor::set_state (node, version);
1018 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1020 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1021 and set all plugins to the same state.
1024 if ((*niter)->name() == plugin->state_node_name()) {
1026 plugin->set_state (**niter, version);
1028 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1029 (*i)->set_state (**niter, version);
1036 if (version < 3000) {
1038 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1039 this is all handled by Automatable
1042 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1043 if ((*niter)->name() == "Redirect") {
1044 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1045 Processor::set_state (**niter, version);
1050 set_parameter_state_2X (node, version);
1053 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1057 (*i)->deactivate ();
1065 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1067 XMLNodeList nlist = node.children();
1068 XMLNodeIterator niter;
1070 /* look for port automation node */
1072 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1074 if ((*niter)->name() != port_automation_node_name) {
1080 XMLNodeConstIterator iter;
1085 cnodes = (*niter)->children ("port");
1087 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1091 if ((cprop = child->property("number")) != 0) {
1092 port = cprop->value().c_str();
1094 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1098 sscanf (port, "%" PRIu32, &port_id);
1100 if (port_id >= _plugins[0]->parameter_count()) {
1101 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1105 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1106 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1109 if (!child->children().empty()) {
1110 c->alist()->set_state (*child->children().front(), version);
1112 /* In some cases 2.X saves lists with min_yval and max_yval
1113 being FLT_MIN and FLT_MAX respectively. This causes problems
1114 in A3 because these min/max values are used to compute
1115 where GUI control points should be drawn. If we see such
1116 values, `correct' them to the min/max of the appropriate
1120 float min_y = c->alist()->get_min_y ();
1121 float max_y = c->alist()->get_max_y ();
1123 Plugin::ParameterDescriptor desc;
1124 _plugins.front()->get_parameter_descriptor (port_id, desc);
1126 if (min_y == FLT_MIN) {
1130 if (max_y == FLT_MAX) {
1134 c->alist()->set_yrange (min_y, max_y);
1137 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1149 PluginInsert::describe_parameter (Evoral::Parameter param)
1151 if (param.type() != PluginAutomation) {
1152 return Automatable::describe_parameter(param);
1155 return _plugins[0]->describe_parameter (param);
1159 PluginInsert::signal_latency() const
1161 if (_user_latency) {
1162 return _user_latency;
1165 return _plugins[0]->signal_latency ();
1169 PluginInsert::type ()
1171 return plugin()->get_info()->type;
1174 PluginInsert::PluginControl::PluginControl (PluginInsert* p, const Evoral::Parameter ¶m, boost::shared_ptr<AutomationList> list)
1175 : AutomationControl (p->session(), param, list, p->describe_parameter(param))
1178 Plugin::ParameterDescriptor desc;
1179 boost::shared_ptr<Plugin> plugin = p->plugin (0);
1181 alist()->reset_default (plugin->default_value (param.id()));
1183 plugin->get_parameter_descriptor (param.id(), desc);
1184 _logarithmic = desc.logarithmic;
1185 _sr_dependent = desc.sr_dependent;
1186 _toggled = desc.toggled;
1189 /** @param val `user' value */
1191 PluginInsert::PluginControl::set_value (double user_val)
1193 /* FIXME: probably should be taking out some lock here.. */
1195 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1196 (*i)->set_parameter (_list->parameter().id(), user_val);
1199 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1201 iasp->set_parameter (_list->parameter().id(), user_val);
1204 AutomationControl::set_value (user_val);
1208 PluginInsert::PluginControl::internal_to_interface (double val) const
1211 /* some plugins have a log-scale range "0.."
1212 * ideally we'd map the range down to infinity somehow :)
1214 * one solution could be to use
1215 * val = exp(lower + log(range) * value);
1216 * (log(val) - lower) / range)
1217 * This approach would require access to the actual range (ie
1218 * Plugin::ParameterDescriptor) and also require handling
1219 * of unbound ranges..
1221 * currently an arbitrarly low number is assumed to represnt
1222 * log(0) as hot-fix solution.
1227 val = -8; // ~ -70dB = 20 * log10(exp(-8))
1235 PluginInsert::PluginControl::interface_to_internal (double val) const
1239 /* see note in PluginInsert::PluginControl::internal_to_interface() */
1250 PluginInsert::PluginControl::get_state ()
1254 XMLNode& node (AutomationControl::get_state());
1255 ss << parameter().id();
1256 node.add_property (X_("parameter"), ss.str());
1261 /** @return `user' val */
1263 PluginInsert::PluginControl::get_value () const
1265 /* FIXME: probably should be taking out some lock here.. */
1266 return _plugin->get_parameter (_list->parameter());
1269 boost::shared_ptr<Plugin>
1270 PluginInsert::get_impulse_analysis_plugin()
1272 boost::shared_ptr<Plugin> ret;
1273 if (_impulseAnalysisPlugin.expired()) {
1274 ret = plugin_factory(_plugins[0]);
1275 _impulseAnalysisPlugin = ret;
1277 ret = _impulseAnalysisPlugin.lock();
1284 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1286 // called from outside the audio thread, so this should be safe
1287 // only do audio as analysis is (currently) only for audio plugins
1288 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1289 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1291 _signal_analysis_collected_nframes = 0;
1292 _signal_analysis_collect_nframes_max = nframes;
1295 /** Add a plugin to our list */
1297 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1299 plugin->set_insert_info (this);
1301 if (_plugins.empty()) {
1302 /* first (and probably only) plugin instance - connect to relevant signals
1305 plugin->ParameterChanged.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed, this, _1, _2));
1306 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1307 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1310 _plugins.push_back (plugin);
1314 PluginInsert::realtime_handle_transport_stopped ()
1316 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1317 (*i)->realtime_handle_transport_stopped ();
1322 PluginInsert::realtime_locate ()
1324 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1325 (*i)->realtime_locate ();
1330 PluginInsert::monitoring_changed ()
1332 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1333 (*i)->monitoring_changed ();
1338 PluginInsert::start_touch (uint32_t param_id)
1340 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1342 ac->start_touch (session().audible_frame());
1347 PluginInsert::end_touch (uint32_t param_id)
1349 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1351 ac->stop_touch (true, session().audible_frame());