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 , _pending_no_inplace (false)
74 , _strict_io_configured (false)
76 /* the first is the master */
80 create_automatable_parameters ();
85 PluginInsert::set_count (uint32_t num)
87 bool require_state = !_plugins.empty();
89 /* this is a bad idea.... we shouldn't do this while active.
90 only a route holding their redirect_lock should be calling this
95 } else if (num > _plugins.size()) {
96 uint32_t diff = num - _plugins.size();
98 for (uint32_t n = 0; n < diff; ++n) {
99 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
106 /* XXX do something */
110 } else if (num < _plugins.size()) {
111 uint32_t diff = _plugins.size() - num;
112 for (uint32_t n= 0; n < diff; ++n) {
120 PluginInsert::~PluginInsert ()
125 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
127 if (which.type() != PluginAutomation)
130 boost::shared_ptr<AutomationControl> c
131 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
134 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
139 PluginInsert::output_streams() const
141 assert (!_plugins.empty());
143 PluginInfoPtr info = _plugins.front()->get_info();
145 if (_strict_io_configured) {
146 return _configured_in; // XXX, check initial configuration
148 else if (info->reconfigurable_io()) {
149 ChanCount out = _plugins.front()->output_streams ();
150 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
153 ChanCount out = info->n_outputs;
154 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
155 out.set_audio (out.n_audio() * _plugins.size());
156 out.set_midi (out.n_midi() * _plugins.size() + midi_bypass.n_midi());
162 PluginInsert::input_streams() const
164 assert (!_plugins.empty());
168 PluginInfoPtr info = _plugins.front()->get_info();
170 if (info->reconfigurable_io()) {
171 assert (_plugins.size() == 1);
172 in = _plugins.front()->input_streams();
177 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
179 if (_match.method == Split) {
181 /* we are splitting 1 processor input to multiple plugin inputs,
182 so we have a maximum of 1 stream of each type.
184 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
185 if (in.get (*t) > 1) {
191 } else if (_match.method == Hide) {
193 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
194 in.set (*t, in.get (*t) - _match.hide.get (*t));
200 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
201 in.set (*t, in.get (*t) * _plugins.size ());
209 PluginInsert::natural_output_streams() const
211 return _plugins[0]->get_info()->n_outputs;
215 PluginInsert::natural_input_streams() const
217 return _plugins[0]->get_info()->n_inputs;
221 PluginInsert::has_no_inputs() const
223 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
227 PluginInsert::has_no_audio_inputs() const
229 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
233 PluginInsert::is_midi_instrument() const
235 /* XXX more finesse is possible here. VST plugins have a
236 a specific "instrument" flag, for example.
238 PluginInfoPtr pi = _plugins[0]->get_info();
240 return pi->n_inputs.n_midi() != 0 &&
241 pi->n_outputs.n_audio() > 0;
245 PluginInsert::create_automatable_parameters ()
247 assert (!_plugins.empty());
249 set<Evoral::Parameter> a = _plugins.front()->automatable ();
251 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
252 if (i->type() == PluginAutomation) {
254 Evoral::Parameter param(*i);
256 ParameterDescriptor desc;
257 _plugins.front()->get_parameter_descriptor(i->id(), desc);
259 can_automate (param);
260 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
261 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
263 _plugins.front()->set_automation_control (i->id(), c);
264 } else if (i->type() == PluginPropertyAutomation) {
265 Evoral::Parameter param(*i);
266 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
267 if (desc.datatype != Variant::NOTHING) {
268 boost::shared_ptr<AutomationList> list;
269 if (Variant::type_is_numeric(desc.datatype)) {
270 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
272 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
277 /** Called when something outside of this host has modified a plugin
278 * parameter. Responsible for propagating the change to two places:
280 * 1) anything listening to the Control itself
281 * 2) any replicated plugins that make up this PluginInsert.
283 * The PluginInsert is connected to the ParameterChangedExternally signal for
284 * the first (primary) plugin, and here broadcasts that change to any others.
286 * XXX We should probably drop this whole replication idea (Paul, October 2015)
287 * since it isn't used by sensible plugin APIs (AU, LV2).
290 PluginInsert::parameter_changed_externally (uint32_t which, float val)
292 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
294 /* First propagation: alter the underlying value of the control,
295 * without telling the plugin(s) that own/use it to set it.
302 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
305 pc->catch_up_with_external_value (val);
308 /* Second propagation: tell all plugins except the first to
309 update the value of this parameter. For sane plugin APIs,
310 there are no other plugins, so this is a no-op in those
314 Plugins::iterator i = _plugins.begin();
316 /* don't set the first plugin, just all the slaves */
318 if (i != _plugins.end()) {
320 for (; i != _plugins.end(); ++i) {
321 (*i)->set_parameter (which, val);
327 PluginInsert::set_block_size (pframes_t nframes)
330 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
331 if ((*i)->set_block_size (nframes) != 0) {
339 PluginInsert::activate ()
341 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
345 Processor::activate ();
349 PluginInsert::deactivate ()
351 Processor::deactivate ();
353 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
359 PluginInsert::flush ()
361 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
367 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
369 _no_inplace = _pending_no_inplace;
370 // Calculate if, and how many frames we need to collect for analysis
371 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
372 _signal_analysis_collected_nframes);
373 if (nframes < collect_signal_nframes) { // we might not get all frames now
374 collect_signal_nframes = nframes;
377 ChanCount const in_streams = input_streams ();
378 ChanCount const out_streams = output_streams ();
380 if (_match.method == Split) {
381 assert (_in_map.size () == 1);
382 /* fix the input mapping so that we have maps for each of the plugin's inputs */
384 /* copy the first stream's buffer contents to the others */
385 /* XXX: audio only */
387 uint32_t first_idx = _in_map[0].get (DataType::AUDIO, 0, &valid);
389 for (uint32_t i = in_streams.n_audio(); i < natural_input_streams().n_audio(); ++i) {
390 bufs.get_audio(_in_map[0].get (DataType::AUDIO, i, &valid)).read_from(bufs.get_audio(first_idx), nframes, offset, offset);
395 bufs.set_count(ChanCount::max(bufs.count(), in_streams));
396 bufs.set_count(ChanCount::max(bufs.count(), out_streams));
398 /* Note that we've already required that plugins
399 be able to handle in-place processing.
406 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
408 boost::shared_ptr<AutomationControl> c
409 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
411 if (c->list() && c->automation_playback()) {
414 const float val = c->list()->rt_safe_eval (now, valid);
417 /* This is the ONLY place where we are
419 * AutomationControl::set_value_unchecked(). We
420 * know that the control is in
421 * automation playback mode, so no
422 * check on writable() is required
423 * (which must be done in AutomationControl::set_value()
426 c->set_value_unchecked(val);
433 if (collect_signal_nframes > 0) {
435 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
436 //std::cerr << " streams " << input_streams().n_audio() << std::endl;
437 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
439 _signal_analysis_inputs.set_count(input_streams());
441 for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
442 _signal_analysis_inputs.get_audio(i).read_from(
444 collect_signal_nframes,
445 _signal_analysis_collected_nframes); // offset is for target buffer
451 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
454 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
456 ARDOUR::ChanMapping in_map (natural_input_streams());
457 ARDOUR::ChanMapping out_map;
458 ARDOUR::ChanCount mapped;
459 ARDOUR::ChanCount backmap;
461 // map inputs sequentially
462 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
463 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
465 uint32_t in_idx = _in_map[pc].get (*t, in, &valid);
466 uint32_t m = mapped.get (*t);
468 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
470 inplace_bufs.get (*t, m).silence (nframes, offset);
472 mapped.set (*t, m + 1);
476 // TODO use map_offset_to() instead ??
480 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
481 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
482 uint32_t m = mapped.get (*t);
483 inplace_bufs.get (*t, m).silence (nframes, offset);
484 out_map.set (*t, out, m);
485 mapped.set (*t, m + 1);
489 if ((*i)->connect_and_run(inplace_bufs, in_map, out_map, nframes, offset)) {
493 // clear output buffers
494 // TODO only clear buffers that are not connected, but configured
495 bufs.silence (nframes, offset);
498 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
499 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
500 uint32_t m = backmap.get (*t);
502 uint32_t out_idx = _out_map[pc].get (*t, out, &valid);
504 bufs.get (*t, out_idx).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
506 backmap.set (*t, m + 1);
513 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
514 if ((*i)->connect_and_run(bufs, _in_map[pc], _out_map[pc], nframes, offset)) {
520 if (collect_signal_nframes > 0) {
522 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
523 //std::cerr << " streams " << output_streams().n_audio() << std::endl;
525 _signal_analysis_outputs.set_count(output_streams());
527 for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
528 _signal_analysis_outputs.get_audio(i).read_from(
530 collect_signal_nframes,
531 _signal_analysis_collected_nframes); // offset is for target buffer
534 _signal_analysis_collected_nframes += collect_signal_nframes;
535 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
537 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
538 _signal_analysis_collect_nframes_max = 0;
539 _signal_analysis_collected_nframes = 0;
541 AnalysisDataGathered(&_signal_analysis_inputs,
542 &_signal_analysis_outputs);
545 /* leave remaining channel buffers alone */
549 PluginInsert::silence (framecnt_t nframes)
555 ChanMapping in_map (natural_input_streams ());
556 ChanMapping out_map (natural_output_streams ());
558 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
559 (*i)->connect_and_run (_session.get_scratch_buffers ((*i)->get_info()->n_inputs, true), in_map, out_map, nframes, 0);
564 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t /*end_frame*/, pframes_t nframes, bool)
566 if (_pending_active) {
567 /* run as normal if we are active or moving from inactive to active */
569 if (_session.transport_rolling() || _session.bounce_processing()) {
570 automation_run (bufs, start_frame, nframes);
572 connect_and_run (bufs, nframes, 0, false);
576 uint32_t in = input_streams ().n_audio ();
577 uint32_t out = output_streams().n_audio ();
579 if (has_no_audio_inputs() || in == 0) {
581 /* silence all (audio) outputs. Should really declick
582 * at the transitions of "active"
585 for (uint32_t n = 0; n < out; ++n) {
586 bufs.get_audio (n).silence (nframes);
589 } else if (out > in) {
591 /* not active, but something has make up for any channel count increase */
593 // TODO: option round-robin (n % in) or silence additional buffers ??
594 // for now , simply replicate last buffer
595 for (uint32_t n = in; n < out; ++n) {
596 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
600 bufs.count().set_audio (out);
603 _active = _pending_active;
605 /* we have no idea whether the plugin generated silence or not, so mark
606 * all buffers appropriately.
612 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
614 Evoral::ControlEvent next_event (0, 0.0f);
615 framepos_t now = start;
616 framepos_t end = now + nframes;
617 framecnt_t offset = 0;
619 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
622 connect_and_run (bufs, nframes, offset, false);
626 if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
628 /* no events have a time within the relevant range */
630 connect_and_run (bufs, nframes, offset, true, now);
636 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
638 connect_and_run (bufs, cnt, offset, true, now);
644 if (!find_next_event (now, end, next_event)) {
649 /* cleanup anything that is left to do */
652 connect_and_run (bufs, nframes, offset, true, now);
657 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
659 if (param.type() != PluginAutomation)
662 if (_plugins.empty()) {
663 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
665 abort(); /*NOTREACHED*/
668 return _plugins[0]->default_value (param.id());
673 PluginInsert::can_reset_all_parameters ()
677 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
679 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
681 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
685 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
691 if (ac->automation_state() & Play) {
696 return all && (params > 0);
700 PluginInsert::reset_parameters_to_default ()
704 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
706 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
708 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
712 const float dflt = _plugins[0]->default_value (cid);
713 const float curr = _plugins[0]->get_parameter (cid);
719 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
724 if (ac->automation_state() & Play) {
729 ac->set_value (dflt, Controllable::NoGroup);
734 boost::shared_ptr<Plugin>
735 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
737 boost::shared_ptr<LadspaPlugin> lp;
738 boost::shared_ptr<LuaProc> lua;
740 boost::shared_ptr<LV2Plugin> lv2p;
742 #ifdef WINDOWS_VST_SUPPORT
743 boost::shared_ptr<WindowsVSTPlugin> vp;
746 boost::shared_ptr<LXVSTPlugin> lxvp;
748 #ifdef AUDIOUNIT_SUPPORT
749 boost::shared_ptr<AUPlugin> ap;
752 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
753 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
754 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
755 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
757 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
758 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
760 #ifdef WINDOWS_VST_SUPPORT
761 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
762 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
765 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
766 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
768 #ifdef AUDIOUNIT_SUPPORT
769 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
770 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
774 fatal << string_compose (_("programming error: %1"),
775 X_("unknown plugin type in PluginInsert::plugin_factory"))
777 abort(); /*NOTREACHED*/
778 return boost::shared_ptr<Plugin> ((Plugin*) 0);
782 PluginInsert::configure_io (ChanCount in, ChanCount out)
784 Match old_match = _match;
785 ChanCount old_in = input_streams ();
786 ChanCount old_out = output_streams ();
789 _configured_out = out;
791 /* TODO use "custom config"
792 * allow user to edit/override output ports, handle strict i/o.
794 * configuration should only applied here.
797 /* set the matching method and number of plugins that we will use to meet this configuration */
798 _match = private_can_support_io_configuration (in, out);
799 if (set_count (_match.plugins) == false) {
800 PluginIoReConfigure (); /* EMIT SIGNAL */
804 /* configure plugins */
805 switch (_match.method) {
808 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out) == false) {
809 PluginIoReConfigure (); /* EMIT SIGNAL */
815 if (_plugins.front()->configure_io (in, out) == false) {
816 PluginIoReConfigure (); /* EMIT SIGNAL */
822 // TODO make configurable, ideally use a single in/out map for all replicated
825 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
826 if (_match.method == Split) {
827 /* TODO see PluginInsert::connect_and_run, channel replication */
828 _in_map[pc] = ChanMapping (natural_input_streams ());
830 _in_map[pc] = ChanMapping (input_streams ());
832 _out_map[pc] = ChanMapping (output_streams());
834 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
835 _in_map[pc].offset_to(*t, pc * natural_input_streams().get(*t));
836 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
841 if ( (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
846 PluginIoReConfigure (); /* EMIT SIGNAL */
849 // we don't know the analysis window size, so we must work with the
850 // current buffer size here. each request for data fills in these
851 // buffers and the analyser makes sure it gets enough data for the
853 session().ensure_buffer_set (_signal_analysis_inputs, in);
854 //_signal_analysis_inputs.set_count (in);
856 session().ensure_buffer_set (_signal_analysis_outputs, out);
857 //_signal_analysis_outputs.set_count (out);
859 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
861 return Processor::configure_io (in, out);
864 /** Decide whether this PluginInsert can support a given IO configuration.
865 * To do this, we run through a set of possible solutions in rough order of
868 * @param in Required input channel count.
869 * @param out Filled in with the output channel count if we return true.
870 * @return true if the given IO configuration can be supported.
873 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
875 return private_can_support_io_configuration (in, out).method != Impossible;
878 /** A private version of can_support_io_configuration which returns the method
879 * by which the configuration can be matched, rather than just whether or not
883 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
885 _strict_io_configured = false;
886 if (_plugins.empty()) {
890 PluginInfoPtr info = _plugins.front()->get_info();
891 ChanCount in; in += inx;
894 if (info->reconfigurable_io()) {
895 /* Plugin has flexible I/O, so delegate to it */
896 bool const r = _plugins.front()->can_support_io_configuration (in, out);
898 return Match (Impossible, 0);
901 if (_strict_io && in.n_audio() < out.n_audio()) {
902 DEBUG_TRACE (DEBUG::Processors, string_compose ("hiding output ports of reconfigurable %1\n", name()));
903 out.set (DataType::AUDIO, in.get (DataType::AUDIO));
906 return Match (Delegate, 1);
909 ChanCount inputs = info->n_inputs;
910 ChanCount outputs = info->n_outputs;
912 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
913 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
914 midi_bypass.set(DataType::MIDI, 1);
916 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
917 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
918 in.set(DataType::MIDI, 0);
921 bool no_inputs = true;
922 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
923 if (inputs.get (*t) != 0) {
929 /* replicate no-input generators with strict i/o */
930 if (no_inputs && _strict_io) {
932 bool can_replicate = true;
934 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
935 uint32_t nout = outputs.get (*t);
936 uint32_t nwant = in.get (*t);
938 can_replicate = false;
945 if (f == 0 && nwant % nout == 0) {
949 if (f * nout != nwant) {
950 can_replicate = false;
955 if (can_replicate && f > 1) {
956 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
957 out.set (*t, outputs.get(*t) * f);
960 return Match (Replicate, f);
964 if ((no_inputs || inputs == in) && _strict_io) {
965 /* special case synths and generators */
966 if (in.n_audio () == 0 && in.n_midi () > 0 && outputs.n_audio () > 0) {
967 // TODO limit the audio-channel count to track output
968 out = outputs + midi_bypass;
970 _strict_io_configured = true;
971 out = in + midi_bypass;
973 return Match (ExactMatch, 1);
977 /* no inputs so we can take any input configuration since we throw it away */
978 out = outputs + midi_bypass;
979 return Match (NoInputs, 1);
982 /* Plugin inputs match requested inputs exactly */
984 out = outputs + midi_bypass;
985 return Match (ExactMatch, 1);
988 /* We may be able to run more than one copy of the plugin within this insert
989 to cope with the insert having more inputs than the plugin.
990 We allow replication only for plugins with either zero or 1 inputs and outputs
991 for every valid data type.
995 bool can_replicate = true;
996 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
998 uint32_t nin = inputs.get (*t);
1000 // No inputs of this type
1001 if (nin == 0 && in.get(*t) == 0) {
1005 if (nin != 1 || outputs.get (*t) != 1) {
1006 can_replicate = false;
1010 // Potential factor not set yet
1012 f = in.get(*t) / nin;
1015 // Factor for this type does not match another type, can not replicate
1016 if (f != (in.get(*t) / nin)) {
1017 can_replicate = false;
1022 if (can_replicate) {
1024 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1025 out.set (*t, outputs.get(*t) * f);
1028 return Match (Replicate, f);
1031 /* If the processor has exactly one input of a given type, and
1032 the plugin has more, we can feed the single processor input
1033 to some or all of the plugin inputs. This is rather
1034 special-case-y, but the 1-to-many case is by far the
1035 simplest. How do I split thy 2 processor inputs to 3
1036 plugin inputs? Let me count the ways ...
1039 bool can_split = !_strict_io;
1040 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_split; ++t) {
1042 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
1043 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1045 if (!can_split_type && !nothing_to_do_for_type) {
1051 out = outputs + midi_bypass;
1052 return Match (Split, 1);
1055 /* If the plugin has more inputs than we want, we can `hide' some of them
1056 by feeding them silence.
1059 bool could_hide = false;
1060 bool cannot_hide = false;
1061 ChanCount hide_channels;
1063 for (DataType::iterator t = DataType::begin(); t != DataType::end() && !cannot_hide; ++t) {
1064 if (inputs.get(*t) > in.get(*t)) {
1065 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1066 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1068 } else if (inputs.get(*t) < in.get(*t)) {
1069 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1074 if (could_hide && !cannot_hide) {
1075 if (_strict_io /*&& inputs.get (DataType::AUDIO) == outputs.get (DataType::AUDIO)*/) {
1076 _strict_io_configured = true;
1079 out = outputs + midi_bypass;
1081 return Match (Hide, 1, hide_channels);
1084 midi_bypass.reset();
1085 return Match (Impossible, 0);
1089 PluginInsert::get_state ()
1091 return state (true);
1095 PluginInsert::state (bool full)
1097 XMLNode& node = Processor::state (full);
1099 node.add_property("type", _plugins[0]->state_node_name());
1100 node.add_property("unique-id", _plugins[0]->unique_id());
1101 node.add_property("count", string_compose("%1", _plugins.size()));
1103 /* remember actual i/o configuration (for later placeholder
1104 * in case the plugin goes missing) */
1105 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1106 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1108 _plugins[0]->set_insert_id(this->id());
1109 node.add_child_nocopy (_plugins[0]->get_state());
1111 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1112 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1114 node.add_child_nocopy (ac->get_state());
1122 PluginInsert::set_control_ids (const XMLNode& node, int version)
1124 const XMLNodeList& nlist = node.children();
1125 XMLNodeConstIterator iter;
1126 set<Evoral::Parameter>::const_iterator p;
1128 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1129 if ((*iter)->name() == Controllable::xml_node_name) {
1130 const XMLProperty* prop;
1132 uint32_t p = (uint32_t)-1;
1134 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1135 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1137 p = lv2plugin->port_index(prop->value().c_str());
1141 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1142 p = atoi (prop->value());
1145 if (p != (uint32_t)-1) {
1147 /* this may create the new controllable */
1149 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1151 #ifndef NO_PLUGIN_STATE
1155 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1157 ac->set_state (**iter, version);
1166 PluginInsert::set_state(const XMLNode& node, int version)
1168 XMLNodeList nlist = node.children();
1169 XMLNodeIterator niter;
1170 XMLPropertyList plist;
1171 const XMLProperty *prop;
1172 ARDOUR::PluginType type;
1174 if ((prop = node.property ("type")) == 0) {
1175 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1179 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1180 type = ARDOUR::LADSPA;
1181 } else if (prop->value() == X_("lv2")) {
1183 } else if (prop->value() == X_("windows-vst")) {
1184 type = ARDOUR::Windows_VST;
1185 } else if (prop->value() == X_("lxvst")) {
1186 type = ARDOUR::LXVST;
1187 } else if (prop->value() == X_("audiounit")) {
1188 type = ARDOUR::AudioUnit;
1189 } else if (prop->value() == X_("luaproc")) {
1192 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1198 prop = node.property ("unique-id");
1201 #ifdef WINDOWS_VST_SUPPORT
1202 /* older sessions contain VST plugins with only an "id" field.
1205 if (type == ARDOUR::Windows_VST) {
1206 prop = node.property ("id");
1210 #ifdef LXVST_SUPPORT
1211 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1213 if (type == ARDOUR::LXVST) {
1214 prop = node.property ("id");
1220 error << _("Plugin has no unique ID field") << endmsg;
1225 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1227 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1228 * allow to move sessions windows <> linux */
1229 #ifdef LXVST_SUPPORT
1230 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1231 type = ARDOUR::LXVST;
1232 plugin = find_plugin (_session, prop->value(), type);
1236 #ifdef WINDOWS_VST_SUPPORT
1237 if (plugin == 0 && type == ARDOUR::LXVST) {
1238 type = ARDOUR::Windows_VST;
1239 plugin = find_plugin (_session, prop->value(), type);
1244 error << string_compose(
1245 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1246 "Perhaps it was removed or moved since it was last used."),
1252 if (type == ARDOUR::Lua) {
1253 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1254 // we need to load the script to set the name and parameters.
1255 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1257 lp->set_script_from_state (*ls);
1261 // The name of the PluginInsert comes from the plugin, nothing else
1262 _name = plugin->get_info()->name;
1266 // Processor::set_state() will set this, but too late
1267 // for it to be available when setting up plugin
1268 // state. We can't call Processor::set_state() until
1269 // the plugins themselves are created and added.
1273 if (_plugins.empty()) {
1274 /* if we are adding the first plugin, we will need to set
1275 up automatable controls.
1277 add_plugin (plugin);
1278 create_automatable_parameters ();
1279 set_control_ids (node, version);
1282 if ((prop = node.property ("count")) != 0) {
1283 sscanf (prop->value().c_str(), "%u", &count);
1286 if (_plugins.size() != count) {
1287 for (uint32_t n = 1; n < count; ++n) {
1288 add_plugin (plugin_factory (plugin));
1292 Processor::set_state (node, version);
1294 PBD::ID new_id = this->id();
1295 PBD::ID old_id = this->id();
1297 if ((prop = node.property ("id")) != 0) {
1298 old_id = prop->value ();
1301 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1303 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1304 and set all plugins to the same state.
1307 if ((*niter)->name() == plugin->state_node_name()) {
1309 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1310 /* Plugin state can include external files which are named after the ID.
1312 * If regenerate_xml_or_string_ids() is set, the ID will already have
1313 * been changed, so we need to use the old ID from the XML to load the
1314 * state and then update the ID.
1316 * When copying a plugin-state, route_ui takes care of of updating the ID,
1317 * but we need to call set_insert_id() to clear the cached plugin-state
1318 * and force a change.
1320 if (!regenerate_xml_or_string_ids ()) {
1321 (*i)->set_insert_id (new_id);
1323 (*i)->set_insert_id (old_id);
1326 (*i)->set_state (**niter, version);
1328 if (regenerate_xml_or_string_ids ()) {
1329 (*i)->set_insert_id (new_id);
1337 if (version < 3000) {
1339 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1340 this is all handled by Automatable
1343 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1344 if ((*niter)->name() == "Redirect") {
1345 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1346 Processor::set_state (**niter, version);
1351 set_parameter_state_2X (node, version);
1354 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1358 (*i)->deactivate ();
1366 PluginInsert::update_id (PBD::ID id)
1369 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1370 (*i)->set_insert_id (id);
1375 PluginInsert::set_state_dir (const std::string& d)
1377 // state() only saves the state of the first plugin
1378 _plugins[0]->set_state_dir (d);
1382 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1384 XMLNodeList nlist = node.children();
1385 XMLNodeIterator niter;
1387 /* look for port automation node */
1389 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1391 if ((*niter)->name() != port_automation_node_name) {
1397 XMLNodeConstIterator iter;
1402 cnodes = (*niter)->children ("port");
1404 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1408 if ((cprop = child->property("number")) != 0) {
1409 port = cprop->value().c_str();
1411 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1415 sscanf (port, "%" PRIu32, &port_id);
1417 if (port_id >= _plugins[0]->parameter_count()) {
1418 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1422 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1423 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1425 if (c && c->alist()) {
1426 if (!child->children().empty()) {
1427 c->alist()->set_state (*child->children().front(), version);
1429 /* In some cases 2.X saves lists with min_yval and max_yval
1430 being FLT_MIN and FLT_MAX respectively. This causes problems
1431 in A3 because these min/max values are used to compute
1432 where GUI control points should be drawn. If we see such
1433 values, `correct' them to the min/max of the appropriate
1437 float min_y = c->alist()->get_min_y ();
1438 float max_y = c->alist()->get_max_y ();
1440 ParameterDescriptor desc;
1441 _plugins.front()->get_parameter_descriptor (port_id, desc);
1443 if (min_y == FLT_MIN) {
1447 if (max_y == FLT_MAX) {
1451 c->alist()->set_yrange (min_y, max_y);
1454 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1466 PluginInsert::describe_parameter (Evoral::Parameter param)
1468 if (param.type() == PluginAutomation) {
1469 return _plugins[0]->describe_parameter (param);
1470 } else if (param.type() == PluginPropertyAutomation) {
1471 boost::shared_ptr<AutomationControl> c(automation_control(param));
1472 if (c && !c->desc().label.empty()) {
1473 return c->desc().label;
1476 return Automatable::describe_parameter(param);
1480 PluginInsert::signal_latency() const
1482 if (_user_latency) {
1483 return _user_latency;
1486 return _plugins[0]->signal_latency ();
1490 PluginInsert::type ()
1492 return plugin()->get_info()->type;
1495 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1496 const Evoral::Parameter& param,
1497 const ParameterDescriptor& desc,
1498 boost::shared_ptr<AutomationList> list)
1499 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1503 alist()->reset_default (desc.normal);
1505 list->set_interpolation(Evoral::ControlList::Discrete);
1510 set_flags(Controllable::Toggle);
1514 /** @param val `user' value */
1516 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1519 _set_value (user_val, group_override);
1523 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1525 /* used only by automation playback */
1526 _set_value (user_val, Controllable::NoGroup);
1530 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1532 /* FIXME: probably should be taking out some lock here.. */
1534 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1535 (*i)->set_parameter (_list->parameter().id(), user_val);
1538 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1540 iasp->set_parameter (_list->parameter().id(), user_val);
1543 AutomationControl::set_value (user_val, group_override);
1547 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1549 AutomationControl::set_value (user_val, Controllable::NoGroup);
1553 PluginInsert::PluginControl::get_state ()
1557 XMLNode& node (AutomationControl::get_state());
1558 ss << parameter().id();
1559 node.add_property (X_("parameter"), ss.str());
1561 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1563 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1570 /** @return `user' val */
1572 PluginInsert::PluginControl::get_value () const
1574 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1580 return plugin->get_parameter (_list->parameter().id());
1583 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
1584 const Evoral::Parameter& param,
1585 const ParameterDescriptor& desc,
1586 boost::shared_ptr<AutomationList> list)
1587 : AutomationControl (p->session(), param, desc, list)
1591 alist()->set_yrange (desc.lower, desc.upper);
1592 alist()->reset_default (desc.normal);
1596 set_flags(Controllable::Toggle);
1601 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
1604 set_value_unchecked (user_val);
1609 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1611 /* Old numeric set_value(), coerce to appropriate datatype if possible.
1612 This is lossy, but better than nothing until Ardour's automation system
1613 can handle various datatypes all the way down. */
1614 const Variant value(_desc.datatype, user_val);
1615 if (value.type() == Variant::NOTHING) {
1616 error << "set_value(double) called for non-numeric property" << endmsg;
1620 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1621 (*i)->set_property(_list->parameter().id(), value);
1625 AutomationControl::set_value (user_val, Controllable::NoGroup);
1629 PluginInsert::PluginPropertyControl::get_state ()
1633 XMLNode& node (AutomationControl::get_state());
1634 ss << parameter().id();
1635 node.add_property (X_("property"), ss.str());
1636 node.remove_property (X_("value"));
1642 PluginInsert::PluginPropertyControl::get_value () const
1644 return _value.to_double();
1647 boost::shared_ptr<Plugin>
1648 PluginInsert::get_impulse_analysis_plugin()
1650 boost::shared_ptr<Plugin> ret;
1651 if (_impulseAnalysisPlugin.expired()) {
1652 ret = plugin_factory(_plugins[0]);
1653 ret->configure_io (input_streams (), output_streams ());
1654 _impulseAnalysisPlugin = ret;
1656 ret = _impulseAnalysisPlugin.lock();
1663 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1665 // called from outside the audio thread, so this should be safe
1666 // only do audio as analysis is (currently) only for audio plugins
1667 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1668 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1670 _signal_analysis_collected_nframes = 0;
1671 _signal_analysis_collect_nframes_max = nframes;
1674 /** Add a plugin to our list */
1676 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1678 plugin->set_insert_id (this->id());
1680 if (_plugins.empty()) {
1681 /* first (and probably only) plugin instance - connect to relevant signals
1684 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
1685 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1686 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1689 _plugins.push_back (plugin);
1693 PluginInsert::realtime_handle_transport_stopped ()
1695 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1696 (*i)->realtime_handle_transport_stopped ();
1701 PluginInsert::realtime_locate ()
1703 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1704 (*i)->realtime_locate ();
1709 PluginInsert::monitoring_changed ()
1711 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1712 (*i)->monitoring_changed ();
1717 PluginInsert::start_touch (uint32_t param_id)
1719 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1721 ac->start_touch (session().audible_frame());
1726 PluginInsert::end_touch (uint32_t param_id)
1728 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1730 ac->stop_touch (true, session().audible_frame());