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 if (_plugins.empty()) {
726 PluginInfoPtr info = _plugins.front()->get_info();
727 ChanCount in; in += inx;
730 if (info->reconfigurable_io()) {
731 /* Plugin has flexible I/O, so delegate to it */
732 bool const r = _plugins.front()->can_support_io_configuration (in, out);
734 return Match (Impossible, 0);
737 return Match (Delegate, 1);
740 ChanCount inputs = info->n_inputs;
741 ChanCount outputs = info->n_outputs;
743 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
744 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
745 midi_bypass.set(DataType::MIDI, 1);
747 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
748 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
749 in.set(DataType::MIDI, 0);
752 bool no_inputs = true;
753 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
754 if (inputs.get (*t) != 0) {
761 /* no inputs so we can take any input configuration since we throw it away */
762 out = outputs + midi_bypass;
763 return Match (NoInputs, 1);
766 /* Plugin inputs match requested inputs exactly */
768 out = outputs + midi_bypass;
769 return Match (ExactMatch, 1);
772 /* We may be able to run more than one copy of the plugin within this insert
773 to cope with the insert having more inputs than the plugin.
774 We allow replication only for plugins with either zero or 1 inputs and outputs
775 for every valid data type.
779 bool can_replicate = true;
780 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
782 uint32_t nin = inputs.get (*t);
784 // No inputs of this type
785 if (nin == 0 && in.get(*t) == 0) {
789 if (nin != 1 || outputs.get (*t) != 1) {
790 can_replicate = false;
794 // Potential factor not set yet
796 f = in.get(*t) / nin;
799 // Factor for this type does not match another type, can not replicate
800 if (f != (in.get(*t) / nin)) {
801 can_replicate = false;
807 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
808 out.set (*t, outputs.get(*t) * f);
811 return Match (Replicate, f);
814 /* If the processor has exactly one input of a given type, and
815 the plugin has more, we can feed the single processor input
816 to some or all of the plugin inputs. This is rather
817 special-case-y, but the 1-to-many case is by far the
818 simplest. How do I split thy 2 processor inputs to 3
819 plugin inputs? Let me count the ways ...
822 bool can_split = true;
823 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
825 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
826 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
828 if (!can_split_type && !nothing_to_do_for_type) {
834 out = outputs + midi_bypass;
835 return Match (Split, 1);
838 /* If the plugin has more inputs than we want, we can `hide' some of them
839 by feeding them silence.
842 bool could_hide = false;
843 bool cannot_hide = false;
844 ChanCount hide_channels;
846 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
847 if (inputs.get(*t) > in.get(*t)) {
848 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
849 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
851 } else if (inputs.get(*t) < in.get(*t)) {
852 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
857 if (could_hide && !cannot_hide) {
858 out = outputs + midi_bypass;
859 return Match (Hide, 1, hide_channels);
863 return Match (Impossible, 0);
867 PluginInsert::get_state ()
873 PluginInsert::state (bool full)
875 XMLNode& node = Processor::state (full);
877 node.add_property("type", _plugins[0]->state_node_name());
878 node.add_property("unique-id", _plugins[0]->unique_id());
879 node.add_property("count", string_compose("%1", _plugins.size()));
880 node.add_child_nocopy (_plugins[0]->get_state());
882 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
883 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
885 node.add_child_nocopy (ac->get_state());
893 PluginInsert::set_control_ids (const XMLNode& node, int version)
895 const XMLNodeList& nlist = node.children();
896 XMLNodeConstIterator iter;
897 set<Evoral::Parameter>::const_iterator p;
899 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
900 if ((*iter)->name() == Controllable::xml_node_name) {
901 const XMLProperty* prop;
903 if ((prop = (*iter)->property (X_("parameter"))) != 0) {
904 uint32_t p = atoi (prop->value());
906 /* this may create the new controllable */
908 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
910 #ifndef NO_PLUGIN_STATE
914 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
916 ac->set_state (**iter, version);
925 PluginInsert::set_state(const XMLNode& node, int version)
927 XMLNodeList nlist = node.children();
928 XMLNodeIterator niter;
929 XMLPropertyList plist;
930 const XMLProperty *prop;
931 ARDOUR::PluginType type;
933 if ((prop = node.property ("type")) == 0) {
934 error << _("XML node describing plugin is missing the `type' field") << endmsg;
938 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
939 type = ARDOUR::LADSPA;
940 } else if (prop->value() == X_("lv2")) {
942 } else if (prop->value() == X_("windows-vst")) {
943 type = ARDOUR::Windows_VST;
944 } else if (prop->value() == X_("lxvst")) {
945 type = ARDOUR::LXVST;
946 } else if (prop->value() == X_("audiounit")) {
947 type = ARDOUR::AudioUnit;
949 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
955 prop = node.property ("unique-id");
958 #ifdef WINDOWS_VST_SUPPORT
959 /* older sessions contain VST plugins with only an "id" field.
962 if (type == ARDOUR::Windows_VST) {
963 prop = node.property ("id");
968 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
970 if (type == ARDOUR::LXVST) {
971 prop = node.property ("id");
977 error << _("Plugin has no unique ID field") << endmsg;
982 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
985 error << string_compose(
986 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
987 "Perhaps it was removed or moved since it was last used."),
993 // The name of the PluginInsert comes from the plugin, nothing else
994 _name = plugin->get_info()->name;
998 // Processor::set_state() will set this, but too late
999 // for it to be available when setting up plugin
1000 // state. We can't call Processor::set_state() until
1001 // the plugins themselves are created and added.
1005 if (_plugins.empty()) {
1006 /* if we are adding the first plugin, we will need to set
1007 up automatable controls.
1009 add_plugin (plugin);
1010 create_automatable_parameters ();
1011 set_control_ids (node, version);
1014 if ((prop = node.property ("count")) != 0) {
1015 sscanf (prop->value().c_str(), "%u", &count);
1018 if (_plugins.size() != count) {
1019 for (uint32_t n = 1; n < count; ++n) {
1020 add_plugin (plugin_factory (plugin));
1024 Processor::set_state (node, version);
1026 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1028 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1029 and set all plugins to the same state.
1032 if ((*niter)->name() == plugin->state_node_name()) {
1034 plugin->set_state (**niter, version);
1036 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1037 (*i)->set_state (**niter, version);
1044 if (version < 3000) {
1046 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1047 this is all handled by Automatable
1050 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1051 if ((*niter)->name() == "Redirect") {
1052 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1053 Processor::set_state (**niter, version);
1058 set_parameter_state_2X (node, version);
1061 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1065 (*i)->deactivate ();
1073 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1075 XMLNodeList nlist = node.children();
1076 XMLNodeIterator niter;
1078 /* look for port automation node */
1080 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1082 if ((*niter)->name() != port_automation_node_name) {
1088 XMLNodeConstIterator iter;
1093 cnodes = (*niter)->children ("port");
1095 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1099 if ((cprop = child->property("number")) != 0) {
1100 port = cprop->value().c_str();
1102 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1106 sscanf (port, "%" PRIu32, &port_id);
1108 if (port_id >= _plugins[0]->parameter_count()) {
1109 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1113 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1114 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1117 if (!child->children().empty()) {
1118 c->alist()->set_state (*child->children().front(), version);
1120 /* In some cases 2.X saves lists with min_yval and max_yval
1121 being FLT_MIN and FLT_MAX respectively. This causes problems
1122 in A3 because these min/max values are used to compute
1123 where GUI control points should be drawn. If we see such
1124 values, `correct' them to the min/max of the appropriate
1128 float min_y = c->alist()->get_min_y ();
1129 float max_y = c->alist()->get_max_y ();
1131 Plugin::ParameterDescriptor desc;
1132 _plugins.front()->get_parameter_descriptor (port_id, desc);
1134 if (min_y == FLT_MIN) {
1138 if (max_y == FLT_MAX) {
1142 c->alist()->set_yrange (min_y, max_y);
1145 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1157 PluginInsert::describe_parameter (Evoral::Parameter param)
1159 if (param.type() != PluginAutomation) {
1160 return Automatable::describe_parameter(param);
1163 return _plugins[0]->describe_parameter (param);
1167 PluginInsert::signal_latency() const
1169 if (_user_latency) {
1170 return _user_latency;
1173 return _plugins[0]->signal_latency ();
1177 PluginInsert::type ()
1179 return plugin()->get_info()->type;
1182 PluginInsert::PluginControl::PluginControl (PluginInsert* p, const Evoral::Parameter ¶m, boost::shared_ptr<AutomationList> list)
1183 : AutomationControl (p->session(), param, list, p->describe_parameter(param))
1186 Plugin::ParameterDescriptor desc;
1187 boost::shared_ptr<Plugin> plugin = p->plugin (0);
1189 alist()->reset_default (plugin->default_value (param.id()));
1191 plugin->get_parameter_descriptor (param.id(), desc);
1192 _logarithmic = desc.logarithmic;
1193 _sr_dependent = desc.sr_dependent;
1194 _toggled = desc.toggled;
1197 /** @param val `user' value */
1199 PluginInsert::PluginControl::set_value (double user_val)
1201 /* FIXME: probably should be taking out some lock here.. */
1203 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1204 (*i)->set_parameter (_list->parameter().id(), user_val);
1207 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1209 iasp->set_parameter (_list->parameter().id(), user_val);
1212 AutomationControl::set_value (user_val);
1216 PluginInsert::PluginControl::internal_to_interface (double val) const
1219 /* some plugins have a log-scale range "0.."
1220 * ideally we'd map the range down to infinity somehow :)
1222 * one solution could be to use
1223 * val = exp(lower + log(range) * value);
1224 * (log(val) - lower) / range)
1225 * This approach would require access to the actual range (ie
1226 * Plugin::ParameterDescriptor) and also require handling
1227 * of unbound ranges..
1229 * currently an arbitrarly low number is assumed to represnt
1230 * log(0) as hot-fix solution.
1235 val = -8; // ~ -70dB = 20 * log10(exp(-8))
1243 PluginInsert::PluginControl::interface_to_internal (double val) const
1247 /* see note in PluginInsert::PluginControl::internal_to_interface() */
1258 PluginInsert::PluginControl::get_state ()
1262 XMLNode& node (AutomationControl::get_state());
1263 ss << parameter().id();
1264 node.add_property (X_("parameter"), ss.str());
1269 /** @return `user' val */
1271 PluginInsert::PluginControl::get_value () const
1273 /* FIXME: probably should be taking out some lock here.. */
1274 return _plugin->get_parameter (_list->parameter());
1277 boost::shared_ptr<Plugin>
1278 PluginInsert::get_impulse_analysis_plugin()
1280 boost::shared_ptr<Plugin> ret;
1281 if (_impulseAnalysisPlugin.expired()) {
1282 ret = plugin_factory(_plugins[0]);
1283 _impulseAnalysisPlugin = ret;
1285 ret = _impulseAnalysisPlugin.lock();
1292 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1294 // called from outside the audio thread, so this should be safe
1295 // only do audio as analysis is (currently) only for audio plugins
1296 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1297 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1299 _signal_analysis_collected_nframes = 0;
1300 _signal_analysis_collect_nframes_max = nframes;
1303 /** Add a plugin to our list */
1305 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1307 plugin->set_insert_info (this);
1309 if (_plugins.empty()) {
1310 /* first (and probably only) plugin instance - connect to relevant signals
1313 plugin->ParameterChanged.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed, this, _1, _2));
1314 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1315 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1318 _plugins.push_back (plugin);
1322 PluginInsert::realtime_handle_transport_stopped ()
1324 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1325 (*i)->realtime_handle_transport_stopped ();
1330 PluginInsert::realtime_locate ()
1332 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1333 (*i)->realtime_locate ();
1338 PluginInsert::monitoring_changed ()
1340 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1341 (*i)->monitoring_changed ();
1346 PluginInsert::start_touch (uint32_t param_id)
1348 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1350 ac->start_touch (session().audible_frame());
1355 PluginInsert::end_touch (uint32_t param_id)
1357 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1359 ac->stop_touch (true, session().audible_frame());