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/luaproc.h"
37 #include "ardour/plugin.h"
38 #include "ardour/plugin_insert.h"
41 #include "ardour/lv2_plugin.h"
44 #ifdef WINDOWS_VST_SUPPORT
45 #include "ardour/windows_vst_plugin.h"
49 #include "ardour/lxvst_plugin.h"
52 #ifdef AUDIOUNIT_SUPPORT
53 #include "ardour/audio_unit.h"
56 #include "ardour/session.h"
57 #include "ardour/types.h"
62 using namespace ARDOUR;
65 const string PluginInsert::port_automation_node_name = "PortAutomation";
67 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
68 : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
69 , _signal_analysis_collected_nframes(0)
70 , _signal_analysis_collect_nframes_max(0)
72 /* the first is the master */
76 create_automatable_parameters ();
81 PluginInsert::set_count (uint32_t num)
83 bool require_state = !_plugins.empty();
85 /* this is a bad idea.... we shouldn't do this while active.
86 only a route holding their redirect_lock should be calling this
91 } else if (num > _plugins.size()) {
92 uint32_t diff = num - _plugins.size();
94 for (uint32_t n = 0; n < diff; ++n) {
95 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
102 /* XXX do something */
106 } else if (num < _plugins.size()) {
107 uint32_t diff = _plugins.size() - num;
108 for (uint32_t n= 0; n < diff; ++n) {
116 PluginInsert::~PluginInsert ()
121 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
123 if (which.type() != PluginAutomation)
126 boost::shared_ptr<AutomationControl> c
127 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
130 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
135 PluginInsert::output_streams() const
137 assert (!_plugins.empty());
139 PluginInfoPtr info = _plugins.front()->get_info();
141 if (info->reconfigurable_io()) {
142 ChanCount out = _plugins.front()->output_streams ();
143 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
146 ChanCount out = info->n_outputs;
147 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
148 out.set_audio (out.n_audio() * _plugins.size());
149 out.set_midi (out.n_midi() * _plugins.size() + midi_bypass.n_midi());
155 PluginInsert::input_streams() const
157 assert (!_plugins.empty());
161 PluginInfoPtr info = _plugins.front()->get_info();
163 if (info->reconfigurable_io()) {
164 assert (_plugins.size() == 1);
165 in = _plugins.front()->input_streams();
170 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
172 if (_match.method == Split) {
174 /* we are splitting 1 processor input to multiple plugin inputs,
175 so we have a maximum of 1 stream of each type.
177 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
178 if (in.get (*t) > 1) {
184 } else if (_match.method == Hide) {
186 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
187 in.set (*t, in.get (*t) - _match.hide.get (*t));
193 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
194 in.set (*t, in.get (*t) * _plugins.size ());
202 PluginInsert::natural_output_streams() const
204 return _plugins[0]->get_info()->n_outputs;
208 PluginInsert::natural_input_streams() const
210 return _plugins[0]->get_info()->n_inputs;
214 PluginInsert::has_no_inputs() const
216 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
220 PluginInsert::has_no_audio_inputs() const
222 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
226 PluginInsert::is_midi_instrument() const
228 /* XXX more finesse is possible here. VST plugins have a
229 a specific "instrument" flag, for example.
231 PluginInfoPtr pi = _plugins[0]->get_info();
233 return pi->n_inputs.n_midi() != 0 &&
234 pi->n_outputs.n_audio() > 0;
238 PluginInsert::create_automatable_parameters ()
240 assert (!_plugins.empty());
242 set<Evoral::Parameter> a = _plugins.front()->automatable ();
244 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
245 if (i->type() == PluginAutomation) {
247 Evoral::Parameter param(*i);
249 ParameterDescriptor desc;
250 _plugins.front()->get_parameter_descriptor(i->id(), desc);
252 can_automate (param);
253 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
254 add_control (boost::shared_ptr<AutomationControl> (new PluginControl(this, param, desc, list)));
255 } else if (i->type() == PluginPropertyAutomation) {
256 Evoral::Parameter param(*i);
257 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
258 if (desc.datatype != Variant::NOTHING) {
259 boost::shared_ptr<AutomationList> list;
260 if (Variant::type_is_numeric(desc.datatype)) {
261 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
263 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
268 /** Called when something outside of this host has modified a plugin
269 * parameter. Responsible for propagating the change to two places:
271 * 1) anything listening to the Control itself
272 * 2) any replicated plugins that make up this PluginInsert.
274 * The PluginInsert is connected to the ParameterChangedExternally signal for
275 * the first (primary) plugin, and here broadcasts that change to any others.
277 * XXX We should probably drop this whole replication idea (Paul, October 2015)
278 * since it isn't used by sensible plugin APIs (AU, LV2).
281 PluginInsert::parameter_changed_externally (uint32_t which, float val)
283 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
285 /* First propagation: alter the underlying value of the control,
286 * without telling the plugin(s) that own/use it to set it.
293 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
296 pc->catch_up_with_external_value (val);
299 /* Second propagation: tell all plugins except the first to
300 update the value of this parameter. For sane plugin APIs,
301 there are no other plugins, so this is a no-op in those
305 Plugins::iterator i = _plugins.begin();
307 /* don't set the first plugin, just all the slaves */
309 if (i != _plugins.end()) {
311 for (; i != _plugins.end(); ++i) {
312 (*i)->set_parameter (which, val);
318 PluginInsert::set_block_size (pframes_t nframes)
321 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
322 if ((*i)->set_block_size (nframes) != 0) {
330 PluginInsert::activate ()
332 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
336 Processor::activate ();
340 PluginInsert::deactivate ()
342 Processor::deactivate ();
344 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
350 PluginInsert::flush ()
352 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
358 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
360 // Calculate if, and how many frames we need to collect for analysis
361 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
362 _signal_analysis_collected_nframes);
363 if (nframes < collect_signal_nframes) { // we might not get all frames now
364 collect_signal_nframes = nframes;
367 ChanCount const in_streams = input_streams ();
368 ChanCount const out_streams = output_streams ();
370 ChanMapping in_map (in_streams);
371 ChanMapping out_map (out_streams);
373 if (_match.method == Split) {
374 /* fix the input mapping so that we have maps for each of the plugin's inputs */
375 in_map = ChanMapping (natural_input_streams ());
377 /* copy the first stream's buffer contents to the others */
378 /* XXX: audio only */
379 uint32_t first_idx = in_map.get (DataType::AUDIO, 0, &valid);
381 for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
382 bufs.get_audio(in_map.get (DataType::AUDIO, i, &valid)).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
387 bufs.set_count(ChanCount::max(bufs.count(), in_streams));
388 bufs.set_count(ChanCount::max(bufs.count(), out_streams));
390 /* Note that we've already required that plugins
391 be able to handle in-place processing.
398 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
400 boost::shared_ptr<AutomationControl> c
401 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
403 if (c->list() && c->automation_playback()) {
406 const float val = c->list()->rt_safe_eval (now, valid);
409 /* This is the ONLY place where we are
411 * AutomationControl::set_value_unchecked(). We
412 * know that the control is in
413 * automation playback mode, so no
414 * check on writable() is required
415 * (which must be done in AutomationControl::set_value()
418 c->set_value_unchecked(val);
425 if (collect_signal_nframes > 0) {
427 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
428 //std::cerr << " streams " << input_streams().n_audio() << std::endl;
429 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
431 _signal_analysis_inputs.set_count(input_streams());
433 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
434 _signal_analysis_inputs.get_audio(i).read_from(
436 collect_signal_nframes,
437 _signal_analysis_collected_nframes); // offset is for target buffer
442 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
443 if ((*i)->connect_and_run(bufs, in_map, out_map, nframes, offset)) {
446 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
447 in_map.offset_to(*t, natural_input_streams().get(*t));
448 out_map.offset_to(*t, natural_output_streams().get(*t));
452 if (collect_signal_nframes > 0) {
454 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
455 //std::cerr << " streams " << output_streams().n_audio() << std::endl;
457 _signal_analysis_outputs.set_count(output_streams());
459 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
460 _signal_analysis_outputs.get_audio(i).read_from(
462 collect_signal_nframes,
463 _signal_analysis_collected_nframes); // offset is for target buffer
466 _signal_analysis_collected_nframes += collect_signal_nframes;
467 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
469 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
470 _signal_analysis_collect_nframes_max = 0;
471 _signal_analysis_collected_nframes = 0;
473 AnalysisDataGathered(&_signal_analysis_inputs,
474 &_signal_analysis_outputs);
477 /* leave remaining channel buffers alone */
481 PluginInsert::silence (framecnt_t nframes)
487 ChanMapping in_map(input_streams());
488 ChanMapping out_map(output_streams());
490 if (_match.method == Split) {
491 /* fix the input mapping so that we have maps for each of the plugin's inputs */
492 in_map = ChanMapping (natural_input_streams ());
495 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
496 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
501 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t /*end_frame*/, pframes_t nframes, bool)
503 if (_pending_active) {
504 /* run as normal if we are active or moving from inactive to active */
506 if (_session.transport_rolling() || _session.bounce_processing()) {
507 automation_run (bufs, start_frame, nframes);
509 connect_and_run (bufs, nframes, 0, false);
513 uint32_t in = input_streams ().n_audio ();
514 uint32_t out = output_streams().n_audio ();
516 if (has_no_audio_inputs() || in == 0) {
518 /* silence all (audio) outputs. Should really declick
519 * at the transitions of "active"
522 for (uint32_t n = 0; n < out; ++n) {
523 bufs.get_audio (n).silence (nframes);
526 } else if (out > in) {
528 /* not active, but something has make up for any channel count increase */
530 // TODO: option round-robin (n % in) or silence additional buffers ??
531 // for now , simply replicate last buffer
532 for (uint32_t n = in; n < out; ++n) {
533 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
537 bufs.count().set_audio (out);
540 _active = _pending_active;
542 /* we have no idea whether the plugin generated silence or not, so mark
543 * all buffers appropriately.
549 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
551 Evoral::ControlEvent next_event (0, 0.0f);
552 framepos_t now = start;
553 framepos_t end = now + nframes;
554 framecnt_t offset = 0;
556 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
559 connect_and_run (bufs, nframes, offset, false);
563 if (!find_next_event (now, end, next_event) || requires_fixed_sized_buffers()) {
565 /* no events have a time within the relevant range */
567 connect_and_run (bufs, nframes, offset, true, now);
573 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
575 connect_and_run (bufs, cnt, offset, true, now);
581 if (!find_next_event (now, end, next_event)) {
586 /* cleanup anything that is left to do */
589 connect_and_run (bufs, nframes, offset, true, now);
594 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
596 if (param.type() != PluginAutomation)
599 if (_plugins.empty()) {
600 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
602 abort(); /*NOTREACHED*/
605 return _plugins[0]->default_value (param.id());
610 PluginInsert::can_reset_all_parameters ()
614 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
616 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
618 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
622 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
628 if (ac->automation_state() & Play) {
633 return all && (params > 0);
637 PluginInsert::reset_parameters_to_default ()
641 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
643 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
645 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
649 const float dflt = _plugins[0]->default_value (cid);
650 const float curr = _plugins[0]->get_parameter (cid);
656 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
661 if (ac->automation_state() & Play) {
666 ac->set_value (dflt, Controllable::NoGroup);
671 boost::shared_ptr<Plugin>
672 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
674 boost::shared_ptr<LadspaPlugin> lp;
675 boost::shared_ptr<LuaProc> lua;
677 boost::shared_ptr<LV2Plugin> lv2p;
679 #ifdef WINDOWS_VST_SUPPORT
680 boost::shared_ptr<WindowsVSTPlugin> vp;
683 boost::shared_ptr<LXVSTPlugin> lxvp;
685 #ifdef AUDIOUNIT_SUPPORT
686 boost::shared_ptr<AUPlugin> ap;
689 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
690 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
691 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
692 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
694 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
695 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
697 #ifdef WINDOWS_VST_SUPPORT
698 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
699 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
702 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
703 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
705 #ifdef AUDIOUNIT_SUPPORT
706 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
707 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
711 fatal << string_compose (_("programming error: %1"),
712 X_("unknown plugin type in PluginInsert::plugin_factory"))
714 abort(); /*NOTREACHED*/
715 return boost::shared_ptr<Plugin> ((Plugin*) 0);
719 PluginInsert::configure_io (ChanCount in, ChanCount out)
721 Match old_match = _match;
722 ChanCount old_in = input_streams ();
723 ChanCount old_out = output_streams ();
726 _configured_out = out;
728 /* set the matching method and number of plugins that we will use to meet this configuration */
729 _match = private_can_support_io_configuration (in, out);
730 if (set_count (_match.plugins) == false) {
731 PluginIoReConfigure (); /* EMIT SIGNAL */
735 /* configure plugins */
736 switch (_match.method) {
739 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out) == false) {
740 PluginIoReConfigure (); /* EMIT SIGNAL */
746 if (_plugins.front()->configure_io (in, out) == false) {
747 PluginIoReConfigure (); /* EMIT SIGNAL */
753 if ( (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
758 PluginIoReConfigure (); /* EMIT SIGNAL */
761 // we don't know the analysis window size, so we must work with the
762 // current buffer size here. each request for data fills in these
763 // buffers and the analyser makes sure it gets enough data for the
765 session().ensure_buffer_set (_signal_analysis_inputs, in);
766 //_signal_analysis_inputs.set_count (in);
768 session().ensure_buffer_set (_signal_analysis_outputs, out);
769 //_signal_analysis_outputs.set_count (out);
771 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
773 return Processor::configure_io (in, out);
776 /** Decide whether this PluginInsert can support a given IO configuration.
777 * To do this, we run through a set of possible solutions in rough order of
780 * @param in Required input channel count.
781 * @param out Filled in with the output channel count if we return true.
782 * @return true if the given IO configuration can be supported.
785 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
787 return private_can_support_io_configuration (in, out).method != Impossible;
790 /** A private version of can_support_io_configuration which returns the method
791 * by which the configuration can be matched, rather than just whether or not
795 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
797 if (_plugins.empty()) {
801 PluginInfoPtr info = _plugins.front()->get_info();
802 ChanCount in; in += inx;
805 if (info->reconfigurable_io()) {
806 /* Plugin has flexible I/O, so delegate to it */
807 bool const r = _plugins.front()->can_support_io_configuration (in, out);
809 return Match (Impossible, 0);
812 return Match (Delegate, 1);
815 ChanCount inputs = info->n_inputs;
816 ChanCount outputs = info->n_outputs;
818 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
819 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
820 midi_bypass.set(DataType::MIDI, 1);
822 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
823 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
824 in.set(DataType::MIDI, 0);
827 bool no_inputs = true;
828 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
829 if (inputs.get (*t) != 0) {
836 /* no inputs so we can take any input configuration since we throw it away */
837 out = outputs + midi_bypass;
838 return Match (NoInputs, 1);
841 /* Plugin inputs match requested inputs exactly */
843 out = outputs + midi_bypass;
844 return Match (ExactMatch, 1);
847 /* We may be able to run more than one copy of the plugin within this insert
848 to cope with the insert having more inputs than the plugin.
849 We allow replication only for plugins with either zero or 1 inputs and outputs
850 for every valid data type.
854 bool can_replicate = true;
855 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
857 uint32_t nin = inputs.get (*t);
859 // No inputs of this type
860 if (nin == 0 && in.get(*t) == 0) {
864 if (nin != 1 || outputs.get (*t) != 1) {
865 can_replicate = false;
869 // Potential factor not set yet
871 f = in.get(*t) / nin;
874 // Factor for this type does not match another type, can not replicate
875 if (f != (in.get(*t) / nin)) {
876 can_replicate = false;
882 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
883 out.set (*t, outputs.get(*t) * f);
886 return Match (Replicate, f);
889 /* If the processor has exactly one input of a given type, and
890 the plugin has more, we can feed the single processor input
891 to some or all of the plugin inputs. This is rather
892 special-case-y, but the 1-to-many case is by far the
893 simplest. How do I split thy 2 processor inputs to 3
894 plugin inputs? Let me count the ways ...
897 bool can_split = true;
898 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
900 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
901 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
903 if (!can_split_type && !nothing_to_do_for_type) {
909 out = outputs + midi_bypass;
910 return Match (Split, 1);
913 /* If the plugin has more inputs than we want, we can `hide' some of them
914 by feeding them silence.
917 bool could_hide = false;
918 bool cannot_hide = false;
919 ChanCount hide_channels;
921 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
922 if (inputs.get(*t) > in.get(*t)) {
923 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
924 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
926 } else if (inputs.get(*t) < in.get(*t)) {
927 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
932 if (could_hide && !cannot_hide) {
933 out = outputs + midi_bypass;
934 return Match (Hide, 1, hide_channels);
938 return Match (Impossible, 0);
942 PluginInsert::get_state ()
948 PluginInsert::state (bool full)
950 XMLNode& node = Processor::state (full);
952 node.add_property("type", _plugins[0]->state_node_name());
953 node.add_property("unique-id", _plugins[0]->unique_id());
954 node.add_property("count", string_compose("%1", _plugins.size()));
956 /* remember actual i/o configuration (for later placeholder
957 * in case the plugin goes missing) */
958 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
959 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
961 _plugins[0]->set_insert_id(this->id());
962 node.add_child_nocopy (_plugins[0]->get_state());
964 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
965 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
967 node.add_child_nocopy (ac->get_state());
975 PluginInsert::set_control_ids (const XMLNode& node, int version)
977 const XMLNodeList& nlist = node.children();
978 XMLNodeConstIterator iter;
979 set<Evoral::Parameter>::const_iterator p;
981 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
982 if ((*iter)->name() == Controllable::xml_node_name) {
983 const XMLProperty* prop;
985 uint32_t p = (uint32_t)-1;
987 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
988 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
990 p = lv2plugin->port_index(prop->value().c_str());
994 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
995 p = atoi (prop->value());
998 if (p != (uint32_t)-1) {
1000 /* this may create the new controllable */
1002 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1004 #ifndef NO_PLUGIN_STATE
1008 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1010 ac->set_state (**iter, version);
1019 PluginInsert::set_state(const XMLNode& node, int version)
1021 XMLNodeList nlist = node.children();
1022 XMLNodeIterator niter;
1023 XMLPropertyList plist;
1024 const XMLProperty *prop;
1025 ARDOUR::PluginType type;
1027 if ((prop = node.property ("type")) == 0) {
1028 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1032 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1033 type = ARDOUR::LADSPA;
1034 } else if (prop->value() == X_("lv2")) {
1036 } else if (prop->value() == X_("windows-vst")) {
1037 type = ARDOUR::Windows_VST;
1038 } else if (prop->value() == X_("lxvst")) {
1039 type = ARDOUR::LXVST;
1040 } else if (prop->value() == X_("audiounit")) {
1041 type = ARDOUR::AudioUnit;
1042 } else if (prop->value() == X_("luaproc")) {
1045 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1051 prop = node.property ("unique-id");
1054 #ifdef WINDOWS_VST_SUPPORT
1055 /* older sessions contain VST plugins with only an "id" field.
1058 if (type == ARDOUR::Windows_VST) {
1059 prop = node.property ("id");
1063 #ifdef LXVST_SUPPORT
1064 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1066 if (type == ARDOUR::LXVST) {
1067 prop = node.property ("id");
1073 error << _("Plugin has no unique ID field") << endmsg;
1078 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1080 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1081 * allow to move sessions windows <> linux */
1082 #ifdef LXVST_SUPPORT
1083 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1084 type = ARDOUR::LXVST;
1085 plugin = find_plugin (_session, prop->value(), type);
1089 #ifdef WINDOWS_VST_SUPPORT
1090 if (plugin == 0 && type == ARDOUR::LXVST) {
1091 type = ARDOUR::Windows_VST;
1092 plugin = find_plugin (_session, prop->value(), type);
1097 error << string_compose(
1098 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1099 "Perhaps it was removed or moved since it was last used."),
1105 if (type == ARDOUR::Lua) {
1106 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1107 // we need to load the script to set the name and parameters.
1108 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1110 lp->set_script_from_state (*ls);
1114 // The name of the PluginInsert comes from the plugin, nothing else
1115 _name = plugin->get_info()->name;
1119 // Processor::set_state() will set this, but too late
1120 // for it to be available when setting up plugin
1121 // state. We can't call Processor::set_state() until
1122 // the plugins themselves are created and added.
1126 if (_plugins.empty()) {
1127 /* if we are adding the first plugin, we will need to set
1128 up automatable controls.
1130 add_plugin (plugin);
1131 create_automatable_parameters ();
1132 set_control_ids (node, version);
1135 if ((prop = node.property ("count")) != 0) {
1136 sscanf (prop->value().c_str(), "%u", &count);
1139 if (_plugins.size() != count) {
1140 for (uint32_t n = 1; n < count; ++n) {
1141 add_plugin (plugin_factory (plugin));
1145 Processor::set_state (node, version);
1147 PBD::ID new_id = this->id();
1148 PBD::ID old_id = this->id();
1150 if ((prop = node.property ("id")) != 0) {
1151 old_id = prop->value ();
1154 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1156 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1157 and set all plugins to the same state.
1160 if ((*niter)->name() == plugin->state_node_name()) {
1162 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1163 /* Plugin state can include external files which are named after the ID.
1165 * If regenerate_xml_or_string_ids() is set, the ID will already have
1166 * been changed, so we need to use the old ID from the XML to load the
1167 * state and then update the ID.
1169 * When copying a plugin-state, route_ui takes care of of updating the ID,
1170 * but we need to call set_insert_id() to clear the cached plugin-state
1171 * and force a change.
1173 if (!regenerate_xml_or_string_ids ()) {
1174 (*i)->set_insert_id (new_id);
1176 (*i)->set_insert_id (old_id);
1179 (*i)->set_state (**niter, version);
1181 if (regenerate_xml_or_string_ids ()) {
1182 (*i)->set_insert_id (new_id);
1190 if (version < 3000) {
1192 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1193 this is all handled by Automatable
1196 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1197 if ((*niter)->name() == "Redirect") {
1198 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1199 Processor::set_state (**niter, version);
1204 set_parameter_state_2X (node, version);
1207 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1211 (*i)->deactivate ();
1219 PluginInsert::update_id (PBD::ID id)
1222 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1223 (*i)->set_insert_id (id);
1228 PluginInsert::set_state_dir (const std::string& d)
1230 // state() only saves the state of the first plugin
1231 _plugins[0]->set_state_dir (d);
1235 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1237 XMLNodeList nlist = node.children();
1238 XMLNodeIterator niter;
1240 /* look for port automation node */
1242 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1244 if ((*niter)->name() != port_automation_node_name) {
1250 XMLNodeConstIterator iter;
1255 cnodes = (*niter)->children ("port");
1257 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1261 if ((cprop = child->property("number")) != 0) {
1262 port = cprop->value().c_str();
1264 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1268 sscanf (port, "%" PRIu32, &port_id);
1270 if (port_id >= _plugins[0]->parameter_count()) {
1271 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1275 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1276 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1278 if (c && c->alist()) {
1279 if (!child->children().empty()) {
1280 c->alist()->set_state (*child->children().front(), version);
1282 /* In some cases 2.X saves lists with min_yval and max_yval
1283 being FLT_MIN and FLT_MAX respectively. This causes problems
1284 in A3 because these min/max values are used to compute
1285 where GUI control points should be drawn. If we see such
1286 values, `correct' them to the min/max of the appropriate
1290 float min_y = c->alist()->get_min_y ();
1291 float max_y = c->alist()->get_max_y ();
1293 ParameterDescriptor desc;
1294 _plugins.front()->get_parameter_descriptor (port_id, desc);
1296 if (min_y == FLT_MIN) {
1300 if (max_y == FLT_MAX) {
1304 c->alist()->set_yrange (min_y, max_y);
1307 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1319 PluginInsert::describe_parameter (Evoral::Parameter param)
1321 if (param.type() == PluginAutomation) {
1322 return _plugins[0]->describe_parameter (param);
1323 } else if (param.type() == PluginPropertyAutomation) {
1324 boost::shared_ptr<AutomationControl> c(automation_control(param));
1325 if (c && !c->desc().label.empty()) {
1326 return c->desc().label;
1329 return Automatable::describe_parameter(param);
1333 PluginInsert::signal_latency() const
1335 if (_user_latency) {
1336 return _user_latency;
1339 return _plugins[0]->signal_latency ();
1343 PluginInsert::type ()
1345 return plugin()->get_info()->type;
1348 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1349 const Evoral::Parameter& param,
1350 const ParameterDescriptor& desc,
1351 boost::shared_ptr<AutomationList> list)
1352 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1356 alist()->reset_default (desc.normal);
1358 list->set_interpolation(Evoral::ControlList::Discrete);
1363 set_flags(Controllable::Toggle);
1367 /** @param val `user' value */
1369 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1372 _set_value (user_val, group_override);
1376 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1378 /* used only by automation playback */
1379 _set_value (user_val, Controllable::NoGroup);
1383 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1385 /* FIXME: probably should be taking out some lock here.. */
1387 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1388 (*i)->set_parameter (_list->parameter().id(), user_val);
1391 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1393 iasp->set_parameter (_list->parameter().id(), user_val);
1396 AutomationControl::set_value (user_val, group_override);
1400 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1402 AutomationControl::set_value (user_val, Controllable::NoGroup);
1406 PluginInsert::PluginControl::get_state ()
1410 XMLNode& node (AutomationControl::get_state());
1411 ss << parameter().id();
1412 node.add_property (X_("parameter"), ss.str());
1414 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1416 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1423 /** @return `user' val */
1425 PluginInsert::PluginControl::get_value () const
1427 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1433 return plugin->get_parameter (_list->parameter().id());
1436 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
1437 const Evoral::Parameter& param,
1438 const ParameterDescriptor& desc,
1439 boost::shared_ptr<AutomationList> list)
1440 : AutomationControl (p->session(), param, desc, list)
1444 alist()->set_yrange (desc.lower, desc.upper);
1445 alist()->reset_default (desc.normal);
1449 set_flags(Controllable::Toggle);
1454 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
1457 set_value_unchecked (user_val);
1462 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1464 /* Old numeric set_value(), coerce to appropriate datatype if possible.
1465 This is lossy, but better than nothing until Ardour's automation system
1466 can handle various datatypes all the way down. */
1467 const Variant value(_desc.datatype, user_val);
1468 if (value.type() == Variant::NOTHING) {
1469 error << "set_value(double) called for non-numeric property" << endmsg;
1473 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1474 (*i)->set_property(_list->parameter().id(), value);
1478 AutomationControl::set_value (user_val, Controllable::NoGroup);
1482 PluginInsert::PluginPropertyControl::get_state ()
1486 XMLNode& node (AutomationControl::get_state());
1487 ss << parameter().id();
1488 node.add_property (X_("property"), ss.str());
1489 node.remove_property (X_("value"));
1495 PluginInsert::PluginPropertyControl::get_value () const
1497 return _value.to_double();
1500 boost::shared_ptr<Plugin>
1501 PluginInsert::get_impulse_analysis_plugin()
1503 boost::shared_ptr<Plugin> ret;
1504 if (_impulseAnalysisPlugin.expired()) {
1505 ret = plugin_factory(_plugins[0]);
1506 ret->configure_io (input_streams (), output_streams ());
1507 _impulseAnalysisPlugin = ret;
1509 ret = _impulseAnalysisPlugin.lock();
1516 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1518 // called from outside the audio thread, so this should be safe
1519 // only do audio as analysis is (currently) only for audio plugins
1520 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1521 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1523 _signal_analysis_collected_nframes = 0;
1524 _signal_analysis_collect_nframes_max = nframes;
1527 /** Add a plugin to our list */
1529 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1531 plugin->set_insert_id (this->id());
1533 if (_plugins.empty()) {
1534 /* first (and probably only) plugin instance - connect to relevant signals
1537 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
1538 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1539 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1542 _plugins.push_back (plugin);
1546 PluginInsert::realtime_handle_transport_stopped ()
1548 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1549 (*i)->realtime_handle_transport_stopped ();
1554 PluginInsert::realtime_locate ()
1556 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1557 (*i)->realtime_locate ();
1562 PluginInsert::monitoring_changed ()
1564 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1565 (*i)->monitoring_changed ();
1570 PluginInsert::start_touch (uint32_t param_id)
1572 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1574 ac->start_touch (session().audible_frame());
1579 PluginInsert::end_touch (uint32_t param_id)
1581 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1583 ac->stop_touch (true, session().audible_frame());