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 /* set the matching method and number of plugins that we will use to meet this configuration */
792 _match = private_can_support_io_configuration (in, out);
793 if (set_count (_match.plugins) == false) {
794 PluginIoReConfigure (); /* EMIT SIGNAL */
798 /* configure plugins */
799 switch (_match.method) {
802 if (_plugins.front()->configure_io (_plugins.front()->get_info()->n_inputs, out) == false) {
803 PluginIoReConfigure (); /* EMIT SIGNAL */
809 if (_plugins.front()->configure_io (in, out) == false) {
810 PluginIoReConfigure (); /* EMIT SIGNAL */
816 // TODO make configurable
818 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
819 if (_match.method == Split) {
820 /* TODO see PluginInsert::connect_and_run, channel replication */
821 _in_map[pc] = ChanMapping (natural_input_streams ());
823 _in_map[pc] = ChanMapping (input_streams ());
825 _out_map[pc] = ChanMapping (output_streams());
827 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
828 _in_map[pc].offset_to(*t, pc * natural_input_streams().get(*t));
829 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
834 if ( (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
839 PluginIoReConfigure (); /* EMIT SIGNAL */
842 // we don't know the analysis window size, so we must work with the
843 // current buffer size here. each request for data fills in these
844 // buffers and the analyser makes sure it gets enough data for the
846 session().ensure_buffer_set (_signal_analysis_inputs, in);
847 //_signal_analysis_inputs.set_count (in);
849 session().ensure_buffer_set (_signal_analysis_outputs, out);
850 //_signal_analysis_outputs.set_count (out);
852 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
854 return Processor::configure_io (in, out);
857 /** Decide whether this PluginInsert can support a given IO configuration.
858 * To do this, we run through a set of possible solutions in rough order of
861 * @param in Required input channel count.
862 * @param out Filled in with the output channel count if we return true.
863 * @return true if the given IO configuration can be supported.
866 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
868 return private_can_support_io_configuration (in, out).method != Impossible;
871 /** A private version of can_support_io_configuration which returns the method
872 * by which the configuration can be matched, rather than just whether or not
876 PluginInsert::private_can_support_io_configuration (ChanCount const & inx, ChanCount& out)
878 _strict_io_configured = false;
879 if (_plugins.empty()) {
883 PluginInfoPtr info = _plugins.front()->get_info();
884 ChanCount in; in += inx;
887 if (info->reconfigurable_io()) {
888 /* Plugin has flexible I/O, so delegate to it */
889 bool const r = _plugins.front()->can_support_io_configuration (in, out);
891 return Match (Impossible, 0);
894 if (_strict_io && in.n_audio() < out.n_audio()) {
895 DEBUG_TRACE (DEBUG::Processors, string_compose ("hiding output ports of reconfigurable %1\n", name()));
896 out.set (DataType::AUDIO, in.get (DataType::AUDIO));
899 return Match (Delegate, 1);
902 ChanCount inputs = info->n_inputs;
903 ChanCount outputs = info->n_outputs;
905 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
906 DEBUG_TRACE ( DEBUG::Processors, string_compose ("bypassing midi-data around %1\n", name()));
907 midi_bypass.set(DataType::MIDI, 1);
909 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
910 DEBUG_TRACE ( DEBUG::Processors, string_compose ("hiding midi-port from plugin %1\n", name()));
911 in.set(DataType::MIDI, 0);
914 bool no_inputs = true;
915 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
916 if (inputs.get (*t) != 0) {
923 /* no inputs so we can take any input configuration since we throw it away */
924 out = outputs + midi_bypass;
925 return Match (NoInputs, 1);
928 /* Plugin inputs match requested inputs exactly */
929 if (inputs == in && (!_strict_io || outputs.n_audio() == inputs.n_audio())) {
930 out = outputs + midi_bypass;
931 return Match (ExactMatch, 1);
934 /* We may be able to run more than one copy of the plugin within this insert
935 to cope with the insert having more inputs than the plugin.
936 We allow replication only for plugins with either zero or 1 inputs and outputs
937 for every valid data type.
941 bool can_replicate = true;
942 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
944 uint32_t nin = inputs.get (*t);
946 // No inputs of this type
947 if (nin == 0 && in.get(*t) == 0) {
951 if (nin != 1 || outputs.get (*t) != 1) {
952 can_replicate = false;
956 // Potential factor not set yet
958 f = in.get(*t) / nin;
961 // Factor for this type does not match another type, can not replicate
962 if (f != (in.get(*t) / nin)) {
963 can_replicate = false;
969 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
970 out.set (*t, outputs.get(*t) * f);
973 return Match (Replicate, f);
976 /* If the processor has exactly one input of a given type, and
977 the plugin has more, we can feed the single processor input
978 to some or all of the plugin inputs. This is rather
979 special-case-y, but the 1-to-many case is by far the
980 simplest. How do I split thy 2 processor inputs to 3
981 plugin inputs? Let me count the ways ...
984 bool can_split = !_strict_io;
985 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
987 bool const can_split_type = (in.get (*t) == 1 && inputs.get (*t) > 1);
988 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
990 if (!can_split_type && !nothing_to_do_for_type) {
996 out = outputs + midi_bypass;
997 return Match (Split, 1);
1000 /* If the plugin has more inputs than we want, we can `hide' some of them
1001 by feeding them silence.
1004 bool could_hide = false;
1005 bool cannot_hide = false;
1006 ChanCount hide_channels;
1008 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1009 if (inputs.get(*t) > in.get(*t)) {
1010 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1011 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1013 } else if (inputs.get(*t) < in.get(*t)) {
1014 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1019 if (could_hide && !cannot_hide) {
1020 if (_strict_io /*&& inputs.get (DataType::AUDIO) == outputs.get (DataType::AUDIO)*/) {
1021 _strict_io_configured = true;
1024 out = outputs + midi_bypass;
1026 return Match (Hide, 1, hide_channels);
1029 midi_bypass.reset();
1030 return Match (Impossible, 0);
1034 PluginInsert::get_state ()
1036 return state (true);
1040 PluginInsert::state (bool full)
1042 XMLNode& node = Processor::state (full);
1044 node.add_property("type", _plugins[0]->state_node_name());
1045 node.add_property("unique-id", _plugins[0]->unique_id());
1046 node.add_property("count", string_compose("%1", _plugins.size()));
1048 /* remember actual i/o configuration (for later placeholder
1049 * in case the plugin goes missing) */
1050 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1051 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1053 _plugins[0]->set_insert_id(this->id());
1054 node.add_child_nocopy (_plugins[0]->get_state());
1056 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1057 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1059 node.add_child_nocopy (ac->get_state());
1067 PluginInsert::set_control_ids (const XMLNode& node, int version)
1069 const XMLNodeList& nlist = node.children();
1070 XMLNodeConstIterator iter;
1071 set<Evoral::Parameter>::const_iterator p;
1073 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1074 if ((*iter)->name() == Controllable::xml_node_name) {
1075 const XMLProperty* prop;
1077 uint32_t p = (uint32_t)-1;
1079 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1080 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1082 p = lv2plugin->port_index(prop->value().c_str());
1086 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1087 p = atoi (prop->value());
1090 if (p != (uint32_t)-1) {
1092 /* this may create the new controllable */
1094 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1096 #ifndef NO_PLUGIN_STATE
1100 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1102 ac->set_state (**iter, version);
1111 PluginInsert::set_state(const XMLNode& node, int version)
1113 XMLNodeList nlist = node.children();
1114 XMLNodeIterator niter;
1115 XMLPropertyList plist;
1116 const XMLProperty *prop;
1117 ARDOUR::PluginType type;
1119 if ((prop = node.property ("type")) == 0) {
1120 error << _("XML node describing plugin is missing the `type' field") << endmsg;
1124 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
1125 type = ARDOUR::LADSPA;
1126 } else if (prop->value() == X_("lv2")) {
1128 } else if (prop->value() == X_("windows-vst")) {
1129 type = ARDOUR::Windows_VST;
1130 } else if (prop->value() == X_("lxvst")) {
1131 type = ARDOUR::LXVST;
1132 } else if (prop->value() == X_("audiounit")) {
1133 type = ARDOUR::AudioUnit;
1134 } else if (prop->value() == X_("luaproc")) {
1137 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
1143 prop = node.property ("unique-id");
1146 #ifdef WINDOWS_VST_SUPPORT
1147 /* older sessions contain VST plugins with only an "id" field.
1150 if (type == ARDOUR::Windows_VST) {
1151 prop = node.property ("id");
1155 #ifdef LXVST_SUPPORT
1156 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
1158 if (type == ARDOUR::LXVST) {
1159 prop = node.property ("id");
1165 error << _("Plugin has no unique ID field") << endmsg;
1170 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
1172 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
1173 * allow to move sessions windows <> linux */
1174 #ifdef LXVST_SUPPORT
1175 if (plugin == 0 && type == ARDOUR::Windows_VST) {
1176 type = ARDOUR::LXVST;
1177 plugin = find_plugin (_session, prop->value(), type);
1181 #ifdef WINDOWS_VST_SUPPORT
1182 if (plugin == 0 && type == ARDOUR::LXVST) {
1183 type = ARDOUR::Windows_VST;
1184 plugin = find_plugin (_session, prop->value(), type);
1189 error << string_compose(
1190 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
1191 "Perhaps it was removed or moved since it was last used."),
1197 if (type == ARDOUR::Lua) {
1198 XMLNode *ls = node.child (plugin->state_node_name().c_str());
1199 // we need to load the script to set the name and parameters.
1200 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
1202 lp->set_script_from_state (*ls);
1206 // The name of the PluginInsert comes from the plugin, nothing else
1207 _name = plugin->get_info()->name;
1211 // Processor::set_state() will set this, but too late
1212 // for it to be available when setting up plugin
1213 // state. We can't call Processor::set_state() until
1214 // the plugins themselves are created and added.
1218 if (_plugins.empty()) {
1219 /* if we are adding the first plugin, we will need to set
1220 up automatable controls.
1222 add_plugin (plugin);
1223 create_automatable_parameters ();
1224 set_control_ids (node, version);
1227 if ((prop = node.property ("count")) != 0) {
1228 sscanf (prop->value().c_str(), "%u", &count);
1231 if (_plugins.size() != count) {
1232 for (uint32_t n = 1; n < count; ++n) {
1233 add_plugin (plugin_factory (plugin));
1237 Processor::set_state (node, version);
1239 PBD::ID new_id = this->id();
1240 PBD::ID old_id = this->id();
1242 if ((prop = node.property ("id")) != 0) {
1243 old_id = prop->value ();
1246 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1248 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
1249 and set all plugins to the same state.
1252 if ((*niter)->name() == plugin->state_node_name()) {
1254 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1255 /* Plugin state can include external files which are named after the ID.
1257 * If regenerate_xml_or_string_ids() is set, the ID will already have
1258 * been changed, so we need to use the old ID from the XML to load the
1259 * state and then update the ID.
1261 * When copying a plugin-state, route_ui takes care of of updating the ID,
1262 * but we need to call set_insert_id() to clear the cached plugin-state
1263 * and force a change.
1265 if (!regenerate_xml_or_string_ids ()) {
1266 (*i)->set_insert_id (new_id);
1268 (*i)->set_insert_id (old_id);
1271 (*i)->set_state (**niter, version);
1273 if (regenerate_xml_or_string_ids ()) {
1274 (*i)->set_insert_id (new_id);
1282 if (version < 3000) {
1284 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
1285 this is all handled by Automatable
1288 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1289 if ((*niter)->name() == "Redirect") {
1290 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
1291 Processor::set_state (**niter, version);
1296 set_parameter_state_2X (node, version);
1299 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1303 (*i)->deactivate ();
1311 PluginInsert::update_id (PBD::ID id)
1314 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1315 (*i)->set_insert_id (id);
1320 PluginInsert::set_state_dir (const std::string& d)
1322 // state() only saves the state of the first plugin
1323 _plugins[0]->set_state_dir (d);
1327 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
1329 XMLNodeList nlist = node.children();
1330 XMLNodeIterator niter;
1332 /* look for port automation node */
1334 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1336 if ((*niter)->name() != port_automation_node_name) {
1342 XMLNodeConstIterator iter;
1347 cnodes = (*niter)->children ("port");
1349 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
1353 if ((cprop = child->property("number")) != 0) {
1354 port = cprop->value().c_str();
1356 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
1360 sscanf (port, "%" PRIu32, &port_id);
1362 if (port_id >= _plugins[0]->parameter_count()) {
1363 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
1367 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
1368 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
1370 if (c && c->alist()) {
1371 if (!child->children().empty()) {
1372 c->alist()->set_state (*child->children().front(), version);
1374 /* In some cases 2.X saves lists with min_yval and max_yval
1375 being FLT_MIN and FLT_MAX respectively. This causes problems
1376 in A3 because these min/max values are used to compute
1377 where GUI control points should be drawn. If we see such
1378 values, `correct' them to the min/max of the appropriate
1382 float min_y = c->alist()->get_min_y ();
1383 float max_y = c->alist()->get_max_y ();
1385 ParameterDescriptor desc;
1386 _plugins.front()->get_parameter_descriptor (port_id, desc);
1388 if (min_y == FLT_MIN) {
1392 if (max_y == FLT_MAX) {
1396 c->alist()->set_yrange (min_y, max_y);
1399 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
1411 PluginInsert::describe_parameter (Evoral::Parameter param)
1413 if (param.type() == PluginAutomation) {
1414 return _plugins[0]->describe_parameter (param);
1415 } else if (param.type() == PluginPropertyAutomation) {
1416 boost::shared_ptr<AutomationControl> c(automation_control(param));
1417 if (c && !c->desc().label.empty()) {
1418 return c->desc().label;
1421 return Automatable::describe_parameter(param);
1425 PluginInsert::signal_latency() const
1427 if (_user_latency) {
1428 return _user_latency;
1431 return _plugins[0]->signal_latency ();
1435 PluginInsert::type ()
1437 return plugin()->get_info()->type;
1440 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
1441 const Evoral::Parameter& param,
1442 const ParameterDescriptor& desc,
1443 boost::shared_ptr<AutomationList> list)
1444 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
1448 alist()->reset_default (desc.normal);
1450 list->set_interpolation(Evoral::ControlList::Discrete);
1455 set_flags(Controllable::Toggle);
1459 /** @param val `user' value */
1461 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1464 _set_value (user_val, group_override);
1468 PluginInsert::PluginControl::set_value_unchecked (double user_val)
1470 /* used only by automation playback */
1471 _set_value (user_val, Controllable::NoGroup);
1475 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
1477 /* FIXME: probably should be taking out some lock here.. */
1479 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1480 (*i)->set_parameter (_list->parameter().id(), user_val);
1483 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
1485 iasp->set_parameter (_list->parameter().id(), user_val);
1488 AutomationControl::set_value (user_val, group_override);
1492 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
1494 AutomationControl::set_value (user_val, Controllable::NoGroup);
1498 PluginInsert::PluginControl::get_state ()
1502 XMLNode& node (AutomationControl::get_state());
1503 ss << parameter().id();
1504 node.add_property (X_("parameter"), ss.str());
1506 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
1508 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
1515 /** @return `user' val */
1517 PluginInsert::PluginControl::get_value () const
1519 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
1525 return plugin->get_parameter (_list->parameter().id());
1528 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
1529 const Evoral::Parameter& param,
1530 const ParameterDescriptor& desc,
1531 boost::shared_ptr<AutomationList> list)
1532 : AutomationControl (p->session(), param, desc, list)
1536 alist()->set_yrange (desc.lower, desc.upper);
1537 alist()->reset_default (desc.normal);
1541 set_flags(Controllable::Toggle);
1546 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
1549 set_value_unchecked (user_val);
1554 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
1556 /* Old numeric set_value(), coerce to appropriate datatype if possible.
1557 This is lossy, but better than nothing until Ardour's automation system
1558 can handle various datatypes all the way down. */
1559 const Variant value(_desc.datatype, user_val);
1560 if (value.type() == Variant::NOTHING) {
1561 error << "set_value(double) called for non-numeric property" << endmsg;
1565 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
1566 (*i)->set_property(_list->parameter().id(), value);
1570 AutomationControl::set_value (user_val, Controllable::NoGroup);
1574 PluginInsert::PluginPropertyControl::get_state ()
1578 XMLNode& node (AutomationControl::get_state());
1579 ss << parameter().id();
1580 node.add_property (X_("property"), ss.str());
1581 node.remove_property (X_("value"));
1587 PluginInsert::PluginPropertyControl::get_value () const
1589 return _value.to_double();
1592 boost::shared_ptr<Plugin>
1593 PluginInsert::get_impulse_analysis_plugin()
1595 boost::shared_ptr<Plugin> ret;
1596 if (_impulseAnalysisPlugin.expired()) {
1597 ret = plugin_factory(_plugins[0]);
1598 ret->configure_io (input_streams (), output_streams ());
1599 _impulseAnalysisPlugin = ret;
1601 ret = _impulseAnalysisPlugin.lock();
1608 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
1610 // called from outside the audio thread, so this should be safe
1611 // only do audio as analysis is (currently) only for audio plugins
1612 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, input_streams().n_audio(), nframes);
1613 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, output_streams().n_audio(), nframes);
1615 _signal_analysis_collected_nframes = 0;
1616 _signal_analysis_collect_nframes_max = nframes;
1619 /** Add a plugin to our list */
1621 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
1623 plugin->set_insert_id (this->id());
1625 if (_plugins.empty()) {
1626 /* first (and probably only) plugin instance - connect to relevant signals
1629 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
1630 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
1631 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
1634 _plugins.push_back (plugin);
1638 PluginInsert::realtime_handle_transport_stopped ()
1640 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1641 (*i)->realtime_handle_transport_stopped ();
1646 PluginInsert::realtime_locate ()
1648 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1649 (*i)->realtime_locate ();
1654 PluginInsert::monitoring_changed ()
1656 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
1657 (*i)->monitoring_changed ();
1662 PluginInsert::start_touch (uint32_t param_id)
1664 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1666 ac->start_touch (session().audible_frame());
1671 PluginInsert::end_touch (uint32_t param_id)
1673 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
1675 ac->stop_touch (true, session().audible_frame());