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, Controllable::NoGroup);
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 uint32_t p = (uint32_t)-1;
981 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
982 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
984 p = lv2plugin->port_index(prop->value().c_str());
988 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
989 p = atoi (prop->value());
992 if (p != (uint32_t)-1) {
994 /* this may create the new controllable */
996 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
998 #ifndef NO_PLUGIN_STATE
1002 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1004 ac->set_state (**iter, version);
1013 PluginInsert::set_state(const XMLNode& node, int version)
1015 XMLNodeList nlist = node.children();
1016 XMLNodeIterator niter;
1017 XMLPropertyList plist;
1018 const XMLProperty *prop;
1019 ARDOUR::PluginType type;
1021 if ((prop = node.property ("type")) == 0) {
1022 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1026 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1027 type = ARDOUR::LADSPA;
1028 } else if (prop->value() == X_("lv2")) {
1030 } else if (prop->value() == X_("windows-vst")) {
1031 type = ARDOUR::Windows_VST;
1032 } else if (prop->value() == X_("lxvst")) {
1033 type = ARDOUR::LXVST;
1034 } else if (prop->value() == X_("audiounit")) {
1035 type = ARDOUR::AudioUnit;
1037 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1043 prop = node.property ("unique-id");
1046 #ifdef WINDOWS_VST_SUPPORT
1047 /* older sessions contain VST plugins with only an "id" field.
1050 if (type == ARDOUR::Windows_VST) {
1051 prop = node.property ("id");
1055 #ifdef LXVST_SUPPORT
1056 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1058 if (type == ARDOUR::LXVST) {
1059 prop = node.property ("id");
1065 error << _("Plugin has no unique ID field") << endmsg;
1070 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1072 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1073 * allow to move sessions windows <> linux */
1074 #ifdef LXVST_SUPPORT
1075 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1076 type = ARDOUR::LXVST;
1077 plugin = find_plugin (_session, prop->value(), type);
1081 #ifdef WINDOWS_VST_SUPPORT
1082 if (plugin == 0 && type == ARDOUR::LXVST) {
1083 type = ARDOUR::Windows_VST;
1084 plugin = find_plugin (_session, prop->value(), type);
1089 error << string_compose(
1090 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1091 "Perhaps it was removed or moved since it was last used."),
1097 // The name of the PluginInsert comes from the plugin, nothing else
1098 _name = plugin->get_info()->name;
1102 // Processor::set_state() will set this, but too late
1103 // for it to be available when setting up plugin
1104 // state. We can't call Processor::set_state() until
1105 // the plugins themselves are created and added.
1109 if (_plugins.empty()) {
1110 /* if we are adding the first plugin, we will need to set
1111 up automatable controls.
1113 add_plugin (plugin);
1114 create_automatable_parameters ();
1115 set_control_ids (node, version);
1118 if ((prop = node.property ("count")) != 0) {
1119 sscanf (prop->value().c_str(), "%u", &count);
1122 if (_plugins.size() != count) {
1123 for (uint32_t n = 1; n < count; ++n) {
1124 add_plugin (plugin_factory (plugin));
1128 Processor::set_state (node, version);
1130 PBD::ID new_id = this->id();
1131 PBD::ID old_id = this->id();
1133 if ((prop = node.property ("id")) != 0) {
1134 old_id = prop->value ();
1137 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1139 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1140 and set all plugins to the same state.
1143 if ((*niter)->name() == plugin->state_node_name()) {
1145 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1146 /* Plugin state can include external files which are named after the ID.
1148 * If regenerate_xml_or_string_ids() is set, the ID will already have
1149 * been changed, so we need to use the old ID from the XML to load the
1150 * state and then update the ID.
1152 * When copying a plugin-state, route_ui takes care of of updating the ID,
1153 * but we need to call set_insert_id() to clear the cached plugin-state
1154 * and force a change.
1156 if (!regenerate_xml_or_string_ids ()) {
1157 (*i)->set_insert_id (new_id);
1159 (*i)->set_insert_id (old_id);
1162 (*i)->set_state (**niter, version);
1164 if (regenerate_xml_or_string_ids ()) {
1165 (*i)->set_insert_id (new_id);
1173 if (version < 3000) {
1175 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1176 this is all handled by Automatable
1179 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1180 if ((*niter)->name() == "Redirect") {
1181 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1182 Processor::set_state (**niter, version);
1187 set_parameter_state_2X (node, version);
1190 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1194 (*i)->deactivate ();
1202 PluginInsert::update_id (PBD::ID id)
1205 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1206 (*i)->set_insert_id (id);
1211 PluginInsert::set_state_dir (const std::string& d)
1213 // state() only saves the state of the first plugin
1214 _plugins[0]->set_state_dir (d);
1218 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1220 XMLNodeList nlist = node.children();
1221 XMLNodeIterator niter;
1223 /* look for port automation node */
1225 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1227 if ((*niter)->name() != port_automation_node_name) {
1233 XMLNodeConstIterator iter;
1238 cnodes = (*niter)->children ("port");
1240 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1244 if ((cprop = child->property("number")) != 0) {
1245 port = cprop->value().c_str();
1247 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1251 sscanf (port, "%" PRIu32, &port_id);
1253 if (port_id >= _plugins[0]->parameter_count()) {
1254 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1258 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1259 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1261 if (c && c->alist()) {
1262 if (!child->children().empty()) {
1263 c->alist()->set_state (*child->children().front(), version);
1265 /* In some cases 2.X saves lists with min_yval and max_yval
1266 being FLT_MIN and FLT_MAX respectively. This causes problems
1267 in A3 because these min/max values are used to compute
1268 where GUI control points should be drawn. If we see such
1269 values, `correct' them to the min/max of the appropriate
1273 float min_y = c->alist()->get_min_y ();
1274 float max_y = c->alist()->get_max_y ();
1276 ParameterDescriptor desc;
1277 _plugins.front()->get_parameter_descriptor (port_id, desc);
1279 if (min_y == FLT_MIN) {
1283 if (max_y == FLT_MAX) {
1287 c->alist()->set_yrange (min_y, max_y);
1290 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1302 PluginInsert::describe_parameter (Evoral::Parameter param)
1304 if (param.type() == PluginAutomation) {
1305 return _plugins[0]->describe_parameter (param);
1306 } else if (param.type() == PluginPropertyAutomation) {
1307 boost::shared_ptr<AutomationControl> c(automation_control(param));
1308 if (c && !c->desc().label.empty()) {
1309 return c->desc().label;
1312 return Automatable::describe_parameter(param);
1316 PluginInsert::signal_latency() const
1318 if (_user_latency) {
1319 return _user_latency;
1322 return _plugins[0]->signal_latency ();
1326 PluginInsert::type ()
1328 return plugin()->get_info()->type;
1331 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1332 const Evoral::Parameter& param,
1333 const ParameterDescriptor& desc,
1334 boost::shared_ptr<AutomationList> list)
1335 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1339 alist()->reset_default (desc.normal);
1341 list->set_interpolation(Evoral::ControlList::Discrete);
1346 set_flags(Controllable::Toggle);
1350 /** @param val `user' value */
1352 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override */)
1355 set_value_unchecked (user_val);
1360 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1362 /* FIXME: probably should be taking out some lock here.. */
1364 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1365 (*i)->set_parameter (_list->parameter().id(), user_val);
1368 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1370 iasp->set_parameter (_list->parameter().id(), user_val);
1373 AutomationControl::set_value (user_val, Controllable::NoGroup);
1377 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1379 AutomationControl::set_value (user_val, Controllable::NoGroup);
1383 PluginInsert::PluginControl::get_state ()
1387 XMLNode& node (AutomationControl::get_state());
1388 ss << parameter().id();
1389 node.add_property (X_("parameter"), ss.str());
1391 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1393 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1400 /** @return `user' val */
1402 PluginInsert::PluginControl::get_value () const
1404 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1410 return plugin->get_parameter (_list->parameter().id());
1413 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
1414 const Evoral::Parameter& param,
1415 const ParameterDescriptor& desc,
1416 boost::shared_ptr<AutomationList> list)
1417 : AutomationControl (p->session(), param, desc, list)
1421 alist()->set_yrange (desc.lower, desc.upper);
1422 alist()->reset_default (desc.normal);
1426 set_flags(Controllable::Toggle);
1431 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
1434 set_value_unchecked (user_val);
1439 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1441 /* Old numeric set_value(), coerce to appropriate datatype if possible.
1442 This is lossy, but better than nothing until Ardour's automation system
1443 can handle various datatypes all the way down. */
1444 const Variant value(_desc.datatype, user_val);
1445 if (value.type() == Variant::NOTHING) {
1446 error << "set_value(double) called for non-numeric property" << endmsg;
1450 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1451 (*i)->set_property(_list->parameter().id(), value);
1455 AutomationControl::set_value (user_val, Controllable::NoGroup);
1459 PluginInsert::PluginPropertyControl::get_state ()
1463 XMLNode& node (AutomationControl::get_state());
1464 ss << parameter().id();
1465 node.add_property (X_("property"), ss.str());
1466 node.remove_property (X_("value"));
1472 PluginInsert::PluginPropertyControl::get_value () const
1474 return _value.to_double();
1477 boost::shared_ptr<Plugin>
1478 PluginInsert::get_impulse_analysis_plugin()
1480 boost::shared_ptr<Plugin> ret;
1481 if (_impulseAnalysisPlugin.expired()) {
1482 ret = plugin_factory(_plugins[0]);
1483 ret->configure_io (input_streams (), output_streams ());
1484 _impulseAnalysisPlugin = ret;
1486 ret = _impulseAnalysisPlugin.lock();
1493 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1495 // called from outside the audio thread, so this should be safe
1496 // only do audio as analysis is (currently) only for audio plugins
1497 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1498 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1500 _signal_analysis_collected_nframes = 0;
1501 _signal_analysis_collect_nframes_max = nframes;
1504 /** Add a plugin to our list */
1506 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1508 plugin->set_insert_id (this->id());
1510 if (_plugins.empty()) {
1511 /* first (and probably only) plugin instance - connect to relevant signals
1514 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
1515 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1516 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1519 _plugins.push_back (plugin);
1523 PluginInsert::realtime_handle_transport_stopped ()
1525 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1526 (*i)->realtime_handle_transport_stopped ();
1531 PluginInsert::realtime_locate ()
1533 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1534 (*i)->realtime_locate ();
1539 PluginInsert::monitoring_changed ()
1541 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1542 (*i)->monitoring_changed ();
1547 PluginInsert::start_touch (uint32_t param_id)
1549 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1551 ac->start_touch (session().audible_frame());
1556 PluginInsert::end_touch (uint32_t param_id)
1558 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1560 ac->stop_touch (true, session().audible_frame());