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 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
244 if (i->type() == PluginAutomation) {
246 Evoral::Parameter param(*i);
248 ParameterDescriptor desc;
249 _plugins.front()->get_parameter_descriptor(i->id(), desc);
251 can_automate (param);
252 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
253 add_control (boost::shared_ptr<AutomationControl> (new PluginControl(this, param, desc, list)));
254 } else if (i->type() == PluginPropertyAutomation) {
255 Evoral::Parameter param(*i);
256 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
257 if (desc.datatype != Variant::NOTHING) {
258 boost::shared_ptr<AutomationList> list;
259 if (Variant::type_is_numeric(desc.datatype)) {
260 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
262 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
267 /** Called when something outside of this host has modified a plugin
268 * parameter. Responsible for propagating the change to two places:
270 * 1) anything listening to the Control itself
271 * 2) any replicated plugins that make up this PluginInsert.
273 * The PluginInsert is connected to the ParameterChangedExternally signal for
274 * the first (primary) plugin, and here broadcasts that change to any others.
276 * XXX We should probably drop this whole replication idea (Paul, October 2015)
277 * since it isn't used by sensible plugin APIs (AU, LV2).
280 PluginInsert::parameter_changed_externally (uint32_t which, float val)
282 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
284 /* First propagation: alter the underlying value of the control,
285 * without telling the plugin(s) that own/use it to set it.
292 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
295 pc->catch_up_with_external_value (val);
298 /* Second propagation: tell all plugins except the first to
299 update the value of this parameter. For sane plugin APIs,
300 there are no other plugins, so this is a no-op in those
304 Plugins::iterator i = _plugins.begin();
306 /* don't set the first plugin, just all the slaves */
308 if (i != _plugins.end()) {
310 for (; i != _plugins.end(); ++i) {
311 (*i)->set_parameter (which, val);
317 PluginInsert::set_block_size (pframes_t nframes)
320 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
321 if ((*i)->set_block_size (nframes) != 0) {
329 PluginInsert::activate ()
331 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
335 Processor::activate ();
339 PluginInsert::deactivate ()
341 Processor::deactivate ();
343 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
349 PluginInsert::flush ()
351 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
357 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
359 // Calculate if, and how many frames we need to collect for analysis
360 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
361 _signal_analysis_collected_nframes);
362 if (nframes < collect_signal_nframes) { // we might not get all frames now
363 collect_signal_nframes = nframes;
366 ChanCount const in_streams = input_streams ();
367 ChanCount const out_streams = output_streams ();
369 ChanMapping in_map (in_streams);
370 ChanMapping out_map (out_streams);
372 if (_match.method == Split) {
373 /* fix the input mapping so that we have maps for each of the plugin's inputs */
374 in_map = ChanMapping (natural_input_streams ());
376 /* copy the first stream's buffer contents to the others */
377 /* XXX: audio only */
378 uint32_t first_idx = in_map.get (DataType::AUDIO, 0, &valid);
380 for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
381 bufs.get_audio(in_map.get (DataType::AUDIO, i, &valid)).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
386 bufs.set_count(ChanCount::max(bufs.count(), in_streams));
387 bufs.set_count(ChanCount::max(bufs.count(), out_streams));
389 /* Note that we've already required that plugins
390 be able to handle in-place processing.
397 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
399 boost::shared_ptr<AutomationControl> c
400 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
402 if (c->list() && c->automation_playback()) {
405 const float val = c->list()->rt_safe_eval (now, valid);
408 /* This is the ONLY place where we are
410 * AutomationControl::set_value_unchecked(). We
411 * know that the control is in
412 * automation playback mode, so no
413 * check on writable() is required
414 * (which must be done in AutomationControl::set_value()
417 c->set_value_unchecked(val);
424 if (collect_signal_nframes > 0) {
426 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
427 //std::cerr << " streams " << input_streams().n_audio() << std::endl;
428 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
430 _signal_analysis_inputs.set_count(input_streams());
432 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
433 _signal_analysis_inputs.get_audio(i).read_from(
435 collect_signal_nframes,
436 _signal_analysis_collected_nframes); // offset is for target buffer
441 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
442 (*i)->connect_and_run(bufs, in_map, out_map, nframes, offset);
443 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
444 in_map.offset_to(*t, natural_input_streams().get(*t));
445 out_map.offset_to(*t, natural_output_streams().get(*t));
449 if (collect_signal_nframes > 0) {
451 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
452 //std::cerr << " streams " << output_streams().n_audio() << std::endl;
454 _signal_analysis_outputs.set_count(output_streams());
456 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
457 _signal_analysis_outputs.get_audio(i).read_from(
459 collect_signal_nframes,
460 _signal_analysis_collected_nframes); // offset is for target buffer
463 _signal_analysis_collected_nframes += collect_signal_nframes;
464 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
466 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
467 _signal_analysis_collect_nframes_max = 0;
468 _signal_analysis_collected_nframes = 0;
470 AnalysisDataGathered(&_signal_analysis_inputs,
471 &_signal_analysis_outputs);
474 /* leave remaining channel buffers alone */
478 PluginInsert::silence (framecnt_t nframes)
484 ChanMapping in_map(input_streams());
485 ChanMapping out_map(output_streams());
487 if (_match.method == Split) {
488 /* fix the input mapping so that we have maps for each of the plugin's inputs */
489 in_map = ChanMapping (natural_input_streams ());
492 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
493 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
498 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t /*end_frame*/, pframes_t nframes, bool)
500 if (_pending_active) {
501 /* run as normal if we are active or moving from inactive to active */
503 if (_session.transport_rolling() || _session.bounce_processing()) {
504 automation_run (bufs, start_frame, nframes);
506 connect_and_run (bufs, nframes, 0, false);
510 uint32_t in = input_streams ().n_audio ();
511 uint32_t out = output_streams().n_audio ();
513 if (has_no_audio_inputs() || in == 0) {
515 /* silence all (audio) outputs. Should really declick
516 * at the transitions of "active"
519 for (uint32_t n = 0; n < out; ++n) {
520 bufs.get_audio (n).silence (nframes);
523 } else if (out > in) {
525 /* not active, but something has make up for any channel count increase */
527 // TODO: option round-robin (n % in) or silence additional buffers ??
528 // for now , simply replicate last buffer
529 for (uint32_t n = in; n < out; ++n) {
530 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
534 bufs.count().set_audio (out);
537 _active = _pending_active;
539 /* we have no idea whether the plugin generated silence or not, so mark
540 * all buffers appropriately.
546 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
548 Evoral::ControlEvent next_event (0, 0.0f);
549 framepos_t now = start;
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")
599 abort(); /*NOTREACHED*/
602 return _plugins[0]->default_value (param.id());
607 PluginInsert::can_reset_all_parameters ()
611 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
613 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
615 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
619 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
625 if (ac->automation_state() & Play) {
630 return all && (params > 0);
634 PluginInsert::reset_parameters_to_default ()
638 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
640 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
642 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
646 const float dflt = _plugins[0]->default_value (cid);
647 const float curr = _plugins[0]->get_parameter (cid);
653 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
658 if (ac->automation_state() & Play) {
663 ac->set_value (dflt);
668 boost::shared_ptr<Plugin>
669 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
671 boost::shared_ptr<LadspaPlugin> lp;
673 boost::shared_ptr<LV2Plugin> lv2p;
675 #ifdef WINDOWS_VST_SUPPORT
676 boost::shared_ptr<WindowsVSTPlugin> vp;
679 boost::shared_ptr<LXVSTPlugin> lxvp;
681 #ifdef AUDIOUNIT_SUPPORT
682 boost::shared_ptr<AUPlugin> ap;
685 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
686 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
688 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
689 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
691 #ifdef WINDOWS_VST_SUPPORT
692 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
693 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
696 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
697 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
699 #ifdef AUDIOUNIT_SUPPORT
700 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
701 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
705 fatal << string_compose (_("programming error: %1"),
706 X_("unknown plugin type in PluginInsert::plugin_factory"))
708 abort(); /*NOTREACHED*/
709 return boost::shared_ptr<Plugin> ((Plugin*) 0);
713 PluginInsert::configure_io (ChanCount in, ChanCount out)
715 Match old_match = _match;
716 ChanCount old_in = input_streams ();
717 ChanCount old_out = output_streams ();
720 _configured_out = out;
722 /* set the matching method and number of plugins that we will use to meet this configuration */
723 _match = private_can_support_io_configuration (in, out);
724 if (set_count (_match.plugins) == false) {
725 PluginIoReConfigure (); /* EMIT SIGNAL */
729 /* configure plugins */
730 switch (_match.method) {
733 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out) == false) {
734 PluginIoReConfigure (); /* EMIT SIGNAL */
740 if (_plugins.front()->configure_io (in, out) == false) {
741 PluginIoReConfigure (); /* EMIT SIGNAL */
747 if ( (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
752 PluginIoReConfigure (); /* EMIT SIGNAL */
755 // we don't know the analysis window size, so we must work with the
756 // current buffer size here. each request for data fills in these
757 // buffers and the analyser makes sure it gets enough data for the
759 session().ensure_buffer_set (_signal_analysis_inputs, in);
760 //_signal_analysis_inputs.set_count (in);
762 session().ensure_buffer_set (_signal_analysis_outputs, out);
763 //_signal_analysis_outputs.set_count (out);
765 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
767 return Processor::configure_io (in, out);
770 /** Decide whether this PluginInsert can support a given IO configuration.
771 * To do this, we run through a set of possible solutions in rough order of
774 * @param in Required input channel count.
775 * @param out Filled in with the output channel count if we return true.
776 * @return true if the given IO configuration can be supported.
779 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
781 return private_can_support_io_configuration (in, out).method != Impossible;
784 /** A private version of can_support_io_configuration which returns the method
785 * by which the configuration can be matched, rather than just whether or not
789 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
791 if (_plugins.empty()) {
795 PluginInfoPtr info = _plugins.front()->get_info();
796 ChanCount in; in += inx;
799 if (info->reconfigurable_io()) {
800 /* Plugin has flexible I/O, so delegate to it */
801 bool const r = _plugins.front()->can_support_io_configuration (in, out);
803 return Match (Impossible, 0);
806 return Match (Delegate, 1);
809 ChanCount inputs = info->n_inputs;
810 ChanCount outputs = info->n_outputs;
812 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
813 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
814 midi_bypass.set(DataType::MIDI, 1);
816 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
817 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
818 in.set(DataType::MIDI, 0);
821 bool no_inputs = true;
822 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
823 if (inputs.get (*t) != 0) {
830 /* no inputs so we can take any input configuration since we throw it away */
831 out = outputs + midi_bypass;
832 return Match (NoInputs, 1);
835 /* Plugin inputs match requested inputs exactly */
837 out = outputs + midi_bypass;
838 return Match (ExactMatch, 1);
841 /* We may be able to run more than one copy of the plugin within this insert
842 to cope with the insert having more inputs than the plugin.
843 We allow replication only for plugins with either zero or 1 inputs and outputs
844 for every valid data type.
848 bool can_replicate = true;
849 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
851 uint32_t nin = inputs.get (*t);
853 // No inputs of this type
854 if (nin == 0 && in.get(*t) == 0) {
858 if (nin != 1 || outputs.get (*t) != 1) {
859 can_replicate = false;
863 // Potential factor not set yet
865 f = in.get(*t) / nin;
868 // Factor for this type does not match another type, can not replicate
869 if (f != (in.get(*t) / nin)) {
870 can_replicate = false;
876 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
877 out.set (*t, outputs.get(*t) * f);
880 return Match (Replicate, f);
883 /* If the processor has exactly one input of a given type, and
884 the plugin has more, we can feed the single processor input
885 to some or all of the plugin inputs. This is rather
886 special-case-y, but the 1-to-many case is by far the
887 simplest. How do I split thy 2 processor inputs to 3
888 plugin inputs? Let me count the ways ...
891 bool can_split = true;
892 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
894 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
895 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
897 if (!can_split_type && !nothing_to_do_for_type) {
903 out = outputs + midi_bypass;
904 return Match (Split, 1);
907 /* If the plugin has more inputs than we want, we can `hide' some of them
908 by feeding them silence.
911 bool could_hide = false;
912 bool cannot_hide = false;
913 ChanCount hide_channels;
915 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
916 if (inputs.get(*t) > in.get(*t)) {
917 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
918 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
920 } else if (inputs.get(*t) < in.get(*t)) {
921 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
926 if (could_hide && !cannot_hide) {
927 out = outputs + midi_bypass;
928 return Match (Hide, 1, hide_channels);
932 return Match (Impossible, 0);
936 PluginInsert::get_state ()
942 PluginInsert::state (bool full)
944 XMLNode& node = Processor::state (full);
946 node.add_property("type", _plugins[0]->state_node_name());
947 node.add_property("unique-id", _plugins[0]->unique_id());
948 node.add_property("count", string_compose("%1", _plugins.size()));
950 /* remember actual i/o configuration (for later placeholder
951 * in case the plugin goes missing) */
952 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
953 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
955 _plugins[0]->set_insert_id(this->id());
956 node.add_child_nocopy (_plugins[0]->get_state());
958 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
959 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
961 node.add_child_nocopy (ac->get_state());
969 PluginInsert::set_control_ids (const XMLNode& node, int version)
971 const XMLNodeList& nlist = node.children();
972 XMLNodeConstIterator iter;
973 set<Evoral::Parameter>::const_iterator p;
975 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
976 if ((*iter)->name() == Controllable::xml_node_name) {
977 const XMLProperty* prop;
979 if ((prop = (*iter)->property (X_("parameter"))) != 0) {
980 uint32_t p = atoi (prop->value());
982 /* this may create the new controllable */
984 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
986 #ifndef NO_PLUGIN_STATE
990 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
992 ac->set_state (**iter, version);
1001 PluginInsert::set_state(const XMLNode& node, int version)
1003 XMLNodeList nlist = node.children();
1004 XMLNodeIterator niter;
1005 XMLPropertyList plist;
1006 const XMLProperty *prop;
1007 ARDOUR::PluginType type;
1009 if ((prop = node.property ("type")) == 0) {
1010 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1014 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1015 type = ARDOUR::LADSPA;
1016 } else if (prop->value() == X_("lv2")) {
1018 } else if (prop->value() == X_("windows-vst")) {
1019 type = ARDOUR::Windows_VST;
1020 } else if (prop->value() == X_("lxvst")) {
1021 type = ARDOUR::LXVST;
1022 } else if (prop->value() == X_("audiounit")) {
1023 type = ARDOUR::AudioUnit;
1025 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1031 prop = node.property ("unique-id");
1034 #ifdef WINDOWS_VST_SUPPORT
1035 /* older sessions contain VST plugins with only an "id" field.
1038 if (type == ARDOUR::Windows_VST) {
1039 prop = node.property ("id");
1043 #ifdef LXVST_SUPPORT
1044 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1046 if (type == ARDOUR::LXVST) {
1047 prop = node.property ("id");
1053 error << _("Plugin has no unique ID field") << endmsg;
1058 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1060 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1061 * allow to move sessions windows <> linux */
1062 #ifdef LXVST_SUPPORT
1063 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1064 type = ARDOUR::LXVST;
1065 plugin = find_plugin (_session, prop->value(), type);
1069 #ifdef WINDOWS_VST_SUPPORT
1070 if (plugin == 0 && type == ARDOUR::LXVST) {
1071 type = ARDOUR::Windows_VST;
1072 plugin = find_plugin (_session, prop->value(), type);
1077 error << string_compose(
1078 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1079 "Perhaps it was removed or moved since it was last used."),
1085 // The name of the PluginInsert comes from the plugin, nothing else
1086 _name = plugin->get_info()->name;
1090 // Processor::set_state() will set this, but too late
1091 // for it to be available when setting up plugin
1092 // state. We can't call Processor::set_state() until
1093 // the plugins themselves are created and added.
1097 if (_plugins.empty()) {
1098 /* if we are adding the first plugin, we will need to set
1099 up automatable controls.
1101 add_plugin (plugin);
1102 create_automatable_parameters ();
1103 set_control_ids (node, version);
1106 if ((prop = node.property ("count")) != 0) {
1107 sscanf (prop->value().c_str(), "%u", &count);
1110 if (_plugins.size() != count) {
1111 for (uint32_t n = 1; n < count; ++n) {
1112 add_plugin (plugin_factory (plugin));
1116 Processor::set_state (node, version);
1118 PBD::ID new_id = this->id();
1119 PBD::ID old_id = this->id();
1121 if ((prop = node.property ("id")) != 0) {
1122 old_id = prop->value ();
1125 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1127 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1128 and set all plugins to the same state.
1131 if ((*niter)->name() == plugin->state_node_name()) {
1133 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1134 /* Plugin state can include external files which are named after the ID.
1136 * If regenerate_xml_or_string_ids() is set, the ID will already have
1137 * been changed, so we need to use the old ID from the XML to load the
1138 * state and then update the ID.
1140 * When copying a plugin-state, route_ui takes care of of updating the ID,
1141 * but we need to call set_insert_id() to clear the cached plugin-state
1142 * and force a change.
1144 if (!regenerate_xml_or_string_ids ()) {
1145 (*i)->set_insert_id (new_id);
1147 (*i)->set_insert_id (old_id);
1150 (*i)->set_state (**niter, version);
1152 if (regenerate_xml_or_string_ids ()) {
1153 (*i)->set_insert_id (new_id);
1161 if (version < 3000) {
1163 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1164 this is all handled by Automatable
1167 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1168 if ((*niter)->name() == "Redirect") {
1169 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1170 Processor::set_state (**niter, version);
1175 set_parameter_state_2X (node, version);
1178 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1182 (*i)->deactivate ();
1190 PluginInsert::update_id (PBD::ID id)
1193 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1194 (*i)->set_insert_id (id);
1199 PluginInsert::set_state_dir (const std::string& d)
1201 // state() only saves the state of the first plugin
1202 _plugins[0]->set_state_dir (d);
1206 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1208 XMLNodeList nlist = node.children();
1209 XMLNodeIterator niter;
1211 /* look for port automation node */
1213 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1215 if ((*niter)->name() != port_automation_node_name) {
1221 XMLNodeConstIterator iter;
1226 cnodes = (*niter)->children ("port");
1228 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1232 if ((cprop = child->property("number")) != 0) {
1233 port = cprop->value().c_str();
1235 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1239 sscanf (port, "%" PRIu32, &port_id);
1241 if (port_id >= _plugins[0]->parameter_count()) {
1242 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1246 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1247 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1249 if (c && c->alist()) {
1250 if (!child->children().empty()) {
1251 c->alist()->set_state (*child->children().front(), version);
1253 /* In some cases 2.X saves lists with min_yval and max_yval
1254 being FLT_MIN and FLT_MAX respectively. This causes problems
1255 in A3 because these min/max values are used to compute
1256 where GUI control points should be drawn. If we see such
1257 values, `correct' them to the min/max of the appropriate
1261 float min_y = c->alist()->get_min_y ();
1262 float max_y = c->alist()->get_max_y ();
1264 ParameterDescriptor desc;
1265 _plugins.front()->get_parameter_descriptor (port_id, desc);
1267 if (min_y == FLT_MIN) {
1271 if (max_y == FLT_MAX) {
1275 c->alist()->set_yrange (min_y, max_y);
1278 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1290 PluginInsert::describe_parameter (Evoral::Parameter param)
1292 if (param.type() == PluginAutomation) {
1293 return _plugins[0]->describe_parameter (param);
1294 } else if (param.type() == PluginPropertyAutomation) {
1295 boost::shared_ptr<AutomationControl> c(automation_control(param));
1296 if (c && !c->desc().label.empty()) {
1297 return c->desc().label;
1300 return Automatable::describe_parameter(param);
1304 PluginInsert::signal_latency() const
1306 if (_user_latency) {
1307 return _user_latency;
1310 return _plugins[0]->signal_latency ();
1314 PluginInsert::type ()
1316 return plugin()->get_info()->type;
1319 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1320 const Evoral::Parameter& param,
1321 const ParameterDescriptor& desc,
1322 boost::shared_ptr<AutomationList> list)
1323 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1327 alist()->reset_default (desc.normal);
1329 list->set_interpolation(Evoral::ControlList::Discrete);
1334 set_flags(Controllable::Toggle);
1338 /** @param val `user' value */
1340 PluginInsert::PluginControl::set_value (double user_val)
1343 set_value_unchecked (user_val);
1348 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1350 /* FIXME: probably should be taking out some lock here.. */
1352 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1353 (*i)->set_parameter (_list->parameter().id(), user_val);
1356 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1358 iasp->set_parameter (_list->parameter().id(), user_val);
1361 AutomationControl::set_value (user_val);
1365 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1367 AutomationControl::set_value (user_val);
1371 PluginInsert::PluginControl::get_state ()
1375 XMLNode& node (AutomationControl::get_state());
1376 ss << parameter().id();
1377 node.add_property (X_("parameter"), ss.str());
1382 /** @return `user' val */
1384 PluginInsert::PluginControl::get_value () const
1386 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1392 return plugin->get_parameter (_list->parameter().id());
1395 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
1396 const Evoral::Parameter& param,
1397 const ParameterDescriptor& desc,
1398 boost::shared_ptr<AutomationList> list)
1399 : AutomationControl (p->session(), param, desc, list)
1403 alist()->set_yrange (desc.lower, desc.upper);
1404 alist()->reset_default (desc.normal);
1408 set_flags(Controllable::Toggle);
1413 PluginInsert::PluginPropertyControl::set_value (double user_val)
1416 set_value_unchecked (user_val);
1421 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1423 /* Old numeric set_value(), coerce to appropriate datatype if possible.
1424 This is lossy, but better than nothing until Ardour's automation system
1425 can handle various datatypes all the way down. */
1426 const Variant value(_desc.datatype, user_val);
1427 if (value.type() == Variant::NOTHING) {
1428 error << "set_value(double) called for non-numeric property" << endmsg;
1432 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1433 (*i)->set_property(_list->parameter().id(), value);
1437 AutomationControl::set_value(user_val);
1441 PluginInsert::PluginPropertyControl::get_state ()
1445 XMLNode& node (AutomationControl::get_state());
1446 ss << parameter().id();
1447 node.add_property (X_("property"), ss.str());
1448 node.remove_property (X_("value"));
1454 PluginInsert::PluginPropertyControl::get_value () const
1456 return _value.to_double();
1459 boost::shared_ptr<Plugin>
1460 PluginInsert::get_impulse_analysis_plugin()
1462 boost::shared_ptr<Plugin> ret;
1463 if (_impulseAnalysisPlugin.expired()) {
1464 ret = plugin_factory(_plugins[0]);
1465 ret->configure_io (input_streams (), output_streams ());
1466 _impulseAnalysisPlugin = ret;
1468 ret = _impulseAnalysisPlugin.lock();
1475 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1477 // called from outside the audio thread, so this should be safe
1478 // only do audio as analysis is (currently) only for audio plugins
1479 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1480 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1482 _signal_analysis_collected_nframes = 0;
1483 _signal_analysis_collect_nframes_max = nframes;
1486 /** Add a plugin to our list */
1488 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1490 plugin->set_insert_id (this->id());
1492 if (_plugins.empty()) {
1493 /* first (and probably only) plugin instance - connect to relevant signals
1496 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
1497 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1498 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1501 _plugins.push_back (plugin);
1505 PluginInsert::realtime_handle_transport_stopped ()
1507 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1508 (*i)->realtime_handle_transport_stopped ();
1513 PluginInsert::realtime_locate ()
1515 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1516 (*i)->realtime_locate ();
1521 PluginInsert::monitoring_changed ()
1523 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1524 (*i)->monitoring_changed ();
1529 PluginInsert::start_touch (uint32_t param_id)
1531 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1533 ac->start_touch (session().audible_frame());
1538 PluginInsert::end_touch (uint32_t param_id)
1540 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1542 ac->stop_touch (true, session().audible_frame());