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"
39 #include "ardour/port.h"
42 #include "ardour/lv2_plugin.h"
45 #ifdef WINDOWS_VST_SUPPORT
46 #include "ardour/windows_vst_plugin.h"
50 #include "ardour/lxvst_plugin.h"
53 #ifdef AUDIOUNIT_SUPPORT
54 #include "ardour/audio_unit.h"
57 #include "ardour/session.h"
58 #include "ardour/types.h"
63 using namespace ARDOUR;
66 const string PluginInsert::port_automation_node_name = "PortAutomation";
68 PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug)
69 : Processor (s, (plug ? plug->name() : string ("toBeRenamed")))
70 , _signal_analysis_collected_nframes(0)
71 , _signal_analysis_collect_nframes_max(0)
76 , _maps_from_state (false)
78 /* the first is the master */
82 create_automatable_parameters ();
83 const ChanCount& sc (sidechain_input_pins ());
84 if (sc.n_audio () > 0) {
85 add_sidechain (sc.n_audio ());
90 PluginInsert::~PluginInsert ()
95 PluginInsert::set_strict_io (bool b)
97 bool changed = _strict_io != b;
100 PluginConfigChanged (); /* EMIT SIGNAL */
105 PluginInsert::set_count (uint32_t num)
107 bool require_state = !_plugins.empty();
109 /* this is a bad idea.... we shouldn't do this while active.
110 only a route holding their redirect_lock should be calling this
115 } else if (num > _plugins.size()) {
116 uint32_t diff = num - _plugins.size();
118 for (uint32_t n = 0; n < diff; ++n) {
119 boost::shared_ptr<Plugin> p = plugin_factory (_plugins[0]);
123 XMLNode& state = _plugins[0]->get_state ();
124 p->set_state (state, Stateful::loading_state_version);
131 PluginConfigChanged (); /* EMIT SIGNAL */
133 } else if (num < _plugins.size()) {
134 uint32_t diff = _plugins.size() - num;
135 for (uint32_t n= 0; n < diff; ++n) {
138 PluginConfigChanged (); /* EMIT SIGNAL */
146 PluginInsert::set_outputs (const ChanCount& c)
148 bool changed = (_custom_out != c) && _custom_cfg;
151 PluginConfigChanged (); /* EMIT SIGNAL */
156 PluginInsert::set_custom_cfg (bool b)
158 bool changed = _custom_cfg != b;
161 PluginConfigChanged (); /* EMIT SIGNAL */
166 PluginInsert::set_preset_out (const ChanCount& c)
168 bool changed = _preset_out != c;
170 if (changed && !_custom_cfg) {
171 PluginConfigChanged (); /* EMIT SIGNAL */
177 PluginInsert::add_sidechain (uint32_t n_audio)
179 // caller must hold process lock
183 std::ostringstream n;
185 n << "Sidechain " << Session::next_name_id ();
187 n << "TO BE RESET FROM XML";
189 SideChain *sc = new SideChain (_session, n.str ());
190 _sidechain = boost::shared_ptr<SideChain> (sc);
191 _sidechain->activate ();
192 for (uint32_t n = 0; n < n_audio; ++n) {
193 _sidechain->input()->add_port ("", owner()); // add a port, don't connect.
195 PluginConfigChanged (); /* EMIT SIGNAL */
200 PluginInsert::del_sidechain ()
206 PluginConfigChanged (); /* EMIT SIGNAL */
211 PluginInsert::control_list_automation_state_changed (Evoral::Parameter which, AutoState s)
213 if (which.type() != PluginAutomation)
216 boost::shared_ptr<AutomationControl> c
217 = boost::dynamic_pointer_cast<AutomationControl>(control (which));
220 _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
225 PluginInsert::output_streams() const
227 assert (_configured);
228 return _configured_out;
232 PluginInsert::input_streams() const
234 assert (_configured);
235 return _configured_in;
239 PluginInsert::internal_streams() const
241 assert (_configured);
242 return _configured_internal;
246 PluginInsert::internal_output_streams() const
248 assert (!_plugins.empty());
250 PluginInfoPtr info = _plugins.front()->get_info();
252 if (info->reconfigurable_io()) {
253 ChanCount out = _plugins.front()->output_streams ();
254 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, reconfigur(able) output streams = %1\n", out));
257 ChanCount out = info->n_outputs;
258 // DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, static output streams = %1 for %2 plugins\n", out, _plugins.size()));
259 out.set_audio (out.n_audio() * _plugins.size());
260 out.set_midi (out.n_midi() * _plugins.size());
266 PluginInsert::internal_input_streams() const
268 assert (!_plugins.empty());
272 PluginInfoPtr info = _plugins.front()->get_info();
274 if (info->reconfigurable_io()) {
275 in = _plugins.front()->input_streams();
280 DEBUG_TRACE (DEBUG::Processors, string_compose ("Plugin insert, input streams = %1, match using %2\n", in, _match.method));
282 if (_match.method == Split) {
284 /* we are splitting 1 processor input to multiple plugin inputs,
285 so we have a maximum of 1 stream of each type.
287 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
288 if (in.get (*t) > 1) {
294 } else if (_match.method == Hide) {
296 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
297 in.set (*t, in.get (*t) - _match.hide.get (*t));
303 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
304 in.set (*t, in.get (*t) * _plugins.size ());
312 PluginInsert::natural_output_streams() const
315 if (is_channelstrip ()) {
316 return ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2));
319 return _plugins[0]->get_info()->n_outputs;
323 PluginInsert::natural_input_streams() const
326 if (is_channelstrip ()) {
327 return ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2));
330 return _plugins[0]->get_info()->n_inputs;
334 PluginInsert::sidechain_input_pins() const
336 return _cached_sidechain_pins;
340 PluginInsert::has_no_inputs() const
342 return _plugins[0]->get_info()->n_inputs == ChanCount::ZERO;
346 PluginInsert::has_no_audio_inputs() const
348 return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
352 PluginInsert::plugin_latency () const {
353 return _plugins.front()->signal_latency ();
357 PluginInsert::needs_midi_input() const
359 PluginInfoPtr pip = _plugins[0]->get_info();
360 if (pip->needs_midi_input ()) {
363 return pip->n_inputs.n_midi() != 0 && pip->n_outputs.n_audio() != 0;
367 PluginInsert::create_automatable_parameters ()
369 assert (!_plugins.empty());
371 set<Evoral::Parameter> a = _plugins.front()->automatable ();
373 for (set<Evoral::Parameter>::iterator i = a.begin(); i != a.end(); ++i) {
374 if (i->type() == PluginAutomation) {
376 Evoral::Parameter param(*i);
378 ParameterDescriptor desc;
379 _plugins.front()->get_parameter_descriptor(i->id(), desc);
381 can_automate (param);
382 boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
383 boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
385 _plugins.front()->set_automation_control (i->id(), c);
386 } else if (i->type() == PluginPropertyAutomation) {
387 Evoral::Parameter param(*i);
388 const ParameterDescriptor& desc = _plugins.front()->get_property_descriptor(param.id());
389 if (desc.datatype != Variant::NOTHING) {
390 boost::shared_ptr<AutomationList> list;
391 if (Variant::type_is_numeric(desc.datatype)) {
392 list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
394 add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
399 /** Called when something outside of this host has modified a plugin
400 * parameter. Responsible for propagating the change to two places:
402 * 1) anything listening to the Control itself
403 * 2) any replicated plugins that make up this PluginInsert.
405 * The PluginInsert is connected to the ParameterChangedExternally signal for
406 * the first (primary) plugin, and here broadcasts that change to any others.
408 * XXX We should probably drop this whole replication idea (Paul, October 2015)
409 * since it isn't used by sensible plugin APIs (AU, LV2).
412 PluginInsert::parameter_changed_externally (uint32_t which, float val)
414 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, which));
416 /* First propagation: alter the underlying value of the control,
417 * without telling the plugin(s) that own/use it to set it.
424 boost::shared_ptr<PluginControl> pc = boost::dynamic_pointer_cast<PluginControl> (ac);
427 pc->catch_up_with_external_value (val);
430 /* Second propagation: tell all plugins except the first to
431 update the value of this parameter. For sane plugin APIs,
432 there are no other plugins, so this is a no-op in those
436 Plugins::iterator i = _plugins.begin();
438 /* don't set the first plugin, just all the slaves */
440 if (i != _plugins.end()) {
442 for (; i != _plugins.end(); ++i) {
443 (*i)->set_parameter (which, val);
449 PluginInsert::set_block_size (pframes_t nframes)
452 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
453 if ((*i)->set_block_size (nframes) != 0) {
461 PluginInsert::activate ()
463 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
467 Processor::activate ();
471 PluginInsert::deactivate ()
473 Processor::deactivate ();
475 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
481 PluginInsert::flush ()
483 for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
489 PluginInsert::connect_and_run (BufferSet& bufs, pframes_t nframes, framecnt_t offset, bool with_auto, framepos_t now)
491 // TODO: atomically copy maps & _no_inplace
492 PinMappings in_map (_in_map);
493 PinMappings out_map (_out_map);
494 ChanMapping thru_map (_thru_map);
495 if (_mapping_changed) { // ToDo use a counters, increment until match.
496 _no_inplace = check_inplace ();
497 _mapping_changed = false;
500 if (_latency_changed) {
501 /* delaylines are configured with the max possible latency (as reported by the plugin)
502 * so this won't allocate memory (unless the plugin lied about its max latency)
503 * It may still 'click' though, since the fixed delaylines are not de-clicked.
504 * Then again plugin-latency changes are not click-free to begin with.
506 * This is also worst case, there is currently no concept of per-stream latency.
508 * e.g. Two identical latent plugins:
509 * 1st plugin: process left (latent), bypass right.
510 * 2nd plugin: bypass left, process right (latent).
511 * -> currently this yields 2 times latency of the plugin,
513 _latency_changed = false;
514 _delaybuffers.set (ChanCount::max(bufs.count(), _configured_out), plugin_latency ());
517 if (_match.method == Split && !_no_inplace) {
518 // TODO: also use this optimization if one source-buffer
519 // feeds _all_ *connected* inputs.
520 // currently this is *first* buffer to all only --
521 // see PluginInsert::check_inplace
522 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
523 if (_configured_internal.get (*t) == 0) {
527 uint32_t first_idx = in_map[0].get (*t, 0, &valid);
528 assert (valid && first_idx == 0); // check_inplace ensures this
529 /* copy the first stream's buffer contents to the others */
530 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
531 uint32_t idx = in_map[0].get (*t, i, &valid);
534 bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
538 /* the copy operation produces a linear monotonic input map */
539 in_map[0] = ChanMapping (natural_input_streams ());
542 bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
543 bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
549 for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
551 boost::shared_ptr<AutomationControl> c
552 = boost::dynamic_pointer_cast<AutomationControl>(li->second);
554 if (c->list() && c->automation_playback()) {
557 const float val = c->list()->rt_safe_eval (now, valid);
560 /* This is the ONLY place where we are
562 * AutomationControl::set_value_unchecked(). We
563 * know that the control is in
564 * automation playback mode, so no
565 * check on writable() is required
566 * (which must be done in AutomationControl::set_value()
569 c->set_value_unchecked(val);
576 /* Calculate if, and how many frames we need to collect for analysis */
577 framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
578 _signal_analysis_collected_nframes);
579 if (nframes < collect_signal_nframes) { // we might not get all frames now
580 collect_signal_nframes = nframes;
583 if (collect_signal_nframes > 0) {
585 //std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
586 //std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
587 //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
589 _signal_analysis_inputs.set_count(internal_input_streams());
591 for (uint32_t i = 0; i < internal_input_streams().n_audio(); ++i) {
592 _signal_analysis_inputs.get_audio(i).read_from(
594 collect_signal_nframes,
595 _signal_analysis_collected_nframes); // offset is for target buffer
600 if (is_channelstrip ()) {
601 if (_configured_in.n_audio() > 0) {
602 ChanMapping mb_in_map (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
603 ChanMapping mb_out_map (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
605 _plugins.front()->connect_and_run (bufs, mb_in_map, mb_out_map, nframes, offset);
607 for (uint32_t out = _configured_in.n_audio (); out < bufs.count().get (DataType::AUDIO); ++out) {
608 bufs.get (DataType::AUDIO, out).silence (nframes, offset);
614 // TODO optimize -- build maps once.
616 BufferSet& inplace_bufs = _session.get_noinplace_buffers();
617 ARDOUR::ChanMapping used_outputs;
619 assert (inplace_bufs.count () >= natural_input_streams () + _configured_out);
621 /* build used-output map */
622 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
623 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
624 for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
626 uint32_t out_idx = out_map[pc].get (*t, out, &valid);
628 used_outputs.set (*t, out_idx, 1); // mark as used
633 /* copy thru data to outputs before processing in-place */
634 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
635 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
637 uint32_t in_idx = thru_map.get (*t, out, &valid);
639 uint32_t m = out + natural_input_streams ().get (*t);
640 _delaybuffers.delay (*t, out, inplace_bufs.get (*t, m), bufs.get (*t, in_idx), nframes, offset, offset);
641 used_outputs.set (*t, out, 1); // mark as used
647 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
649 ARDOUR::ChanMapping i_in_map (natural_input_streams());
650 ARDOUR::ChanMapping i_out_map (out_map[pc]);
651 ARDOUR::ChanCount mapped;
653 /* map inputs sequentially */
654 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
655 for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
657 uint32_t in_idx = in_map[pc].get (*t, in, &valid);
658 uint32_t m = mapped.get (*t);
660 inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
662 inplace_bufs.get (*t, m).silence (nframes, offset);
664 mapped.set (*t, m + 1);
668 /* outputs are mapped to inplace_bufs after the inputs */
669 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
670 i_out_map.offset_to (*t, natural_input_streams ().get (*t));
673 if ((*i)->connect_and_run (inplace_bufs, i_in_map, i_out_map, nframes, offset)) {
678 /* all instances have completed, now copy data that was written
679 * and zero unconnected buffers */
680 ARDOUR::ChanMapping nonzero_out (used_outputs);
681 if (has_midi_bypass ()) {
682 nonzero_out.set (DataType::MIDI, 0, 1); // Midi bypass.
684 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
685 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
687 used_outputs.get (*t, out, &valid);
689 nonzero_out.get (*t, out, &valid);
691 bufs.get (*t, out).silence (nframes, offset);
694 uint32_t m = out + natural_input_streams ().get (*t);
695 bufs.get (*t, out).read_from (inplace_bufs.get (*t, m), nframes, offset, offset);
700 /* in-place processing */
702 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
703 if ((*i)->connect_and_run(bufs, in_map[pc], out_map[pc], nframes, offset)) {
708 // TODO optimize: store "unconnected" in a fixed set.
709 // it only changes on reconfiguration.
710 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
711 for (uint32_t out = 0; out < bufs.count().get (*t); ++out) {
713 if (*t == DataType::MIDI && out == 0 && has_midi_bypass ()) {
714 mapped = true; // in-place Midi bypass
716 for (uint32_t pc = 0; pc < get_count() && !mapped; ++pc) {
717 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
719 uint32_t idx = out_map[pc].get (*t, o, &valid);
720 if (valid && idx == out) {
727 bufs.get (*t, out).silence (nframes, offset);
733 if (collect_signal_nframes > 0) {
735 //std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
736 //std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
738 _signal_analysis_outputs.set_count(internal_output_streams());
740 for (uint32_t i = 0; i < internal_output_streams().n_audio(); ++i) {
741 _signal_analysis_outputs.get_audio(i).read_from(
743 collect_signal_nframes,
744 _signal_analysis_collected_nframes); // offset is for target buffer
747 _signal_analysis_collected_nframes += collect_signal_nframes;
748 assert(_signal_analysis_collected_nframes <= _signal_analysis_collect_nframes_max);
750 if (_signal_analysis_collected_nframes == _signal_analysis_collect_nframes_max) {
751 _signal_analysis_collect_nframes_max = 0;
752 _signal_analysis_collected_nframes = 0;
754 AnalysisDataGathered(&_signal_analysis_inputs,
755 &_signal_analysis_outputs);
761 PluginInsert::silence (framecnt_t nframes)
767 _delaybuffers.flush ();
769 ChanMapping in_map (natural_input_streams ());
770 ChanMapping out_map (natural_output_streams ());
771 ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
773 if (is_channelstrip ()) {
774 if (_configured_in.n_audio() > 0) {
775 _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), in_map, out_map, nframes, 0);
779 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
780 (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), in_map, out_map, nframes, 0);
785 PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool)
787 if (_pending_active) {
788 /* run as normal if we are active or moving from inactive to active */
791 // collect sidechain input for complete cycle (!)
792 // TODO we need delaylines here for latency compensation
793 _sidechain->run (bufs, start_frame, end_frame, nframes, true);
796 if (_session.transport_rolling() || _session.bounce_processing()) {
797 automation_run (bufs, start_frame, nframes);
799 connect_and_run (bufs, nframes, 0, false);
803 // TODO use mapping in bypassed mode ?!
804 // -> do we bypass the processor or the plugin
806 // TODO include sidechain??
808 uint32_t in = input_streams ().n_audio ();
809 uint32_t out = output_streams().n_audio ();
811 if (has_no_audio_inputs() || in == 0) {
813 /* silence all (audio) outputs. Should really declick
814 * at the transitions of "active"
817 for (uint32_t n = 0; n < out; ++n) {
818 bufs.get_audio (n).silence (nframes);
821 } else if (out > in) {
823 /* not active, but something has make up for any channel count increase
824 * for now , simply replicate last buffer
826 for (uint32_t n = in; n < out; ++n) {
827 bufs.get_audio(n).read_from(bufs.get_audio(in - 1), nframes);
831 bufs.count().set_audio (out);
834 _active = _pending_active;
836 /* we have no idea whether the plugin generated silence or not, so mark
837 * all buffers appropriately.
842 PluginInsert::automation_run (BufferSet& bufs, framepos_t start, pframes_t nframes)
844 Evoral::ControlEvent next_event (0, 0.0f);
845 framepos_t now = start;
846 framepos_t end = now + nframes;
847 framecnt_t offset = 0;
849 Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
852 connect_and_run (bufs, nframes, offset, false);
856 if (!find_next_event (now, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
858 /* no events have a time within the relevant range */
860 connect_and_run (bufs, nframes, offset, true, now);
866 framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - now), (framecnt_t) nframes);
868 connect_and_run (bufs, cnt, offset, true, now);
874 if (!find_next_event (now, end, next_event)) {
879 /* cleanup anything that is left to do */
882 connect_and_run (bufs, nframes, offset, true, now);
887 PluginInsert::default_parameter_value (const Evoral::Parameter& param)
889 if (param.type() != PluginAutomation)
892 if (_plugins.empty()) {
893 fatal << _("programming error: ") << X_("PluginInsert::default_parameter_value() called with no plugin")
895 abort(); /*NOTREACHED*/
898 return _plugins[0]->default_value (param.id());
903 PluginInsert::can_reset_all_parameters ()
907 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
909 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
911 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
915 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
921 if (ac->automation_state() & Play) {
926 return all && (params > 0);
930 PluginInsert::reset_parameters_to_default ()
934 for (uint32_t par = 0; par < _plugins[0]->parameter_count(); ++par) {
936 const uint32_t cid = _plugins[0]->nth_parameter (par, ok);
938 if (!ok || !_plugins[0]->parameter_is_input(cid)) {
942 const float dflt = _plugins[0]->default_value (cid);
943 const float curr = _plugins[0]->get_parameter (cid);
949 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter(PluginAutomation, 0, cid));
954 if (ac->automation_state() & Play) {
959 ac->set_value (dflt, Controllable::NoGroup);
964 boost::shared_ptr<Plugin>
965 PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
967 boost::shared_ptr<LadspaPlugin> lp;
968 boost::shared_ptr<LuaProc> lua;
970 boost::shared_ptr<LV2Plugin> lv2p;
972 #ifdef WINDOWS_VST_SUPPORT
973 boost::shared_ptr<WindowsVSTPlugin> vp;
976 boost::shared_ptr<LXVSTPlugin> lxvp;
978 #ifdef AUDIOUNIT_SUPPORT
979 boost::shared_ptr<AUPlugin> ap;
982 if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
983 return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
984 } else if ((lua = boost::dynamic_pointer_cast<LuaProc> (other)) != 0) {
985 return boost::shared_ptr<Plugin> (new LuaProc (*lua));
987 } else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
988 return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
990 #ifdef WINDOWS_VST_SUPPORT
991 } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
992 return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
995 } else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
996 return boost::shared_ptr<Plugin> (new LXVSTPlugin (*lxvp));
998 #ifdef AUDIOUNIT_SUPPORT
999 } else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
1000 return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
1004 fatal << string_compose (_("programming error: %1"),
1005 X_("unknown plugin type in PluginInsert::plugin_factory"))
1007 abort(); /*NOTREACHED*/
1008 return boost::shared_ptr<Plugin> ((Plugin*) 0);
1012 PluginInsert::set_input_map (uint32_t num, ChanMapping m) {
1013 if (num < _in_map.size()) {
1014 bool changed = _in_map[num] != m;
1016 changed |= sanitize_maps ();
1018 PluginMapChanged (); /* EMIT SIGNAL */
1019 _mapping_changed = true;
1020 _session.set_dirty();
1026 PluginInsert::set_output_map (uint32_t num, ChanMapping m) {
1027 if (num < _out_map.size()) {
1028 bool changed = _out_map[num] != m;
1030 changed |= sanitize_maps ();
1032 PluginMapChanged (); /* EMIT SIGNAL */
1033 _mapping_changed = true;
1034 _session.set_dirty();
1040 PluginInsert::set_thru_map (ChanMapping m) {
1041 bool changed = _thru_map != m;
1043 changed |= sanitize_maps ();
1045 PluginMapChanged (); /* EMIT SIGNAL */
1046 _mapping_changed = true;
1047 _session.set_dirty();
1052 PluginInsert::input_map () const
1056 for (PinMappings::const_iterator i = _in_map.begin (); i != _in_map.end (); ++i, ++pc) {
1057 ChanMapping m (i->second);
1058 const ChanMapping::Mappings& mp ((*i).second.mappings());
1059 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1060 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1061 rv.set (tm->first, i->first + pc * natural_input_streams().get(tm->first), i->second);
1069 PluginInsert::output_map () const
1073 for (PinMappings::const_iterator i = _out_map.begin (); i != _out_map.end (); ++i, ++pc) {
1074 ChanMapping m (i->second);
1075 const ChanMapping::Mappings& mp ((*i).second.mappings());
1076 for (ChanMapping::Mappings::const_iterator tm = mp.begin(); tm != mp.end(); ++tm) {
1077 for (ChanMapping::TypeMapping::const_iterator i = tm->second.begin(); i != tm->second.end(); ++i) {
1078 rv.set (tm->first, i->first + pc * natural_output_streams().get(tm->first), i->second);
1082 if (has_midi_bypass ()) {
1083 rv.set (DataType::MIDI, 0, 0);
1090 PluginInsert::has_midi_bypass () const
1092 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1093 && natural_output_streams ().n_midi () == 0) {
1100 PluginInsert::has_midi_thru () const
1102 if (_configured_in.n_midi () == 1 && _configured_out.n_midi () == 1
1103 && natural_input_streams ().n_midi () == 0 && natural_output_streams ().n_midi () == 0) {
1111 PluginInsert::is_channelstrip () const {
1112 return _plugins.front()->is_channelstrip();
1117 PluginInsert::check_inplace ()
1119 bool inplace_ok = !_plugins.front()->inplace_broken ();
1121 if (_thru_map.n_total () > 0) {
1122 // TODO once midi-bypass is part of the mapping, ignore it
1126 if (_match.method == Split && inplace_ok) {
1127 assert (get_count() == 1);
1128 assert (_in_map.size () == 1);
1129 if (!_out_map[0].is_monotonic ()) {
1132 if (_configured_internal != _configured_in) {
1133 /* no sidechain -- TODO we could allow this with
1134 * some more logic in PluginInsert::connect_and_run().
1136 * PluginInsert::reset_map() already maps it.
1141 for (DataType::iterator t = DataType::begin(); t != DataType::end() && inplace_ok; ++t) {
1142 if (_configured_internal.get (*t) == 0) {
1146 uint32_t first_idx = _in_map[0].get (*t, 0, &valid);
1147 if (!valid || first_idx != 0) {
1148 // so far only allow to copy the *first* stream's buffer to others
1151 for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
1152 uint32_t idx = _in_map[0].get (*t, i, &valid);
1153 if (valid && idx != first_idx) {
1162 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: In Place Split Map\n", name()));
1167 for (uint32_t pc = 0; pc < get_count() && inplace_ok ; ++pc) {
1168 if (!_in_map[pc].is_monotonic ()) {
1171 if (!_out_map[pc].is_monotonic ()) {
1175 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("%1: %2\n", name(), inplace_ok ? "In-Place" : "No Inplace Processing"));
1176 return !inplace_ok; // no-inplace
1180 PluginInsert::sanitize_maps ()
1182 bool changed = false;
1183 /* strip dead wood */
1184 PinMappings new_ins;
1185 PinMappings new_outs;
1186 ChanMapping new_thru;
1188 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1190 ChanMapping new_out;
1191 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1192 for (uint32_t i = 0; i < natural_input_streams().get (*t); ++i) {
1194 uint32_t idx = _in_map[pc].get (*t, i, &valid);
1195 if (valid && idx < _configured_internal.get (*t)) {
1196 new_in.set (*t, i, idx);
1199 for (uint32_t o = 0; o < natural_output_streams().get (*t); ++o) {
1201 uint32_t idx = _out_map[pc].get (*t, o, &valid);
1202 if (valid && idx < _configured_out.get (*t)) {
1203 new_out.set (*t, o, idx);
1207 if (_in_map[pc] != new_in || _out_map[pc] != new_out) {
1210 new_ins[pc] = new_in;
1211 new_outs[pc] = new_out;
1214 /* prevent dup output assignments */
1215 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1216 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1217 bool mapped = false;
1218 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1220 uint32_t idx = new_outs[pc].get_src (*t, o, &valid);
1221 if (valid && mapped) {
1222 new_outs[pc].unset (*t, idx);
1230 /* remove excess thru */
1231 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1232 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1234 uint32_t idx = _thru_map.get (*t, o, &valid);
1235 if (valid && idx < _configured_internal.get (*t)) {
1236 new_thru.set (*t, o, idx);
1241 /* prevent out + thru, existing plugin outputs override thru */
1242 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1243 for (uint32_t o = 0; o < _configured_out.get (*t); ++o) {
1244 bool mapped = false;
1246 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1247 new_outs[pc].get_src (*t, o, &mapped);
1248 if (mapped) { break; }
1250 if (!mapped) { continue; }
1251 uint32_t idx = new_thru.get (*t, o, &valid);
1253 new_thru.unset (*t, idx);
1258 if (has_midi_bypass ()) {
1259 // TODO: include midi-bypass in the thru set,
1260 // remove dedicated handling.
1261 new_thru.unset (DataType::MIDI, 0);
1264 if (_in_map != new_ins || _out_map != new_outs || _thru_map != new_thru) {
1268 _out_map = new_outs;
1269 _thru_map = new_thru;
1275 PluginInsert::reset_map (bool emit)
1277 const PinMappings old_in (_in_map);
1278 const PinMappings old_out (_out_map);
1282 _thru_map = ChanMapping ();
1284 /* build input map */
1285 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1286 uint32_t sc = 0; // side-chain round-robin (all instances)
1288 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1289 const uint32_t nis = natural_input_streams ().get(*t);
1290 const uint32_t stride = nis - sidechain_input_pins().get (*t);
1292 /* SC inputs are last in the plugin-insert.. */
1293 const uint32_t sc_start = _configured_in.get (*t);
1294 const uint32_t sc_len = _configured_internal.get (*t) - sc_start;
1295 /* ...but may not be at the end of the plugin ports.
1296 * in case the side-chain is not the last port, shift connections back.
1297 * and connect to side-chain
1300 uint32_t ic = 0; // split inputs
1301 const uint32_t cend = _configured_in.get (*t);
1303 for (uint32_t in = 0; in < nis; ++in) {
1304 const Plugin::IOPortDescription& iod (_plugins[pc]->describe_io_port (*t, true, in));
1305 if (iod.is_sidechain) {
1306 /* connect sidechain sinks to sidechain inputs in round-robin fashion */
1307 if (sc_len > 0) {// side-chain may be hidden
1308 _in_map[pc].set (*t, in, sc_start + sc);
1309 sc = (sc + 1) % sc_len;
1313 if (_match.method == Split) {
1314 if (cend == 0) { continue; }
1315 if (_strict_io && ic + stride * pc >= cend) {
1318 /* connect *no* sidechain sinks in round-robin fashion */
1319 _in_map[pc].set (*t, in, ic + stride * pc);
1320 if (_strict_io && (ic + 1) == cend) {
1323 ic = (ic + 1) % cend;
1325 uint32_t s = in - shift;
1326 if (stride * pc + s < cend) {
1327 _in_map[pc].set (*t, in, s + stride * pc);
1335 /* build output map */
1337 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1338 _out_map[pc] = ChanMapping (ChanCount::min (natural_output_streams(), _configured_out));
1339 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1340 _out_map[pc].offset_to(*t, pc * natural_output_streams().get(*t));
1345 if (old_in == _in_map && old_out == _out_map) {
1349 PluginMapChanged (); /* EMIT SIGNAL */
1350 _mapping_changed = true;
1351 _session.set_dirty();
1357 PluginInsert::configure_io (ChanCount in, ChanCount out)
1359 Match old_match = _match;
1361 ChanCount old_internal;
1365 old_in = _configured_in;
1366 old_internal = _configured_internal;
1367 old_out = _configured_out;
1370 _configured_in = in;
1371 _configured_internal = in;
1372 _configured_out = out;
1375 /* TODO hide midi-bypass, and custom outs. Best /fake/ "out" here.
1376 * (currently _sidechain->configure_io always succeeds
1377 * since Processor::configure_io() succeeds)
1379 if (!_sidechain->configure_io (in, out)) {
1380 DEBUG_TRACE (DEBUG::ChanMapping, "Sidechain configuration failed\n");
1383 _configured_internal += _sidechain->input()->n_ports();
1385 // include (static_cast<Route*>owner())->name() ??
1386 _sidechain->input ()-> set_pretty_name (string_compose (_("SC %1"), name ()));
1389 /* get plugin configuration */
1390 _match = private_can_support_io_configuration (in, out);
1392 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1394 DEBUG_STR_APPEND(a, string_compose ("Match '%1': ", name()));
1395 DEBUG_STR_APPEND(a, _match);
1396 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1400 /* set the matching method and number of plugins that we will use to meet this configuration */
1401 if (set_count (_match.plugins) == false) {
1402 PluginIoReConfigure (); /* EMIT SIGNAL */
1403 _configured = false;
1407 /* configure plugins */
1408 switch (_match.method) {
1411 if (_plugins.front()->configure_io (natural_input_streams(), out) == false) {
1412 PluginIoReConfigure (); /* EMIT SIGNAL */
1413 _configured = false;
1419 ChanCount dout (in); // hint
1422 } else if (_preset_out.n_audio () > 0) {
1423 dout.set (DataType::AUDIO, _preset_out.n_audio ());
1424 } else if (dout.n_midi () > 0 && dout.n_audio () == 0) {
1425 dout.set (DataType::AUDIO, 2);
1427 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1429 bool const r = _plugins.front()->can_support_io_configuration (in, dout, &useins);
1431 if (useins.n_audio() == 0) {
1434 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("Delegate configuration: %1 %2 %3\n", name(), useins, dout));
1436 if (_plugins.front()->configure_io (useins, dout) == false) {
1437 PluginIoReConfigure (); /* EMIT SIGNAL */
1438 _configured = false;
1444 if (_plugins.front()->configure_io (in, out) == false) {
1445 PluginIoReConfigure (); /* EMIT SIGNAL */
1446 _configured = false;
1452 bool mapping_changed = false;
1453 if (old_in == in && old_out == out
1455 && old_match.method == _match.method
1456 && _in_map.size() == _out_map.size()
1457 && _in_map.size() == get_count ()
1459 assert (_maps_from_state == false);
1460 /* If the configuration has not changed, keep the mapping */
1461 if (old_internal != _configured_internal) {
1462 mapping_changed = sanitize_maps ();
1464 } else if (_match.custom_cfg && _configured) {
1465 assert (_maps_from_state == false);
1466 mapping_changed = sanitize_maps ();
1469 if (is_channelstrip ()) {
1470 /* fake channel map - for wire display */
1471 _maps_from_state = false;
1474 _thru_map = ChanMapping ();
1475 _in_map[0] = ChanMapping (ChanCount::min (_configured_in, ChanCount (DataType::AUDIO, 2)));
1476 _out_map[0] = ChanMapping (ChanCount::min (_configured_out, ChanCount (DataType::AUDIO, 2)));
1477 /* set "thru" map for in-place forward of audio */
1478 for (uint32_t i = 2; i < _configured_in.n_audio(); ++i) {
1479 _thru_map.set (DataType::AUDIO, i, i);
1481 /* and midi (after implicit 1st channel bypass) */
1482 for (uint32_t i = 1; i < _configured_in.n_midi(); ++i) {
1483 _thru_map.set (DataType::MIDI, i, i);
1487 if (_maps_from_state) {
1488 _maps_from_state = false;
1489 mapping_changed = true;
1492 /* generate a new mapping */
1493 mapping_changed = reset_map (false);
1497 if (mapping_changed) {
1498 PluginMapChanged (); /* EMIT SIGNAL */
1501 if (DEBUG_ENABLED(DEBUG::ChanMapping)) {
1504 DEBUG_STR_APPEND(a, "\n--------<<--------\n");
1505 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
1507 DEBUG_STR_APPEND(a, "----><----\n");
1509 DEBUG_STR_APPEND(a, string_compose ("Channel Map for %1 plugin %2\n", name(), pc));
1510 DEBUG_STR_APPEND(a, " * Inputs:\n");
1511 DEBUG_STR_APPEND(a, _in_map[pc]);
1512 DEBUG_STR_APPEND(a, " * Outputs:\n");
1513 DEBUG_STR_APPEND(a, _out_map[pc]);
1515 DEBUG_STR_APPEND(a, " * Thru:\n");
1516 DEBUG_STR_APPEND(a, _thru_map);
1517 DEBUG_STR_APPEND(a, "-------->>--------\n");
1518 DEBUG_TRACE (DEBUG::ChanMapping, DEBUG_STR(a).str());
1523 _no_inplace = check_inplace ();
1524 _mapping_changed = false;
1526 /* only the "noinplace_buffers" thread buffers need to be this large,
1527 * this can be optimized. other buffers are fine with
1528 * ChanCount::max (natural_input_streams (), natural_output_streams())
1529 * and route.cc's max (configured_in, configured_out)
1531 * no-inplace copies "thru" outputs (to emulate in-place) for
1532 * all outputs (to prevent overwrite) into a temporary space
1533 * which also holds input buffers (in case the plugin does process
1534 * in-place and overwrites those).
1536 * this buffers need to be at least as
1537 * natural_input_streams () + possible outputs.
1539 * sidechain inputs add a constraint on the input:
1540 * configured input + sidechain (=_configured_internal)
1542 * NB. this also satisfies
1543 * max (natural_input_streams(), natural_output_streams())
1544 * which is needed for silence runs
1546 _required_buffers = ChanCount::max (_configured_internal,
1547 natural_input_streams () + ChanCount::max (_configured_out, natural_output_streams () * get_count ()));
1549 if (old_in != in || old_out != out || old_internal != _configured_internal
1550 || (old_match.method != _match.method && (old_match.method == Split || _match.method == Split))
1552 PluginIoReConfigure (); /* EMIT SIGNAL */
1555 _delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
1556 _latency_changed = true;
1558 // we don't know the analysis window size, so we must work with the
1559 // current buffer size here. each request for data fills in these
1560 // buffers and the analyser makes sure it gets enough data for the
1562 session().ensure_buffer_set (_signal_analysis_inputs, in);
1563 //_signal_analysis_inputs.set_count (in);
1565 session().ensure_buffer_set (_signal_analysis_outputs, out);
1566 //_signal_analysis_outputs.set_count (out);
1568 // std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
1571 return Processor::configure_io (in, out);
1574 /** Decide whether this PluginInsert can support a given IO configuration.
1575 * To do this, we run through a set of possible solutions in rough order of
1578 * @param in Required input channel count.
1579 * @param out Filled in with the output channel count if we return true.
1580 * @return true if the given IO configuration can be supported.
1583 PluginInsert::can_support_io_configuration (const ChanCount& in, ChanCount& out)
1586 _sidechain->can_support_io_configuration (in, out); // never fails, sets "out"
1588 return private_can_support_io_configuration (in, out).method != Impossible;
1592 PluginInsert::private_can_support_io_configuration (ChanCount const& in, ChanCount& out) const
1594 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1595 // preseed hint (for variable i/o)
1596 out.set (DataType::AUDIO, _preset_out.n_audio ());
1599 Match rv = internal_can_support_io_configuration (in, out);
1601 if (!_custom_cfg && _preset_out.n_audio () > 0) {
1602 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("using output preset: %1 %2\n", name(), _preset_out));
1603 out.set (DataType::AUDIO, _preset_out.n_audio ());
1608 /** A private version of can_support_io_configuration which returns the method
1609 * by which the configuration can be matched, rather than just whether or not
1613 PluginInsert::internal_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1615 if (_plugins.empty()) {
1620 if (is_channelstrip ()) {
1622 return Match (ExactMatch, 1);
1626 /* if a user specified a custom cfg, so be it. */
1628 PluginInfoPtr info = _plugins.front()->get_info();
1630 if (info->reconfigurable_io()) {
1631 return Match (Delegate, get_count(), _strict_io, true);
1633 return Match (ExactMatch, get_count(), _strict_io, true);
1637 /* try automatic configuration */
1638 Match m = PluginInsert::automatic_can_support_io_configuration (inx, out);
1640 PluginInfoPtr info = _plugins.front()->get_info();
1641 ChanCount inputs = info->n_inputs;
1642 ChanCount outputs = info->n_outputs;
1644 /* handle case strict-i/o */
1645 if (_strict_io && m.method != Impossible) {
1648 /* special case MIDI instruments */
1649 if (needs_midi_input ()) {
1650 // output = midi-bypass + at most master-out channels.
1651 ChanCount max_out (DataType::AUDIO, 2); // TODO use master-out
1652 max_out.set (DataType::MIDI, out.get(DataType::MIDI));
1653 out = ChanCount::min (out, max_out);
1654 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o instrument: %1\n", name()));
1660 if (inx.n_audio () != out.n_audio ()) { // ignore midi bypass
1661 /* replicate processor to match output count (generators and such)
1662 * at least enough to feed every output port. */
1663 uint32_t f = 1; // at least one. e.g. control data filters, no in, no out.
1664 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1665 uint32_t nout = outputs.get (*t);
1666 if (nout == 0 || inx.get(*t) == 0) { continue; }
1667 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nout));
1670 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("special case strict-i/o generator: %1\n", name()));
1671 return Match (Replicate, f, _strict_io);
1682 if (m.method != Impossible) {
1686 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1688 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("resolving 'Impossible' match for %1\n", name()));
1690 if (info->reconfigurable_io()) {
1693 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1694 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1695 bool const r = _plugins.front()->can_support_io_configuration (inx, out, &useins);
1697 // houston, we have a problem.
1698 return Match (Impossible, 0);
1700 return Match (Delegate, 1, _strict_io);
1703 ChanCount midi_bypass;
1704 if (inx.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1705 midi_bypass.set (DataType::MIDI, 1);
1708 // add at least as many plugins so that output count matches input count (w/o sidechain pins)
1710 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1711 uint32_t nin = ns_inputs.get (*t);
1712 uint32_t nout = outputs.get (*t);
1713 if (nin == 0 || inx.get(*t) == 0) { continue; }
1714 // prefer floor() so the count won't overly increase IFF (nin < nout)
1715 f = max (f, (uint32_t) floor (inx.get(*t) / (float)nout));
1717 if (f > 0 && outputs * f >= _configured_out) {
1718 out = outputs * f + midi_bypass;
1719 return Match (Replicate, f, _strict_io);
1722 // add at least as many plugins needed to connect all inputs (w/o sidechain pins)
1724 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1725 uint32_t nin = ns_inputs.get (*t);
1726 if (nin == 0 || inx.get(*t) == 0) { continue; }
1727 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1730 out = outputs * f + midi_bypass;
1731 return Match (Replicate, f, _strict_io);
1734 // add at least as many plugins needed to connect all inputs
1736 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1737 uint32_t nin = inputs.get (*t);
1738 if (nin == 0 || inx.get(*t) == 0) { continue; }
1739 f = max (f, (uint32_t) ceil (inx.get(*t) / (float)nin));
1741 out = outputs * f + midi_bypass;
1742 return Match (Replicate, f, _strict_io);
1745 /* this is the original Ardour 3/4 behavior, mainly for backwards compatibility */
1747 PluginInsert::automatic_can_support_io_configuration (ChanCount const & inx, ChanCount& out) const
1749 if (_plugins.empty()) {
1753 PluginInfoPtr info = _plugins.front()->get_info();
1754 ChanCount in; in += inx;
1755 ChanCount midi_bypass;
1757 if (info->reconfigurable_io()) {
1758 /* Plugin has flexible I/O, so delegate to it
1759 * pre-seed outputs, plugin tries closest match
1762 if (out.n_midi () > 0 && out.n_audio () == 0) { out.set (DataType::AUDIO, 2); }
1763 if (out.n_audio () == 0) { out.set (DataType::AUDIO, 1); }
1764 bool const r = _plugins.front()->can_support_io_configuration (in, out);
1766 return Match (Impossible, 0);
1768 return Match (Delegate, 1);
1771 ChanCount inputs = info->n_inputs;
1772 ChanCount outputs = info->n_outputs;
1773 ChanCount ns_inputs = inputs - sidechain_input_pins ();
1775 if (in.get(DataType::MIDI) == 1 && outputs.get(DataType::MIDI) == 0) {
1776 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("bypassing midi-data around %1\n", name()));
1777 midi_bypass.set (DataType::MIDI, 1);
1779 if (in.get(DataType::MIDI) == 1 && inputs.get(DataType::MIDI) == 0) {
1780 DEBUG_TRACE (DEBUG::ChanMapping, string_compose ("hiding midi-port from plugin %1\n", name()));
1781 in.set(DataType::MIDI, 0);
1784 // add internally provided sidechain ports
1785 ChanCount insc = in + sidechain_input_ports ();
1787 bool no_inputs = true;
1788 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1789 if (inputs.get (*t) != 0) {
1796 /* no inputs so we can take any input configuration since we throw it away */
1797 out = outputs + midi_bypass;
1798 return Match (NoInputs, 1);
1801 /* Plugin inputs match requested inputs + side-chain-ports exactly */
1802 if (inputs == insc) {
1803 out = outputs + midi_bypass;
1804 return Match (ExactMatch, 1);
1807 /* Plugin inputs matches without side-chain-pins */
1808 if (ns_inputs == in) {
1809 out = outputs + midi_bypass;
1810 return Match (ExactMatch, 1);
1813 /* We may be able to run more than one copy of the plugin within this insert
1814 to cope with the insert having more inputs than the plugin.
1815 We allow replication only for plugins with either zero or 1 inputs and outputs
1816 for every valid data type.
1820 bool can_replicate = true;
1821 for (DataType::iterator t = DataType::begin(); t != DataType::end() && can_replicate; ++t) {
1823 // ignore side-chains
1824 uint32_t nin = ns_inputs.get (*t);
1826 // No inputs of this type
1827 if (nin == 0 && in.get(*t) == 0) {
1831 if (nin != 1 || outputs.get (*t) != 1) {
1832 can_replicate = false;
1836 // Potential factor not set yet
1838 f = in.get(*t) / nin;
1841 // Factor for this type does not match another type, can not replicate
1842 if (f != (in.get(*t) / nin)) {
1843 can_replicate = false;
1848 if (can_replicate && f > 0) {
1849 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1850 out.set (*t, outputs.get(*t) * f);
1853 return Match (Replicate, f);
1856 /* If the processor has exactly one input of a given type, and
1857 the plugin has more, we can feed the single processor input
1858 to some or all of the plugin inputs. This is rather
1859 special-case-y, but the 1-to-many case is by far the
1860 simplest. How do I split thy 2 processor inputs to 3
1861 plugin inputs? Let me count the ways ...
1864 bool can_split = true;
1865 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1867 bool const can_split_type = (in.get (*t) == 1 && ns_inputs.get (*t) > 1);
1868 bool const nothing_to_do_for_type = (in.get (*t) == 0 && inputs.get (*t) == 0);
1870 if (!can_split_type && !nothing_to_do_for_type) {
1876 out = outputs + midi_bypass;
1877 return Match (Split, 1);
1880 /* If the plugin has more inputs than we want, we can `hide' some of them
1881 by feeding them silence.
1884 bool could_hide = false;
1885 bool cannot_hide = false;
1886 ChanCount hide_channels;
1888 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
1889 if (inputs.get(*t) > in.get(*t)) {
1890 /* there is potential to hide, since the plugin has more inputs of type t than the insert */
1891 hide_channels.set (*t, inputs.get(*t) - in.get(*t));
1893 } else if (inputs.get(*t) < in.get(*t)) {
1894 /* we definitely cannot hide, since the plugin has fewer inputs of type t than the insert */
1899 if (could_hide && !cannot_hide) {
1900 out = outputs + midi_bypass;
1901 return Match (Hide, 1, false, false, hide_channels);
1904 return Match (Impossible, 0);
1909 PluginInsert::get_state ()
1911 return state (true);
1915 PluginInsert::state (bool full)
1917 XMLNode& node = Processor::state (full);
1919 node.add_property("type", _plugins[0]->state_node_name());
1920 node.add_property("unique-id", _plugins[0]->unique_id());
1921 node.add_property("count", string_compose("%1", _plugins.size()));
1923 /* remember actual i/o configuration (for later placeholder
1924 * in case the plugin goes missing) */
1925 node.add_child_nocopy (* _configured_in.state (X_("ConfiguredInput")));
1926 node.add_child_nocopy (* _configured_out.state (X_("ConfiguredOutput")));
1927 node.add_child_nocopy (* _preset_out.state (X_("PresetOutput")));
1929 /* save custom i/o config */
1930 node.add_property("custom", _custom_cfg ? "yes" : "no");
1931 for (uint32_t pc = 0; pc < get_count(); ++pc) {
1933 snprintf (tmp, sizeof(tmp), "InputMap-%d", pc);
1934 node.add_child_nocopy (* _in_map[pc].state (tmp));
1935 snprintf (tmp, sizeof(tmp), "OutputMap-%d", pc);
1936 node.add_child_nocopy (* _out_map[pc].state (tmp));
1938 node.add_child_nocopy (* _thru_map.state ("ThruMap"));
1941 node.add_child_nocopy (_sidechain->state (full));
1944 _plugins[0]->set_insert_id(this->id());
1945 node.add_child_nocopy (_plugins[0]->get_state());
1947 for (Controls::iterator c = controls().begin(); c != controls().end(); ++c) {
1948 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> ((*c).second);
1950 node.add_child_nocopy (ac->get_state());
1958 PluginInsert::set_control_ids (const XMLNode& node, int version)
1960 const XMLNodeList& nlist = node.children();
1961 XMLNodeConstIterator iter;
1962 set<Evoral::Parameter>::const_iterator p;
1964 for (iter = nlist.begin(); iter != nlist.end(); ++iter) {
1965 if ((*iter)->name() == Controllable::xml_node_name) {
1966 const XMLProperty* prop;
1968 uint32_t p = (uint32_t)-1;
1970 if ((prop = (*iter)->property (X_("symbol"))) != 0) {
1971 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugins[0]);
1973 p = lv2plugin->port_index(prop->value().c_str());
1977 if (p == (uint32_t)-1 && (prop = (*iter)->property (X_("parameter"))) != 0) {
1978 p = atoi (prop->value());
1981 if (p != (uint32_t)-1) {
1983 /* this may create the new controllable */
1985 boost::shared_ptr<Evoral::Control> c = control (Evoral::Parameter (PluginAutomation, 0, p));
1987 #ifndef NO_PLUGIN_STATE
1991 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (c);
1993 ac->set_state (**iter, version);
2002 PluginInsert::set_state(const XMLNode& node, int version)
2004 XMLNodeList nlist = node.children();
2005 XMLNodeIterator niter;
2006 XMLPropertyList plist;
2007 const XMLProperty *prop;
2008 ARDOUR::PluginType type;
2010 if ((prop = node.property ("type")) == 0) {
2011 error << _("XML node describing plugin is missing the `type' field") << endmsg;
2015 if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
2016 type = ARDOUR::LADSPA;
2017 } else if (prop->value() == X_("lv2")) {
2019 } else if (prop->value() == X_("windows-vst")) {
2020 type = ARDOUR::Windows_VST;
2021 } else if (prop->value() == X_("lxvst")) {
2022 type = ARDOUR::LXVST;
2023 } else if (prop->value() == X_("audiounit")) {
2024 type = ARDOUR::AudioUnit;
2025 } else if (prop->value() == X_("luaproc")) {
2028 error << string_compose (_("unknown plugin type %1 in plugin insert state"),
2034 prop = node.property ("unique-id");
2037 #ifdef WINDOWS_VST_SUPPORT
2038 /* older sessions contain VST plugins with only an "id" field.
2041 if (type == ARDOUR::Windows_VST) {
2042 prop = node.property ("id");
2046 #ifdef LXVST_SUPPORT
2047 /*There shouldn't be any older sessions with linuxVST support.. but anyway..*/
2049 if (type == ARDOUR::LXVST) {
2050 prop = node.property ("id");
2056 error << _("Plugin has no unique ID field") << endmsg;
2061 boost::shared_ptr<Plugin> plugin = find_plugin (_session, prop->value(), type);
2063 /* treat linux and windows VST plugins equivalent if they have the same uniqueID
2064 * allow to move sessions windows <> linux */
2065 #ifdef LXVST_SUPPORT
2066 if (plugin == 0 && type == ARDOUR::Windows_VST) {
2067 type = ARDOUR::LXVST;
2068 plugin = find_plugin (_session, prop->value(), type);
2072 #ifdef WINDOWS_VST_SUPPORT
2073 if (plugin == 0 && type == ARDOUR::LXVST) {
2074 type = ARDOUR::Windows_VST;
2075 plugin = find_plugin (_session, prop->value(), type);
2080 error << string_compose(
2081 _("Found a reference to a plugin (\"%1\") that is unknown.\n"
2082 "Perhaps it was removed or moved since it was last used."),
2088 if (type == ARDOUR::Lua) {
2089 XMLNode *ls = node.child (plugin->state_node_name().c_str());
2090 // we need to load the script to set the name and parameters.
2091 boost::shared_ptr<LuaProc> lp = boost::dynamic_pointer_cast<LuaProc>(plugin);
2093 lp->set_script_from_state (*ls);
2097 // The name of the PluginInsert comes from the plugin, nothing else
2098 _name = plugin->get_info()->name;
2102 // Processor::set_state() will set this, but too late
2103 // for it to be available when setting up plugin
2104 // state. We can't call Processor::set_state() until
2105 // the plugins themselves are created and added.
2109 if (_plugins.empty()) {
2110 /* if we are adding the first plugin, we will need to set
2111 up automatable controls.
2113 add_plugin (plugin);
2114 create_automatable_parameters ();
2115 set_control_ids (node, version);
2118 if ((prop = node.property ("count")) != 0) {
2119 sscanf (prop->value().c_str(), "%u", &count);
2122 if (_plugins.size() != count) {
2123 for (uint32_t n = 1; n < count; ++n) {
2124 add_plugin (plugin_factory (plugin));
2128 Processor::set_state (node, version);
2130 PBD::ID new_id = this->id();
2131 PBD::ID old_id = this->id();
2133 if ((prop = node.property ("id")) != 0) {
2134 old_id = prop->value ();
2137 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2139 /* find the node with the type-specific node name ("lv2", "ladspa", etc)
2140 and set all plugins to the same state.
2143 if ((*niter)->name() == plugin->state_node_name()) {
2145 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2146 /* Plugin state can include external files which are named after the ID.
2148 * If regenerate_xml_or_string_ids() is set, the ID will already have
2149 * been changed, so we need to use the old ID from the XML to load the
2150 * state and then update the ID.
2152 * When copying a plugin-state, route_ui takes care of of updating the ID,
2153 * but we need to call set_insert_id() to clear the cached plugin-state
2154 * and force a change.
2156 if (!regenerate_xml_or_string_ids ()) {
2157 (*i)->set_insert_id (new_id);
2159 (*i)->set_insert_id (old_id);
2162 (*i)->set_state (**niter, version);
2164 if (regenerate_xml_or_string_ids ()) {
2165 (*i)->set_insert_id (new_id);
2173 if (version < 3000) {
2175 /* Only 2.X sessions need a call to set_parameter_state() - in 3.X and above
2176 this is all handled by Automatable
2179 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2180 if ((*niter)->name() == "Redirect") {
2181 /* XXX do we need to tackle placement? i think not (pd; oct 16 2009) */
2182 Processor::set_state (**niter, version);
2187 set_parameter_state_2X (node, version);
2190 if ((prop = node.property (X_("custom"))) != 0) {
2191 _custom_cfg = string_is_affirmative (prop->value());
2194 uint32_t in_maps = 0;
2195 uint32_t out_maps = 0;
2196 XMLNodeList kids = node.children ();
2197 for (XMLNodeIterator i = kids.begin(); i != kids.end(); ++i) {
2198 if ((*i)->name() == X_("ConfiguredOutput")) {
2199 _custom_out = ChanCount(**i);
2201 if ((*i)->name() == X_("PresetOutput")) {
2202 _preset_out = ChanCount(**i);
2204 if (strncmp ((*i)->name ().c_str(), X_("InputMap-"), 9) == 0) {
2205 long pc = atol (&((*i)->name().c_str()[9]));
2206 if (pc >=0 && pc <= get_count()) {
2207 _in_map[pc] = ChanMapping (**i);
2211 if (strncmp ((*i)->name ().c_str(), X_("OutputMap-"), 10) == 0) {
2212 long pc = atol (&((*i)->name().c_str()[10]));
2213 if (pc >=0 && pc <= get_count()) {
2214 _out_map[pc] = ChanMapping (**i);
2218 if ((*i)->name () == "ThruMap") {
2219 _thru_map = ChanMapping (**i);
2222 // sidechain is a Processor (IO)
2223 if ((*i)->name () == Processor::state_node_name) {
2227 _sidechain->set_state (**i, version);
2231 if (in_maps == out_maps && out_maps >0 && out_maps == get_count()) {
2232 _maps_from_state = true;
2235 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2239 (*i)->deactivate ();
2243 PluginConfigChanged (); /* EMIT SIGNAL */
2248 PluginInsert::update_id (PBD::ID id)
2251 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2252 (*i)->set_insert_id (id);
2257 PluginInsert::set_state_dir (const std::string& d)
2259 // state() only saves the state of the first plugin
2260 _plugins[0]->set_state_dir (d);
2264 PluginInsert::set_parameter_state_2X (const XMLNode& node, int version)
2266 XMLNodeList nlist = node.children();
2267 XMLNodeIterator niter;
2269 /* look for port automation node */
2271 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2273 if ((*niter)->name() != port_automation_node_name) {
2279 XMLNodeConstIterator iter;
2284 cnodes = (*niter)->children ("port");
2286 for (iter = cnodes.begin(); iter != cnodes.end(); ++iter){
2290 if ((cprop = child->property("number")) != 0) {
2291 port = cprop->value().c_str();
2293 warning << _("PluginInsert: Auto: no ladspa port number") << endmsg;
2297 sscanf (port, "%" PRIu32, &port_id);
2299 if (port_id >= _plugins[0]->parameter_count()) {
2300 warning << _("PluginInsert: Auto: port id out of range") << endmsg;
2304 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(
2305 control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
2307 if (c && c->alist()) {
2308 if (!child->children().empty()) {
2309 c->alist()->set_state (*child->children().front(), version);
2311 /* In some cases 2.X saves lists with min_yval and max_yval
2312 being FLT_MIN and FLT_MAX respectively. This causes problems
2313 in A3 because these min/max values are used to compute
2314 where GUI control points should be drawn. If we see such
2315 values, `correct' them to the min/max of the appropriate
2319 float min_y = c->alist()->get_min_y ();
2320 float max_y = c->alist()->get_max_y ();
2322 ParameterDescriptor desc;
2323 _plugins.front()->get_parameter_descriptor (port_id, desc);
2325 if (min_y == FLT_MIN) {
2329 if (max_y == FLT_MAX) {
2333 c->alist()->set_yrange (min_y, max_y);
2336 error << string_compose (_("PluginInsert: automatable control %1 not found - ignored"), port_id) << endmsg;
2348 PluginInsert::describe_parameter (Evoral::Parameter param)
2350 if (param.type() == PluginAutomation) {
2351 return _plugins[0]->describe_parameter (param);
2352 } else if (param.type() == PluginPropertyAutomation) {
2353 boost::shared_ptr<AutomationControl> c(automation_control(param));
2354 if (c && !c->desc().label.empty()) {
2355 return c->desc().label;
2358 return Automatable::describe_parameter(param);
2362 PluginInsert::signal_latency() const
2364 if (_user_latency) {
2365 return _user_latency;
2368 return _plugins[0]->signal_latency ();
2372 PluginInsert::type ()
2374 return plugin()->get_info()->type;
2377 PluginInsert::PluginControl::PluginControl (PluginInsert* p,
2378 const Evoral::Parameter& param,
2379 const ParameterDescriptor& desc,
2380 boost::shared_ptr<AutomationList> list)
2381 : AutomationControl (p->session(), param, desc, list, p->describe_parameter(param))
2385 alist()->reset_default (desc.normal);
2387 list->set_interpolation(Evoral::ControlList::Discrete);
2392 set_flags(Controllable::Toggle);
2396 /** @param val `user' value */
2398 PluginInsert::PluginControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2401 _set_value (user_val, group_override);
2405 PluginInsert::PluginControl::set_value_unchecked (double user_val)
2407 /* used only by automation playback */
2408 _set_value (user_val, Controllable::NoGroup);
2412 PluginInsert::PluginControl::_set_value (double user_val, PBD::Controllable::GroupControlDisposition group_override)
2414 /* FIXME: probably should be taking out some lock here.. */
2416 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2417 (*i)->set_parameter (_list->parameter().id(), user_val);
2420 boost::shared_ptr<Plugin> iasp = _plugin->_impulseAnalysisPlugin.lock();
2422 iasp->set_parameter (_list->parameter().id(), user_val);
2425 AutomationControl::set_value (user_val, group_override);
2429 PluginInsert::PluginControl::catch_up_with_external_value (double user_val)
2431 AutomationControl::set_value (user_val, Controllable::NoGroup);
2435 PluginInsert::PluginControl::get_state ()
2439 XMLNode& node (AutomationControl::get_state());
2440 ss << parameter().id();
2441 node.add_property (X_("parameter"), ss.str());
2443 boost::shared_ptr<LV2Plugin> lv2plugin = boost::dynamic_pointer_cast<LV2Plugin> (_plugin->_plugins[0]);
2445 node.add_property (X_("symbol"), lv2plugin->port_symbol (parameter().id()));
2452 /** @return `user' val */
2454 PluginInsert::PluginControl::get_value () const
2456 boost::shared_ptr<Plugin> plugin = _plugin->plugin (0);
2462 return plugin->get_parameter (_list->parameter().id());
2465 PluginInsert::PluginPropertyControl::PluginPropertyControl (PluginInsert* p,
2466 const Evoral::Parameter& param,
2467 const ParameterDescriptor& desc,
2468 boost::shared_ptr<AutomationList> list)
2469 : AutomationControl (p->session(), param, desc, list)
2473 alist()->set_yrange (desc.lower, desc.upper);
2474 alist()->reset_default (desc.normal);
2478 set_flags(Controllable::Toggle);
2483 PluginInsert::PluginPropertyControl::set_value (double user_val, PBD::Controllable::GroupControlDisposition /* group_override*/)
2486 set_value_unchecked (user_val);
2491 PluginInsert::PluginPropertyControl::set_value_unchecked (double user_val)
2493 /* Old numeric set_value(), coerce to appropriate datatype if possible.
2494 This is lossy, but better than nothing until Ardour's automation system
2495 can handle various datatypes all the way down. */
2496 const Variant value(_desc.datatype, user_val);
2497 if (value.type() == Variant::NOTHING) {
2498 error << "set_value(double) called for non-numeric property" << endmsg;
2502 for (Plugins::iterator i = _plugin->_plugins.begin(); i != _plugin->_plugins.end(); ++i) {
2503 (*i)->set_property(_list->parameter().id(), value);
2507 AutomationControl::set_value (user_val, Controllable::NoGroup);
2511 PluginInsert::PluginPropertyControl::get_state ()
2515 XMLNode& node (AutomationControl::get_state());
2516 ss << parameter().id();
2517 node.add_property (X_("property"), ss.str());
2518 node.remove_property (X_("value"));
2524 PluginInsert::PluginPropertyControl::get_value () const
2526 return _value.to_double();
2529 boost::shared_ptr<Plugin>
2530 PluginInsert::get_impulse_analysis_plugin()
2532 boost::shared_ptr<Plugin> ret;
2533 if (_impulseAnalysisPlugin.expired()) {
2534 // LV2 in particular uses various _session params
2535 // during init() -- most notably block_size..
2537 ret = plugin_factory(_plugins[0]);
2538 ret->configure_io (internal_input_streams (), internal_output_streams ());
2539 _impulseAnalysisPlugin = ret;
2541 ret = _impulseAnalysisPlugin.lock();
2548 PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
2550 // called from outside the audio thread, so this should be safe
2551 // only do audio as analysis is (currently) only for audio plugins
2552 _signal_analysis_inputs.ensure_buffers( DataType::AUDIO, internal_input_streams().n_audio(), nframes);
2553 _signal_analysis_outputs.ensure_buffers( DataType::AUDIO, internal_output_streams().n_audio(), nframes);
2555 _signal_analysis_collected_nframes = 0;
2556 _signal_analysis_collect_nframes_max = nframes;
2559 /** Add a plugin to our list */
2561 PluginInsert::add_plugin (boost::shared_ptr<Plugin> plugin)
2563 plugin->set_insert_id (this->id());
2565 if (_plugins.empty()) {
2566 /* first (and probably only) plugin instance - connect to relevant signals */
2568 plugin->ParameterChangedExternally.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed_externally, this, _1, _2));
2569 plugin->StartTouch.connect_same_thread (*this, boost::bind (&PluginInsert::start_touch, this, _1));
2570 plugin->EndTouch.connect_same_thread (*this, boost::bind (&PluginInsert::end_touch, this, _1));
2571 plugin->LatencyChanged.connect_same_thread (*this, boost::bind (&PluginInsert::latency_changed, this, _1, _2));
2572 // cache sidechain port count
2573 _cached_sidechain_pins.reset ();
2574 const ChanCount& nis (plugin->get_info()->n_inputs);
2575 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2576 for (uint32_t in = 0; in < nis.get (*t); ++in) {
2577 const Plugin::IOPortDescription& iod (plugin->describe_io_port (*t, true, in));
2578 if (iod.is_sidechain) {
2579 _cached_sidechain_pins.set (*t, 1 + _cached_sidechain_pins.n(*t));
2584 #if (defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT)
2585 boost::shared_ptr<VSTPlugin> vst = boost::dynamic_pointer_cast<VSTPlugin> (plugin);
2587 vst->set_insert (this, _plugins.size ());
2590 _plugins.push_back (plugin);
2594 PluginInsert::realtime_handle_transport_stopped ()
2596 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2597 (*i)->realtime_handle_transport_stopped ();
2602 PluginInsert::realtime_locate ()
2604 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2605 (*i)->realtime_locate ();
2610 PluginInsert::monitoring_changed ()
2612 for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
2613 (*i)->monitoring_changed ();
2618 PluginInsert::latency_changed (framecnt_t, framecnt_t)
2620 // this is called in RT context, LatencyChanged is emitted after run()
2621 _latency_changed = true;
2625 PluginInsert::start_touch (uint32_t param_id)
2627 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2629 ac->start_touch (session().audible_frame());
2634 PluginInsert::end_touch (uint32_t param_id)
2636 boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
2638 ac->stop_touch (true, session().audible_frame());
2642 std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
2645 case PluginInsert::Impossible: o << "Impossible"; break;
2646 case PluginInsert::Delegate: o << "Delegate"; break;
2647 case PluginInsert::NoInputs: o << "NoInputs"; break;
2648 case PluginInsert::ExactMatch: o << "ExactMatch"; break;
2649 case PluginInsert::Replicate: o << "Replicate"; break;
2650 case PluginInsert::Split: o << "Split"; break;
2651 case PluginInsert::Hide: o << "Hide"; break;
2653 o << " cnt: " << m.plugins
2654 << (m.strict_io ? " strict-io" : "")
2655 << (m.custom_cfg ? " custom-cfg" : "");
2656 if (m.method == PluginInsert::Hide) {
2657 o << " hide: " << m.hide;