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 if (has_no_audio_inputs()) {
469 /* silence all (audio) outputs. Should really declick
470 * at the transitions of "active"
473 uint32_t out = output_streams().n_audio ();
475 for (uint32_t n = 0; n < out; ++n) {
476 bufs.get_audio (n).silence (nframes);
479 bufs.count().set_audio (out);
483 /* does this need to be done with MIDI? it appears not */
485 uint32_t in = input_streams ().n_audio ();
486 uint32_t out = output_streams().n_audio ();
490 /* not active, but something has make up for any channel count increase */
492 // TODO: option round-robin (n % in) or silence additional buffers ??
493 for (uint32_t n = in; n < out; ++n) {
494 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
498 bufs.count().set_audio (out);
502 _active = _pending_active;
504 /* we have no idea whether the plugin generated silence or not, so mark
505 * all buffers appropriately.
511 PluginInsert::set_parameter (Evoral::Parameter param, float val)
513 if (param.type() != PluginAutomation) {
517 /* the others will be set from the event triggered by this */
519 _plugins[0]->set_parameter (param.id(), val);
521 boost::shared_ptr<AutomationControl> ac
522 = boost::dynamic_pointer_cast<AutomationControl>(control(param));
527 warning << "set_parameter called for nonexistant parameter "
528 << EventTypeMap::instance().to_symbol(param) << endmsg;
531 _session.set_dirty();
535 PluginInsert::get_parameter (Evoral::Parameter param)
537 if (param.type() != PluginAutomation) {
540 assert (!_plugins.empty ());
541 return _plugins[0]->get_parameter (param.id());
546 PluginInsert::automation_run (BufferSet& bufs, pframes_t nframes)
548 Evoral::ControlEvent next_event (0, 0.0f);
549 framepos_t now = _session.transport_frame ();
550 framepos_t end = now + nframes;
551 framecnt_t offset = 0;
553 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
556 connect_and_run (bufs, nframes, offset, false);
560 if (!find_next_event (now, end, next_event) || requires_fixed_sized_buffers()) {
562 /* no events have a time within the relevant range */
564 connect_and_run (bufs, nframes, offset, true, now);
570 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
572 connect_and_run (bufs, cnt, offset, true, now);
578 if (!find_next_event (now, end, next_event)) {
583 /* cleanup anything that is left to do */
586 connect_and_run (bufs, nframes, offset, true, now);
591 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
593 if (param.type() != PluginAutomation)
596 if (_plugins.empty()) {
597 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
602 return _plugins[0]->default_value (param.id());
605 boost::shared_ptr<Plugin>
606 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
608 boost::shared_ptr<LadspaPlugin> lp;
610 boost::shared_ptr<LV2Plugin> lv2p;
612 #ifdef WINDOWS_VST_SUPPORT
613 boost::shared_ptr<WindowsVSTPlugin> vp;
616 boost::shared_ptr<LXVSTPlugin> lxvp;
618 #ifdef AUDIOUNIT_SUPPORT
619 boost::shared_ptr<AUPlugin> ap;
622 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
623 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
625 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
626 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
628 #ifdef WINDOWS_VST_SUPPORT
629 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
630 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
633 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
634 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
636 #ifdef AUDIOUNIT_SUPPORT
637 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
638 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
642 fatal << string_compose (_("programming error: %1"),
643 X_("unknown plugin type in PluginInsert::plugin_factory"))
646 return boost::shared_ptr<Plugin> ((Plugin*) 0);
650 PluginInsert::configure_io (ChanCount in, ChanCount out)
652 Match old_match = _match;
653 ChanCount old_in = input_streams ();
654 ChanCount old_out = output_streams ();
656 /* set the matching method and number of plugins that we will use to meet this configuration */
657 _match = private_can_support_io_configuration (in, out);
658 if (set_count (_match.plugins) == false) {
662 if ( (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
667 PluginIoReConfigure (); /* EMIT SIGNAL */
670 /* configure plugins */
671 switch (_match.method) {
674 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out)) {
680 if (_plugins.front()->configure_io (in, out) == false) {
686 // we don't know the analysis window size, so we must work with the
687 // current buffer size here. each request for data fills in these
688 // buffers and the analyser makes sure it gets enough data for the
690 session().ensure_buffer_set (_signal_analysis_inputs, in);
691 //_signal_analysis_inputs.set_count (in);
693 session().ensure_buffer_set (_signal_analysis_outputs, out);
694 //_signal_analysis_outputs.set_count (out);
696 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
698 return Processor::configure_io (in, out);
701 /** Decide whether this PluginInsert can support a given IO configuration.
702 * To do this, we run through a set of possible solutions in rough order of
705 * @param in Required input channel count.
706 * @param out Filled in with the output channel count if we return true.
707 * @return true if the given IO configuration can be supported.
710 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
712 return private_can_support_io_configuration (in, out).method != Impossible;
715 /** A private version of can_support_io_configuration which returns the method
716 * by which the configuration can be matched, rather than just whether or not
720 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
722 PluginInfoPtr info = _plugins.front()->get_info();
723 ChanCount in; in += inx;
726 if (info->reconfigurable_io()) {
727 /* Plugin has flexible I/O, so delegate to it */
728 bool const r = _plugins.front()->can_support_io_configuration (in, out);
730 return Match (Impossible, 0);
733 return Match (Delegate, 1);
736 ChanCount inputs = info->n_inputs;
737 ChanCount outputs = info->n_outputs;
739 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
740 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
741 midi_bypass.set(DataType::MIDI, 1);
743 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
744 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
745 in.set(DataType::MIDI, 0);
748 bool no_inputs = true;
749 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
750 if (inputs.get (*t) != 0) {
757 /* no inputs so we can take any input configuration since we throw it away */
758 out = outputs + midi_bypass;
759 return Match (NoInputs, 1);
762 /* Plugin inputs match requested inputs exactly */
764 out = outputs + midi_bypass;
765 return Match (ExactMatch, 1);
768 /* We may be able to run more than one copy of the plugin within this insert
769 to cope with the insert having more inputs than the plugin.
770 We allow replication only for plugins with either zero or 1 inputs and outputs
771 for every valid data type.
775 bool can_replicate = true;
776 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
778 uint32_t nin = inputs.get (*t);
780 // No inputs of this type
781 if (nin == 0 && in.get(*t) == 0) {
785 if (nin != 1 || outputs.get (*t) != 1) {
786 can_replicate = false;
790 // Potential factor not set yet
792 f = in.get(*t) / nin;
795 // Factor for this type does not match another type, can not replicate
796 if (f != (in.get(*t) / nin)) {
797 can_replicate = false;
803 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
804 out.set (*t, outputs.get(*t) * f);
807 return Match (Replicate, f);
810 /* If the processor has exactly one input of a given type, and
811 the plugin has more, we can feed the single processor input
812 to some or all of the plugin inputs. This is rather
813 special-case-y, but the 1-to-many case is by far the
814 simplest. How do I split thy 2 processor inputs to 3
815 plugin inputs? Let me count the ways ...
818 bool can_split = true;
819 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
821 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
822 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
824 if (!can_split_type && !nothing_to_do_for_type) {
830 out = outputs + midi_bypass;
831 return Match (Split, 1);
834 /* If the plugin has more inputs than we want, we can `hide' some of them
835 by feeding them silence.
838 bool could_hide = false;
839 bool cannot_hide = false;
840 ChanCount hide_channels;
842 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
843 if (inputs.get(*t) > in.get(*t)) {
844 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
845 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
847 } else if (inputs.get(*t) < in.get(*t)) {
848 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
853 if (could_hide && !cannot_hide) {
854 out = outputs + midi_bypass;
855 return Match (Hide, 1, hide_channels);
859 return Match (Impossible, 0);
863 PluginInsert::get_state ()
869 PluginInsert::state (bool full)
871 XMLNode& node = Processor::state (full);
873 node.add_property("type", _plugins[0]->state_node_name());
874 node.add_property("unique-id", _plugins[0]->unique_id());
875 node.add_property("count", string_compose("%1", _plugins.size()));
876 node.add_child_nocopy (_plugins[0]->get_state());
878 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
879 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
881 node.add_child_nocopy (ac->get_state());
889 PluginInsert::set_control_ids (const XMLNode& node, int version)
891 const XMLNodeList& nlist = node.children();
892 XMLNodeConstIterator iter;
893 set<Evoral::Parameter>::const_iterator p;
895 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
896 if ((*iter)->name() == Controllable::xml_node_name) {
897 const XMLProperty* prop;
899 if ((prop = (*iter)->property (X_("parameter"))) != 0) {
900 uint32_t p = atoi (prop->value());
902 /* this may create the new controllable */
904 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
906 #ifndef NO_PLUGIN_STATE
910 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
912 ac->set_state (**iter, version);
921 PluginInsert::set_state(const XMLNode& node, int version)
923 XMLNodeList nlist = node.children();
924 XMLNodeIterator niter;
925 XMLPropertyList plist;
926 const XMLProperty *prop;
927 ARDOUR::PluginType type;
929 if ((prop = node.property ("type")) == 0) {
930 error << _("XML node describing plugin is missing the `type' field") << endmsg;
934 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
935 type = ARDOUR::LADSPA;
936 } else if (prop->value() == X_("lv2")) {
938 } else if (prop->value() == X_("windows-vst")) {
939 type = ARDOUR::Windows_VST;
940 } else if (prop->value() == X_("lxvst")) {
941 type = ARDOUR::LXVST;
942 } else if (prop->value() == X_("audiounit")) {
943 type = ARDOUR::AudioUnit;
945 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
951 prop = node.property ("unique-id");
954 #ifdef WINDOWS_VST_SUPPORT
955 /* older sessions contain VST plugins with only an "id" field.
958 if (type == ARDOUR::Windows_VST) {
959 prop = node.property ("id");
964 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
966 if (type == ARDOUR::LXVST) {
967 prop = node.property ("id");
973 error << _("Plugin has no unique ID field") << endmsg;
978 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
981 error << string_compose(
982 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
983 "Perhaps it was removed or moved since it was last used."),
989 // The name of the PluginInsert comes from the plugin, nothing else
990 _name = plugin->get_info()->name;
994 // Processor::set_state() will set this, but too late
995 // for it to be available when setting up plugin
996 // state. We can't call Processor::set_state() until
997 // the plugins themselves are created and added.
1001 if (_plugins.empty()) {
1002 /* if we are adding the first plugin, we will need to set
1003 up automatable controls.
1005 add_plugin (plugin);
1006 create_automatable_parameters ();
1007 set_control_ids (node, version);
1010 if ((prop = node.property ("count")) != 0) {
1011 sscanf (prop->value().c_str(), "%u", &count);
1014 if (_plugins.size() != count) {
1015 for (uint32_t n = 1; n < count; ++n) {
1016 add_plugin (plugin_factory (plugin));
1020 Processor::set_state (node, version);
1022 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1024 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1025 and set all plugins to the same state.
1028 if ((*niter)->name() == plugin->state_node_name()) {
1030 plugin->set_state (**niter, version);
1032 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1033 (*i)->set_state (**niter, version);
1040 if (version < 3000) {
1042 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1043 this is all handled by Automatable
1046 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1047 if ((*niter)->name() == "Redirect") {
1048 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1049 Processor::set_state (**niter, version);
1054 set_parameter_state_2X (node, version);
1057 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1061 (*i)->deactivate ();
1069 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1071 XMLNodeList nlist = node.children();
1072 XMLNodeIterator niter;
1074 /* look for port automation node */
1076 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1078 if ((*niter)->name() != port_automation_node_name) {
1084 XMLNodeConstIterator iter;
1089 cnodes = (*niter)->children ("port");
1091 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1095 if ((cprop = child->property("number")) != 0) {
1096 port = cprop->value().c_str();
1098 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1102 sscanf (port, "%" PRIu32, &port_id);
1104 if (port_id >= _plugins[0]->parameter_count()) {
1105 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1109 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1110 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1113 if (!child->children().empty()) {
1114 c->alist()->set_state (*child->children().front(), version);
1116 /* In some cases 2.X saves lists with min_yval and max_yval
1117 being FLT_MIN and FLT_MAX respectively. This causes problems
1118 in A3 because these min/max values are used to compute
1119 where GUI control points should be drawn. If we see such
1120 values, `correct' them to the min/max of the appropriate
1124 float min_y = c->alist()->get_min_y ();
1125 float max_y = c->alist()->get_max_y ();
1127 Plugin::ParameterDescriptor desc;
1128 _plugins.front()->get_parameter_descriptor (port_id, desc);
1130 if (min_y == FLT_MIN) {
1134 if (max_y == FLT_MAX) {
1138 c->alist()->set_yrange (min_y, max_y);
1141 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1153 PluginInsert::describe_parameter (Evoral::Parameter param)
1155 if (param.type() != PluginAutomation) {
1156 return Automatable::describe_parameter(param);
1159 return _plugins[0]->describe_parameter (param);
1163 PluginInsert::signal_latency() const
1165 if (_user_latency) {
1166 return _user_latency;
1169 return _plugins[0]->signal_latency ();
1173 PluginInsert::type ()
1175 return plugin()->get_info()->type;
1178 PluginInsert::PluginControl::PluginControl (PluginInsert* p, const Evoral::Parameter ¶m, boost::shared_ptr<AutomationList> list)
1179 : AutomationControl (p->session(), param, list, p->describe_parameter(param))
1182 Plugin::ParameterDescriptor desc;
1183 boost::shared_ptr<Plugin> plugin = p->plugin (0);
1185 alist()->reset_default (plugin->default_value (param.id()));
1187 plugin->get_parameter_descriptor (param.id(), desc);
1188 _logarithmic = desc.logarithmic;
1189 _sr_dependent = desc.sr_dependent;
1190 _toggled = desc.toggled;
1193 /** @param val `user' value */
1195 PluginInsert::PluginControl::set_value (double user_val)
1197 /* FIXME: probably should be taking out some lock here.. */
1199 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1200 (*i)->set_parameter (_list->parameter().id(), user_val);
1203 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1205 iasp->set_parameter (_list->parameter().id(), user_val);
1208 AutomationControl::set_value (user_val);
1212 PluginInsert::PluginControl::internal_to_interface (double val) const
1226 PluginInsert::PluginControl::interface_to_internal (double val) const
1236 PluginInsert::PluginControl::get_state ()
1240 XMLNode& node (AutomationControl::get_state());
1241 ss << parameter().id();
1242 node.add_property (X_("parameter"), ss.str());
1247 /** @return `user' val */
1249 PluginInsert::PluginControl::get_value () const
1251 /* FIXME: probably should be taking out some lock here.. */
1252 return _plugin->get_parameter (_list->parameter());
1255 boost::shared_ptr<Plugin>
1256 PluginInsert::get_impulse_analysis_plugin()
1258 boost::shared_ptr<Plugin> ret;
1259 if (_impulseAnalysisPlugin.expired()) {
1260 ret = plugin_factory(_plugins[0]);
1261 _impulseAnalysisPlugin = ret;
1263 ret = _impulseAnalysisPlugin.lock();
1270 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1272 // called from outside the audio thread, so this should be safe
1273 // only do audio as analysis is (currently) only for audio plugins
1274 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1275 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1277 _signal_analysis_collected_nframes = 0;
1278 _signal_analysis_collect_nframes_max = nframes;
1281 /** Add a plugin to our list */
1283 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1285 plugin->set_insert_info (this);
1287 if (_plugins.empty()) {
1288 /* first (and probably only) plugin instance - connect to relevant signals
1291 plugin->ParameterChanged.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed, this, _1, _2));
1292 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1293 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1296 _plugins.push_back (plugin);
1300 PluginInsert::realtime_handle_transport_stopped ()
1302 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1303 (*i)->realtime_handle_transport_stopped ();
1308 PluginInsert::realtime_locate ()
1310 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1311 (*i)->realtime_locate ();
1316 PluginInsert::monitoring_changed ()
1318 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1319 (*i)->monitoring_changed ();
1324 PluginInsert::start_touch (uint32_t param_id)
1326 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1328 ac->start_touch (session().audible_frame());
1333 PluginInsert::end_touch (uint32_t param_id)
1335 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1337 ac->stop_touch (true, session().audible_frame());